Add files using upload-large-folder tool

parse/train/B1lDoJSYDH/B1lDoJSYDH.md

@@ -0,0 +1,361 @@
+# LAGRANGIAN FLUID SIMULATION WITH CONTINUOUS CONVOLUTIONS
+
+Benjamin Ummenhofer Intel Labs
+
+Lukas Prantl & Nils Thuerey Technical University of Munich
+
+Vladlen Koltun Intel Labs
+
+# ABSTRACT
+
+We present an approach to Lagrangian fluid simulation with a new type of convolutional network. Our networks process sets of moving particles, which describe fluids in space and time. Unlike previous approaches, we do not build an explicit graph structure to connect the particles but use spatial convolutions as the main differentiable operation that relates particles to their neighbors. To this end we present a simple, novel, and effective extension of N-D convolutions to the continuous domain. We show that our network architecture can simulate different materials, generalizes to arbitrary collision geometries, and can be used for inverse problems. In addition, we demonstrate that our continuous convolutions outperform prior formulations in terms of accuracy and speed.
+
+# 1 INTRODUCTION
+
+Understanding physics can help reasoning about our environment and interacting with it. Neural networks have emerged as a particularly promising approach to capture the complexity of natural phenomena from data (Ling et al., 2016; Tompson et al., 2017; Morton et al., 2018). An important aspect of learning physics with neural networks is the choice of representation. Lagrangian representations based on particles are particularly popular and have supported recent results with rigid bodies, deformable solids, and fluids (Battaglia et al., 2016; Mrowca et al., 2018; Li et al., 2019). Many of these approaches use graph structures to define interactions; the existence of an edge determines in a binary fashion whether two particles interact.
+
+However, a wide range of physical processes such as fluid mechanics are described by continuous partial differential equations rather than discrete graph structures. The continuous, volumetric, and tightly coupled nature of these processes causes inherent difficulties for graph-based approaches, such as a large number of edge connections that must be established, tracked, and disengaged as the particles move. In this work, instead of using graphs as the underlying representation, we adopt a continuous viewpoint. We propose to use convolutional networks (ConvNets) with continuous convolutions on particles for learning fluid mechanics. We treat fluids as spatially continuous functions sampled at a finite set of (continuously evolving) positions and process them with a novel continuous convolution layer. This matches the continuous nature of the problem more closely and simplifies the definition of neural networks by abstracting the underlying particle representation.
+
+We extend the grid-based filter representation commonly used for discrete convolutions to the continuous domain by simple linear interpolation. Linear interpolation of the filters allows efficient lookup of spatially varying filter values at arbitrary positions while retaining the compactness and efficiency of the grid representation. In addition, we use a window function to define the support of the filters and a ball-to-cube mapping to support spherical receptive fields. We show that our convolutions, despite their simplicity, perform better than more sophisticated representations (Wang et al., 2018; Schenck & Fox, 2018).
+
+With the presented continuous convolution layer, we develop an efficient ConvNet architecture for learning fluid mechanics. The network processes sets of particles. We use dynamic particles to represent the fluid and static particles to describe the boundary of the scene. Modeling the scene boundary with particles makes it easy to apply our network to new scenes and allows the network to learn collision handling in a unified framework. Our network generalizes to arbitrary obstacle configurations and can simulate a range of material behavior. To demonstrate the usefulness of a learned – and hence differentiable – fluid simulator, we show that material properties can be estimated from observed simulation data. Experimental results indicate that the presented approach outperforms a state-of-the-art graph-based framework (Li et al., 2019).
+
+# 2 RELATED WORK
+
+Fluids encompass a range of materials that are important in everyday life and throughout science and engineering (Wilcox, 2006). A prominent set of methods, known as Smoothed Particle Hydrodynamics (SPH), employs a Lagrangian viewpoint to simulate these phenomena. SPH originated in particle-based models for astrophysics (Gingold & Monaghan, 1977) and has become extremely popular for simulating complex flows in many fields of science (Monaghan, 1988). Among others, it has been highly successful for modeling interface flows (Colagrossi & Landrini, 2003), complex multi-phase phenomena (Hu & Adams, 2006), and even magnetohydrodynamics (Price, 2012).
+
+SPH and its variants have been widely used to model complex real-world phenomena for visual effects. Following the earlier development of physics-based fluid simulation for special effects by Foster & Metaxas (1996), the introduction of SPH (Muller et al., 2003) has led to a large class of ¨ powerful algorithms (Solenthaler & Pajarola, 2009; Bender & Koschier, 2015). These applications often involve complex geometries at large scales, and extensions such as FleX (Macklin et al., 2014) and pressure-aware rigid-body coupling (Gissler et al., 2018) broaden the framework to encompass many physical phenomena.
+
+Lagrangian flows have also been considered in machine learning. The pioneering work of Ladicky´ et al. (2015) demonstrated that flow representations can be learned with regression forests. CNNs were used by Tompson et al. (2017) to accelerate the expensive pressure correction step of gridbased solvers, while other works have focused on super-resolution (Xie et al., 2018), learning time evolution via the Koopman operator (Morton et al., 2018), and learning reduced representations (Wiewel et al., 2019; Kim et al., 2019). Differentiable SPH solvers were proposed to solve control tasks for robotic applications (Schenck & Fox, 2018). Generic physics simulations for Lagrangian rigid and deformable bodies were considered in a series of works that developed graph-based representations (Battaglia et al., 2016; Sanchez-Gonzalez et al., 2018). Such graph-based representations were recently applied directly to fluid simulation (Mrowca et al., 2018; Li et al., 2019). We share with these recent works the goal of modeling Lagrangian fluids with differentiable neural networks, but take a different tack: rather than using graph-based representations, we work with point clouds and continuous convolutions over the spatial domain.
+
+From a technical perspective, our approach is also related to existing works that apply convolutions on point clouds. A number of methods transferred the convolution concept to point clouds in the context of semantic classification and segmentation of 3D objects (Hua et al., 2018; Atzmon et al., 2018; Hermosilla et al., 2018; Li et al., 2018; Su et al., 2018; Wu et al., 2019; Xu et al., 2018; Lei et al., 2019). Particularly notable in our context is the work of Wang et al. (2018), who used continuous convolutions to compute the scene flow between two point clouds, and the aforementioned work of Schenck & Fox (2018), who used convolutions to implement a differentiable version of position-based fluids (Macklin & Muller, 2013). Both works define continuous convolution opera- ¨ tors that can support regression tasks and we compare to them directly in Section 6. Most closely related to our filter representation is the work of Fey et al. (2018). They use B-splines to define continuous filters and propose to use spherical coordinates to implement spherical receptive fields. Spherical coordinates are problematic due to singularities and require special treatment, which we avoid with a ball-to-cube mapping. Furthermore, the output of the operator of Fey et al. (2018) can be discontinuous. We show in our ablation study in Section 6 that applying a window function to guarantee a continuous output is advantageous for our task.
+
+# 3 BASICS
+
+Fluids have been studied for centuries, and the Navier-Stokes equations for incompressible fluids are well established (Batchelor, 1967):
+
+$$
+\frac { \partial { \bf v } } { \partial t } + { \bf v } \cdot \nabla { \bf v } = - \frac { 1 } { \rho } \nabla p + \nu \nabla ^ { 2 } { \bf v } + { \bf g } , ~ \mathrm { s . t . } ~ \nabla \cdot { \bf v } = 0 .
+$$
+
+A common approach to solve these partial differential equations is to approximate the fluid with a set of smooth particles (Monaghan, 1988). Each particle corresponds to a continuous blob of matter and carries the local properties of the fluid, such as velocity and density, which move with the flow. This is motivated by the fact that a function $A ( \mathbf { x } )$ can be represented by an integral interpolation
+
+$$
+A ( \mathbf { x } ) = \int A ( \mathbf { x } ^ { \prime } ) \delta ( \| \mathbf { x } - \mathbf { x } ^ { \prime } \| _ { 2 } ) d V ( \mathbf { x } ^ { \prime } ) ,
+$$
+
+where $\delta ( x )$ denotes the Dirac delta function. This equation can be discretized as
+
+$$
+A ( { \bf x } ) \approx \sum _ { i } V _ { i } A _ { i } W ( \| { \bf x } - { \bf x } ^ { \prime } \| _ { 2 } , h ) ,
+$$
+
+where $V _ { i }$ is the volume at the given point in space and
+
+$$
+\operatorname* { l i m } _ { h \to 0 } W ( | \mathbf x - \mathbf x ^ { \prime } | , h ) = \delta ( | \mathbf x - \mathbf x ^ { \prime } | ) .
+$$
+
+Here $W ( x , h )$ is a smooth kernel or convolution with radius $h$ , usually in the form of a Gaussian distribution, but more complex functions can also be used. In practice, the kernel is finite and yields localized neighborhoods of particles that interact via interactions weighted by the kernel of its derivatives. In this way, the continuous description for fluids from Equation 1 can be discretized in a Lagrangian fashion and solved numerically. Typically, internal forces are calculated based on the local pressure, viscosity, and surface tension, which give an update for the position of each particle. Below, we adopt the position-based fluids (PBF) method (Macklin & Muller, 2013; Macklin et al., ¨ 2014), which likewise is based on SPH, but reformulates the updates as constraints on the positions.
+
+# 4 CONTINUOUS CONVOLUTIONS
+
+The discrete convolution operator as commonly used in ConvNets is defined as
+
+$$
+( f * g ) ( \mathbf { x } ) = \sum _ { \tau \in \Omega } f ( \mathbf { x } + \pmb { \tau } ) g ( \pmb { \tau } ) ,
+$$
+
+where $f$ and $g$ are the input and the filter function, $\mathbf { x }$ is the position, $\tau$ is the shift vector, and $\Omega$ is the set of shift vectors that defines the support of the filter function. On regular data such as images, the positions $\mathbf { x }$ range over a regular grid and the shift vectors $\tau$ are integer-valued, i.e. $\mathbf { x } , \tau \in \overline { { \mathbb { Z } } } ^ { \dot { d } }$ for some dimensionality $d$ . Analogously in the continuous domain, this convolution is defined as
+
+$$
+( f * g ) ( \mathbf { x } ) = \int _ { \mathbb { R } ^ { d } } f ( \mathbf { x } + \pmb { \tau } ) g ( \pmb { \tau } ) d \pmb { \tau } ,
+$$
+
+where $\mathbf { x }$ and $\tau$ are real-valued vectors, i.e. $\mathbf { x } , \tau \in \mathbb { R } ^ { d }$ .
+
+We now adapt this definition to unstructured point clouds. In this setting we have a finite number of points that sample the function $f$ but do not lie on a grid. For a point cloud with $i = 1 , . . , N$ points with values $f _ { i }$ at positions $\mathbf { x } _ { i }$ , we define the convolution at position $\mathbf { x }$ as
+
+$$
+( f * g ) ( \mathbf { x } ) = \frac { 1 } { \psi ( \mathbf { x } ) } \sum _ { i \in N ( \mathbf { x } , R ) } a ( \mathbf { x } _ { i } , \mathbf { x } ) \ f _ { i } \ g ( \Lambda ( \mathbf { x } _ { i } - \mathbf { x } ) ) .
+$$
+
+$\mathcal { N } ( { \bf x } , R )$ is the set of points within a radius $R$ around $\ \textbf { x } , \ a$ is a scalar function that can be used for density normalization specific to the points $\mathbf { x } _ { i }$ and $\mathbf { x }$ as in Hermosilla et al. (2018). In the simplest case, $a$ can be constant: $a = 1$ . In our case we want to ensure a smooth response of our convolution under varying particle neighborhoods, therefore we define $a$ as a window function:
+
+$$
+a ( \mathbf x _ { i } , \mathbf x ) = \left\{ \begin{array} { l l } { \left( 1 - \frac { \| \mathbf x _ { i } - \mathbf x \| _ { 2 } ^ { 2 } } { R ^ { 2 } } \right) ^ { 3 } } & { \mathrm { f o r } \| \mathbf x _ { i } - \mathbf x \| _ { 2 } < R } \\ { 0 } & { \mathrm { e l s e } . } \end{array} \right.
+$$
+
+A similar function has been used by Muller et al. (2003) in the SPH framework. ¨ $\psi$ is another scalar function for normalization, which can be set in our implementation as either
+
+$$
+\psi ( \mathbf { x } ) = 1 \quad \mathrm { o r } \quad \psi ( \mathbf { x } ) = \sum _ { i \in \mathcal { N } ( \mathbf { x } , R ) } a ( \mathbf { x } _ { i } , \mathbf { x } ) .
+$$
+
+![](images/41d3bbef3523f4805a96413e83be032ac332d44c48e7e858354dea8d7359abbc.jpg)  
+Figure 1: We use spherical filter shapes for our continuous convolutions but use regular grids to store the filter values. The left part of the figure shows a spherical region with radius $R$ and a point with relative coordinates r with respect to the center. We transform r via a mapping $\Lambda$ to normalized coordinates in a regular grid. The thin dotted lines illustrate the distortion of the mapping. To look up the final filter value we use trilinear interpolation in the regular grid.
+
+We use $\psi ( \mathbf { x } ) = 1$ , since changes in the density of particles are an important feature for simulating fluids.
+
+For the filter function $g$ we simply use a regular grid to store the filter values but use linear interpolation to make $g$ a continuous function. In addition, we use a mapping $\Lambda ( \mathbf { r } )$ of a unit ball to a unit cube to implement spherical filters as shown in Figure 1. We use the mapping described by Griepentrog et al. (2008) and give the detailed function in the appendix. The intermediate coordinate mapping $\Lambda$ provides the flexibility to implement different spatial shapes while keeping the advantages of a regular grid for the storage and lookup of filter values.
+
+Note that Equation 7 uses a similar approximation as in the SPH framework (Equation 3). Assuming that each point represents the same volume, $V _ { i }$ is a constant factor in Equation 3, which we drop in our definition.
+
+# 5 LEARNING FLUID MECHANICS WITH CONVOLUTIONAL NETWORKS
+
+Our goal is to learn fluid mechanics from observing the motion of particles. The input to our ConvNet is a set of particles with corresponding features. Since position itself is not a feature but simply defines the particle’s position in space, we must assign a feature vector to each particle. The feature vector we use is a constant scalar 1 accompanied by the velocity $\mathbf { v }$ and the viscosity $\nu$ . A particle $p _ { i } ^ { n }$ at timestep $n$ with its position and input feature vector is thus a tuple $\left( \mathbf { x } _ { i } ^ { n } , \left[ 1 , \mathbf { v } _ { i } ^ { n } , \nu _ { i } \right] \right)$ . Defining the velocity explicitly as an input feature allows us to compute intermediate velocities and positions as in Ladicky et al. (2015) and to apply external forces and pass this information to the ´ network. We compute the intermediate positions $\mathbf { x } _ { i } ^ { n * }$ and velocities $\mathbf { v } _ { i } ^ { n * }$ beginning with timestep $n$ with Heun’s method as
+
+$$
+\begin{array} { r l } & { \mathbf { v } _ { i } ^ { n * } = \mathbf { v } _ { i } ^ { n } + \Delta t \mathbf { a } _ { \mathrm { e x t } } } \\ & { \mathbf { x } _ { i } ^ { n * } = \mathbf { x } _ { i } ^ { n } + \Delta t \frac { \mathbf { v } _ { i } ^ { n } + \mathbf { v } _ { i } ^ { n * } } { 2 } . } \end{array}
+$$
+
+The vector $\mathbf { a } _ { \mathrm { e x t } }$ is an acceleration through which we can apply external forces to control the fluid or to simply apply gravity. The intermediate positions and velocities lack any interactions between particles or the scene, which we are going to implement with a ConvNet. To enable the network to handle collisions with the environment we define a second set of static particles $s _ { j }$ . We sample particles on the boundaries of the scene with normals $\mathbf { n } _ { j }$ as the feature vectors, i.e. $s _ { j } ^ { \mathsf { ^ { \prime } } } = ( \mathbf { x } _ { j } , [ \mathbf { n } _ { j } ] )$ . Our network implements the function
+
+$$
+[ \Delta { \bf x } _ { 1 } , \ldots , \Delta { \bf x } _ { N } ] = \mathrm { C o n v N e t } ( \{ p _ { 1 } ^ { n * } , \ldots , p _ { N } ^ { n * } \} , \{ s _ { 1 } , \ldots , s _ { M } \} ) ,
+$$
+
+which uses convolutions to combine features from both particle sets. $\Delta \mathbf { x }$ is a correction of the position which accounts for all particle interactions including the collision handling with the scene. Finally, we apply the correction to update positions and velocities for $n + 1$ as
+
+$$
+\begin{array} { r l } & { \mathbf { x } _ { i } ^ { n + 1 } = \mathbf { x } _ { i } ^ { n * } + \Delta \mathbf { x } _ { i } } \\ & { \mathbf { v } _ { i } ^ { n + 1 } = \frac { \mathbf { x } _ { i } ^ { n + 1 } - \mathbf { x } _ { i } ^ { n } } { \Delta t } . } \end{array}
+$$
+
+Note that the updated position $\mathbf { x } _ { i } ^ { n + 1 }$ depends on the output vector $\Delta { { \bf { x } } _ { i } }$ and allows us to directly define our learning objective on the particle positions.
+
+![](images/2b448c62ece1345a05c8277b267b6df08bffec896e1811b20a9b37b056073ce5.jpg)  
+Figure 2: Schematic of our network with a depth of four. In the first depth level we compute convolutions at each dynamic particle location with the set of static particles that defines the environment as well as the dynamic particle set. We also directly process the features of each particle via a fully-connected stream. In the following levels, we compute convolutions only on the dynamic particles. At each level we use addition to aggregate the features computed by convolutions and fully-connected layers. Between the second and third level we also include a residual connection. The final level generates the position correction $\Delta \mathbf { x }$ . Operations annotated with a \* are followed by the ReLU activation function. All CConv and FC operations use an additive bias.
+
+# 5.1 NETWORK ARCHITECTURE
+
+We use a simple convolutional architecture with an effective depth of four. An overview of the network is shown in Figure 2. Since we want to compute the correction for all dynamic particles in our scene, we compute convolutions for the intermediate positions defined in Equation 11. Our network is a sequence of continuous convolutions (CConv), which are defined by an input particle set, the positions at which we want to evaluate the convolution, its filters $G$ , and the radius $R$ . For instance, to describe a convolution on the static particles $s _ { i }$ at intermediate positions $\mathbf { x } _ { i } ^ { n * }$ we can write
+
+$$
+[ { \bf f } _ { 1 } , \ldots , { \bf f } _ { N } ] = \mathrm { C C o n v } ( \{ s _ { 1 } , \ldots , s _ { M } \} , [ { \bf x } _ { 1 } ^ { n * } , \ldots , { \bf x } _ { N } ^ { n * } ] , G , R ) ,
+$$
+
+where $\mathbf { f } _ { i }$ are the computed output features for each position $\mathbf { x } _ { i } ^ { n * }$ . $G$ is a 5D array storing all filters in the layout [width, height, depth, $\mathrm { c h } _ { \mathrm { i n } } , \mathrm { c h } _ { \mathrm { o u t } } ]$ . In contrast to discrete convolutions on a regular grid, the spatial filter dimensions here do not define the receptive field but the resolution of the filters. The receptive field depends only on the radius $R$ , which specifies the spatial extent. Throughout our network we use filters with a spatial resolution of [4, 4, 4] and a radius of 4.5 times the particle radius.
+
+For convolutions within the dynamic particles we exclude the particle at which we evaluate the convolution and instead process the particle’s own features in a stream of fully-connected layers. After each depth level we then combine the result from the convolutions and the fully-connected layers by addition. This can be interpreted as a convolution with a spatial resolution of $4 \times 4 \times 4 + 1$ . We found that this design improves accuracy and allows us to use smaller filters with even sizes (see Table 2).
+
+# 5.2 TRAINING PROCEDURE
+
+We train our fluid simulation network in supervised fashion based on particle trajectories produced by classic (“ground-truth”) physics simulation. Our loss is defined as follows:
+
+$$
+\mathcal { L } ^ { n + 1 } = \sum _ { i = 1 } ^ { N } \phi _ { i } \left. \mathbf { x } _ { i } ^ { n + 1 } - \hat { \mathbf { x } } _ { i } ^ { n + 1 } \right. _ { 2 } ^ { \gamma } .
+$$
+
+The ground-truth position at timestep $n + 1$ is denoted by $\hat { \mathbf { x } } _ { i } ^ { n + 1 }$ and the predicted position from the network is denoted by $\mathbf { x } _ { i } ^ { n + 1 } = \mathbf { x } _ { i } ^ { n * } + \Delta \mathbf { x } _ { i }$ , where $\Delta { { \bf { x } } _ { i } }$ is provided by the network. $\phi _ { i }$ is an individual weight for each point. We use $\begin{array} { r } { \phi _ { i } = \exp ( - \frac { 1 } { c } | \mathcal { N } ( \mathbf { x } _ { i } ^ { n * } ) | ) } \end{array}$ , which emphasizes the loss for particles with fewer neighbors. We choose $c = 4 0$ , which corresponds to the average number of neighbors across our experiments. Particles with few neighbors are close to the surface or interact with the scene boundary. Both cases are important for fluid simulation because particles near the surface define the liquid-air interface, which is particularly salient, and particles near the scene boundary require collision handling. The parameter $\gamma = 0 . 5$ makes our loss function more sensitive to small particle motions, which is important for increasing the accuracy and visual fidelity for small fluid flows. During training we predict particle positions for two future timesteps, namely $n + 1$ and $n + 2$ . The combined loss $\mathcal { L }$ is
+
+![](images/e4a49216268a94b12eb5035a2162f35f2734226af166947401897668e3d0ec91.jpg)  
+Figure 3: Comparison to ground-truth physics simulation. Two fluid bodies collide. Top: simulation by our trained network. Bottom: simulation of the same scenario by DFSPH (Bender & Koschier, 2015), a high-fidelity solver that was executed with small timesteps (down to 0.001s). Despite using a much larger timestep (0.02s), our convolutional network produces results of comparable visual fidelity. Note that our particles are falling slightly more slowly due to differences in the integration of positions and the much larger timestep. See the supplementary video.
+
+$$
+{ \mathcal { L } } = { \mathcal { L } } ^ { n + 1 } + { \mathcal { L } } ^ { n + 2 } .
+$$
+
+We found that optimizing a loss defined over two frames improves the overall quality of the simulation. (Optimization for three frames did not result in further improvements.) We optimize $\mathcal { L }$ over 50,000 iterations with Adam (Kingma & Ba, 2015) and a learning rate decay with multiple steps, starting with a learning rate of 0.001 and stopping with $1 . 5 6 \cdot 1 0 ^ { - 5 }$ .
+
+# 5.3 DATASETS
+
+We have trained our network on multiple datasets. For quantitative comparisons with prior work we trained our network on the dam break data from Li et al. (2019). The scene simulates the behavior of a randomly placed fluid block in a static box. We generate 2000 scenes for training and 300 for testing. The data was generated with FleX, which is a position-based simulator that targets real-time applications (Macklin et al., 2014).
+
+We also trained our network on more challenging data generated with DFSPH (Bender & Koschier, 2015), which prioritizes simulation fidelity over runtime. DFSPH can generate accurate fluid flows with very low volume compression: a desired property. We generate ground-truth data by randomly placing multiple bodies of fluid in 10 different box-like scenes and simulating them for 16 seconds each with an adaptive timestep of up to $1 \mathrm { k H z }$ . The time resolution of the generated data is $5 0 \mathrm { { H z } }$ . We show a qualitative comparison of our method to the ground truth in Figure 3. We generate 200 scenes for training and 20 scenes for the test set. To train networks that can deal with multiple materials, we additionally generate 200 scenes with fluids of varying viscosity. For estimating material properties, we generate 7 test scenes that only differ in the viscosity parameter.
+
+# 6 EVALUATION
+
+Baselines. We compare our method to DPI-Nets (Li et al., 2019), which were previously shown to significantly outperform prior formulations such as hierarchical relation networks (Mrowca et al., 2018). Figure 4 provides a qualitative comparison. Quantitative results are reported in Table 1. To analyze the accuracy of the forward step for each method, we compute the average error of the particle positions with respect to the ground truth. We use every $5 ^ { \mathrm { t h } }$ frame for initialization and compute the deviation from the ground truth for two subsequent frames, denoted by $n + 1$ and $n + 2$ .
+
+![](images/15026580939376a905379a68fddd2924ccbf3b0b80a48da70f72cb01cd59ec0d.jpg)  
+Figure 4: Qualitative comparison with DPI-Nets on a test sequence from our dataset. Two fluid bodies collide inside a container. DPI-Nets works well on data with little variance but has problems with more complex scenes and high particle velocities. The DPI-Nets simulation becomes unstable immediately after the fluid hits the box. The fluid behavior predicted by our network matches the ground truth more closely and remains stable for the whole sequence. The two networks have been trained on the same data. Test sequences are distinct from training sequences. See the supplementary video.
+
+In addition, we report the average distance from the ground-truth particles to the closest particle in the prediction for the whole sequence, to measure long-term similarity. We compute the distance for frame $n$ as
+
+$$
+d ^ { n } = \frac { 1 } { N } \sum _ { i = 1 } ^ { N } \operatorname* { m i n } _ { \mathbf { x } ^ { n } \in X ^ { n } } \| \hat { \mathbf { x } } _ { i } ^ { n } - \mathbf { x } ^ { n } \| _ { 2 } ,
+$$
+
+where $X ^ { n }$ is the set of predicted particle positions for frame $n$ , $\hat { \mathbf { x } } _ { i } ^ { n }$ is the ground-truth position for particle $i$ , and $N$ is the number of particles.
+
+We also compare our continuous convolution formulation to continuous convolution representations used in SPNets (Schenck & Fox, 2018), PCNN (Wang et al., 2018), KPConv (Thomas et al., 2019), and SplineCNN (Fey et al., 2018). To this end, we plug the respective convolution operators into our network architecture as shown in Figure 2. This facilitates controlled comparisons in which the overall architecture and simulation setup are fixed and only the convolution operators are varied. As shown in Table 1, our method outperforms all baselines with respect to both accuracy and inference time.
+
+We have trained and tested all methods on the dam break dataset from Li et al. (2019) as well as our data (generated with a high-fidelity simulator (Bender & Koschier, 2015)). To facilitate the training on our data for all methods, we generated a simplified version with a constant number of particles (6,000) and a single box environment (as shown in Figure 4). We train DPI-Nets for 5 epochs and all other networks for 50,000 iterations, which corresponds to 2.7 epochs for the dam break data and 5 epochs for our data. Training takes about a day for our method with our convolutions on an NVIDIA RTX 2080Ti. Training with PCNN convolutions (Wang et al., 2018) takes about 2 days on 4 GPUs. Note that our reimplementation of PCNN convolutions uses Tensorflow’s built-in functions, which consume a lot of memory and necessitate multi-GPU training. The DPI-Nets model trains in about one day. Training with SplineCNN Convs takes 3 to 4 days on a single GPU. We got the best results for this method with spherical kernel coordinates and closed splines. For KPConvs we used a Quadro RTX 6000 with $2 4 \mathrm { \ G B }$ of RAM due to the higher memory requirements. Training took about 1 day with 15 kernel points. For SPNets convolutions, we estimated a training time of more than 29 days with $3 \times 3 \times 3$ filters by extrapolating from timing of a smaller number of iterations. We thus only report inference time for this method. Note that the convolutions of SPNets were designed to implement the position-based fluids algorithm, while we use them here in a more general network architecture with a much larger number of channels, which explains the very long runtime.
+
+Ablation study. We perform an ablation study to evaluate our decisions in the design of the continuous convolution operator and the network. We study the importance of the interpolation, the window function, the loss design, and the architecture choice. The results are reported in Table 2. This table reports error measures (averaged over the test sequences) that were used in Table 1, and also reports the errors for two predicted frames initialized with the frames at the end of each sequence to measure the errors for small flow velocities. Large errors for small velocities can yield perceptually salient artifacts: rather than being still, fluid particles jitter or churn.
+
+Table 1: Accuracy and runtime analysis. We compare the average error between the ground-truth particle positions and two predicted future frames on the test set. Additionally, we report the average distance from the ground truth to the prediction over the whole sequence. In this test mode some methods become unstable after a few frames. In the last column we report the average inference time per frame.   
+
+<table><tr><td rowspan="2" colspan="2">Method</td><td colspan="2">Average pos error (mm)</td><td rowspan="2">Average distance to closest point d&quot; (mm)</td><td rowspan="2">Frame inference time (ms)</td></tr><tr><td>n+1</td><td>n+2</td></tr><tr><td></td><td>DPI-Nets</td><td>12.73</td><td>25.38</td><td>22.07</td><td>202.56</td></tr><tr><td></td><td>SPNets Convs</td><td>一</td><td>一</td><td></td><td>1058.46</td></tr><tr><td></td><td>PCNN Convs</td><td>0.72</td><td>1.67</td><td>19.79</td><td>187.34</td></tr><tr><td>RParaasr</td><td>SplineCNN Convs</td><td>0.71</td><td>1.65</td><td>170.20</td><td>67.67</td></tr><tr><td></td><td>KPConv</td><td>2.49</td><td>7.05</td><td>unstable</td><td>47.96</td></tr><tr><td></td><td>Ours</td><td>0.62</td><td>1.49</td><td>16.98</td><td>12.01</td></tr><tr><td></td><td>DPI-Nets</td><td>26.19</td><td>51.77</td><td>unstable</td><td>305.55</td></tr><tr><td></td><td>SPNets Convs</td><td>1</td><td>1</td><td>1</td><td>784.35</td></tr><tr><td>raarae rl gaest</td><td>PCNN Convs</td><td>0.67</td><td>1.87</td><td>32.51</td><td>319.17</td></tr><tr><td></td><td>SplineCNN Convs</td><td>0.68</td><td>1.93</td><td>unstable</td><td>281.92</td></tr><tr><td></td><td>KPConv</td><td>1.65</td><td>4.54</td><td>unstable</td><td>57.89</td></tr><tr><td></td><td>Ours</td><td>0.56</td><td>1.51</td><td>29.50</td><td>16.47</td></tr></table>
+
+Table 2: Ablation study. We compare the average error between the ground-truth particle positions and two predicted future frames on the test set, evaluated over whole test sequences (left) and just on the final frames of each test sequence (middle; this focuses on frames with small motion). The rightmost column shows the average distance from the ground truth to the predicted point set over whole test sequences. Ours w/o interpolation uses nearest-neighbor instead of trilinear interpolation for the convolution filters. Ours w/o window uses $a ( \mathbf { x } _ { i } , \mathbf { x } ) = 1$ in Equation 7. Ours w/ na¨ıve loss uses Euclidean distance as the loss, i.e. we set $\gamma = 1$ and $\phi _ { i } = 1$ in Equation 16. Ours w/o FC uses only convolutions and includes the central particle in the convolution (rather than separately processing its features via an FC layer).   
+
+<table><tr><td rowspan="2">Method</td><td colspan="2">Average error (mm)</td><td colspan="2">Seq. end error (mm)</td><td rowspan="2">Average distance to closest point d&quot; (mm)</td></tr><tr><td>n+1</td><td>n+2</td><td>n+1</td><td>n+2</td></tr><tr><td>Ours</td><td>0.67</td><td>1.87</td><td>0.25</td><td>0.74</td><td>30.63</td></tr><tr><td>Ours w/o interpolation</td><td>0.79</td><td>2.24</td><td>0.30</td><td>0.89</td><td>32.39</td></tr><tr><td>Ours w/o window</td><td>0.77</td><td>2.21</td><td>0.30</td><td>0.89</td><td>31.77</td></tr><tr><td>Ours w/ naive loss</td><td>0.69</td><td>1.86</td><td>0.27</td><td>0.77</td><td>30.35</td></tr><tr><td>Ours w/o FC</td><td>0.75</td><td>2.17</td><td>0.27</td><td>0.80</td><td>32.49</td></tr></table>
+
+Generalization. In Figure 5 we show that our network generalizes well to scenes with drastically different geometry than seen during training. (The training set uses only box-like containers. See the appendix for visualization.) These scenarios demonstrate that we can emit particles during simulation, which can be costly for methods that build and maintain explicit graph structures. We compare generalization performance quantitatively to DFPSH on a complex scene in Figure 6. Figure 7 demonstrates generalization along a different dimension. Here we show that we can set the viscosity of the fluid at test time to a value not seen during training. The fluid shape used in this example was also not seen during training.
+
+![](images/e67c7b9cd9fa6a6ff5084b5f367ebe88d096599b3b8339604611780fee048f5f.jpg)  
+Figure 5: Generalization to environments with drastically different geometry than seen during training. Top: we use an emitter to fill up a virtual river with fluid particles, demonstrating generalization with respect to scene geometry and the number of particles. Bottom: a waterfall scene showing the fluid particles and the particle representation of the environment. See the supplementary video.
+
+![](images/abe4e641cedacda2fe157a71a4d9a67468250b42603b501a7399766755b97762.jpg)  
+Figure 6: Average distance from the ground-truth particles to the predicted particles on a complex scene. Top: error over time for our trained network and DFSPH. We use a timestep of $\Delta t = 5$ ms for DFSPH and $\Delta t = 2 0 \mathrm { m s }$ for our method, which also corresponds to the frame sampling rate. The ground truth was generated with DFSPH and a timestep of 1ms. Bottom: simulation produced by our network. Large errors are concentrated in the beginning of the sequence when the fluid initially collides with the environment and the fluid behavior is most chaotic. During this phase the error is higher for our method than DFSPH. After 200 frames the error levels become similar.
+
+![](images/61470283b23c7be98c6eab7fcd81861f2b541e055b261fcecfd497d7763d31d3.jpg)  
+Figure 7: We can control the viscosity of the simulated fluid at test time by changing the input parameter $\nu$ in the input feature vector.
+
+Material estimation. In this experiment we apply our network to an inverse problem: material estimation from observation. We use our network to estimate the viscosity parameter of a fluid from the particle movement. The training data for this experiment contains 200 sequences with random viscosity parameters between 0.01 and 0.3. For testing we generate 5 new sequences with 100 frames and random viscosity within the same range as used during training and use an initial fluid shape not present in the training data. To test generalization we generate two sequences with viscosity values outside the training range, namely 0.35 and 0.4. To estimate the viscosity we backpropagate through the trained network and optimize $\nu$ with gradient descent. Table 3 reports the results, which indicate that our network can be used to estimate material properties from observed data.
+
+<table><tr><td>GT viscosity</td><td>0.044</td><td>0.127</td><td>0.174</td><td>0.233</td><td>0.269</td><td>0.350</td><td>0.400</td><td>Mean</td></tr><tr><td>Avg. estimated viscosity</td><td>0.027</td><td>0.150</td><td>0.202</td><td>0.255</td><td>0.277</td><td>0.322</td><td>0.336</td><td></td></tr><tr><td>Avg. relative error (%)</td><td>38.377</td><td>18.542</td><td>15.604</td><td>9.568</td><td>3.235</td><td>7.954</td><td>16.016</td><td>15.614</td></tr></table>
+
+Table 3: Application to an inverse problem: material estimation from observed fluid motion. To estimate the viscosity we backpropagate through our network and optimize $\nu$ with gradient descent. For each scene, we run the procedure 10 times, each time with random initialization, and report the average. Viscosity values 0.350 and 0.400 are outside the range that was used during training and are used to test generalization.
+
+# 7 CONCLUSION
+
+We have developed continuous convolutional networks for Lagrangian fluid simulation. We have introduced a simple formulation for continuous convolutions and demonstrated its accuracy and speed. Our model captures a wide range of complex material behavior, offers long-term stability, and generalizes to new situations such as varying particle counts, domain geometries, and material properties. There are numerous directions for future work, such as extending the framework to incorporate rigid and deformable solids. We will release the code to facilitate such development. Our continuous convolution implementation will be made available as part of Open3D (Zhou et al., 2018).
+
+Acknowledgements. We thank Jan Bender for his support with the SPlisHSPlasH framework.
+
+# REFERENCES
+
+Matan Atzmon, Haggai Maron, and Yaron Lipman. Point convolutional neural networks by extension operators. ACM Trans. Graph., 37(4), 2018.
+
+George K. Batchelor. An Introduction to Fluid Dynamics. Cambridge University Press, 1967.
+
+Peter W. Battaglia, Razvan Pascanu, Matthew Lai, Danilo Rezende, and Koray Kavukcuoglu. Interaction networks for learning about objects, relations and physics. In Advances in Neural Information Processing Systems, 2016.
+
+Jan Bender and Dan Koschier. Divergence-free smoothed particle hydrodynamics. In Symposium on Computer Animation, 2015.
+
+Andrea Colagrossi and Maurizio Landrini. Numerical simulation of interfacial flows by smoothed particle hydrodynamics. Journal of Computational Physics, 191(2), 2003.
+
+Matthias Fey, Jan Eric Lenssen, Frank Weichert, and Heinrich Muller. SplineCNN: Fast geometric ¨ deep learning with continuous B-spline kernels. In CVPR, 2018.
+
+Nick Foster and Dimitris N. Metaxas. Realistic animation of liquids. Graphical Models and Image Processing, 58(5), 1996.
+
+Robert A Gingold and Joseph J Monaghan. Smoothed particle hydrodynamics: Theory and application to non-spherical stars. Monthly Notices of the Royal Astronomical Society, 181(3), 1977.
+
+Christoph Gissler, Andreas Peer, Stefan Band, Jan Bender, and Matthias Teschner. Interlinked SPH pressure solvers for strong fluid-rigid coupling. ACM Trans. Graph., 38(1), 2018.
+
+Jens Andre Griepentrog, Wolfgang H ´ oppner, Hans-Christoph Kaiser, and Joachim Rehberg. A bi- ¨ Lipschitz continuous, volume preserving map from the unit ball onto a cube. Note di Matematica, 28, 2008.
+
+Pedro Hermosilla, Tobias Ritschel, Pere-Pau Vazquez, ´ Alvar Vinacua, and Timo Ropinski. Monte \` Carlo convolution for learning on non-uniformly sampled point clouds. ACM Trans. Graph., 37 (6), 2018.
+
+Xiang Yu Hu and Nikolaus A Adams. A multi-phase SPH method for macroscopic and mesoscopic flows. Journal of Computational Physics, 213(2), 2006.
+
+Binh-Son Hua, Minh-Khoi Tran, and Sai-Kit Yeung. Pointwise convolutional neural networks. In CVPR, 2018.
+
+Byungsoo Kim, Vinicius C. Azevedo, Nils Thuerey, Theodore Kim, Markus Gross, and Barbara Solenthaler. Deep fluids: A generative network for parameterized fluid simulations. Computer Graphics Forum, 38(2), 2019.
+
+Diederik P. Kingma and Jimmy Ba. Adam: A method for stochastic optimization. In ICLR, 2015.
+
+L’ubor Ladicky, SoHyeon Jeong, Barbara Solenthaler, Marc Pollefeys, and Markus Gross. Data- ´ driven fluid simulations using regression forests. ACM Trans. Graph., 34(6), 2015.
+
+Huan Lei, Naveed Akhtar, and Ajmal Mian. Octree guided CNN with spherical kernels for 3D point clouds. In CVPR, 2019.
+
+Yangyan Li, Rui Bu, Mingchao Sun, Wei Wu, Xinhan Di, and Baoquan Chen. PointCNN: Convolution on X-transformed points. In Advances in Neural Information Processing Systems, 2018.
+
+Yunzhu Li, Jiajun Wu, Russ Tedrake, Joshua B. Tenenbaum, and Antonio Torralba. Learning particle dynamics for manipulating rigid bodies, deformable objects, and fluids. In ICLR, 2019.
+
+Julia Ling, Andrew Kurzawski, and Jeremy Templeton. Reynolds averaged turbulence modelling using deep neural networks with embedded invariance. Journal of Fluid Mechanics, 807, 2016.
+
+Miles Macklin and Matthias Muller. Position based fluids. ¨ ACM Trans. Graph., 32(4), 2013.
+
+Miles Macklin, Matthias Muller, Nuttapong Chentanez, and Tae-Yong Kim. Unified particle physics ¨ for real-time applications. ACM Trans. Graph., 33(4), 2014.
+
+J Monaghan. An introduction to SPH. Computer Physics Communications, 48(1), 1988.
+
+Jeremy Morton, Antony Jameson, Mykel J Kochenderfer, and Freddie Witherden. Deep dynamical modeling and control of unsteady fluid flows. In Advances in Neural Information Processing Systems, 2018.
+
+Damian Mrowca, Chengxu Zhuang, Elias Wang, Nick Haber, Li F Fei-Fei, Josh Tenenbaum, and Daniel L Yamins. Flexible neural representation for physics prediction. In Advances in Neural Information Processing Systems, 2018.
+
+Matthias Muller, David Charypar, and Markus Gross. Particle-based fluid simulation for interactive ¨ applications. In Symposium on Computer Animation, 2003.
+
+Daniel J Price. Smoothed particle hydrodynamics and magnetohydrodynamics. Journal of Computational Physics, 231(3), 2012.
+
+Alvaro Sanchez-Gonzalez, Nicolas Heess, Jost Tobias Springenberg, Josh Merel, Martin A. Riedmiller, Raia Hadsell, and Peter W. Battaglia. Graph networks as learnable physics engines for inference and control. In ICML, 2018.
+
+Connor Schenck and Dieter Fox. SPNets: Differentiable fluid dynamics for deep neural networks. In Conference on Robot Learning, 2018.
+
+Barbara Solenthaler and Renato Pajarola. Predictive-corrective incompressible SPH. ACM Trans. Graph., 28(3), 2009.
+
+Hang Su, Varun Jampani, Deqing Sun, Subhransu Maji, Evangelos Kalogerakis, Ming-Hsuan Yang, and Jan Kautz. SPLATNet: Sparse lattice networks for point cloud processing. In CVPR, 2018.
+
+Matthias Teschner, Bruno Heidelberger, Matthias Muller, Danat Pomerantes, and Markus H. Gross. ¨ Optimized spatial hashing for collision detection of deformable objects. In Vision, Modeling, and Visualization (VMV), 2003.
+
+Hugues Thomas, Charles R. Qi, Jean-Emmanuel Deschaud, Beatriz Marcotegui, Franc¸ois Goulette, and Leonidas J. Guibas. KPConv: Flexible and deformable convolution for point clouds. In ICCV, 2019.
+
+Jonathan Tompson, Kristofer Schlachter, Pablo Sprechmann, and Ken Perlin. Accelerating Eulerian fluid simulation with convolutional networks. In ICML, 2017.
+
+Shenlong Wang, Simon Suo, Wei-Chiu Ma, Andrei Pokrovsky, and Raquel Urtasun. Deep parametric continuous convolutional neural networks. In CVPR, 2018.
+
+Steffen Wiewel, Moritz Becher, and Nils Thuerey. Latent space physics: Towards learning the temporal evolution of fluid flow. Computer Graphics Forum, 38(2), 2019.
+
+David C Wilcox. Turbulence Modeling for CFD. DCW industries, 3rd edition, 2006.
+
+Wenxuan Wu, Zhongang Qi, and Fuxin Li. PointConv: Deep convolutional networks on 3D point clouds. In CVPR, 2019.
+
+You Xie, Erik Franz, Mengyu Chu, and Nils Thuerey. tempoGAN: A temporally coherent, volumetric GAN for super-resolution fluid flow. ACM Trans. Graph., 37(4), 2018.
+
+Yifan Xu, Tianqi Fan, Mingye Xu, Long Zeng, and Yu Qiao. SpiderCNN: Deep learning on point sets with parameterized convolutional filters. In ECCV, 2018.
+
+Qian-Yi Zhou, Jaesik Park, and Vladlen Koltun. Open3D: A modern library for 3D data processing. arXiv:1801.09847, 2018.
+
+# A APPENDIX
+
+# A.1 IMPLEMENTATION DETAILS
+
+To accelerate the computation of Equation 7 we use existing general matrix multiplication primitives. Similar to standard convolutions in deep learning frameworks we build a matrix with patches that we then multiply with the filter matrix. We can account for the linear interpolation by applying the interpolation to the patch matrix instead of the filters. For 3D point clouds a single point contributes to up to 8 voxels in a patch.
+
+Another crucial part of our implementation is the nearest neighbor search. Since the positions of the fluid particles update with each timestep, we have to rebuild the neighborhood information for every frame. We implement the neighborhood search with spatial hashing (we use the hash function proposed in Teschner et al. (2003)). We explicitly store all particle neighbors in a compact list, which allows us to reuse the information for multiple convolutions operating on the same point sets. Table 4 compares the average frame runtimes of our method with the baselines.
+
+# A.2 DATASET GENERATION
+
+To enable generalization to new environments we use 10 different containers (see Figure 8) in our data generation process. During scene generation we randomly sample an environment and place up to 3 fluid bodies with different shapes and sizes (see Figure 9) and random initial velocities in the scene. We simulate each generated scene with DFSPH using the SPlisHSPlasH framework 1 for
+
+<table><tr><td>Method</td><td></td><td>Frame inference time (ms)</td><td>Frame NNS time (ms)</td><td>NNS Method</td></tr><tr><td></td><td>DPI-Nets</td><td>202.56</td><td>103.26</td><td>KD-Tree (SciPy)</td></tr><tr><td>Daraaa</td><td>SPNets Convs</td><td>1058.46</td><td>5.24</td><td>Spatial hashing on GPU</td></tr><tr><td></td><td>PCNN Convs</td><td>187.34</td><td>2.42</td><td>*Spatial hashing on GPU</td></tr><tr><td></td><td>SplineCNN Convs</td><td>67.67</td><td>41.92</td><td>Brute-force on GPU</td></tr><tr><td></td><td>KPConv</td><td>47.96</td><td>28.12</td><td>KD-Tree (nanoflann)</td></tr><tr><td></td><td>Ours</td><td>12.01</td><td>2.14</td><td>* Spatial hashing on GPU</td></tr><tr><td>gaaarae err tar est</td><td>DPI-Nets</td><td>305.55</td><td>171.22</td><td>KD-Tree (SciPy)</td></tr><tr><td></td><td>SPNets Convs</td><td>784.35</td><td>10.19</td><td>Spatial hashing on GPU</td></tr><tr><td></td><td>PCNN Convs</td><td>319.17</td><td>2.78</td><td>* Spatial hashing on GPU</td></tr><tr><td></td><td>SplineCNN Convs</td><td>281.92</td><td>245.52</td><td>Brute-force on GPU</td></tr><tr><td></td><td>KPConv</td><td>57.89</td><td>34.07</td><td>KD-Tree (nanoflann)</td></tr><tr><td></td><td>Ours</td><td>16.47</td><td>2.38</td><td>*Spatial hashing on GPU</td></tr></table>
+
+Table 4: Runtime analysis. We compare the average per frame inference time and the time used for the nearest neighbor search (NNS). Our convolution achieves the shortest inference times in comparison even if NNS times would be excluded. Irrespective of that, the methods used for finding neighbors can have a significant contribution to the total runtime. Since fluid particles are moving, acceleration structures for the neighbor search have to be rebuilt each frame. This affects the KDTree methods as well as the methods using spatial hashing. Note that we use the same NNS for PCNN and Ours (denoted with \*). For all methods except for SPNets the inference time is shorter on the smaller DPI DamBreak data (3456 particles compared to the 6000 particles of our data). We attribute this to a higher number of neighbors on the DPI DamBreak, which is about 49 on average compared to the average 40 neighbors on our datasets. All runtimes were measured on a system with an Intel Core i9-7960 and an NVIDIA RTX 2080Ti.
+
+16 seconds to ensure that each scene contains frames with small particle velocities. To create the particle representation of the box-like containers, we do Poisson-Disc sampling on the mesh surface with the tools provided by DFPSH and add surface normals to each particle.
+
+![](images/8d35cce31d9dfd8d41d1ab91b20111ad299e58de888e2118fc1c35b7b0bd9688.jpg)  
+Figure 8: We sample from 10 different box-like containers during data generation. For the simplified version of our dataset used in the quantitative comparison with the baselines we only use the first container (leftmost container in the first row).
+
+![](images/d23198eef7fc652a9b841e946779bbeda60a591a9f56f8e201f10920c76328cb.jpg)  
+Figure 9: We randomly place fluid bodies of different initial shapes in the scene during data generation. We sample from 5 different shapes and vary the size, the orientation and the initial particle velocity. All particles from the same fluid body start with the same initial velocity. The image shows the particles generated from each shape for a specific size and orientation.
+
+<table><tr><td rowspan="2">Method</td><td colspan="2">Average error (mm)</td><td colspan="2">Seq. end error (mm)</td><td rowspan="2">Average distance to closest point d (mm)</td></tr><tr><td>n+1</td><td>n+2</td><td>n+1</td><td>n+2</td></tr><tr><td>Ours</td><td>0.67</td><td>1.87</td><td>0.25</td><td>0.74</td><td>30.63</td></tr><tr><td>Ours triangular window</td><td>0.69</td><td>1.94</td><td>0.27</td><td>0.79</td><td>30.28</td></tr><tr><td>Ours w/o window</td><td>0.77</td><td>2.21</td><td>0.30</td><td>0.89</td><td>31.77</td></tr></table>
+
+Table 5: Comparison of different window functions. Ours uses a window function similar to the poly6 kernel used in Muller et al. (2003). ¨ Ours triangular window uses a triangular window function. Ours w/o window does not use a window function. This case can also be interpreted as a rectangular window since we only consider points within a radius $R$ .
+
+# A.3 TRAINING DETAILS
+
+We use the Tensorflow framework for implementing the training procedure. We use Adam as optimizer and train with a batch size of 16 and an initial learning rate of 0.001. We half the learning rate at steps 20000, 25000, . . . , 45000. For the convolutions we use the random uniform initializer with range [-0.05, 0.05]. All other weights are initialized with the respective default initializers of Tensorflow version 1.12. The output of the network is scaled with $\scriptstyle { \frac { 1 } { 1 2 8 } }$ to roughly adjust the output range to the ground truth position correction of the training data.
+
+The unit of length of the training data is meter. The particle radius used in DFSPH is $h = 0 . 0 2 5 \mathrm { m }$ .   
+For our convolutions, we use spherical filters with an empirically determined radius of $R = 4 . 5 h$ .
+
+# A.4 WINDOW FUNCTION
+
+We compare 3 different choices for the window function $a$ from Equation 8 in Table 5. The results show that enforcing a continuous output with a window function yields better results. Further, using a window function similar to kernels used in SPH codes gives better results than a simple triangular window. Learning the window function is therefore a possible direction to extend our framework to further improve the accuracy.
+
+# A.5 COORDINATE MAPPING FUNCTION
+
+We use the ball to cube mapping described in (Griepentrog et al., 2008) to map a position within a spherical region to the filter values stored in a regular grid. We give here the functions used for the 3-D case as used in our implementation. For more details see (Griepentrog et al., 2008).
+
+The function $\Lambda$ is a composition of the functions $\Lambda _ { \mathrm { b a l l  c y l } }$ and $\Lambda _ { \mathrm { c y l \to c u b e } }$ , which map a sphere to a cylinder and a cylinder to a cube respectively. We define $\Lambda _ { \mathrm { b a l l  c y l } }$ for vectors ${ \bf r } = ( x , y , z )$ as
+
+$$
+\begin{array} { r } { \Lambda _ { \mathrm { b a l l } \to \mathrm { c y l } } ( \mathbf { r } ) = \left\{ \begin{array} { l l } { ( 0 , 0 , 0 ) } & { \mathrm { i f ~ } \| \mathbf { r } \| _ { 2 } = 0 } \\ { \left( x \frac { \| \mathbf { r } \| _ { 2 } } { \| ( x , y ) \| _ { 2 } } , y \frac { \| \mathbf { r } \| _ { 2 } } { \| ( x , y ) \| _ { 2 } } , \frac { 3 } { 2 } z \right) } & { \mathrm { i f ~ } \frac { 5 } { 4 } z ^ { 2 } \leq x ^ { 2 } + y ^ { 2 } } \\ { \left( x \sqrt { \frac { 3 \| \mathbf { r } \| _ { 2 } } { \| \mathbf { r } \| _ { 2 } + | z | } } , y \sqrt { \frac { 3 \| \mathbf { r } \| _ { 2 } } { \| \mathbf { r } \| _ { 2 } + | z | } } , \mathrm { s i g n } ( z ) \| \mathbf { r } \| _ { 2 } \right) } & { \mathrm { e l s e } . } \end{array} \right. } \end{array}
+$$
+
+The cylinder to cube mapping is defined as
+
+$$
+\Lambda _ { \mathrm { c y l } \to \mathrm { c u b e } } ( \mathbf { r } ) = \left\{ \begin{array} { l l } { ( 0 , 0 , z ) } & { \mathrm { i f ~ } x = 0 , y = 0 } \\ { ( \mathrm { s i g n } ( x ) \| ( x , y ) \| _ { 2 } , \frac { 4 } { \pi } \mathrm { s i g n } ( x ) \| ( x , y ) \| _ { 2 } \mathrm { a r c t a n } \frac { y } { x } , z ) } & { \mathrm { i f ~ } | y | \leq | x | } \\ { \left( \frac { 4 } { \pi } \mathrm { s i g n } ( y ) \| ( x , y ) \| _ { 2 } \mathrm { a r c t a n } \frac { x } { y } , \mathrm { s i g n } ( y ) \| ( x , y ) \| _ { 2 } , z \right) } & { \mathrm { e l s e } . } \end{array} \right.
+$$
+
+We assume that vectors $\mathbf { r }$ are normalized with the search radius $R$ such that $\| \mathbf { r } \| _ { 2 } \leq 1$ . This yields the following $\Lambda$ , which maps from a unit ball to the normalized coordinates of a cube:
+
+$$
+\Lambda ( { \bf r } ) = \frac { 1 } { 2 } \Lambda _ { \mathrm { c y l \to c u b e } } ( \Lambda _ { \mathrm { b a l l \to c y l } } ( { \bf r } ) ) + ( 0 . 5 , 0 . 5 , 0 . 5 ) .
+$$

parse/train/B1lDoJSYDH/B1lDoJSYDH_content_list.json

@@ -0,0 +1,1852 @@
+[
+    {
+        "type": "text",
+        "text": "LAGRANGIAN FLUID SIMULATION WITH CONTINUOUS CONVOLUTIONS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            99,
+            612,
+            146
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Benjamin Ummenhofer Intel Labs ",
+        "bbox": [
+            184,
+            170,
+            349,
+            198
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Lukas Prantl & Nils Thuerey Technical University of Munich ",
+        "bbox": [
+            405,
+            170,
+            612,
+            198
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Vladlen Koltun Intel Labs ",
+        "bbox": [
+            668,
+            171,
+            776,
+            198
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "ABSTRACT ",
+        "text_level": 1,
+        "bbox": [
+            454,
+            236,
+            544,
+            251
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "We present an approach to Lagrangian fluid simulation with a new type of convolutional network. Our networks process sets of moving particles, which describe fluids in space and time. Unlike previous approaches, we do not build an explicit graph structure to connect the particles but use spatial convolutions as the main differentiable operation that relates particles to their neighbors. To this end we present a simple, novel, and effective extension of N-D convolutions to the continuous domain. We show that our network architecture can simulate different materials, generalizes to arbitrary collision geometries, and can be used for inverse problems. In addition, we demonstrate that our continuous convolutions outperform prior formulations in terms of accuracy and speed. ",
+        "bbox": [
+            233,
+            267,
+            764,
+            406
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 INTRODUCTION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            439,
+            336,
+            455
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Understanding physics can help reasoning about our environment and interacting with it. Neural networks have emerged as a particularly promising approach to capture the complexity of natural phenomena from data (Ling et al., 2016; Tompson et al., 2017; Morton et al., 2018). An important aspect of learning physics with neural networks is the choice of representation. Lagrangian representations based on particles are particularly popular and have supported recent results with rigid bodies, deformable solids, and fluids (Battaglia et al., 2016; Mrowca et al., 2018; Li et al., 2019). Many of these approaches use graph structures to define interactions; the existence of an edge determines in a binary fashion whether two particles interact. ",
+        "bbox": [
+            174,
+            470,
+            825,
+            583
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "However, a wide range of physical processes such as fluid mechanics are described by continuous partial differential equations rather than discrete graph structures. The continuous, volumetric, and tightly coupled nature of these processes causes inherent difficulties for graph-based approaches, such as a large number of edge connections that must be established, tracked, and disengaged as the particles move. In this work, instead of using graphs as the underlying representation, we adopt a continuous viewpoint. We propose to use convolutional networks (ConvNets) with continuous convolutions on particles for learning fluid mechanics. We treat fluids as spatially continuous functions sampled at a finite set of (continuously evolving) positions and process them with a novel continuous convolution layer. This matches the continuous nature of the problem more closely and simplifies the definition of neural networks by abstracting the underlying particle representation. ",
+        "bbox": [
+            174,
+            589,
+            825,
+            728
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "We extend the grid-based filter representation commonly used for discrete convolutions to the continuous domain by simple linear interpolation. Linear interpolation of the filters allows efficient lookup of spatially varying filter values at arbitrary positions while retaining the compactness and efficiency of the grid representation. In addition, we use a window function to define the support of the filters and a ball-to-cube mapping to support spherical receptive fields. We show that our convolutions, despite their simplicity, perform better than more sophisticated representations (Wang et al., 2018; Schenck & Fox, 2018). ",
+        "bbox": [
+            174,
+            736,
+            825,
+            833
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "With the presented continuous convolution layer, we develop an efficient ConvNet architecture for learning fluid mechanics. The network processes sets of particles. We use dynamic particles to represent the fluid and static particles to describe the boundary of the scene. Modeling the scene boundary with particles makes it easy to apply our network to new scenes and allows the network to learn collision handling in a unified framework. Our network generalizes to arbitrary obstacle configurations and can simulate a range of material behavior. To demonstrate the usefulness of a learned – and hence differentiable – fluid simulator, we show that material properties can be estimated from observed simulation data. Experimental results indicate that the presented approach outperforms a state-of-the-art graph-based framework (Li et al., 2019). ",
+        "bbox": [
+            174,
+            840,
+            825,
+            922
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            103,
+            823,
+            146
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2 RELATED WORK ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            166,
+            344,
+            183
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Fluids encompass a range of materials that are important in everyday life and throughout science and engineering (Wilcox, 2006). A prominent set of methods, known as Smoothed Particle Hydrodynamics (SPH), employs a Lagrangian viewpoint to simulate these phenomena. SPH originated in particle-based models for astrophysics (Gingold & Monaghan, 1977) and has become extremely popular for simulating complex flows in many fields of science (Monaghan, 1988). Among others, it has been highly successful for modeling interface flows (Colagrossi & Landrini, 2003), complex multi-phase phenomena (Hu & Adams, 2006), and even magnetohydrodynamics (Price, 2012). ",
+        "bbox": [
+            174,
+            198,
+            825,
+            295
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "SPH and its variants have been widely used to model complex real-world phenomena for visual effects. Following the earlier development of physics-based fluid simulation for special effects by Foster & Metaxas (1996), the introduction of SPH (Muller et al., 2003) has led to a large class of ¨ powerful algorithms (Solenthaler & Pajarola, 2009; Bender & Koschier, 2015). These applications often involve complex geometries at large scales, and extensions such as FleX (Macklin et al., 2014) and pressure-aware rigid-body coupling (Gissler et al., 2018) broaden the framework to encompass many physical phenomena. ",
+        "bbox": [
+            174,
+            301,
+            825,
+            400
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Lagrangian flows have also been considered in machine learning. The pioneering work of Ladicky´ et al. (2015) demonstrated that flow representations can be learned with regression forests. CNNs were used by Tompson et al. (2017) to accelerate the expensive pressure correction step of gridbased solvers, while other works have focused on super-resolution (Xie et al., 2018), learning time evolution via the Koopman operator (Morton et al., 2018), and learning reduced representations (Wiewel et al., 2019; Kim et al., 2019). Differentiable SPH solvers were proposed to solve control tasks for robotic applications (Schenck & Fox, 2018). Generic physics simulations for Lagrangian rigid and deformable bodies were considered in a series of works that developed graph-based representations (Battaglia et al., 2016; Sanchez-Gonzalez et al., 2018). Such graph-based representations were recently applied directly to fluid simulation (Mrowca et al., 2018; Li et al., 2019). We share with these recent works the goal of modeling Lagrangian fluids with differentiable neural networks, but take a different tack: rather than using graph-based representations, we work with point clouds and continuous convolutions over the spatial domain. ",
+        "bbox": [
+            174,
+            406,
+            825,
+            587
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "From a technical perspective, our approach is also related to existing works that apply convolutions on point clouds. A number of methods transferred the convolution concept to point clouds in the context of semantic classification and segmentation of 3D objects (Hua et al., 2018; Atzmon et al., 2018; Hermosilla et al., 2018; Li et al., 2018; Su et al., 2018; Wu et al., 2019; Xu et al., 2018; Lei et al., 2019). Particularly notable in our context is the work of Wang et al. (2018), who used continuous convolutions to compute the scene flow between two point clouds, and the aforementioned work of Schenck & Fox (2018), who used convolutions to implement a differentiable version of position-based fluids (Macklin & Muller, 2013). Both works define continuous convolution opera- ¨ tors that can support regression tasks and we compare to them directly in Section 6. Most closely related to our filter representation is the work of Fey et al. (2018). They use B-splines to define continuous filters and propose to use spherical coordinates to implement spherical receptive fields. Spherical coordinates are problematic due to singularities and require special treatment, which we avoid with a ball-to-cube mapping. Furthermore, the output of the operator of Fey et al. (2018) can be discontinuous. We show in our ablation study in Section 6 that applying a window function to guarantee a continuous output is advantageous for our task. ",
+        "bbox": [
+            174,
+            594,
+            825,
+            803
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "3 BASICS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            821,
+            267,
+            838
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Fluids have been studied for centuries, and the Navier-Stokes equations for incompressible fluids are well established (Batchelor, 1967): ",
+        "bbox": [
+            173,
+            854,
+            823,
+            883
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "equation",
+        "img_path": "images/f62c11fc6d8654ce936a85df16ce2aebb397081349fcd885f121f92584c06c35.jpg",
+        "text": "$$\n\\frac { \\partial { \\bf v } } { \\partial t } + { \\bf v } \\cdot \\nabla { \\bf v } = - \\frac { 1 } { \\rho } \\nabla p + \\nu \\nabla ^ { 2 } { \\bf v } + { \\bf g } , ~ \\mathrm { s . t . } ~ \\nabla \\cdot { \\bf v } = 0 .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            312,
+            888,
+            684,
+            922
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "A common approach to solve these partial differential equations is to approximate the fluid with a set of smooth particles (Monaghan, 1988). Each particle corresponds to a continuous blob of matter and carries the local properties of the fluid, such as velocity and density, which move with the flow. This is motivated by the fact that a function $A ( \\mathbf { x } )$ can be represented by an integral interpolation ",
+        "bbox": [
+            174,
+            103,
+            825,
+            160
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/29639995ca24b1f07b84fc1774a0a9b95938e7d1af664fad9e840698e3f7dac9.jpg",
+        "text": "$$\nA ( \\mathbf { x } ) = \\int A ( \\mathbf { x } ^ { \\prime } ) \\delta ( \\| \\mathbf { x } - \\mathbf { x } ^ { \\prime } \\| _ { 2 } ) d V ( \\mathbf { x } ^ { \\prime } ) ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            369,
+            165,
+            629,
+            196
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "where $\\delta ( x )$ denotes the Dirac delta function. This equation can be discretized as ",
+        "bbox": [
+            174,
+            202,
+            699,
+            217
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/1537cc6f7a4d34de813a523739d397a62be3b7f64b6733aa6130a7707b14c417.jpg",
+        "text": "$$\nA ( { \\bf x } ) \\approx \\sum _ { i } V _ { i } A _ { i } W ( \\| { \\bf x } - { \\bf x } ^ { \\prime } \\| _ { 2 } , h ) ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            379,
+            222,
+            617,
+            256
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "where $V _ { i }$ is the volume at the given point in space and ",
+        "bbox": [
+            173,
+            258,
+            529,
+            273
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/8e1546dc9f63d548652b1b24645bd2db363f7d895c24c6571d87694e7b047480.jpg",
+        "text": "$$\n\\operatorname* { l i m } _ { h \\to 0 } W ( | \\mathbf x - \\mathbf x ^ { \\prime } | , h ) = \\delta ( | \\mathbf x - \\mathbf x ^ { \\prime } | ) .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            382,
+            279,
+            617,
+            303
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Here $W ( x , h )$ is a smooth kernel or convolution with radius $h$ , usually in the form of a Gaussian distribution, but more complex functions can also be used. In practice, the kernel is finite and yields localized neighborhoods of particles that interact via interactions weighted by the kernel of its derivatives. In this way, the continuous description for fluids from Equation 1 can be discretized in a Lagrangian fashion and solved numerically. Typically, internal forces are calculated based on the local pressure, viscosity, and surface tension, which give an update for the position of each particle. Below, we adopt the position-based fluids (PBF) method (Macklin & Muller, 2013; Macklin et al., ¨ 2014), which likewise is based on SPH, but reformulates the updates as constraints on the positions. ",
+        "bbox": [
+            173,
+            306,
+            825,
+            420
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "4 CONTINUOUS CONVOLUTIONS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            439,
+            460,
+            455
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "The discrete convolution operator as commonly used in ConvNets is defined as ",
+        "bbox": [
+            173,
+            469,
+            691,
+            484
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/d4b7a40278e200fdf0ab4f0273d5f875ccfc0f63b7b4ede42784ad7fe40da696.jpg",
+        "text": "$$\n( f * g ) ( \\mathbf { x } ) = \\sum _ { \\tau \\in \\Omega } f ( \\mathbf { x } + \\pmb { \\tau } ) g ( \\pmb { \\tau } ) ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            387,
+            489,
+            609,
+            523
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "where $f$ and $g$ are the input and the filter function, $\\mathbf { x }$ is the position, $\\tau$ is the shift vector, and $\\Omega$ is the set of shift vectors that defines the support of the filter function. On regular data such as images, the positions $\\mathbf { x }$ range over a regular grid and the shift vectors $\\tau$ are integer-valued, i.e. $\\mathbf { x } , \\tau \\in \\overline { { \\mathbb { Z } } } ^ { \\dot { d } }$ for some dimensionality $d$ . Analogously in the continuous domain, this convolution is defined as ",
+        "bbox": [
+            173,
+            527,
+            825,
+            584
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/28c85f075557687d7b53613b197377dc8b149b3ad89f025949247145e5abfe69.jpg",
+        "text": "$$\n( f * g ) ( \\mathbf { x } ) = \\int _ { \\mathbb { R } ^ { d } } f ( \\mathbf { x } + \\pmb { \\tau } ) g ( \\pmb { \\tau } ) d \\pmb { \\tau } ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            379,
+            588,
+            619,
+            622
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "where $\\mathbf { x }$ and $\\tau$ are real-valued vectors, i.e. $\\mathbf { x } , \\tau \\in \\mathbb { R } ^ { d }$ . ",
+        "bbox": [
+            173,
+            627,
+            527,
+            642
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "We now adapt this definition to unstructured point clouds. In this setting we have a finite number of points that sample the function $f$ but do not lie on a grid. For a point cloud with $i = 1 , . . , N$ points with values $f _ { i }$ at positions $\\mathbf { x } _ { i }$ , we define the convolution at position $\\mathbf { x }$ as ",
+        "bbox": [
+            173,
+            648,
+            826,
+            691
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/e94be402437224ee1c6d5a016fc3b11b25d90a6c3ebb8edcc88682a265d036d8.jpg",
+        "text": "$$\n( f * g ) ( \\mathbf { x } ) = \\frac { 1 } { \\psi ( \\mathbf { x } ) } \\sum _ { i \\in N ( \\mathbf { x } , R ) } a ( \\mathbf { x } _ { i } , \\mathbf { x } ) \\ f _ { i } \\ g ( \\Lambda ( \\mathbf { x } _ { i } - \\mathbf { x } ) ) .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            315,
+            695,
+            681,
+            736
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "$\\mathcal { N } ( { \\bf x } , R )$ is the set of points within a radius $R$ around $\\ \\textbf { x } , \\ a$ is a scalar function that can be used for density normalization specific to the points $\\mathbf { x } _ { i }$ and $\\mathbf { x }$ as in Hermosilla et al. (2018). In the simplest case, $a$ can be constant: $a = 1$ . In our case we want to ensure a smooth response of our convolution under varying particle neighborhoods, therefore we define $a$ as a window function: ",
+        "bbox": [
+            173,
+            741,
+            826,
+            797
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/c70e6362e5ffd3aa0e8ff1fd1f3216a39448f51c8ed9383b57d4896636ca9aed.jpg",
+        "text": "$$\na ( \\mathbf x _ { i } , \\mathbf x ) = \\left\\{ \\begin{array} { l l } { \\left( 1 - \\frac { \\| \\mathbf x _ { i } - \\mathbf x \\| _ { 2 } ^ { 2 } } { R ^ { 2 } } \\right) ^ { 3 } } & { \\mathrm { f o r } \\| \\mathbf x _ { i } - \\mathbf x \\| _ { 2 } < R } \\\\ { 0 } & { \\mathrm { e l s e } . } \\end{array} \\right.\n$$",
+        "text_format": "latex",
+        "bbox": [
+            325,
+            801,
+            671,
+            847
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "A similar function has been used by Muller et al. (2003) in the SPH framework. ¨ $\\psi$ is another scalar function for normalization, which can be set in our implementation as either ",
+        "bbox": [
+            173,
+            852,
+            821,
+            881
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/693dc2c67962a6cbc0c480d2a9497b9d3415ea09a25f6e897095817b1ef2e792.jpg",
+        "text": "$$\n\\psi ( \\mathbf { x } ) = 1 \\quad \\mathrm { o r } \\quad \\psi ( \\mathbf { x } ) = \\sum _ { i \\in \\mathcal { N } ( \\mathbf { x } , R ) } a ( \\mathbf { x } _ { i } , \\mathbf { x } ) .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            356,
+            885,
+            643,
+            921
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "image",
+        "img_path": "images/41d3bbef3523f4805a96413e83be032ac332d44c48e7e858354dea8d7359abbc.jpg",
+        "image_caption": [
+            "Figure 1: We use spherical filter shapes for our continuous convolutions but use regular grids to store the filter values. The left part of the figure shows a spherical region with radius $R$ and a point with relative coordinates r with respect to the center. We transform r via a mapping $\\Lambda$ to normalized coordinates in a regular grid. The thin dotted lines illustrate the distortion of the mapping. To look up the final filter value we use trilinear interpolation in the regular grid. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            333,
+            98,
+            663,
+            194
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "We use $\\psi ( \\mathbf { x } ) = 1$ , since changes in the density of particles are an important feature for simulating fluids. ",
+        "bbox": [
+            173,
+            290,
+            823,
+            319
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "For the filter function $g$ we simply use a regular grid to store the filter values but use linear interpolation to make $g$ a continuous function. In addition, we use a mapping $\\Lambda ( \\mathbf { r } )$ of a unit ball to a unit cube to implement spherical filters as shown in Figure 1. We use the mapping described by Griepentrog et al. (2008) and give the detailed function in the appendix. The intermediate coordinate mapping $\\Lambda$ provides the flexibility to implement different spatial shapes while keeping the advantages of a regular grid for the storage and lookup of filter values. ",
+        "bbox": [
+            173,
+            325,
+            825,
+            410
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Note that Equation 7 uses a similar approximation as in the SPH framework (Equation 3). Assuming that each point represents the same volume, $V _ { i }$ is a constant factor in Equation 3, which we drop in our definition. ",
+        "bbox": [
+            174,
+            416,
+            825,
+            458
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "5 LEARNING FLUID MECHANICS WITH CONVOLUTIONAL NETWORKS ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            477,
+            767,
+            494
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Our goal is to learn fluid mechanics from observing the motion of particles. The input to our ConvNet is a set of particles with corresponding features. Since position itself is not a feature but simply defines the particle’s position in space, we must assign a feature vector to each particle. The feature vector we use is a constant scalar 1 accompanied by the velocity $\\mathbf { v }$ and the viscosity $\\nu$ . A particle $p _ { i } ^ { n }$ at timestep $n$ with its position and input feature vector is thus a tuple $\\left( \\mathbf { x } _ { i } ^ { n } , \\left[ 1 , \\mathbf { v } _ { i } ^ { n } , \\nu _ { i } \\right] \\right)$ . Defining the velocity explicitly as an input feature allows us to compute intermediate velocities and positions as in Ladicky et al. (2015) and to apply external forces and pass this information to the ´ network. We compute the intermediate positions $\\mathbf { x } _ { i } ^ { n * }$ and velocities $\\mathbf { v } _ { i } ^ { n * }$ beginning with timestep $n$ with Heun’s method as ",
+        "bbox": [
+            173,
+            507,
+            825,
+            633
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/e93a69e232444685aa2cfb34b7e030f80dd5e82f78dd5ac3d4928f5560a8805d.jpg",
+        "text": "$$\n\\begin{array} { r l } & { \\mathbf { v } _ { i } ^ { n * } = \\mathbf { v } _ { i } ^ { n } + \\Delta t \\mathbf { a } _ { \\mathrm { e x t } } } \\\\ & { \\mathbf { x } _ { i } ^ { n * } = \\mathbf { x } _ { i } ^ { n } + \\Delta t \\frac { \\mathbf { v } _ { i } ^ { n } + \\mathbf { v } _ { i } ^ { n * } } { 2 } . } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            405,
+            636,
+            591,
+            686
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "The vector $\\mathbf { a } _ { \\mathrm { e x t } }$ is an acceleration through which we can apply external forces to control the fluid or to simply apply gravity. The intermediate positions and velocities lack any interactions between particles or the scene, which we are going to implement with a ConvNet. To enable the network to handle collisions with the environment we define a second set of static particles $s _ { j }$ . We sample particles on the boundaries of the scene with normals $\\mathbf { n } _ { j }$ as the feature vectors, i.e. $s _ { j } ^ { \\mathsf { ^ { \\prime } } } = ( \\mathbf { x } _ { j } , [ \\mathbf { n } _ { j } ] )$ . Our network implements the function ",
+        "bbox": [
+            173,
+            686,
+            825,
+            770
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/726e30ca76055a9de6baf40fa0e695479f369277761c9f8d8ea904cdf9715c02.jpg",
+        "text": "$$\n[ \\Delta { \\bf x } _ { 1 } , \\ldots , \\Delta { \\bf x } _ { N } ] = \\mathrm { C o n v N e t } ( \\{ p _ { 1 } ^ { n * } , \\ldots , p _ { N } ^ { n * } \\} , \\{ s _ { 1 } , \\ldots , s _ { M } \\} ) ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            290,
+            773,
+            705,
+            791
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "which uses convolutions to combine features from both particle sets. $\\Delta \\mathbf { x }$ is a correction of the position which accounts for all particle interactions including the collision handling with the scene. Finally, we apply the correction to update positions and velocities for $n + 1$ as ",
+        "bbox": [
+            174,
+            792,
+            825,
+            835
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/d5444451d496a763391bfc800b403deaa06633af231c69c4afa03b638c6934f2.jpg",
+        "text": "$$\n\\begin{array} { r l } & { \\mathbf { x } _ { i } ^ { n + 1 } = \\mathbf { x } _ { i } ^ { n * } + \\Delta \\mathbf { x } _ { i } } \\\\ & { \\mathbf { v } _ { i } ^ { n + 1 } = \\frac { \\mathbf { x } _ { i } ^ { n + 1 } - \\mathbf { x } _ { i } ^ { n } } { \\Delta t } . } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            426,
+            835,
+            571,
+            890
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Note that the updated position $\\mathbf { x } _ { i } ^ { n + 1 }$ depends on the output vector $\\Delta { { \\bf { x } } _ { i } }$ and allows us to directly define our learning objective on the particle positions. ",
+        "bbox": [
+            171,
+            892,
+            823,
+            921
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "image",
+        "img_path": "images/2b448c62ece1345a05c8277b267b6df08bffec896e1811b20a9b37b056073ce5.jpg",
+        "image_caption": [
+            "Figure 2: Schematic of our network with a depth of four. In the first depth level we compute convolutions at each dynamic particle location with the set of static particles that defines the environment as well as the dynamic particle set. We also directly process the features of each particle via a fully-connected stream. In the following levels, we compute convolutions only on the dynamic particles. At each level we use addition to aggregate the features computed by convolutions and fully-connected layers. Between the second and third level we also include a residual connection. The final level generates the position correction $\\Delta \\mathbf { x }$ . Operations annotated with a \\* are followed by the ReLU activation function. All CConv and FC operations use an additive bias. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            205,
+            98,
+            794,
+            272
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "5.1 NETWORK ARCHITECTURE ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            422,
+            403,
+            436
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "We use a simple convolutional architecture with an effective depth of four. An overview of the network is shown in Figure 2. Since we want to compute the correction for all dynamic particles in our scene, we compute convolutions for the intermediate positions defined in Equation 11. Our network is a sequence of continuous convolutions (CConv), which are defined by an input particle set, the positions at which we want to evaluate the convolution, its filters $G$ , and the radius $R$ . For instance, to describe a convolution on the static particles $s _ { i }$ at intermediate positions $\\mathbf { x } _ { i } ^ { n * }$ we can write ",
+        "bbox": [
+            173,
+            446,
+            825,
+            544
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/12a111dde44769f39f0a09472e5c844f61fbf1219de767cd6cbe7679d530e3df.jpg",
+        "text": "$$\n[ { \\bf f } _ { 1 } , \\ldots , { \\bf f } _ { N } ] = \\mathrm { C C o n v } ( \\{ s _ { 1 } , \\ldots , s _ { M } \\} , [ { \\bf x } _ { 1 } ^ { n * } , \\ldots , { \\bf x } _ { N } ^ { n * } ] , G , R ) ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            297,
+            544,
+            697,
+            560
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "where $\\mathbf { f } _ { i }$ are the computed output features for each position $\\mathbf { x } _ { i } ^ { n * }$ . $G$ is a 5D array storing all filters in the layout [width, height, depth, $\\mathrm { c h } _ { \\mathrm { i n } } , \\mathrm { c h } _ { \\mathrm { o u t } } ]$ . In contrast to discrete convolutions on a regular grid, the spatial filter dimensions here do not define the receptive field but the resolution of the filters. The receptive field depends only on the radius $R$ , which specifies the spatial extent. Throughout our network we use filters with a spatial resolution of [4, 4, 4] and a radius of 4.5 times the particle radius. ",
+        "bbox": [
+            173,
+            563,
+            825,
+            646
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "For convolutions within the dynamic particles we exclude the particle at which we evaluate the convolution and instead process the particle’s own features in a stream of fully-connected layers. After each depth level we then combine the result from the convolutions and the fully-connected layers by addition. This can be interpreted as a convolution with a spatial resolution of $4 \\times 4 \\times 4 + 1$ . We found that this design improves accuracy and allows us to use smaller filters with even sizes (see Table 2). ",
+        "bbox": [
+            173,
+            652,
+            825,
+            738
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "5.2 TRAINING PROCEDURE ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            753,
+            377,
+            768
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "We train our fluid simulation network in supervised fashion based on particle trajectories produced by classic (“ground-truth”) physics simulation. Our loss is defined as follows: ",
+        "bbox": [
+            171,
+            780,
+            823,
+            808
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/221334f321389bee3374221caa1769ccc93a0d41afba961ee350911dbde05be7.jpg",
+        "text": "$$\n\\mathcal { L } ^ { n + 1 } = \\sum _ { i = 1 } ^ { N } \\phi _ { i } \\left. \\mathbf { x } _ { i } ^ { n + 1 } - \\hat { \\mathbf { x } } _ { i } ^ { n + 1 } \\right. _ { 2 } ^ { \\gamma } .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            383,
+            814,
+            614,
+            857
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "The ground-truth position at timestep $n + 1$ is denoted by $\\hat { \\mathbf { x } } _ { i } ^ { n + 1 }$ and the predicted position from the network is denoted by $\\mathbf { x } _ { i } ^ { n + 1 } = \\mathbf { x } _ { i } ^ { n * } + \\Delta \\mathbf { x } _ { i }$ , where $\\Delta { { \\bf { x } } _ { i } }$ is provided by the network. $\\phi _ { i }$ is an individual weight for each point. We use $\\begin{array} { r } { \\phi _ { i } = \\exp ( - \\frac { 1 } { c } | \\mathcal { N } ( \\mathbf { x } _ { i } ^ { n * } ) | ) } \\end{array}$ , which emphasizes the loss for particles with fewer neighbors. We choose $c = 4 0$ , which corresponds to the average number of neighbors across our experiments. Particles with few neighbors are close to the surface or interact with the scene boundary. Both cases are important for fluid simulation because particles near the surface define the liquid-air interface, which is particularly salient, and particles near the scene boundary require collision handling. The parameter $\\gamma = 0 . 5$ makes our loss function more sensitive to small particle motions, which is important for increasing the accuracy and visual fidelity for small fluid flows. During training we predict particle positions for two future timesteps, namely $n + 1$ and $n + 2$ . The combined loss $\\mathcal { L }$ is ",
+        "bbox": [
+            174,
+            863,
+            825,
+            924
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "image",
+        "img_path": "images/e4a49216268a94b12eb5035a2162f35f2734226af166947401897668e3d0ec91.jpg",
+        "image_caption": [
+            "Figure 3: Comparison to ground-truth physics simulation. Two fluid bodies collide. Top: simulation by our trained network. Bottom: simulation of the same scenario by DFSPH (Bender & Koschier, 2015), a high-fidelity solver that was executed with small timesteps (down to 0.001s). Despite using a much larger timestep (0.02s), our convolutional network produces results of comparable visual fidelity. Note that our particles are falling slightly more slowly due to differences in the integration of positions and the much larger timestep. See the supplementary video. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            179,
+            99,
+            816,
+            246
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            369,
+            825,
+            467
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "equation",
+        "img_path": "images/0e35a81a32d630f1310e81a6cce1d82825399c041ec33f32035f309ff40c85f5.jpg",
+        "text": "$$\n{ \\mathcal { L } } = { \\mathcal { L } } ^ { n + 1 } + { \\mathcal { L } } ^ { n + 2 } .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            431,
+            465,
+            566,
+            483
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "We found that optimizing a loss defined over two frames improves the overall quality of the simulation. (Optimization for three frames did not result in further improvements.) We optimize $\\mathcal { L }$ over 50,000 iterations with Adam (Kingma & Ba, 2015) and a learning rate decay with multiple steps, starting with a learning rate of 0.001 and stopping with $1 . 5 6 \\cdot 1 0 ^ { - 5 }$ . ",
+        "bbox": [
+            174,
+            487,
+            823,
+            542
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "5.3 DATASETS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            559,
+            287,
+            574
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "We have trained our network on multiple datasets. For quantitative comparisons with prior work we trained our network on the dam break data from Li et al. (2019). The scene simulates the behavior of a randomly placed fluid block in a static box. We generate 2000 scenes for training and 300 for testing. The data was generated with FleX, which is a position-based simulator that targets real-time applications (Macklin et al., 2014). ",
+        "bbox": [
+            174,
+            585,
+            825,
+            656
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "We also trained our network on more challenging data generated with DFSPH (Bender & Koschier, 2015), which prioritizes simulation fidelity over runtime. DFSPH can generate accurate fluid flows with very low volume compression: a desired property. We generate ground-truth data by randomly placing multiple bodies of fluid in 10 different box-like scenes and simulating them for 16 seconds each with an adaptive timestep of up to $1 \\mathrm { k H z }$ . The time resolution of the generated data is $5 0 \\mathrm { { H z } }$ . We show a qualitative comparison of our method to the ground truth in Figure 3. We generate 200 scenes for training and 20 scenes for the test set. To train networks that can deal with multiple materials, we additionally generate 200 scenes with fluids of varying viscosity. For estimating material properties, we generate 7 test scenes that only differ in the viscosity parameter. ",
+        "bbox": [
+            174,
+            662,
+            825,
+            789
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "6 EVALUATION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            809,
+            313,
+            824
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Baselines. We compare our method to DPI-Nets (Li et al., 2019), which were previously shown to significantly outperform prior formulations such as hierarchical relation networks (Mrowca et al., 2018). Figure 4 provides a qualitative comparison. Quantitative results are reported in Table 1. To analyze the accuracy of the forward step for each method, we compute the average error of the particle positions with respect to the ground truth. We use every $5 ^ { \\mathrm { t h } }$ frame for initialization and compute the deviation from the ground truth for two subsequent frames, denoted by $n + 1$ and $n + 2$ . ",
+        "bbox": [
+            174,
+            839,
+            825,
+            924
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "image",
+        "img_path": "images/15026580939376a905379a68fddd2924ccbf3b0b80a48da70f72cb01cd59ec0d.jpg",
+        "image_caption": [
+            "Figure 4: Qualitative comparison with DPI-Nets on a test sequence from our dataset. Two fluid bodies collide inside a container. DPI-Nets works well on data with little variance but has problems with more complex scenes and high particle velocities. The DPI-Nets simulation becomes unstable immediately after the fluid hits the box. The fluid behavior predicted by our network matches the ground truth more closely and remains stable for the whole sequence. The two networks have been trained on the same data. Test sequences are distinct from training sequences. See the supplementary video. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            176,
+            101,
+            820,
+            285
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "In addition, we report the average distance from the ground-truth particles to the closest particle in the prediction for the whole sequence, to measure long-term similarity. We compute the distance for frame $n$ as ",
+        "bbox": [
+            173,
+            422,
+            825,
+            464
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "equation",
+        "img_path": "images/30e570848d6cdd9fbec7b1227af2c79db7659c49d66f357c34d1577f949a5ace.jpg",
+        "text": "$$\nd ^ { n } = \\frac { 1 } { N } \\sum _ { i = 1 } ^ { N } \\operatorname* { m i n } _ { \\mathbf { x } ^ { n } \\in X ^ { n } } \\| \\hat { \\mathbf { x } } _ { i } ^ { n } - \\mathbf { x } ^ { n } \\| _ { 2 } ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            385,
+            463,
+            611,
+            507
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "where $X ^ { n }$ is the set of predicted particle positions for frame $n$ , $\\hat { \\mathbf { x } } _ { i } ^ { n }$ is the ground-truth position for particle $i$ , and $N$ is the number of particles. ",
+        "bbox": [
+            173,
+            512,
+            823,
+            541
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "We also compare our continuous convolution formulation to continuous convolution representations used in SPNets (Schenck & Fox, 2018), PCNN (Wang et al., 2018), KPConv (Thomas et al., 2019), and SplineCNN (Fey et al., 2018). To this end, we plug the respective convolution operators into our network architecture as shown in Figure 2. This facilitates controlled comparisons in which the overall architecture and simulation setup are fixed and only the convolution operators are varied. As shown in Table 1, our method outperforms all baselines with respect to both accuracy and inference time. ",
+        "bbox": [
+            174,
+            547,
+            825,
+            645
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "We have trained and tested all methods on the dam break dataset from Li et al. (2019) as well as our data (generated with a high-fidelity simulator (Bender & Koschier, 2015)). To facilitate the training on our data for all methods, we generated a simplified version with a constant number of particles (6,000) and a single box environment (as shown in Figure 4). We train DPI-Nets for 5 epochs and all other networks for 50,000 iterations, which corresponds to 2.7 epochs for the dam break data and 5 epochs for our data. Training takes about a day for our method with our convolutions on an NVIDIA RTX 2080Ti. Training with PCNN convolutions (Wang et al., 2018) takes about 2 days on 4 GPUs. Note that our reimplementation of PCNN convolutions uses Tensorflow’s built-in functions, which consume a lot of memory and necessitate multi-GPU training. The DPI-Nets model trains in about one day. Training with SplineCNN Convs takes 3 to 4 days on a single GPU. We got the best results for this method with spherical kernel coordinates and closed splines. For KPConvs we used a Quadro RTX 6000 with $2 4 \\mathrm { \\ G B }$ of RAM due to the higher memory requirements. Training took about 1 day with 15 kernel points. For SPNets convolutions, we estimated a training time of more than 29 days with $3 \\times 3 \\times 3$ filters by extrapolating from timing of a smaller number of iterations. We thus only report inference time for this method. Note that the convolutions of SPNets were designed to implement the position-based fluids algorithm, while we use them here in a more general network architecture with a much larger number of channels, which explains the very long runtime. ",
+        "bbox": [
+            174,
+            652,
+            825,
+            888
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Ablation study. We perform an ablation study to evaluate our decisions in the design of the continuous convolution operator and the network. We study the importance of the interpolation, the window function, the loss design, and the architecture choice. The results are reported in Table 2. This table reports error measures (averaged over the test sequences) that were used in Table 1, and also reports the errors for two predicted frames initialized with the frames at the end of each sequence to measure the errors for small flow velocities. Large errors for small velocities can yield perceptually salient artifacts: rather than being still, fluid particles jitter or churn. ",
+        "bbox": [
+            173,
+            895,
+            821,
+            924
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "table",
+        "img_path": "images/d736599d1c6d394069116182862ea6ac516a501c26417739e9701082b755729e.jpg",
+        "table_caption": [
+            "Table 1: Accuracy and runtime analysis. We compare the average error between the ground-truth particle positions and two predicted future frames on the test set. Additionally, we report the average distance from the ground truth to the prediction over the whole sequence. In this test mode some methods become unstable after a few frames. In the last column we report the average inference time per frame. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=\"2\" colspan=\"2\">Method</td><td colspan=\"2\">Average pos error (mm)</td><td rowspan=\"2\">Average distance to closest point d&quot; (mm)</td><td rowspan=\"2\">Frame inference time (ms)</td></tr><tr><td>n+1</td><td>n+2</td></tr><tr><td></td><td>DPI-Nets</td><td>12.73</td><td>25.38</td><td>22.07</td><td>202.56</td></tr><tr><td></td><td>SPNets Convs</td><td>一</td><td>一</td><td></td><td>1058.46</td></tr><tr><td></td><td>PCNN Convs</td><td>0.72</td><td>1.67</td><td>19.79</td><td>187.34</td></tr><tr><td>RParaasr</td><td>SplineCNN Convs</td><td>0.71</td><td>1.65</td><td>170.20</td><td>67.67</td></tr><tr><td></td><td>KPConv</td><td>2.49</td><td>7.05</td><td>unstable</td><td>47.96</td></tr><tr><td></td><td>Ours</td><td>0.62</td><td>1.49</td><td>16.98</td><td>12.01</td></tr><tr><td></td><td>DPI-Nets</td><td>26.19</td><td>51.77</td><td>unstable</td><td>305.55</td></tr><tr><td></td><td>SPNets Convs</td><td>1</td><td>1</td><td>1</td><td>784.35</td></tr><tr><td>raarae rl gaest</td><td>PCNN Convs</td><td>0.67</td><td>1.87</td><td>32.51</td><td>319.17</td></tr><tr><td></td><td>SplineCNN Convs</td><td>0.68</td><td>1.93</td><td>unstable</td><td>281.92</td></tr><tr><td></td><td>KPConv</td><td>1.65</td><td>4.54</td><td>unstable</td><td>57.89</td></tr><tr><td></td><td>Ours</td><td>0.56</td><td>1.51</td><td>29.50</td><td>16.47</td></tr></table>",
+        "bbox": [
+            184,
+            101,
+            812,
+            306
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            424,
+            825,
+            493
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "table",
+        "img_path": "images/97ad8d39cd0251ffc444682f1b1c30003db2bb91074d4c2a326beed81c0252d6.jpg",
+        "table_caption": [
+            "Table 2: Ablation study. We compare the average error between the ground-truth particle positions and two predicted future frames on the test set, evaluated over whole test sequences (left) and just on the final frames of each test sequence (middle; this focuses on frames with small motion). The rightmost column shows the average distance from the ground truth to the predicted point set over whole test sequences. Ours w/o interpolation uses nearest-neighbor instead of trilinear interpolation for the convolution filters. Ours w/o window uses $a ( \\mathbf { x } _ { i } , \\mathbf { x } ) = 1$ in Equation 7. Ours w/ na¨ıve loss uses Euclidean distance as the loss, i.e. we set $\\gamma = 1$ and $\\phi _ { i } = 1$ in Equation 16. Ours w/o FC uses only convolutions and includes the central particle in the convolution (rather than separately processing its features via an FC layer). "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=\"2\">Method</td><td colspan=\"2\">Average error (mm)</td><td colspan=\"2\">Seq. end error (mm)</td><td rowspan=\"2\">Average distance to closest point d&quot; (mm)</td></tr><tr><td>n+1</td><td>n+2</td><td>n+1</td><td>n+2</td></tr><tr><td>Ours</td><td>0.67</td><td>1.87</td><td>0.25</td><td>0.74</td><td>30.63</td></tr><tr><td>Ours w/o interpolation</td><td>0.79</td><td>2.24</td><td>0.30</td><td>0.89</td><td>32.39</td></tr><tr><td>Ours w/o window</td><td>0.77</td><td>2.21</td><td>0.30</td><td>0.89</td><td>31.77</td></tr><tr><td>Ours w/ naive loss</td><td>0.69</td><td>1.86</td><td>0.27</td><td>0.77</td><td>30.35</td></tr><tr><td>Ours w/o FC</td><td>0.75</td><td>2.17</td><td>0.27</td><td>0.80</td><td>32.49</td></tr></table>",
+        "bbox": [
+            217,
+            529,
+            781,
+            640
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Generalization. In Figure 5 we show that our network generalizes well to scenes with drastically different geometry than seen during training. (The training set uses only box-like containers. See the appendix for visualization.) These scenarios demonstrate that we can emit particles during simulation, which can be costly for methods that build and maintain explicit graph structures. We compare generalization performance quantitatively to DFPSH on a complex scene in Figure 6. Figure 7 demonstrates generalization along a different dimension. Here we show that we can set the viscosity of the fluid at test time to a value not seen during training. The fluid shape used in this example was also not seen during training. ",
+        "bbox": [
+            173,
+            811,
+            825,
+            924
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "image",
+        "img_path": "images/e67c7b9cd9fa6a6ff5084b5f367ebe88d096599b3b8339604611780fee048f5f.jpg",
+        "image_caption": [
+            "Figure 5: Generalization to environments with drastically different geometry than seen during training. Top: we use an emitter to fill up a virtual river with fluid particles, demonstrating generalization with respect to scene geometry and the number of particles. Bottom: a waterfall scene showing the fluid particles and the particle representation of the environment. See the supplementary video. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            186,
+            102,
+            812,
+            296
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "image",
+        "img_path": "images/abe4e641cedacda2fe157a71a4d9a67468250b42603b501a7399766755b97762.jpg",
+        "image_caption": [
+            "Figure 6: Average distance from the ground-truth particles to the predicted particles on a complex scene. Top: error over time for our trained network and DFSPH. We use a timestep of $\\Delta t = 5$ ms for DFSPH and $\\Delta t = 2 0 \\mathrm { m s }$ for our method, which also corresponds to the frame sampling rate. The ground truth was generated with DFSPH and a timestep of 1ms. Bottom: simulation produced by our network. Large errors are concentrated in the beginning of the sequence when the fluid initially collides with the environment and the fluid behavior is most chaotic. During this phase the error is higher for our method than DFSPH. After 200 frames the error levels become similar. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            186,
+            397,
+            810,
+            621
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "image",
+        "img_path": "images/61470283b23c7be98c6eab7fcd81861f2b541e055b261fcecfd497d7763d31d3.jpg",
+        "image_caption": [
+            "Figure 7: We can control the viscosity of the simulated fluid at test time by changing the input parameter $\\nu$ in the input feature vector. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            179,
+            750,
+            820,
+            875
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Material estimation. In this experiment we apply our network to an inverse problem: material estimation from observation. We use our network to estimate the viscosity parameter of a fluid from the particle movement. The training data for this experiment contains 200 sequences with random viscosity parameters between 0.01 and 0.3. For testing we generate 5 new sequences with 100 frames and random viscosity within the same range as used during training and use an initial fluid shape not present in the training data. To test generalization we generate two sequences with viscosity values outside the training range, namely 0.35 and 0.4. To estimate the viscosity we backpropagate through the trained network and optimize $\\nu$ with gradient descent. Table 3 reports the results, which indicate that our network can be used to estimate material properties from observed data. ",
+        "bbox": [
+            173,
+            103,
+            825,
+            242
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "table",
+        "img_path": "images/3ffd6888393460e0f3071ac858e5b10995c3ffcd2dd388702c4ae06e5a628074.jpg",
+        "table_caption": [],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>GT viscosity</td><td>0.044</td><td>0.127</td><td>0.174</td><td>0.233</td><td>0.269</td><td>0.350</td><td>0.400</td><td>Mean</td></tr><tr><td>Avg. estimated viscosity</td><td>0.027</td><td>0.150</td><td>0.202</td><td>0.255</td><td>0.277</td><td>0.322</td><td>0.336</td><td></td></tr><tr><td>Avg. relative error (%)</td><td>38.377</td><td>18.542</td><td>15.604</td><td>9.568</td><td>3.235</td><td>7.954</td><td>16.016</td><td>15.614</td></tr></table>",
+        "bbox": [
+            176,
+            252,
+            821,
+            306
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Table 3: Application to an inverse problem: material estimation from observed fluid motion. To estimate the viscosity we backpropagate through our network and optimize $\\nu$ with gradient descent. For each scene, we run the procedure 10 times, each time with random initialization, and report the average. Viscosity values 0.350 and 0.400 are outside the range that was used during training and are used to test generalization. ",
+        "bbox": [
+            173,
+            316,
+            825,
+            387
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "7 CONCLUSION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            416,
+            318,
+            433
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "We have developed continuous convolutional networks for Lagrangian fluid simulation. We have introduced a simple formulation for continuous convolutions and demonstrated its accuracy and speed. Our model captures a wide range of complex material behavior, offers long-term stability, and generalizes to new situations such as varying particle counts, domain geometries, and material properties. There are numerous directions for future work, such as extending the framework to incorporate rigid and deformable solids. We will release the code to facilitate such development. Our continuous convolution implementation will be made available as part of Open3D (Zhou et al., 2018). ",
+        "bbox": [
+            174,
+            448,
+            825,
+            559
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Acknowledgements. We thank Jan Bender for his support with the SPlisHSPlasH framework. ",
+        "bbox": [
+            173,
+            574,
+            800,
+            589
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "REFERENCES ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            609,
+            285,
+            626
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Matan Atzmon, Haggai Maron, and Yaron Lipman. Point convolutional neural networks by extension operators. ACM Trans. Graph., 37(4), 2018. ",
+        "bbox": [
+            173,
+            633,
+            823,
+            661
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "George K. Batchelor. An Introduction to Fluid Dynamics. Cambridge University Press, 1967. ",
+        "bbox": [
+            173,
+            670,
+            787,
+            685
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Peter W. Battaglia, Razvan Pascanu, Matthew Lai, Danilo Rezende, and Koray Kavukcuoglu. Interaction networks for learning about objects, relations and physics. In Advances in Neural Information Processing Systems, 2016. ",
+        "bbox": [
+            173,
+            694,
+            823,
+            736
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Jan Bender and Dan Koschier. Divergence-free smoothed particle hydrodynamics. In Symposium on Computer Animation, 2015. ",
+        "bbox": [
+            173,
+            744,
+            823,
+            773
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Andrea Colagrossi and Maurizio Landrini. Numerical simulation of interfacial flows by smoothed particle hydrodynamics. Journal of Computational Physics, 191(2), 2003. ",
+        "bbox": [
+            174,
+            782,
+            821,
+            811
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Matthias Fey, Jan Eric Lenssen, Frank Weichert, and Heinrich Muller. SplineCNN: Fast geometric ¨ deep learning with continuous B-spline kernels. In CVPR, 2018. ",
+        "bbox": [
+            173,
+            820,
+            821,
+            849
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Nick Foster and Dimitris N. Metaxas. Realistic animation of liquids. Graphical Models and Image Processing, 58(5), 1996. ",
+        "bbox": [
+            176,
+            858,
+            821,
+            886
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Robert A Gingold and Joseph J Monaghan. Smoothed particle hydrodynamics: Theory and application to non-spherical stars. Monthly Notices of the Royal Astronomical Society, 181(3), 1977. ",
+        "bbox": [
+            173,
+            895,
+            820,
+            924
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Christoph Gissler, Andreas Peer, Stefan Band, Jan Bender, and Matthias Teschner. Interlinked SPH pressure solvers for strong fluid-rigid coupling. ACM Trans. Graph., 38(1), 2018. ",
+        "bbox": [
+            171,
+            103,
+            823,
+            133
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Jens Andre Griepentrog, Wolfgang H ´ oppner, Hans-Christoph Kaiser, and Joachim Rehberg. A bi- ¨ Lipschitz continuous, volume preserving map from the unit ball onto a cube. Note di Matematica, 28, 2008. ",
+        "bbox": [
+            173,
+            140,
+            821,
+            183
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Pedro Hermosilla, Tobias Ritschel, Pere-Pau Vazquez, ´ Alvar Vinacua, and Timo Ropinski. Monte \\` Carlo convolution for learning on non-uniformly sampled point clouds. ACM Trans. Graph., 37 (6), 2018. ",
+        "bbox": [
+            174,
+            191,
+            823,
+            234
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Xiang Yu Hu and Nikolaus A Adams. A multi-phase SPH method for macroscopic and mesoscopic flows. Journal of Computational Physics, 213(2), 2006. ",
+        "bbox": [
+            169,
+            243,
+            825,
+            272
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Binh-Son Hua, Minh-Khoi Tran, and Sai-Kit Yeung. Pointwise convolutional neural networks. In CVPR, 2018. ",
+        "bbox": [
+            173,
+            280,
+            823,
+            310
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Byungsoo Kim, Vinicius C. Azevedo, Nils Thuerey, Theodore Kim, Markus Gross, and Barbara Solenthaler. Deep fluids: A generative network for parameterized fluid simulations. Computer Graphics Forum, 38(2), 2019. ",
+        "bbox": [
+            176,
+            318,
+            823,
+            361
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Diederik P. Kingma and Jimmy Ba. Adam: A method for stochastic optimization. In ICLR, 2015. ",
+        "bbox": [
+            173,
+            369,
+            810,
+            386
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "L’ubor Ladicky, SoHyeon Jeong, Barbara Solenthaler, Marc Pollefeys, and Markus Gross. Data- ´ driven fluid simulations using regression forests. ACM Trans. Graph., 34(6), 2015. ",
+        "bbox": [
+            174,
+            393,
+            820,
+            422
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Huan Lei, Naveed Akhtar, and Ajmal Mian. Octree guided CNN with spherical kernels for 3D point clouds. In CVPR, 2019. ",
+        "bbox": [
+            173,
+            430,
+            823,
+            460
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Yangyan Li, Rui Bu, Mingchao Sun, Wei Wu, Xinhan Di, and Baoquan Chen. PointCNN: Convolution on X-transformed points. In Advances in Neural Information Processing Systems, 2018. ",
+        "bbox": [
+            173,
+            468,
+            823,
+            498
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Yunzhu Li, Jiajun Wu, Russ Tedrake, Joshua B. Tenenbaum, and Antonio Torralba. Learning particle dynamics for manipulating rigid bodies, deformable objects, and fluids. In ICLR, 2019. ",
+        "bbox": [
+            174,
+            506,
+            823,
+            536
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Julia Ling, Andrew Kurzawski, and Jeremy Templeton. Reynolds averaged turbulence modelling using deep neural networks with embedded invariance. Journal of Fluid Mechanics, 807, 2016. ",
+        "bbox": [
+            169,
+            542,
+            825,
+            573
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Miles Macklin and Matthias Muller. Position based fluids. ¨ ACM Trans. Graph., 32(4), 2013. ",
+        "bbox": [
+            174,
+            580,
+            782,
+            597
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Miles Macklin, Matthias Muller, Nuttapong Chentanez, and Tae-Yong Kim. Unified particle physics ¨ for real-time applications. ACM Trans. Graph., 33(4), 2014. ",
+        "bbox": [
+            171,
+            604,
+            823,
+            633
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "J Monaghan. An introduction to SPH. Computer Physics Communications, 48(1), 1988. ",
+        "bbox": [
+            171,
+            641,
+            753,
+            659
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Jeremy Morton, Antony Jameson, Mykel J Kochenderfer, and Freddie Witherden. Deep dynamical modeling and control of unsteady fluid flows. In Advances in Neural Information Processing Systems, 2018. ",
+        "bbox": [
+            173,
+            665,
+            825,
+            708
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Damian Mrowca, Chengxu Zhuang, Elias Wang, Nick Haber, Li F Fei-Fei, Josh Tenenbaum, and Daniel L Yamins. Flexible neural representation for physics prediction. In Advances in Neural Information Processing Systems, 2018. ",
+        "bbox": [
+            174,
+            717,
+            825,
+            761
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Matthias Muller, David Charypar, and Markus Gross. Particle-based fluid simulation for interactive ¨ applications. In Symposium on Computer Animation, 2003. ",
+        "bbox": [
+            168,
+            768,
+            823,
+            797
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Daniel J Price. Smoothed particle hydrodynamics and magnetohydrodynamics. Journal of Computational Physics, 231(3), 2012. ",
+        "bbox": [
+            171,
+            805,
+            823,
+            835
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Alvaro Sanchez-Gonzalez, Nicolas Heess, Jost Tobias Springenberg, Josh Merel, Martin A. Riedmiller, Raia Hadsell, and Peter W. Battaglia. Graph networks as learnable physics engines for inference and control. In ICML, 2018. ",
+        "bbox": [
+            173,
+            843,
+            823,
+            887
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Connor Schenck and Dieter Fox. SPNets: Differentiable fluid dynamics for deep neural networks. In Conference on Robot Learning, 2018. ",
+        "bbox": [
+            173,
+            895,
+            820,
+            924
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Barbara Solenthaler and Renato Pajarola. Predictive-corrective incompressible SPH. ACM Trans. Graph., 28(3), 2009. ",
+        "bbox": [
+            173,
+            103,
+            821,
+            132
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Hang Su, Varun Jampani, Deqing Sun, Subhransu Maji, Evangelos Kalogerakis, Ming-Hsuan Yang, and Jan Kautz. SPLATNet: Sparse lattice networks for point cloud processing. In CVPR, 2018. ",
+        "bbox": [
+            173,
+            140,
+            823,
+            170
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Matthias Teschner, Bruno Heidelberger, Matthias Muller, Danat Pomerantes, and Markus H. Gross. ¨ Optimized spatial hashing for collision detection of deformable objects. In Vision, Modeling, and Visualization (VMV), 2003. ",
+        "bbox": [
+            176,
+            178,
+            823,
+            220
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Hugues Thomas, Charles R. Qi, Jean-Emmanuel Deschaud, Beatriz Marcotegui, Franc¸ois Goulette, and Leonidas J. Guibas. KPConv: Flexible and deformable convolution for point clouds. In ICCV, 2019. ",
+        "bbox": [
+            174,
+            229,
+            823,
+            272
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Jonathan Tompson, Kristofer Schlachter, Pablo Sprechmann, and Ken Perlin. Accelerating Eulerian fluid simulation with convolutional networks. In ICML, 2017. ",
+        "bbox": [
+            173,
+            280,
+            823,
+            309
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Shenlong Wang, Simon Suo, Wei-Chiu Ma, Andrei Pokrovsky, and Raquel Urtasun. Deep parametric continuous convolutional neural networks. In CVPR, 2018. ",
+        "bbox": [
+            174,
+            318,
+            823,
+            347
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Steffen Wiewel, Moritz Becher, and Nils Thuerey. Latent space physics: Towards learning the temporal evolution of fluid flow. Computer Graphics Forum, 38(2), 2019. ",
+        "bbox": [
+            174,
+            356,
+            823,
+            385
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "David C Wilcox. Turbulence Modeling for CFD. DCW industries, 3rd edition, 2006. ",
+        "bbox": [
+            174,
+            392,
+            732,
+            409
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Wenxuan Wu, Zhongang Qi, and Fuxin Li. PointConv: Deep convolutional networks on 3D point clouds. In CVPR, 2019. ",
+        "bbox": [
+            173,
+            416,
+            823,
+            445
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "You Xie, Erik Franz, Mengyu Chu, and Nils Thuerey. tempoGAN: A temporally coherent, volumetric GAN for super-resolution fluid flow. ACM Trans. Graph., 37(4), 2018. ",
+        "bbox": [
+            173,
+            453,
+            821,
+            483
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Yifan Xu, Tianqi Fan, Mingye Xu, Long Zeng, and Yu Qiao. SpiderCNN: Deep learning on point sets with parameterized convolutional filters. In ECCV, 2018. ",
+        "bbox": [
+            173,
+            491,
+            823,
+            520
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Qian-Yi Zhou, Jaesik Park, and Vladlen Koltun. Open3D: A modern library for 3D data processing. arXiv:1801.09847, 2018. ",
+        "bbox": [
+            174,
+            529,
+            821,
+            558
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "A APPENDIX ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            583,
+            299,
+            599
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "A.1 IMPLEMENTATION DETAILS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            614,
+            410,
+            628
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "To accelerate the computation of Equation 7 we use existing general matrix multiplication primitives. Similar to standard convolutions in deep learning frameworks we build a matrix with patches that we then multiply with the filter matrix. We can account for the linear interpolation by applying the interpolation to the patch matrix instead of the filters. For 3D point clouds a single point contributes to up to 8 voxels in a patch. ",
+        "bbox": [
+            174,
+            641,
+            825,
+            710
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Another crucial part of our implementation is the nearest neighbor search. Since the positions of the fluid particles update with each timestep, we have to rebuild the neighborhood information for every frame. We implement the neighborhood search with spatial hashing (we use the hash function proposed in Teschner et al. (2003)). We explicitly store all particle neighbors in a compact list, which allows us to reuse the information for multiple convolutions operating on the same point sets. Table 4 compares the average frame runtimes of our method with the baselines. ",
+        "bbox": [
+            174,
+            718,
+            825,
+            801
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "A.2 DATASET GENERATION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            818,
+            379,
+            832
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "To enable generalization to new environments we use 10 different containers (see Figure 8) in our data generation process. During scene generation we randomly sample an environment and place up to 3 fluid bodies with different shapes and sizes (see Figure 9) and random initial velocities in the scene. We simulate each generated scene with DFSPH using the SPlisHSPlasH framework 1 for ",
+        "bbox": [
+            174,
+            844,
+            823,
+            900
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "table",
+        "img_path": "images/708c9b4151c0c00dd851caceef824c423a693063c469c1b1e3477fab2ca7373b.jpg",
+        "table_caption": [],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Method</td><td></td><td>Frame inference time (ms)</td><td>Frame NNS time (ms)</td><td>NNS Method</td></tr><tr><td></td><td>DPI-Nets</td><td>202.56</td><td>103.26</td><td>KD-Tree (SciPy)</td></tr><tr><td>Daraaa</td><td>SPNets Convs</td><td>1058.46</td><td>5.24</td><td>Spatial hashing on GPU</td></tr><tr><td></td><td>PCNN Convs</td><td>187.34</td><td>2.42</td><td>*Spatial hashing on GPU</td></tr><tr><td></td><td>SplineCNN Convs</td><td>67.67</td><td>41.92</td><td>Brute-force on GPU</td></tr><tr><td></td><td>KPConv</td><td>47.96</td><td>28.12</td><td>KD-Tree (nanoflann)</td></tr><tr><td></td><td>Ours</td><td>12.01</td><td>2.14</td><td>* Spatial hashing on GPU</td></tr><tr><td>gaaarae err tar est</td><td>DPI-Nets</td><td>305.55</td><td>171.22</td><td>KD-Tree (SciPy)</td></tr><tr><td></td><td>SPNets Convs</td><td>784.35</td><td>10.19</td><td>Spatial hashing on GPU</td></tr><tr><td></td><td>PCNN Convs</td><td>319.17</td><td>2.78</td><td>* Spatial hashing on GPU</td></tr><tr><td></td><td>SplineCNN Convs</td><td>281.92</td><td>245.52</td><td>Brute-force on GPU</td></tr><tr><td></td><td>KPConv</td><td>57.89</td><td>34.07</td><td>KD-Tree (nanoflann)</td></tr><tr><td></td><td>Ours</td><td>16.47</td><td>2.38</td><td>*Spatial hashing on GPU</td></tr></table>",
+        "bbox": [
+            176,
+            101,
+            823,
+            287
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Table 4: Runtime analysis. We compare the average per frame inference time and the time used for the nearest neighbor search (NNS). Our convolution achieves the shortest inference times in comparison even if NNS times would be excluded. Irrespective of that, the methods used for finding neighbors can have a significant contribution to the total runtime. Since fluid particles are moving, acceleration structures for the neighbor search have to be rebuilt each frame. This affects the KDTree methods as well as the methods using spatial hashing. Note that we use the same NNS for PCNN and Ours (denoted with \\*). For all methods except for SPNets the inference time is shorter on the smaller DPI DamBreak data (3456 particles compared to the 6000 particles of our data). We attribute this to a higher number of neighbors on the DPI DamBreak, which is about 49 on average compared to the average 40 neighbors on our datasets. All runtimes were measured on a system with an Intel Core i9-7960 and an NVIDIA RTX 2080Ti. ",
+        "bbox": [
+            173,
+            296,
+            825,
+            450
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "16 seconds to ensure that each scene contains frames with small particle velocities. To create the particle representation of the box-like containers, we do Poisson-Disc sampling on the mesh surface with the tools provided by DFPSH and add surface normals to each particle. ",
+        "bbox": [
+            173,
+            491,
+            825,
+            534
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "image",
+        "img_path": "images/8d35cce31d9dfd8d41d1ab91b20111ad299e58de888e2118fc1c35b7b0bd9688.jpg",
+        "image_caption": [
+            "Figure 8: We sample from 10 different box-like containers during data generation. For the simplified version of our dataset used in the quantitative comparison with the baselines we only use the first container (leftmost container in the first row). "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            220,
+            570,
+            774,
+            838
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "image",
+        "img_path": "images/d23198eef7fc652a9b841e946779bbeda60a591a9f56f8e201f10920c76328cb.jpg",
+        "image_caption": [
+            "Figure 9: We randomly place fluid bodies of different initial shapes in the scene during data generation. We sample from 5 different shapes and vary the size, the orientation and the initial particle velocity. All particles from the same fluid body start with the same initial velocity. The image shows the particles generated from each shape for a specific size and orientation. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            207,
+            101,
+            790,
+            271
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "table",
+        "img_path": "images/0fb91eb40d3ce7844ead3e2558c7a741c22dfaf617f44436ee33cd7007e4bdaa.jpg",
+        "table_caption": [],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=\"2\">Method</td><td colspan=\"2\">Average error (mm)</td><td colspan=\"2\">Seq. end error (mm)</td><td rowspan=\"2\">Average distance to closest point d (mm)</td></tr><tr><td>n+1</td><td>n+2</td><td>n+1</td><td>n+2</td></tr><tr><td>Ours</td><td>0.67</td><td>1.87</td><td>0.25</td><td>0.74</td><td>30.63</td></tr><tr><td>Ours triangular window</td><td>0.69</td><td>1.94</td><td>0.27</td><td>0.79</td><td>30.28</td></tr><tr><td>Ours w/o window</td><td>0.77</td><td>2.21</td><td>0.30</td><td>0.89</td><td>31.77</td></tr></table>",
+        "bbox": [
+            214,
+            368,
+            784,
+            454
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "Table 5: Comparison of different window functions. Ours uses a window function similar to the poly6 kernel used in Muller et al. (2003). ¨ Ours triangular window uses a triangular window function. Ours w/o window does not use a window function. This case can also be interpreted as a rectangular window since we only consider points within a radius $R$ . ",
+        "bbox": [
+            173,
+            464,
+            826,
+            520
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "A.3 TRAINING DETAILS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            554,
+            354,
+            568
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "We use the Tensorflow framework for implementing the training procedure. We use Adam as optimizer and train with a batch size of 16 and an initial learning rate of 0.001. We half the learning rate at steps 20000, 25000, . . . , 45000. For the convolutions we use the random uniform initializer with range [-0.05, 0.05]. All other weights are initialized with the respective default initializers of Tensorflow version 1.12. The output of the network is scaled with $\\scriptstyle { \\frac { 1 } { 1 2 8 } }$ to roughly adjust the output range to the ground truth position correction of the training data. ",
+        "bbox": [
+            174,
+            583,
+            825,
+            667
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "The unit of length of the training data is meter. The particle radius used in DFSPH is $h = 0 . 0 2 5 \\mathrm { m }$ .   \nFor our convolutions, we use spherical filters with an empirically determined radius of $R = 4 . 5 h$ . ",
+        "bbox": [
+            174,
+            674,
+            823,
+            702
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "A.4 WINDOW FUNCTION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            727,
+            361,
+            741
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "We compare 3 different choices for the window function $a$ from Equation 8 in Table 5. The results show that enforcing a continuous output with a window function yields better results. Further, using a window function similar to kernels used in SPH codes gives better results than a simple triangular window. Learning the window function is therefore a possible direction to extend our framework to further improve the accuracy. ",
+        "bbox": [
+            174,
+            756,
+            825,
+            827
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "A.5 COORDINATE MAPPING FUNCTION",
+        "text_level": 1,
+        "bbox": [
+            178,
+            852,
+            460,
+            866
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "We use the ball to cube mapping described in (Griepentrog et al., 2008) to map a position within a spherical region to the filter values stored in a regular grid. We give here the functions used for the 3-D case as used in our implementation. For more details see (Griepentrog et al., 2008). ",
+        "bbox": [
+            176,
+            882,
+            823,
+            924
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "The function $\\Lambda$ is a composition of the functions $\\Lambda _ { \\mathrm { b a l l  c y l } }$ and $\\Lambda _ { \\mathrm { c y l \\to c u b e } }$ , which map a sphere to a cylinder and a cylinder to a cube respectively. We define $\\Lambda _ { \\mathrm { b a l l  c y l } }$ for vectors ${ \\bf r } = ( x , y , z )$ as ",
+        "bbox": [
+            169,
+            102,
+            826,
+            133
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "equation",
+        "img_path": "images/8471d0836f5de5bd0e5d30fe5fbfd0a1d2273d7f3bd6be515e513076b5106694.jpg",
+        "text": "$$\n\\begin{array} { r } { \\Lambda _ { \\mathrm { b a l l } \\to \\mathrm { c y l } } ( \\mathbf { r } ) = \\left\\{ \\begin{array} { l l } { ( 0 , 0 , 0 ) } & { \\mathrm { i f ~ } \\| \\mathbf { r } \\| _ { 2 } = 0 } \\\\ { \\left( x \\frac { \\| \\mathbf { r } \\| _ { 2 } } { \\| ( x , y ) \\| _ { 2 } } , y \\frac { \\| \\mathbf { r } \\| _ { 2 } } { \\| ( x , y ) \\| _ { 2 } } , \\frac { 3 } { 2 } z \\right) } & { \\mathrm { i f ~ } \\frac { 5 } { 4 } z ^ { 2 } \\leq x ^ { 2 } + y ^ { 2 } } \\\\ { \\left( x \\sqrt { \\frac { 3 \\| \\mathbf { r } \\| _ { 2 } } { \\| \\mathbf { r } \\| _ { 2 } + | z | } } , y \\sqrt { \\frac { 3 \\| \\mathbf { r } \\| _ { 2 } } { \\| \\mathbf { r } \\| _ { 2 } + | z | } } , \\mathrm { s i g n } ( z ) \\| \\mathbf { r } \\| _ { 2 } \\right) } & { \\mathrm { e l s e } . } \\end{array} \\right. } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            235,
+            140,
+            763,
+            208
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "The cylinder to cube mapping is defined as ",
+        "bbox": [
+            174,
+            219,
+            455,
+            236
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "equation",
+        "img_path": "images/f406a4aa0f519837f7b85d11f062882b52332bb326748bdc286669f918ab13a5.jpg",
+        "text": "$$\n\\Lambda _ { \\mathrm { c y l } \\to \\mathrm { c u b e } } ( \\mathbf { r } ) = \\left\\{ \\begin{array} { l l } { ( 0 , 0 , z ) } & { \\mathrm { i f ~ } x = 0 , y = 0 } \\\\ { ( \\mathrm { s i g n } ( x ) \\| ( x , y ) \\| _ { 2 } , \\frac { 4 } { \\pi } \\mathrm { s i g n } ( x ) \\| ( x , y ) \\| _ { 2 } \\mathrm { a r c t a n } \\frac { y } { x } , z ) } & { \\mathrm { i f ~ } | y | \\leq | x | } \\\\ { \\left( \\frac { 4 } { \\pi } \\mathrm { s i g n } ( y ) \\| ( x , y ) \\| _ { 2 } \\mathrm { a r c t a n } \\frac { x } { y } , \\mathrm { s i g n } ( y ) \\| ( x , y ) \\| _ { 2 } , z \\right) } & { \\mathrm { e l s e } . } \\end{array} \\right.\n$$",
+        "text_format": "latex",
+        "bbox": [
+            192,
+            242,
+            777,
+            303
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "We assume that vectors $\\mathbf { r }$ are normalized with the search radius $R$ such that $\\| \\mathbf { r } \\| _ { 2 } \\leq 1$ . This yields the following $\\Lambda$ , which maps from a unit ball to the normalized coordinates of a cube: ",
+        "bbox": [
+            169,
+            315,
+            825,
+            345
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "equation",
+        "img_path": "images/f12d4bf8de77f6d548fa468ea83db16bec127b914853573e4106bd1f5a3128c9.jpg",
+        "text": "$$\n\\Lambda ( { \\bf r } ) = \\frac { 1 } { 2 } \\Lambda _ { \\mathrm { c y l \\to c u b e } } ( \\Lambda _ { \\mathrm { b a l l \\to c y l } } ( { \\bf r } ) ) + ( 0 . 5 , 0 . 5 , 0 . 5 ) .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            331,
+            361,
+            666,
+            391
+        ],
+        "page_idx": 14
+    }
+]

parse/train/BkCV_W-AZ/BkCV_W-AZ.md

@@ -0,0 +1,384 @@
+# REGRET MINIMIZATION FOR PARTIALLY OBSERVABLE DEEP REINFORCEMENT LEARNING
+
+Anonymous authors Paper under double-blind review
+
+# ABSTRACT
+
+Deep reinforcement learning algorithms that estimate state and state-action value functions have been shown to be effective in a variety of challenging domains, including learning control strategies from raw image pixels. However, algorithms that estimate state and state-action value functions typically assume a fully observed state and must compensate for partial or non-Markovian observations by using finite-length frame-history observations or recurrent networks. In this work, we propose a new deep reinforcement learning algorithm based on counterfactual regret minimization that iteratively updates an approximation to a cumulative clipped advantage function and is robust to partially observed state. We demonstrate that on several partially observed reinforcement learning tasks, this new class of algorithms can substantially outperform strong baseline methods: on Pong with single-frame observations, and on the challenging Doom (ViZDoom) and Minecraft (Malmo) first-person navigation benchmarks. ¨
+
+# 1 INTRODUCTION
+
+Many reinforcement learning problems of practical interest have the property of partial observability, where observations of state are generally non-Markovian. Despite the importance of partial observation in the real world, value function-based methods such as Q-learning (Mnih et al., 2013; 2015) generally assume a Markovian observation space. On the other hand, Monte Carlo policy gradient methods do not assume Markovian observations, but many practical policy gradient methods such as A3C (Mnih et al., 2016) introduce the Markov assumption when using a critic or state-dependent baseline in order to improve sample efficiency.
+
+Consider deep reinforcement learning methods that learn a state or state-action value function. One common workaround for the problem of partial observation is to learn value functions on the space of finite-length frame-history observations, under the assumption that frame-histories of sufficient length will give the environment the approximate appearance of full observability. When learning to play Atari 2600 games from images, deep Q-learning algorithms (Mnih et al., 2013; 2015) concatenate the last 4 observed frames of the video screen buffer as input to a state-action value convolutional network. Not all non-Markovian tasks are amenable to finite-length frame-histories; recurrent value functions can incorporate longer and potentially infinite histories (Hausknecht & Stone, 2017; Foerster et al., 2016), but at the cost of solving a harder optimization problem. Can we develop methods that learn a variant of the value function that is more robust to partial observability?
+
+Our contribution is a new model-free deep reinforcement learning algorithm based on the principle of regret minimization which does not require access to a Markovian state. Our method learns a policy by estimating a cumulative clipped advantage function, which is an approximation to a type of regret that is central to two partial information game-solving algorithms from which we draw our primary inspiration: counterfactual regret minimization (CFR) (Zinkevich et al., 2007) and $\mathrm { C F R + }$ (Tammelin, 2014). Hence we call our algorithm “advantage-based regret minimization” (ARM).
+
+We evaluate our approach on three visual reinforcement learning domains: Pong with varying framehistory lengths (Bellemare et al., 2013), and the first-person games Doom (Kempka et al., 2016) and Minecraft (Johnson et al., 2016). Doom and Minecraft exhibit a first-person viewpoint in a 3- dimensional environment and should appear non-Markovian even with frame-history observations. We find that our method offers substantial improvement over prior methods in these partially observable environments: on both Doom and Minecraft, our method can learn well-performing policies within about 1 million simulator steps using only visual input frame-history observations.
+
+# 2 RELATED WORK
+
+Deep reinforcement learning algorithms have been demonstrated to achieve excellent results on a range of complex tasks, including playing games (Mnih et al., 2015; Oh et al., 2016) and continuous control (Schulman et al., 2015; Lillicrap et al., 2016; Levine et al., 2016). Prior deep reinforcement learning algorithms either learn state or state-action value functions (Mnih et al., 2013), learn policies using policy gradients (Schulman et al., 2015), or perform a combination of the two using actor-critic architectures (Mnih et al., 2016). Policy gradient methods typically do not need to assume a Markovian state, but tend to suffer from poor sample complexity, due to their inability to use off-policy data. Methods based on learning Q-functions can use replay buffers to include off-policy data, accelerating learning (Lillicrap et al., 2016). However, learning Q-functions with Bellman error minimization typically requires a Markovian state space. When learning from observations such as images, the inputs might not be Markovian. Prior methods have proposed to mitigate this issue by using recurrent critics and Q-functions (Hausknecht & Stone, 2017; Oh et al., 2016; Mnih et al., 2016; Heess et al., 2015), and learning Q-functions that depend on entire histories of observations. Heuristics such as concatenation of short observation sequences have also been used (Mnih et al., 2015). However, all of these changes increase the size of the input space, increasing variance, and make the optimization problem more complex. Our method instead learns cumulative advantage functions that depend only on the current state, but can still handle non-Markovian problems.
+
+The form of our advantage function update resembles positive temporal difference methods (Peng et al., 2016; van Hasselt & Wiering, 2007). Additionally, our update rule for a modified cumulative Q-function resembles the average Q-function (Anschel et al., 2017) used for variance reduction in Q-learning. In both cases, the theoretical foundations of our method are based on cumulative regret minimization, and the motivation is substantively different. Previous work by Ross et al. (2011); Ross & Bagnell (2014) has connected regret minimization to reinforcement learning, imitation learning, and structured prediction, although not with counterfactual regret minimization. Regression regret matching (Waugh et al., 2015) is based on a closely related idea, which is to directly approximate the regret with a linear regression model, however the use of a linear model is limited in representation compared to deep function approximation.
+
+# 3 ADVANTAGE-BASED REGRET MINIMIZATION
+
+In this section, we provide background on CFR and $\mathrm { C F R + }$ , describe ARM in detail, and give some intuition for why ARM works.
+
+# 3.1 COUNTERFACTUAL REGRET MINIMIZATION (CFR)
+
+In this section we review the algorithm of counterfactual regret minimization (Zinkevich et al., 2007). We closely follow the version of CFR as described in the Supplementary Material of Bowling et al. (2015), except that we try to use the notation of reinforcement learning where appropriate.
+
+Consider the setting of an extensive game. There are $N$ players numbered $i = 1 , \ldots , N$ . An additional player may be considered a “chance” player to simulate random events. At each time step of the game, one player chooses an action $a \in A _ { i }$ . Define the following concepts and notation:
+
+• Sequences: A sequence specifically refers to a sequence of actions starting from an initial game state. (It is assumed that a sequence of actions, including actions of the “chance” player, is sufficient for defining state within the extensive game.) Let $\mathcal { H }$ be the space of all sequences, and let $\mathcal { Z }$ be the space of terminal sequences.   
+Information sets: Let $\mathcal { T }$ be the space of information sets; that is, for each $I \in \mathcal { Z }$ , $I$ is a set of sequences $h \in I$ which are indistinguishable to the current player. Information sets are a represention of partial observability.   
+Strategies: Let $\pi _ { i } ( a | I )$ be the strategy of the $i$ -th player, where $\pi _ { i } ( a | I )$ is a probability distribution over action $a$ conditioned on information set $I$ . Let $\pi = ( \pi _ { 1 } , \ldots , \pi _ { N } )$ denote
+
+the strategy profile for all players, and let $\pi _ { - i } = ( \pi _ { 1 } , \ldots , \pi _ { i - 1 } , \pi _ { i + 1 } , \ldots , \pi _ { N } )$ denote the strategy profile for all players except the $i$ -th player.
+
+• Sequence probabilities: Let $\rho ^ { \pi } ( h )$ be the probability of reaching the sequence $h$ when all players follow $\pi$ . Additionally, let $\rho ^ { \pi } ( h , h ^ { \prime } )$ be the probability of reaching $h ^ { \prime }$ conditioned on $h$ having already been reached. Similarly, define $\rho _ { i } ^ { \pi }$ and $\rho _ { - i } ^ { \pi }$ to contain the contributions of respectively only the $i$ -th player or of all players except the $i$ -th.
+
+• Values: Let $u _ { i } ( z )$ be the value of a terminal sequence $z$ to the $i$ -th player. Let the expected value of a strategy profile $\pi$ to the $i$ -th player be $\begin{array} { r } { J _ { i } ( \pi ) = \sum _ { z \in Z } \rho ^ { \bar { \pi } } ( z ) u _ { i } ( z ) } \end{array}$ .
+
+Define the counterfactual value $Q _ { \pi , i } ^ { \mathrm { C F } }$ of all players following strategy $\pi$ , except the $i$ -th player plays to reach information set and to then take action $a$ :
+
+$$
+Q _ { \pi , i } ^ { \mathrm { C F } } ( I , a ) = \sum _ { h \in I } \sum _ { z \in \mathcal { Z } : h \sqsubseteq z } \rho _ { - i } ^ { \pi } ( z ) \rho _ { i } ^ { \pi | I  a } ( h , z ) u _ { i } ( z ) .
+$$
+
+The notation $h \sqsubset h ^ { \prime }$ denotes that $h$ is a prefix of $h ^ { \prime }$ , while $\pi | I  a$ denotes that action $a$ is to be performed when $I$ is observed. The counterfactual value $Q _ { \pi , i } ^ { \mathrm { C F } } ( I , a )$ is a calculation that assumes the $i$ -th player reaches any $h \in I$ , and upon reaching any $h \in I$ it always chooses $a$ .
+
+Consider a learning scenario where at the $t$ -th iteration the players follow a strategy profile $\pi ^ { t }$ . The $i$ -th player’s regret after $T$ iterations is defined in terms of the $i$ -th player’s optimal strategy $\pi _ { i } ^ { * }$ :
+
+$$
+R _ { i } ^ { T } = \sum _ { t = 0 } ^ { T - 1 } J _ { i } ( ( \pi _ { 1 } ^ { t } , \cdot \cdot \cdot , \pi _ { i - 1 } ^ { t } , \pi _ { i } ^ { * } , \pi _ { i + 1 } ^ { t } , \cdot \cdot \cdot , \pi _ { N } ^ { t } ) ) - J _ { i } ( \pi ^ { t } ) .
+$$
+
+The average regret is the average over learning iterations: $( 1 / T ) R _ { i } ^ { T }$ . Now define the counterfactual regret of the $i$ -th player for taking action $a$ at information set $I$ :
+
+$$
+\begin{array} { r l } & { ( R _ { i } ^ { \mathrm { ( C F ) } } ) ^ { T } ( I , a ) = \displaystyle \sum _ { t = 0 } ^ { T - 1 } \left( Q _ { \pi ^ { t } , i } ^ { \mathrm { C F } } ( I , a ) - \sum _ { a ^ { \prime } \in A } \pi _ { i } ^ { t } ( a ^ { \prime } | I ) Q _ { \pi ^ { t } , i } ^ { \mathrm { C F } } ( I , a ^ { \prime } ) \right) } \\ & { \quad \quad \quad \quad = ( R _ { i } ^ { \mathrm { ( C F ) } } ) ^ { T - 1 } ( I , a ) + Q _ { \pi ^ { T - 1 } , i } ^ { \mathrm { C F } } ( I , a ) - \displaystyle \sum _ { a ^ { \prime } \in A } \pi _ { i } ^ { T - 1 } ( a ^ { \prime } | I ) Q _ { \pi ^ { T - 1 } , i } ^ { \mathrm { C F } } ( I , a ^ { \prime } ) . } \end{array}
+$$
+
+The counterfactual regret (Equation (3)) can be shown to majorize the regret (Equation (2)) (Theorem 3, Zinkevich et al. (2007)). CFR can then be described as a learning algorithm where the strategy is updated using regret matching (Hart & Mas-Colell, 2000) applied to the counterfactual regret calculated in the most recent iteration:
+
+$$
+\pi _ { i } ^ { T + 1 } ( a | I ) = \left\{ \begin{array} { l l } { \frac { \operatorname* { m a x } ( 0 , ( R _ { i } ^ { \mathrm { ( C F ) } } ) ^ { T + 1 } ( I , a ) ) } { \sum _ { a ^ { \prime } \in A } \operatorname* { m a x } ( 0 , ( R _ { i } ^ { \mathrm { ( C F ) } } ) ^ { T + 1 } ( I , a ^ { \prime } ) ) } } & { \mathrm { i f } \sum _ { a ^ { \prime } \in A } \operatorname* { m a x } ( 0 , ( R _ { i } ^ { \mathrm { ( C F ) } } ) ^ { T + 1 } ( I , a ^ { \prime } ) ) > 0 } \\ { \frac { 1 } { | A | } } & { \mathrm { o t h e r w i s e } . } \end{array} \right.
+$$
+
+If all players follow the CFR regret matching strategy (Equation (5)), then at the $T$ -th iteration the players’ average regrets are bounded by ${ \cal O } ( T ^ { - 1 / 2 } )$ (Theorem 4, Zinkevich et al. (2007)).
+
+# 3.2 $\mathrm { C F R + }$
+
+$\mathrm { C F R + }$ (Tammelin, 2014) consists of a modification to CFR, in which instead of calculating the full counterfactual regret as in (4), instead the counterfactual regret is recursively positively clipped to yield the clipped counterfactual regret:
+
+$$
+( R _ { i } ^ { \mathrm { ( C F + } } ) ^ { T } ( I , a ) = \operatorname* { m a x } ( 0 , ( R _ { i } ^ { \mathrm { ( C F + } } ) ) ^ { T - 1 } ( I , a ) ) + Q _ { \pi ^ { T - 1 } , i } ^ { \mathrm { C F } } ( I , a ) - \sum _ { a ^ { \prime } \in A } \pi _ { i } ^ { T - 1 } ( a ^ { \prime } | I ) Q _ { \pi ^ { T - 1 } , i } ^ { \mathrm { C F } } ( I , a ^ { \prime } ) .
+$$
+
+Comparing Equation (4) with Equation (6), one can see that the only difference in CFR is that the previous iteration’s counterfactual regret is positively clipped in the recursion. The one-line change of $\mathrm { C F R + }$ turns out to yield a large practical improvement in the performance of the algorithm (Bowling et al., 2015), and there is also an associated regret bound for $\mathrm { C F R + }$ that is as strong as the bound for CFR (Tammelin et al., 2015).
+
+# 3.3 FROM CFR AND $\mathrm { C F R + }$ TO ARM
+
+CFR and $\mathrm { C F R + }$ are formulated for imperfect information extensive-form games, so they are naturally generalized to partially observed stochastic games since a stochastic game can always be represented in extensive form. A 1-player partially observed stochastic game is simply a POMDP with observation space $\mathcal { O }$ (Littman, 1994). By mapping information sets $I \in \mathcal { T }$ to observations $o \in \mathcal { O }$ e counterfactual value as a kind of statio that assumes the agent follows the policy ary observation-actioexcept on observing value, after $Q _ { \pi , i } ^ { \mathrm { C F } } ( I , a ) \equiv Q _ { \pi | o \mapsto a } ^ { ( \mathrm { s t a t } ) } ( o , a )$ $\pi$ $o$ $a$ $Q _ { \pi | o \mapsto a } ^ { ( \mathrm { s t a t } ) } ( o , a ) \approx Q _ { \pi } ( o , a )$ , where $Q _ { \pi }$ is the usual action value function, is valid when observations are rarely seen more than once in a trajectory. By approximating $Q _ { \pi | o \mapsto a } ^ { ( \mathrm { s t a t } ) } ( o , a ) \approx Q _ { \pi } ( o , a )$ , we get a recurrence in terms of more familiar value functions (compare Equations (6) and (7)):
+
+$$
+\begin{array} { l } { \bar { A } _ { t } ^ { + } ( o _ { k } , a _ { k } ) = \operatorname* { m a x } ( 0 , \bar { A } _ { t - 1 } ^ { + } ( o _ { k } , a _ { k } ) ) + Q _ { \pi _ { t } } ( o _ { k } , a _ { k } ) - { \displaystyle \sum _ { a ^ { \prime } \in \mathcal { A } } } \pi _ { t } ( a ^ { \prime } | o _ { k } ) Q _ { \pi _ { t } } ( o _ { k } , a ^ { \prime } ) } \\ { = \operatorname* { m a x } ( 0 , \bar { A } _ { t - 1 } ^ { + } ( o _ { k } , a _ { k } ) ) + Q _ { \pi _ { t } } ( o _ { k } , a _ { k } ) - V _ { \pi _ { t } } ( o _ { k } ) } \\ { = \operatorname* { m a x } ( 0 , \bar { A } _ { t - 1 } ^ { + } ( o _ { k } , a _ { k } ) ) + A _ { \pi _ { t } } ( o _ { k } , a _ { k } ) } \end{array}
+$$
+
+where $\bar { A } _ { t } ^ { + } ( o , a )$ is the cumulative clipped advantage function, and $A _ { \pi _ { t } } ( o , a )$ is the ordinary advantage function evaluated at policy $\pi _ { t }$ . Advantage-based regret minimization (ARM) is the resulting reinforcement learning algorithm that updates the policy to regret match on the cumulative clipped advantage function:
+
+$$
+\pi _ { t + 1 } ( a _ { k } | o _ { k } ) = \left\{ \begin{array} { l l } { \frac { \operatorname* { m a x } ( 0 , \bar { A } _ { t } ^ { + } ( o _ { k } , a _ { k } ) ) } { \sum _ { a ^ { \prime } \in A } \operatorname* { m a x } ( 0 , \bar { A } _ { t } ^ { + } ( o _ { k } , a ^ { \prime } ) ) } } & { \mathrm { i f ~ } \sum _ { a ^ { \prime } \in A } \operatorname* { m a x } ( 0 , \bar { A } _ { t } ^ { + } ( o _ { k } , a ^ { \prime } ) ) > 0 } \\ { \frac { 1 } { | \bar { A } | } } & { \mathrm { o t h e r w i s e } . } \end{array} \right.
+$$
+
+Equations (9) and (10) suggest the outline of a batch-mode deep reinforcement learning algorithm. At the $t$ -th sampling iteration, a batch of data is collected by sampling trajectories using the current policy $\pi _ { t }$ , followed by two processing steps: (a) fit $\bar { A } _ { t } ^ { + }$ using Equation (9), then (b) set the next iteration’s policy $\pi _ { t + 1 }$ using Equation (10).
+
+# 3.4 IMPLEMENTATION OF ARM
+
+To implement Equation (9) with deep function approximation, we define two value function approximations, $V _ { \pi _ { t } } \left( o _ { k } ; \theta _ { t } \right)$ and $\bar { Q } _ { t } ^ { + } ( o _ { k } , a _ { k } ; \omega _ { t } )$ , as well as a target value function $V ^ { \prime } ( o _ { k } ; \varphi )$ , where $\theta _ { t } , \omega _ { t }$ , and $\varphi$ are the learnable parameters. The cumulative clipped advantage function is represented as $\bar { A } _ { t } ^ { + } ( \dot { o } _ { k } , a _ { k } ) = \bar { Q } _ { t } ^ { + } ( o _ { k } , \dot { a _ { k } } ; \omega _ { t } ) - V _ { \pi _ { t } } ( o _ { k } ; \theta _ { t } )$ . Within each sampling iteration, the value functions are fitted using stochastic gradient descent by sampling minibatches and performing gradient steps. The state-value function $V _ { \pi _ { t } } ( o _ { k } ; \theta _ { t } )$ is fit to minimize an $n$ -step temporal difference loss with a moving target $V ^ { \prime } ( o _ { k + n } ; \varphi )$ , essentially using the estimator of the deep deterministic policy gradient (DDPG) (Lillicrap et al., 2016). In the same minibatch, $\bar { Q } _ { t } ^ { + } ( o _ { k } , a _ { k } ; \theta _ { t } )$ is fit to a similar loss, but with an additional target reward bonus that incorporates the previous iteration’s cumulative clipped advantage, $\operatorname* { m a x } ( 0 , \bar { A } _ { t - 1 } ^ { \mp } ( o _ { k } , a _ { k } ) )$ . The regression targets $v ( o _ { k } ; \varphi )$ and $\bar { q } ^ { + } ( o _ { k } , a _ { k } ; \varphi )$ are defined in terms of the $n$ -step returns $\begin{array} { r } { g _ { k } ^ { n } = \sum _ { k ^ { \prime } = k } ^ { k + n - 1 } \gamma ^ { k ^ { \prime } - k } r _ { k ^ { \prime } } } \end{array}$
+
+$$
+\begin{array} { r l } & { \qquad v ( o _ { k } ; \varphi ) \triangleq g _ { k } ^ { n } + \gamma ^ { n } V ^ { \prime } ( o _ { k + n } ; \varphi ) } \\ & { \qquad q ( o _ { k } , a _ { k } ; \varphi ) \triangleq r _ { k } + \gamma g _ { k + 1 } ^ { n - 1 } + \gamma ^ { n } V ^ { \prime } ( o _ { k + n } ; \varphi ) } \\ & { \qquad q ^ { + } ( o _ { k } , a _ { k } ; \varphi ) \triangleq \operatorname* { m a x } ( 0 , \bar { Q } _ { t - 1 } ^ { + } ( o _ { k } , a _ { k } ; \omega _ { t - 1 } ) - V _ { \pi _ { t - 1 } } ( o _ { k } ; \theta _ { t - 1 } ) ) + q ( o _ { k } , a _ { k } ; \varphi ) . } \end{array}
+$$
+
+Altogether, each minibatch step of the optimization subproblem consists of the following three parameter updates in terms of the regression targets $v ( o _ { k } ; \varphi )$ and $\bar { q } ^ { + } ( o _ { k } , a _ { k } ; \varphi )$ :
+
+$$
+\begin{array} { r l } & { \theta _ { t } ^ { ( \ell + 1 ) }  \theta _ { t } ^ { ( \ell ) } - \frac { \alpha } { 2 } \nabla _ { \theta _ { t } ^ { ( \ell ) } } ( V _ { \pi _ { t } } ( o _ { k } ; \theta _ { t } ^ { ( \ell ) } ) - v ( o _ { k } ; \varphi ^ { ( \ell ) } ) ) ^ { 2 } } \\ & { \omega _ { t } ^ { ( \ell + 1 ) }  \omega _ { t } ^ { ( \ell ) } - \frac { \alpha } { 2 } \nabla _ { \omega _ { t } ^ { ( \ell ) } } ( \bar { Q } _ { t } ^ { + } ( o _ { k } , a _ { k } ; \omega _ { t } ^ { ( \ell ) } ) - \bar { q } ^ { + } ( o _ { k } , a _ { k } ; \varphi ^ { ( \ell ) } ) ) ^ { 2 } } \\ & { \varphi ^ { ( \ell + 1 ) }  \varphi ^ { ( \ell ) } + \tau ( \theta _ { t } ^ { ( \ell + 1 ) } - \varphi ^ { ( \ell ) } ) . } \end{array}
+$$
+
+Algorithm 1 Advantage-based regret minimization (ARM).   
+
+<table><tr><td>initialize πo ←uniform,θ-1,ω-1 ←arbitrary for tin O,...do collect batch of trajectory data Dt ~ t initialize0t←0t-1,Wt←Wt-1,←0t-1 forlinO,...do sample transitions (Ok,ak,rk,.::, Ok+n-1,ak+n-1,rk+n-1,Ok+n) ~ Dt</td></tr><tr><td>calculate n-step returns g = ∑k=k k+n-1 k&#x27;-krk&#x27; set δk+n ← I[ok+n is terminal] if t=O then set k←0</td></tr><tr><td>else setΦk ←max(0,Qt-1(Ok,ak; Wt-1) -Vπt-1(Ok;0t-1)) end if</td></tr><tr><td>set v(ok) ←gκ+γn(1-δk+n)V&#x27;(0k+n;φ) update 0t with step size α and targets v(ok) (Equation (14))</td></tr><tr><td>update Wt with step size α and targets q+(Ok, ak) (Equation (15)) update  with moving average step size T (Equation (16)) end for set πt+1(alo) x max(0,Qt(o,a; wt)-Vπt(o;0t))</td></tr></table>
+
+The overall advantage-based regret minimization algorithm is summarized in Algorithm 1.
+
+We note that the mechanics of the ARM updates are similar to on-policy value function estimation, but ARM learns a modified on-policy Q-function from transitions with the added reward bonus $\operatorname* { m a x } ( 0 , \bar { A } _ { t - 1 } ^ { + } ( o _ { k } , a _ { k } ) )$ (Equation (13)). This reward bonus can be thought of a kind of “optimism in the face of uncertainty.”
+
+# 3.5 ARM VS. EXISTING POLICY GRADIENT METHODS
+
+In this section, we accentuate that ARM represents an inherently different update compared to existing policy gradient methods.
+
+Recent work has shown that policy gradient methods and Q-learning methods are connected via entropy regularization (O’Donoghue et al., 2017; Haarnoja et al., 2017; Nachum et al., 2017; Schulman et al., 2017; Anonymous, 2018). One perspective is from the soft policy iteration framework for batch-mode reinforcement learning (Anonymous, 2018), where at each batch iteration the updated policy is obtained by minimizing the average KL-divergence between the policy class $\Pi$ and a target policy $f$ . Below is the soft policy iteration update, where the subscript $t$ refers to the batch iteration:
+
+$$
+\begin{array} { r l } & { \pi _ { t + 1 } \gets \arg \underset { \pi \in \Pi } { \operatorname* { m i n } } \mathbb { E } _ { o \sim \rho _ { t } } [ D _ { \mathrm { K L } } ( \pi \| f ) ] } \\ & { \qquad = \arg \underset { \pi \in \Pi } { \operatorname* { m i n } } \mathbb { E } _ { o \sim \rho _ { t } } [ \mathbb { E } _ { a \sim \pi ( \cdot | o ) } [ \log ( \pi ( a | o ) ) - \log ( f ( a | o ) ) ] ] . } \end{array}
+$$
+
+Using the connection between policy gradient methods and Q-learning, we define the policy gradient target policy as the softmax distribution on the entropy regularized advantage function Aβ-soft:
+
+$$
+f ^ { \mathrm { P G } } ( a | o ) \triangleq \frac { \exp ( \beta A _ { t } ^ { \beta \mathrm { - s o f t } } ( o , a ) ) } { \sum _ { a ^ { \prime } \in \mathcal { A } } \exp ( \beta A _ { t } ^ { \beta \mathrm { - s o f t } } ( o , a ^ { \prime } ) ) } .
+$$
+
+We note that it is more conventional in the literature to use the soft Q-function $Q ^ { \beta - \mathrm { s o f t } } ( o , a )$ rather than the soft advantage function $A ^ { \beta - \mathrm { s o f t } } ( o , a )$ , however since they differ only by a function of $o$ then they both induce the same target softmax policy. Now, parameterizing the policy $\pi$ in terms of an explicit parameter $\theta$ , we obtain the expression for the existing policy gradient, where $b ( o )$ is a baseline function:
+
+$$
+\Delta \theta ^ { \mathrm { P G } } \propto \mathbb { E } _ { o \sim \rho _ { t } } [ \mathbb { E } _ { a \sim \pi ( \cdot | a ; \theta ) } [ \nabla _ { \theta } \log ( \pi ( o | a ; \theta ) ) ( ( 1 / \beta ) \log ( \pi ( o | a ; \theta ) ) - A _ { t } ^ { \beta \sim \mathrm { o f f } } ( o , a ) + b ( o ) ) ] ] .
+$$
+
+The classic policy gradient arises in the limit $\beta \to \infty$ .
+
+Note that an alternative choice of target policy $f$ will lead to a different kind of policy gradient update. A policy gradient algorithm based on ARM instead proposes the following target policy based on the regret-matching distribution:
+
+$$
+f ^ { \mathrm { A R M } } ( a | o ) \triangleq \frac { \operatorname* { m a x } ( 0 , \bar { A } _ { t } ^ { + } ( o , a ) ) } { \sum _ { a ^ { \prime } \in \mathcal { A } } \operatorname* { m a x } ( 0 , \bar { A } _ { t } ^ { + } ( o , a ^ { \prime } ) ) } .
+$$
+
+Similarly, we can express the ARM-like policy gradient, where again $b ( o )$ is a baseline:
+
+$$
+\begin{array} { r } { \mathtt { D } \theta ^ { \mathrm { A R M } } = \mathbb { E } _ { o \sim \rho _ { \mathrm { f } } } [ \mathbb { E } _ { a \sim \pi ( \cdot | \sigma ; \theta ) } [ \nabla _ { \theta } \log ( \pi ( o | a ; \theta ) ) ( \log ( \pi ( o | a ; \theta ) ) - \log ( \operatorname* { m a x } ( 0 , \bar { A } _ { t } ^ { + } ( o , a ) ) ) + b ( o ) ) ] ] . } \end{array}
+$$
+
+Comparing Equations (20) and (22), we see that the ARM-like policy gradient (Equation (22)) has a logarithmic dependence on the advantage-like function $\bar { A } ^ { + }$ , whereas the existing policy gradient (Equation (20)) is only linearly dependent on the advantage function $A ^ { \beta - \mathrm { s o f t } }$ . This difference in logarithmic vs. linear dependence is responsible for a large part of the inherent distinction of ARM from existing policy gradient methods. One consequence of the difference in logarithmic vs. linear dependence is that the ARM-like update should be less sensitive to large positive advantages that may result from overestimation compared to existing policy gradient methods.
+
+We also see that for the existing policy gradient (Equation (20)), the $( 1 / \beta ) \log ( \pi ( a | o ; \theta ) )$ term, which is derived from the policy entropy, is vanishing for large $\beta$ (e.g. $\beta = 1 0 0$ is a common choice in practice). On the other hand, for the ARM-like policy gradient (Equation (22)), there is no similar vanishing effect, suggesting that ARM may perform a kind of entropy regularization by default.
+
+In practice we cannot implement an ARM-like policy gradient exactly as in Equation (22), as due to the positive clipping $\operatorname* { m a x } ( 0 , { \bar { A } } ^ { + } )$ there can appear $\log ( 0 )$ . However we believe this is not an intrinsic obstacle, leaving the issue of implementing an ARM-like policy gradient to future work.
+
+# 3.6 WHY DOES ARM WORK BETTER IN PARTIALLY OBSERVABLE DOMAINS?
+
+In the previous Section 3.5, we showed that ARM and existing policy gradient methods can be distinguished by their choices of target policy and the nature of their dependence on their respective advantage-like functions. In this section, we argue that the convergence results of CFR and $\mathrm { C F R + }$ suggest that ARM, to the degree that it inherits the properties of $\mathrm { C F R / C F R + }$ , ought to benefit from greater partial observability compared to other methods.
+
+We assume that regret bounds are a useful way to compare the convergence of different RL algorithms, due to the interpretation of regret as “area over the learning curve (and under the optimal√ expected value $J ^ { * }$ ).” Specifically, the regret bound of CFR and $\mathrm { C F R + }$ is $O ( | O | \sqrt { T } )$ where $| \mathcal { O } |$ is the size of the observation space (Zinkevich et al., 2007; Tammelin et al., 2015). The policy gradient method with a suitable baseline has a learning rate $\eta$ -dependent regret bound derived from the stochastic gradient method; assuming parameter norm bound $B$ and gradient estimator second moments $G ^ { 2 }$ , by setting the learning rate $\eta \propto T ^ { - 1 / 2 }$ policy gradient achieves a regret bound of $O ( \sqrt { T } )$ with no explicit dependence on the observation space size $| \mathcal { O } |$ (Dick, 2015).
+
+We argue that possessing a regret bound proportional to the observation space size $| \mathcal { O } |$ is beneficial in highly partially observable domains. Let us fix an underlying state space $s$ . Compare two RL algorithms, where algorithm 1 (which is ARM-like) has a regret bound $c _ { 1 } | \mathcal { O } | \sqrt { T }$ , whereas algorithm 2 (which is policy gradient-like) has a regret bound $c _ { 2 } \sqrt { T }$ ; here, $c _ { 1 }$ and $c _ { 2 }$ are constants. Note that if $c _ { 1 } | \mathcal { O } | = c _ { 2 }$ or equivalently $| \mathcal { O } | = c _ { 2 } / c _ { 1 }$ , then the two RL algorithms possess the exact same regret bound. If on the other hand $\left| \mathcal { O } \right| < c _ { 2 } / c _ { 1 }$ , then the regret bound of RL algorithm 1 is actually lower than that of RL algorithm 2. Applying this intuition to CFR and hence ARM suggests that ARM can benefit from greater partial observability if the degree of partial observability is above a threshold.
+
+For Q-learning per se, we are not aware of any known regret bound. Szepesvari proved that the ´ convergence rate of Q-learning in the $L ^ { \infty }$ -norm, assuming a fixed exploration strategy, depends on a condition number $C$ , which is the ratio of the minimum to maximum state-action occupation frequencies (Szepesvari, 1998), and which describes how “balanced” the exploration strategy is. If ´ partial observability leads to imbalanced exploration due to confounding of states from perceptual aliasing (McCallum, 1997), then Q-learning should be negatively affected.
+
+We note that there remains a gap between ARM as implemented and the theory of CFR: the use of (a) function approximation and sampling over tabular enumeration; (b) the “ordinary” Q-function instead of the “stationary” Q-function; and (c) $n$ -step bootstrapped values instead of full returns for value function estimation. Waugh et al. (2015) address CFR with function approximation via a noisy version of a generalized Blackwell’s condition (Cesa-Bianchi & Lugosi, 2003). Even the original implementation of CFR used sampling in place of enumeration (Zinkevich et al., 2007). We refer the reader to Bellemare et al. (2016) for a more in-depth discussion of the stationary Q-function. Although only the full returns are guaranteed to be unbiased in non-Markovian settings, it is quite common for practical RL algorithms to trade off strict unbiasedness in favor of lower variance by using $n$ -step returns or variations thereof (Schulman et al., 2016; Gu et al., 2017).
+
+# 4 EXPERIMENTS
+
+Because we hypothesize that ARM should perform well in partially observable reinforcement learning environments, we conduct our experiments on visual domains that naturally provide partial observations of state. All of our evaluations use feedforward convnets with frame-history observations. We are interested in comparing ARM with methods that assume Markovian observations, namely double deep Q-learning (van Hasselt et al., 2016), as well as methods that can handle non-Markovian observations, primarily TRPO (Schulman et al., 2015; 2016), and to a lesser extent A3C (Mnih et al., 2016) whose critic assumes Markovian observations. We are also interested in controlling for the advantage structure of ARM by comparing with other advantage-structured methods, which include dueling networks (Wang et al., 2016), as well as policy gradient methods that estimate an empirical advantage using a baseline state-value function or critic (e.g. TRPO, A3C).
+
+# 4.1 LEARNING TO PLAY PONG WITH A SINGLE FRAME
+
+Atari games consist of a small set of moving sprites with fixed shapes and palettes, and the motion of sprites can be highly deterministic, so that with only 4 recently observed frames as input one can predict hundreds of frames into the future on some games using only a feedforward model (Oh et al., 2015). To increase the partial observability of Atari games, one may artificially limit the amount of frame history fed as input to the networks (Hausknecht & Stone, 2017). As a proof of concept of ARM, we trained agents to play Pong via the Arcade Learning Environment (Bellemare et al., 2013) when the frame-history length is varied between 4 (the default) and 1. We found that the performance of double deep Q-learning degraded noticeably when the frame-history length was reduced from 4 to 1, whereas performance of ARM was not affected nearly as much. Our results on Pong are summarized in Figure 1.
+
+![](images/d17a3f8ac400502818872bfd8c6491354010200aa08ebf771c86d4e4b1b0fcb7.jpg)  
+Figure 1: Comparing double deep Q-learning (orange) and ARM (blue) on Pong.
+
+# 4.2 LEARNING TO NAVIGATE IN VIZDOOM
+
+We evaluated ARM on the task of learning first-person navigation in the ViZDoom (Kempka et al., 2016) domain based on the game of Doom. Doom is a substantially more complex domain than Atari, featuring an egocentric viewpoint, 3D perspective, and complex visuals. We expect that Doom exhibits a substantial degree of partial observability and therefore serves as a more difficult evaluation of reinforcement learning algorithms’ effectiveness on partially observable domains. We performed our evaluation on two standard ViZDoom navigation benchmarks, “HealthGathering”
+
+and “MyWayHome.” In “HealthGathering,” the agent is placed in a toxic room and continually loses life points, but can navigate toward healthkit objects to prolong its life; the goal is to survive for as long as possible. In “MyWayHome,” the agent is randomly placed in a small maze and must find a target object that has a fixed visual appearance and is in a fixed location in the maze; the goal is to reach the target object before time runs out. Figure 2 (top row) shows example observations from the two ViZDoom scenarios.
+
+Unlike previous evaluations which augmented the raw pixel frames with extra information about the game state, e.g. elapsed time ticks or remaining health (Kempka et al., 2016; Dosovitskiy & Koltun, 2017), in our evaluation we forced all networks to learn using only visual input. Despite this restriction, ARM is still able to quickly learn policies with minimal tuning of hyperparameters and reach close to the maximum score in under 1 million steps. On “HealthGathering,” we observed that ARM very quickly learns a policy that can achieve close to the maximum episode return of 2100. Double deep Q-learning learns a more consistent policy on “HealthGathering” compared to ARM and TRPO, but we believe this to be the result of evaluating double DQN’s $\epsilon$ -greedy policy with small $\epsilon$ compared to the truly stochastic policies learned by ARM and TRPO. On “MyWayHome,” we observed that ARM generally learned a well-performing policy more quickly than other methods. Additionally, we found that ARM is able to take advantage of an off-policy replay memory when learning on ViZDoom by storing the trajectories of previous sampling batches and applying an importance sampling correction to the $n$ -step returns; please see Section 6.2 in the Appendix for details. Our Doom results are in Figure 6.
+
+![](images/eb67b2bf92537bb9e524252d79c88f95c44e030b7fa632f8399695fb74da885d.jpg)  
+Figure 2: Top row: Doom screenshots from (left) “HealthGathering” and (right) “MyWayHome.” Bottom row: Minecraft screenshots from (leftmost) “L1” through (rightmost) “L5”
+
+![](images/a578e0fde415fbaa29313d8eef053a0758257658bc7097447ce30625994816f4.jpg)  
+Figure 3: Evaluating double deep Q-learning (orange), dueling double DQN (red), A3C (purple), TRPO (green), ARM (blue), and ARM with off-policy data (cyan) on two ViZDoom scenarios.
+
+# 4.3 LEARNING TO NAVIGATE IN MINECRAFT
+
+We finally evaluated ARM on the task of learning first-person navigation in the Malmo domain ¨ based on the game of Minecraft (Johnson et al., 2016). Minecraft has similar visual complexity to Doom and should possess a comparable degree of partial observability, but Minecraft has the potential to be more difficult than Doom due to the diversity of possible Minecraft environments that can be generated. Our evaluation on Minecraft is adapted from the teacher-student curriculum learning protocol (Matiisen et al., 2017), which consists of 5 consecutive “levels” that successively increase the difficulty of completing the simple task of reaching a target block: the first level (“L1”) consists of a single room; the intermediate levels (“L2”–“L4”) consist of a corridor with lava-bridge and wall-gap obstacles; and the final level (“L5”) consists of a $2 \times 2$ arrangement of rooms randomly separated by lava-bridge or wall-gap obstacles. Figure 2 (bottom row) shows example observations from the five Minecraft levels.
+
+We performed our Minecraft experiments using fixed curriculum learning schedules to evaluate the sample efficiency of different algorithms: the agent is initially placed in the first level (“L1”), and the agent is advanced to the next level whenever a preselected number of simulator steps have elapsed, until the agent reaches the last level (“L5”). We found that ARM and dueling double DQN both were able to learn on an aggressive “fast” schedule of only 62500 simulator steps between levels. TRPO required a “slow” schedule of 93750 simulator steps between levels to reliably learn. ARM was able to consistently learn a well performing policy on all of the levels, whereas double DQN learned more slowly on some of the intermediate levels. ARM also more consistently reached a high score on the final, most difficult level (“L5”). Our Minecraft results are shown in Figure 4.
+
+![](images/d9207a568dbbd2bbee8c90f7edd9b397fc7e3f523d0ae82626197667af5e147c.jpg)  
+Figure 4: Evaluating double deep Q-learning (orange), dueling double DQN (red), TRPO (green), and ARM (blue) on a Minecraft curriculum learning protocol. The simulator step counts at which each level begins are labeled and demarcated with dashed vertical lines.
+
+# 5 DISCUSSION
+
+In this paper, we presented a novel deep reinforcement learning algorithm based on counterfactual regret minimization (CFR). We call our method advantage-based regret minimization (ARM). Similarly to prior methods that learn state or state-action value functions, our method learns a cumulative clipped advantage function of observation and action. However, in contrast to these prior methods, ARM is well suited to partially observed or non-Markovian environments, making it an appealing choice in a number of difficult domains. When compared to baseline methods, including deep Q-learning and TRPO, on non-Markovian tasks such as the challenging ViZDoom and Malmo first- ¨ person navigation benchmarks, ARM achieves substantially better results. This illustrates the value of ARM for partially observable problems. In future work, we plan to further explore applications of ARM to more complex tasks, including continuous action spaces.
+
+# REFERENCES
+
+Anonymous. Soft actor-critic: Off-policy maximum entropy deep reinforcement learning with a stochastic actor. International Conference on Learning Representations, 2018. URL https: //openreview.net/forum?id=HJjvxl-Cb.
+
+Oron Anschel, Nir Baram, and Nahum Shimkin. Averaged-DQN: Variance Reduction and Stabilization for Deep Reinforcement Learning. In International Conference on Machine Learning, pp. 176–185, 2017.
+
+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.
+
+Mark G. Bellemare, Georg Ostrovski, Arthur Guez, Philip S. Thomas, and Remi Munos. Increasing ´ the Action Gap: New Operators for Reinforcement Learning. In AAAI, 2016.
+
+Michael Bowling, Neil Burch, Michael Johanson, and Oskari Tammelin. Heads-up limit hold’em poker is solved. Science, 347(6218):145–149, 2015.
+
+Nicolo Cesa-Bianchi and G \` abor Lugosi. Potential-Based Algorithms in On-Line Prediction and ´ Game Theory. Machine Learning, 51(3):239–261, 2003.
+
+Travis Dick. Policy Gradient Reinforcement Learning Without Regret. Master’s thesis, University of Alberta, 2015.
+
+Alexey Dosovitskiy and Vladlen Koltun. Learning to Act by Predicting the Future. arXiv preprint arXiv:1611.01779v2, 2017.
+
+Jakob N. Foerster, Yannis M. Assael, Nando de Freitas, and Shimon Whiteson. Learning to Communicate with Deep Multi-Agent Reinforcement Learning. In Advances in Neural Information Processing Systems 29, 2016.
+
+Shixiang Gu, Timothy Lillicrap, Zoubin Ghahramani, Richard E. Turner, Bernhard Scholkopf, and ¨ Sergey Levine. Interpolated Policy Gradient: Merging On-Policy and Off-Policy Gradient Estimation for Deep Reinforcement Learning. arXiv preprint arXiv:1706.00387v1, 2017.
+
+Tuomas Haarnoja, Haoran Tang, Pieter Abbeel, and Sergey Levine. Reinforcement Learning with Deep Energy-Based Policies. arXiv preprint arXiv:1702.08165v2, 2017.
+
+Sergiu Hart and Andreu Mas-Colell. A Simple Adaptive Procedure Leading to Correlated Equilibrium. Econometrica, 68(5):1127–1150, 2000.
+
+Matthew Hausknecht and Peter Stone. Deep Recurrent Q-Learning for Partially Observable MDPs. arXiv preprint arXiv:1507.06527v4, 2017.
+
+Nicolas Heess, Jonathan J. Hunt, Timothy P. Lillicrap, and David Silver. Memory-based control with recurrent neural networks. arXiv preprint arXiv:1512.04455v1, 2015.
+
+Edward L Ionides. Truncated Importance Sampling. Journal of Computational and Graphical Statistics, 17(2):295–311, 2008.
+
+Matthew Johnson, Katja Hofmann, Tim Hutton, and David Bignell. The Malmo Platform for Artificial Intelligence Experimentation. In Proceedings of the 25th International Joint Conference on Artificial Intelligence, 2016.
+
+Michal Kempka, Marek Wydmuch, Grzegorz Runc, Jakub Toczek, and Wojciech Jaskowski. ViZ- ´ Doom: A Doom-based AI Research Platform for Visual Reinforcement Learning. arXiv preprint arXiv:1605.02097v2, 2016.
+
+Sergey Levine, Chelsea Finn, Trevor Darrell, and Pieter Abbeel. End-to-end training of deep visuomotor policies. The Journal of Machine Learning Research, 17(1):1334–1373, 2016.
+
+Timothy P. Lillicrap, Jonathan J. Hunt, Alexander Pritzel, Nicolas Heess, Tom Erez, Yuval Tassa, David Silver, and Daan Wierstra. Continuous control with deep reinforcement learning. arXiv preprint arXiv:1509.02971v5, 2016.
+
+Michael L. Littman. Markov games as a framework for multi-agent reinforcement learning. In Proceedings of the 11th International Conference on Machine Learning, pp. 157–163, 1994.
+
+Tambet Matiisen, Avital Oliver, Taco Cohen, and John Schulman. Teacher-Student Curriculum Learning. arXiv preprint arXiv:1707.00183v1, 2017.
+
+Andrew Kachites McCallum. Efficient Exploration in Reinforcement Learning with Hidden State. In AAAI Fall Symposium on Model-directed Autonomous Systems, 1997.
+
+Volodymyr Mnih, Koray Kavukcuoglu, David Silver, Alex Graves, Ioannis Antonoglou, Daan Wierstra, and Martin Riedmiller. Playing Atari with Deep Reinforcement Learning. arXiv preprint arXiv:1312.5602v1, 2013.
+
+Volodymyr Mnih, Koray Kavukcuoglu, David Silver, Andrei A. Rusu, Joel Veness, Marc G. Bellemare, Alex Graves, Martin Riedmiller, Andreas K. Fidjeland, Georg Ostrovski, et al. Human-level control through deep reinforcement learning. Nature, 518(7540):529–533, 2015.
+
+Volodymyr Mnih, Adria Puigdomenech Badia, Mehdi Mirza, Alex Graves, Timothy Lillicrap, Tim Harley, David Silver, and Koray Kavukcuoglu. Asynchronous methods for deep reinforcement learning. In International Conference on Machine Learning, pp. 1928–1937, 2016.
+
+Ofir Nachum, Mohammad Norouzi, Kelvin Xu, and Dale Schuurmans. Bridging the Gap Between Value and Policy Based Reinforcement Learning. In 31st Conference on Neural Information Processing Systems, 2017.
+
+Brendan O’Donoghue, Remi Munos, Koray Kavukcuoglu, and Volodymyr Mnih. Combining policy ´ gradient and Q-learning. arXiv preprint arXiv:1611.01626v3, 2017.
+
+Junhyuk Oh, Xiaoxiao Guo, Honglak Lee, Richard L Lewis, and Satinder Singh. Action-Conditional Video Prediction using Deep Networks in Atari Games. In Advances in Neural Information Processing Systems, pp. 2863–2871, 2015.
+
+Junhyuk Oh, Valliappa Chockalingam, Satinder Singh, and Honglak Lee. Control of memory, active perception, and action in minecraft. In Proceedings of The 33rd International Conference on Machine Learning, pp. 2790–2799, 2016.
+
+Xue Bin Peng, Glen Berseth, and Michiel van de Penne. Terrain-Adaptive Locomotion Skills Using Deep Reinforcement Learning. ACM Transactions on Graphics, 35(4):81, 2016.
+
+Stephane Ross and J. Andrew Bagnell. Reinforcement and Imitation Learning via Interactive No-´ Regret Learning. arXiv preprint arXiv:1406.5979v1, 2014.
+
+Stephane Ross, Geoffrey J. Gordon, and J. Andrew Bagnell. A Reduction of Imitation Learning and ´ Structured Prediction to No-Regret Online Learning. In Proceedings of the Fourteenth International Conference on Artificial Intelligence and Statistics, pp. 627–635, 2011.
+
+John Schulman, Sergey Levine, Pieter Abbeel, Michael Jordan, and Philipp Moritz. Trust region policy optimization. In Proceedings of the 32nd International Conference on Machine Learning (ICML-15), pp. 1889–1897, 2015.
+
+John Schulman, Philipp Moritz, Sergey Levine, Michael I. Jordan, and Pieter Abbeel. HighDimensional Continuous Control Using Generalized Advantage Estimation. arXiv preprint arXiv:1506.02438v5, 2016.
+
+John Schulman, Xi Chen, and Pieter Abbeel. Equivalence Between Policy Gradients and Soft QLearning. arXiv preprint arXiv:1704.06440v1, 2017.
+
+Csaba Szepesvari. The Asymptotic Convergence-Rate of Q-learning. In ´ Advances in Neural Information Processing Systems, pp. 1064–1070, 1998.
+
+Oskari Tammelin. Solving Large Imperfect Information Games Using $\mathrm { C F R + }$ . arXiv preprint arXiv:1407.5042v1, 2014.
+
+Oskari Tammelin, Neil Burch, Michael Johanson, and Michael Bowling. Solving Heads-up Limit Texas Hold’em. In Proceedings of the 24th International Joint Conference on Artificial Intelligence, 2015.
+
+Hado van Hasselt and Marco A. Wiering. Reinforcement Learning in Continuous Action Spaces. In Proceedings of the 2007 IEEE Symposium on Approximate Dynamic Programming and Reinforcement Learning, pp. 272–279, 2007.
+
+Hado van Hasselt, Arthur Guez, and David Silver. Deep Reinforcement Learning and Double QLearning. In Proceedings of the Thirtieth AAAI Conference on Artificial Intelligence, 2016.
+
+Ziyu Wang, Tom Schaul, Matteo Hessel, Hado van Hasselt, Marc Lanctot, and Nando de Freitas. Dueling Network Architectures for Deep Reinforcement Learning. In Proceedings of the $3 3 r d$ International Conference on Machine Learning, pp. 1995–2003, 2016.
+
+Ziyu Wang, Victor Bapst, Nicolas Heess, Volodymyr Mnih, Remi Munos, Koray Kavukcuoglu, and Nando de Freitas. Sample Efficient Actor-Critic with Experience Replay. arXiv preprint arXiv:1611.01224v2, 2017.
+
+Kevin Waugh, Dustin Morrill, J. Andrew Bagnell, and Michael Bowling. Solving Games with Functional Regret Estimation. In Workshops at the Twenty-Ninth AAAI Conference on Artificial Intelligence, 2015. Supplementary material in arXiv preprint arXiv:1411.7974v2.
+
+Martin Zinkevich, Michael Johanson, Michael H. Bowling, and Carmelo Piccione. Regret Minimization in Games with Incomplete Information. In Advances in Neural Information Processing Systems 20, pp. 1729–1736, 2007.
+
+# 6 APPENDIX
+
+# 6.1 EXPERIMENTAL DETAILS
+
+# 6.1.1 PONG (ARCADE LEARNING ENVIRONMENT)
+
+We use the preprocessing and convolutional network model of (Mnih et al., 2013). Specifically, we view every 4th emulator frame, convert the raw frames to grayscale, and perform downsampling to generate a single observed frame. The input observation of the convnet is a concatenation of the most recent frames (either 4 frames or 1 frame). The convnet consists of an $8 \times 8$ convolution with stride 4 and 16 filters followed by ReLU, a $4 \times 4$ convolution with stride 2 and 32 filters followed by ReLU, a linear map with 256 filters followed by ReLU, and a linear map with $| { \cal A } |$ filters where $| { \cal A } |$ is the action space cardinality $\lvert \lvert A \rvert = 6$ for Pong).
+
+We used Adam with a constant learning rate of $\alpha = 1 0 ^ { - 4 }$ , a minibatch size of 32, and the moment decay rates set to their defaults $\beta _ { 1 } = 0 . 9$ and $\beta _ { 2 } = 0 . 9 9 9$ . Our results on each method are averaged across 3 random seeds.
+
+We ran ARM with the hyperparameters: sampling batch size of 12500, 4000/3000 minibatches of Adam for the first/subsequent sampling iterations respectively, and target update step size $\tau = 0 . 0 1$ . Double DQN uses the tuned hyperparameters (van Hasselt et al., 2016). Note that our choice of ARM hyperparameters yields an equivalent number of minibatch gradient updates per sample as used by DQN and double DQN, i.e. 1 minibatch gradient update per 4 simulator steps.
+
+# 6.1.2 DOOM (VIZDOOM)
+
+We used a convolutional network architecture similar to those of (Kempka et al., 2016) and (Dosovitskiy & Koltun, 2017). The Doom screen was rendered at a resolution of $1 6 0 \times 1 2 0$ and downsized to $8 4 \times 8 4$ . Only every 4th frame was rendered, and the input observation to the convnet is a concatenation of the last 4 rendered RGB frames for a total of 12 input channels. The convnet contains 3 convolutions with 32 filters each: the first is size $8 \times 8$ with stride 4, the second is size $4 \times 4$ with stride 2, and the third is size $3 \times 3$ with stride 1. The final convolution is followed by a linear map with 1024 filters. A second linear map yields the output. Hidden activations are gated by ReLUs.
+
+For “HealthGathering” only, we scaled rewards by a factor of 0.01. We did not scale rewards for “MyWayHome.” We used Adam with a constant learning rate of $\alpha = 1 0 ^ { - 5 }$ and a minibatch size of 32 to train all networks (except TRPO). For “HealthGathering” we set $\beta _ { 1 } = 0 . 9 5$ , whereas for “MyWayHome” we set $\beta _ { 1 } = 0 . 9$ . We set $\beta _ { 2 } = 0 . 9 9 9$ for both scenarios. Our results on each method are averaged across 3 random seeds.
+
+Double DQN and dueling double DQN: $n = 5$ step returns; update interval 30000; 1 minibatch gradient update per 4 simulator steps; replay memory uniform initialization size 50000; replay memory maximum size 240000; exploration period 240000; with final exploration rate $\epsilon = 0 . 0 1$ .
+
+A3C: 16 workers; $n = 2 0$ steps for “HealthGathering” and $n = 4 0$ steps for “MyWayHome”;   
+negentropy regularization $\beta = 0 . 0 1$ ; and gradient norm clip 5.
+
+TRPO: sampling batch size 12500; KL-divergence step size $\delta = 0 . 0 1$ ; 10 conjugate gradient iterations; and Fisher information/Gauss-Newton damping coefficient $\lambda = 0 . 1$ .
+
+ARM: $n = 5$ step returns; sampling batch size 12500; 4000 Adam minibatches in the first sampling iteration, 3000 Adam minibatches in all subsequent sampling iterations; target update step size $\tau = 0 . 0 1$ . Again, our choice of ARM hyperparameters yields an equivalent number of minibatch gradient updates per sample as used by DQN and double DQN. For “HealthGathering” only, because ARM converges so quickly we annealed the Adam learning rate to $\alpha = 2 . 5 \times 1 0 ^ { - 6 }$ after 500000 elapsed simulator steps.
+
+Off-policy ARM: $n = 5$ step returns; sampling batch size 1563, replay cache sample size 25000; 400 Adam minibatches per sampling iteration; target update step size $\tau = 0 . 0 1$ ; and importance sampling weight clip $c = 1$ .
+
+# 6.1.3 MINECRAFT (MALMO¨ )
+
+Our Minecraft tasks generally were the same as the ones used by Matiisen et al. (2017), with a few differences. Instead of using a continuous action space, we used a discrete action space with 4 move and turn actions. To aid learning on the last level (“L5”), we removed the reward penalty upon episode timeout and we increased the timeout on “L5” from 45 seconds to 75 seconds due to the larger size of the environment. We scaled rewards for all levels by 0.001.
+
+We use the same convolutional network architecture for Minecraft as we used for ViZDoom in Section 4.2. The Minecraft screen was rendered at a resolution of $3 2 0 \times 2 4 0$ and downsized to $8 4 \times$ 84. Only every 5th frame was rendered, and the input observation of the convnet is a concatenation of the last 4 rendered RGB frames for a total of 12 input channels. We used Adam with constant learning rate $\alpha = 1 0 ^ { - 5 }$ , moment decay rates $\beta _ { 1 } = 0 . 9$ and $\beta _ { 2 } = 0 . 9 9 9$ , and minibatch size 32 to train all networks (except TRPO). Our results on each method are averaged across 5 random seeds.
+
+Double DQN and dueling double DQN: $n = 5$ step returns; update interval 12500; 1 minibatch gradient update per 4 simulator steps; replay memory uniform initialization size 12500; replay memory maximum size 62500; exploration period 62500; with final exploration rate $\epsilon = 0 . 0 1$ .
+
+TRPO: sampling batch size 6250; KL-divergence step size $\delta = 0 . 0 1$ ; 10 conjugate gradient iterations; and Fisher information/Gauss-Newton damping coefficient $\lambda = 0 . 1$ .
+
+ARM: $n = 5$ step returns; sampling batch size 12500; 4000 Adam minibatches in the first sampling iteration, 3000 Adam minibatches in all subsequent sampling iterations; target update step size $\tau = 0 . 0 1$ .
+
+# 6.2 OFF-POLICY ARM VIA IMPORTANCE SAMPLING
+
+Our current approach to running ARM with off-policy data consists of applying an importance sampling correction directly to the $n$ -step returns. Given the behavior policy $\mu$ under which the data was sampled, the current policy $\pi _ { t }$ under which we want to perform estimation, and an importance sampling weight clip $c$ for variance reduction, the corrected $n$ -step return we use is:
+
+$$
+g _ { k } ^ { n } ( \mu \| \pi _ { t } ) = \sum _ { k ^ { \prime } = k } ^ { k + n - 1 } \gamma ^ { k ^ { \prime } - k } \left( \prod _ { \ell = k } ^ { k ^ { \prime } } w _ { \mu \| \pi _ { t } } ( a _ { \ell } | o _ { \ell } ) \right) r _ { k ^ { \prime } }
+$$
+
+where the truncated importance weight $\scriptstyle w _ { \mu \parallel \pi _ { t } } ( a | o )$ is defined (Ionides, 2008):
+
+$$
+w _ { \boldsymbol { \mu } \parallel \pi _ { t } } ( a | o ) = \operatorname* { m i n } \left( c , \frac { \pi _ { t } ( a | o ) } { \mu ( a | o ) } \right) .
+$$
+
+Our choice of $c = 1$ in our experiments was inspired by Wang et al. (2017). We found that $c = 1$ worked well but note other choices for $c$ may also be reasonable.
+
+When applying our importance sampling correction, we preserve all details of the ARM algorithm except for two aspects: the transition sampling strategy (a finite memory of previous batches are cached and uniformly sampled) and the regression targets for learning the value functions. Specifically, the regression targets $v ( o _ { k } ; \varphi )$ , $q ( o _ { k } , a _ { k } ; \varphi )$ , and $\bar { q } ^ { + } ( o _ { k } , a _ { k } ; \bar { \varphi } )$ (Equations (11)–(13)) are modified to the following:
+
+$$
+\begin{array} { r l } & { \quad v _ { \mu \parallel \pi _ { t } } ( o _ { k } ; \varphi ) = g _ { k } ^ { n } ( \mu \| \pi _ { t } ) + \gamma ^ { n } V ^ { \prime } ( o _ { k + n } ; \varphi ) } \\ & { \quad q _ { \mu \parallel \pi _ { t } } ( o _ { k } , a _ { k } ; \varphi ) = r _ { k } + \gamma w _ { \mu \parallel \pi _ { t } } ( a _ { k } | o _ { k } ) g _ { k + 1 } ^ { n - 1 } ( \mu \| \pi _ { t } ) + \gamma ^ { n } V ^ { \prime } ( o _ { k + n } ; \varphi ) } \\ & { \quad \bar { q } _ { \mu \parallel \pi _ { t } } ^ { + } ( o _ { k } , a _ { k } ; \varphi ) = \operatorname* { m a x } ( 0 , \bar { Q } _ { t - 1 } ^ { + } ( o _ { k } , a _ { k } ; \omega _ { t - 1 } ) - V _ { \pi _ { t - 1 } } ( o _ { k } ; \theta _ { t - 1 } ) ) + q _ { \mu \parallel \pi _ { t } } ( o _ { k } , a _ { k } ; \varphi ) . } \end{array}
+$$
+
+Note that the target value function $V ^ { \prime } ( o _ { k + n } ; \varphi )$ does not require an importance sampling correction because $V ^ { \prime }$ already approximates the on-policy value function $V _ { \pi _ { t } } \big ( o _ { k + n } ; \theta _ { t } \big )$ .
+
+# 6.3 ADDITIONAL EXPERIMENTS
+
+# 6.3.1 ATARI 2600 GAMES
+
+Although our primary interest is in partially observable reinforcement learning domains, we also want to check that ARM works in nearly fully observable and Markovian environments, such as
+
+Atari 2600 games. We consider two baselines: double deep Q-learning, and double deep fitted Qiteration which is a batch counterpart to double DQN. We find that double deep Q-learning is a strong baseline for learning to play Atari games, although ARM still successfully learns interesting policies. One major benefit of Q-learning-based methods is the ability to utilize a large off-policy replay memory. Our results on a suite of Atari games are in Figure 5.
+
+![](images/785ce79df806fb81361c2e129888ddc1c489cd18e3df2c9458a2b66c42dc610d.jpg)  
+Figure 5: Comparing double deep Q-learning (orange), double deep fitted Q-iteration (red), and ARM (blue) on a suite of seven Atari games from the Arcade Learning Environment. For each method, we plot the mean across 3 trials along with standard error bars.
+
+# 6.3.2 RECURRENCE IN DOOM MYWAYHOME
+
+We evaluated the effect of recurrent policy and value function estimation in the maze-like MyWayHome scenario of ViZDoom. We found that recurrence has a small positive effect on the convergence of A2C (Mnih et al., 2016), but was much less significant than the choice of algorithm. Our hyperparameters were similar to those described for A3C in Section 6.1.2, except we used a learning rate $\mathrm { \dot { 1 } 0 ^ { - 4 } }$ and gradient norm clip 0.5. For the recurrent policy and value function, we replaced the first fully connected operation with an LSTM featuring an equivalent number of hidden units (1024).
+
+![](images/c2b69a73a11245bd1cb2c803496cf6279e9e9540805079b1798a35ff8d4befbc.jpg)  
+Figure 6: Comparing A2C with a feedforward convolutional network (blue) and a recurrent convolutional-LSTM network (orange) on the ViZDoom scenario MyWayHome.

parse/train/BkCV_W-AZ/BkCV_W-AZ_content_list.json

@@ -0,0 +1,1972 @@
+[
+    {
+        "type": "text",
+        "text": "REGRET MINIMIZATION FOR PARTIALLY OBSERVABLE DEEP REINFORCEMENT LEARNING ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            98,
+            823,
+            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": "Deep reinforcement learning algorithms that estimate state and state-action value functions have been shown to be effective in a variety of challenging domains, including learning control strategies from raw image pixels. However, algorithms that estimate state and state-action value functions typically assume a fully observed state and must compensate for partial or non-Markovian observations by using finite-length frame-history observations or recurrent networks. In this work, we propose a new deep reinforcement learning algorithm based on counterfactual regret minimization that iteratively updates an approximation to a cumulative clipped advantage function and is robust to partially observed state. We demonstrate that on several partially observed reinforcement learning tasks, this new class of algorithms can substantially outperform strong baseline methods: on Pong with single-frame observations, and on the challenging Doom (ViZDoom) and Minecraft (Malmo) first-person navigation benchmarks. ¨ ",
+        "bbox": [
+            233,
+            268,
+            764,
+            449
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 INTRODUCTION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            479,
+            336,
+            496
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Many reinforcement learning problems of practical interest have the property of partial observability, where observations of state are generally non-Markovian. Despite the importance of partial observation in the real world, value function-based methods such as Q-learning (Mnih et al., 2013; 2015) generally assume a Markovian observation space. On the other hand, Monte Carlo policy gradient methods do not assume Markovian observations, but many practical policy gradient methods such as A3C (Mnih et al., 2016) introduce the Markov assumption when using a critic or state-dependent baseline in order to improve sample efficiency. ",
+        "bbox": [
+            174,
+            513,
+            825,
+            609
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Consider deep reinforcement learning methods that learn a state or state-action value function. One common workaround for the problem of partial observation is to learn value functions on the space of finite-length frame-history observations, under the assumption that frame-histories of sufficient length will give the environment the approximate appearance of full observability. When learning to play Atari 2600 games from images, deep Q-learning algorithms (Mnih et al., 2013; 2015) concatenate the last 4 observed frames of the video screen buffer as input to a state-action value convolutional network. Not all non-Markovian tasks are amenable to finite-length frame-histories; recurrent value functions can incorporate longer and potentially infinite histories (Hausknecht & Stone, 2017; Foerster et al., 2016), but at the cost of solving a harder optimization problem. Can we develop methods that learn a variant of the value function that is more robust to partial observability? ",
+        "bbox": [
+            174,
+            617,
+            825,
+            756
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Our contribution is a new model-free deep reinforcement learning algorithm based on the principle of regret minimization which does not require access to a Markovian state. Our method learns a policy by estimating a cumulative clipped advantage function, which is an approximation to a type of regret that is central to two partial information game-solving algorithms from which we draw our primary inspiration: counterfactual regret minimization (CFR) (Zinkevich et al., 2007) and $\\mathrm { C F R + }$ (Tammelin, 2014). Hence we call our algorithm “advantage-based regret minimization” (ARM). ",
+        "bbox": [
+            174,
+            763,
+            823,
+            847
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "We evaluate our approach on three visual reinforcement learning domains: Pong with varying framehistory lengths (Bellemare et al., 2013), and the first-person games Doom (Kempka et al., 2016) and Minecraft (Johnson et al., 2016). Doom and Minecraft exhibit a first-person viewpoint in a 3- dimensional environment and should appear non-Markovian even with frame-history observations. We find that our method offers substantial improvement over prior methods in these partially observable environments: on both Doom and Minecraft, our method can learn well-performing policies within about 1 million simulator steps using only visual input frame-history observations. ",
+        "bbox": [
+            174,
+            854,
+            823,
+            924
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            103,
+            823,
+            132
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2 RELATED WORK ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            151,
+            344,
+            167
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Deep reinforcement learning algorithms have been demonstrated to achieve excellent results on a range of complex tasks, including playing games (Mnih et al., 2015; Oh et al., 2016) and continuous control (Schulman et al., 2015; Lillicrap et al., 2016; Levine et al., 2016). Prior deep reinforcement learning algorithms either learn state or state-action value functions (Mnih et al., 2013), learn policies using policy gradients (Schulman et al., 2015), or perform a combination of the two using actor-critic architectures (Mnih et al., 2016). Policy gradient methods typically do not need to assume a Markovian state, but tend to suffer from poor sample complexity, due to their inability to use off-policy data. Methods based on learning Q-functions can use replay buffers to include off-policy data, accelerating learning (Lillicrap et al., 2016). However, learning Q-functions with Bellman error minimization typically requires a Markovian state space. When learning from observations such as images, the inputs might not be Markovian. Prior methods have proposed to mitigate this issue by using recurrent critics and Q-functions (Hausknecht & Stone, 2017; Oh et al., 2016; Mnih et al., 2016; Heess et al., 2015), and learning Q-functions that depend on entire histories of observations. Heuristics such as concatenation of short observation sequences have also been used (Mnih et al., 2015). However, all of these changes increase the size of the input space, increasing variance, and make the optimization problem more complex. Our method instead learns cumulative advantage functions that depend only on the current state, but can still handle non-Markovian problems. ",
+        "bbox": [
+            174,
+            184,
+            825,
+            419
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "The form of our advantage function update resembles positive temporal difference methods (Peng et al., 2016; van Hasselt & Wiering, 2007). Additionally, our update rule for a modified cumulative Q-function resembles the average Q-function (Anschel et al., 2017) used for variance reduction in Q-learning. In both cases, the theoretical foundations of our method are based on cumulative regret minimization, and the motivation is substantively different. Previous work by Ross et al. (2011); Ross & Bagnell (2014) has connected regret minimization to reinforcement learning, imitation learning, and structured prediction, although not with counterfactual regret minimization. Regression regret matching (Waugh et al., 2015) is based on a closely related idea, which is to directly approximate the regret with a linear regression model, however the use of a linear model is limited in representation compared to deep function approximation. ",
+        "bbox": [
+            174,
+            426,
+            825,
+            565
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "3 ADVANTAGE-BASED REGRET MINIMIZATION ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            584,
+            578,
+            601
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "In this section, we provide background on CFR and $\\mathrm { C F R + }$ , describe ARM in detail, and give some intuition for why ARM works. ",
+        "bbox": [
+            173,
+            616,
+            823,
+            643
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "3.1 COUNTERFACTUAL REGRET MINIMIZATION (CFR) ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            660,
+            563,
+            675
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "In this section we review the algorithm of counterfactual regret minimization (Zinkevich et al., 2007). We closely follow the version of CFR as described in the Supplementary Material of Bowling et al. (2015), except that we try to use the notation of reinforcement learning where appropriate. ",
+        "bbox": [
+            174,
+            686,
+            825,
+            728
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Consider the setting of an extensive game. There are $N$ players numbered $i = 1 , \\ldots , N$ . An additional player may be considered a “chance” player to simulate random events. At each time step of the game, one player chooses an action $a \\in A _ { i }$ . Define the following concepts and notation: ",
+        "bbox": [
+            176,
+            736,
+            825,
+            779
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "• Sequences: A sequence specifically refers to a sequence of actions starting from an initial game state. (It is assumed that a sequence of actions, including actions of the “chance” player, is sufficient for defining state within the extensive game.) Let $\\mathcal { H }$ be the space of all sequences, and let $\\mathcal { Z }$ be the space of terminal sequences.   \nInformation sets: Let $\\mathcal { T }$ be the space of information sets; that is, for each $I \\in \\mathcal { Z }$ , $I$ is a set of sequences $h \\in I$ which are indistinguishable to the current player. Information sets are a represention of partial observability.   \nStrategies: Let $\\pi _ { i } ( a | I )$ be the strategy of the $i$ -th player, where $\\pi _ { i } ( a | I )$ is a probability distribution over action $a$ conditioned on information set $I$ . Let $\\pi = ( \\pi _ { 1 } , \\ldots , \\pi _ { N } )$ denote ",
+        "bbox": [
+            215,
+            790,
+            825,
+            924
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "the strategy profile for all players, and let $\\pi _ { - i } = ( \\pi _ { 1 } , \\ldots , \\pi _ { i - 1 } , \\pi _ { i + 1 } , \\ldots , \\pi _ { N } )$ denote the strategy profile for all players except the $i$ -th player. ",
+        "bbox": [
+            225,
+            103,
+            823,
+            132
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "• Sequence probabilities: Let $\\rho ^ { \\pi } ( h )$ be the probability of reaching the sequence $h$ when all players follow $\\pi$ . Additionally, let $\\rho ^ { \\pi } ( h , h ^ { \\prime } )$ be the probability of reaching $h ^ { \\prime }$ conditioned on $h$ having already been reached. Similarly, define $\\rho _ { i } ^ { \\pi }$ and $\\rho _ { - i } ^ { \\pi }$ to contain the contributions of respectively only the $i$ -th player or of all players except the $i$ -th. ",
+        "bbox": [
+            217,
+            136,
+            825,
+            193
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "• Values: Let $u _ { i } ( z )$ be the value of a terminal sequence $z$ to the $i$ -th player. Let the expected value of a strategy profile $\\pi$ to the $i$ -th player be $\\begin{array} { r } { J _ { i } ( \\pi ) = \\sum _ { z \\in Z } \\rho ^ { \\bar { \\pi } } ( z ) u _ { i } ( z ) } \\end{array}$ . ",
+        "bbox": [
+            217,
+            195,
+            825,
+            227
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Define the counterfactual value $Q _ { \\pi , i } ^ { \\mathrm { C F } }$ of all players following strategy $\\pi$ , except the $i$ -th player plays to reach information set and to then take action $a$ : ",
+        "bbox": [
+            174,
+            237,
+            821,
+            266
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/88abbee838cbafa4b7110d39b93b3ddf80870cdaa7356cd25e48d9a60b43cbd4.jpg",
+        "text": "$$\nQ _ { \\pi , i } ^ { \\mathrm { C F } } ( I , a ) = \\sum _ { h \\in I } \\sum _ { z \\in \\mathcal { Z } : h \\sqsubseteq z } \\rho _ { - i } ^ { \\pi } ( z ) \\rho _ { i } ^ { \\pi | I  a } ( h , z ) u _ { i } ( z ) .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            325,
+            268,
+            673,
+            304
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "The notation $h \\sqsubset h ^ { \\prime }$ denotes that $h$ is a prefix of $h ^ { \\prime }$ , while $\\pi | I  a$ denotes that action $a$ is to be performed when $I$ is observed. The counterfactual value $Q _ { \\pi , i } ^ { \\mathrm { C F } } ( I , a )$ is a calculation that assumes the $i$ -th player reaches any $h \\in I$ , and upon reaching any $h \\in I$ it always chooses $a$ . ",
+        "bbox": [
+            174,
+            309,
+            826,
+            353
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Consider a learning scenario where at the $t$ -th iteration the players follow a strategy profile $\\pi ^ { t }$ . The $i$ -th player’s regret after $T$ iterations is defined in terms of the $i$ -th player’s optimal strategy $\\pi _ { i } ^ { * }$ : ",
+        "bbox": [
+            173,
+            359,
+            823,
+            388
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/98e1fee090244906b394537eb68957dfa7e5b12c9e0331f246f0bcdd7fc2be40.jpg",
+        "text": "$$\nR _ { i } ^ { T } = \\sum _ { t = 0 } ^ { T - 1 } J _ { i } ( ( \\pi _ { 1 } ^ { t } , \\cdot \\cdot \\cdot , \\pi _ { i - 1 } ^ { t } , \\pi _ { i } ^ { * } , \\pi _ { i + 1 } ^ { t } , \\cdot \\cdot \\cdot , \\pi _ { N } ^ { t } ) ) - J _ { i } ( \\pi ^ { t } ) .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            303,
+            393,
+            694,
+            438
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "The average regret is the average over learning iterations: $( 1 / T ) R _ { i } ^ { T }$ . Now define the counterfactual regret of the $i$ -th player for taking action $a$ at information set $I$ : ",
+        "bbox": [
+            174,
+            444,
+            821,
+            473
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/266c4eee562ba8164965686fbd7ea075f7e24b13e6703afd7bdd82eb7caba22e.jpg",
+        "text": "$$\n\\begin{array} { r l } & { ( R _ { i } ^ { \\mathrm { ( C F ) } } ) ^ { T } ( I , a ) = \\displaystyle \\sum _ { t = 0 } ^ { T - 1 } \\left( Q _ { \\pi ^ { t } , i } ^ { \\mathrm { C F } } ( I , a ) - \\sum _ { a ^ { \\prime } \\in A } \\pi _ { i } ^ { t } ( a ^ { \\prime } | I ) Q _ { \\pi ^ { t } , i } ^ { \\mathrm { C F } } ( I , a ^ { \\prime } ) \\right) } \\\\ & { \\quad \\quad \\quad \\quad = ( R _ { i } ^ { \\mathrm { ( C F ) } } ) ^ { T - 1 } ( I , a ) + Q _ { \\pi ^ { T - 1 } , i } ^ { \\mathrm { C F } } ( I , a ) - \\displaystyle \\sum _ { a ^ { \\prime } \\in A } \\pi _ { i } ^ { T - 1 } ( a ^ { \\prime } | I ) Q _ { \\pi ^ { T - 1 } , i } ^ { \\mathrm { C F } } ( I , a ^ { \\prime } ) . } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            214,
+            479,
+            784,
+            559
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "The counterfactual regret (Equation (3)) can be shown to majorize the regret (Equation (2)) (Theorem 3, Zinkevich et al. (2007)). CFR can then be described as a learning algorithm where the strategy is updated using regret matching (Hart & Mas-Colell, 2000) applied to the counterfactual regret calculated in the most recent iteration: ",
+        "bbox": [
+            176,
+            563,
+            825,
+            618
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/3cae9e16be414bec467d7401c5feceb58bf64a20f6d65b50ee507711ec236601.jpg",
+        "text": "$$\n\\pi _ { i } ^ { T + 1 } ( a | I ) = \\left\\{ \\begin{array} { l l } { \\frac { \\operatorname* { m a x } ( 0 , ( R _ { i } ^ { \\mathrm { ( C F ) } } ) ^ { T + 1 } ( I , a ) ) } { \\sum _ { a ^ { \\prime } \\in A } \\operatorname* { m a x } ( 0 , ( R _ { i } ^ { \\mathrm { ( C F ) } } ) ^ { T + 1 } ( I , a ^ { \\prime } ) ) } } & { \\mathrm { i f } \\sum _ { a ^ { \\prime } \\in A } \\operatorname* { m a x } ( 0 , ( R _ { i } ^ { \\mathrm { ( C F ) } } ) ^ { T + 1 } ( I , a ^ { \\prime } ) ) > 0 } \\\\ { \\frac { 1 } { | A | } } & { \\mathrm { o t h e r w i s e } . } \\end{array} \\right.\n$$",
+        "text_format": "latex",
+        "bbox": [
+            196,
+            625,
+            781,
+            674
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "If all players follow the CFR regret matching strategy (Equation (5)), then at the $T$ -th iteration the players’ average regrets are bounded by ${ \\cal O } ( T ^ { - 1 / 2 } )$ (Theorem 4, Zinkevich et al. (2007)). ",
+        "bbox": [
+            171,
+            679,
+            825,
+            710
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3.2 $\\mathrm { C F R + }$ ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            726,
+            258,
+            739
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "$\\mathrm { C F R + }$ (Tammelin, 2014) consists of a modification to CFR, in which instead of calculating the full counterfactual regret as in (4), instead the counterfactual regret is recursively positively clipped to yield the clipped counterfactual regret: ",
+        "bbox": [
+            173,
+            751,
+            825,
+            794
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/91e78d1e40a3505e02e4d5b3d603ae18acd740eafde0079349ca0df45fbfab1f.jpg",
+        "text": "$$\n( R _ { i } ^ { \\mathrm { ( C F + } } ) ^ { T } ( I , a ) = \\operatorname* { m a x } ( 0 , ( R _ { i } ^ { \\mathrm { ( C F + } } ) ) ^ { T - 1 } ( I , a ) ) + Q _ { \\pi ^ { T - 1 } , i } ^ { \\mathrm { C F } } ( I , a ) - \\sum _ { a ^ { \\prime } \\in A } \\pi _ { i } ^ { T - 1 } ( a ^ { \\prime } | I ) Q _ { \\pi ^ { T - 1 } , i } ^ { \\mathrm { C F } } ( I , a ^ { \\prime } ) .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            181,
+            799,
+            820,
+            833
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Comparing Equation (4) with Equation (6), one can see that the only difference in CFR is that the previous iteration’s counterfactual regret is positively clipped in the recursion. The one-line change of $\\mathrm { C F R + }$ turns out to yield a large practical improvement in the performance of the algorithm (Bowling et al., 2015), and there is also an associated regret bound for $\\mathrm { C F R + }$ that is as strong as the bound for CFR (Tammelin et al., 2015). ",
+        "bbox": [
+            173,
+            853,
+            825,
+            924
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3.3 FROM CFR AND $\\mathrm { C F R + }$ TO ARM ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            103,
+            442,
+            117
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "CFR and $\\mathrm { C F R + }$ are formulated for imperfect information extensive-form games, so they are naturally generalized to partially observed stochastic games since a stochastic game can always be represented in extensive form. A 1-player partially observed stochastic game is simply a POMDP with observation space $\\mathcal { O }$ (Littman, 1994). By mapping information sets $I \\in \\mathcal { T }$ to observations $o \\in \\mathcal { O }$ e counterfactual value as a kind of statio that assumes the agent follows the policy ary observation-actioexcept on observing value, after $Q _ { \\pi , i } ^ { \\mathrm { C F } } ( I , a ) \\equiv Q _ { \\pi | o \\mapsto a } ^ { ( \\mathrm { s t a t } ) } ( o , a )$ $\\pi$ $o$ $a$ $Q _ { \\pi | o \\mapsto a } ^ { ( \\mathrm { s t a t } ) } ( o , a ) \\approx Q _ { \\pi } ( o , a )$ , where $Q _ { \\pi }$ is the usual action value function, is valid when observations are rarely seen more than once in a trajectory. By approximating $Q _ { \\pi | o \\mapsto a } ^ { ( \\mathrm { s t a t } ) } ( o , a ) \\approx Q _ { \\pi } ( o , a )$ , we get a recurrence in terms of more familiar value functions (compare Equations (6) and (7)): ",
+        "bbox": [
+            173,
+            128,
+            825,
+            284
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/e29127386e43d87b927f420a09d485b4512f37e9eb1083e88ac4d1c208ac5541.jpg",
+        "text": "$$\n\\begin{array} { l } { \\bar { A } _ { t } ^ { + } ( o _ { k } , a _ { k } ) = \\operatorname* { m a x } ( 0 , \\bar { A } _ { t - 1 } ^ { + } ( o _ { k } , a _ { k } ) ) + Q _ { \\pi _ { t } } ( o _ { k } , a _ { k } ) - { \\displaystyle \\sum _ { a ^ { \\prime } \\in \\mathcal { A } } } \\pi _ { t } ( a ^ { \\prime } | o _ { k } ) Q _ { \\pi _ { t } } ( o _ { k } , a ^ { \\prime } ) } \\\\ { = \\operatorname* { m a x } ( 0 , \\bar { A } _ { t - 1 } ^ { + } ( o _ { k } , a _ { k } ) ) + Q _ { \\pi _ { t } } ( o _ { k } , a _ { k } ) - V _ { \\pi _ { t } } ( o _ { k } ) } \\\\ { = \\operatorname* { m a x } ( 0 , \\bar { A } _ { t - 1 } ^ { + } ( o _ { k } , a _ { k } ) ) + A _ { \\pi _ { t } } ( o _ { k } , a _ { k } ) } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            228,
+            287,
+            766,
+            366
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "where $\\bar { A } _ { t } ^ { + } ( o , a )$ is the cumulative clipped advantage function, and $A _ { \\pi _ { t } } ( o , a )$ is the ordinary advantage function evaluated at policy $\\pi _ { t }$ . Advantage-based regret minimization (ARM) is the resulting reinforcement learning algorithm that updates the policy to regret match on the cumulative clipped advantage function: ",
+        "bbox": [
+            174,
+            368,
+            825,
+            425
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/00a8dd0f887669543e408d791345c087c22c8147b6dfc387db7fec7cd3ff96ae.jpg",
+        "text": "$$\n\\pi _ { t + 1 } ( a _ { k } | o _ { k } ) = \\left\\{ \\begin{array} { l l } { \\frac { \\operatorname* { m a x } ( 0 , \\bar { A } _ { t } ^ { + } ( o _ { k } , a _ { k } ) ) } { \\sum _ { a ^ { \\prime } \\in A } \\operatorname* { m a x } ( 0 , \\bar { A } _ { t } ^ { + } ( o _ { k } , a ^ { \\prime } ) ) } } & { \\mathrm { i f ~ } \\sum _ { a ^ { \\prime } \\in A } \\operatorname* { m a x } ( 0 , \\bar { A } _ { t } ^ { + } ( o _ { k } , a ^ { \\prime } ) ) > 0 } \\\\ { \\frac { 1 } { | \\bar { A } | } } & { \\mathrm { o t h e r w i s e } . } \\end{array} \\right.\n$$",
+        "text_format": "latex",
+        "bbox": [
+            238,
+            429,
+            758,
+            479
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Equations (9) and (10) suggest the outline of a batch-mode deep reinforcement learning algorithm. At the $t$ -th sampling iteration, a batch of data is collected by sampling trajectories using the current policy $\\pi _ { t }$ , followed by two processing steps: (a) fit $\\bar { A } _ { t } ^ { + }$ using Equation (9), then (b) set the next iteration’s policy $\\pi _ { t + 1 }$ using Equation (10). ",
+        "bbox": [
+            176,
+            483,
+            823,
+            540
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3.4 IMPLEMENTATION OF ARM ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            555,
+            406,
+            570
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "To implement Equation (9) with deep function approximation, we define two value function approximations, $V _ { \\pi _ { t } } \\left( o _ { k } ; \\theta _ { t } \\right)$ and $\\bar { Q } _ { t } ^ { + } ( o _ { k } , a _ { k } ; \\omega _ { t } )$ , as well as a target value function $V ^ { \\prime } ( o _ { k } ; \\varphi )$ , where $\\theta _ { t } , \\omega _ { t }$ , and $\\varphi$ are the learnable parameters. The cumulative clipped advantage function is represented as $\\bar { A } _ { t } ^ { + } ( \\dot { o } _ { k } , a _ { k } ) = \\bar { Q } _ { t } ^ { + } ( o _ { k } , \\dot { a _ { k } } ; \\omega _ { t } ) - V _ { \\pi _ { t } } ( o _ { k } ; \\theta _ { t } )$ . Within each sampling iteration, the value functions are fitted using stochastic gradient descent by sampling minibatches and performing gradient steps. The state-value function $V _ { \\pi _ { t } } ( o _ { k } ; \\theta _ { t } )$ is fit to minimize an $n$ -step temporal difference loss with a moving target $V ^ { \\prime } ( o _ { k + n } ; \\varphi )$ , essentially using the estimator of the deep deterministic policy gradient (DDPG) (Lillicrap et al., 2016). In the same minibatch, $\\bar { Q } _ { t } ^ { + } ( o _ { k } , a _ { k } ; \\theta _ { t } )$ is fit to a similar loss, but with an additional target reward bonus that incorporates the previous iteration’s cumulative clipped advantage, $\\operatorname* { m a x } ( 0 , \\bar { A } _ { t - 1 } ^ { \\mp } ( o _ { k } , a _ { k } ) )$ . The regression targets $v ( o _ { k } ; \\varphi )$ and $\\bar { q } ^ { + } ( o _ { k } , a _ { k } ; \\varphi )$ are defined in terms of the $n$ -step returns $\\begin{array} { r } { g _ { k } ^ { n } = \\sum _ { k ^ { \\prime } = k } ^ { k + n - 1 } \\gamma ^ { k ^ { \\prime } - k } r _ { k ^ { \\prime } } } \\end{array}$ ",
+        "bbox": [
+            173,
+            580,
+            825,
+            742
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/f28bc657f0bd394364ac682cb887ba79893917e08a2a822a0e96e9def84b670a.jpg",
+        "text": "$$\n\\begin{array} { r l } & { \\qquad v ( o _ { k } ; \\varphi ) \\triangleq g _ { k } ^ { n } + \\gamma ^ { n } V ^ { \\prime } ( o _ { k + n } ; \\varphi ) } \\\\ & { \\qquad q ( o _ { k } , a _ { k } ; \\varphi ) \\triangleq r _ { k } + \\gamma g _ { k + 1 } ^ { n - 1 } + \\gamma ^ { n } V ^ { \\prime } ( o _ { k + n } ; \\varphi ) } \\\\ & { \\qquad q ^ { + } ( o _ { k } , a _ { k } ; \\varphi ) \\triangleq \\operatorname* { m a x } ( 0 , \\bar { Q } _ { t - 1 } ^ { + } ( o _ { k } , a _ { k } ; \\omega _ { t - 1 } ) - V _ { \\pi _ { t - 1 } } ( o _ { k } ; \\theta _ { t - 1 } ) ) + q ( o _ { k } , a _ { k } ; \\varphi ) . } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            235,
+            746,
+            761,
+            810
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Altogether, each minibatch step of the optimization subproblem consists of the following three parameter updates in terms of the regression targets $v ( o _ { k } ; \\varphi )$ and $\\bar { q } ^ { + } ( o _ { k } , a _ { k } ; \\varphi )$ : ",
+        "bbox": [
+            174,
+            811,
+            820,
+            840
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/54daf7a6d7b822377ba971ff9cf7f7de6ecbec704169a5a4217b79fc9f66f892.jpg",
+        "text": "$$\n\\begin{array} { r l } & { \\theta _ { t } ^ { ( \\ell + 1 ) }  \\theta _ { t } ^ { ( \\ell ) } - \\frac { \\alpha } { 2 } \\nabla _ { \\theta _ { t } ^ { ( \\ell ) } } ( V _ { \\pi _ { t } } ( o _ { k } ; \\theta _ { t } ^ { ( \\ell ) } ) - v ( o _ { k } ; \\varphi ^ { ( \\ell ) } ) ) ^ { 2 } } \\\\ & { \\omega _ { t } ^ { ( \\ell + 1 ) }  \\omega _ { t } ^ { ( \\ell ) } - \\frac { \\alpha } { 2 } \\nabla _ { \\omega _ { t } ^ { ( \\ell ) } } ( \\bar { Q } _ { t } ^ { + } ( o _ { k } , a _ { k } ; \\omega _ { t } ^ { ( \\ell ) } ) - \\bar { q } ^ { + } ( o _ { k } , a _ { k } ; \\varphi ^ { ( \\ell ) } ) ) ^ { 2 } } \\\\ & { \\varphi ^ { ( \\ell + 1 ) }  \\varphi ^ { ( \\ell ) } + \\tau ( \\theta _ { t } ^ { ( \\ell + 1 ) } - \\varphi ^ { ( \\ell ) } ) . } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            284,
+            844,
+            712,
+            924
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "table",
+        "img_path": "images/e4a9a6d5fda0b6f53f78a15d89e91c7fd4a6d6733234a94d222a6af083a63ce6.jpg",
+        "table_caption": [
+            "Algorithm 1 Advantage-based regret minimization (ARM). "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>initialize πo ←uniform,θ-1,ω-1 ←arbitrary for tin O,...do collect batch of trajectory data Dt ~ t initialize0t←0t-1,Wt←Wt-1,←0t-1 forlinO,...do sample transitions (Ok,ak,rk,.::, Ok+n-1,ak+n-1,rk+n-1,Ok+n) ~ Dt</td></tr><tr><td>calculate n-step returns g = ∑k=k k+n-1 k&#x27;-krk&#x27; set δk+n ← I[ok+n is terminal] if t=O then set k←0</td></tr><tr><td>else setΦk ←max(0,Qt-1(Ok,ak; Wt-1) -Vπt-1(Ok;0t-1)) end if</td></tr><tr><td>set v(ok) ←gκ+γn(1-δk+n)V&#x27;(0k+n;φ) update 0t with step size α and targets v(ok) (Equation (14))</td></tr><tr><td>update Wt with step size α and targets q+(Ok, ak) (Equation (15)) update  with moving average step size T (Equation (16)) end for set πt+1(alo) x max(0,Qt(o,a; wt)-Vπt(o;0t))</td></tr></table>",
+        "bbox": [
+            176,
+            119,
+            707,
+            420
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "The overall advantage-based regret minimization algorithm is summarized in Algorithm 1. ",
+        "bbox": [
+            169,
+            446,
+            764,
+            462
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "We note that the mechanics of the ARM updates are similar to on-policy value function estimation, but ARM learns a modified on-policy Q-function from transitions with the added reward bonus $\\operatorname* { m a x } ( 0 , \\bar { A } _ { t - 1 } ^ { + } ( o _ { k } , a _ { k } ) )$ (Equation (13)). This reward bonus can be thought of a kind of “optimism in the face of uncertainty.” ",
+        "bbox": [
+            173,
+            468,
+            825,
+            525
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "3.5 ARM VS. EXISTING POLICY GRADIENT METHODS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            541,
+            555,
+            555
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "In this section, we accentuate that ARM represents an inherently different update compared to existing policy gradient methods. ",
+        "bbox": [
+            171,
+            566,
+            823,
+            595
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Recent work has shown that policy gradient methods and Q-learning methods are connected via entropy regularization (O’Donoghue et al., 2017; Haarnoja et al., 2017; Nachum et al., 2017; Schulman et al., 2017; Anonymous, 2018). One perspective is from the soft policy iteration framework for batch-mode reinforcement learning (Anonymous, 2018), where at each batch iteration the updated policy is obtained by minimizing the average KL-divergence between the policy class $\\Pi$ and a target policy $f$ . Below is the soft policy iteration update, where the subscript $t$ refers to the batch iteration: ",
+        "bbox": [
+            176,
+            602,
+            823,
+            686
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/00a1130ebc139d37dd043b6c527b1640657ed3cb585175e1fc8c7245df40ec1e.jpg",
+        "text": "$$\n\\begin{array} { r l } & { \\pi _ { t + 1 } \\gets \\arg \\underset { \\pi \\in \\Pi } { \\operatorname* { m i n } } \\mathbb { E } _ { o \\sim \\rho _ { t } } [ D _ { \\mathrm { K L } } ( \\pi \\| f ) ] } \\\\ & { \\qquad = \\arg \\underset { \\pi \\in \\Pi } { \\operatorname* { m i n } } \\mathbb { E } _ { o \\sim \\rho _ { t } } [ \\mathbb { E } _ { a \\sim \\pi ( \\cdot | o ) } [ \\log ( \\pi ( a | o ) ) - \\log ( f ( a | o ) ) ] ] . } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            292,
+            691,
+            705,
+            742
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Using the connection between policy gradient methods and Q-learning, we define the policy gradient target policy as the softmax distribution on the entropy regularized advantage function Aβ-soft: ",
+        "bbox": [
+            173,
+            746,
+            826,
+            775
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/66769bc45464b30009cc10fa228d4d1a4bed06a06020ce6941430dce238b48d5.jpg",
+        "text": "$$\nf ^ { \\mathrm { P G } } ( a | o ) \\triangleq \\frac { \\exp ( \\beta A _ { t } ^ { \\beta \\mathrm { - s o f t } } ( o , a ) ) } { \\sum _ { a ^ { \\prime } \\in \\mathcal { A } } \\exp ( \\beta A _ { t } ^ { \\beta \\mathrm { - s o f t } } ( o , a ^ { \\prime } ) ) } .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            361,
+            780,
+            637,
+            820
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "We note that it is more conventional in the literature to use the soft Q-function $Q ^ { \\beta - \\mathrm { s o f t } } ( o , a )$ rather than the soft advantage function $A ^ { \\beta - \\mathrm { s o f t } } ( o , a )$ , however since they differ only by a function of $o$ then they both induce the same target softmax policy. Now, parameterizing the policy $\\pi$ in terms of an explicit parameter $\\theta$ , we obtain the expression for the existing policy gradient, where $b ( o )$ is a baseline function: ",
+        "bbox": [
+            174,
+            827,
+            825,
+            897
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/eec5ec662c0f38f1ec6fe3bd9666cad720b22a21d64536f058d3ded2bf44f492.jpg",
+        "text": "$$\n\\Delta \\theta ^ { \\mathrm { P G } } \\propto \\mathbb { E } _ { o \\sim \\rho _ { t } } [ \\mathbb { E } _ { a \\sim \\pi ( \\cdot | a ; \\theta ) } [ \\nabla _ { \\theta } \\log ( \\pi ( o | a ; \\theta ) ) ( ( 1 / \\beta ) \\log ( \\pi ( o | a ; \\theta ) ) - A _ { t } ^ { \\beta \\sim \\mathrm { o f f } } ( o , a ) + b ( o ) ) ] ] .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            181,
+            900,
+            789,
+            921
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "The classic policy gradient arises in the limit $\\beta \\to \\infty$ . ",
+        "bbox": [
+            174,
+            103,
+            527,
+            118
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Note that an alternative choice of target policy $f$ will lead to a different kind of policy gradient update. A policy gradient algorithm based on ARM instead proposes the following target policy based on the regret-matching distribution: ",
+        "bbox": [
+            173,
+            125,
+            825,
+            166
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "equation",
+        "img_path": "images/a05657fdd36fd48acdef7772662f7dddff9cb39a07b094a899127d73f40780c8.jpg",
+        "text": "$$\nf ^ { \\mathrm { A R M } } ( a | o ) \\triangleq \\frac { \\operatorname* { m a x } ( 0 , \\bar { A } _ { t } ^ { + } ( o , a ) ) } { \\sum _ { a ^ { \\prime } \\in \\mathcal { A } } \\operatorname* { m a x } ( 0 , \\bar { A } _ { t } ^ { + } ( o , a ^ { \\prime } ) ) } .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            359,
+            170,
+            638,
+            208
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Similarly, we can express the ARM-like policy gradient, where again $b ( o )$ is a baseline: ",
+        "bbox": [
+            174,
+            212,
+            746,
+            227
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "equation",
+        "img_path": "images/a8d6ae8c1234e8136539588f9f25a1172298321b065c32764e9c8b0a238335f5.jpg",
+        "text": "$$\n\\begin{array} { r } { \\mathtt { D } \\theta ^ { \\mathrm { A R M } } = \\mathbb { E } _ { o \\sim \\rho _ { \\mathrm { f } } } [ \\mathbb { E } _ { a \\sim \\pi ( \\cdot | \\sigma ; \\theta ) } [ \\nabla _ { \\theta } \\log ( \\pi ( o | a ; \\theta ) ) ( \\log ( \\pi ( o | a ; \\theta ) ) - \\log ( \\operatorname* { m a x } ( 0 , \\bar { A } _ { t } ^ { + } ( o , a ) ) ) + b ( o ) ) ] ] . } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            181,
+            231,
+            823,
+            250
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Comparing Equations (20) and (22), we see that the ARM-like policy gradient (Equation (22)) has a logarithmic dependence on the advantage-like function $\\bar { A } ^ { + }$ , whereas the existing policy gradient (Equation (20)) is only linearly dependent on the advantage function $A ^ { \\beta - \\mathrm { s o f t } }$ . This difference in logarithmic vs. linear dependence is responsible for a large part of the inherent distinction of ARM from existing policy gradient methods. One consequence of the difference in logarithmic vs. linear dependence is that the ARM-like update should be less sensitive to large positive advantages that may result from overestimation compared to existing policy gradient methods. ",
+        "bbox": [
+            173,
+            266,
+            825,
+            366
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "We also see that for the existing policy gradient (Equation (20)), the $( 1 / \\beta ) \\log ( \\pi ( a | o ; \\theta ) )$ term, which is derived from the policy entropy, is vanishing for large $\\beta$ (e.g. $\\beta = 1 0 0$ is a common choice in practice). On the other hand, for the ARM-like policy gradient (Equation (22)), there is no similar vanishing effect, suggesting that ARM may perform a kind of entropy regularization by default. ",
+        "bbox": [
+            174,
+            371,
+            825,
+            428
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "In practice we cannot implement an ARM-like policy gradient exactly as in Equation (22), as due to the positive clipping $\\operatorname* { m a x } ( 0 , { \\bar { A } } ^ { + } )$ there can appear $\\log ( 0 )$ . However we believe this is not an intrinsic obstacle, leaving the issue of implementing an ARM-like policy gradient to future work. ",
+        "bbox": [
+            174,
+            434,
+            825,
+            477
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "3.6 WHY DOES ARM WORK BETTER IN PARTIALLY OBSERVABLE DOMAINS? ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            493,
+            714,
+            507
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "In the previous Section 3.5, we showed that ARM and existing policy gradient methods can be distinguished by their choices of target policy and the nature of their dependence on their respective advantage-like functions. In this section, we argue that the convergence results of CFR and $\\mathrm { C F R + }$ suggest that ARM, to the degree that it inherits the properties of $\\mathrm { C F R / C F R + }$ , ought to benefit from greater partial observability compared to other methods. ",
+        "bbox": [
+            174,
+            518,
+            825,
+            588
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "We assume that regret bounds are a useful way to compare the convergence of different RL algorithms, due to the interpretation of regret as “area over the learning curve (and under the optimal√ expected value $J ^ { * }$ ).” Specifically, the regret bound of CFR and $\\mathrm { C F R + }$ is $O ( | O | \\sqrt { T } )$ where $| \\mathcal { O } |$ is the size of the observation space (Zinkevich et al., 2007; Tammelin et al., 2015). The policy gradient method with a suitable baseline has a learning rate $\\eta$ -dependent regret bound derived from the stochastic gradient method; assuming parameter norm bound $B$ and gradient estimator second moments $G ^ { 2 }$ , by setting the learning rate $\\eta \\propto T ^ { - 1 / 2 }$ policy gradient achieves a regret bound of $O ( \\sqrt { T } )$ with no explicit dependence on the observation space size $| \\mathcal { O } |$ (Dick, 2015). ",
+        "bbox": [
+            174,
+            595,
+            825,
+            712
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "We argue that possessing a regret bound proportional to the observation space size $| \\mathcal { O } |$ is beneficial in highly partially observable domains. Let us fix an underlying state space $s$ . Compare two RL algorithms, where algorithm 1 (which is ARM-like) has a regret bound $c _ { 1 } | \\mathcal { O } | \\sqrt { T }$ , whereas algorithm 2 (which is policy gradient-like) has a regret bound $c _ { 2 } \\sqrt { T }$ ; here, $c _ { 1 }$ and $c _ { 2 }$ are constants. Note that if $c _ { 1 } | \\mathcal { O } | = c _ { 2 }$ or equivalently $| \\mathcal { O } | = c _ { 2 } / c _ { 1 }$ , then the two RL algorithms possess the exact same regret bound. If on the other hand $\\left| \\mathcal { O } \\right| < c _ { 2 } / c _ { 1 }$ , then the regret bound of RL algorithm 1 is actually lower than that of RL algorithm 2. Applying this intuition to CFR and hence ARM suggests that ARM can benefit from greater partial observability if the degree of partial observability is above a threshold. ",
+        "bbox": [
+            173,
+            717,
+            825,
+            833
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "For Q-learning per se, we are not aware of any known regret bound. Szepesvari proved that the ´ convergence rate of Q-learning in the $L ^ { \\infty }$ -norm, assuming a fixed exploration strategy, depends on a condition number $C$ , which is the ratio of the minimum to maximum state-action occupation frequencies (Szepesvari, 1998), and which describes how “balanced” the exploration strategy is. If ´ partial observability leads to imbalanced exploration due to confounding of states from perceptual aliasing (McCallum, 1997), then Q-learning should be negatively affected. ",
+        "bbox": [
+            173,
+            840,
+            825,
+            924
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "We note that there remains a gap between ARM as implemented and the theory of CFR: the use of (a) function approximation and sampling over tabular enumeration; (b) the “ordinary” Q-function instead of the “stationary” Q-function; and (c) $n$ -step bootstrapped values instead of full returns for value function estimation. Waugh et al. (2015) address CFR with function approximation via a noisy version of a generalized Blackwell’s condition (Cesa-Bianchi & Lugosi, 2003). Even the original implementation of CFR used sampling in place of enumeration (Zinkevich et al., 2007). We refer the reader to Bellemare et al. (2016) for a more in-depth discussion of the stationary Q-function. Although only the full returns are guaranteed to be unbiased in non-Markovian settings, it is quite common for practical RL algorithms to trade off strict unbiasedness in favor of lower variance by using $n$ -step returns or variations thereof (Schulman et al., 2016; Gu et al., 2017). ",
+        "bbox": [
+            174,
+            103,
+            825,
+            242
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "4 EXPERIMENTS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            263,
+            326,
+            279
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Because we hypothesize that ARM should perform well in partially observable reinforcement learning environments, we conduct our experiments on visual domains that naturally provide partial observations of state. All of our evaluations use feedforward convnets with frame-history observations. We are interested in comparing ARM with methods that assume Markovian observations, namely double deep Q-learning (van Hasselt et al., 2016), as well as methods that can handle non-Markovian observations, primarily TRPO (Schulman et al., 2015; 2016), and to a lesser extent A3C (Mnih et al., 2016) whose critic assumes Markovian observations. We are also interested in controlling for the advantage structure of ARM by comparing with other advantage-structured methods, which include dueling networks (Wang et al., 2016), as well as policy gradient methods that estimate an empirical advantage using a baseline state-value function or critic (e.g. TRPO, A3C). ",
+        "bbox": [
+            174,
+            294,
+            825,
+            433
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "4.1 LEARNING TO PLAY PONG WITH A SINGLE FRAME ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            450,
+            562,
+            464
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Atari games consist of a small set of moving sprites with fixed shapes and palettes, and the motion of sprites can be highly deterministic, so that with only 4 recently observed frames as input one can predict hundreds of frames into the future on some games using only a feedforward model (Oh et al., 2015). To increase the partial observability of Atari games, one may artificially limit the amount of frame history fed as input to the networks (Hausknecht & Stone, 2017). As a proof of concept of ARM, we trained agents to play Pong via the Arcade Learning Environment (Bellemare et al., 2013) when the frame-history length is varied between 4 (the default) and 1. We found that the performance of double deep Q-learning degraded noticeably when the frame-history length was reduced from 4 to 1, whereas performance of ARM was not affected nearly as much. Our results on Pong are summarized in Figure 1. ",
+        "bbox": [
+            173,
+            476,
+            825,
+            614
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/d17a3f8ac400502818872bfd8c6491354010200aa08ebf771c86d4e4b1b0fcb7.jpg",
+        "image_caption": [
+            "Figure 1: Comparing double deep Q-learning (orange) and ARM (blue) on Pong. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            331,
+            626,
+            656,
+            762
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "4.2 LEARNING TO NAVIGATE IN VIZDOOM ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            814,
+            485,
+            828
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "We evaluated ARM on the task of learning first-person navigation in the ViZDoom (Kempka et al., 2016) domain based on the game of Doom. Doom is a substantially more complex domain than Atari, featuring an egocentric viewpoint, 3D perspective, and complex visuals. We expect that Doom exhibits a substantial degree of partial observability and therefore serves as a more difficult evaluation of reinforcement learning algorithms’ effectiveness on partially observable domains. We performed our evaluation on two standard ViZDoom navigation benchmarks, “HealthGathering” ",
+        "bbox": [
+            174,
+            840,
+            825,
+            922
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "and “MyWayHome.” In “HealthGathering,” the agent is placed in a toxic room and continually loses life points, but can navigate toward healthkit objects to prolong its life; the goal is to survive for as long as possible. In “MyWayHome,” the agent is randomly placed in a small maze and must find a target object that has a fixed visual appearance and is in a fixed location in the maze; the goal is to reach the target object before time runs out. Figure 2 (top row) shows example observations from the two ViZDoom scenarios. ",
+        "bbox": [
+            174,
+            103,
+            825,
+            186
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Unlike previous evaluations which augmented the raw pixel frames with extra information about the game state, e.g. elapsed time ticks or remaining health (Kempka et al., 2016; Dosovitskiy & Koltun, 2017), in our evaluation we forced all networks to learn using only visual input. Despite this restriction, ARM is still able to quickly learn policies with minimal tuning of hyperparameters and reach close to the maximum score in under 1 million steps. On “HealthGathering,” we observed that ARM very quickly learns a policy that can achieve close to the maximum episode return of 2100. Double deep Q-learning learns a more consistent policy on “HealthGathering” compared to ARM and TRPO, but we believe this to be the result of evaluating double DQN’s $\\epsilon$ -greedy policy with small $\\epsilon$ compared to the truly stochastic policies learned by ARM and TRPO. On “MyWayHome,” we observed that ARM generally learned a well-performing policy more quickly than other methods. Additionally, we found that ARM is able to take advantage of an off-policy replay memory when learning on ViZDoom by storing the trajectories of previous sampling batches and applying an importance sampling correction to the $n$ -step returns; please see Section 6.2 in the Appendix for details. Our Doom results are in Figure 6. ",
+        "bbox": [
+            173,
+            194,
+            825,
+            388
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "image",
+        "img_path": "images/eb67b2bf92537bb9e524252d79c88f95c44e030b7fa632f8399695fb74da885d.jpg",
+        "image_caption": [
+            "Figure 2: Top row: Doom screenshots from (left) “HealthGathering” and (right) “MyWayHome.” Bottom row: Minecraft screenshots from (leftmost) “L1” through (rightmost) “L5” "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            184,
+            412,
+            820,
+            575
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "image",
+        "img_path": "images/a578e0fde415fbaa29313d8eef053a0758257658bc7097447ce30625994816f4.jpg",
+        "image_caption": [
+            "Figure 3: Evaluating double deep Q-learning (orange), dueling double DQN (red), A3C (purple), TRPO (green), ARM (blue), and ARM with off-policy data (cyan) on two ViZDoom scenarios. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            254,
+            667,
+            723,
+            859
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "4.3 LEARNING TO NAVIGATE IN MINECRAFT ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            103,
+            493,
+            117
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "We finally evaluated ARM on the task of learning first-person navigation in the Malmo domain ¨ based on the game of Minecraft (Johnson et al., 2016). Minecraft has similar visual complexity to Doom and should possess a comparable degree of partial observability, but Minecraft has the potential to be more difficult than Doom due to the diversity of possible Minecraft environments that can be generated. Our evaluation on Minecraft is adapted from the teacher-student curriculum learning protocol (Matiisen et al., 2017), which consists of 5 consecutive “levels” that successively increase the difficulty of completing the simple task of reaching a target block: the first level (“L1”) consists of a single room; the intermediate levels (“L2”–“L4”) consist of a corridor with lava-bridge and wall-gap obstacles; and the final level (“L5”) consists of a $2 \\times 2$ arrangement of rooms randomly separated by lava-bridge or wall-gap obstacles. Figure 2 (bottom row) shows example observations from the five Minecraft levels. ",
+        "bbox": [
+            174,
+            132,
+            825,
+            284
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "We performed our Minecraft experiments using fixed curriculum learning schedules to evaluate the sample efficiency of different algorithms: the agent is initially placed in the first level (“L1”), and the agent is advanced to the next level whenever a preselected number of simulator steps have elapsed, until the agent reaches the last level (“L5”). We found that ARM and dueling double DQN both were able to learn on an aggressive “fast” schedule of only 62500 simulator steps between levels. TRPO required a “slow” schedule of 93750 simulator steps between levels to reliably learn. ARM was able to consistently learn a well performing policy on all of the levels, whereas double DQN learned more slowly on some of the intermediate levels. ARM also more consistently reached a high score on the final, most difficult level (“L5”). Our Minecraft results are shown in Figure 4. ",
+        "bbox": [
+            174,
+            291,
+            825,
+            416
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "image",
+        "img_path": "images/d9207a568dbbd2bbee8c90f7edd9b397fc7e3f523d0ae82626197667af5e147c.jpg",
+        "image_caption": [
+            "Figure 4: Evaluating double deep Q-learning (orange), dueling double DQN (red), TRPO (green), and ARM (blue) on a Minecraft curriculum learning protocol. The simulator step counts at which each level begins are labeled and demarcated with dashed vertical lines. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            189,
+            433,
+            802,
+            559
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "5 DISCUSSION ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            652,
+            310,
+            669
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "In this paper, we presented a novel deep reinforcement learning algorithm based on counterfactual regret minimization (CFR). We call our method advantage-based regret minimization (ARM). Similarly to prior methods that learn state or state-action value functions, our method learns a cumulative clipped advantage function of observation and action. However, in contrast to these prior methods, ARM is well suited to partially observed or non-Markovian environments, making it an appealing choice in a number of difficult domains. When compared to baseline methods, including deep Q-learning and TRPO, on non-Markovian tasks such as the challenging ViZDoom and Malmo first- ¨ person navigation benchmarks, ARM achieves substantially better results. This illustrates the value of ARM for partially observable problems. In future work, we plan to further explore applications of ARM to more complex tasks, including continuous action spaces. ",
+        "bbox": [
+            174,
+            689,
+            825,
+            828
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "REFERENCES ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            854,
+            285,
+            869
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Anonymous. Soft actor-critic: Off-policy maximum entropy deep reinforcement learning with a stochastic actor. International Conference on Learning Representations, 2018. URL https: //openreview.net/forum?id=HJjvxl-Cb. ",
+        "bbox": [
+            176,
+            882,
+            823,
+            922
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Oron Anschel, Nir Baram, and Nahum Shimkin. Averaged-DQN: Variance Reduction and Stabilization for Deep Reinforcement Learning. In International Conference on Machine Learning, pp. 176–185, 2017. ",
+        "bbox": [
+            173,
+            103,
+            823,
+            146
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "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. ",
+        "bbox": [
+            174,
+            155,
+            821,
+            198
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Mark G. Bellemare, Georg Ostrovski, Arthur Guez, Philip S. Thomas, and Remi Munos. Increasing ´ the Action Gap: New Operators for Reinforcement Learning. In AAAI, 2016. ",
+        "bbox": [
+            173,
+            208,
+            821,
+            237
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Michael Bowling, Neil Burch, Michael Johanson, and Oskari Tammelin. Heads-up limit hold’em poker is solved. Science, 347(6218):145–149, 2015. ",
+        "bbox": [
+            171,
+            246,
+            821,
+            276
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Nicolo Cesa-Bianchi and G \\` abor Lugosi. Potential-Based Algorithms in On-Line Prediction and ´ Game Theory. Machine Learning, 51(3):239–261, 2003. ",
+        "bbox": [
+            173,
+            285,
+            823,
+            314
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Travis Dick. Policy Gradient Reinforcement Learning Without Regret. Master’s thesis, University of Alberta, 2015. ",
+        "bbox": [
+            173,
+            324,
+            823,
+            353
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Alexey Dosovitskiy and Vladlen Koltun. Learning to Act by Predicting the Future. arXiv preprint arXiv:1611.01779v2, 2017. ",
+        "bbox": [
+            173,
+            362,
+            823,
+            392
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Jakob N. Foerster, Yannis M. Assael, Nando de Freitas, and Shimon Whiteson. Learning to Communicate with Deep Multi-Agent Reinforcement Learning. In Advances in Neural Information Processing Systems 29, 2016. ",
+        "bbox": [
+            173,
+            400,
+            823,
+            444
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Shixiang Gu, Timothy Lillicrap, Zoubin Ghahramani, Richard E. Turner, Bernhard Scholkopf, and ¨ Sergey Levine. Interpolated Policy Gradient: Merging On-Policy and Off-Policy Gradient Estimation for Deep Reinforcement Learning. arXiv preprint arXiv:1706.00387v1, 2017. ",
+        "bbox": [
+            178,
+            453,
+            823,
+            497
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Tuomas Haarnoja, Haoran Tang, Pieter Abbeel, and Sergey Levine. Reinforcement Learning with Deep Energy-Based Policies. arXiv preprint arXiv:1702.08165v2, 2017. ",
+        "bbox": [
+            171,
+            506,
+            823,
+            535
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Sergiu Hart and Andreu Mas-Colell. A Simple Adaptive Procedure Leading to Correlated Equilibrium. Econometrica, 68(5):1127–1150, 2000. ",
+        "bbox": [
+            173,
+            544,
+            821,
+            574
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Matthew Hausknecht and Peter Stone. Deep Recurrent Q-Learning for Partially Observable MDPs. arXiv preprint arXiv:1507.06527v4, 2017. ",
+        "bbox": [
+            174,
+            583,
+            820,
+            613
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Nicolas Heess, Jonathan J. Hunt, Timothy P. Lillicrap, and David Silver. Memory-based control with recurrent neural networks. arXiv preprint arXiv:1512.04455v1, 2015. ",
+        "bbox": [
+            173,
+            621,
+            823,
+            651
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Edward L Ionides. Truncated Importance Sampling. Journal of Computational and Graphical Statistics, 17(2):295–311, 2008. ",
+        "bbox": [
+            173,
+            660,
+            823,
+            689
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Matthew Johnson, Katja Hofmann, Tim Hutton, and David Bignell. The Malmo Platform for Artificial Intelligence Experimentation. In Proceedings of the 25th International Joint Conference on Artificial Intelligence, 2016. ",
+        "bbox": [
+            173,
+            699,
+            823,
+            742
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Michal Kempka, Marek Wydmuch, Grzegorz Runc, Jakub Toczek, and Wojciech Jaskowski. ViZ- ´ Doom: A Doom-based AI Research Platform for Visual Reinforcement Learning. arXiv preprint arXiv:1605.02097v2, 2016. ",
+        "bbox": [
+            174,
+            751,
+            823,
+            795
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Sergey Levine, Chelsea Finn, Trevor Darrell, and Pieter Abbeel. End-to-end training of deep visuomotor policies. The Journal of Machine Learning Research, 17(1):1334–1373, 2016. ",
+        "bbox": [
+            169,
+            804,
+            823,
+            833
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Timothy P. Lillicrap, Jonathan J. Hunt, Alexander Pritzel, Nicolas Heess, Tom Erez, Yuval Tassa, David Silver, and Daan Wierstra. Continuous control with deep reinforcement learning. arXiv preprint arXiv:1509.02971v5, 2016. ",
+        "bbox": [
+            173,
+            843,
+            823,
+            886
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Michael L. Littman. Markov games as a framework for multi-agent reinforcement learning. In Proceedings of the 11th International Conference on Machine Learning, pp. 157–163, 1994. ",
+        "bbox": [
+            173,
+            895,
+            821,
+            924
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Tambet Matiisen, Avital Oliver, Taco Cohen, and John Schulman. Teacher-Student Curriculum Learning. arXiv preprint arXiv:1707.00183v1, 2017. ",
+        "bbox": [
+            171,
+            103,
+            825,
+            132
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Andrew Kachites McCallum. Efficient Exploration in Reinforcement Learning with Hidden State. In AAAI Fall Symposium on Model-directed Autonomous Systems, 1997. ",
+        "bbox": [
+            171,
+            141,
+            821,
+            171
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Volodymyr Mnih, Koray Kavukcuoglu, David Silver, Alex Graves, Ioannis Antonoglou, Daan Wierstra, and Martin Riedmiller. Playing Atari with Deep Reinforcement Learning. arXiv preprint arXiv:1312.5602v1, 2013. ",
+        "bbox": [
+            176,
+            179,
+            823,
+            223
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Volodymyr Mnih, Koray Kavukcuoglu, David Silver, Andrei A. Rusu, Joel Veness, Marc G. Bellemare, Alex Graves, Martin Riedmiller, Andreas K. Fidjeland, Georg Ostrovski, et al. Human-level control through deep reinforcement learning. Nature, 518(7540):529–533, 2015. ",
+        "bbox": [
+            174,
+            232,
+            823,
+            275
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Volodymyr Mnih, Adria Puigdomenech Badia, Mehdi Mirza, Alex Graves, Timothy Lillicrap, Tim Harley, David Silver, and Koray Kavukcuoglu. Asynchronous methods for deep reinforcement learning. In International Conference on Machine Learning, pp. 1928–1937, 2016. ",
+        "bbox": [
+            176,
+            284,
+            823,
+            328
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Ofir Nachum, Mohammad Norouzi, Kelvin Xu, and Dale Schuurmans. Bridging the Gap Between Value and Policy Based Reinforcement Learning. In 31st Conference on Neural Information Processing Systems, 2017. ",
+        "bbox": [
+            176,
+            337,
+            825,
+            380
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Brendan O’Donoghue, Remi Munos, Koray Kavukcuoglu, and Volodymyr Mnih. Combining policy ´ gradient and Q-learning. arXiv preprint arXiv:1611.01626v3, 2017. ",
+        "bbox": [
+            169,
+            388,
+            823,
+            419
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Junhyuk Oh, Xiaoxiao Guo, Honglak Lee, Richard L Lewis, and Satinder Singh. Action-Conditional Video Prediction using Deep Networks in Atari Games. In Advances in Neural Information Processing Systems, pp. 2863–2871, 2015. ",
+        "bbox": [
+            174,
+            428,
+            823,
+            470
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Junhyuk Oh, Valliappa Chockalingam, Satinder Singh, and Honglak Lee. Control of memory, active perception, and action in minecraft. In Proceedings of The 33rd International Conference on Machine Learning, pp. 2790–2799, 2016. ",
+        "bbox": [
+            174,
+            479,
+            823,
+            523
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Xue Bin Peng, Glen Berseth, and Michiel van de Penne. Terrain-Adaptive Locomotion Skills Using Deep Reinforcement Learning. ACM Transactions on Graphics, 35(4):81, 2016. ",
+        "bbox": [
+            173,
+            531,
+            820,
+            561
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Stephane Ross and J. Andrew Bagnell. Reinforcement and Imitation Learning via Interactive No-´ Regret Learning. arXiv preprint arXiv:1406.5979v1, 2014. ",
+        "bbox": [
+            171,
+            570,
+            821,
+            601
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Stephane Ross, Geoffrey J. Gordon, and J. Andrew Bagnell. A Reduction of Imitation Learning and ´ Structured Prediction to No-Regret Online Learning. In Proceedings of the Fourteenth International Conference on Artificial Intelligence and Statistics, pp. 627–635, 2011. ",
+        "bbox": [
+            174,
+            608,
+            823,
+            652
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "John Schulman, Sergey Levine, Pieter Abbeel, Michael Jordan, and Philipp Moritz. Trust region policy optimization. In Proceedings of the 32nd International Conference on Machine Learning (ICML-15), pp. 1889–1897, 2015. ",
+        "bbox": [
+            173,
+            661,
+            823,
+            704
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "John Schulman, Philipp Moritz, Sergey Levine, Michael I. Jordan, and Pieter Abbeel. HighDimensional Continuous Control Using Generalized Advantage Estimation. arXiv preprint arXiv:1506.02438v5, 2016. ",
+        "bbox": [
+            173,
+            713,
+            823,
+            756
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "John Schulman, Xi Chen, and Pieter Abbeel. Equivalence Between Policy Gradients and Soft QLearning. arXiv preprint arXiv:1704.06440v1, 2017. ",
+        "bbox": [
+            168,
+            765,
+            823,
+            795
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Csaba Szepesvari. The Asymptotic Convergence-Rate of Q-learning. In ´ Advances in Neural Information Processing Systems, pp. 1064–1070, 1998. ",
+        "bbox": [
+            171,
+            804,
+            823,
+            833
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Oskari Tammelin. Solving Large Imperfect Information Games Using $\\mathrm { C F R + }$ . arXiv preprint arXiv:1407.5042v1, 2014. ",
+        "bbox": [
+            171,
+            842,
+            823,
+            872
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Oskari Tammelin, Neil Burch, Michael Johanson, and Michael Bowling. Solving Heads-up Limit Texas Hold’em. In Proceedings of the 24th International Joint Conference on Artificial Intelligence, 2015. ",
+        "bbox": [
+            174,
+            881,
+            825,
+            924
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Hado van Hasselt and Marco A. Wiering. Reinforcement Learning in Continuous Action Spaces. In Proceedings of the 2007 IEEE Symposium on Approximate Dynamic Programming and Reinforcement Learning, pp. 272–279, 2007. ",
+        "bbox": [
+            176,
+            103,
+            820,
+            146
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Hado van Hasselt, Arthur Guez, and David Silver. Deep Reinforcement Learning and Double QLearning. In Proceedings of the Thirtieth AAAI Conference on Artificial Intelligence, 2016. ",
+        "bbox": [
+            171,
+            155,
+            823,
+            184
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Ziyu Wang, Tom Schaul, Matteo Hessel, Hado van Hasselt, Marc Lanctot, and Nando de Freitas. Dueling Network Architectures for Deep Reinforcement Learning. In Proceedings of the $3 3 r d$ International Conference on Machine Learning, pp. 1995–2003, 2016. ",
+        "bbox": [
+            176,
+            193,
+            823,
+            236
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Ziyu Wang, Victor Bapst, Nicolas Heess, Volodymyr Mnih, Remi Munos, Koray Kavukcuoglu, and Nando de Freitas. Sample Efficient Actor-Critic with Experience Replay. arXiv preprint arXiv:1611.01224v2, 2017. ",
+        "bbox": [
+            173,
+            243,
+            823,
+            286
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Kevin Waugh, Dustin Morrill, J. Andrew Bagnell, and Michael Bowling. Solving Games with Functional Regret Estimation. In Workshops at the Twenty-Ninth AAAI Conference on Artificial Intelligence, 2015. Supplementary material in arXiv preprint arXiv:1411.7974v2. ",
+        "bbox": [
+            174,
+            295,
+            826,
+            338
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Martin Zinkevich, Michael Johanson, Michael H. Bowling, and Carmelo Piccione. Regret Minimization in Games with Incomplete Information. In Advances in Neural Information Processing Systems 20, pp. 1729–1736, 2007. ",
+        "bbox": [
+            174,
+            348,
+            825,
+            390
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "6 APPENDIX ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            102,
+            294,
+            117
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "6.1 EXPERIMENTAL DETAILS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            142,
+            388,
+            156
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "6.1.1 PONG (ARCADE LEARNING ENVIRONMENT) ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            174,
+            535,
+            189
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "We use the preprocessing and convolutional network model of (Mnih et al., 2013). Specifically, we view every 4th emulator frame, convert the raw frames to grayscale, and perform downsampling to generate a single observed frame. The input observation of the convnet is a concatenation of the most recent frames (either 4 frames or 1 frame). The convnet consists of an $8 \\times 8$ convolution with stride 4 and 16 filters followed by ReLU, a $4 \\times 4$ convolution with stride 2 and 32 filters followed by ReLU, a linear map with 256 filters followed by ReLU, and a linear map with $| { \\cal A } |$ filters where $| { \\cal A } |$ is the action space cardinality $\\lvert \\lvert A \\rvert = 6$ for Pong). ",
+        "bbox": [
+            174,
+            205,
+            825,
+            304
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "We used Adam with a constant learning rate of $\\alpha = 1 0 ^ { - 4 }$ , a minibatch size of 32, and the moment decay rates set to their defaults $\\beta _ { 1 } = 0 . 9$ and $\\beta _ { 2 } = 0 . 9 9 9$ . Our results on each method are averaged across 3 random seeds. ",
+        "bbox": [
+            174,
+            309,
+            825,
+            352
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "We ran ARM with the hyperparameters: sampling batch size of 12500, 4000/3000 minibatches of Adam for the first/subsequent sampling iterations respectively, and target update step size $\\tau = 0 . 0 1$ . Double DQN uses the tuned hyperparameters (van Hasselt et al., 2016). Note that our choice of ARM hyperparameters yields an equivalent number of minibatch gradient updates per sample as used by DQN and double DQN, i.e. 1 minibatch gradient update per 4 simulator steps. ",
+        "bbox": [
+            174,
+            358,
+            825,
+            429
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "6.1.2 DOOM (VIZDOOM) ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            459,
+            364,
+            474
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "We used a convolutional network architecture similar to those of (Kempka et al., 2016) and (Dosovitskiy & Koltun, 2017). The Doom screen was rendered at a resolution of $1 6 0 \\times 1 2 0$ and downsized to $8 4 \\times 8 4$ . Only every 4th frame was rendered, and the input observation to the convnet is a concatenation of the last 4 rendered RGB frames for a total of 12 input channels. The convnet contains 3 convolutions with 32 filters each: the first is size $8 \\times 8$ with stride 4, the second is size $4 \\times 4$ with stride 2, and the third is size $3 \\times 3$ with stride 1. The final convolution is followed by a linear map with 1024 filters. A second linear map yields the output. Hidden activations are gated by ReLUs. ",
+        "bbox": [
+            174,
+            489,
+            825,
+            588
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "For “HealthGathering” only, we scaled rewards by a factor of 0.01. We did not scale rewards for “MyWayHome.” We used Adam with a constant learning rate of $\\alpha = 1 0 ^ { - 5 }$ and a minibatch size of 32 to train all networks (except TRPO). For “HealthGathering” we set $\\beta _ { 1 } = 0 . 9 5$ , whereas for “MyWayHome” we set $\\beta _ { 1 } = 0 . 9$ . We set $\\beta _ { 2 } = 0 . 9 9 9$ for both scenarios. Our results on each method are averaged across 3 random seeds. ",
+        "bbox": [
+            174,
+            594,
+            825,
+            665
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Double DQN and dueling double DQN: $n = 5$ step returns; update interval 30000; 1 minibatch gradient update per 4 simulator steps; replay memory uniform initialization size 50000; replay memory maximum size 240000; exploration period 240000; with final exploration rate $\\epsilon = 0 . 0 1$ . ",
+        "bbox": [
+            174,
+            671,
+            825,
+            713
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "A3C: 16 workers; $n = 2 0$ steps for “HealthGathering” and $n = 4 0$ steps for “MyWayHome”;   \nnegentropy regularization $\\beta = 0 . 0 1$ ; and gradient norm clip 5. ",
+        "bbox": [
+            174,
+            719,
+            821,
+            750
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "TRPO: sampling batch size 12500; KL-divergence step size $\\delta = 0 . 0 1$ ; 10 conjugate gradient iterations; and Fisher information/Gauss-Newton damping coefficient $\\lambda = 0 . 1$ . ",
+        "bbox": [
+            171,
+            755,
+            821,
+            784
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "ARM: $n = 5$ step returns; sampling batch size 12500; 4000 Adam minibatches in the first sampling iteration, 3000 Adam minibatches in all subsequent sampling iterations; target update step size $\\tau = 0 . 0 1$ . Again, our choice of ARM hyperparameters yields an equivalent number of minibatch gradient updates per sample as used by DQN and double DQN. For “HealthGathering” only, because ARM converges so quickly we annealed the Adam learning rate to $\\alpha = 2 . 5 \\times 1 0 ^ { - 6 }$ after 500000 elapsed simulator steps. ",
+        "bbox": [
+            174,
+            790,
+            825,
+            875
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Off-policy ARM: $n = 5$ step returns; sampling batch size 1563, replay cache sample size 25000; 400 Adam minibatches per sampling iteration; target update step size $\\tau = 0 . 0 1$ ; and importance sampling weight clip $c = 1$ . ",
+        "bbox": [
+            176,
+            882,
+            823,
+            924
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "6.1.3 MINECRAFT (MALMO¨ ) ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            103,
+            388,
+            118
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "Our Minecraft tasks generally were the same as the ones used by Matiisen et al. (2017), with a few differences. Instead of using a continuous action space, we used a discrete action space with 4 move and turn actions. To aid learning on the last level (“L5”), we removed the reward penalty upon episode timeout and we increased the timeout on “L5” from 45 seconds to 75 seconds due to the larger size of the environment. We scaled rewards for all levels by 0.001. ",
+        "bbox": [
+            173,
+            127,
+            825,
+            198
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "We use the same convolutional network architecture for Minecraft as we used for ViZDoom in Section 4.2. The Minecraft screen was rendered at a resolution of $3 2 0 \\times 2 4 0$ and downsized to $8 4 \\times$ 84. Only every 5th frame was rendered, and the input observation of the convnet is a concatenation of the last 4 rendered RGB frames for a total of 12 input channels. We used Adam with constant learning rate $\\alpha = 1 0 ^ { - 5 }$ , moment decay rates $\\beta _ { 1 } = 0 . 9$ and $\\beta _ { 2 } = 0 . 9 9 9$ , and minibatch size 32 to train all networks (except TRPO). Our results on each method are averaged across 5 random seeds. ",
+        "bbox": [
+            174,
+            204,
+            825,
+            289
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "Double DQN and dueling double DQN: $n = 5$ step returns; update interval 12500; 1 minibatch gradient update per 4 simulator steps; replay memory uniform initialization size 12500; replay memory maximum size 62500; exploration period 62500; with final exploration rate $\\epsilon = 0 . 0 1$ . ",
+        "bbox": [
+            174,
+            295,
+            825,
+            338
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "TRPO: sampling batch size 6250; KL-divergence step size $\\delta = 0 . 0 1$ ; 10 conjugate gradient iterations; and Fisher information/Gauss-Newton damping coefficient $\\lambda = 0 . 1$ . ",
+        "bbox": [
+            169,
+            343,
+            823,
+            373
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "ARM: $n = 5$ step returns; sampling batch size 12500; 4000 Adam minibatches in the first sampling iteration, 3000 Adam minibatches in all subsequent sampling iterations; target update step size $\\tau = 0 . 0 1$ . ",
+        "bbox": [
+            174,
+            378,
+            825,
+            421
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "6.2 OFF-POLICY ARM VIA IMPORTANCE SAMPLING ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            438,
+            547,
+            452
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "Our current approach to running ARM with off-policy data consists of applying an importance sampling correction directly to the $n$ -step returns. Given the behavior policy $\\mu$ under which the data was sampled, the current policy $\\pi _ { t }$ under which we want to perform estimation, and an importance sampling weight clip $c$ for variance reduction, the corrected $n$ -step return we use is: ",
+        "bbox": [
+            174,
+            463,
+            825,
+            520
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "equation",
+        "img_path": "images/00de119b584548f124d2ae0529ead548b6420a81912d6aca99411541e38eb2bf.jpg",
+        "text": "$$\ng _ { k } ^ { n } ( \\mu \\| \\pi _ { t } ) = \\sum _ { k ^ { \\prime } = k } ^ { k + n - 1 } \\gamma ^ { k ^ { \\prime } - k } \\left( \\prod _ { \\ell = k } ^ { k ^ { \\prime } } w _ { \\mu \\| \\pi _ { t } } ( a _ { \\ell } | o _ { \\ell } ) \\right) r _ { k ^ { \\prime } }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            330,
+            522,
+            666,
+            571
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "where the truncated importance weight $\\scriptstyle w _ { \\mu \\parallel \\pi _ { t } } ( a | o )$ is defined (Ionides, 2008): ",
+        "bbox": [
+            174,
+            574,
+            684,
+            590
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "equation",
+        "img_path": "images/ae61e9bf15c0a5fe19a559673152ce4c73d7747c3620d39c649fbf182a54c1de.jpg",
+        "text": "$$\nw _ { \\boldsymbol { \\mu } \\parallel \\pi _ { t } } ( a | o ) = \\operatorname* { m i n } \\left( c , \\frac { \\pi _ { t } ( a | o ) } { \\mu ( a | o ) } \\right) .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            385,
+            593,
+            612,
+            627
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "Our choice of $c = 1$ in our experiments was inspired by Wang et al. (2017). We found that $c = 1$ worked well but note other choices for $c$ may also be reasonable. ",
+        "bbox": [
+            174,
+            628,
+            823,
+            657
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "When applying our importance sampling correction, we preserve all details of the ARM algorithm except for two aspects: the transition sampling strategy (a finite memory of previous batches are cached and uniformly sampled) and the regression targets for learning the value functions. Specifically, the regression targets $v ( o _ { k } ; \\varphi )$ , $q ( o _ { k } , a _ { k } ; \\varphi )$ , and $\\bar { q } ^ { + } ( o _ { k } , a _ { k } ; \\bar { \\varphi } )$ (Equations (11)–(13)) are modified to the following: ",
+        "bbox": [
+            174,
+            664,
+            825,
+            734
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "equation",
+        "img_path": "images/e261536418495d6a281284211e30b69430a5e175be5aab9fc5b30e7501eb253d.jpg",
+        "text": "$$\n\\begin{array} { r l } & { \\quad v _ { \\mu \\parallel \\pi _ { t } } ( o _ { k } ; \\varphi ) = g _ { k } ^ { n } ( \\mu \\| \\pi _ { t } ) + \\gamma ^ { n } V ^ { \\prime } ( o _ { k + n } ; \\varphi ) } \\\\ & { \\quad q _ { \\mu \\parallel \\pi _ { t } } ( o _ { k } , a _ { k } ; \\varphi ) = r _ { k } + \\gamma w _ { \\mu \\parallel \\pi _ { t } } ( a _ { k } | o _ { k } ) g _ { k + 1 } ^ { n - 1 } ( \\mu \\| \\pi _ { t } ) + \\gamma ^ { n } V ^ { \\prime } ( o _ { k + n } ; \\varphi ) } \\\\ & { \\quad \\bar { q } _ { \\mu \\parallel \\pi _ { t } } ^ { + } ( o _ { k } , a _ { k } ; \\varphi ) = \\operatorname* { m a x } ( 0 , \\bar { Q } _ { t - 1 } ^ { + } ( o _ { k } , a _ { k } ; \\omega _ { t - 1 } ) - V _ { \\pi _ { t - 1 } } ( o _ { k } ; \\theta _ { t - 1 } ) ) + q _ { \\mu \\parallel \\pi _ { t } } ( o _ { k } , a _ { k } ; \\varphi ) . } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            199,
+            734,
+            771,
+            797
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "Note that the target value function $V ^ { \\prime } ( o _ { k + n } ; \\varphi )$ does not require an importance sampling correction because $V ^ { \\prime }$ already approximates the on-policy value function $V _ { \\pi _ { t } } \\big ( o _ { k + n } ; \\theta _ { t } \\big )$ . ",
+        "bbox": [
+            173,
+            800,
+            823,
+            830
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "6.3 ADDITIONAL EXPERIMENTS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            845,
+            408,
+            859
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "6.3.1 ATARI 2600 GAMES ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            871,
+            366,
+            886
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "Although our primary interest is in partially observable reinforcement learning domains, we also want to check that ARM works in nearly fully observable and Markovian environments, such as ",
+        "bbox": [
+            174,
+            895,
+            825,
+            924
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "Atari 2600 games. We consider two baselines: double deep Q-learning, and double deep fitted Qiteration which is a batch counterpart to double DQN. We find that double deep Q-learning is a strong baseline for learning to play Atari games, although ARM still successfully learns interesting policies. One major benefit of Q-learning-based methods is the ability to utilize a large off-policy replay memory. Our results on a suite of Atari games are in Figure 5. ",
+        "bbox": [
+            174,
+            103,
+            825,
+            174
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "image",
+        "img_path": "images/785ce79df806fb81361c2e129888ddc1c489cd18e3df2c9458a2b66c42dc610d.jpg",
+        "image_caption": [
+            "Figure 5: Comparing double deep Q-learning (orange), double deep fitted Q-iteration (red), and ARM (blue) on a suite of seven Atari games from the Arcade Learning Environment. For each method, we plot the mean across 3 trials along with standard error bars. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            250,
+            185,
+            741,
+            378
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "6.3.2 RECURRENCE IN DOOM MYWAYHOME",
+        "text_level": 1,
+        "bbox": [
+            174,
+            457,
+            501,
+            472
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "We evaluated the effect of recurrent policy and value function estimation in the maze-like MyWayHome scenario of ViZDoom. We found that recurrence has a small positive effect on the convergence of A2C (Mnih et al., 2016), but was much less significant than the choice of algorithm. Our hyperparameters were similar to those described for A3C in Section 6.1.2, except we used a learning rate $\\mathrm { \\dot { 1 } 0 ^ { - 4 } }$ and gradient norm clip 0.5. For the recurrent policy and value function, we replaced the first fully connected operation with an LSTM featuring an equivalent number of hidden units (1024). ",
+        "bbox": [
+            173,
+            481,
+            825,
+            565
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "image",
+        "img_path": "images/c2b69a73a11245bd1cb2c803496cf6279e9e9540805079b1798a35ff8d4befbc.jpg",
+        "image_caption": [
+            "Figure 6: Comparing A2C with a feedforward convolutional network (blue) and a recurrent convolutional-LSTM network (orange) on the ViZDoom scenario MyWayHome. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            390,
+            577,
+            609,
+            768
+        ],
+        "page_idx": 14
+    }
+]

parse/train/H1zriGeCZ/H1zriGeCZ.md

@@ -0,0 +1,461 @@
+# HYPERPARAMETER OPTIMIZATION:A SPECTRAL APPROACH
+
+Elad Hazan Princeton University and Google Brain ehazan@cs.princeton.edu
+
+Adam Klivans Department of Computer Science University of Texas at Austin klivans@cs.utexas.edu
+
+Yang Yuan   
+Department of Computer Science Cornell University   
+yangyuan@cs.cornell.edu
+
+# ABSTRACT
+
+We give a simple, fast algorithm for hyperparameter optimization inspired by techniques from the analysis of Boolean functions. We focus on the high-dimensional regime where the canonical example is training a neural network with a large number of hyperparameters. The algorithm — an iterative application of compressed sensing techniques for orthogonal polynomials — requires only uniform sampling of the hyperparameters and is thus easily parallelizable.
+
+Experiments for training deep neural networks on Cifar-10 show that compared to state-of-the-art tools (e.g., Hyperband and Spearmint), our algorithm finds significantly improved solutions, in some cases better than what is attainable by handtuning. In terms of overall running time (i.e., time required to sample various settings of hyperparameters plus additional computation time), we are at least an order of magnitude faster than Hyperband and Bayesian Optimization. We also outperform Random Search $8 \times$ .
+
+Our method is inspired by provably-efficient algorithms for learning decision trees using the discrete Fourier transform. We obtain improved sample-complexty bounds for learning decision trees while matching state-of-the-art bounds on running time (polynomial and quasipolynomial, respectively).
+
+# 1 INTRODUCTION
+
+Large scale machine learning and optimization systems usually involve a large number of free parameters for the user to fix according to their application. A timely example is the training of deep neural networks for a signal processing application: the ML specialist needs to decide on an architecture, depth of the network, choice of connectivity per layer (convolutional, fully-connected, etc.), choice of optimization algorithm and recursively choice of parameters inside the optimization library itself (learning rate, momentum, etc.).
+
+Given a set of hyperparameters and their potential assignments, the naive practice is to search through the entire grid of parameter assignments and pick the one that performed the best, a.k.a. “grid search”. As the number of hyperparameters increases, the number of possible assignments increases exponentially and a grid search becomes quickly infeasible. It is thus crucial to find a method for automatic tuning of these parameters.
+
+This auto-tuning, or finding a good setting of these parameters, is now referred to as hyperparameter optimization (HPO), or simply automatic machine learning (auto-ML). For continuous hyperparameters, gradient descent is usually the method of choice (Maclaurin et al., 2015; Luketina et al., 2015; Fu et al., 2016). Discrete parameters, however, such as choice of architecture, number of layers, connectivity and so forth are significantly more challenging. More formally, let
+
+$$
+f : \{ - 1 , 1 \} ^ { n } \mapsto [ 0 , 1 ]
+$$
+
+be a function mapping hyperparameter choices to test error of our model. That is, each dimension corresponds to a certain hyperparameter (number of layers, connectivity, etc.), and for simplicity of illustration we encode the choices for each parameter as binary numbers $\{ - 1 , 1 \}$ . The goal of HPO is to approximate the minimizer $\begin{array} { r } { x ^ { * } = \arg \operatorname* { m i n } _ { x \in \{ 0 , 1 \} ^ { n } } f ( x ) } \end{array}$ in the following setting:
+
+1. Oracle model: evaluation of $f$ for a given choice of hyperparameters is assumed to be very expensive. Such is the case of training a given architecture of a huge dataset. 2. Parallelism is crucial: testing several model hyperparameters in parallel is entirely possible in cloud architecture, and dramatically reduces overall optimization time. 3. $f$ is structured.
+
+The third point is very important since clearly HPO is information-theoretically hard and $2 ^ { n }$ evaluations of the function are necessary in the worst case. Different works have considered exploiting one or more of the properties above. The approach of Bayesian optimization (Snoek et al., 2012) addresses the structure of $f$ , and assumes that a useful prior distribution over the structure of $f$ is known in advance. Multi-armed bandit algorithms (Li et al., 2016), and Random Search (Bergstra & Bengio, 2012), exploit computational parallelism very well, but do not exploit any particular structure of $f ^ { 1 }$ . These approaches are surveyed in more detail later.
+
+# 1.1 OUR CONTRIBUTION
+
+In this paper we introduce a new spectral approach to hyperparameter optimization. Our main idea is to make assumptions on the structure of $f$ in the Fourier domain. Specifically we assume that $f$ can be approximated by a sparse and low degree polynomial in the Fourier basis. This means intuitively that it can be approximated well by a decision tree.
+
+The implication of this assumption is that we can obtain a rigorous theoretical guarantee: approximate minimization of $f$ over the boolean hypercube with function evaluations only linear in sparsity that can be carried out in parallel. We further give improved heuristics on this basic construction and show experiments showing our assumptions are validated in practice for HPO as applied to deep learning over image datasets.
+
+Thus our contributions can be listed as:
+
+• A new spectral method called Harmonica that has provable guarantees: sample-efficient recovery if the underlying objective is a sparse (noisy) polynomial and easy to implement on parallel architectures. We demonstrate significant improvements in accuracy, sample complexity, and running time for deep neural net training experiments. We compare ourselves to state-of-the-art solvers from Bayesian optimization, Multi-armed bandit techniques, and Random Search. Projecting to even higher numbers of hyperparameters, we perform simulations that show several orders-of-magnitude of speedup versus Bayesian optimization techniques. Improved bounds on the sample complexity of learning noisy, size $s$ decision trees over $n$ variables under the uniform distribution. We observe that the classical sample complexity bound of $n ^ { O ( \log ( s / \varepsilon ) ) }$ due to Linial et al. (1993) can be improved to quadratic in the size of the tree ${ \tilde { O } } ( s ^ { 2 } / \varepsilon \cdot \log n )$ while matching the best known quasipolynomial bound in running time.
+
+# 1.2 PREVIOUS WORK
+
+The literature on discrete-domain HPO can be roughly divided into two: probabilistic approaches and decision-theoretic methods. In critical applications, researchers usually use a grid search over all parameter space, but that becomes quickly prohibitive as the number of hyperparameter grows. Gradient-based methods such as (Maclaurin et al., 2015; Luketina et al., 2015; Fu et al., 2016; Bengio, 2000) are applicable only to continuous hyperparameters which we do not consider. Neural network structural search based on reinforcement learning is an active direction (Baker et al., 2016; Zoph & Le, 2016; Zhong et al., 2017), which usually needs many samples of network architectures. 1 except that they could implicitly utilize smoothness or other local properties of the space.
+
+Probabilistic methods and Bayesian optimization. Bayesian optimization (BO) algorithms (Bergstra et al., 2011; Snoek et al., 2012; Swersky et al., 2013; Snoek et al., 2014; Gardner et al., 2014; Wang et al., 2013; Ilievski et al., 2017) tune hyperparameters by assuming a prior distribution of the loss function, and then keep updating this prior distribution based on the new observations. Each new observation is selected according to an acquisition function, which balances exploration and exploitation such that the new observation gives us a better result, or helps gain more information. The BO approach is inherently serial and difficult to parallelize, and its theoretical guarantees have thus far been limited to statistical consistency (convergence in the limit).
+
+Decision-theoretic methods. Perhaps the simplest approach to HPO is random sampling of different choices of parameters and picking the best amongst the chosen evaluations (Bergstra & Bengio, 2012). It is naturally very easy to implement and parallelize. Upon this simple technique, researchers have tried to allocate different budgets to the different evaluations, depending on their early performance. Using adaptive resource allocation techniques found in the multi-armed bandit literature, Successive Halving (SH) algorithm was introduced (Jamieson & Talwalkar, 2016). Hyperband further improves SH by automatically tuning the hyperparameters in SH (Li et al., 2016).
+
+Learning decision trees. Prior work for learning decision trees (more generally Boolean functions that are approximated by low-degree polynomials) used the celebrated “low-degree” algorithm of Linial et al. (1993). Their algorithm uses random sampling to estimate each low-degree Fourier coefficient to high accuracy.
+
+We make use of the approach of Stobbe & Krause (2012), who showed how to learn low-degree, sparse Boolean functions using tools from compressed sensing (similar approaches were taken by Kocaoglu et al. (2014) and Negahban & Shah (2012)). We observe that their approach can be extended to learn functions that are both “approximately sparse” (in the sense that the $L _ { 1 }$ norm of the coefficients is bounded) and “approximately low-degree” (in the sense that most of the $L _ { 2 }$ mass of the Fourier spectrum resides on monomials of low-degree). This implies the first decision tree learning algorithm with polynomial sample complexity that handles adversarial noise. In addition, we obtain the optimal dependence on the error parameter $\varepsilon$ .
+
+For the problem of learning exactly $k$ -sparse Boolean functions over $n$ variables, Haviv & Regev (2015) have recently shown that $O ( n k \log n )$ uniformly random samples suffice. Their result is not algorithmic but does provide an upper bound on the information-theoretic problem of how many samples are required to learn. The best algorithm in terms of running time for learning $k$ -sparse Boolean functions is due to Feldman et al. (2009), and requires time $2 ^ { { \bar { \Omega } } ( n / \log n ) }$ . It is based on the Blum et al. (2003) algorithm for learning parities with noise.
+
+Techniques. Our methods are heavily based on known results from the analysis of boolean functions as well as compressed sensing.
+
+# 2 SETUP AND DEFINITIONS
+
+The problem of hyperparameter optimization is that of minimizing a discrete, real-valued function, which we denote by $f : \{ - 1 , 1 \} ^ { n } \mapsto [ - 1 , 1 ]$ (we can handle arbitrary inputs, binary is chosen for simplicity of presentation).
+
+In the context of hyperparameter optimization, function evaluation is very expensive, although parallelizable, as it corresponds to training a deep neural net. In contrast, any computation that does not involve function evaluation is considered less expensive, such as computations that require time $\Omega ( n ^ { d } )$ for “somewhat large” $d$ or are subexponential (we still consider runtimes that are exponential in $n$ to be costly).
+
+# 2.1 BASICS OF FOURIER ANALYSIS
+
+The reader is referred to O’Donnell (2014) for an in depth treatment of Fourier analysis of Boolean functions. Let $f : \mathcal { X } \mapsto [ - 1 , 1 ]$ be a function over domain $\mathcal { X } \subseteq \mathbb { R } ^ { n }$ . Let $\mathcal { D }$ a probability distribution on $\mathcal { X }$ . We write $g \equiv _ { \varepsilon } f$ and say that $f , g$ are $\varepsilon$ -close if $\begin{array} { r } { \mathbb { E } _ { x \sim \mathcal { D } } [ ( f ( x ) - g ( x ) ) ^ { \bar { 2 } } ] \le \varepsilon } \end{array}$ .
+
+Definition 1. (Rauhut, 2010) We say a family of functions $\psi _ { 1 } , \ldots , \psi _ { N }$ ( $\psi _ { i }$ maps $\mathcal { X }$ to $\mathbb { R }$ ) is a Random Orthonormal Family with respect to $\mathcal { D }$ if
+
+$$
+\mathbb { E } _ { \mathcal { D } } [ \psi _ { i } ( X ) \cdot \psi _ { j } ( X ) ] = \delta _ { i j } = \left\{ \begin{array} { l l } { 1 } & { \mathrm { ~ i f ~ } i = j } \\ { 0 } & { \mathrm { ~ o t h e r w i s e } } \end{array} \right. .
+$$
+
+The expectation is taken with respect to probability distribution $\mathcal { D }$ . We say that the family is $K$ - bounded if $\begin{array} { r } { \operatorname* { s u p } _ { x \in \mathcal { X } } | \psi _ { i } ( x ) | \le K } \end{array}$ for every $i$ . Henceforth we assume $K = 1$ .
+
+An important example of a random orthonormal family is the class of parity functions with respect to the uniform distribution on $\{ - 1 , 1 \} ^ { n }$ :
+
+Definition 2. A parity function on some subset of variables $S \subseteq [ n ]$ is the function $\chi _ { S } : \{ - 1 , 1 \} ^ { n } \mapsto$ $\{ - 1 , 1 \}$ where $\begin{array} { r } { \bar { \chi } _ { S } ( x ) = \prod _ { i \in S } x _ { i } } \end{array}$ .
+
+It is easy to see that the set of all $2 ^ { n }$ parity functions $\{ \chi _ { S } \}$ , one for each $S \subseteq [ n ]$ , form a random orthonormal family with respect to the uniform distribution on $\{ - 1 , 1 \} ^ { n }$ .
+
+This random orthonormal family is often referred to as the Fourier basis, as it is a complete orthonormal basis for the class of Boolean functions with respect to the uniform distribution on $\{ - 1 , 1 \} ^ { n }$ . More generally, for any $f : \{ - 1 , 1 \} ^ { n } \mapsto \mathbb { R }$ , $f$ can be uniquely represented in this basis as $\begin{array} { r } { f ( x ) = \sum _ { S \subseteq [ n ] } \hat { f } _ { S } \chi _ { S } ( x ) } \end{array}$ where $\hat { f } _ { S } = \langle f , \chi _ { S } \rangle = \mathbb { E } _ { x \in \{ - 1 , 1 \} ^ { n } } [ f ( x ) \chi _ { S } ( x ) ]$ is the Fourier coefficient corresponding to $S$ where $x$ is drawn uniformly from $\{ - 1 , 1 \} ^ { n }$ . We also have Parseval’s identity: $\begin{array} { r } { \mathbb { E } [ f ^ { 2 } ] = \sum _ { S } \hat { f } _ { S } ^ { 2 } } \end{array}$ .
+
+In this paper, we will work exclusively with the above parity basis. Our results apply more generally, however, to any orthogonal family of polynomials (and corresponding product measure on $\mathbb { R } ^ { n }$ ). For example, if we wished to work with continuous hyperparameters, we could work with families of Hermite orthogonal polynomials with respect to multivariate spherical Gaussian distributions.
+
+We conclude with a definition of low-degree, approximately sparse (bounded $L _ { 1 }$ norm) functions:
+
+Definition 3 (Approximately sparse function). Let $\{ \chi _ { S } \}$ be the parity basis, and let $\mathcal { C }$ be a class of functions mapping $\{ - 1 , 1 \} ^ { n }$ to $\mathbb { R }$ . Thus for $f \in { \mathcal { C } }$ , $\begin{array} { r } { f = \sum _ { S } \hat { f } ( S ) \chi _ { S } } \end{array}$ . We say a function $f \in C$ is $s$ -sparse if $L _ { 0 } ( f ) ~ \le ~ s$ , ie., f has at most $s$ nonzero entries in its polynomial expansion. $f$ is $( \varepsilon , d )$ -concentrated if $\begin{array} { r } { \mathbb { E } [ ( f - \sum _ { S , | S | } \le _ { d } \hat { f } ( S ) \chi _ { S } ) ^ { 2 } ] \ge 1 - \varepsilon . { \mathcal C } } \end{array}$ is $( \varepsilon , d , s )$ -bounded if for every $f \in { \mathcal { C } }$ , $f$ is $( \varepsilon , d )$ -concentrated and in addition $\mathcal { C }$ has $L _ { 1 }$ norm bounded by $s$ , that is, for every $f \in { \mathcal { C } }$ we have $\Sigma _ { S } \left| \hat { f } ( S ) \right| \le s$ .
+
+It is easy to see that the class of functions with bounded $L _ { 1 }$ norm is more general than sparse functions. For example, the Boolean AND function has $L _ { 1 }$ norm bounded by 1 but is not sparse.
+
+We also have the following simple fact:
+
+Fact 4. (Mansour, 1994) Let $f$ be such that $L _ { 1 } ( f ) ~ \leq ~ s .$ . Then there exists $g$ such that $g$ is $s ^ { 2 } / \varepsilon$ sparse and $E [ ( f - g ) ^ { 2 } ] \ \leq \ \varepsilon .$ . The function $g$ is constructed by taking all coefficients of magnitude $\varepsilon / s$ or larger in $f$ ’s expansion as a polynomial.
+
+# 2.2 COMPRESSED SENSING AND SPARSE RECOVERY
+
+In the problem of sparse recovery, a learner attempts to recover a sparse vector $x \in \mathbb { R } ^ { n }$ which is $s$ sparse, i.e. $\| x \| _ { 0 } ~ \leq ~ s$ , from an observation vector $y \in R ^ { m }$ that is assumed to equal $y =$ $A x + e$ , where $e$ is assumed to be zero-mean, usually Gaussian, noise. The seminal work of Candes et al. (2006); Donoho (2006) shows how $x$ can be recovered exactly under various conditions on the observation matrix $A \in \mathbb { R } ^ { m \times n }$ and the noise. The usual method for recovering the signal proceeds by solving a convex optimization problem consisting of $\ell _ { 1 }$ minimization as follows (for some parameter $\lambda > 0$ ):
+
+$$
+\operatorname* { m i n } _ { x \in \mathbb { R } ^ { n } } \left\{ \| x \| _ { 1 } + \lambda \| A x - y \| _ { 2 } ^ { 2 } \right\} .
+$$
+
+The above formulation comes in many equivalent forms (e.g., Lasso), where one of the objective parts may appear as a hard constraint.
+
+![](images/99c3e11f461c522493c36ebff71c1d89e0b5b627007d4ccea635366a7149f59b.jpg)  
+Figure 1: Compressed sensing over the Fourier domain: Harmonica recovers the Fourier coefficients of a sparse low degree polynomial $\textstyle \sum _ { S } \alpha _ { S } \Psi _ { S } ( x _ { i } )$ from observations $f ( x _ { i } )$ of randomly chosen points $x _ { i } \in$ $\{ - 1 , 1 \} ^ { n }$ .
+
+For our work, the most relevant extension of traditional sparse recovery is due to Rauhut (2010), who considers the problem of sparse recovery when the measurements are evaluated according to a random orthonormal family. More concretely, fix $x \in \mathbb { R } ^ { n }$ with $s$ non-zero entries. For $K$ - bounded random orthonormal family $\mathcal { F } = \{ \psi _ { 1 } , . . . , \psi _ { N } \}$ , and $m$ independent draws $z ^ { 1 } , \ldots , z ^ { m }$ from corresponding distribution $\mathcal { D }$ define the $m \times N$ matrix $A$ such that $A _ { i j } = \psi _ { j } ( z ^ { i } )$ . Rauhut gives the following result for recovering sparse vectors $x$ :
+
+Theorem 5 (Sparse Recovery for Random Orthonormal Families, (Rauhut, 2010) Theorem 4.4). Given as input matrix √ $A \ \in \ \mathbb { R } ^ { m \times N }$ and vector $y$ with $y _ { i } ~ = ~ A x + e _ { i }$ for some vector e with $\| e \| _ { 2 } ~ \le ~ \bar { \eta \sqrt { m } } ,$ , mathematical program (1) finds a vector $x ^ { * }$ such that for constants $c _ { 1 }$ and $c _ { 2 }$ , $\begin{array} { r } { \| x - x ^ { * } \| _ { 2 } \ \leq \ c _ { 1 } \frac { \sigma _ { s } ( x ) _ { 1 } } { \sqrt { s } } + c _ { 2 } \eta } \end{array}$ with probability $1 - \delta$ as long as for sufficiently large constant $C _ { i }$ , $m \ge C K ^ { 2 } \log K \cdot s \log ^ { 3 } s \cdot \log ^ { 2 } N \cdot \log ( 1 / \delta )$ .
+
+The term $\sigma _ { s } ( x ) _ { 1 }$ is equal to $\operatorname* { m i n } \{ \| x - z \| _ { 1 } , z$ is $s$ sparse}. Recent work (Bourgain, 2014; Haviv & Regev, 2016) has improved the dependence on the polylog factors in the lower bound for $m$ .
+
+# 3 BASIC ALGORITHM AND MAIN THEORETICAL RESULTS
+
+The main component of our spectral algorithm for hyperparameter optimization is given in Algorithm $1 ^ { 2 }$ . It is essentially an extension of sparse recovery (basis pursuit or Lasso) to the orthogonal basis of polynomials in addition to an optimization step. See Figure 1 for an illustration. We prove Harmonica’s theoretical guarantee, and show how it gives rise to new theoretical results in learning from the uniform distribution.
+
+In the next section we describe extensions of this basic algorithm to a more practical algorithm with various heuristics to improve its performance.
+
+# Algorithm 1 Harmonica-1
+
+1: Input: oracle for $f$ , number of samples $T$ , sparsity $s$ , degree $d$ , parameter $\lambda$ .   
+2: Invoke $\mathrm { P S R } ( f , T , s , d , \lambda )$ (Procedure 2) to obtain $( g , J )$ , where $g$ is a function defined on vari  
+ables specified by index set $J \subseteq [ n ]$ .   
+3: Set the variables in $[ n ] \mid J$ to arbitrary values, compute a minimizer $x ^ { \star } \in \arg \operatorname* { m i n } g ( x )$ .   
+4: return $x ^ { \star }$
+
+Theorem 6 (Noiseless recovery). Let $\{ \psi _ { S } \}$ be a 1-bounded orthonormal polynomial basis for distribution $\mathcal { D }$ . Let $f : \mathbb { R } ^ { n } \mapsto \mathbb { R }$ be a $( 0 , d , s )$ -bounded function as per definition $^ 3$ with respect to the basis $\psi _ { S }$ . Then Algorithm $^ { l }$ , in time $n ^ { O ( d ) }$ and sample complexity $T = { \tilde { O } } ( s \cdot d \log n )$ , returns $x ^ { \star }$ such that $x ^ { \star } \in \arg \operatorname* { m i n } f ( x )$ .
+
+This theorem, and indeed most of the results in this paper, follows from the main recovery properties of Procedure 2. This recovery procedure satisfies the following main lemma. See its proof in Section A.1.
+
+Lemma 7 (Noisy recovery). Let $\{ \psi _ { S } \}$ be a 1-bounded orthonormal polynomial basis for distribution $\mathcal { D }$ . Let $f ~ : ~ \mathbb { R } ^ { n } \ \mapsto \ \mathbb { R }$ be a $( \varepsilon / 4 , d , s )$ -bounded as per definition 3 with respect to the
+
+# Procedure 2 Polynomial Sparse Recovery (PSR)
+
+1: Input: oracle for $f$ , number of samples $T$ , sparsity $s$ , degree $d$ , regularization parameter $\lambda$   
+2: Query $T$ random samples: $\{ f ( x _ { 1 } ) , . . . . , f ( x _ { T } ) \}$ .
+
+3: Solve sparse $d$ -polynomial regression over all polynomials up to degree $d$
+
+$$
+\arg \operatorname* { m i n } _ { \alpha \in \mathbb { R } ^ { \left( \frac { n } { d } \right) } } \left\{ \sum _ { i = 1 } ^ { T } \left( \sum _ { | S | \leq d } \alpha _ { S } \psi _ { S } ( x _ { i } ) - f ( x _ { i } ) \right) ^ { 2 } + \lambda \| \alpha \| _ { 1 } \right\}
+$$
+
+4: Let $S _ { 1 } , . . . , S _ { s }$ be the indices of the largest coefficients of $\vec { \alpha }$ .
+
+5: return $\begin{array} { r } { g \triangleq \sum _ { i \in [ s ] } \alpha _ { S _ { i } } \psi _ { S _ { i } } ( x ) } \end{array}$ and $J = \cup _ { i = 1 } ^ { s } S _ { i }$ basis $\psi _ { S }$ . Then Procedure 2 finds a function $\begin{array} { l l } { \boldsymbol { \mathit { g } } } & { \equiv _ { \varepsilon } } & { \boldsymbol { \mathit { f } } } \end{array}$ in time $O ( n ^ { d } )$ and sample complexity $T = \tilde { O } ( s ^ { 2 } / \varepsilon \cdot d \log n )$ .
+
+Remark: Note that the above Lemma also holds in the adversarial or agnostic noise setting. That is, an adversary could add a noise vector $v$ to the labels received by the learner. In this case, the learner will see label vector $y = A x + e + v$ . If $\| v \| _ { 2 } ~ \le ~ \sqrt { \gamma m }$ , then we will recover a polynomial with squared-error at most $\varepsilon + O ( \gamma )$ via re-scaling $\varepsilon$ by a constant factor and applying the triangle inequality to $\lVert e + v \rVert _ { 2 }$ .
+
+While this noisy recovery lemma is the basis for our enhanced algorithm in the next section as well as the learning-theoretic result on learning of decision trees detailed in the next subsection, it does not imply recovery of the global optimum. The reason is that noisy recovery guarantees that we output a hypothesis close to the underlying function, but even a single noisy point can completely change the optimum.
+
+Nevertheless, we can use our techniques to prove recovery of optimality for functions that are computed exactly by a sparse, low-degree polynomial (Theorem 6). See the proof in Section A.2.
+
+# 3.1 APPLICATION: LEARNING DECISION TREES IN QUASI-POLYNOMIAL TIME AND POLYNOMIAL SAMPLE COMPLEXITY
+
+Lemma 7 has important applications for learning (in the PAC model (Valiant, 1984)) well-studied function classes with respect to the uniform distribution on $\{ - 1 , 1 \} ^ { n 3 }$ . For example, we obtain the first quasi-polynomial time algorithm for learning decision trees with respect to the uniform distribution on $\bar { \{ - 1 , 1 \} } ^ { n }$ with polynomial sample complexity:
+
+Corollary 8. Let $\mathcal { X } = \{ - 1 , 1 \} ^ { n }$ and let $\mathcal { C }$ be the class of all decision trees of size s on n variables. Then $\mathcal { C }$ is learnable with respect to the uniform distribution in time $n ^ { O ( \log ( s / \varepsilon ) ) }$ and sample complexity $m = \tilde { O } ( s ^ { 2 } / \varepsilon \cdot \log n )$ . Further, if the labels are corrupted by arbitrary noise vector $v$ such that $\| v \| _ { 2 } ~ \le ~ \sqrt { \gamma m }$ , then the output classifier will have squared-error at most $\varepsilon + O ( \gamma )$ .
+
+See the proof of Corollary 8 in Section A.3.
+
+Comparison with the “Low-Degree” Algorithm. Prior work for learning decision trees (more generally Boolean functions that are approximated by low-degree polynomials) used the celebrated “low-degree” algorithm of Linial et al. (1993). Their algorithm uses random sampling to estimate each low-degree Fourier coefficient to high accuracy. In contrast, our approach is to use algorithms for compressed sensing to estimate the coefficients. Tools for compressed sensing take advantage of the incoherence of the design matrix and give improved results that seem unattainable from the “low-degree” algorithm.
+
+For learning noiseless, Boolean decision trees, the low-degree algorithm uses quasipolynomial time and sample complexity ${ \tilde { O } } ( s ^ { 2 } / \varepsilon ^ { 2 } \cdot \log n )$ to learn to accuracy $\varepsilon$ . It is not clear, however, how to obtain any noise tolerance from their approach.
+
+For general real-valued decision trees where $B$ is an upper bound on the maximum value at any leaf of a size $s$ tree, our algorithm will succeed with sample complexity $\tilde { O } ( B ^ { 2 } s ^ { 2 } / \varepsilon \cdot \log n )$ and be tolerant to noise while the low-degree algorithm will use $\bar { \tilde { O } } ( B ^ { 4 } s ^ { 2 } \bar { / } \varepsilon ^ { 2 } \cdot \mathrm { l o g } n )$ (and will have no noise tolerance properties). Note our improvement in the dependence on $\varepsilon$ (even in the noiseless setting), which is a consequence of the RIP property of the random orthonormal family.
+
+# 4 HARMONICA: THE FULL ALGORITHM
+
+Rather than applying Algorithm 1 directly, we found that performance is greatly enhanced by iteratively using Procedure 2 to estimate the most influential hyperparameters and their optimal values.
+
+In the rest of this section we describe this iterative heuristic, which essentially runs Algorithm 1 for multiple stages. More concretely, we continue to invoke the PSR subroutine until the search space becomes small enough for us to use a “base” hyperparameter optimizer (in our case either SH or Random Search).
+
+The space of minimizing assignments to a multivariate polynomial is a highly non-convex set that may contain many distinct points. As such, we take an average of several of the best minimizers (of subsets of hyperparameters) during each stage.
+
+In order to describe this formally we need the following definition of a restriction of function:
+
+Definition 9 (restriction (O’Donnell, 2014)). Let $f \in \{ - 1 , 1 \} ^ { n } \mapsto \mathbb { R }$ , $J \subseteq [ n ]$ , and $z \in \{ - 1 , 1 \} ^ { J }$ be given. We call $( J , z )$ a restriction pair of function $f$ . We denote $f _ { J , z }$ the function over $n - | J |$ variables given by setting the variables of $J$ to $z$ .
+
+We can now describe our main algorithm (Algorithm 3). Here $q$ is the number of stages for which we apply the PSR subroutine, and the restriction size $t$ serves as a tie-breaking rule for the best minimizers (which can be set to 1).
+
+# Algorithm 3 Harmonica- $q$
+
+1: Input: oracle for $f$ , number of samples $T$ , sparsity $s$ , degree $d$ , regularization parameter $\lambda$ ,   
+number of stages $q$ , restriction size $t$ , base hyperparameter optimizer ALG.   
+2: for stage $i = 1$ to $q$ do   
+3: Invoke $\mathrm { P S R } ( f , T , s , d , \lambda )$ (Procedure 2) to obtain $( g _ { i } , J _ { i } )$ , where $g _ { i }$ is a function defined on   
+variables specified by index set $J _ { i } \subseteq [ n ]$ .   
+4: Let $M _ { i } = \left\{ x _ { 1 } ^ { \star } , . . . , x _ { t } ^ { \star } \right\} = \arg \operatorname* { m i n } g _ { i } ( x )$ be the best $t$ minimizers of $g _ { i }$ .   
+5: Let $f _ { i } = \mathbb { E } _ { k \in [ t ] } [ f _ { J _ { i } , x _ { k } ^ { \star } } ]$ be the expected restriction of $f$ according to minimizers $M _ { i }$ . 4   
+6: Set $f = f _ { i }$ .   
+7: end for   
+8: return Search for the global minimizer of $f _ { q }$ using base optimizer ALG
+
+We defer the comparison of Harmonica and other algorithms in Section B.
+
+# 5 EXPERIMENTS WITH TRAINING DEEP NETWORKS
+
+We compare Harmonica5 with Spearmint6 (Snoek et al., 2012), Hyperband, $\mathrm { S H } ^ { 7 }$ and Random Search. Both Spearmint and Hyperband are state-of-the-art algorithms, and it is observed that Random Search $2 \mathbf { x }$ (Random Search with doubled function evaluation resources) is a very competitive benchmark that beats many algorithms8.
+
+Our first experiment is over training residual network on Cifar-10 dataset9. We included 39 binary hyperparameters, including initialization, optimization method, learning rate schedule, momentum rate, etc. Table 1 (Section C.1) details the hyperparameters considered. We also include 21 dummy variables to make the task more challenging. Notice that Hyperband, SH, and Random Search are agnostic to the dummy variables in the sense that they just set the value of dummy variables randomly, therefore select essentially the same set of configurations with or without the dummy variables. Only Harmonica and Spearmint are sensitive to the dummy variables as they try to learn the high dimensional function space. To make a fair comparison, we run Spearmint without any dummy variables.
+
+![](images/e326dfc0161f280589b33fe67d80bfb2428d811436cb26680f2be72e5a9eecaf.jpg)  
+Figure 2: Distribution of the best results and running time of different algorithms
+
+![](images/08dbffb196c4680e0af6a48c558dd7b9325b550ec0ee2fc138f4b1e69ab23817.jpg)  
+Figure 3: Comparing different variants of Harmonica with SH on test error and running time
+
+As most hyperparameters have a consistent effect as the network becomes deeper, a common handtuning strategy is “tune on small network, then apply the knowledge to big network” (See discussion in Section C.3). Harmonica can also exploit this strategy as it selects important features stageby-stage. More specifically, during the feature selection stages, we run Harmonica for tuning an 8 layer neural network with 30 training epochs. At each stage, we take 300 samples to extract 5 important features, and set restriction size $t \ : = \ : 4$ (see Procedure 2). After that, we fix all the important features, and run the SH or Random Search as our base algorithm on the big 56 layer neural network for training the whole 160 epochs10. To clarify, “stage” means the stages of the hyperparameter algorithms, while “epoch” means the epochs for training the neural network.
+
+# 5.1 PERFORMANCE
+
+We tried three versions of Harmonica for this experiment, Harmonica with 1 stage (Harmonica-1), 2 stages (Harmonica-2) and 3 stages (Harmonica-3). All of them use SH as the base algorithm. The top 10 test error results and running times of the different algorithms are depicted in Figure 2. SH based algorithms may return fewer than 10 results. For more runs of variants of Harmonica and its resulting test error, see Figure 3 (the results are similar to Figure 2).
+
+Test error and scalability: Harmonica-1 uses less than $1 / 5$ time of Spearmint, $1 / 7$ time of Hyperband and $1 / 8$ time compared with Random Search, but gets better results than the competing algorithms. It beats the Random Search 8x benchmark (stronger than Random Search $2 \mathbf { x }$ benchmark of Li et al. (2016)). Harmonica-2 uses slightly more time, but is able to find better results.
+
+Improving upon human-tuned parameters: Harmonica-3 obtains a better test error $( 6 . 5 8 \% )$ ) as compared to the best hand-tuning rate $6 . 9 7 \%$ reported in (He et al., 2016)11. Harmonica-3 uses only 6.1 GPU days, which is less than half day in our environment, as we have 20 GPUs running in parallel. Notice that we did not cherry pick the results for Harmonica-3. In Section 5.3 we show by running Harmonica-3 for longer time, one can obtain a few other solutions better than hand tuning.
+
+Performance of provable methods: Harmonica-1 has noiseless and noisy recovery guarantees (Lemma 7), which are validated experimentally.
+
+# 5.2 AVERAGE TEST ERROR FOR EACH STAGE
+
+We computed the average test error among 300 random samples for an 8 layer network with 30 epochs after each stage. See Figure 4 in Appendix. After selecting 5 features in stage 1, the average test error drops from 60.16 to 33.3, which indicates the top 5 features are very important. As we proceed to stage 3, the improvement on test error becomes less significant as the selected features at stage 3 have mild contributions.
+
+# 5.3 HYPERPARAMETERS FOR HARMONICA
+
+To be clear, Harmonica itself has six hyperparameters that one needs to set including the number of stages, $\ell _ { 1 }$ regularizer for Lasso, the number of features selected per stage, base algorithm, small network configuration, and the number of samples per stage. Note, however, that we have reduced the search space of general hyperparameter optimization down to a set of only six hyperparameters. Empirically, our algorithm is robust to different settings of these parameters, and we did not even attempt to tune some of them (e.g., small network configuration).
+
+Base algorithm and #stages. We tried different versions of Harmonica, including Harmonica with 1 stage, 2 stages and 3 stages using SH as the base algorithm (Harmonica-1, Harmonica-2, Harmonica-3), with 1 stage and 2 stages using Random Search as the base algorithm (Harmonica-1- Random-Search, Harmonica-2-Random-Search), and with 2 stages and 3 stages running SH as the base for longer time (Harmonica-2-Long, Harmonica-3-Long). As can be seen in Figure 3, most variants produce better results than SH and use less running time. Moreover, if we run SH for longer time, we will obtain more stable solutions with less variance in test error.
+
+Lasso parameters are stable. See Table 3 in Appendix for stable range for regularization term $\lambda$ and the number of samples. Here stable range means as long as the parameters are set in this range, the top 5 features and the signs of their weights (which are what we need for computing $g ( x )$ in Procedure 2) do not change. In other words, the feature selection outcome is not affected. When parameters are outside the stable ranges, usually the top features are still unchanged, and we miss only one or two out of the five features.
+
+On the degree of features. We set degree to be three because it does not find any important features with degree larger than this. Since Lasso can be solved efficiently (less than 5 minutes in our experiments), the choice of degree can be decided automatically.
+
+# 5.4 EXPERIMENTS WITH SYNTHETIC FUNCTIONS
+
+Our second experiment considers a synthetic hierarchically bounded function $h ( x )$ . In this experiment, we showed that the optimization time of Harmonica is significantly faster than Spearmint, and the estimation error of Harmonica is linear in the noise level of the function. See Section C.4 for details.
+
+# 6 ACKNOWLEDGEMENTS
+
+We thank Sanjeev Arora for helpful discussions and encouragement. We thank anonymous reviewers for their helpful comments. Elad Hazan is supported by NSF grant 1523815. This project is supported by a Microsoft Azure research award and Amazon AWS research award.
+
+# REFERENCES
+
+Bowen Baker, Otkrist Gupta, Nikhil Naik, and Ramesh Raskar. Designing neural network architectures using reinforcement learning. CoRR, abs/1611.02167, 2016.
+
+Yoshua Bengio. Gradient-based optimization of hyperparameters. Neural Computation, 12(8): 1889–1900, 2000.
+
+James Bergstra and Yoshua Bengio. Random search for hyper-parameter optimization. J. Mach. Learn. Res., 13:281–305, February 2012. ISSN 1532-4435.
+
+James S. Bergstra, Remi Bardenet, Yoshua Bengio, and Bal ´ azs K ´ egl. Algorithms for hyper- ´ parameter optimization. In J. Shawe-Taylor, R. S. Zemel, P. L. Bartlett, F. Pereira, and K. Q. Weinberger (eds.), Advances in Neural Information Processing Systems 24, pp. 2546–2554. Curran Associates, Inc., 2011.
+
+Avrim Blum, Adam Kalai, and Hal Wasserman. Noise-tolerant learning, the parity problem, and the statistical query model. J. ACM, 50(4):506–519, July 2003. ISSN 0004-5411.
+
+Jean Bourgain. An Improved Estimate in the Restricted Isometry Problem, pp. 65–70. Springer International Publishing, Cham, 2014.
+
+E. J. Candes, J. Romberg, and T. Tao. Robust uncertainty principles: Exact signal reconstruction from highly incomplete frequency information. IEEE Trans. Inf. Theor., 52(2):489–509, February 2006. ISSN 0018-9448.
+
+D. L. Donoho. Compressed sensing. IEEE Trans. Inf. Theor., 52(4):1289–1306, April 2006. ISSN 0018-9448.
+
+V. Feldman, Parikshit Gopalan, Subhash Khot, and Ashok Kumar Ponnuswami. On agnostic learning parities, monomials,and halfspaces. SIAM Journal on Computing, 39(2):606–645, 2009. ISSN 0097-5397.
+
+Jie Fu, Hongyin Luo, Jiashi Feng, Kian Hsiang Low, and Tat-Seng Chua. Drmad: Distilling reversemode automatic differentiation for optimizing hyperparameters of deep neural networks. CoRR, abs/1601.00917, 2016.
+
+Jacob R. Gardner, Matt J. Kusner, Zhixiang Eddie Xu, Kilian Q. Weinberger, and John P. Cunningham. Bayesian optimization with inequality constraints. In Proceedings of the 31th International Conference on Machine Learning, ICML 2014, Beijing, China, 21-26 June 2014, pp. 937–945, 2014.
+
+Xavier Glorot and Yoshua Bengio. Understanding the difficulty of training deep feedforward neural networks. In Proceedings of the Thirteenth International Conference on Artificial Intelligence and Statistics, AISTATS 2010, Chia Laguna Resort, Sardinia, Italy, May 13-15, 2010, pp. 249– 256, 2010.
+
+Ishay Haviv and Oded Regev. The list-decoding size of fourier-sparse boolean functions. In David Zuckerman (ed.), 30th Conference on Computational Complexity, CCC 2015, June 17- 19, 2015, Portland, Oregon, USA, volume 33 of LIPIcs, pp. 58–71. Schloss Dagstuhl - LeibnizZentrum fuer Informatik, 2015. ISBN 978-3-939897-81-1. URL http://www.dagstuhl. de/dagpub/978-3-939897-81-1.
+
+Ishay Haviv and Oded Regev. The restricted isometry property of subsampled fourier matrices. In Proceedings of the Twenty-seventh Annual ACM-SIAM Symposium on Discrete Algorithms, SODA ’16, pp. 288–297, Philadelphia, PA, USA, 2016. Society for Industrial and Applied Mathematics. ISBN 978-1-611974-33-1. URL http://dl.acm.org/citation.cfm?id= 2884435.2884457.
+
+Kaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. Delving deep into rectifiers: Surpassing human-level performance on imagenet classification. In 2015 IEEE International Conference on Computer Vision, ICCV 2015, Santiago, Chile, December 7-13, 2015, pp. 1026–1034, 2015.
+
+Kaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. Deep residual learning for image recognition. In 2016 IEEE Conference on Computer Vision and Pattern Recognition, CVPR 2016, Las Vegas, NV, USA, June 27-30, 2016, pp. 770–778, 2016.
+
+Gao Huang, Zhuang Liu, and Kilian Q. Weinberger. Densely connected convolutional networks. CoRR, abs/1608.06993, 2016.
+
+Ilija Ilievski, Taimoor Akhtar, Jiashi Feng, and Christine Annette Shoemaker. Efficient hyperparameter optimization for deep learning algorithms using deterministic RBF surrogates. In Proceedings of the Thirty-First AAAI Conference on Artificial Intelligence, February 4-9, 2017, San Francisco, California, USA., pp. 822–829, 2017.
+
+Sergey Ioffe and Christian Szegedy. Batch normalization: Accelerating deep network training by reducing internal covariate shift. In Proceedings of the 32nd International Conference on Machine Learning, ICML 2015, Lille, France, 6-11 July 2015, pp. 448–456, 2015.
+
+Kevin G. Jamieson and Ameet Talwalkar. Non-stochastic best arm identification and hyperparameter optimization. In Proceedings of the 19th International Conference on Artificial Intelligence and Statistics, AISTATS 2016, Cadiz, Spain, May 9-11, 2016, pp. 240–248, 2016.
+
+Diederik P. Kingma and Jimmy Ba. Adam: A method for stochastic optimization. CoRR, abs/1412.6980, 2014.
+
+Murat Kocaoglu, Karthikeyan Shanmugam, Alexandros G. Dimakis, and Adam R. Klivans. Sparse polynomial learning and graph sketching. In Zoubin Ghahramani, Max Welling, Corinna Cortes, Neil D. Lawrence, and Kilian Q. Weinberger (eds.), Advances in Neural Information Processing Systems 27: Annual Conference on Neural Information Processing Systems 2014, December 8-13 2014, Montreal, Quebec, Canada, pp. 3122–3130, 2014. URL http://papers.nips.cc/ book/advances-in-neural-information-processing-systems-27-2014.
+
+L. Li, K. Jamieson, G. DeSalvo, A. Rostamizadeh, and A. Talwalkar. Hyperband: A Novel BanditBased Approach to Hyperparameter Optimization. ArXiv e-prints, March 2016.
+
+Nathan Linial, Yishay Mansour, and Noam Nisan. Constant depth circuits, fourier transform, and learnability. J. ACM, 40(3):607–620, July 1993. ISSN 0004-5411.
+
+Jelena Luketina, Mathias Berglund, Klaus Greff, and Tapani Raiko. Scalable gradient-based tuning of continuous regularization hyperparameters. CoRR, abs/1511.06727, 2015.
+
+Dougal Maclaurin, David Duvenaud, and Ryan P. Adams. Gradient-based hyperparameter optimization through reversible learning. In Proceedings of the 32Nd International Conference on International Conference on Machine Learning - Volume 37, ICML’15, pp. 2113–2122. JMLR.org, 2015. URL http://dl.acm.org/citation.cfm?id=3045118.3045343.
+
+Yishay Mansour. Learning Boolean Functions via the Fourier Transform, pp. 391–424. Springer US, Boston, MA, 1994. doi: 10.1007/978-1-4615-2696-4 11.
+
+Sahand Negahban and Devavrat Shah. Learning sparse boolean polynomials. In Allerton, pp. 2032– 2036. IEEE, 2012. ISBN 978-1-4673-4537-8. URL http://ieeexplore.ieee.org/ xpl/mostRecentIssue.jsp?punumber $=$ 6475439.
+
+Ryan O’Donnell. Analysis of Boolean Functions. Cambridge University Press, New York, NY, USA, 2014. ISBN 1107038324, 9781107038325.
+
+Holger Rauhut. Compressive sensing and structured random matrices. Theoretical foundations and numerical methods for sparse recovery, 9:1–92, 2010.
+
+Benjamin Recht. Embracing the random. http://www.argmin.net/2016/06/23/ hyperband/, 2016a.
+
+Benjamin Recht. The news on auto-tuning. http://www.argmin.net/2016/06/20/ hypertuning/, 2016b.
+
+Jasper Snoek, Hugo Larochelle, and Ryan P. Adams. Practical bayesian optimization of machine learning algorithms. In Advances in Neural Information Processing Systems 25: 26th Annual Conference on Neural Information Processing Systems 2012. Proceedings of a meeting held December 3-6, 2012, Lake Tahoe, Nevada, United States., pp. 2960–2968, 2012.
+
+Jasper Snoek, Kevin Swersky, Richard S. Zemel, and Ryan P. Adams. Input warping for bayesian optimization of non-stationary functions. In Proceedings of the 31th International Conference on Machine Learning, ICML 2014, Beijing, China, 21-26 June 2014, pp. 1674–1682, 2014.
+
+Nitish Srivastava, Geoffrey E. Hinton, Alex Krizhevsky, Ilya Sutskever, and Ruslan Salakhutdinov. Dropout: a simple way to prevent neural networks from overfitting. Journal of Machine Learning Research, 15(1):1929–1958, 2014.
+
+Peter Stobbe and Andreas Krause. Learning fourier sparse set functions. In Neil D. Lawrence and Mark A. Girolami (eds.), Proceedings of the Fifteenth International Conference on Artificial Intelligence and Statistics, AISTATS 2012, La Palma, Canary Islands, April 21-23, 2012, volume 22 of JMLR Proceedings, pp. 1125–1133. JMLR.org, 2012. URL http://jmlr.org/ proceedings/papers/v22/.
+
+Ilya Sutskever, James Martens, George E. Dahl, and Geoffrey E. Hinton. On the importance of initialization and momentum in deep learning. In Proceedings of the 30th International Conference on Machine Learning, ICML 2013, Atlanta, GA, USA, 16-21 June 2013, pp. 1139–1147, 2013.
+
+Kevin Swersky, Jasper Snoek, and Ryan Prescott Adams. Multi-task bayesian optimization. In Advances in Neural Information Processing Systems 26: 27th Annual Conference on Neural Information Processing Systems 2013. Proceedings of a meeting held December 5-8, 2013, Lake Tahoe, Nevada, United States., pp. 2004–2012, 2013.
+
+R. Tibshirani. Regression shrinkage and selection via the lasso. Journal of the Royal Statistical Society (Series B), 58:267–288, 1996.
+
+Leslie G Valiant. A theory of the learnable. Communications of the ACM, 27(11):1134–1142, 1984.
+
+Ziyu Wang, Masrour Zoghi, Frank Hutter, David Matheson, and Nando de Freitas. Bayesian optimization in high dimensions via random embeddings. In IJCAI 2013, Proceedings of the $2 3 r d$ International Joint Conference on Artificial Intelligence, Beijing, China, August 3-9, 2013, pp. 1778–1784, 2013.
+
+Jian Wu and Peter I. Frazier. The parallel knowledge gradient method for batch bayesian optimization. In Advances in Neural Information Processing Systems 29: Annual Conference on Neural Information Processing Systems 2016, December 5-10, 2016, Barcelona, Spain, pp. 3126–3134, 2016.
+
+Sergey Zagoruyko and Nikos Komodakis. Wide residual networks. CoRR, abs/1605.07146, 2016.
+
+Zhao Zhong, Junjie Yan, and Cheng-Lin Liu. Practical network blocks design with q-learning. CoRR, abs/1708.05552, 2017.
+
+Barret Zoph and Quoc V. Le. Neural architecture search with reinforcement learning. CoRR, abs/1611.01578, 2016.
+
+# A MISSING PROOFS
+
+A.1 PROOF OF LEMMA 7
+
+Recall the Chebyshev inequality:
+
+Fact 10 (Multidimensional Chebyshev inequality). Let $X$ be an m dimensional random vector, with expected value $\mu = \operatorname { \mathbb { E } } [ X ]$ , and covariance matrix $V = \mathbb { E } [ ( X - \mu ) ( X - \mu ) ^ { T } ]$ .
+
+If $V$ is a positive definite matrix, for any real number $\delta > 0$ :
+
+$$
+\mathbb { P } ( \sqrt { ( X - \mu ) ^ { T } V ^ { - 1 } ( X - \mu ) } > \delta ) \le \frac { m } { \delta ^ { 2 } }
+$$
+
+For ease of notation we assume $K = 1$ . Let $f$ be an $( \varepsilon / 4 , s , d )$ -bounded function written in the orthonormal basis as $\textstyle \sum _ { S } { \hat { f } } ( S ) \psi _ { S }$ . We can equivalently write $f$ as $f = h + g$ , where $h$ is a degree $d$ polynomial that only includes coefficients of magnitude at least $\varepsilon / 4 s$ and the constant term of the polynomial expansion of $f$ .
+
+Since $\begin{array} { r } { L _ { 1 } ( f ) = \sum _ { S } | \hat { f } _ { S } | \le s } \end{array}$ , by Fact 4 we have that $h$ is $4 s ^ { 2 } / \varepsilon + 1$ sparse. The function $g$ is thus the sum of the remaining ${ \hat { f } } ( S ) \psi _ { S }$ terms not included in $h$ .
+
+Draw $m$ (to be chosen later) random labeled examples $\{ ( z ^ { 1 } , y ^ { 1 } ) , \dots , ( z ^ { m } , y ^ { m } ) \}$ and enumerate all $N = n ^ { d }$ basis functions $\psi _ { S }$ for $| S | \le d$ as $\{ \psi _ { 1 } , \ldots , \psi _ { N } \}$ . Form matrix $A$ such that $A _ { i j } = \psi _ { j } ( z ^ { i } )$ and consider the problem of recovering $4 s ^ { 2 } / \varepsilon + 1$ sparse $x$ given $A x + e = y$ where $x$ is the vector of coefficients of $h$ , the $i$ th entry of $y$ equals $y ^ { i }$ , and $e _ { i } = g ( \bar { z } ^ { i } )$ .
+
+We will prove that with constant probability over the choice $m$ random examples, $\| e \| _ { 2 } ~ \le ~ \sqrt { \varepsilon m }$ . Applying Theorem 5 by setting $\eta = \sqrt { \varepsilon }$ and observing that $\sigma _ { 4 s ^ { 2 } / \varepsilon + 1 } ( x ) _ { 1 } = 0$ , we will recover $x ^ { \prime }$ such that $\| x - x ^ { \prime } \| _ { 2 } ^ { 2 } \ \leq \ c _ { 2 } ^ { 2 } \varepsilon$ for some constant $c _ { 2 }$ . As such, for the function $\begin{array} { r } { \tilde { f } = \sum _ { i = 1 } ^ { N } x _ { i } ^ { \prime } \psi _ { i } } \end{array}$ we will have $\mathbb { E } [ \| h - \tilde { f } \| ^ { 2 } ] \ \leq \ c _ { 2 } ^ { 2 } \varepsilon$ by Parseval’s identity. Note, however, that we may rescale $\varepsilon$ by constant factor $1 / ( 2 c _ { 2 } ^ { 2 } )$ to obtain error $\varepsilon / 2$ and only incur an additional constant (multiplicative) factor in the sample complexity bound.
+
+By the definition of $g$ , we have
+
+$$
+\| g \| ^ { 2 } = \left( \sum _ { S , | S | > d } \hat { f } ( S ) ^ { 2 } + \sum _ { R } \hat { f } ( R ) ^ { 2 } \right)
+$$
+
+where each ${ \hat { f } } ( R )$ is of magnitude at most $\varepsilon / 4 s$ . By Fact 4 and Parseval’s identity we have $\textstyle \sum _ { R } { \hat { f } } ( R ) ^ { 2 } \ \leq \ \varepsilon / 4$ . Since $f$ is $( \varepsilon / 4 , d )$ -concentrated we have $\begin{array} { r } { \sum _ { S , | S | > d } { \hat { f } } ( S ) ^ { 2 } ~ \le ~ \varepsilon / 4 } \end{array}$ . Thus, $\| g \| ^ { 2 }$ is at most $\varepsilon / 2$ . Therefore, by triangle inequality $\mathbb { E } [ \| f - \tilde { f } \| ^ { 2 } ] \le \mathbb { E } [ \| h - \tilde { f } \| ^ { 2 } ] + \mathbb { E } [ \| g \| ^ { 2 } ] \le \varepsilon$ . It remains to bound $\| e \| _ { 2 }$ . Note that since the examples are chosen independently, the entries $e _ { i } =$ $g ( z ^ { i } )$ are independent random variables. Since $g$ is a linear combination of orthonormal monomials (not including the constant term), we have $\mathbb { E } _ { z \sim D } [ g ( z ) ] = 0$ . Here we can apply linearity of variance (the covariance of $\psi _ { i }$ and $\psi _ { j }$ is zero for all $i \neq j$ ) and calculate the variance
+
+$$
+\mathbf { V a r } ( g ( z ^ { i } ) ) = ( \sum _ { S , | S | > d } { \hat { f } } ( S ) ^ { 2 } + \sum _ { R } { \hat { f } } ( R ) ^ { 2 } )
+$$
+
+With the same calculation as (3), we know ${ \mathbf { V a r } } ( g ( z ^ { i } ) )$ is at most $\varepsilon / 2$ .
+
+Now consider the covariance matrix $V$ of the vector $e$ which equals $\mathbb { E } [ e e ^ { \top } ]$ (recall every entry of $e$ has mean 0). Then $V$ is a diagonal matrix (covariance between two independent samples is zero), and every diagonal entry is at most $\varepsilon / 2$ . Applying Fact 10 we have
+
+$$
+\mathbb { P } ( \| e \| _ { 2 } > \sqrt { \frac { \varepsilon } { 2 } } \delta ) \ \leq \ \frac { m } { \delta ^ { 2 } } .
+$$
+
+Setting $\delta = { \sqrt { 2 m } }$ , we conclude that $\mathbb { P } ( \| e \| _ { 2 } > { \sqrt { \varepsilon m } } ) \leq { \frac { 1 } { 2 } }$ . Hence with probability at least $1 / 2$ , we have that $\| e \| _ { 2 } ~ \le ~ \sqrt { \varepsilon m }$ . From Theorem 5, we may choose $m = \tilde { O } ( s ^ { 2 } / \varepsilon \cdot \log n ^ { d } )$ . This completes the proof. Note that the probability $1 / 2$ above can be boosted to any constant probability with a constant factor loss in sample complexity.
+
+# A.2 PROOF OF THEOREM 6
+
+There are at most $N = n ^ { d }$ polynomials $\psi _ { S }$ with $| S | \le d$ . Let the enumeration of these polynomials be $\psi _ { 1 } , \ldots , \psi _ { N }$ . Draw $m$ labeled examples $\{ ( z ^ { 1 } , y ^ { 1 } ) , \dots , ( z ^ { m } , y ^ { m } ) \}$ independently from $\mathcal { D }$ and construct an $m \times N$ matrix $A$ with $A _ { i j } = \psi _ { j } ( z ^ { i } )$ . Since $f$ can be written as an $s$ sparse linear combination of $\psi _ { 1 } , \dots , \psi _ { N }$ , there exists an $s$ -sparse vector $x$ such that $A x = y$ where the ith entry of $y$ is $y ^ { i }$ . Hence we can apply Theorem 5 to recover $x$ exactly. These are the $s$ non-zero coefficients of $f$ ’s expansion in terms of $\{ \psi _ { S } \}$ . Since $f$ is recovered exactly, its minimizer is found in the optimization step.
+
+# A.3 PROOF OF COROLLARY 8
+
+As mentioned earlier, the orthonormal polynomial basis for the class of Boolean functions with respect to the uniform distribution on $\{ - 1 , 1 \} ^ { n }$ is the class of parity functions $\{ \chi _ { S } \}$ for $S \subseteq \{ - 1 , 1 \} ^ { n }$ . Further, it is easy to show that for Boolean function $f$ , if $\mathbb { E } [ ( h - f ) ^ { 2 } ] ~ \leq ~ \varepsilon$ then $\mathbb { P } [ \mathsf { s i g n } ( h ( x ) ) \neq$ $f ( x ) ] \ \leq \ \varepsilon$ . The corollary now follows by applying Lemma 7 and two known structural facts about decision trees: 1) a tree of size $s$ is $( \varepsilon , \log ( s / \varepsilon ) )$ -concentrated and has $L _ { 1 }$ norm bounded by $s$ (see e.g., Mansour Mansour (1994)) and 2) by Fact 4, for any function $f$ with $L _ { 1 }$ norm bounded by $s$ (i.e., a decision tree of size $s$ ), there exists an $s ^ { 2 } / \varepsilon$ sparse function $g$ such that $\mathbb { E } [ ( f - g ) ^ { 2 } ] \ \leq \ \varepsilon$ . The noise tolerance property follows immediately from the remark after the proof of Lemma 7.
+
+# B ALGORITHM ATTRIBUTES AND HEURISTICS
+
+Scalability. If the hidden function if $s$ -sparse, Harmonica can find such a sparse function using $\tilde { O } ( s \log s )$ samples. If at every stage of Harmonica, the target function can be approximated by an $s$ sparse function, we only need ${ \tilde { O } } ( q s \log s )$ samples where $q$ is the number of stages. For real world applications such as deep neural network hyperparameter tuning, it seems (empirically) reasonable to assume that the hidden function is indeed sparse at every stage (see Section 5).
+
+For Hyperband (Li et al., 2016), SH (Jamieson & Talwalkar, 2016) or Random Search, even if the function is $s$ -sparse, in order to cover the optimal configuration by random sampling, we need $\Omega ( 2 ^ { s } )$ samples.
+
+Optimization time. Harmonica runs the Lasso (Tibshirani, 1996) algorithm after each stage to solve (2), which is a well studied convex optimization problem and has very fast implementations. Hyperband and SH are also efficient in terms of running time as a function of the number of function evaluations, and require sorting or other simple computations. The running time of Bayesian optimization is cubic in number of function evaluations, which limits applicability for large number of evaluations / high dimensionality, as we shall see in Section C.4.
+
+Parallelizability. Harmonica, similar to Hyperband, SH, and Random Search, has straightforward parallel implementations. In every stage of those algorithms, we could simply evaluate the objective functions over randomly chosen points in parallel.
+
+It is hard to run Bayesian optimization algorithm in parallel due to its inherent serial nature. Previous works explored variants in which multiple points are evaluated at the same time in parallel (Wu & Frazier, 2016), though speed ups do not grow linearly in the number of machines, and the batch size is usually limited to a small number.
+
+Feature Extraction. Harmonica is able to extract important features with weights in each stages, which automatically sorts all the features according to their importance. See Section C.2.
+
+# C EXPERIMENTAL DETAILS
+
+# C.1 OPTIONS
+
+Table 1: 60 options used in Section 5   
+
+<table><tr><td colspan="1" rowspan="1">Option Name</td><td colspan="1" rowspan="1">Description</td></tr><tr><td colspan="1" rowspan="1">01. Weight initialization</td><td colspan="1" rowspan="1">Use standard initializations or other initializations?</td></tr><tr><td colspan="1" rowspan="1">02. Weight initialization (Detail 1)</td><td colspan="1" rowspan="1"> Xavier Glorot (Glorot &amp; Bengio,2010), Kaiming (He et al., 2015),1/n,or1/n2？</td></tr><tr><td colspan="1" rowspan="1">03.Optimization method</td><td colspan="1" rowspan="1"> SGD or ADAM? (Kingma &amp; Ba, 2014)</td></tr><tr><td colspan="1" rowspan="1">04. Initial learning rate</td><td colspan="1" rowspan="1">≥ 0.01 or&lt;0.01？</td></tr><tr><td colspan="1" rowspan="1">05. Initial learning rate (Detail 1)</td><td colspan="1" rowspan="1">≥ 0.1,&lt;0.1，≥ 0.001,0r&lt;0.001？</td></tr><tr><td colspan="1" rowspan="1">06. Initial learning rate (Detail 2)</td><td colspan="1" rowspan="1">0.3,0.1, 0.03,0.01,0.003,0.001,0.0003,0r 0.0001？</td></tr><tr><td colspan="1" rowspan="1"> 07. Learning rate drop</td><td colspan="1" rowspan="1">Do we need to decrease learning rate as we train? Yes or No?</td></tr><tr><td colspan="1" rowspan="1">08. Learning rate first drop time</td><td colspan="1" rowspan="1">If drop learning rate, when is the first time to drop by 1/1O? Epoch 40or Epoch 60?</td></tr><tr><td colspan="1" rowspan="1">09. Learning rate second drop time</td><td colspan="1" rowspan="1">If drop learning rate, when is the second time to drop by 1/10o? Epoch80 or Epoch 100?</td></tr><tr><td colspan="1" rowspan="1">10. Use momentum (Sutskever et al.,2013)</td><td colspan="1" rowspan="1">Yes or No?</td></tr><tr><td colspan="1" rowspan="1">11.Momentum rate</td><td colspan="1" rowspan="1">If use momentum, rate is 0.9 or 0.99?</td></tr><tr><td colspan="1" rowspan="1">12. Initial residual link weight</td><td colspan="1" rowspan="1">What is the initial residual link weight? All constant 1 or a randomnumber in [0,1]?</td></tr><tr><td colspan="1" rowspan="1">13.Tune residual link weight</td><td colspan="1" rowspan="1">Do we want to use back propagation to tune the weight of residual links?Yes or No?</td></tr><tr><td colspan="1" rowspan="1">14.Tune time of residual link weight</td><td colspan="1" rowspan="1">When do we start to tune residual link weight? At the first epoch orepoch 10?</td></tr><tr><td colspan="1" rowspan="1">15. Resblock first activation</td><td colspan="1" rowspan="1">Do we want to add activation layer after the first convolution? Yes orNo？</td></tr><tr><td colspan="1" rowspan="1">16. Resblock second activation</td><td colspan="1" rowspan="1">Do we want to add activation layer after the second convolution? YesorNo?</td></tr><tr><td colspan="1" rowspan="1">17. Resblock third activation</td><td colspan="1" rowspan="1">Do we want to add activation layer after adding the residual link? Yesor No?</td></tr><tr><td colspan="1" rowspan="1">18.Convolution bias</td><td colspan="1" rowspan="1">Do we want to have bias term in convolutional layers? Yes or No?</td></tr><tr><td colspan="1" rowspan="1">19.Activation</td><td colspan="1" rowspan="1">What kind of activations do we use? ReLU or others?</td></tr><tr><td colspan="1" rowspan="1">20. Activation (Detail 1)</td><td colspan="1" rowspan="1">ReLU, ReLU, Sigmoid,or Tanh?</td></tr><tr><td colspan="1" rowspan="1">21. Use dropout (Srivastava et al., 2014)</td><td colspan="1" rowspan="1">Yes or No?</td></tr><tr><td colspan="1" rowspan="1">22. Dropout rate</td><td colspan="1" rowspan="1"> If use dropout, rate is high or low?</td></tr><tr><td colspan="1" rowspan="1">23. Dropout rate (Detail 1)</td><td colspan="1" rowspan="1">If use dropout, the rate is 0.3, 0.2, 0.1, or 0.05?</td></tr><tr><td colspan="1" rowspan="1">24.Batch norm (Ioffe &amp; Szegedy, 2015)</td><td colspan="1" rowspan="1">Do we use batch norm? Yes or No?</td></tr><tr><td colspan="1" rowspan="1">25. Batch norm tuning</td><td colspan="1" rowspan="1">If we use batch norm,do we tune the parameters in the batch normlayers? Yes or No?</td></tr><tr><td colspan="1" rowspan="1">26. Resnet shortcut type</td><td colspan="1" rowspan="1">What kind of resnet shortcut type do we use? Identity or others?</td></tr><tr><td colspan="1" rowspan="1">27. Resnet shortcut type (Detail 1)</td><td colspan="1" rowspan="1">Identity, Identity, Type B or Type C?</td></tr><tr><td colspan="1" rowspan="1">28.Weight decay</td><td colspan="1" rowspan="1">Do we use weight decay during the training? Yes or No?</td></tr><tr><td colspan="1" rowspan="1">29.Weight decay parameter</td><td colspan="1" rowspan="1">If use weight decay, what is the parameter? 1e - 3 or 1e - 4?</td></tr><tr><td colspan="1" rowspan="1">30.Batch Size</td><td colspan="1" rowspan="1">What is the batch size we should use? Big or Small?</td></tr><tr><td colspan="1" rowspan="1">31.Batch Size (Detail 1)</td><td colspan="1" rowspan="1">256,128,64,or 32？</td></tr><tr><td colspan="1" rowspan="1">32. Optnet</td><td colspan="1" rowspan="1"> An option specific to the codel2. Yes or No?</td></tr><tr><td colspan="1" rowspan="1">33.Share gradInput</td><td colspan="1" rowspan="1"> An option specific to the code. Yes or No?</td></tr><tr><td colspan="1" rowspan="1">34.Backend</td><td colspan="1" rowspan="1">What kind of backend shall we use? cudnn or cunn?</td></tr><tr><td colspan="1" rowspan="1">35.cudnn running state</td><td colspan="1" rowspan="1">If use cudnn, shall we use fastest of other states?</td></tr><tr><td colspan="1" rowspan="1"> 36. cudnn running state (Detail 1)</td><td colspan="1" rowspan="1">Fastest,Fastest, default, deterministic</td></tr><tr><td colspan="1" rowspan="1">37. nthreads</td><td colspan="1" rowspan="1">How many threads shall we use? Many or few?</td></tr><tr><td>38.nthreads (Detail 1)</td><td>8,4,2,or 1?</td></tr><tr><td>39-60.Dummy variables</td><td>Just dummy variables,no effect at all.</td></tr></table>
+
+See Table 1 for the specific hyperparameter options that we use in Section 5. For those variables with $k$ options $( k > 2 )$ , we use $\log k$ binary variables under the same name to represent them. For example, we have two variables (01, 02) and their binary representation to denote four kinds of possible initializations: Xavier Glorot (Glorot & Bengio, 2010), Kaiming (He et al., 2015), $1 / n$ , or $\mathbf { { \bar { 1 } } } / n ^ { 2 }$ .
+
+# C.2 IMPORTANCE FEATURES
+
+We show the selected important features and their weights during the first 3 stages in Table 2, where each feature is a monomial of variables with degree at most 3. We do not include the 4th stage because in that stage there are no features with nonzero weights.
+
+Smart choices on important options. Based on Table 2, Harmonica will fix the following variables (sorted according to their importance): Batch Norm (Yes), Activation (ReLU), Initial learning rate ([0.001, 0.1]), Optimization method (Adam), Use momentum (Yes), Resblock first activation (Yes), Resblcok third activation (No), Weight decay (No if initial learning rate is comparatively small and Yes otherwise), Batch norm tuning (Yes). Most of these choices match what people are doing in practice.
+
+A metric for the importance of variables. The features that Harmonica finds can serve as a metric for measuring the importance of different variables. For example, Batch Norm turns out to be the most significant variable, and ReLU is second important. By contrast, Dropout, when Batch Norm is presented, does not have significant contributions. This actually matches with the observations in (Ioffe & Szegedy, 2015).
+
+No dummy/irrelevant variables selected. Although there are 21/60 dummy variables, we never select any of them. Moreover, the irrelevant variables like cudnn, backend, nthreads, which do not affect the test error, were not selected.
+
+Table 2: Important features   
+
+<table><tr><td rowspan=1 colspan=1>Stage</td><td rowspan=1 colspan=1>Feature Name</td><td rowspan=1 colspan=1>Weights</td></tr><tr><td rowspan=1 colspan=1>1-1</td><td rowspan=1 colspan=1>24.Batch norm</td><td rowspan=1 colspan=1>8.05</td></tr><tr><td rowspan=1 colspan=1>1-2</td><td rowspan=1 colspan=1>19. Activation</td><td rowspan=1 colspan=1>3.47</td></tr><tr><td rowspan=1 colspan=1>1-3</td><td rowspan=1 colspan=1> 04. Initial learning rate * O5. Initial learning rate (Detail 1)</td><td rowspan=1 colspan=1>3.12</td></tr><tr><td rowspan=1 colspan=1>1-4</td><td rowspan=1 colspan=1>19. Activation * 24. Batch norm</td><td rowspan=1 colspan=1>-2.55</td></tr><tr><td rowspan=1 colspan=1>1-5</td><td rowspan=1 colspan=1>04. Initial learning rate</td><td rowspan=1 colspan=1>-2.34</td></tr><tr><td rowspan=1 colspan=1>1-6</td><td rowspan=1 colspan=1>28. Weight decay</td><td rowspan=1 colspan=1>-1.90</td></tr><tr><td rowspan=1 colspan=1>1-7</td><td rowspan=1 colspan=1>24. Batch norm * 28. Weight decay</td><td rowspan=1 colspan=1>1.79</td></tr><tr><td rowspan=1 colspan=1>1-8</td><td rowspan=1 colspan=1> 34. Optnet * 35. Share gradInput * 52. Dummy13</td><td rowspan=1 colspan=1>1.54</td></tr><tr><td rowspan=1 colspan=1>2-1</td><td rowspan=1 colspan=1>03.Optimization method</td><td rowspan=1 colspan=1>-4.22</td></tr><tr><td rowspan=1 colspan=1>2-2</td><td rowspan=1 colspan=1>03.Optimization method * 10. Use momentum</td><td rowspan=1 colspan=1>-3.02</td></tr><tr><td rowspan=1 colspan=1>2-3</td><td rowspan=1 colspan=1>15.Resblock first activation</td><td rowspan=1 colspan=1>2.80</td></tr><tr><td rowspan=1 colspan=1>2-4</td><td rowspan=1 colspan=1>10.Use momentum</td><td rowspan=1 colspan=1>2.19</td></tr><tr><td rowspan=1 colspan=1>2-5</td><td rowspan=1 colspan=1>15.Resblock first activation * 17. Resblock third activation</td><td rowspan=1 colspan=1>1.68</td></tr><tr><td rowspan=1 colspan=1>2-6</td><td rowspan=1 colspan=1>01.Good initialization</td><td rowspan=1 colspan=1>-1.26</td></tr><tr><td rowspan=1 colspan=1>2-7</td><td rowspan=1 colspan=1>01.Good initialization *10. Use momentum</td><td rowspan=1 colspan=1>-1.12</td></tr><tr><td rowspan=1 colspan=1>2-8</td><td rowspan=1 colspan=1>01.Good initialization * O3.Optimization method</td><td rowspan=1 colspan=1>0.67</td></tr><tr><td rowspan=1 colspan=1>3-1</td><td rowspan=1 colspan=1>29.Weight decayparameter</td><td rowspan=1 colspan=1>-0.49</td></tr><tr><td rowspan=1 colspan=1>3-2</td><td rowspan=1 colspan=1>28.Weight decay</td><td rowspan=1 colspan=1>-0.26</td></tr><tr><td rowspan=1 colspan=1>3-3</td><td rowspan=1 colspan=1>06. Initial learning rate (Detail 3) * 28. Weight decay</td><td rowspan=1 colspan=1>0.23</td></tr><tr><td rowspan=1 colspan=1>3-4</td><td rowspan=1 colspan=1>25. Batch norm tuning</td><td rowspan=1 colspan=1>0.21</td></tr><tr><td rowspan=1 colspan=1>3-5</td><td rowspan=1 colspan=1>28.Weight decay * 29. Weight decay parameter</td><td rowspan=1 colspan=1>0.20</td></tr></table>
+
+![](images/48480742a7e3047f910b83704d39f33d4d3f86debfcc321e9755db858d6028be.jpg)  
+Figure 4: Average test error drops.
+
+![](images/4ceac4a6b0b83a17cb4882f61038396f89c230f4cadd13e30482e53afbc844bf.jpg)  
+Figure 5: Optimization time comparison
+
+Table 3: Stable ranges for parameters in Lasso   
+
+<table><tr><td rowspan=1 colspan=1>Parameter</td><td rowspan=1 colspan=1>Stage 1</td><td rowspan=1 colspan=1>Stage 2</td><td rowspan=1 colspan=1>Stage 3</td></tr><tr><td rowspan=1 colspan=1>入</td><td rowspan=1 colspan=1>[0.01,4.5]</td><td rowspan=1 colspan=1>[0.1,2.5]</td><td rowspan=1 colspan=1>[0.5, 1.1]</td></tr><tr><td rowspan=1 colspan=1>#Samples</td><td rowspan=1 colspan=1>≥250</td><td rowspan=1 colspan=1>≥180</td><td rowspan=1 colspan=1>≥150</td></tr></table>
+
+# C.3 GENERALIZING FROM SMALL NETWORKS TO BIG NETWORKS
+
+In our experiments, Harmonica first runs on a small network to extract important features and then uses these features to do fine tuning on a big network. Since Harmonica finds significantly better solutions, it is natural to ask whether other algorithms can also exploit this strategy to improve performance.
+
+Unfortunately, it seems that all the other algorithms do not naturally support feature extraction from a small network. For Bayesian Optimization techniques, small networks and large networks have different optimization spaces. Therefore without some modification, Spearmint cannot use information from the small network to update the prior distribution for the large network.
+
+Random-search-based techniques are able to find configurations with low test error on the small network, which might be good candidates for the large network. However, based on our simulation, good configurations of hyperparameters from random search do not generalize from small networks to large networks. This is in contrast to important features in our (Fourier) space, which do seem to generalize.
+
+To test the latter observation using Cifar-10 dataset, we first spent 7 GPU days on 8 layer network to find top 10 configurations among 300 random selected configurations. Then we apply these 10 configurations, as well as 90 locally perturbed configurations (each of them is obtained by switching one random option from one top-10 configuration), so in total 100 “promising” configurations, to the large 56 layer network. This simulation takes 27 GPU days, but the best test error we obtained is only $1 1 . 1 \%$ , even worse than purely random search. Since Hyperband is essentially a fast version of Random Search, it also does not support feature extraction.
+
+Hence, being able to extract important features from small networks seems empirically to be a unique feature of Harmonica.
+
+# C.4 EXPERIMENTS WITH SYNTHETIC FUNCTIONS
+
+Our second experiment considers a synthetic hierarchically bounded function $h ( x )$ . We run Harmonica with 100 samples, 5 features selected per stage, for 3 stages, using degree 3 features. See Figure 5 for optimization time comparison. We only plot the optimization time for Spearmint when $n = 6 0$ , which takes more than one day for 500 samples. Harmonica is several magnitudes faster than Spearmint. In Figure 6, we show that Harmonica is able to estimate the hidden function with error proportional to the noise level.
+
+The synthetic function $h ( x ) \in \{ - 1 , + 1 \} ^ { n } \to \mathbb { R }$ is defined as follows. $h ( x )$ has three stages, and in $i$ -th stage $( i = 0 , 1 , 2 )$ , it has $3 2 ^ { i }$ sparse vectors $s _ { i , j }$ for $j = 0 , \cdots , 3 2 ^ { i } - 1$ . Each $s _ { i , j }$ contains 5 pairs of weight $w _ { i , j } ^ { k }$ and feature $f _ { i , j } ^ { k }$ for $k = 1 , \cdots 5$ , where $w _ { i , j } ^ { k } \in [ 1 0 + 1 0 ^ { - i } , 1 0 ^ { \top } + 1 0 ^ { 2 - i } ]$ . and $f _ { i , j } ^ { k }$ is a monomial on $x$ with degree at most 3. Therefore, for input $x \in \mathbb { R } ^ { n }$ , the sparse vector $\begin{array} { r } { s _ { i , j } ( x ) = \sum _ { k = 1 } ^ { 5 } w _ { i , j } ^ { k } f _ { i , j } ^ { k } ( x ) } \end{array}$ . Since $x \in \{ - 1 , + 1 \} ^ { n }$ , $f _ { i , j } ^ { k } ( x )$ is binary. Therefore, $\{ f _ { i , j } ^ { k } ( x ) \} _ { k = 1 } ^ { 5 }$ contains 5 binaries and represents a integer in $\left[ 0 , 3 1 \right]$ , denoted as $c _ { i , j } ( \boldsymbol { x } )$ . Let $h ( x ) = s _ { 1 , 1 } ( x ) +$ $s _ { 2 , c _ { 1 , 1 } ( x ) } ( x ) + s _ { 3 , c _ { 1 , 1 } ( x ) * 3 2 + c _ { 2 , c _ { 1 , 1 } ( x ) } ( x ) } ( x ) + \xi$ , where $\xi$ is the noise uniformly sampled from $[ - A , A ]$ ( $\boldsymbol { \cdot } \boldsymbol { A }$ is the noise level). In other words, in every stage $i$ we will get a sparse vector $s _ { i , j }$ . Based on $s _ { i , j } ( x )$ , we pick a the next sparse function and proceed to the next stage.
+
+![](images/254dee2622dc7cda4ac87acbbbbba38a06c9d97217697a782fcc87d4a610c65d.jpg)  
+Figure 6: The estimation error of Harmonica is linear in noise level.

parse/train/_WnGcwXLYOE/_WnGcwXLYOE.md

@@ -0,0 +1,255 @@
+# FLEX: Unifying Evaluation for Few-Shot NLP
+
+Jonathan Bragg∗ Arman Cohan∗ Kyle Lo Iz Beltagy
+
+Allen Institute for AI, Seattle, WA {jbragg,armanc,kylel,beltagy}@allenai.org
+
+# Abstract
+
+Few-shot NLP research is highly active, yet conducted in disjoint research threads with evaluation suites that lack challenging-yet-realistic testing setups and fail to employ careful experimental design. Consequently, the community does not know which techniques perform best or even if they outperform simple baselines. In response, we formulate the FLEX Principles, a set of requirements and best practices for unified, rigorous, valid, and cost-sensitive few-shot NLP evaluation. These principles include Sample Size Design, a novel approach to benchmark design that optimizes statistical accuracy and precision while keeping evaluation costs manageable. Following the principles, we release the FLEX benchmark,2 which includes four few-shot transfer settings, zero-shot evaluation, and a public leaderboard that covers diverse NLP tasks. In addition, we present UniFew,3 a prompt-based model for few-shot learning that unifies pretraining and finetuning prompt formats, eschewing complex machinery of recent prompt-based approaches in adapting downstream task formats to language model pretraining objectives. We demonstrate that despite simplicity, UniFew achieves results competitive with both popular meta-learning and prompt-based approaches.
+
+# 1 Introduction
+
+Few-shot learning, the challenge of learning from a small number of examples, is critical for developing efficient, robust NLP techniques [71, 76]. In recent years, separate threads of few-shot NLP research have pursued goals like generalization to new classes [e.g., 5, 25], adaptation to new domains and tasks [e.g., 3, 4, 21], and direct application of pretrained language models (LMs) [e.g., 10, 24, 55, 56]. Unfortunately, despite the shared goal of advancing few-shot NLP techniques, the community does not know which techniques work best or even if they perform better than simple baselines. Evaluation suites across these research threads are disjoint, lack challenging-yet-realistic testing setups (e.g., class imbalance, variable training set sizes, etc.), and do not employ careful experimental design to ensure accurate and precise evaluation estimates and minimal computational burden. Prior work in few-shot learning outside of NLP serves as a stark warning of the consequences of improper measurement: Dhillon et al. [19] showed that techniques from several years of prior work did not make clear progress due to large overlapping accuracy distributions and, moreover, do not outperform a simple, carefully-tuned baseline.
+
+Need for systematic benchmark design As such, a high-quality benchmark is urgently needed to enable rigorous comparison of techniques across disjoint, highly-active threads of few-shot NLP research. But what should such an evaluation suite look like? Some best practices for evaluation of few-shot methods have been introduced in the computer vision (CV) literature [19, 67] and should be applied to NLP. However, unifying few-shot NLP work introduces new challenges. For example, the benchmark needs to test all types of transfer studied in separate research threads to measure progress on new techniques that make gains in each of these important generalization settings (§2). Also, given the importance of zero-shot learning and learning from task descriptions [29, 73], the benchmark needs to include zero-shot episodes and textual labels to enable measuring progress for models that do not use conventional supervised training, including methods that leverage the latent knowledge in pretrained LMs [10, 24, 78]. Further, the benchmark must accommodate new, computationally-expensive approaches, without overly reducing the number of evaluation episodes at the expense of statistical accuracy [3, 24, 75].
+
+Table 1: Comparison of the FLEX benchmark with closest prior work. Our benchmark consists of episodes with variable number of shots in the range [1-5] and with class imbalance. “No extra test data” refers to excluding validation data from testing tasks, to avoid unfairly advantaging models that use such data [50]. Our benchmark’s number of test episodes is selected to balance statistical accuracy and precision, which suffers in few-episode setups, and compute requirements, which is too costly in many-episode setups (§5).   
+
+<table><tr><td></td><td></td><td></td><td></td><td></td><td></td><td>CrosSFit[75]LM-BFF[24] GPT-3[10]DS[5]SMLMT[4] FewGlue[56]FLEX(ours)</td><td></td></tr><tr><td>Class Transfer</td><td></td><td></td><td></td><td>√</td><td></td><td></td><td></td></tr><tr><td>Domain Transfer</td><td></td><td></td><td></td><td></td><td>√</td><td></td><td></td></tr><tr><td>Task Transfer</td><td></td><td></td><td></td><td></td><td></td><td></td><td></td></tr><tr><td>Pretraining Transfer</td><td></td><td>√</td><td>&lt;</td><td></td><td></td><td>√</td><td>&gt;&gt;&gt;&gt;</td></tr><tr><td>Shots per class</td><td>{16,32}</td><td>16</td><td>variable</td><td>{1,5}</td><td>{4,8,16,32}</td><td>{total 32}4</td><td>[1-5]</td></tr><tr><td>Variable shots</td><td></td><td>1</td><td>√</td><td></td><td></td><td></td><td></td></tr><tr><td>Unbalanced</td><td></td><td></td><td></td><td></td><td></td><td></td><td></td></tr><tr><td>Textual labels</td><td></td><td>√</td><td></td><td></td><td></td><td>√</td><td></td></tr><tr><td>Zero-shot</td><td></td><td>√</td><td>√</td><td></td><td></td><td>-</td><td></td></tr><tr><td>No extra test data</td><td></td><td></td><td></td><td>√</td><td>√</td><td>mixed5</td><td>&gt;&gt;&gt;&gt;&gt;0</td></tr><tr><td># test episodes</td><td>5</td><td>5</td><td>1</td><td>1000</td><td>10</td><td>1</td><td></td></tr><tr><td>Reporting</td><td>avg</td><td>avg,SD</td><td>ag</td><td>avg, SD</td><td>avg,SD</td><td>avg, SD</td><td>al16</td></tr><tr><td>#datasets</td><td>160</td><td>16</td><td></td><td>7</td><td>18</td><td>8</td><td>20</td></tr></table>
+
+Need for a robust few-shot model Recent prompt-based models [10] have shown strong results in few-shot learning. These models leverage the power of (often large) pretrained language models and adapt the format of downstream tasks to the underlying pretraining objective (e.g., Masked Language Modeling). This way, given the right natural language prompt (and sometimes verbalizers [55] and additional demonstrative examples), the model can quickly fine-tune on the downstream task [24, 43, 44, 55, 56]. However, adapting task formats to the underlying (masked) language modeling objectives is not straightforward; such models have been shown to be sensitive to varying choices of the prompt/demonstrations, training settings, hyperparameters, and learning algorithms [33, 50, 78], often requiring large held out sets and/or complex methods to overcomes such challenges. Can models eschew complex prompt engineering by unifying pretraining and downstream task formats?
+
+In this paper, we tackle these key issues by introducing FLEX—Few-shot Language Evaluation across $\mathbf { \delta } ( \mathbf { X } )$ many transfer types—and contributing the following:
+
+• FLEX Principles (§3), a set of requirements and best practices for few-shot NLP evaluation that enables unified, rigorous, valid, and cost-sensitive measurements. – Sample Size Design: In support of valid, cost-sensitive measurement, we introduce a novel approach to few-shot sample size design (§5) that optimizes for a benchmark’s statistical accuracy and precision while keeping computational costs accessible to a broad range of researchers.   
+• FLEX benchmark (§4), an implementation of the FLEX Principles. It tests across four few-shot transfer settings,7 and includes a public leaderboard for few-shot NLP that covers 20 datasets across diverse NLP tasks (e.g., NLI, relation classification, entity typing). Table 1 summarizes key differences between FLEX and other few-shot NLP evaluation suites.
+
+• UniFew (§6), a prompt-based model for few-shot learning in NLP. While most existing methods leverage pre-trained LMs for few-shot learning, LM pre-training tasks do not closely match natural downstream task formats, requiring complex methods (e.g., extensive prompt-engineering, use of verbalizers, episodic hyperparameter tuning, custom learning algorithms) to make these models work in few-shot setting. Instead, the key idea of our model, UniFew, is to close the gap between pre-training and fine-tuning formats by posing tasks as multiple-choice QA and using an underlying model that is pre-trained on a similar natural QA task format. This eliminates the need for complexities of adapting downstream tasks to the LM objectives, while resulting in competitive performance with both recent few-shot and meta-learning methods.
+
+To aid similar efforts, our release of FLEX includes a toolkit for benchmark creation and few-shot NLP model development, which we used to create the FLEX benchmark and train UniFew.
+
+# 2 Background and Related Work
+
+We first provide background and notation for few-shot learning and evaluation, then discuss related work in NLP and outside NLP that motivated us to create the FLEX Principles and benchmark.
+
+Few-shot background and notation Broadly, modern approaches to few-shot learning are evaluated in a three-phase procedure [68]. In the first phase, a general-purpose pretrained model is obtained. In the subsequent “meta-training” phase,8 techniques aim to adapt the model to be well-suited for few-shot generalization. Finally, a “meta-testing” phase evaluates the adapted model in new few-shot prediction settings.
+
+Let $\mathcal { D }$ be a dataset of $( x , y )$ examples with full label set $\mathcal { V } _ { D }$ . From it, we construct three sets of episodes, corresponding to meta-training, meta-validation, and meta-testing and denoted by ${ \mathcal { E } } _ { \operatorname* { t r a i n } }$ ${ \mathcal E } _ { \mathrm { v a l } }$ , and ${ \mathcal { E } } _ { \mathrm { t e s t } }$ , respectively. Each episode in each of these sets is a few-shot problem with its own test set and other attributes. Forsampled subset of labels in ly, e and $E$ is a tuplee disjoint $( \mathcal { D } _ { \mathrm { t r a i n } } ^ { E } , \mathcal { D } _ { \mathrm { v a l } } ^ { E } , \dot { \mathcal { D } } _ { \mathrm { t e s t } } ^ { E } , \mathcal { y } _ { \mathcal { D } } ^ { E } )$ wherewith l $y _ { \mathcal { D } } ^ { E }$ is a  ls in $\mathcal { V } _ { D }$ $\mathcal { D } _ { \mathrm { t r a i n | v a l | t e s t } } ^ { E }$ $\mathcal { D }$ $y _ { \mathcal { D } } ^ { E }$ . 9 For each episode, the model’s objective is to correctly predict labels for examples $\mathcal { D } _ { \mathrm { t e s t } } ^ { E }$ . To accomplish this, models make use of labeled examples in $\mathcal { D } _ { \mathrm { t r a i n } } ^ { E }$ , which is typically configured such that each label $i$ in $y _ { \mathcal { D } } ^ { E }$ has $K _ { i } ^ { E }$ provided examples; $K _ { i } ^ { E }$ is known as the shot, and the setting when a class has no examples in $\mathcal { D } _ { \mathrm { t r a i n } } ^ { E }$ (i.e., $K _ { i } ^ { E } = 0$ ) is called zero-shot.
+
+Few-shot evaluation in NLP Research in few-shot NLP has proceeded in several parallel threads, each focused on a different type of transfer ability [76]. Each thread has separate evaluation practices, and the vast majority of few-shot NLP research has limited evaluation to a single transfer type (see Table 1). Here, we describe these types of transfer and their evaluation practices.
+
+Following the CV literature [67, 68], one thread of few-shot NLP focuses on class transfer, the problem of generalizing from a supervised set of classes at meta-train time to a differenfrom the same dataset at meta-test time. Evaluation typically involves splitting classes $\mathcal { V } _ { D }$ of c into $\mathcal { V } _ { \mathrm { t r a i n } } ^ { \mathcal { D } }$ $y _ { \mathrm { v a l } } ^ { \mathcal { D } }$ and $\mathcal { V } _ { \mathrm { t e s t } } ^ { \mathcal { D } }$ disjoint subsets. Class transfer has been studied on many text classification tasks [5], including relation classification [25, 28, 64], intent classification [37, 64], inter alia. In contrast, domain transfer keeps the same classes between meta-training and meta-testing but changes the textual domain (e.g., generalizing from MNLI to science-focused SciTail [4, 21]). Evaluation then requires identifying pairs of datasets with the same classes $\mathcal { \ V } _ { D }$ , where one dataset’s episodes are assigned to ${ \mathcal { E } } _ { \operatorname* { t r a i n } }$ and the other’s to ${ \mathcal { E } } _ { \mathrm { t e s t } }$ . Domain transfer has also been studied on many tasks [3, 4], including dialogue intent detection & slot tagging [31], sentiment classification [77], NLI [21], and machine translation [27, 58].
+
+Researchers have also begun to study task transfer, the problem of generalizing from a set of tasks at meta-train time to unseen tasks at meta-test time. Evaluation requires tasks (e.g., NLI) appearing in ${ \mathcal { E } } _ { \mathrm { t e s t } }$ not to appear in ${ \mathcal { E } } _ { \mathrm { t r a i n } }$ or ${ \mathcal E } _ { \mathrm { v a l } }$ . Prior work has used GLUE tasks [70] for meta-training before meta-testing on tasks such as entity typing [3, 4], while other work instead used GLUE for meta-testing [21]. Very recent work has studied task transfer over a large set of datasets [75, 80]. A limited amount of work evaluates both domain and task transfer [3, 4, 21]. An important emerging line of work (not noted by Yin [76]) is pretraining transfer, the problem of whether pretrained language models can perform well at meta-test time without any meta-training. Evaluation in this setting requires ${ \mathcal { E } } _ { \mathrm { t r a i n } }$ , $\bar { \mathcal { E } } _ { \mathrm { v a l } } = \emptyset$ . Prior work has shown that pretrained language models are capable of surprising performance on many few-shot tasks, even without fine-tuning [10]. More recent work, mainly focusing on text classification, has reported further gains with cloze-style formats [55, 56, 65], prompt engineering [24], or calibration [78]. FLEX is designed to exercise all four of these transfer types from previous work.
+
+Few-shot evaluation outside NLP The few-shot learning literature has largely focused on image classification, with the introduction of increasingly complex meta-learning algorithms [e.g., 23, 39, 54, 61, 68]. However, more recent work has shown that simple fine-tuning baselines are in fact competitive, and attribute this delayed discovery to problematic evaluation methodology [15, 19]. FLEX adopts recommended methodology [19, 67], and we introduce an analogous baseline (UniFew) to provide a strong measurement foundation for few-shot NLP.
+
+# 3 FLEX Principles for Few-Shot NLP Evaluation
+
+We now enumerate key desiderata for a few-shot NLP benchmark capable of solving the urgent problems with few-shot NLP evaluation, including separate evaluations for each transfer type and failure to incorporate best measurement practices from other domains (§2).
+
+Diversity of transfer types To make NLP models broadly useful, few-shot NLP techniques must be capable of class, domain, and task transfer. Moreover, techniques should make use of the relevant supervision provided during meta-training to increase performance compared to the pretraining transfer setting. The benchmark should measure all four transfer settings to ensure that the community develops techniques that improve on strong pretraining transfer baselines, and enable comparison across these currently separate threads of research.
+
+Variable number of shots and classes To better simulate a variety of real-world scenarios, the benchmark should include a variety of training set sizes and numbers of classes [67]. Testing robustness to these factors is crucial; few-shot techniques are often sensitive to changes in these factors [12], yet all prior few-shot NLP evaluations we are aware of used a fixed number of training shots and classes, known in advance during meta-training.
+
+Unbalanced training sets The benchmark should also include unbalanced training sets with different training shots per class, another realistic setting adopted by CV benchmarks [67]. Class imbalance has also been observed to degrade performance [11, 47], yet prior few-shot NLP evaluations do not include this setting either.
+
+Textual labels While numerical label values are often used in classification tasks, descriptive textual labels are also present for many tasks. Making these textual labels available for use by few-shot techniques enables the development of techniques that can leverage the class name, like in-context learning [10], template generation [24], and meta-learning [45]. Textual labels are crucial in particular for zero-shot evaluation.
+
+Zero-shot evaluation We believe zero-shot evaluation is integral to the goals of few-shot evaluation. Similar to the motivation for measuring pretraining transfer, zero-shot evaluation is an important use case and also provides a strong baseline for some tasks. In the absence of training examples, textual class labels or richer task descriptions [73] must be provided. Some recent few-shot NLP work [e.g., 10, 24] evaluated with zero training shots, but most [e.g., 3, 5, 75] did not.
+
+No extra meta-testing data We believe the benchmark should not provide validation data $\langle \mathcal { D } _ { \mathrm { v a l } } ^ { E } =$ $\emptyset , \forall E \in { \mathcal { E } } _ { \mathrm { t e s t } } )$ or unlabeled data for meta-testing tasks, since few-shot learning seeks to enable high performance in environments where collecting additional data is costly.10 Variation in these dimensions in prior NLP work makes comparison of results extremely difficult because it is often under-reported and gives unfair advantage to approaches that leverage such data [50]. For example, per-episode hyperparameter tuning on extra data has been shown to greatly inflate evaluation scores [24]. A few researchers [5, 65] follow our suggested approach, but others have used many different settings, from validation sets of various sizes [10, 24, 79] to no validation set but a large set of unlabeled examples [55, 56].
+
+Principled sample size design Promising few-shot techniques can incur significant computational cost per episode, e.g., due to fine-tuning model parameters [4], searching for prompts [24], inter alia. To alleviate these costs, related works often evaluate with a limited number of episodes, which precludes statistically accurate or precise performance estimates. We believe the benchmark’s test sample size should be optimized to enable proper performance evaluation for such techniques, while ensuring the computational burden is inclusive toward researchers without large compute resources.
+
+Proper reporting of CIs, SDs, and individual results The benchmark should report confidence intervals (CIs) of performance estimates and follow recent guidelines [19] to report standard deviations (SDs) for understanding variability. Moreover, we newly advocate for controlling for the same sampled few-shot episodes across all methods and reporting individual episode results, so that researchers can run higher-powered paired statistical tests when comparing results [22], crucial when the benchmark has been optimized for low evaluation budgets.
+
+# 4 FLEX Benchmark
+
+The FLEX benchmark is a unifying, rigorous evaluation suite for few-shot learning in NLP, which implements the desiderata outlined in the previous section. In this section, we describe detailed design decisions and our accompanying few-shot NLP toolkit (§4.4), which we are releasing to facilitate easily adding NLP datasets and advanced sampling options to future benchmarks. We also describe the FLEX leaderboard (§4.5).
+
+# 4.1 Task and Dataset Selection
+
+Following GLUE [70] and other prior work [3, 5, 24, 78], we focus on tasks formatted as classification. Despite recent advances, NLP state-of-the-art models remain significantly worse than human performance on many text classification tasks, particularly in the few-shot setting. Automatic scoring of classification tasks is also more reliable than text generation tasks.
+
+We selected datasets across three recent few-shot NLP evaluation suites, which separately studied class transfer [5], domain and task transfer [3, 4], and pretraining transfer [24]. Our benchmark includes a broad mix of tasks (NLI, question classification, entity typing, relation classification, and sentiment analysis) and formats (document, sentence, sentence pair). More complete dataset and license details are available in the following subsection and Appendix A.
+
+# 4.2 Meta-Evaluation Protocols
+
+As discussed earlier, FLEX evaluates four different types of transfer: Class, Domain, Task, and Pretraining Transfer. To support all types, we report results to the FLEX benchmark both without metatraining (pretraining-only) and with meta-training. This reporting scheme evaluates the performance of the basic pretrained model and the benefit (or lack thereof) of meta-training. A similar reporting scheme was proposed by Triantafillou et al. [67] for CV.
+
+Pretraining-Only In this setting, the pretrained model is directly meta-tested on our benchmark without any additional training. This is the Pretraining Transfer setting, and it is the most difficult, but given the recent success of pretrained models in NLP for few-shot learning [10, 24], we believe that comparison to models without any meta-training is important for NLP tasks.
+
+Meta-Trained In this setting, the model is meta-trained then meta-tested on our benchmark. We carefully selected and split datasets across meta-train/validation/test in order to enable testing of Class, Domain, and Task transfer with a single meta-training phase (to reduce computational burden). Datasets involved in each transfer setting (detailed split information in Table 4 in Appendix A):
+
+• Class Transfer: FewRel [28], HuffPost [46], Amazon [30], 20News [38], and Reuters [41] take part in meta-training and meta-testing but with different classes. • Domain Transfer: MR [49], CR [32], SNLI [9], and SciTail [35] are only in the meta-testing phase, but the corresponding sentiment and NLI datasets exist in the meta-training phase (MNLI [74], QNLI [52], and SST-2 [62]).
+
+• Task Transfer: Subj [48], TREC [69], and CoNLL [66] are also for meta-testing only, and they represent tasks that the model does not encounter during meta-training.
+
+Instead of per-episode hyperparameter tuning, we provide meta-validation episodes ${ \mathcal E } _ { \mathrm { v a l } }$ for learning (during meta-training) global hyperparameters that work across all episodes. Specifically, the metavalidation dataset splits (see Table 4) consist of CoLa [72] for task transfer, WNLI [40] for domain transfer, and the validation splits used by Bao et al. [5] for all class transfer datasets. Following [3], we also include meta-training datasets MRPC [20], RTE [6, 8, 17, 26], and QQP [70].
+
+# 4.3 Episode Sampling
+
+We describe how our benchmark samples meta-testing episodes ${ \mathcal { E } } _ { \mathrm { t e s t } }$ . For meta-training, we allow users to sample from ${ \mathcal { E } } _ { \operatorname* { t r a i n } }$ , ${ \mathcal E } _ { \mathrm { v a l } }$ in any way, or directly use the underlying dataset splits.
+
+Number of classes For Class Transfer datasets, FLEX evaluates model robustness to variable number of new classes. When constructing episode $E$ from one of these datasets $\mathcal { D }$ , our benchmark samples an episode-specific number of classes from dataset $D$ , the sampler picks a random number from the range $\mathcal { V } _ { D } ^ { E } \sim \mathrm { \bar { U n i f } } ( 5 , \operatorname* { m i n } ( | \mathcal { V } _ { D } | , 1 0 ) )$ . 11  For Domain and Task Transfer, the number of classes is fixed to the maximum number of classes in each dataset because Class Transfer is not being evaluated.
+
+Number of shots Following prior work outside NLP [47, 67], our benchmark samples the training shot independently for each episode $E$ and class $i$ , as $K _ { i } ^ { E } \sim \mathrm { U n i f } ( K _ { \operatorname* { m i n } } , K _ { \operatorname* { m a x } } )$ , where $K _ { \operatorname* { m i n } } = 1$ Given strong performance of NLP models with few or even zero examples [10, 73] and following prior work [5], we set the limit $K _ { \operatorname* { m a x } } = 5$ . Separately, we allocate an equal number of episodes as zero-shot, where we instead set $\mathcal { D } _ { \mathrm { t r a i n } } ^ { E } = \varnothing$ (equivalently, $K _ { i } ^ { E } = 0 , \forall i )$ . In each episode, examples are sampled uniformly at random without replacement (but can be reused across episodes).12 Following Triantafillou et al. [67], we select a testing shot that is balanced across classes and leaves roughly half of examples for sampling the training examples. The total number of episodes for each reported configuration (pair of dataset and either zero- or few-shot) is set to 90 using Sample Size Design (§5).
+
+# 4.4 Extensible Toolkit for Benchmark Creation and Model Training & Evaluation
+
+Alongside the FLEX benchmark, we release an extensible, highly-configurable Python toolkit, which we used to generate the benchmark, and train and evaluate our models. Unlike existing meta-learning frameworks (e.g., Torchmeta [18], learn2learn [2]), our framework makes available a wide range of community-contributed NLP datasets and utilities via HuggingFace Datasets [42].13 Our code also provides advanced sampling utilities (e.g., for class imbalance), ensures reproducibility by checksumming generated episodes, and reports all recommended statistics.
+
+# 4.5 Public Leaderboard
+
+We provide public leaderboards for each of the meta-evaluation protocols: Pretraining-Only14 and Meta-Trained.15 Submissions take the form of a text label predictions file, which is produced by our toolkit. Results are reported with confidence intervals, standard deviations, and individual predictions on request. See Appendix G for a screenshot of the results interface.
+
+# 5 Sample Size Design: Balancing Statistical Measurement & Compute Cost
+
+We demonstrate a principled approach to determining the optimal sample size configuration in our few-shot benchmark. A proper benchmark should produce performance estimates that are accurate, close to the true value, and precise, low variance. A large (test) sample size can achieve this, yet must be considered alongside computational cost so that a broad community of researchers with differing amounts of compute resources can participate. This decision is further complicated in the few-shot setting, where sample size refers to both the number of test episodes $| \mathcal { E } _ { \mathrm { t e s t } } |$ and the number of test examples $| \mathcal { D } _ { \mathrm { t e s t } } ^ { E } |$ per episode $E \in \mathcal { E } _ { \mathrm { t e s t } }$ . For practicality, we consider $\overline { { | \mathcal { D } _ { \mathrm { t e s t } } | } }$ , the mean $| \mathcal { D } _ { \mathrm { t e s t } } ^ { E } |$ across all episodes, rather than every $| \mathcal { D } _ { \mathrm { t e s t } } ^ { E } |$ . It remains unknown how one should best distribute test examples between $| \mathcal { E } _ { \mathrm { t e s t } } |$ and $\overline { { | \mathcal { D } _ { \mathrm { t e s t } } | } }$ : More episodes each with fewer examples, or fewer episodes each with many examples? Prior work has been inconsistent in this regard. For example, Gao et al. [24] used $| \mathcal { E } _ { \mathrm { t e s t } } | = 5$ and large $\overline { { | \mathcal { D } _ { \mathrm { t e s t } } | } }$ , while Bao et al. [5] used $| \mathcal { E } _ { \mathrm { t e s t } } | = 1 0 0 0$ and much smaller $\overline { { | \mathcal { D } _ { \mathrm { t e s t } } | } }$ .
+
+![](images/20b72aa04b5ecaf7008d376f1db2ef72f6b0892ea549c2a8081f72b78f0af4b9.jpg)  
+Figure 1: Results of simulation study described in $\ S 5$ . Each curve corresponds to a compute budget constraint $C$ (GPU-hours). Each point on a curve is an allocation of test data between the number of test episodes $| \mathcal { E } _ { \mathrm { t e s t } } |$ or mean number of examples per episode $\overline { { | \mathcal { D } _ { \mathrm { t e s t } } | } }$ such that evaluation can be completed within given budget. Per curve, lower values of $| \mathcal { E } _ { \mathrm { t e s t } } |$ correspond linearly to larger values of $\overline { { | \mathcal { D } _ { \mathrm { t e s t } } | } }$ , which are shown as numerical text annotations in (b). Error bars represent the $1 0 ^ { t h }$ and $9 0 ^ { t h }$ percentile values from repeated simulations across $\mu _ { a c c } \in \{ 0 . 3 , 0 . 3 5 , \ldots , 0 . 9 5 \}$ .
+
+Inspired by simulation techniques for informing statistically-powered experimental design [13], we study how different configurations of $| \mathcal { E } _ { \mathrm { t e s t } } |$ and $\overline { { | \mathcal { D } _ { \mathrm { t e s t } } | } }$ across different compute budgets $C$ impact the accuracy and precision of our estimated CIs, specifically with respect to coverage probability [53] and width. First, we estimate per-episode and per-test-example costs of our few-shot model (§6) to obtain valid $( C , \vert \mathcal { E } _ { \mathrm { t e s t } } \vert , \vert \overline { { \mathcal { D } _ { \mathrm { t e s t } } } } \vert )$ configurations s.t. the full benchmark completes within given $C$ (GPU-hours).16 Then, for each $( C , \vert \mathcal { E } _ { \mathrm { t e s t } } \vert , \vert \overline { { \mathcal { D } _ { \mathrm { t e s t } } } } \vert )$ , we perform 1000 simulation runs, in which each run samples predictions under a true model accuracy $\mu _ { a c c }$ and computes a single $9 5 \%$ CI, its width, and whether it correctly covers $\mu _ { a c c }$ . Averaging over simulation runs gives us estimates for the coverage probability and width of our benchmark’s CI for a single $( C , \vert \mathcal { E } _ { \mathrm { t e s t } } \vert , \vert \overline { { \mathcal { D } _ { \mathrm { t e s t } } } } \vert )$ . We repeat this whole procedure for different $\mu _ { a c c } \in \{ 0 . 3 , 0 . 3 5 , \ldots , 0 . 9 5 \}$ to cover a wide range of possible model performances observed across many datasets (see Table 3).
+
+Figure 1 shows CI coverage probability and width for many $( C , \vert \mathcal { E } _ { \mathrm { t e s t } } \vert , \overline { { \vert D _ { \mathrm { t e s t } } \vert } } )$ configurations. First, we find in Figure 1a that sufficiently-many test episodes (i.e., $\vert \mathcal { E } _ { \mathrm { t e s t } } \vert > 6 0 )$ is needed to guarantee coverage probability of our CIs is within one percentage point of the target $9 5 \%$ , a trend that holds regardless of compute budget. Small $| \mathcal { E } _ { \mathrm { t e s t } } |$ also corresponds to large CI widths across all considered budgets in Figure 1b. This suggests that the choices of $| \mathcal { E } _ { \mathrm { t e s t } } | = 1 , 5 , 1 0$ in prior work [4, 24, 56, 75] can mean inaccurate and wide CIs, while choices of $| \mathcal { E } _ { \mathrm { t e s t } } | = 1 0 0 0$ [5] can be prohibitively costly for methods with high training cost.
+
+Next, Figure 1b reveals (i) diminishing returns in $\mathrm { C I }$ width (decrease in $y$ -axis) as compute increases, and (ii) existence of an optimal balance between $| \mathcal { E } _ { \mathrm { t e s t } } |$ and $\overline { { | \mathcal { D } _ { \mathrm { t e s t } } | } }$ for each budget. Restricting our consideration to budgets with optima satisfying sufficient coverage probability $\lvert \mathcal { E } _ { \mathrm { t e s t } } \rvert > 6 0 )$ , the minimum viable budget is 36 GPU-hours. Then, assessing the marginal benefit of each 12 GPU-hour budget increase in terms of marginal reduction in CI width between optima, we arrive at our FLEX configuration of $| \mathcal { E } _ { \mathrm { t e s t } } | = 9 0$ and $\overline { { | \mathscr { D } _ { \mathrm { t e s t } } | } } \approx 4 7 0$ under a budget of $C = 4 8$ GPU-hours.17 Further details are in Appendix B.
+
+# 6 UniFew: A Few-Shot Learning Model by Unifying Pre-training and Downstream Task Formats
+
+Despite their encouraging results, existing works on few-shot learning in NLP are based on either customized and often complex meta-learning algorithms [3, 4, 5, 60], heavy manual/automated engineering of textual descriptions or prompts [24, 55, 59, 78], ordering of training examples [44, 56], extensive hyperparameter tuning on held-out sets [24, 44, 55], or custom learning algorithms [55, 65]. We present UniFew, a strong few-shot learning model across all transfer settings and datasets tested, that eschews the need for incorporating the above-mentioned complexities and challenges.
+
+UniFew is a prompt-based model [56], a class of models that tailor the input/output format of their data to match the format used during pretraining. While this technique allows them to perform a task without the need for additional classification layers, prompt-based models are typically sensitive to the choice of the prompts, which can require extensive search, trial-and-error, and even additional models to get right [24, 78]. To avoid this issue while still leveraging the strong capabilities of pretrained models, UniFew (1) converts examples into multiple-choice question-answer (QA) format, and (2) uses UnifiedQA [34], a T5 [51] model further pretrained on a large collection of QA pairs.18,19
+
+Compared to other prompt-based models, UniFew has two main strengths. First, the prompt design problem is much simpler because UnifiedQA questions had well-defined formats. For example, we only need four general prompt templates which cover all 20 datasets in the FLEX benchmark, while prior works have needed specialized prompts for each dataset. Second, UnifiedQA’s multiple-choice format ensures the model outputs a valid class label, without the need for learned or manually-defined mappings or verbalizers required for other prompt-based methods [24, 55].20 In concurrent work, Zhong et al. [80] also show the benefit of performing meta-tuning on a variety of datasets; while their task setup as Q/A is similar to UniFew, they focus exclusively on binary zero-shot classification tasks and, unlike UniFew, do not handle multi-class or few-shot problems.
+
+We experiment with UniFew both without and with meta-training on the FLEX benchmark’s metatraining data, following the FLEX protocol (§4.2). We call the meta-trained variant $\mathrm { U n i F e w } _ { \mathrm { m e t a } }$ . We use simple prompts in the format of question followed by choices followed by the answer (according to the UnifiedQA original format). The exact prompts used are provided in Appendix C.
+
+Training details For meta-training and meta-validation of UniFew, we sampled ${ \mathcal { E } } _ { \operatorname* { t r a i n } }$ and ${ \mathcal E } _ { \mathrm { v a l } }$ with 5-class, 5-training-shot sampling with the same number of shots per class.21 We trained the model for total number of 30K steps, using a linear learning rate scheduler with peak rate of $3 e { - 5 }$ , 200 warmup steps, and batch size of 4; we selected the best checkpoint based on ${ \mathcal E } _ { \mathrm { v a l } }$ performance. At meta-test time, for each episode, we trained the model on the episode’s training examples (if they exist) and predicted the outputs on test examples. For training at meta-test time, we used constant learning rate of $3 e { \mathrm { - } } 5$ and batch size of 4, and trained the model for 400 steps.22 We used NVidia RTX8000 GPUs, which take about 7 GPU-hours for meta-training and 48 GPU-hours for meta-testing. For meta-testing we split the episodes among 8 GPUs to speed up evaluations.
+
+# 7 Experiments
+
+Comparing UniFew with prior work To demonstrate the efficacy of UniFew, we evaluate it against state-of-the-art approaches for few-shot and meta-learning in NLP: LM-BFF [24], a language
+
+(a) H-SMLMT (Bansal et al. [4])
+
+Table 2: Comparing UniFew with prior methods on their respective test suites, reporting mean accuracy (and standard deviation). For each test suite, for each result set on same number of shots, we indicate with $\vartriangleright$ when results are directly comparable: (i) either both use meta-training (H-SMLMT & DS with $\mathrm { U n i F e w } _ { \mathrm { m e t a } } )$ or neither do (LM-BFF with UniFew). We bold the better of the two.   
+(b) LM-BFF (Gao et al. [24])   
+
+<table><tr><td>Model</td><td></td><td>Shots</td><td>CR</td><td>MR</td><td>SNLI</td><td>Subj</td><td>TREC</td></tr><tr><td>□</td><td>LM-BFFman 23</td><td>024</td><td>79.5</td><td>80.8</td><td>49.5</td><td>51.4</td><td>32.0</td></tr><tr><td>□</td><td>UniFew</td><td>0</td><td>78.8</td><td>74.8</td><td>54.4</td><td>50.3</td><td>15.0</td></tr><tr><td></td><td>UniFeWmeta.</td><td>0.</td><td>92.1</td><td>90.5.</td><td>83.8</td><td>56.8</td><td>39.1</td></tr><tr><td>□</td><td>LM-BFF</td><td>16/1625</td><td>91.0 ±0.9</td><td>87.7 ±1.4</td><td>77.5 ±3.5</td><td>91.4 ±1.8</td><td>89.4 ±1.7</td></tr><tr><td>□</td><td>UniFew</td><td>16/16</td><td>92.2 ±0.8</td><td>87.2 ±0.1</td><td>75.6 ±1.5</td><td>84.6 ±5.4</td><td>86.7 ±0.3</td></tr><tr><td></td><td>UniFeWmeta</td><td>16/16</td><td>92.7 ±0.4</td><td>90.2 ±0.8</td><td>84.9 ±0.5</td><td>87.6 ±2.0</td><td>86.1 ±0.4</td></tr><tr><td colspan="8">(c) Distributional Signature (Bao et al. [5])</td></tr><tr><td>Model □ DS</td><td></td><td>Shots 1</td><td>Amznt 62.7</td><td>FRelt 67.1</td><td>HuffP+ 43.1</td><td>20N+ 52.2</td><td>Reut+ 81.8</td></tr><tr><td></td><td>UniFew</td><td>1</td><td>±0.7 82.1</td><td>±0.9 75.7</td><td>±0.2 65.9</td><td>±0.7 58.4</td><td>±1.6 92.0</td></tr><tr><td>□</td><td>UniFeWmeta</td><td>1</td><td>±8.5 84.3</td><td>±13.2 90.6</td><td>±13.4 78.6</td><td>±11.6 70.3</td><td>±8.3 96.9</td></tr><tr><td></td><td></td><td></td><td>±8.9</td><td>±6.2</td><td>±6.9</td><td>±9.1</td><td>±2.5</td></tr><tr><td colspan="8"></td></tr><tr><td>□</td><td>DS</td><td>5</td><td>81.2 ±0.3</td><td>83.5 ±0.3</td><td>63.5 ±0.1</td><td>68.3 ±0.2</td><td>96.0 ±0.3</td></tr><tr><td></td><td>UniFew</td><td>5</td><td>88.5 ±7.4</td><td>88.8 ±6.5</td><td>77.1 ±6.0</td><td>72.2 ±8.4</td><td>97.0 ±2.8</td></tr><tr><td>□</td><td>UniFeWmeta</td><td>5</td><td>90.5 ±5.9</td><td>93.1 ±4.4</td><td>81.7 ±5.2</td><td>76.2 ±7.1</td><td>98.0 ±2.0</td></tr></table>
+
+<table><tr><td>Model</td><td>Shots</td><td>CNLL</td><td>SciT</td></tr><tr><td>H-SMLMT</td><td>4</td><td>57.6 ±7.1</td><td>76.8 ±3.4</td></tr><tr><td>UniFew</td><td>4</td><td>76.6 ±2.6</td><td>65.1 ±9.9</td></tr><tr><td>UniFeWmeta</td><td>4</td><td>79.7 ±2.8</td><td>85.4 ±2.5</td></tr><tr><td> H-SMLMT</td><td>8</td><td>70.2 ±3.0</td><td>79.1 ±1.1</td></tr><tr><td>UniFew</td><td>8</td><td>80.6 ±3.7</td><td>70.9 ±5.2</td></tr><tr><td>V UniFeWmeta</td><td>8</td><td>81.2 ±3.8</td><td>86.8 ±1.4</td></tr><tr><td>&gt; H-SMLMT</td><td>16</td><td>80.6 ±2.8</td><td>80.4 ±1.4</td></tr><tr><td>UniFew</td><td>16</td><td>85.8 ±1.9</td><td>76.7 ±4.6</td></tr><tr><td>V UniFeWmeta</td><td>16</td><td>87.9 ±1.9</td><td>85.4 ±2.5</td></tr></table>
+
+model prompt-based fine-tuning method, as well as Distributional Signatures (DS) [5] and H-SMLMT [4], two state-of-the-art meta-learning techniques. Refer to Appendix D for details on these methods.
+
+We compare to these methods using the datasets in the FLEX benchmark to establish the quality of our model. Since we constructed our benchmark from disjoint subsets of datasets evaluated in each of these prior works (§4.1), we compare each method with its corresponding subset of datasets. Each of these prior works evaluates their methods using different experimental setups (classes, number of episodes, shots) than our benchmark and was not designed to handle FLEX’s challenging episode characteristics like class imbalance. To enable fair comparison, we test UniFew on the exact data splits released by the authors when available (H-SMLMT and LM-BFF). For DS, we sample (balanced) episodes using our framework after matching their test settings (number of shots and classes, class splits, etc.) and reproduce their reported results to within $1 \%$ absolute difference using their model code; we use these episodes for our experiments. The results in Table 2 show that UniFewmeta outperforms both H-SMLMT and DS meta-learning approaches by relatively large margins, while achieving competitive results compared with LM-BFF. Note that UniFew’s strong results are without meta-learning approaches, extensive prompt-engineering, or per-episode hyperparameter search.
+
+Evaluating UniFew on the FLEX benchmark Having established UniFew as a strong model comparable to recent, state-of-the art techniques, we present its results on the final version of our benchmark (with class imbalance, etc.). From Table 3, we observe three findings. First, pretraining is an effective technique for infusing an NLP model with the ability to perform few-shot generalization even without any meta-training, as UniFew is able to score $\Delta _ { \mathrm { f e w } } = + 1 2 . 8$ higher when provided few rather than zero examples. Second, by comparing UniFew $\mathrm { \ m e t a }$ and UniFew, we see that metatraining has a substantial impact on zero-shot performance $\Delta _ { \mathrm { m e t a } } = + 1 4 . 5 )$ , but its benefit, while still substantial, is less in the few-shot setting $\Delta _ { \mathrm { m e t a } } = + 8 . 6 )$ . Third, while meta-training adds roughly the same benefit to zero and few-shot performance for both domain and task transfer settings, meta-training disproportionately benefits zero-shot class transfer $\langle \Delta _ { \mathrm { m e t a } } = + 1 6 . 2 \rangle$ over few-shot class transfer $\Delta _ { \mathrm { { m e t a } } } = + 4 . 3 )$ . Such observations are made possible through unified evaluation and comparison across different transfer types. The full FLEX benchmark results broken down by individual datasets are in Appendix E.
+
+Table 3: Mean accuracy of UniFew and UniFew $\mathrm { \ m e t a }$ on FLEX benchmark in zero and few-shot setups.   
+
+<table><tr><td></td><td colspan="3">Zero-shot</td><td></td><td colspan="3">Few-shot</td><td></td><td></td></tr><tr><td></td><td>Class</td><td>Domain</td><td>Task</td><td>Overall</td><td>Class</td><td>Domain</td><td>Task</td><td>Overall</td><td>△few (Overall)</td></tr><tr><td>UniFew</td><td>59.5</td><td>67.9</td><td>36.6</td><td>56.5</td><td>75.8</td><td>72.4</td><td>54.3</td><td>69.3</td><td>+12.8</td></tr><tr><td>UniFeWmeta</td><td>75.6</td><td>87.6</td><td>41.1</td><td>71.0</td><td>80.2</td><td>86.8</td><td>62.4</td><td>77.9</td><td>+6.9</td></tr><tr><td>△meta</td><td>+16.2</td><td>+19.7</td><td>+4.5</td><td>+14.5</td><td>+4.3</td><td>+14.4</td><td>+8.1</td><td>+8.6</td><td></td></tr></table>
+
+# 8 Limitations and Future Work
+
+While the initial FLEX benchmark is focused on classification tasks, we aim to use our benchmark creation toolkit (§4.4) to incorporate additional task formats like span selection or text generation. Furthermore, the benchmark currently only supports English language tasks; to study language transfer, we aim to incorporate new datasets using our toolkit. Adding diverse datasets has its own challenges; while we’ve selected datasets for our benchmark based on prior work adoption and have attempted to verify their licensing for research use, we were unable to find license details for some datasets (Appendix A). We believe it is crucial to continually evolve the suite of datasets to remain challenging for the best models [36] and to tackle real-world challenges [1].
+
+In addition, Sample Size Design (§5) simulations currently rely on our own available training estimates. We plan to gather a more representative sample from community leaderboard submissions.
+
+Our public leaderboard could benefit from extended support for detailed comparisons between submissions based on properties of techniques. For example, approaches may vary in terms of model characteristics (e.g., number of parameters), data and supervision used during pretraining, amount of compute, etc. We encourage reporting all these factors to enable the community to analyze and make progress on important sub-spaces in the overall few-shot technique design space.
+
+Finally, we believe the benefits of improving few-shot NLP techniques outweigh potential risks, but we acknowledge potential harms associated with language models [7, 14, 57, 63]. Few-shot models learn a task from a few examples but rely heavily on knowledge encoded in the pretrained model. Thus, few-shot models are more likely to inherit the biases of the pretrained models, compared to more fully supervised models; as the community focuses more on few-shot learning, it is more important than ever for future pretrained models to be careful about biases in the underlying pretraining corpora.
+
+# 9 Conclusion
+
+In this work, we unify and bring rigor to few-shot NLP evaluation. We formulate the FLEX Principles, a set of requirements and best practices that enables unified, rigorous, valid, and cost-sensitive measurement. We advance the principles with new Sample Size Design methodology for optimizing statistical accuracy and precision while keeping costs low. The FLEX benchmark is our instantiation of the FLEX Principles; it employs Sample Size Design and includes four few-shot transfer settings, zero-shot evaluation, and a public leaderboard with diverse NLP tasks. We present UniFew, a promptbased model that aligns pretraining and downstream task formats, achieving results competitive with recent few-shot methods despite using trivial prompt engineering. Finally, we release an extensible, open-source toolkit (used to train UniFew and generate the FLEX benchmark) to support future benchmark creation and few-shot NLP model training.
+
+# Acknowledgments and Disclosure of Funding
+
+We would like to thank Chandra Bhagavatula, Matt Gardner, Matt Peters, Doug Downey, Dan Weld, and the four anonymous reviewers for helpful comments, suggestions and feedback. We would also like to acknowledge the large community effort involved in the creation of the datasets and open-source tools we utilize.
+
+# References
+
+[1] Neel Alex, Eli Lifland, Lewis Tunstall, Abhishek Thakur, Pegah Maham, C. Jess Riedel, Emmie Hine, Carolyn Ashurst, Paul Sedille, Alexis Carlier, Michael Noetel, and Andreas Stuhlmüller. 2021. RAFT: A real-world few-shot text classification benchmark. CoRR, abs/2109.14076.   
+[2] Sébastien M R Arnold, Praateek Mahajan, Debajyoti Datta, Ian Bunner, and Konstantinos Saitas Zarkias. 2020. learn2learn: A library for Meta-Learning research.   
+[3] Trapit Bansal, Rishikesh Jha, and Andrew McCallum. 2020. Learning to Few-Shot Learn Across Diverse Natural Language Classification Tasks. In COLING.   
+[4] Trapit Bansal, Rishikesh Jha, Tsendsuren Munkhdalai, and Andrew McCallum. 2020. SelfSupervised Meta-Learning for Few-Shot Natural Language Classification Tasks. In EMNLP.   
+[5] Yujia Bao, Menghua Wu, Shiyu Chang, and Regina Barzilay. 2020. Few-shot Text Classification with Distributional Signatures. In ICLR.   
+[6] Roy Bar-Haim, Ido Dagan, Bill Dolan, L. Ferro, Danilo Giampiccolo, and B. Magnini. 2006. The second PASCAL recognising textual entailment challenge.   
+[7] Emily M. Bender, Timnit Gebru, Angelina McMillan-Major, and Shmargaret Shmitchell. 2021. On the dangers of stochastic parrots: Can language models be too big? FAccT.   
+[8] Luisa Bentivogli, Peter Clark, Ido Dagan, and Danilo Giampiccolo. 2009. The fifth PASCAL recognizing textual entailment challenge. In TAC.   
+[9] Samuel R. Bowman, Gabor Angeli, Christopher Potts, and Christopher D. Manning. 2015. A large annotated corpus for learning natural language inference. In EMNLP.   
+[10] 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. 2020. Language models are few-shot learners. In NeurIPS.   
+[11] Mateusz Buda, Atsuto Maki, and Maciej A. Mazurowski. 2018. A systematic study of the class imbalance problem in convolutional neural networks. Neural Networks, 106:249–259.   
+[12] Tianshi Cao, Marc T. Law, and Sanja Fidler. 2020. A Theoretical Analysis of the Number of Shots in Few-Shot Learning. In ICLR.   
+[13] Dallas Card, Peter Henderson, Urvashi Khandelwal, Robin Jia, Kyle Mahowald, and Dan Jurafsky. 2020. With little power comes great responsibility. In EMNLP.   
+[14] Nicholas Carlini, Florian Tramèr, Eric Wallace, Matthew Jagielski, Ariel Herbert-Voss, Katherine Lee, Adam Roberts, Tom B. Brown, Dawn Song, Úlfar Erlingsson, Alina Oprea, and Colin Raffel. 2020. Extracting training data from large language models. CoRR, abs/2012.07805.   
+[15] Wei-Yu Chen, Yen-Cheng Liu, Zsolt Kira, Yu-Chiang Frank Wang, and Jia-Bin Huang. 2019. A closer look at few-shot classification. In ICLR.   
+[16] Christopher Clark, Kenton Lee, Ming-Wei Chang, Tom Kwiatkowski, Michael Collins, and Kristina Toutanova. 2019. BoolQ: Exploring the Surprising Difficulty of Natural Yes/No Questions. In NAACL.   
+[17] Ido Dagan, Oren Glickman, and Bernardo Magnini. 2005. The PASCAL recognising textual entailment challenge. In International Conference on Machine Learning Challenges.   
+[18] Tristan Deleu, Tobias Würfl, Mandana Samiei, Joseph Paul Cohen, and Yoshua Bengio. 2019. Torchmeta: A Meta-Learning library for PyTorch. Available at: https://github.com/tristandeleu/pytorch-meta.   
+[19] Guneet S. Dhillon, Pratik Chaudhari, Avinash Ravichandran, and Stefano Soatto. 2020. A Baseline for Few-Shot Image Classification. In ICLR.   
+[20] William B. Dolan and Chris Brockett. 2005. Automatically Constructing a Corpus of Sentential Paraphrases. In Proceedings of the Third International Workshop on Paraphrasing (IWP2005).   
+[21] Zi-Yi Dou, Keyi Yu, and Antonios Anastasopoulos. 2019. Investigating Meta-Learning Algorithms for Low-Resource Natural Language Understanding Tasks. In EMNLP.   
+[22] Rotem Dror, Gili Baumer, Segev Shlomov, and Roi Reichart. 2018. The Hitchhiker’s Guide to Testing Statistical Significance in Natural Language Processing. In ACL.   
+[23] Chelsea Finn, Pieter Abbeel, and Sergey Levine. 2017. Model-Agnostic Meta-Learning for Fast Adaptation of Deep Networks. In ICML.   
+[24] Tianyu Gao, Adam Fisch, and Danqi Chen. 2021. Making pre-trained language models better few-shot learners. In ACL.   
+[25] Tianyu Gao, Xu Han, Zhiyuan Liu, and Maosong Sun. 2019. Hybrid Attention-Based Prototypical Networks for Noisy Few-Shot Relation Classification. In Proceedings of the AAAI Conference on Artificial Intelligence, volume 33, pages 6407–6414.   
+[26] Danilo Giampiccolo, Bernardo Magnini, Ido Dagan, and Bill Dolan. 2007. The Third PASCAL Recognizing Textual Entailment Challenge. In Proceedings of the ACL-PASCAL Workshop on Textual Entailment and Paraphrasing, pages 1–9, Prague. Association for Computational Linguistics.   
+[27] Jiatao Gu, Yong Wang, Yun Chen, Victor O. K. Li, and Kyunghyun Cho. 2018. Meta-Learning for Low-Resource Neural Machine Translation. In Proceedings of the 2018 Conference on Empirical Methods in Natural Language Processing, pages 3622–3631, Brussels, Belgium. Association for Computational Linguistics.   
+[28] Xu Han, Hao Zhu, Pengfei Yu, Ziyun Wang, Yuan Yao, Zhiyuan Liu, and Maosong Sun. 2018. FewRel: A Large-Scale Supervised Few-Shot Relation Classification Dataset with State-of-the-Art Evaluation. In EMNLP.   
+[29] Peter Hase and Mohit Bansal. 2021. When can models learn from explanations? A formal framework for understanding the roles of explanation data. CoRR, abs/2102.02201.   
+[30] Ruining He and Julian McAuley. 2016. Ups and Downs: Modeling the Visual Evolution of Fashion Trends with One-Class Collaborative Filtering. In WWW, pages 507–517.   
+[31] Yutai Hou, Jiafeng Mao, Yongkui Lai, Cheng Chen, Wanxiang Che, Zhigang Chen, and Ting Liu. 2020. FewJoint: A few-shot learning benchmark for joint language understanding. CoRR, abs/2009.08138.   
+[32] Minqing Hu and Bing Liu. 2004. Mining and summarizing customer reviews. In KDD.   
+[33] Robert L. Logan IV, Ivana Balazevic, Eric Wallace, Fabio Petroni, Sameer Singh, and Sebastian Riedel. 2021. Cutting down on prompts and parameters: Simple few-shot learning with language models. CoRR, abs/2106.13353.   
+[34] Daniel Khashabi, Sewon Min, Tushar Khot, Ashish Sabharwal, Oyvind Tafjord, P. Clark, and Hannaneh Hajishirzi. 2020. UnifiedQA: Crossing Format Boundaries With a Single QA System. In EMNLP.   
+[35] Tushar Khot, Ashish Sabharwal, and Peter Clark. 2018. SciTaiL: A Textual Entailment Dataset from Science Question Answering. In AAAI.   
+[36] Pang Wei Koh, Shiori Sagawa, Henrik Marklund, Sang Michael Xie, Marvin Zhang, Akshay Balsubramani, Wei hua Hu, Michihiro Yasunaga, Richard L. Phillips, Sara Beery, Jure Leskovec, Anshul Kundaje, Emma Pierson, Sergey Levine, Chelsea Finn, and Percy Liang. 2021. Wilds: A benchmark of in-the-wild distribution shifts. In ICML.   
+[37] Jason Krone, Yi Zhang, and Mona Diab. 2020. Learning to classify intents and slot labels given a handful of examples. In Workshop on Natural Language Processing for Conversational AI.   
+[38] Ken Lang. 1995. NewsWeeder: Learning to Filter Netnews. In ICML.   
+[39] Kwonjoon Lee, Subhransu Maji, Avinash Ravichandran, and Stefano Soatto. 2019. Metalearning with differentiable convex optimization. In CVPR.   
+[40] Hector Levesque, Ernest Davis, and Leora Morgenstern. 2011. The Winograd schema challenge. AAAI Spring Symposium: Logical Formalizations of Commonsense Reasoning, 46:47.   
+[41] David D. Lewis. 1997. Reuters-21578 text categorization test collection, distribution 1.0.   
+[42] Quentin Lhoest, Patrick von Platen, Thomas Wolf, Albert Villanova del Moral, Yacine Jernite, Abhishek Thakur, Suraj Patil, Lewis Tunstall, Mariama Drame, Julien Chaumond, Julien Plu, Joe Davison, Simon Brandeis, Victor Sanh, Teven Le Scao, Kevin Canwen Xu, Nicolas Patry, Angelina McMillan-Major, Philipp Schmid, Sylvain Gugger, Clément Delangue, Théo Matussière, Lysandre Debut, Stas Bekman, and François Lagunas. 2021. huggingface/datasets: 1.9.0.   
+[43] Xiaodong Liu, Pengcheng He, Weizhu Chen, and Jianfeng Gao. 2019. Multi-Task Deep Neural Networks for Natural Language Understanding. In ACL.   
+[44] Yao Lu, Max Bartolo, Alastair Moore, Sebastian Riedel, and Pontus Stenetorp. 2021. Fantastically ordered prompts and where to find them: Overcoming few-shot prompt order sensitivity. CoRR, abs/2104.08786.   
+[45] Qiaoyang Luo, Lingqiao Liu, Yuhao Lin, and Wei Zhang. 2021. Don’t miss the labels: Labelsemantic augmented meta-learner for few-shot text classification. In Findings of the Association for Computational Linguistics: ACL-IJCNLP 2021.   
+[46] Rishabh Misra. 2018. News category dataset.   
+[47] Mateusz Ochal, Massimiliano Patacchiola, Amos Storkey, Jose Vazquez, and Sen Wang. 2021. Few-Shot Learning with Class Imbalance.   
+[48] Bo Pang and Lillian Lee. 2004. A Sentimental Education: Sentiment Analysis Using Subjectivity Summarization Based on Minimum Cuts. In ACL.   
+[49] Bo Pang and Lillian Lee. 2005. Seeing Stars: Exploiting Class Relationships for Sentiment Categorization with Respect to Rating Scales. In ACL.   
+[50] Ethan Perez, Douwe Kiela, and Kyunghyun Cho. 2021. True few-shot learning with language models. CoRR, abs/2105.11447.   
+[51] Colin Raffel, Noam Shazeer, Adam Roberts, Katherine Lee, Sharan Narang, Michael Matena, Yanqi Zhou, W. Li, and Peter J. Liu. 2020. Exploring the limits of transfer learning with a unified text-to-text transformer. J. Mach. Learn. Res., 21:140:1–140:67.   
+[52] Pranav Rajpurkar, Jian Zhang, Konstantin Lopyrev, and Percy Liang. 2016. SQuAD: $^ { 1 0 0 , 0 0 0 + }$ Questions for Machine Comprehension of Text. In EMNLP.   
+[53] D. B. Rubin and N. Schenker. 1986. Efficiently simulating the coverage properties of interval estimates. Journal of the Royal Statistical Society: Series $C$ (Applied Statistics), 35(2):159–167.   
+[54] Andrei A. Rusu, Dushyant Rao, Jakub Sygnowski, Oriol Vinyals, Razvan Pascanu, Simon Osindero, and Raia Hadsell. 2019. Meta-learning with latent embedding optimization. In ICLR.   
+[55] Timo Schick and Hinrich Schütze. 2021. Exploiting cloze-questions for few-shot text classification and natural language inference. In Proceedings of the 16th Conference of the European Chapter of the Association for Computational Linguistics: Main Volume, EACL.   
+[56] Timo Schick and Hinrich Schütze. 2021. It’s not just size that matters: Small language models are also few-shot learners. In NAACL.   
+[57] Roy Schwartz, Jesse Dodge, Noah A. Smith, and Oren Etzioni. 2020. Green AI. Communications of the ACM, 63:54 – 63.   
+[58] Amr Sharaf, Hany Hassan, and Hal Daumé III. 2020. Meta-Learning for Few-Shot NMT Adaptation. In Proceedings of the Fourth Workshop on Neural Generation and Translation, pages 43–53, Online. Association for Computational Linguistics.   
+[59] Taylor Shin, Yasaman Razeghi, Robert L. Logan IV, Eric Wallace, and Sameer Singh. 2020. AutoPrompt: Eliciting knowledge from language models with automatically generated prompts. In EMNLP.   
+[60] Xujie Si, Yuan Yang, Hanjun Dai, Mayur Naik, and Le Song. 2019. Learning a meta-solver for syntax-guided program synthesis. In ICLR.   
+[61] Jake Snell, Kevin Swersky, and Richard Zemel. 2017. Prototypical networks for few-shot learning. In NeurIPS.   
+[62] Richard Socher, Alex Perelygin, Jean Wu, Jason Chuang, Christopher D. Manning, Andrew $\mathrm { N g }$ , and Christopher Potts. 2013. Recursive Deep Models for Semantic Compositionality Over a Sentiment Treebank. In EMNLP.   
+[63] Irene Solaiman, Miles Brundage, Jack Clark, Amanda Askell, Ariel Herbert-Voss, Jeff Wu, Alec Radford, and Jasmine Wang. 2019. Release strategies and the social impacts of language models. CoRR, abs/1908.09203.   
+[64] Shengli Sun, Qingfeng Sun, Kevin Zhou, and Tengchao Lv. 2019. Hierarchical Attention Prototypical Networks for Few-Shot Text Classification. In EMNLP.   
+[65] Derek Tam, Rakesh R. Menon, Mohit Bansal, Shashank Srivastava, and Colin Raffel. 2021. Improving and simplifying pattern exploiting training. CoRR, abs/2103.11955.   
+[66] Erik F. Tjong Kim Sang and Fien De Meulder. 2003. Introduction to the CoNLL-2003 Shared Task: Language-Independent Named Entity Recognition. In Proceedings of the Seventh Conference on Natural Language Learning at HLT-NAACL 2003, pages 142–147.   
+[67] Eleni Triantafillou, Tyler Zhu, Vincent Dumoulin, Pascal Lamblin, Utku Evci, Kelvin Xu, Ross Goroshin, Carles Gelada, Kevin Swersky, Pierre-Antoine Manzagol, and Hugo Larochelle. 2020. Meta-Dataset: A Dataset of Datasets for Learning to Learn from Few Examples. In ICLR.   
+[68] Oriol Vinyals, Charles Blundell, Tim Lillicrap, Koray Kavukcuoglu, and Daan Wierstra. 2016. Matching networks for one shot learning. In Advances in Neural Information Processing Systems 29: Annual Conference on Neural Information Processing Systems 2016.   
+[69] Ellen M. Voorhees and Dawn M. Tice. 2000. Building a question answering test collection. In SIGIR.   
+[70] Alex Wang, Amanpreet Singh, Julian Michael, Felix Hill, Omer Levy, and Samuel R. Bowman. 2018. GLUE: A Multi-Task Benchmark and Analysis Platform for Natural Language Understanding. In ICLR.   
+[71] Yaqing Wang, Quanming Yao, James T. Kwok, and Lionel M. Ni. 2020. Generalizing from a Few Examples: A Survey on Few-shot Learning. ACM Computing Surveys, 53(3):63:1–63:34.   
+[72] Alex Warstadt, Amanpreet Singh, and Samuel R. Bowman. 2019. Neural Network Acceptability Judgments. TACL, 7:625–641.   
+[73] Orion Weller, Nicholas Lourie, Matt Gardner, and Matthew Peters. 2020. Learning from Task Descriptions. In EMNLP.   
+[74] Adina Williams, Nikita Nangia, and Samuel Bowman. 2018. A Broad-Coverage Challenge Corpus for Sentence Understanding through Inference. In NAACL.   
+[75] Qinyuan Ye, Bill Yuchen Lin, and Xiang Ren. 2021. CrossFit: A few-shot learning challenge for cross-task generalization in NLP. CoRR, abs/2104.08835.   
+[76] Wenpeng Yin. 2020. Meta-learning for few-shot natural language processing: A survey. CoRR, abs/2007.09604.   
+[77] Mo Yu, Xiaoxiao Guo, Jinfeng Yi, Shiyu Chang, Saloni Potdar, Yu Cheng, Gerald Tesauro, Haoyu Wang, and Bowen Zhou. 2018. Diverse Few-Shot Text Classification with Multiple Metrics. In NAACL.   
+[78] Tony Z. Zhao, Eric Wallace, Shi Feng, Dan Klein, and Sameer Singh. 2021. Calibrate before use: Improving few-shot performance of language models. CoRR, abs/2102.09690.   
+[79] Yanan Zheng, Jing Zhou, Yujie Qian, Ming Ding, Jian Li, Ruslan Salakhutdinov, Jie Tang, Sebastian Ruder, and Zhilin Yang. 2021. FewNLU: Benchmarking state-of-the-art methods for few-shot natural language understanding. CoRR, abs/2109.12742.   
+[80] Ruiqi Zhong, Kristy Lee, Zheng Zhang, and Dan Klein. 2021. Adapting language models for zero-shot learning by meta-tuning on dataset and prompt collections. CoRR, abs/2104.04670.

parse/train/_WnGcwXLYOE/_WnGcwXLYOE_content_list.json

@@ -0,0 +1,1066 @@
+[
+    {
+        "type": "text",
+        "text": "FLEX: Unifying Evaluation for Few-Shot NLP ",
+        "text_level": 1,
+        "bbox": [
+            214,
+            122,
+            781,
+            148
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Jonathan Bragg∗ Arman Cohan∗ Kyle Lo Iz Beltagy ",
+        "bbox": [
+            269,
+            200,
+            720,
+            215
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Allen Institute for AI, Seattle, WA {jbragg,armanc,kylel,beltagy}@allenai.org ",
+        "bbox": [
+            341,
+            219,
+            658,
+            250
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Abstract ",
+        "text_level": 1,
+        "bbox": [
+            462,
+            285,
+            535,
+            301
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Few-shot NLP research is highly active, yet conducted in disjoint research threads with evaluation suites that lack challenging-yet-realistic testing setups and fail to employ careful experimental design. Consequently, the community does not know which techniques perform best or even if they outperform simple baselines. In response, we formulate the FLEX Principles, a set of requirements and best practices for unified, rigorous, valid, and cost-sensitive few-shot NLP evaluation. These principles include Sample Size Design, a novel approach to benchmark design that optimizes statistical accuracy and precision while keeping evaluation costs manageable. Following the principles, we release the FLEX benchmark,2 which includes four few-shot transfer settings, zero-shot evaluation, and a public leaderboard that covers diverse NLP tasks. In addition, we present UniFew,3 a prompt-based model for few-shot learning that unifies pretraining and finetuning prompt formats, eschewing complex machinery of recent prompt-based approaches in adapting downstream task formats to language model pretraining objectives. We demonstrate that despite simplicity, UniFew achieves results competitive with both popular meta-learning and prompt-based approaches. ",
+        "bbox": [
+            233,
+            316,
+            766,
+            537
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 Introduction ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            563,
+            310,
+            580
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Few-shot learning, the challenge of learning from a small number of examples, is critical for developing efficient, robust NLP techniques [71, 76]. In recent years, separate threads of few-shot NLP research have pursued goals like generalization to new classes [e.g., 5, 25], adaptation to new domains and tasks [e.g., 3, 4, 21], and direct application of pretrained language models (LMs) [e.g., 10, 24, 55, 56]. Unfortunately, despite the shared goal of advancing few-shot NLP techniques, the community does not know which techniques work best or even if they perform better than simple baselines. Evaluation suites across these research threads are disjoint, lack challenging-yet-realistic testing setups (e.g., class imbalance, variable training set sizes, etc.), and do not employ careful experimental design to ensure accurate and precise evaluation estimates and minimal computational burden. Prior work in few-shot learning outside of NLP serves as a stark warning of the consequences of improper measurement: Dhillon et al. [19] showed that techniques from several years of prior work did not make clear progress due to large overlapping accuracy distributions and, moreover, do not outperform a simple, carefully-tuned baseline. ",
+        "bbox": [
+            174,
+            594,
+            825,
+            775
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Need for systematic benchmark design As such, a high-quality benchmark is urgently needed to enable rigorous comparison of techniques across disjoint, highly-active threads of few-shot NLP research. But what should such an evaluation suite look like? Some best practices for evaluation of few-shot methods have been introduced in the computer vision (CV) literature [19, 67] and should be applied to NLP. However, unifying few-shot NLP work introduces new challenges. For example, the benchmark needs to test all types of transfer studied in separate research threads to measure progress on new techniques that make gains in each of these important generalization settings (§2). Also, given the importance of zero-shot learning and learning from task descriptions [29, 73], the benchmark needs to include zero-shot episodes and textual labels to enable measuring progress for models that do not use conventional supervised training, including methods that leverage the latent knowledge in pretrained LMs [10, 24, 78]. Further, the benchmark must accommodate new, computationally-expensive approaches, without overly reducing the number of evaluation episodes at the expense of statistical accuracy [3, 24, 75]. ",
+        "bbox": [
+            174,
+            781,
+            825,
+            837
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "table",
+        "img_path": "images/ddbb10b1d9c8d0ff0e495c9401cbc567c3f40287ce86aef6d1b43ef1552ab798.jpg",
+        "table_caption": [
+            "Table 1: Comparison of the FLEX benchmark with closest prior work. Our benchmark consists of episodes with variable number of shots in the range [1-5] and with class imbalance. “No extra test data” refers to excluding validation data from testing tasks, to avoid unfairly advantaging models that use such data [50]. Our benchmark’s number of test episodes is selected to balance statistical accuracy and precision, which suffers in few-episode setups, and compute requirements, which is too costly in many-episode setups (§5). "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td></td><td></td><td></td><td></td><td></td><td></td><td>CrosSFit[75]LM-BFF[24] GPT-3[10]DS[5]SMLMT[4] FewGlue[56]FLEX(ours)</td><td></td></tr><tr><td>Class Transfer</td><td></td><td></td><td></td><td>√</td><td></td><td></td><td></td></tr><tr><td>Domain Transfer</td><td></td><td></td><td></td><td></td><td>√</td><td></td><td></td></tr><tr><td>Task Transfer</td><td></td><td></td><td></td><td></td><td></td><td></td><td></td></tr><tr><td>Pretraining Transfer</td><td></td><td>√</td><td>&lt;</td><td></td><td></td><td>√</td><td>&gt;&gt;&gt;&gt;</td></tr><tr><td>Shots per class</td><td>{16,32}</td><td>16</td><td>variable</td><td>{1,5}</td><td>{4,8,16,32}</td><td>{total 32}4</td><td>[1-5]</td></tr><tr><td>Variable shots</td><td></td><td>1</td><td>√</td><td></td><td></td><td></td><td></td></tr><tr><td>Unbalanced</td><td></td><td></td><td></td><td></td><td></td><td></td><td></td></tr><tr><td>Textual labels</td><td></td><td>√</td><td></td><td></td><td></td><td>√</td><td></td></tr><tr><td>Zero-shot</td><td></td><td>√</td><td>√</td><td></td><td></td><td>-</td><td></td></tr><tr><td>No extra test data</td><td></td><td></td><td></td><td>√</td><td>√</td><td>mixed5</td><td>&gt;&gt;&gt;&gt;&gt;0</td></tr><tr><td># test episodes</td><td>5</td><td>5</td><td>1</td><td>1000</td><td>10</td><td>1</td><td></td></tr><tr><td>Reporting</td><td>avg</td><td>avg,SD</td><td>ag</td><td>avg, SD</td><td>avg,SD</td><td>avg, SD</td><td>al16</td></tr><tr><td>#datasets</td><td>160</td><td>16</td><td></td><td>7</td><td>18</td><td>8</td><td>20</td></tr></table>",
+        "bbox": [
+            173,
+            181,
+            833,
+            354
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            380,
+            826,
+            506
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Need for a robust few-shot model Recent prompt-based models [10] have shown strong results in few-shot learning. These models leverage the power of (often large) pretrained language models and adapt the format of downstream tasks to the underlying pretraining objective (e.g., Masked Language Modeling). This way, given the right natural language prompt (and sometimes verbalizers [55] and additional demonstrative examples), the model can quickly fine-tune on the downstream task [24, 43, 44, 55, 56]. However, adapting task formats to the underlying (masked) language modeling objectives is not straightforward; such models have been shown to be sensitive to varying choices of the prompt/demonstrations, training settings, hyperparameters, and learning algorithms [33, 50, 78], often requiring large held out sets and/or complex methods to overcomes such challenges. Can models eschew complex prompt engineering by unifying pretraining and downstream task formats? ",
+        "bbox": [
+            173,
+            511,
+            825,
+            650
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "In this paper, we tackle these key issues by introducing FLEX—Few-shot Language Evaluation across $\\mathbf { \\delta } ( \\mathbf { X } )$ many transfer types—and contributing the following: ",
+        "bbox": [
+            173,
+            655,
+            823,
+            684
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "• FLEX Principles (§3), a set of requirements and best practices for few-shot NLP evaluation that enables unified, rigorous, valid, and cost-sensitive measurements. – Sample Size Design: In support of valid, cost-sensitive measurement, we introduce a novel approach to few-shot sample size design (§5) that optimizes for a benchmark’s statistical accuracy and precision while keeping computational costs accessible to a broad range of researchers.   \n• FLEX benchmark (§4), an implementation of the FLEX Principles. It tests across four few-shot transfer settings,7 and includes a public leaderboard for few-shot NLP that covers 20 datasets across diverse NLP tasks (e.g., NLI, relation classification, entity typing). Table 1 summarizes key differences between FLEX and other few-shot NLP evaluation suites. ",
+        "bbox": [
+            210,
+            695,
+            825,
+            844
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "• UniFew (§6), a prompt-based model for few-shot learning in NLP. While most existing methods leverage pre-trained LMs for few-shot learning, LM pre-training tasks do not closely match natural downstream task formats, requiring complex methods (e.g., extensive prompt-engineering, use of verbalizers, episodic hyperparameter tuning, custom learning algorithms) to make these models work in few-shot setting. Instead, the key idea of our model, UniFew, is to close the gap between pre-training and fine-tuning formats by posing tasks as multiple-choice QA and using an underlying model that is pre-trained on a similar natural QA task format. This eliminates the need for complexities of adapting downstream tasks to the LM objectives, while resulting in competitive performance with both recent few-shot and meta-learning methods. ",
+        "bbox": [
+            217,
+            90,
+            825,
+            229
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "To aid similar efforts, our release of FLEX includes a toolkit for benchmark creation and few-shot NLP model development, which we used to create the FLEX benchmark and train UniFew. ",
+        "bbox": [
+            176,
+            241,
+            823,
+            270
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "2 Background and Related Work ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            290,
+            465,
+            308
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "We first provide background and notation for few-shot learning and evaluation, then discuss related work in NLP and outside NLP that motivated us to create the FLEX Principles and benchmark. ",
+        "bbox": [
+            176,
+            321,
+            826,
+            349
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Few-shot background and notation Broadly, modern approaches to few-shot learning are evaluated in a three-phase procedure [68]. In the first phase, a general-purpose pretrained model is obtained. In the subsequent “meta-training” phase,8 techniques aim to adapt the model to be well-suited for few-shot generalization. Finally, a “meta-testing” phase evaluates the adapted model in new few-shot prediction settings. ",
+        "bbox": [
+            174,
+            366,
+            825,
+            435
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Let $\\mathcal { D }$ be a dataset of $( x , y )$ examples with full label set $\\mathcal { V } _ { D }$ . From it, we construct three sets of episodes, corresponding to meta-training, meta-validation, and meta-testing and denoted by ${ \\mathcal { E } } _ { \\operatorname* { t r a i n } }$ ${ \\mathcal E } _ { \\mathrm { v a l } }$ , and ${ \\mathcal { E } } _ { \\mathrm { t e s t } }$ , respectively. Each episode in each of these sets is a few-shot problem with its own test set and other attributes. Forsampled subset of labels in ly, e and $E$ is a tuplee disjoint $( \\mathcal { D } _ { \\mathrm { t r a i n } } ^ { E } , \\mathcal { D } _ { \\mathrm { v a l } } ^ { E } , \\dot { \\mathcal { D } } _ { \\mathrm { t e s t } } ^ { E } , \\mathcal { y } _ { \\mathcal { D } } ^ { E } )$ wherewith l $y _ { \\mathcal { D } } ^ { E }$ is a  ls in $\\mathcal { V } _ { D }$ $\\mathcal { D } _ { \\mathrm { t r a i n | v a l | t e s t } } ^ { E }$ $\\mathcal { D }$ $y _ { \\mathcal { D } } ^ { E }$ . 9 For each episode, the model’s objective is to correctly predict labels for examples $\\mathcal { D } _ { \\mathrm { t e s t } } ^ { E }$ . To accomplish this, models make use of labeled examples in $\\mathcal { D } _ { \\mathrm { t r a i n } } ^ { E }$ , which is typically configured such that each label $i$ in $y _ { \\mathcal { D } } ^ { E }$ has $K _ { i } ^ { E }$ provided examples; $K _ { i } ^ { E }$ is known as the shot, and the setting when a class has no examples in $\\mathcal { D } _ { \\mathrm { t r a i n } } ^ { E }$ (i.e., $K _ { i } ^ { E } = 0$ ) is called zero-shot. ",
+        "bbox": [
+            173,
+            441,
+            825,
+            579
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Few-shot evaluation in NLP Research in few-shot NLP has proceeded in several parallel threads, each focused on a different type of transfer ability [76]. Each thread has separate evaluation practices, and the vast majority of few-shot NLP research has limited evaluation to a single transfer type (see Table 1). Here, we describe these types of transfer and their evaluation practices. ",
+        "bbox": [
+            174,
+            593,
+            825,
+            648
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Following the CV literature [67, 68], one thread of few-shot NLP focuses on class transfer, the problem of generalizing from a supervised set of classes at meta-train time to a differenfrom the same dataset at meta-test time. Evaluation typically involves splitting classes $\\mathcal { V } _ { D }$ of c into $\\mathcal { V } _ { \\mathrm { t r a i n } } ^ { \\mathcal { D } }$ $y _ { \\mathrm { v a l } } ^ { \\mathcal { D } }$ and $\\mathcal { V } _ { \\mathrm { t e s t } } ^ { \\mathcal { D } }$ disjoint subsets. Class transfer has been studied on many text classification tasks [5], including relation classification [25, 28, 64], intent classification [37, 64], inter alia. In contrast, domain transfer keeps the same classes between meta-training and meta-testing but changes the textual domain (e.g., generalizing from MNLI to science-focused SciTail [4, 21]). Evaluation then requires identifying pairs of datasets with the same classes $\\mathcal { \\ V } _ { D }$ , where one dataset’s episodes are assigned to ${ \\mathcal { E } } _ { \\operatorname* { t r a i n } }$ and the other’s to ${ \\mathcal { E } } _ { \\mathrm { t e s t } }$ . Domain transfer has also been studied on many tasks [3, 4], including dialogue intent detection & slot tagging [31], sentiment classification [77], NLI [21], and machine translation [27, 58]. ",
+        "bbox": [
+            174,
+            655,
+            825,
+            809
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Researchers have also begun to study task transfer, the problem of generalizing from a set of tasks at meta-train time to unseen tasks at meta-test time. Evaluation requires tasks (e.g., NLI) appearing in ${ \\mathcal { E } } _ { \\mathrm { t e s t } }$ not to appear in ${ \\mathcal { E } } _ { \\mathrm { t r a i n } }$ or ${ \\mathcal E } _ { \\mathrm { v a l } }$ . Prior work has used GLUE tasks [70] for meta-training before meta-testing on tasks such as entity typing [3, 4], while other work instead used GLUE for meta-testing [21]. Very recent work has studied task transfer over a large set of datasets [75, 80]. A limited amount of work evaluates both domain and task transfer [3, 4, 21]. An important emerging line of work (not noted by Yin [76]) is pretraining transfer, the problem of whether pretrained language models can perform well at meta-test time without any meta-training. Evaluation in this setting requires ${ \\mathcal { E } } _ { \\mathrm { t r a i n } }$ , $\\bar { \\mathcal { E } } _ { \\mathrm { v a l } } = \\emptyset$ . Prior work has shown that pretrained language models are capable of surprising performance on many few-shot tasks, even without fine-tuning [10]. More recent work, mainly focusing on text classification, has reported further gains with cloze-style formats [55, 56, 65], prompt engineering [24], or calibration [78]. FLEX is designed to exercise all four of these transfer types from previous work. ",
+        "bbox": [
+            176,
+            815,
+            823,
+            871
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            90,
+            826,
+            215
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Few-shot evaluation outside NLP The few-shot learning literature has largely focused on image classification, with the introduction of increasingly complex meta-learning algorithms [e.g., 23, 39, 54, 61, 68]. However, more recent work has shown that simple fine-tuning baselines are in fact competitive, and attribute this delayed discovery to problematic evaluation methodology [15, 19]. FLEX adopts recommended methodology [19, 67], and we introduce an analogous baseline (UniFew) to provide a strong measurement foundation for few-shot NLP. ",
+        "bbox": [
+            173,
+            229,
+            825,
+            314
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3 FLEX Principles for Few-Shot NLP Evaluation ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            332,
+            599,
+            349
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "We now enumerate key desiderata for a few-shot NLP benchmark capable of solving the urgent problems with few-shot NLP evaluation, including separate evaluations for each transfer type and failure to incorporate best measurement practices from other domains (§2). ",
+        "bbox": [
+            174,
+            363,
+            825,
+            405
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Diversity of transfer types To make NLP models broadly useful, few-shot NLP techniques must be capable of class, domain, and task transfer. Moreover, techniques should make use of the relevant supervision provided during meta-training to increase performance compared to the pretraining transfer setting. The benchmark should measure all four transfer settings to ensure that the community develops techniques that improve on strong pretraining transfer baselines, and enable comparison across these currently separate threads of research. ",
+        "bbox": [
+            174,
+            411,
+            825,
+            494
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Variable number of shots and classes To better simulate a variety of real-world scenarios, the benchmark should include a variety of training set sizes and numbers of classes [67]. Testing robustness to these factors is crucial; few-shot techniques are often sensitive to changes in these factors [12], yet all prior few-shot NLP evaluations we are aware of used a fixed number of training shots and classes, known in advance during meta-training. ",
+        "bbox": [
+            174,
+            501,
+            825,
+            570
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Unbalanced training sets The benchmark should also include unbalanced training sets with different training shots per class, another realistic setting adopted by CV benchmarks [67]. Class imbalance has also been observed to degrade performance [11, 47], yet prior few-shot NLP evaluations do not include this setting either. ",
+        "bbox": [
+            174,
+            577,
+            823,
+            632
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Textual labels While numerical label values are often used in classification tasks, descriptive textual labels are also present for many tasks. Making these textual labels available for use by few-shot techniques enables the development of techniques that can leverage the class name, like in-context learning [10], template generation [24], and meta-learning [45]. Textual labels are crucial in particular for zero-shot evaluation. ",
+        "bbox": [
+            174,
+            638,
+            825,
+            708
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Zero-shot evaluation We believe zero-shot evaluation is integral to the goals of few-shot evaluation. Similar to the motivation for measuring pretraining transfer, zero-shot evaluation is an important use case and also provides a strong baseline for some tasks. In the absence of training examples, textual class labels or richer task descriptions [73] must be provided. Some recent few-shot NLP work [e.g., 10, 24] evaluated with zero training shots, but most [e.g., 3, 5, 75] did not. ",
+        "bbox": [
+            174,
+            715,
+            825,
+            785
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "No extra meta-testing data We believe the benchmark should not provide validation data $\\langle \\mathcal { D } _ { \\mathrm { v a l } } ^ { E } =$ $\\emptyset , \\forall E \\in { \\mathcal { E } } _ { \\mathrm { t e s t } } )$ or unlabeled data for meta-testing tasks, since few-shot learning seeks to enable high performance in environments where collecting additional data is costly.10 Variation in these dimensions in prior NLP work makes comparison of results extremely difficult because it is often under-reported and gives unfair advantage to approaches that leverage such data [50]. For example, per-episode hyperparameter tuning on extra data has been shown to greatly inflate evaluation scores [24]. A few researchers [5, 65] follow our suggested approach, but others have used many different settings, from validation sets of various sizes [10, 24, 79] to no validation set but a large set of unlabeled examples [55, 56]. ",
+        "bbox": [
+            174,
+            791,
+            825,
+            888
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            90,
+            823,
+            119
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Principled sample size design Promising few-shot techniques can incur significant computational cost per episode, e.g., due to fine-tuning model parameters [4], searching for prompts [24], inter alia. To alleviate these costs, related works often evaluate with a limited number of episodes, which precludes statistically accurate or precise performance estimates. We believe the benchmark’s test sample size should be optimized to enable proper performance evaluation for such techniques, while ensuring the computational burden is inclusive toward researchers without large compute resources. ",
+        "bbox": [
+            173,
+            126,
+            825,
+            209
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Proper reporting of CIs, SDs, and individual results The benchmark should report confidence intervals (CIs) of performance estimates and follow recent guidelines [19] to report standard deviations (SDs) for understanding variability. Moreover, we newly advocate for controlling for the same sampled few-shot episodes across all methods and reporting individual episode results, so that researchers can run higher-powered paired statistical tests when comparing results [22], crucial when the benchmark has been optimized for low evaluation budgets. ",
+        "bbox": [
+            174,
+            215,
+            825,
+            299
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "4 FLEX Benchmark ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            316,
+            359,
+            334
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "The FLEX benchmark is a unifying, rigorous evaluation suite for few-shot learning in NLP, which implements the desiderata outlined in the previous section. In this section, we describe detailed design decisions and our accompanying few-shot NLP toolkit (§4.4), which we are releasing to facilitate easily adding NLP datasets and advanced sampling options to future benchmarks. We also describe the FLEX leaderboard (§4.5). ",
+        "bbox": [
+            174,
+            348,
+            825,
+            417
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "4.1 Task and Dataset Selection ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            434,
+            400,
+            449
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Following GLUE [70] and other prior work [3, 5, 24, 78], we focus on tasks formatted as classification. Despite recent advances, NLP state-of-the-art models remain significantly worse than human performance on many text classification tasks, particularly in the few-shot setting. Automatic scoring of classification tasks is also more reliable than text generation tasks. ",
+        "bbox": [
+            174,
+            458,
+            825,
+            515
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "We selected datasets across three recent few-shot NLP evaluation suites, which separately studied class transfer [5], domain and task transfer [3, 4], and pretraining transfer [24]. Our benchmark includes a broad mix of tasks (NLI, question classification, entity typing, relation classification, and sentiment analysis) and formats (document, sentence, sentence pair). More complete dataset and license details are available in the following subsection and Appendix A. ",
+        "bbox": [
+            174,
+            521,
+            825,
+            590
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "4.2 Meta-Evaluation Protocols ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            606,
+            400,
+            621
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "As discussed earlier, FLEX evaluates four different types of transfer: Class, Domain, Task, and Pretraining Transfer. To support all types, we report results to the FLEX benchmark both without metatraining (pretraining-only) and with meta-training. This reporting scheme evaluates the performance of the basic pretrained model and the benefit (or lack thereof) of meta-training. A similar reporting scheme was proposed by Triantafillou et al. [67] for CV. ",
+        "bbox": [
+            174,
+            632,
+            825,
+            702
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Pretraining-Only In this setting, the pretrained model is directly meta-tested on our benchmark without any additional training. This is the Pretraining Transfer setting, and it is the most difficult, but given the recent success of pretrained models in NLP for few-shot learning [10, 24], we believe that comparison to models without any meta-training is important for NLP tasks. ",
+        "bbox": [
+            174,
+            707,
+            825,
+            763
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Meta-Trained In this setting, the model is meta-trained then meta-tested on our benchmark. We carefully selected and split datasets across meta-train/validation/test in order to enable testing of Class, Domain, and Task transfer with a single meta-training phase (to reduce computational burden). Datasets involved in each transfer setting (detailed split information in Table 4 in Appendix A): ",
+        "bbox": [
+            176,
+            770,
+            825,
+            827
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "• Class Transfer: FewRel [28], HuffPost [46], Amazon [30], 20News [38], and Reuters [41] take part in meta-training and meta-testing but with different classes. • Domain Transfer: MR [49], CR [32], SNLI [9], and SciTail [35] are only in the meta-testing phase, but the corresponding sentiment and NLI datasets exist in the meta-training phase (MNLI [74], QNLI [52], and SST-2 [62]). ",
+        "bbox": [
+            217,
+            837,
+            825,
+            911
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "• Task Transfer: Subj [48], TREC [69], and CoNLL [66] are also for meta-testing only, and they represent tasks that the model does not encounter during meta-training. ",
+        "bbox": [
+            212,
+            90,
+            823,
+            119
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Instead of per-episode hyperparameter tuning, we provide meta-validation episodes ${ \\mathcal E } _ { \\mathrm { v a l } }$ for learning (during meta-training) global hyperparameters that work across all episodes. Specifically, the metavalidation dataset splits (see Table 4) consist of CoLa [72] for task transfer, WNLI [40] for domain transfer, and the validation splits used by Bao et al. [5] for all class transfer datasets. Following [3], we also include meta-training datasets MRPC [20], RTE [6, 8, 17, 26], and QQP [70]. ",
+        "bbox": [
+            174,
+            132,
+            825,
+            200
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "4.3 Episode Sampling ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            217,
+            339,
+            232
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "We describe how our benchmark samples meta-testing episodes ${ \\mathcal { E } } _ { \\mathrm { t e s t } }$ . For meta-training, we allow users to sample from ${ \\mathcal { E } } _ { \\operatorname* { t r a i n } }$ , ${ \\mathcal E } _ { \\mathrm { v a l } }$ in any way, or directly use the underlying dataset splits. ",
+        "bbox": [
+            174,
+            242,
+            823,
+            270
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Number of classes For Class Transfer datasets, FLEX evaluates model robustness to variable number of new classes. When constructing episode $E$ from one of these datasets $\\mathcal { D }$ , our benchmark samples an episode-specific number of classes from dataset $D$ , the sampler picks a random number from the range $\\mathcal { V } _ { D } ^ { E } \\sim \\mathrm { \\bar { U n i f } } ( 5 , \\operatorname* { m i n } ( | \\mathcal { V } _ { D } | , 1 0 ) )$ . 11  For Domain and Task Transfer, the number of classes is fixed to the maximum number of classes in each dataset because Class Transfer is not being evaluated. ",
+        "bbox": [
+            174,
+            276,
+            825,
+            345
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Number of shots Following prior work outside NLP [47, 67], our benchmark samples the training shot independently for each episode $E$ and class $i$ , as $K _ { i } ^ { E } \\sim \\mathrm { U n i f } ( K _ { \\operatorname* { m i n } } , K _ { \\operatorname* { m a x } } )$ , where $K _ { \\operatorname* { m i n } } = 1$ Given strong performance of NLP models with few or even zero examples [10, 73] and following prior work [5], we set the limit $K _ { \\operatorname* { m a x } } = 5$ . Separately, we allocate an equal number of episodes as zero-shot, where we instead set $\\mathcal { D } _ { \\mathrm { t r a i n } } ^ { E } = \\varnothing$ (equivalently, $K _ { i } ^ { E } = 0 , \\forall i )$ . In each episode, examples are sampled uniformly at random without replacement (but can be reused across episodes).12 Following Triantafillou et al. [67], we select a testing shot that is balanced across classes and leaves roughly half of examples for sampling the training examples. The total number of episodes for each reported configuration (pair of dataset and either zero- or few-shot) is set to 90 using Sample Size Design (§5). ",
+        "bbox": [
+            174,
+            352,
+            825,
+            478
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "4.4 Extensible Toolkit for Benchmark Creation and Model Training & Evaluation ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            494,
+            754,
+            510
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Alongside the FLEX benchmark, we release an extensible, highly-configurable Python toolkit, which we used to generate the benchmark, and train and evaluate our models. Unlike existing meta-learning frameworks (e.g., Torchmeta [18], learn2learn [2]), our framework makes available a wide range of community-contributed NLP datasets and utilities via HuggingFace Datasets [42].13 Our code also provides advanced sampling utilities (e.g., for class imbalance), ensures reproducibility by checksumming generated episodes, and reports all recommended statistics. ",
+        "bbox": [
+            174,
+            520,
+            825,
+            603
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "4.5 Public Leaderboard ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            619,
+            352,
+            633
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "We provide public leaderboards for each of the meta-evaluation protocols: Pretraining-Only14 and Meta-Trained.15 Submissions take the form of a text label predictions file, which is produced by our toolkit. Results are reported with confidence intervals, standard deviations, and individual predictions on request. See Appendix G for a screenshot of the results interface. ",
+        "bbox": [
+            174,
+            645,
+            825,
+            700
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "5 Sample Size Design: Balancing Statistical Measurement & Compute Cost ",
+        "text_level": 1,
+        "bbox": [
+            171,
+            719,
+            816,
+            737
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "We demonstrate a principled approach to determining the optimal sample size configuration in our few-shot benchmark. A proper benchmark should produce performance estimates that are accurate, close to the true value, and precise, low variance. A large (test) sample size can achieve this, yet must be considered alongside computational cost so that a broad community of researchers with differing amounts of compute resources can participate. This decision is further complicated in the few-shot setting, where sample size refers to both the number of test episodes $| \\mathcal { E } _ { \\mathrm { t e s t } } |$ and the number of test examples $| \\mathcal { D } _ { \\mathrm { t e s t } } ^ { E } |$ per episode $E \\in \\mathcal { E } _ { \\mathrm { t e s t } }$ . For practicality, we consider $\\overline { { | \\mathcal { D } _ { \\mathrm { t e s t } } | } }$ , the mean $| \\mathcal { D } _ { \\mathrm { t e s t } } ^ { E } |$ across all episodes, rather than every $| \\mathcal { D } _ { \\mathrm { t e s t } } ^ { E } |$ . It remains unknown how one should best distribute test examples between $| \\mathcal { E } _ { \\mathrm { t e s t } } |$ and $\\overline { { | \\mathcal { D } _ { \\mathrm { t e s t } } | } }$ : More episodes each with fewer examples, or fewer episodes each with many examples? Prior work has been inconsistent in this regard. For example, Gao et al. [24] used $| \\mathcal { E } _ { \\mathrm { t e s t } } | = 5$ and large $\\overline { { | \\mathcal { D } _ { \\mathrm { t e s t } } | } }$ , while Bao et al. [5] used $| \\mathcal { E } _ { \\mathrm { t e s t } } | = 1 0 0 0$ and much smaller $\\overline { { | \\mathcal { D } _ { \\mathrm { t e s t } } | } }$ . ",
+        "bbox": [
+            173,
+            751,
+            825,
+            820
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "image",
+        "img_path": "images/20b72aa04b5ecaf7008d376f1db2ef72f6b0892ea549c2a8081f72b78f0af4b9.jpg",
+        "image_caption": [
+            "Figure 1: Results of simulation study described in $\\ S 5$ . Each curve corresponds to a compute budget constraint $C$ (GPU-hours). Each point on a curve is an allocation of test data between the number of test episodes $| \\mathcal { E } _ { \\mathrm { t e s t } } |$ or mean number of examples per episode $\\overline { { | \\mathcal { D } _ { \\mathrm { t e s t } } | } }$ such that evaluation can be completed within given budget. Per curve, lower values of $| \\mathcal { E } _ { \\mathrm { t e s t } } |$ correspond linearly to larger values of $\\overline { { | \\mathcal { D } _ { \\mathrm { t e s t } } | } }$ , which are shown as numerical text annotations in (b). Error bars represent the $1 0 ^ { t h }$ and $9 0 ^ { t h }$ percentile values from repeated simulations across $\\mu _ { a c c } \\in \\{ 0 . 3 , 0 . 3 5 , \\ldots , 0 . 9 5 \\}$ . "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            214,
+            89,
+            789,
+            262
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            392,
+            825,
+            487
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Inspired by simulation techniques for informing statistically-powered experimental design [13], we study how different configurations of $| \\mathcal { E } _ { \\mathrm { t e s t } } |$ and $\\overline { { | \\mathcal { D } _ { \\mathrm { t e s t } } | } }$ across different compute budgets $C$ impact the accuracy and precision of our estimated CIs, specifically with respect to coverage probability [53] and width. First, we estimate per-episode and per-test-example costs of our few-shot model (§6) to obtain valid $( C , \\vert \\mathcal { E } _ { \\mathrm { t e s t } } \\vert , \\vert \\overline { { \\mathcal { D } _ { \\mathrm { t e s t } } } } \\vert )$ configurations s.t. the full benchmark completes within given $C$ (GPU-hours).16 Then, for each $( C , \\vert \\mathcal { E } _ { \\mathrm { t e s t } } \\vert , \\vert \\overline { { \\mathcal { D } _ { \\mathrm { t e s t } } } } \\vert )$ , we perform 1000 simulation runs, in which each run samples predictions under a true model accuracy $\\mu _ { a c c }$ and computes a single $9 5 \\%$ CI, its width, and whether it correctly covers $\\mu _ { a c c }$ . Averaging over simulation runs gives us estimates for the coverage probability and width of our benchmark’s CI for a single $( C , \\vert \\mathcal { E } _ { \\mathrm { t e s t } } \\vert , \\vert \\overline { { \\mathcal { D } _ { \\mathrm { t e s t } } } } \\vert )$ . We repeat this whole procedure for different $\\mu _ { a c c } \\in \\{ 0 . 3 , 0 . 3 5 , \\ldots , 0 . 9 5 \\}$ to cover a wide range of possible model performances observed across many datasets (see Table 3). ",
+        "bbox": [
+            173,
+            491,
+            825,
+            654
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Figure 1 shows CI coverage probability and width for many $( C , \\vert \\mathcal { E } _ { \\mathrm { t e s t } } \\vert , \\overline { { \\vert D _ { \\mathrm { t e s t } } \\vert } } )$ configurations. First, we find in Figure 1a that sufficiently-many test episodes (i.e., $\\vert \\mathcal { E } _ { \\mathrm { t e s t } } \\vert > 6 0 )$ is needed to guarantee coverage probability of our CIs is within one percentage point of the target $9 5 \\%$ , a trend that holds regardless of compute budget. Small $| \\mathcal { E } _ { \\mathrm { t e s t } } |$ also corresponds to large CI widths across all considered budgets in Figure 1b. This suggests that the choices of $| \\mathcal { E } _ { \\mathrm { t e s t } } | = 1 , 5 , 1 0$ in prior work [4, 24, 56, 75] can mean inaccurate and wide CIs, while choices of $| \\mathcal { E } _ { \\mathrm { t e s t } } | = 1 0 0 0$ [5] can be prohibitively costly for methods with high training cost. ",
+        "bbox": [
+            173,
+            660,
+            825,
+            758
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Next, Figure 1b reveals (i) diminishing returns in $\\mathrm { C I }$ width (decrease in $y$ -axis) as compute increases, and (ii) existence of an optimal balance between $| \\mathcal { E } _ { \\mathrm { t e s t } } |$ and $\\overline { { | \\mathcal { D } _ { \\mathrm { t e s t } } | } }$ for each budget. Restricting our consideration to budgets with optima satisfying sufficient coverage probability $\\lvert \\mathcal { E } _ { \\mathrm { t e s t } } \\rvert > 6 0 )$ , the minimum viable budget is 36 GPU-hours. Then, assessing the marginal benefit of each 12 GPU-hour budget increase in terms of marginal reduction in CI width between optima, we arrive at our FLEX configuration of $| \\mathcal { E } _ { \\mathrm { t e s t } } | = 9 0$ and $\\overline { { | \\mathscr { D } _ { \\mathrm { t e s t } } | } } \\approx 4 7 0$ under a budget of $C = 4 8$ GPU-hours.17 Further details are in Appendix B. ",
+        "bbox": [
+            173,
+            763,
+            825,
+            837
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            171,
+            89,
+            826,
+            119
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "6 UniFew: A Few-Shot Learning Model by Unifying Pre-training and Downstream Task Formats ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            138,
+            767,
+            174
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Despite their encouraging results, existing works on few-shot learning in NLP are based on either customized and often complex meta-learning algorithms [3, 4, 5, 60], heavy manual/automated engineering of textual descriptions or prompts [24, 55, 59, 78], ordering of training examples [44, 56], extensive hyperparameter tuning on held-out sets [24, 44, 55], or custom learning algorithms [55, 65]. We present UniFew, a strong few-shot learning model across all transfer settings and datasets tested, that eschews the need for incorporating the above-mentioned complexities and challenges. ",
+        "bbox": [
+            173,
+            189,
+            826,
+            272
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "UniFew is a prompt-based model [56], a class of models that tailor the input/output format of their data to match the format used during pretraining. While this technique allows them to perform a task without the need for additional classification layers, prompt-based models are typically sensitive to the choice of the prompts, which can require extensive search, trial-and-error, and even additional models to get right [24, 78]. To avoid this issue while still leveraging the strong capabilities of pretrained models, UniFew (1) converts examples into multiple-choice question-answer (QA) format, and (2) uses UnifiedQA [34], a T5 [51] model further pretrained on a large collection of QA pairs.18,19 ",
+        "bbox": [
+            174,
+            279,
+            825,
+            376
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Compared to other prompt-based models, UniFew has two main strengths. First, the prompt design problem is much simpler because UnifiedQA questions had well-defined formats. For example, we only need four general prompt templates which cover all 20 datasets in the FLEX benchmark, while prior works have needed specialized prompts for each dataset. Second, UnifiedQA’s multiple-choice format ensures the model outputs a valid class label, without the need for learned or manually-defined mappings or verbalizers required for other prompt-based methods [24, 55].20 In concurrent work, Zhong et al. [80] also show the benefit of performing meta-tuning on a variety of datasets; while their task setup as Q/A is similar to UniFew, they focus exclusively on binary zero-shot classification tasks and, unlike UniFew, do not handle multi-class or few-shot problems. ",
+        "bbox": [
+            174,
+            381,
+            825,
+            507
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "We experiment with UniFew both without and with meta-training on the FLEX benchmark’s metatraining data, following the FLEX protocol (§4.2). We call the meta-trained variant $\\mathrm { U n i F e w } _ { \\mathrm { m e t a } }$ . We use simple prompts in the format of question followed by choices followed by the answer (according to the UnifiedQA original format). The exact prompts used are provided in Appendix C. ",
+        "bbox": [
+            174,
+            512,
+            825,
+            569
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Training details For meta-training and meta-validation of UniFew, we sampled ${ \\mathcal { E } } _ { \\operatorname* { t r a i n } }$ and ${ \\mathcal E } _ { \\mathrm { v a l } }$ with 5-class, 5-training-shot sampling with the same number of shots per class.21 We trained the model for total number of 30K steps, using a linear learning rate scheduler with peak rate of $3 e { - 5 }$ , 200 warmup steps, and batch size of 4; we selected the best checkpoint based on ${ \\mathcal E } _ { \\mathrm { v a l } }$ performance. At meta-test time, for each episode, we trained the model on the episode’s training examples (if they exist) and predicted the outputs on test examples. For training at meta-test time, we used constant learning rate of $3 e { \\mathrm { - } } 5$ and batch size of 4, and trained the model for 400 steps.22 We used NVidia RTX8000 GPUs, which take about 7 GPU-hours for meta-training and 48 GPU-hours for meta-testing. For meta-testing we split the episodes among 8 GPUs to speed up evaluations. ",
+        "bbox": [
+            173,
+            574,
+            825,
+            700
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "7 Experiments ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            719,
+            312,
+            737
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Comparing UniFew with prior work To demonstrate the efficacy of UniFew, we evaluate it against state-of-the-art approaches for few-shot and meta-learning in NLP: LM-BFF [24], a language ",
+        "bbox": [
+            176,
+            751,
+            825,
+            780
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "(a) H-SMLMT (Bansal et al. [4]) ",
+        "bbox": [
+            174,
+            161,
+            367,
+            174
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "table",
+        "img_path": "images/becdc4cbff04696b88d93c8d0c741b148f54dd17189ce5f0adff7e0aaf0ecb01.jpg",
+        "table_caption": [
+            "Table 2: Comparing UniFew with prior methods on their respective test suites, reporting mean accuracy (and standard deviation). For each test suite, for each result set on same number of shots, we indicate with $\\vartriangleright$ when results are directly comparable: (i) either both use meta-training (H-SMLMT & DS with $\\mathrm { U n i F e w } _ { \\mathrm { m e t a } } )$ or neither do (LM-BFF with UniFew). We bold the better of the two. ",
+            "(b) LM-BFF (Gao et al. [24]) "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Model</td><td></td><td>Shots</td><td>CR</td><td>MR</td><td>SNLI</td><td>Subj</td><td>TREC</td></tr><tr><td>□</td><td>LM-BFFman 23</td><td>024</td><td>79.5</td><td>80.8</td><td>49.5</td><td>51.4</td><td>32.0</td></tr><tr><td>□</td><td>UniFew</td><td>0</td><td>78.8</td><td>74.8</td><td>54.4</td><td>50.3</td><td>15.0</td></tr><tr><td></td><td>UniFeWmeta.</td><td>0.</td><td>92.1</td><td>90.5.</td><td>83.8</td><td>56.8</td><td>39.1</td></tr><tr><td>□</td><td>LM-BFF</td><td>16/1625</td><td>91.0 ±0.9</td><td>87.7 ±1.4</td><td>77.5 ±3.5</td><td>91.4 ±1.8</td><td>89.4 ±1.7</td></tr><tr><td>□</td><td>UniFew</td><td>16/16</td><td>92.2 ±0.8</td><td>87.2 ±0.1</td><td>75.6 ±1.5</td><td>84.6 ±5.4</td><td>86.7 ±0.3</td></tr><tr><td></td><td>UniFeWmeta</td><td>16/16</td><td>92.7 ±0.4</td><td>90.2 ±0.8</td><td>84.9 ±0.5</td><td>87.6 ±2.0</td><td>86.1 ±0.4</td></tr><tr><td colspan=\"8\">(c) Distributional Signature (Bao et al. [5])</td></tr><tr><td>Model □ DS</td><td></td><td>Shots 1</td><td>Amznt 62.7</td><td>FRelt 67.1</td><td>HuffP+ 43.1</td><td>20N+ 52.2</td><td>Reut+ 81.8</td></tr><tr><td></td><td>UniFew</td><td>1</td><td>±0.7 82.1</td><td>±0.9 75.7</td><td>±0.2 65.9</td><td>±0.7 58.4</td><td>±1.6 92.0</td></tr><tr><td>□</td><td>UniFeWmeta</td><td>1</td><td>±8.5 84.3</td><td>±13.2 90.6</td><td>±13.4 78.6</td><td>±11.6 70.3</td><td>±8.3 96.9</td></tr><tr><td></td><td></td><td></td><td>±8.9</td><td>±6.2</td><td>±6.9</td><td>±9.1</td><td>±2.5</td></tr><tr><td colspan=\"8\"></td></tr><tr><td>□</td><td>DS</td><td>5</td><td>81.2 ±0.3</td><td>83.5 ±0.3</td><td>63.5 ±0.1</td><td>68.3 ±0.2</td><td>96.0 ±0.3</td></tr><tr><td></td><td>UniFew</td><td>5</td><td>88.5 ±7.4</td><td>88.8 ±6.5</td><td>77.1 ±6.0</td><td>72.2 ±8.4</td><td>97.0 ±2.8</td></tr><tr><td>□</td><td>UniFeWmeta</td><td>5</td><td>90.5 ±5.9</td><td>93.1 ±4.4</td><td>81.7 ±5.2</td><td>76.2 ±7.1</td><td>98.0 ±2.0</td></tr></table>",
+        "bbox": [
+            423,
+            180,
+            812,
+            511
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "table",
+        "img_path": "images/48a8a40f8c1a5612705c02554534d74936750128bae4c8f82fe1deaff5488aff.jpg",
+        "table_caption": [],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Model</td><td>Shots</td><td>CNLL</td><td>SciT</td></tr><tr><td>H-SMLMT</td><td>4</td><td>57.6 ±7.1</td><td>76.8 ±3.4</td></tr><tr><td>UniFew</td><td>4</td><td>76.6 ±2.6</td><td>65.1 ±9.9</td></tr><tr><td>UniFeWmeta</td><td>4</td><td>79.7 ±2.8</td><td>85.4 ±2.5</td></tr><tr><td> H-SMLMT</td><td>8</td><td>70.2 ±3.0</td><td>79.1 ±1.1</td></tr><tr><td>UniFew</td><td>8</td><td>80.6 ±3.7</td><td>70.9 ±5.2</td></tr><tr><td>V UniFeWmeta</td><td>8</td><td>81.2 ±3.8</td><td>86.8 ±1.4</td></tr><tr><td>&gt; H-SMLMT</td><td>16</td><td>80.6 ±2.8</td><td>80.4 ±1.4</td></tr><tr><td>UniFew</td><td>16</td><td>85.8 ±1.9</td><td>76.7 ±4.6</td></tr><tr><td>V UniFeWmeta</td><td>16</td><td>87.9 ±1.9</td><td>85.4 ±2.5</td></tr></table>",
+        "bbox": [
+            174,
+            181,
+            388,
+            426
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "model prompt-based fine-tuning method, as well as Distributional Signatures (DS) [5] and H-SMLMT [4], two state-of-the-art meta-learning techniques. Refer to Appendix D for details on these methods. ",
+        "bbox": [
+            174,
+            536,
+            823,
+            565
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "We compare to these methods using the datasets in the FLEX benchmark to establish the quality of our model. Since we constructed our benchmark from disjoint subsets of datasets evaluated in each of these prior works (§4.1), we compare each method with its corresponding subset of datasets. Each of these prior works evaluates their methods using different experimental setups (classes, number of episodes, shots) than our benchmark and was not designed to handle FLEX’s challenging episode characteristics like class imbalance. To enable fair comparison, we test UniFew on the exact data splits released by the authors when available (H-SMLMT and LM-BFF). For DS, we sample (balanced) episodes using our framework after matching their test settings (number of shots and classes, class splits, etc.) and reproduce their reported results to within $1 \\%$ absolute difference using their model code; we use these episodes for our experiments. The results in Table 2 show that UniFewmeta outperforms both H-SMLMT and DS meta-learning approaches by relatively large margins, while achieving competitive results compared with LM-BFF. Note that UniFew’s strong results are without meta-learning approaches, extensive prompt-engineering, or per-episode hyperparameter search. ",
+        "bbox": [
+            174,
+            570,
+            825,
+            751
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Evaluating UniFew on the FLEX benchmark Having established UniFew as a strong model comparable to recent, state-of-the art techniques, we present its results on the final version of our benchmark (with class imbalance, etc.). From Table 3, we observe three findings. First, pretraining is an effective technique for infusing an NLP model with the ability to perform few-shot generalization even without any meta-training, as UniFew is able to score $\\Delta _ { \\mathrm { f e w } } = + 1 2 . 8$ higher when provided few rather than zero examples. Second, by comparing UniFew $\\mathrm { \\ m e t a }$ and UniFew, we see that metatraining has a substantial impact on zero-shot performance $\\Delta _ { \\mathrm { m e t a } } = + 1 4 . 5 )$ , but its benefit, while still substantial, is less in the few-shot setting $\\Delta _ { \\mathrm { m e t a } } = + 8 . 6 )$ . Third, while meta-training adds roughly the same benefit to zero and few-shot performance for both domain and task transfer settings, meta-training disproportionately benefits zero-shot class transfer $\\langle \\Delta _ { \\mathrm { m e t a } } = + 1 6 . 2 \\rangle$ over few-shot class transfer $\\Delta _ { \\mathrm { { m e t a } } } = + 4 . 3 )$ . Such observations are made possible through unified evaluation and comparison across different transfer types. The full FLEX benchmark results broken down by individual datasets are in Appendix E. ",
+        "bbox": [
+            173,
+            765,
+            825,
+            835
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "table",
+        "img_path": "images/7ab5c165d123b82ff094ee43197eb8b6e00dfb7af3e3c3cbe07da9c8b89f4b54.jpg",
+        "table_caption": [
+            "Table 3: Mean accuracy of UniFew and UniFew $\\mathrm { \\ m e t a }$ on FLEX benchmark in zero and few-shot setups. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td></td><td colspan=\"3\">Zero-shot</td><td></td><td colspan=\"3\">Few-shot</td><td></td><td></td></tr><tr><td></td><td>Class</td><td>Domain</td><td>Task</td><td>Overall</td><td>Class</td><td>Domain</td><td>Task</td><td>Overall</td><td>△few (Overall)</td></tr><tr><td>UniFew</td><td>59.5</td><td>67.9</td><td>36.6</td><td>56.5</td><td>75.8</td><td>72.4</td><td>54.3</td><td>69.3</td><td>+12.8</td></tr><tr><td>UniFeWmeta</td><td>75.6</td><td>87.6</td><td>41.1</td><td>71.0</td><td>80.2</td><td>86.8</td><td>62.4</td><td>77.9</td><td>+6.9</td></tr><tr><td>△meta</td><td>+16.2</td><td>+19.7</td><td>+4.5</td><td>+14.5</td><td>+4.3</td><td>+14.4</td><td>+8.1</td><td>+8.6</td><td></td></tr></table>",
+        "bbox": [
+            205,
+            127,
+            792,
+            213
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            241,
+            825,
+            352
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "8 Limitations and Future Work ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            373,
+            452,
+            391
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "While the initial FLEX benchmark is focused on classification tasks, we aim to use our benchmark creation toolkit (§4.4) to incorporate additional task formats like span selection or text generation. Furthermore, the benchmark currently only supports English language tasks; to study language transfer, we aim to incorporate new datasets using our toolkit. Adding diverse datasets has its own challenges; while we’ve selected datasets for our benchmark based on prior work adoption and have attempted to verify their licensing for research use, we were unable to find license details for some datasets (Appendix A). We believe it is crucial to continually evolve the suite of datasets to remain challenging for the best models [36] and to tackle real-world challenges [1]. ",
+        "bbox": [
+            174,
+            406,
+            825,
+            517
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "In addition, Sample Size Design (§5) simulations currently rely on our own available training estimates. We plan to gather a more representative sample from community leaderboard submissions. ",
+        "bbox": [
+            176,
+            523,
+            821,
+            553
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Our public leaderboard could benefit from extended support for detailed comparisons between submissions based on properties of techniques. For example, approaches may vary in terms of model characteristics (e.g., number of parameters), data and supervision used during pretraining, amount of compute, etc. We encourage reporting all these factors to enable the community to analyze and make progress on important sub-spaces in the overall few-shot technique design space. ",
+        "bbox": [
+            174,
+            558,
+            825,
+            628
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Finally, we believe the benefits of improving few-shot NLP techniques outweigh potential risks, but we acknowledge potential harms associated with language models [7, 14, 57, 63]. Few-shot models learn a task from a few examples but rely heavily on knowledge encoded in the pretrained model. Thus, few-shot models are more likely to inherit the biases of the pretrained models, compared to more fully supervised models; as the community focuses more on few-shot learning, it is more important than ever for future pretrained models to be careful about biases in the underlying pretraining corpora. ",
+        "bbox": [
+            174,
+            633,
+            825,
+            718
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "9 Conclusion ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            739,
+            299,
+            756
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "In this work, we unify and bring rigor to few-shot NLP evaluation. We formulate the FLEX Principles, a set of requirements and best practices that enables unified, rigorous, valid, and cost-sensitive measurement. We advance the principles with new Sample Size Design methodology for optimizing statistical accuracy and precision while keeping costs low. The FLEX benchmark is our instantiation of the FLEX Principles; it employs Sample Size Design and includes four few-shot transfer settings, zero-shot evaluation, and a public leaderboard with diverse NLP tasks. We present UniFew, a promptbased model that aligns pretraining and downstream task formats, achieving results competitive with recent few-shot methods despite using trivial prompt engineering. Finally, we release an extensible, open-source toolkit (used to train UniFew and generate the FLEX benchmark) to support future benchmark creation and few-shot NLP model training. ",
+        "bbox": [
+            174,
+            772,
+            826,
+            911
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Acknowledgments and Disclosure of Funding ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            88,
+            553,
+            107
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "We would like to thank Chandra Bhagavatula, Matt Gardner, Matt Peters, Doug Downey, Dan Weld, and the four anonymous reviewers for helpful comments, suggestions and feedback. We would also like to acknowledge the large community effort involved in the creation of the datasets and open-source tools we utilize. ",
+        "bbox": [
+            174,
+            119,
+            826,
+            175
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "References ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            194,
+            266,
+            210
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "[1] Neel Alex, Eli Lifland, Lewis Tunstall, Abhishek Thakur, Pegah Maham, C. Jess Riedel, Emmie Hine, Carolyn Ashurst, Paul Sedille, Alexis Carlier, Michael Noetel, and Andreas Stuhlmüller. 2021. RAFT: A real-world few-shot text classification benchmark. CoRR, abs/2109.14076.   \n[2] Sébastien M R Arnold, Praateek Mahajan, Debajyoti Datta, Ian Bunner, and Konstantinos Saitas Zarkias. 2020. learn2learn: A library for Meta-Learning research.   \n[3] Trapit Bansal, Rishikesh Jha, and Andrew McCallum. 2020. Learning to Few-Shot Learn Across Diverse Natural Language Classification Tasks. In COLING.   \n[4] Trapit Bansal, Rishikesh Jha, Tsendsuren Munkhdalai, and Andrew McCallum. 2020. SelfSupervised Meta-Learning for Few-Shot Natural Language Classification Tasks. In EMNLP.   \n[5] Yujia Bao, Menghua Wu, Shiyu Chang, and Regina Barzilay. 2020. Few-shot Text Classification with Distributional Signatures. In ICLR.   \n[6] Roy Bar-Haim, Ido Dagan, Bill Dolan, L. Ferro, Danilo Giampiccolo, and B. Magnini. 2006. The second PASCAL recognising textual entailment challenge.   \n[7] Emily M. Bender, Timnit Gebru, Angelina McMillan-Major, and Shmargaret Shmitchell. 2021. On the dangers of stochastic parrots: Can language models be too big? FAccT.   \n[8] Luisa Bentivogli, Peter Clark, Ido Dagan, and Danilo Giampiccolo. 2009. The fifth PASCAL recognizing textual entailment challenge. In TAC.   \n[9] Samuel R. Bowman, Gabor Angeli, Christopher Potts, and Christopher D. Manning. 2015. A large annotated corpus for learning natural language inference. In EMNLP.   \n[10] 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. 2020. Language models are few-shot learners. In NeurIPS.   \n[11] Mateusz Buda, Atsuto Maki, and Maciej A. Mazurowski. 2018. A systematic study of the class imbalance problem in convolutional neural networks. Neural Networks, 106:249–259.   \n[12] Tianshi Cao, Marc T. Law, and Sanja Fidler. 2020. A Theoretical Analysis of the Number of Shots in Few-Shot Learning. In ICLR.   \n[13] Dallas Card, Peter Henderson, Urvashi Khandelwal, Robin Jia, Kyle Mahowald, and Dan Jurafsky. 2020. With little power comes great responsibility. In EMNLP.   \n[14] Nicholas Carlini, Florian Tramèr, Eric Wallace, Matthew Jagielski, Ariel Herbert-Voss, Katherine Lee, Adam Roberts, Tom B. Brown, Dawn Song, Úlfar Erlingsson, Alina Oprea, and Colin Raffel. 2020. Extracting training data from large language models. CoRR, abs/2012.07805.   \n[15] Wei-Yu Chen, Yen-Cheng Liu, Zsolt Kira, Yu-Chiang Frank Wang, and Jia-Bin Huang. 2019. A closer look at few-shot classification. In ICLR.   \n[16] Christopher Clark, Kenton Lee, Ming-Wei Chang, Tom Kwiatkowski, Michael Collins, and Kristina Toutanova. 2019. BoolQ: Exploring the Surprising Difficulty of Natural Yes/No Questions. In NAACL.   \n[17] Ido Dagan, Oren Glickman, and Bernardo Magnini. 2005. The PASCAL recognising textual entailment challenge. In International Conference on Machine Learning Challenges.   \n[18] Tristan Deleu, Tobias Würfl, Mandana Samiei, Joseph Paul Cohen, and Yoshua Bengio. 2019. Torchmeta: A Meta-Learning library for PyTorch. Available at: https://github.com/tristandeleu/pytorch-meta.   \n[19] Guneet S. Dhillon, Pratik Chaudhari, Avinash Ravichandran, and Stefano Soatto. 2020. A Baseline for Few-Shot Image Classification. In ICLR.   \n[20] William B. Dolan and Chris Brockett. 2005. Automatically Constructing a Corpus of Sentential Paraphrases. In Proceedings of the Third International Workshop on Paraphrasing (IWP2005).   \n[21] Zi-Yi Dou, Keyi Yu, and Antonios Anastasopoulos. 2019. Investigating Meta-Learning Algorithms for Low-Resource Natural Language Understanding Tasks. In EMNLP.   \n[22] Rotem Dror, Gili Baumer, Segev Shlomov, and Roi Reichart. 2018. The Hitchhiker’s Guide to Testing Statistical Significance in Natural Language Processing. In ACL.   \n[23] Chelsea Finn, Pieter Abbeel, and Sergey Levine. 2017. Model-Agnostic Meta-Learning for Fast Adaptation of Deep Networks. In ICML.   \n[24] Tianyu Gao, Adam Fisch, and Danqi Chen. 2021. Making pre-trained language models better few-shot learners. In ACL.   \n[25] Tianyu Gao, Xu Han, Zhiyuan Liu, and Maosong Sun. 2019. Hybrid Attention-Based Prototypical Networks for Noisy Few-Shot Relation Classification. In Proceedings of the AAAI Conference on Artificial Intelligence, volume 33, pages 6407–6414.   \n[26] Danilo Giampiccolo, Bernardo Magnini, Ido Dagan, and Bill Dolan. 2007. The Third PASCAL Recognizing Textual Entailment Challenge. In Proceedings of the ACL-PASCAL Workshop on Textual Entailment and Paraphrasing, pages 1–9, Prague. Association for Computational Linguistics.   \n[27] Jiatao Gu, Yong Wang, Yun Chen, Victor O. K. Li, and Kyunghyun Cho. 2018. Meta-Learning for Low-Resource Neural Machine Translation. In Proceedings of the 2018 Conference on Empirical Methods in Natural Language Processing, pages 3622–3631, Brussels, Belgium. Association for Computational Linguistics.   \n[28] Xu Han, Hao Zhu, Pengfei Yu, Ziyun Wang, Yuan Yao, Zhiyuan Liu, and Maosong Sun. 2018. FewRel: A Large-Scale Supervised Few-Shot Relation Classification Dataset with State-of-the-Art Evaluation. In EMNLP.   \n[29] Peter Hase and Mohit Bansal. 2021. When can models learn from explanations? A formal framework for understanding the roles of explanation data. CoRR, abs/2102.02201.   \n[30] Ruining He and Julian McAuley. 2016. Ups and Downs: Modeling the Visual Evolution of Fashion Trends with One-Class Collaborative Filtering. In WWW, pages 507–517.   \n[31] Yutai Hou, Jiafeng Mao, Yongkui Lai, Cheng Chen, Wanxiang Che, Zhigang Chen, and Ting Liu. 2020. FewJoint: A few-shot learning benchmark for joint language understanding. CoRR, abs/2009.08138.   \n[32] Minqing Hu and Bing Liu. 2004. Mining and summarizing customer reviews. In KDD.   \n[33] Robert L. Logan IV, Ivana Balazevic, Eric Wallace, Fabio Petroni, Sameer Singh, and Sebastian Riedel. 2021. Cutting down on prompts and parameters: Simple few-shot learning with language models. CoRR, abs/2106.13353.   \n[34] Daniel Khashabi, Sewon Min, Tushar Khot, Ashish Sabharwal, Oyvind Tafjord, P. Clark, and Hannaneh Hajishirzi. 2020. UnifiedQA: Crossing Format Boundaries With a Single QA System. In EMNLP.   \n[35] Tushar Khot, Ashish Sabharwal, and Peter Clark. 2018. SciTaiL: A Textual Entailment Dataset from Science Question Answering. In AAAI.   \n[36] Pang Wei Koh, Shiori Sagawa, Henrik Marklund, Sang Michael Xie, Marvin Zhang, Akshay Balsubramani, Wei hua Hu, Michihiro Yasunaga, Richard L. Phillips, Sara Beery, Jure Leskovec, Anshul Kundaje, Emma Pierson, Sergey Levine, Chelsea Finn, and Percy Liang. 2021. Wilds: A benchmark of in-the-wild distribution shifts. In ICML.   \n[37] Jason Krone, Yi Zhang, and Mona Diab. 2020. Learning to classify intents and slot labels given a handful of examples. In Workshop on Natural Language Processing for Conversational AI.   \n[38] Ken Lang. 1995. NewsWeeder: Learning to Filter Netnews. In ICML.   \n[39] Kwonjoon Lee, Subhransu Maji, Avinash Ravichandran, and Stefano Soatto. 2019. Metalearning with differentiable convex optimization. In CVPR.   \n[40] Hector Levesque, Ernest Davis, and Leora Morgenstern. 2011. The Winograd schema challenge. AAAI Spring Symposium: Logical Formalizations of Commonsense Reasoning, 46:47.   \n[41] David D. Lewis. 1997. Reuters-21578 text categorization test collection, distribution 1.0.   \n[42] Quentin Lhoest, Patrick von Platen, Thomas Wolf, Albert Villanova del Moral, Yacine Jernite, Abhishek Thakur, Suraj Patil, Lewis Tunstall, Mariama Drame, Julien Chaumond, Julien Plu, Joe Davison, Simon Brandeis, Victor Sanh, Teven Le Scao, Kevin Canwen Xu, Nicolas Patry, Angelina McMillan-Major, Philipp Schmid, Sylvain Gugger, Clément Delangue, Théo Matussière, Lysandre Debut, Stas Bekman, and François Lagunas. 2021. huggingface/datasets: 1.9.0.   \n[43] Xiaodong Liu, Pengcheng He, Weizhu Chen, and Jianfeng Gao. 2019. Multi-Task Deep Neural Networks for Natural Language Understanding. In ACL.   \n[44] Yao Lu, Max Bartolo, Alastair Moore, Sebastian Riedel, and Pontus Stenetorp. 2021. Fantastically ordered prompts and where to find them: Overcoming few-shot prompt order sensitivity. CoRR, abs/2104.08786.   \n[45] Qiaoyang Luo, Lingqiao Liu, Yuhao Lin, and Wei Zhang. 2021. Don’t miss the labels: Labelsemantic augmented meta-learner for few-shot text classification. In Findings of the Association for Computational Linguistics: ACL-IJCNLP 2021.   \n[46] Rishabh Misra. 2018. News category dataset.   \n[47] Mateusz Ochal, Massimiliano Patacchiola, Amos Storkey, Jose Vazquez, and Sen Wang. 2021. Few-Shot Learning with Class Imbalance.   \n[48] Bo Pang and Lillian Lee. 2004. A Sentimental Education: Sentiment Analysis Using Subjectivity Summarization Based on Minimum Cuts. In ACL.   \n[49] Bo Pang and Lillian Lee. 2005. Seeing Stars: Exploiting Class Relationships for Sentiment Categorization with Respect to Rating Scales. In ACL.   \n[50] Ethan Perez, Douwe Kiela, and Kyunghyun Cho. 2021. True few-shot learning with language models. CoRR, abs/2105.11447.   \n[51] Colin Raffel, Noam Shazeer, Adam Roberts, Katherine Lee, Sharan Narang, Michael Matena, Yanqi Zhou, W. Li, and Peter J. Liu. 2020. Exploring the limits of transfer learning with a unified text-to-text transformer. J. Mach. Learn. Res., 21:140:1–140:67.   \n[52] Pranav Rajpurkar, Jian Zhang, Konstantin Lopyrev, and Percy Liang. 2016. SQuAD: $^ { 1 0 0 , 0 0 0 + }$ Questions for Machine Comprehension of Text. In EMNLP.   \n[53] D. B. Rubin and N. Schenker. 1986. Efficiently simulating the coverage properties of interval estimates. Journal of the Royal Statistical Society: Series $C$ (Applied Statistics), 35(2):159–167.   \n[54] Andrei A. Rusu, Dushyant Rao, Jakub Sygnowski, Oriol Vinyals, Razvan Pascanu, Simon Osindero, and Raia Hadsell. 2019. Meta-learning with latent embedding optimization. In ICLR.   \n[55] Timo Schick and Hinrich Schütze. 2021. Exploiting cloze-questions for few-shot text classification and natural language inference. In Proceedings of the 16th Conference of the European Chapter of the Association for Computational Linguistics: Main Volume, EACL.   \n[56] Timo Schick and Hinrich Schütze. 2021. It’s not just size that matters: Small language models are also few-shot learners. In NAACL.   \n[57] Roy Schwartz, Jesse Dodge, Noah A. Smith, and Oren Etzioni. 2020. Green AI. Communications of the ACM, 63:54 – 63.   \n[58] Amr Sharaf, Hany Hassan, and Hal Daumé III. 2020. Meta-Learning for Few-Shot NMT Adaptation. In Proceedings of the Fourth Workshop on Neural Generation and Translation, pages 43–53, Online. Association for Computational Linguistics.   \n[59] Taylor Shin, Yasaman Razeghi, Robert L. Logan IV, Eric Wallace, and Sameer Singh. 2020. AutoPrompt: Eliciting knowledge from language models with automatically generated prompts. In EMNLP.   \n[60] Xujie Si, Yuan Yang, Hanjun Dai, Mayur Naik, and Le Song. 2019. Learning a meta-solver for syntax-guided program synthesis. In ICLR.   \n[61] Jake Snell, Kevin Swersky, and Richard Zemel. 2017. Prototypical networks for few-shot learning. In NeurIPS.   \n[62] Richard Socher, Alex Perelygin, Jean Wu, Jason Chuang, Christopher D. Manning, Andrew $\\mathrm { N g }$ , and Christopher Potts. 2013. Recursive Deep Models for Semantic Compositionality Over a Sentiment Treebank. In EMNLP.   \n[63] Irene Solaiman, Miles Brundage, Jack Clark, Amanda Askell, Ariel Herbert-Voss, Jeff Wu, Alec Radford, and Jasmine Wang. 2019. Release strategies and the social impacts of language models. CoRR, abs/1908.09203.   \n[64] Shengli Sun, Qingfeng Sun, Kevin Zhou, and Tengchao Lv. 2019. Hierarchical Attention Prototypical Networks for Few-Shot Text Classification. In EMNLP.   \n[65] Derek Tam, Rakesh R. Menon, Mohit Bansal, Shashank Srivastava, and Colin Raffel. 2021. Improving and simplifying pattern exploiting training. CoRR, abs/2103.11955.   \n[66] Erik F. Tjong Kim Sang and Fien De Meulder. 2003. Introduction to the CoNLL-2003 Shared Task: Language-Independent Named Entity Recognition. In Proceedings of the Seventh Conference on Natural Language Learning at HLT-NAACL 2003, pages 142–147.   \n[67] Eleni Triantafillou, Tyler Zhu, Vincent Dumoulin, Pascal Lamblin, Utku Evci, Kelvin Xu, Ross Goroshin, Carles Gelada, Kevin Swersky, Pierre-Antoine Manzagol, and Hugo Larochelle. 2020. Meta-Dataset: A Dataset of Datasets for Learning to Learn from Few Examples. In ICLR.   \n[68] Oriol Vinyals, Charles Blundell, Tim Lillicrap, Koray Kavukcuoglu, and Daan Wierstra. 2016. Matching networks for one shot learning. In Advances in Neural Information Processing Systems 29: Annual Conference on Neural Information Processing Systems 2016.   \n[69] Ellen M. Voorhees and Dawn M. Tice. 2000. Building a question answering test collection. In SIGIR.   \n[70] Alex Wang, Amanpreet Singh, Julian Michael, Felix Hill, Omer Levy, and Samuel R. Bowman. 2018. GLUE: A Multi-Task Benchmark and Analysis Platform for Natural Language Understanding. In ICLR.   \n[71] Yaqing Wang, Quanming Yao, James T. Kwok, and Lionel M. Ni. 2020. Generalizing from a Few Examples: A Survey on Few-shot Learning. ACM Computing Surveys, 53(3):63:1–63:34.   \n[72] Alex Warstadt, Amanpreet Singh, and Samuel R. Bowman. 2019. Neural Network Acceptability Judgments. TACL, 7:625–641.   \n[73] Orion Weller, Nicholas Lourie, Matt Gardner, and Matthew Peters. 2020. Learning from Task Descriptions. In EMNLP.   \n[74] Adina Williams, Nikita Nangia, and Samuel Bowman. 2018. A Broad-Coverage Challenge Corpus for Sentence Understanding through Inference. In NAACL.   \n[75] Qinyuan Ye, Bill Yuchen Lin, and Xiang Ren. 2021. CrossFit: A few-shot learning challenge for cross-task generalization in NLP. CoRR, abs/2104.08835.   \n[76] Wenpeng Yin. 2020. Meta-learning for few-shot natural language processing: A survey. CoRR, abs/2007.09604.   \n[77] Mo Yu, Xiaoxiao Guo, Jinfeng Yi, Shiyu Chang, Saloni Potdar, Yu Cheng, Gerald Tesauro, Haoyu Wang, and Bowen Zhou. 2018. Diverse Few-Shot Text Classification with Multiple Metrics. In NAACL.   \n[78] Tony Z. Zhao, Eric Wallace, Shi Feng, Dan Klein, and Sameer Singh. 2021. Calibrate before use: Improving few-shot performance of language models. CoRR, abs/2102.09690.   \n[79] Yanan Zheng, Jing Zhou, Yujie Qian, Ming Ding, Jian Li, Ruslan Salakhutdinov, Jie Tang, Sebastian Ruder, and Zhilin Yang. 2021. FewNLU: Benchmarking state-of-the-art methods for few-shot natural language understanding. CoRR, abs/2109.12742.   \n[80] Ruiqi Zhong, Kristy Lee, Zheng Zhang, and Dan Klein. 2021. Adapting language models for zero-shot learning by meta-tuning on dataset and prompt collections. CoRR, abs/2104.04670. ",
+        "bbox": [
+            173,
+            219,
+            826,
+            911
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            171,
+            42,
+            828,
+            915
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            171,
+            49,
+            828,
+            917
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            171,
+            85,
+            828,
+            823
+        ],
+        "page_idx": 13
+    }
+]

parse/train/piLPYqxtWuA/piLPYqxtWuA.md

@@ -0,0 +1,327 @@
+# FASTSPEECH 2: FAST AND HIGH-QUALITY END-TOEND TEXT TO SPEECH
+
+Yi Ren1∗, Chenxu $\mathbf { H } \mathbf { u } ^ { 1 }$ ∗, Xu Tan2, Tao $\mathbf { Q } \mathbf { i n } ^ { 2 }$ , Sheng Zhao3, Zhou Zhao1†, Tie-Yan Liu2
+
+1Zhejiang University {rayeren,chenxuhu,zhaozhou}@zju.edu.cn
+
+2Microsoft Research Asia {xuta,taoqin,tyliu}@microsoft.com
+
+3Microsoft Azure Speech Sheng.Zhao@microsoft.com
+
+# ABSTRACT
+
+Non-autoregressive text to speech (TTS) models such as FastSpeech (Ren et al., 2019) can synthesize speech significantly faster than previous autoregressive models with comparable quality. The training of FastSpeech model relies on an autoregressive teacher model for duration prediction (to provide more information as input) and knowledge distillation (to simplify the data distribution in output), which can ease the one-to-many mapping problem (i.e., multiple speech variations correspond to the same text) in TTS. However, FastSpeech has several disadvantages: 1) the teacher-student distillation pipeline is complicated and time-consuming, 2) the duration extracted from the teacher model is not accurate enough, and the target mel-spectrograms distilled from teacher model suffer from information loss due to data simplification, both of which limit the voice quality. In this paper, we propose FastSpeech 2, which addresses the issues in FastSpeech and better solves the one-to-many mapping problem in TTS by 1) directly training the model with ground-truth target instead of the simplified output from teacher, and 2) introducing more variation information of speech (e.g., pitch, energy and more accurate duration) as conditional inputs. Specifically, we extract duration, pitch and energy from speech waveform and directly take them as conditional inputs in training and use predicted values in inference. We further design FastSpeech 2s, which is the first attempt to directly generate speech waveform from text in parallel, enjoying the benefit of fully end-to-end inference. Experimental results show that 1) FastSpeech 2 achieves a 3x training speed-up over FastSpeech, and FastSpeech 2s enjoys even faster inference speed; 2) FastSpeech 2 and 2s outperform FastSpeech in voice quality, and FastSpeech 2 can even surpass autoregressive models. Audio samples are available at https://speechresearch.github.io/fastspeech2/.
+
+# 1 INTRODUCTION
+
+Neural network based text to speech (TTS) has made rapid progress and attracted a lot of attention in the machine learning and speech community in recent years (Wang et al., 2017; Shen et al., 2018; Ming et al., 2016; Arik et al., 2017; Ping et al., 2018; Ren et al., 2019; Li et al., 2019). Previous neural TTS models (Wang et al., 2017; Shen et al., 2018; Ping et al., 2018; Li et al., 2019) first generate mel-spectrograms autoregressively from text and then synthesize speech from the generated mel-spectrograms using a separately trained vocoder (Van Den Oord et al., 2016; Oord et al., 2017; Prenger et al., 2019; Kim et al., 2018; Yamamoto et al., 2020; Kumar et al.,
+
+2019). They usually suffer from slow inference speed and robustness (word skipping and repeating) issues (Ren et al., 2019; Chen et al., 2020). In recent years, non-autoregressive TTS models (Ren et al., 2019; Łancucki, 2020; Kim et al., 2020; Lim et al., 2020; Miao et al., 2020; Peng et al., 2019) ´ are designed to address these issues, which generate mel-spectrograms with extremely fast speed and avoid robustness issues, while achieving comparable voice quality with previous autoregressive models.
+
+Among those non-autoregressive TTS methods, FastSpeech (Ren et al., 2019) is one of the most successful models. FastSpeech designs two ways to alleviate the one-to-many mapping problem: 1) Reducing data variance in the target side by using the generated mel-spectrogram from an autoregressive teacher model as the training target (i.e., knowledge distillation). 2) Introducing the duration information (extracted from the attention map of the teacher model) to expand the text sequence to match the length of the mel-spectrogram sequence. While these designs in FastSpeech ease the learning of the one-to-many mapping problem (see Section 2.1) in TTS, they also bring several disadvantages: 1) The two-stage teacher-student training pipeline makes the training process complicated. 2) The target mel-spectrograms generated from the teacher model have some information loss1 compared with the ground-truth ones, since the quality of the audio synthesized from the generated mel-spectrograms is usually worse than that from the ground-truth ones. 3) The duration extracted from the attention map of teacher model is not accurate enough.
+
+In this work, we propose FastSpeech 2 to address the issues in FastSpeech and better handle the one-to-many mapping problem in non-autoregressive TTS. To simplify the training pipeline and avoid the information loss due to data simplification in teacher-student distillation, we directly train the FastSpeech 2 model with ground-truth target instead of the simplified output from a teacher. To reduce the information gap (input does not contain all the information to predict the target) between the input (text sequence) and target output (mel-spectrograms) and alleviate the one-to-many mapping problem for non-autoregressive TTS model training, we introduce some variation information of speech including pitch, energy and more accurate duration into FastSpeech: in training, we extract duration, pitch and energy from the target speech waveform and directly take them as conditional inputs; in inference, we use values predicted by the predictors that are jointly trained with the FastSpeech 2 model. Considering the pitch is important for the prosody of speech and is also difficult to predict due to the large fluctuations along time, we convert the pitch contour into pitch spectrogram using continuous wavelet transform (Tuteur, 1988; Grossmann & Morlet, 1984) and predict the pitch in the frequency domain, which can improve the accuracy of predicted pitch. To further simplify the speech synthesis pipeline, we introduce FastSpeech 2s, which does not use mel-spectrograms as intermediate output and directly generates speech waveform from text in inference, enjoying low latency in inference. Experiments on the LJSpeech (Ito, 2017) dataset show that 1) FastSpeech 2 enjoys much simpler training pipeline (3x training time reduction) than FastSpeech while inherits its advantages of fast, robust and controllable (even more controllable in pitch and energy) speech synthesis, and FastSpeech 2s enjoys even faster inference speed; 2) FastSpeech 2 and 2s outperform FastSpeech in voice quality, and FastSpeech 2 can even surpass autoregressive models. We attach audio samples generated by FastSpeech 2 and 2s at https://speechresearch.github.io/fastspeech2/.
+
+The main contributions of this work are summarized as follows:
+
+• FastSpeech 2 achieves a 3x training speed-up over FastSpeech by simplifying the training pipeline.   
+• FastSpeech 2 alleviates the one-to-many mapping problem in TTS and achieves better voice quality.   
+• FastSpeech 2s further simplifies the inference pipeline for speech synthesis while maintaining high voice quality, by directly generating speech waveform from text.
+
+# 2 FASTSPEECH 2 AND 2S
+
+In this section, we first describe the motivation of the design in FastSpeech 2, and then introduce the architecture of FastSpeech 2, which aims to improve FastSpeech to better handle the one-to
+
+![](images/c4eac523ab73b3722b1bf9ee27b2fe85770fe8eba476e2f0b528a407fa242280.jpg)  
+Figure 1: The overall architecture for FastSpeech 2 and 2s. LR in subfigure (b) denotes the length regulator proposed in FastSpeech. LN in subfigure (c) denotes layer normalization.
+
+many mapping problem, with simpler training pipeline and higher voice quality. At last, we extend FastSpeech 2 to FastSpeech 2s for fully end-to-end text-to-waveform synthesis2.
+
+# 2.1 MOTIVATION
+
+TTS is a typical one-to-many mapping problem (Wang et al., 2017; Zhu et al., 2017; Jayne et al., 2012; Gadermayr et al., 2020; Chen et al., 2021), since multiple possible speech sequences can correspond to a text sequence due to variations in speech, such as pitch, duration, sound volume and prosody. In non-autoregressive TTS, the only input information is text which is not enough to fully predict the variance in speech. In this case, the model is prone to overfit to the variations of the target speech in the training set, resulting in poor generalization ability. As mentioned in Section 1, although FastSpeech designs two ways to alleviate the one-to-many mapping problem, they also bring about several issues including 1) the complicated training pipeline; 2) information loss of target mel-spectrogram as analyzed in Table 1; and 3) not accurate enough ground-truth duration as shown in Table 5a. In the following subsection, we introduce the detailed design of FastSpeech 2 which aims to address these issues.
+
+# 2.2 MODEL OVERVIEW
+
+The overall model architecture of FastSpeech 2 is shown in Figure 1a. The encoder converts the phoneme embedding sequence into the phoneme hidden sequence, and then the variance adaptor adds different variance information such as duration, pitch and energy into the hidden sequence, finally the mel-spectrogram decoder converts the adapted hidden sequence into mel-spectrogram sequence in parallel. We use the feed-forward Transformer block, which is a stack of selfattention (Vaswani et al., 2017) layer and 1D-convolution as in FastSpeech (Ren et al., 2019), as the basic structure for the encoder and mel-spectrogram decoder. Different from FastSpeech that relies on a teacher-student distillation pipeline and the phoneme duration from a teacher model, FastSpeech 2 makes several improvements. First, we remove the teacher-student distillation pipeline, and directly use ground-truth mel-spectrograms as target for model training, which can avoid the information loss in distilled mel-spectrograms and increase the upper bound of the voice quality. Second, our variance adaptor consists of not only duration predictor but also pitch and energy predictors, where 1) the duration predictor uses the phoneme duration obtained by forced alignment (McAuliffe et al., 2017) as training target, which is more accurate than that extracted from the attention map of autoregressive teacher model as verified experimentally in Section 3.2.2; and 2) the additional pitch and energy predictors can provide more variance information, which is important to ease the one-to-many mapping problem in TTS. Third, to further simplify the training pipeline and push it towards a fully end-to-end system, we propose FastSpeech 2s, which directly generates waveform from text, without cascaded mel-spectrogram generation (acoustic model) and waveform generation (vocoder). In the following subsections, we describe detailed designs of the variance adaptor and direct waveform generation in our method.
+
+# 2.3 VARIANCE ADAPTOR
+
+The variance adaptor aims to add variance information (e.g., duration, pitch, energy, etc.) to the phoneme hidden sequence, which can provide enough information to predict variant speech for the one-to-many mapping problem in TTS. We briefly introduce the variance information as follows: 1) phoneme duration, which represents how long the speech voice sounds; 2) pitch, which is a key feature to convey emotions and greatly affects the speech prosody; 3) energy, which indicates framelevel magnitude of mel-spectrograms and directly affects the volume and prosody of speech. More variance information can be added in the variance adaptor, such as emotion, style and speaker, and we leave it for future work. Correspondingly, the variance adaptor consists of 1) a duration predictor (i.e., the length regulator, as used in FastSpeech), 2) a pitch predictor, and 3) an energy predictor, as shown in Figure 1b. In training, we take the ground-truth value of duration, pitch and energy extracted from the recordings as input into the hidden sequence to predict the target speech. At the same time, we use the ground-truth duration, pitch and energy as targets to train the duration, pitch and energy predictors, which are used in inference to synthesize target speech. As shown in Figure 1c, the duration, pitch and energy predictors share similar model structure (but different model parameters), which consists of a 2-layer 1D-convolutional network with ReLU activation, each followed by the layer normalization and the dropout layer, and an extra linear layer to project the hidden states into the output sequence. In the following paragraphs, we describe the details of the three predictors respectively.
+
+Duration Predictor The duration predictor takes the phoneme hidden sequence as input and predicts the duration of each phoneme, which represents how many mel frames correspond to this phoneme, and is converted into logarithmic domain for ease of prediction. The duration predictor is optimized with mean square error (MSE) loss, taking the extracted duration as training target. Instead of extracting the phoneme duration using a pre-trained autoregressive TTS model in FastSpeech, we use Montreal forced alignment (MFA) (McAuliffe et al., 2017) tool3 to extract the phoneme duration, in order to improve the alignment accuracy and thus reduce the information gap between the model input and output.
+
+Pitch Predictor Previous neural network based TTS systems with pitch prediction (Arik et al., 2017; Gibiansky et al., 2017) often predict pitch contour directly. However, due to high variations of ground-truth pitch, the distribution of predicted pitch values is very different from ground-truth distribution, as analyzed in Section 3.2.2. To better predict the variations in pitch contour, we use continuous wavelet transform (CWT) to decompose the continuous pitch series into pitch spectrogram (Suni et al., 2013; Hirose & Tao, 2015) and take the pitch spectrogram as the training target for the pitch predictor which is optimized with MSE loss. In inference, the pitch predictor predicts the pitch spectrogram, which is further converted back into pitch contour using inverse continuous wavelet transform (iCWT). We describe the details of pitch extraction, CWT, iCWT and pitch predictor architecture in Appendix D. To take the pitch contour as input in both training and inference, we quantize pitch $F _ { 0 }$ (ground-truth/predicted value for train/inference respectively) of each frame to 256 possible values in log-scale and further convert it into pitch embedding vector $p$ and add it to the expanded hidden sequence.
+
+Energy Predictor We compute L2-norm of the amplitude of each short-time Fourier transform (STFT) frame as the energy. Then we quantize energy of each frame to 256 possible values uniformly, encoded it into energy embedding $e$ and add it to the expanded hidden sequence similarly to pitch. We use an energy predictor to predict the original values of energy instead of the quantized values and optimize the energy predictor with MSE loss4.
+
+# 2.4 FASTSPEECH 2S
+
+To enable fully end-to-end text-to-waveform generation, in this subsection, we extend FastSpeech 2 to FastSpeech 2s, which directly generates waveform from text, without cascaded mel-spectrogram generation (acoustic model) and waveform generation (vocoder). As shown in Figure 1a, FastSpeech 2s generates waveform conditioning on intermediate hidden, which makes it more compact in inference by discarding mel-spectrogram decoder and achieve comparable performance with a cascaded system. We first discuss the challenges in non-autoregressive text-to-waveform generation, then describe details of FastSpeech 2s, including model structure and training and inference processes.
+
+Challenges in Text-to-Waveform Generation When pushing TTS pipeline towards fully endto-end framework, there are several challenges: 1) Since the waveform contains more variance information (e.g., phase) than mel-spectrograms, the information gap between the input and output is larger than that in text-to-spectrogram generation. 2) It is difficult to train on the audio clip that corresponds to the full text sequence due to the extremely long waveform samples and limited GPU memory. As a result, we can only train on a short audio clip that corresponds to a partial text sequence which makes it hard for the model to capture the relationship among phonemes in different partial text sequences and thus harms the text feature extraction.
+
+Our Method To tackle the challenges above, we make several designs in the waveform decoder: 1) Considering that the phase information is difficult to predict using a variance predictor (Engel et al., 2020), we introduce adversarial training in the waveform decoder to force it to implicitly recover the phase information by itself (Yamamoto et al., 2020). 2) We leverage the mel-spectrogram decoder of FastSpeech 2, which is trained on the full text sequence to help on the text feature extraction. As shown in Figure 1d, the waveform decoder is based on the structure of WaveNet (Van Den Oord et al., 2016) including non-causal convolutions and gated activation (Van den Oord et al., 2016). The waveform decoder takes a sliced hidden sequence corresponding to a short audio clip as input and upsamples it with transposed 1D-convolution to match the length of audio clip. The discriminator in the adversarial training adopts the same structure in Parallel WaveGAN (Yamamoto et al., 2020) which consists of ten layers of non-causal dilated 1-D convolutions with leaky ReLU activation function. The waveform decoder is optimized by the multi-resolution STFT loss and the LSGAN discriminator loss following Parallel WaveGAN. In inference, we discard the mel-spectrogram decoder and only use the waveform decoder to synthesize speech audio.
+
+# 2.5 DISCUSSIONS
+
+In this subsection, we discuss how FastSpeech 2 and 2s differentiate from previous and concurrent works.
+
+Compared with Deep Voice (Arik et al., 2017), Deep Voice 2 (Gibiansky et al., 2017) and other methods Fan et al. (2014); Ze et al. (2013) which generate waveform autoregressively and also predict variance information such as duration and pitch, Fastspeech 2 and 2s adopt self-attention based feed-forward network to generate mel-spectrograms or waveform in parallel. While some existing non-autoregressive acoustic models (Zeng et al., 2020; Lim et al., 2020; Kim et al., 2020) mostly focus on improving the duration accuracy, FastSpeech 2 and 2s provide more variation information (duration, pitch and energy) as inputs to reduce the information gap between the input and output. A concurrent work (Łancucki, 2020) employs pitch prediction in phoneme level, while FastSpeech 2 ´ and 2s predict more fine-grained pitch contour in frame level. In addition, to improve the prosody in synthesized speech, FastSpeech 2 and 2s further introduce continuous wavelet transform to model the variations in pitch.
+
+While some text-to-waveform models such as ClariNet (Ping et al., 2019) jointly train an autoregressive acoustic model and a non-autoregressive vocoder, FastSpeech 2s embraces the fully nonautoregressive architecture for fast inference. A concurrent work called EATS (Donahue et al., 2020)
+
+also employs non-autoregressive architecture and adversarial training to convert text to waveform directly and mainly focuses on predicting the duration of each phoneme end-to-end using a differentiable monotonic interpolation scheme. Compared with EATS, FastSpeech 2s additionally provides more variation information to ease the one-to-many mapping problem in TTS.
+
+Previous non-autoregressive vocoders (Oord et al., 2017; Prenger et al., 2019; Yamamoto et al., 2020; Kumar et al., 2019) are not complete text-to-speech systems, since they convert time aligned linguistic features to waveforms, and require a separate linguistic model to convert input text to linguistic features or an acoustic model to convert input text to acoustic features (e.g., melspectrograms). FastSpeech 2s is the first attempt to directly generate waveform from phoneme sequence fully in parallel, instead of linguistic features or mel-spectrograms.
+
+# 3 EXPERIMENTS AND RESULTS
+
+# 3.1 EXPERIMENTAL SETUP
+
+Datasets We evaluate FastSpeech 2 and 2s on LJSpeech dataset (Ito, 2017). LJSpeech contains 13,100 English audio clips (about 24 hours) and corresponding text transcripts. We split the dataset into three sets: 12,228 samples for training, 349 samples (with document title LJ003) for validation and 523 samples (with document title LJ001 and LJ002) for testing. For subjective evaluation, we randomly choose 100 samples in test set. To alleviate the mispronunciation problem, we convert the text sequence into the phoneme sequence (Arik et al., 2017; Wang et al., 2017; Shen et al., 2018; Sun et al., 2019) with an open-source grapheme-to-phoneme tool5. We transform the raw waveform into mel-spectrograms following Shen et al. (2018) and set frame size and hop size to 1024 and 256 with respect to the sample rate 22050.
+
+Model Configuration Our FastSpeech 2 consists of 4 feed-forward Transformer (FFT) blocks (Ren et al., 2019) in the encoder and the mel-spectrogram decoder. The output linear layer in the decoder converts the hidden states into 80-dimensional mel-spectrograms and our model is optimized with mean absolute error (MAE). We add more detailed configurations of FastSpeech 2 and 2s used in our experiments in Appendix A. The details of training and inference are added in Appendix B.
+
+# 3.2 RESULTS
+
+<table><tr><td>Method</td><td>CMOS</td></tr><tr><td>FastSpeech 2</td><td>一 0.000</td></tr><tr><td>FastSpeech Transformer TTS</td><td>-0.885 -0.235</td></tr></table>
+
+Table 1: Audio quality comparison.   
+
+<table><tr><td>Method</td><td>MOS</td></tr><tr><td>GT</td><td>4.30± 0.07</td></tr><tr><td>GT (Mel + PWG)</td><td>3.92 ± 0.08</td></tr><tr><td>Tacotron 2 (Shen et al.,2018) (Mel + PWG)</td><td>3.70± 0.08</td></tr><tr><td>Transformer TTS (Li et al.,2019) (Mel + PWG)</td><td>3.72 ± 0.07</td></tr><tr><td>FastSpeech (Ren et al.,2019) (Mel + PWG)</td><td>3.68± 0.09</td></tr><tr><td>FastSpeech 2 (Mel + PWG)</td><td>3.83 ± 0.08</td></tr><tr><td>FastSpeech 2s</td><td>3.71 ± 0.09</td></tr></table>
+
+(a) The MOS with $9 5 \%$ confidence intervals.
+
+(b) CMOS comparison.
+
+In this section, we first evaluate the audio quality, training and inference speedup of FastSpeech 2 and 2s. Then we conduct analyses and ablation studies of our method6.
+
+# 3.2.1 MODEL PERFORMANCE
+
+Audio Quality To evaluate the perceptual quality, we perform mean opinion score (MOS) (Chu & Peng, 2006) evaluation on the test set. Twenty native English speakers are asked to make quality judgments about the synthesized speech samples. The text content keeps consistent among different systems so that all testers only examine the audio quality without other interference factors. We compare the MOS of the audio samples generated by FastSpeech 2 and FastSpeech $2 s$ with other systems, including 1) $G T .$ , the ground-truth recordings; 2) GT $( M e l + P W G )$ ), where we first convert the ground-truth audio into mel-spectrograms, and then convert the mel-spectrograms back to audio using Parallel WaveGAN (Yamamoto et al., 2020) (PWG); 3) Tacotron 2 (Shen et al., 2018) $( M e l + P W G )$ ; 4) Transformer TTS (Li et al., 2019) $( M e l + P W G )$ ; 5) FastSpeech (Ren et al., 2019) $( M e l + P W G )$ . All the systems in 3), 4) and 5) use Parallel WaveGAN as the vocoder for a fair comparison. The results are shown in Table 1. It can be seen that FastSpeech 2 can surpass and FastSpeech 2s can match the voice quality of autoregressive models Transformer TTS and Tacotron 2. Importantly, FastSpeech 2 outperforms FastSpeech, which demonstrates the effectiveness of providing variance information such as pitch, energy and more accurate duration and directly taking ground-truth speech as training target without using teacher-student distillation pipeline.
+
+Table 2: The comparison of training time and inference latency in waveform synthesis. The training time of FastSpeech includes teacher and student training. RTF denotes the real-time factor, that is the time (in seconds) required for the system to synthesize one second waveform. The training and inference latency tests are conducted on a server with 36 Intel Xeon CPUs, 256GB memory, 1 NVIDIA V100 GPU and batch size of 48 for training and 1 for inference. Besides, we do not include the time of GPU memory garbage collection and transferring input and output data between the CPU and the GPU. The speedup in waveform synthesis for FastSpeech is larger than that reported in Ren et al. (2019) since we use Parallel WaveGAN as the vocoder which is much faster than WaveGlow.   
+
+<table><tr><td>Method</td><td>Training Time (h)</td><td>Inference Speed (RTF)</td><td>Inference Speedup</td></tr><tr><td>Transformer TTS (Li et al.,2019)</td><td>38.64</td><td>9.32 × 10-1</td><td>/</td></tr><tr><td>FastSpeech (Ren et al.,2019)</td><td>53.12</td><td>1.92 × 10-2</td><td>48.5×</td></tr><tr><td>FastSpeech 2</td><td>17.02</td><td>1.95 × 10-2</td><td>47.8×</td></tr><tr><td>FastSpeech 2s</td><td>92.18</td><td>1.80 × 10-2</td><td>51.8×</td></tr></table>
+
+Training and Inference Speedup FastSpeech 2 simplifies the training pipeline of FastSpeech by removing the teacher-student distillation process, and thus reduces the training time. We list the total training time of Transformer TTS (the autoregressive teacher model), FastSpeech (including the training of Transformer TTS teacher model and FastSpeech student model) and FastSpeech 2 in Table 2. It can be seen that FastSpeech 2 reduces the total training time by $3 . 1 2 \times$ compared with FastSpeech. Note that training time here only includes acoustic model training, without considering the vocoder training. Therefore, we do not compare the training time of FastSpeech 2s here. We then evaluate the inference latency of FastSpeech 2 and 2s compared with the autoregressive Transformer TTS model, which has the similar number of model parameters with FastSpeech 2 and 2s. We show the inference speedup for waveform generation in Table 2. It can be seen that compared with the Transformer TTS model, FastSpeech 2 and 2s speeds up the audio generation by $4 7 . 8 \times$ and $5 1 . 8 \times$ respectively in waveform synthesis. We can also see that FastSpeech 2s is faster than FastSpeech 2 due to fully end-to-end generation.
+
+3.2.2 ANALYSES ON VARIANCE INFORMATION   
+
+<table><tr><td>Method</td><td>9</td><td>Y</td><td>K</td><td>DTW</td></tr><tr><td>GT</td><td>54.4</td><td>0.836</td><td>0.977</td><td>/</td></tr><tr><td>Tacotron 2</td><td>44.1</td><td>1.28</td><td>1.311</td><td>26.32</td></tr><tr><td>TransformerTTS</td><td>40.8</td><td>0.703</td><td>1.419</td><td>24.40</td></tr><tr><td>FastSpeech</td><td>50.8</td><td>0.724</td><td>-0.041</td><td>24.89</td></tr><tr><td>FastSpeech 2</td><td>54.1</td><td>0.881</td><td>0.996</td><td>24.39</td></tr><tr><td>FastSpeech 2 - CWT</td><td>42.3</td><td>0.771</td><td>1.115</td><td>25.13</td></tr><tr><td>FastSpeech 2s</td><td>53.9</td><td>0.872</td><td>0.998</td><td>24.37</td></tr></table>
+
+Table 3: Standard deviation $( \sigma )$ , skewness $( \gamma )$ , kurtosis $( \kappa )$ and average DTW distances (DTW) of pitch in ground-truth and synthesized audio.
+
+More Accurate Variance Information in Synthesized Speech In the paragraph, we measure if providing more variance information (e.g., pitch and energy) as input in FastSpeech 2 and 2s can indeed synthesize speech with more accurate pitch and energy.
+
+For pitch, we compute the moments (standard deviation $( \sigma )$ , skewness $( \gamma )$ and kurtosis $( \kappa )$ ) (Andreeva et al., 2014; Niebuhr & Skarnitzl, 2019) and average dynamic time warping (DTW) Muller ¨ (2007) distance of the pitch distribution for the ground-truth speech and synthesized speech. The results are shown in Table 3. It can be seen that compared with FastSpeech, the moments $( \sigma , \gamma$ and $\kappa$ ) of generated audio of FastSpeech 2/2s are more close to the ground-truth audio and the average DTW distances to the ground-truth pitch are smaller than other methods, demonstrating that FastSpeech 2/2s can generate speech with more natural pitch contour (which can result in better prosody) than FastSpeech. We also conduct a case study on generated pitch contours in Appendix D.
+
+<table><tr><td></td><td></td><td></td><td>Method|FastSpeech |FastSpeech 2|FastSpeech 2s</td></tr><tr><td>MAE</td><td>0.142</td><td>0.131</td><td>0.133</td></tr></table>
+
+Table 4: The mean absolute error (MAE) of the energy in synthesized speech audio.
+
+For energy, we compute the mean absolute error (MAE) between the frame-wise energy extracted from the generated waveform and the ground-truth speech. To ensure that the numbers of frames in the synthesized and ground-truth speech are the same, we use the ground-truth duration extracted by MFA in both FastSpeech and FastSpeech 2. The results are shown in Table 4. We can see that the MAE of the energy for FastSpeech 2/2s are smaller than that for FastSpeech, indicating that they both synthesize speech audio with more similar energy to the ground-truth audio.
+
+More Accurate Duration for Model Training We then analyze the accuracy of the provided duration information to train the duration predictor and the effectiveness of more accurate duration for better voice quality based on FastSpeech. We manually align 50 audio generated by the teacher model and the corresponding text in phoneme level and get the ground-truth phoneme-level duration. We compute the average of absolute phoneme boundary differences (McAuliffe et al., 2017) using the duration from the teacher model of FastSpeech and from MFA as used in this paper respectively. The results are shown in Table 5a. We can see that MFA can generate more accurate duration than the teacher model of FastSpeech. Next, we replace the duration used in FastSpeech (from teacher model) with that extracted by MFA, and conduct the CMOS (Loizou, 2011) test to compare the voice quality between the two FastSpeech models trained with different durations7. The results are listed in Table 5b and it can be seen that more accurate duration information improves the voice quality of FastSpeech, which verifies the effectiveness of our improved duration from MFA.
+
+<table><tr><td>Method</td><td>△(ms)</td></tr><tr><td>Duration from teacher model</td><td>19.68</td></tr><tr><td>Duration from MFA</td><td>12.47</td></tr></table>
+
+<table><tr><td>Setting</td><td>CMOS</td></tr><tr><td>FastSpeech + Duration from teacher</td><td>0</td></tr><tr><td>FastSpeech + Duration from MFA</td><td>+0.195</td></tr></table>
+
+(a) Alignment accuracy comparison.
+
+(b) CMOS comparison.
+
+Table 5: The comparison of the duration from teacher model and MFA. $\Delta$ means the average of absolute boundary differences.
+
+# 3.2.3 ABLATION STUDY
+
+Pitch and Energy Input We conduct ablation studies to demonstrate the effectiveness of several variance information of FastSpeech 2 and 2s, including pitch and energy8. We conduct CMOS evaluation for these ablation studies. The results are shown in Table 6. We find that removing the energy (Row 3 in both subtables) in FastSpeech 2 and 2s results in performance drop in terms of voice quality (-0.040 and -0.160 CMOS respectively), indicating that energy is effective for FastSpeech 2 in improving the voice quality, and more effective for FastSpeech 2s. We also find that removing the pitch (Row 4 in both subtables) in FastSpeech 2 and 2s results in -0.245 and -1.130 CMOS respectively, which demonstrates the effectiveness of pitch. When we remove both pitch and energy (the last row in both subtables), the voice quality further drops, indicating that both pitch and energy can help improve the performance of FastSpeech 2 and 2s.
+
+Predicting Pitch in Frequency Domain To study the effectiveness of predicting pitch in frequency domain using continuous wavelet transform (CWT) as described in Section 2.3, we directly fit the pitch contour with mean square error like energy in FastSpeech 2 and 2s. We conduct CMOS evaluation and get CMOS drops of 0.185 and 0.201 for FastSpeech 2 and 2s respectively. We also compute the moments of pitch and average DTW distance to the ground-truth pitch as shown in row 6 (denoeted as FastSpeech $2 \cdot C W T$ ) in Table 3. The results demonstrate that CWT can help model the pitch better and improve the prosody of synthesized speech, and thus obtaining better CMOS score.
+
+Mel-Spectrogram Decoder in FastSpeech 2s To verify the effectiveness of the mel-spectrogram decoder in FastSpeech 2s on text feature extraction as described in Section 2.4, we remove the mel-spectrogram decoder and conduct CMOS evaluation. It causes a 0.285 CMOS drop, which demonstrates that the mel-spectrogram decoder is essential to high-quality waveform generation.
+
+Table 6: CMOS comparison in the ablation studies.   
+
+<table><tr><td>Setting</td><td>CMOS</td></tr><tr><td>FastSpeech 2</td><td>0</td></tr><tr><td>FastSpeech 2 - energy</td><td>-0.040</td></tr><tr><td>FastSpeech2-pitch</td><td>-0.245</td></tr><tr><td>FastSpeech 2-pitch -energy</td><td>-0.370</td></tr></table>
+
+<table><tr><td>Setting</td><td>CMOS</td></tr><tr><td>FastSpeech 2s</td><td>0</td></tr><tr><td>FastSpeech 2s - energy</td><td>-0.160</td></tr><tr><td>FastSpeech 2s-pitch</td><td>-1.130</td></tr><tr><td>FastSpeech 2s-pitch -energy</td><td>-1.355</td></tr></table>
+
+(b) CMOS comparison for FastSpeech 2s.
+
+(a) CMOS comparison for FastSpeech 2.
+
+# 4 CONCLUSION
+
+In this work, we proposed FastSpeech 2, a fast and high-quality end-to-end TTS system, to address the issues in FastSpeech and ease the one-to-many mapping problem: 1) we directly train the model with ground-truth mel-spectrograms to simplify the training pipeline and also avoid information loss compared with FastSpeech; and 2) we improve the duration accuracy and introduce more variance information including pitch and energy to ease the one-to-many mapping problem, and improve pitch prediction by introducing continuous wavelet transform. Moreover, based on FastSpeech 2, we further developed FastSpeech 2s, a non-autoregressive text-to-waveform generation model, which enjoys the benefit of fully end-to-end inference and achieves faster inference speed. Our experimental results show that FastSpeech 2 and 2s outperform FastSpeech, and FastSpeech 2 can even surpass autoregressive models in terms of voice quality, with much simpler training pipeline while inheriting the advantages of fast, robust and controllable speech synthesis of FastSpeech.
+
+High quality, fast and fully end-to-end training without any external libraries is definitely the ultimate goal of neural TTS and also a very challenging problem. To ensure high quality of FastSpeech 2, we use an external high-performance alignment tool and pitch extraction tools, which may seem a little complicated, but are very helpful for high-quality and fast speech synthesis. We believe there will be more simpler solutions to achieve this goal in the future and we will certainly work on fully end-to-end TTS without external alignment models and tools. We will also consider more variance information (Zhang et al., 2021) to further improve the voice quality and speed up the inference with more light-weight model (Luo et al., 2021).
+
+# ACKNOWLEDGMENTS
+
+This work was supported in part by the National Key R&D Program of China (Grant No.2018AAA0100603), National Natural Science Foundation of China (Grant No.62072397), Zhejiang Natural Science Foundation (Grant No.LR19F020006), National Natural Science Foundation of China (Grant No.61836002) and X Lab, the Second Academy of CASIC, Beijing, 100854, China.
+
+# REFERENCES
+
+Bistra Andreeva, Grazyna Demenko, Bernd M ˙ obius, Frank Zimmerer, Jeanin J ¨ ugler, and Magdalena ¨ Oleskowicz-Popiel. Differences of pitch profiles in germanic and slavic languages. In Fifteenth Annual Conference of the International Speech Communication Association, 2014.
+
+Sercan O Arik, Mike Chrzanowski, Adam Coates, Gregory Diamos, Andrew Gibiansky, Yongguo Kang, Xian Li, John Miller, Andrew Ng, Jonathan Raiman, et al. Deep voice: Real-time neural text-to-speech. arXiv preprint arXiv:1702.07825, 2017.
+
+Mingjian Chen, Xu Tan, Yi Ren, Jin Xu, Hao Sun, Sheng Zhao, and Tao Qin. Multispeech: Multispeaker text to speech with transformer. In INTERSPEECH, pp. 4024–4028, 2020.
+
+Mingjian Chen, Xu Tan, Bohan Li, Yanqing Liu, Tao Qin, sheng zhao, and Tie-Yan Liu. Adaspeech: Adaptive text to speech for custom voice. In International Conference on Learning Representations, 2021. URL https://openreview.net/forum?id $\underline { { \underline { { \mathbf { \Pi } } } } } =$ Drynvt7gg4L.
+
+Min Chu and Hu Peng. Objective measure for estimating mean opinion score of synthesized speech, April 4 2006. US Patent 7,024,362.
+
+Jeff Donahue, Sander Dieleman, Mikołaj Binkowski, Erich Elsen, and Karen Simonyan. End-to-end ´ adversarial text-to-speech. arXiv preprint arXiv:2006.03575, 2020.
+
+Jesse Engel, Lamtharn Hantrakul, Chenjie Gu, and Adam Roberts. Ddsp: Differentiable digital signal processing. arXiv preprint arXiv:2001.04643, 2020.
+
+Yuchen Fan, Yao Qian, Feng-Long Xie, and Frank K Soong. Tts synthesis with bidirectional lstm based recurrent neural networks. In Fifteenth Annual Conference of the International Speech Communication Association, 2014.
+
+Michael Gadermayr, Maximilian Tschuchnig, Dorit Merhof, Nils Kramer, Daniel Truhn, and ¨ Burkhard Gess. An asymetric cycle-consistency loss for dealing with many-to-one mappings in image translation: A study on thigh mr scans. arXiv preprint arXiv:2004.11001, 2020.
+
+Andrew Gibiansky, Sercan Arik, Gregory Diamos, John Miller, Kainan Peng, Wei Ping, Jonathan Raiman, and Yanqi Zhou. Deep voice 2: Multi-speaker neural text-to-speech. In Advances in neural information processing systems, pp. 2962–2970, 2017.
+
+Alexander Grossmann and Jean Morlet. Decomposition of hardy functions into square integrable wavelets of constant shape. SIAM journal on mathematical analysis, 15(4):723–736, 1984.
+
+Keikichi Hirose and Jianhua Tao. Speech Prosody in Speech Synthesis: Modeling and generation of prosody for high quality and flexible speech synthesis. Springer, 2015.
+
+Keith Ito. The lj speech dataset. https://keithito.com/LJ-Speech-Dataset/, 2017.
+
+Chrisina Jayne, Andreas Lanitis, and Chris Christodoulou. One-to-many neural network mapping techniques for face image synthesis. Expert Systems with Applications, 39(10):9778–9787, 2012.
+
+Jaehyeon Kim, Sungwon Kim, Jungil Kong, and Sungroh Yoon. Glow-tts: A generative flow for text-to-speech via monotonic alignment search. arXiv preprint arXiv:2005.11129, 2020.
+
+Sungwon Kim, Sang-gil Lee, Jongyoon Song, Jaehyeon Kim, and Sungroh Yoon. Flowavenet: A generative flow for raw audio. arXiv preprint arXiv:1811.02155, 2018.
+
+Diederik P Kingma and Jimmy Ba. Adam: A method for stochastic optimization. arXiv preprint arXiv:1412.6980, 2014.
+
+Kundan Kumar, Rithesh Kumar, Thibault de Boissiere, Lucas Gestin, Wei Zhen Teoh, Jose Sotelo, Alexandre de Brebisson, Yoshua Bengio, and Aaron C Courville. Melgan: Generative adversarial´ networks for conditional waveform synthesis. In Advances in Neural Information Processing Systems, pp. 14881–14892, 2019.
+
+Adrian Łancucki. Fastpitch: Parallel text-to-speech with pitch prediction. ´ arXiv preprint arXiv:2006.06873, 2020.
+
+Naihan Li, Shujie Liu, Yanqing Liu, Sheng Zhao, and Ming Liu. Neural speech synthesis with transformer network. In Proceedings of the AAAI Conference on Artificial Intelligence, volume 33, pp. 6706–6713, 2019.
+
+Dan Lim, Won Jang, Hyeyeong Park, Bongwan Kim, Jesam Yoon, et al. Jdi-t: Jointly trained duration informed transformer for text-to-speech without explicit alignment. arXiv preprint arXiv:2005.07799, 2020.
+
+Philipos C Loizou. Speech quality assessment. In Multimedia analysis, processing and communications, pp. 623–654. Springer, 2011.
+
+Renqian Luo, Xu Tan, Rui Wang, Tao Qin, Jinzhu Li, Sheng Zhao, Enhong Chen, and Tie-Yan Liu. Lightspeech: Lightweight and fast text to speech with neural architecture search. In 2021 IEEE International Conference on Acoustics, Speech and Signal Processing (ICASSP). IEEE, 2021.
+
+Michael McAuliffe, Michaela Socolof, Sarah Mihuc, Michael Wagner, and Morgan Sonderegger. Montreal forced aligner: Trainable text-speech alignment using kaldi. In Interspeech, pp. 498– 502, 2017.
+
+Chenfeng Miao, Shuang Liang, Minchuan Chen, Jun Ma, Shaojun Wang, and Jing Xiao. Flowtts: A non-autoregressive network for text to speech based on flow. In ICASSP 2020-2020 IEEE International Conference on Acoustics, Speech and Signal Processing (ICASSP), pp. 7209–7213. IEEE, 2020.
+
+Huaiping Ming, Dongyan Huang, Lei Xie, Jie Wu, Minghui Dong, and Haizhou Li. Deep bidirectional lstm modeling of timbre and prosody for emotional voice conversion. 2016.
+
+Meinard Muller. Dynamic time warping. ¨ Information retrieval for music and motion, pp. 69–84, 2007.
+
+Oliver Niebuhr and Radek Skarnitzl. Measuring a speaker’s acoustic correlates of pitch–but which? a contrastive analysis based on perceived speaker charisma. In Proceedings of 19th International Congress of Phonetic Sciences, 2019.
+
+Aaron van den Oord, Yazhe Li, Igor Babuschkin, Karen Simonyan, Oriol Vinyals, Koray Kavukcuoglu, George van den Driessche, Edward Lockhart, Luis C Cobo, Florian Stimberg, et al. Parallel wavenet: Fast high-fidelity speech synthesis. arXiv preprint arXiv:1711.10433, 2017.
+
+Kainan Peng, Wei Ping, Zhao Song, and Kexin Zhao. Parallel neural text-to-speech. arXiv preprint arXiv:1905.08459, 2019.
+
+Wei Ping, Kainan Peng, Andrew Gibiansky, Sercan O. Arik, Ajay Kannan, Sharan Narang, Jonathan Raiman, and John Miller. Deep voice 3: 2000-speaker neural text-to-speech. In International Conference on Learning Representations, 2018.
+
+Wei Ping, Kainan Peng, and Jitong Chen. Clarinet: Parallel wave generation in end-to-end text-tospeech. In International Conference on Learning Representations, 2019.
+
+Ryan Prenger, Rafael Valle, and Bryan Catanzaro. Waveglow: A flow-based generative network for speech synthesis. In ICASSP 2019-2019 IEEE International Conference on Acoustics, Speech and Signal Processing (ICASSP), pp. 3617–3621. IEEE, 2019.
+
+Yi Ren, Yangjun Ruan, Xu Tan, Tao Qin, Sheng Zhao, Zhou Zhao, and Tie-Yan Liu. Fastspeech: Fast, robust and controllable text to speech. In Advances in Neural Information Processing Systems, pp. 3165–3174, 2019.
+
+Harold Ryan. Ricker, ormsby; klander, bntterwo-a choice of wavelets, 1994.
+
+Jonathan Shen, Ruoming Pang, Ron J Weiss, Mike Schuster, Navdeep Jaitly, Zongheng Yang, Zhifeng Chen, Yu Zhang, Yuxuan Wang, Rj Skerrv-Ryan, et al. Natural tts synthesis by conditioning wavenet on mel spectrogram predictions. In 2018 IEEE International Conference on Acoustics, Speech and Signal Processing (ICASSP), pp. 4779–4783. IEEE, 2018.
+
+Hao Sun, Xu Tan, Jun-Wei Gan, Hongzhi Liu, Sheng Zhao, Tao Qin, and Tie-Yan Liu. Token-level ensemble distillation for grapheme-to-phoneme conversion. In INTERSPEECH, 2019.
+
+Antti Santeri Suni, Daniel Aalto, Tuomo Raitio, Paavo Alku, Martti Vainio, et al. Wavelets for intonation modeling in hmm speech synthesis. In 8th ISCA Workshop on Speech Synthesis, Proceedings, Barcelona, August 31-September 2, 2013. ISCA, 2013.
+
+Franz B Tuteur. Wavelet transformations in signal detection. IFAC Proceedings Volumes, 21(9): 1061–1065, 1988.
+
+Aaron Van Den Oord, Sander Dieleman, Heiga Zen, Karen Simonyan, Oriol Vinyals, Alex Graves, ¨ Nal Kalchbrenner, Andrew W Senior, and Koray Kavukcuoglu. Wavenet: A generative model for raw audio. SSW, 125, 2016.
+
+Aaron Van den Oord, Nal Kalchbrenner, Lasse Espeholt, Oriol Vinyals, Alex Graves, et al. Conditional image generation with pixelcnn decoders. In Advances in neural information processing systems, pp. 4790–4798, 2016.
+
+Ashish Vaswani, Noam Shazeer, Niki Parmar, Jakob Uszkoreit, Llion Jones, Aidan N Gomez, Łukasz Kaiser, and Illia Polosukhin. Attention is all you need. In Advances in Neural Information Processing Systems, pp. 5998–6008, 2017.
+
+Yuxuan Wang, RJ Skerry-Ryan, Daisy Stanton, Yonghui Wu, Ron J Weiss, Navdeep Jaitly, Zongheng Yang, Ying Xiao, Zhifeng Chen, Samy Bengio, et al. Tacotron: Towards end-to-end speech synthesis. arXiv preprint arXiv:1703.10135, 2017.
+
+Ryuichi Yamamoto, Eunwoo Song, and Jae-Min Kim. Parallel wavegan: A fast waveform generation model based on generative adversarial networks with multi-resolution spectrogram. In ICASSP 2020-2020 IEEE International Conference on Acoustics, Speech and Signal Processing (ICASSP), pp. 6199–6203. IEEE, 2020.
+
+Heiga Ze, Andrew Senior, and Mike Schuster. Statistical parametric speech synthesis using deep neural networks. In 2013 ieee international conference on acoustics, speech and signal processing, pp. 7962–7966. IEEE, 2013.
+
+Zhen Zeng, Jianzong Wang, Ning Cheng, Tian Xia, and Jing Xiao. Aligntts: Efficient feed-forward text-to-speech system without explicit alignment. In ICASSP 2020-2020 IEEE International Conference on Acoustics, Speech and Signal Processing (ICASSP), pp. 6714–6718. IEEE, 2020.
+
+Chen Zhang, Yi Ren, Xu Tan, Jinglin Liu, Kejun Zhang, Tao Qin, Sheng Zhao, and Tie-Yan Liu. Denoispeech: Denoising text to speech with frame-level noise modeling. In 2021 IEEE International Conference on Acoustics, Speech and Signal Processing (ICASSP). IEEE, 2021.
+
+Jun-Yan Zhu, Richard Zhang, Deepak Pathak, Trevor Darrell, Alexei A Efros, Oliver Wang, and Eli Shechtman. Toward multimodal image-to-image translation. In Advances in neural information processing systems, pp. 465–476, 2017.
+
+# A MODEL CONFIGURATION
+
+Our FastSpeech 2 consists of 4 feed-forward Transformer (FFT) blocks (Ren et al., 2019) in the encoder and the mel-spectrogram decoder. In each FFT block, the dimension of phoneme embeddings and the hidden size of the self-attention are set to 256. The number of attention heads is set to 2 and the kernel sizes of the 1D-convolution in the 2-layer convolutional network after the self-attention layer are set to 9 and 1, with input/output size of 256/1024 for the first layer and 1024/256 in the second layer. The size of the phoneme vocabulary is 76, including punctuations. In the variance predictor, the kernel sizes of the 1D-convolution are set to 3, with input/output sizes of 256/256 for both layers and the dropout rate is set to 0.5. Our waveform decoder consists of 1-layer transposed 1D-convolution with filter size 64 and 30 dilated residual convolution blocks, whose skip channel size and kernel size of 1D-convolution are set to 64 and 3. The configurations of the discriminator in FastSpeech 2s are the same as Parallel WaveGAN (Yamamoto et al., 2020). We list hyperparameters and configurations of all models used in our experiments in Table 7.
+
+Table 7: Hyperparameters of Transformer TTS, FastSpeech and FastSpeech 2/2s.   
+
+<table><tr><td rowspan=1 colspan=1>Hyperparameter</td><td rowspan=1 colspan=1>TransformerTTS</td><td rowspan=1 colspan=1>FastSpeech/FastSpeech 2/2s</td></tr><tr><td rowspan=1 colspan=1>Phoneme Embedding Dimension</td><td rowspan=1 colspan=1>256</td><td rowspan=1 colspan=1>256</td></tr><tr><td rowspan=1 colspan=1>Pre-netLayers</td><td rowspan=1 colspan=1>3</td><td rowspan=1 colspan=1>1</td></tr><tr><td rowspan=1 colspan=1>Pre-net Hidden</td><td rowspan=1 colspan=1>256</td><td rowspan=1 colspan=1>/</td></tr><tr><td rowspan=1 colspan=1>EncoderLayers</td><td rowspan=1 colspan=1>4</td><td rowspan=1 colspan=1>4</td></tr><tr><td rowspan=1 colspan=1>EncoderHidden</td><td rowspan=1 colspan=1>256</td><td rowspan=1 colspan=1>256</td></tr><tr><td rowspan=1 colspan=1>Encoder Conv1D Kernel</td><td rowspan=1 colspan=1>9</td><td rowspan=1 colspan=1>9</td></tr><tr><td rowspan=1 colspan=1>Encoder Conv1D Filter Size</td><td rowspan=1 colspan=1>1024</td><td rowspan=1 colspan=1>1024</td></tr><tr><td rowspan=1 colspan=1>Encoder Attention Heads</td><td rowspan=1 colspan=1>2</td><td rowspan=1 colspan=1>2</td></tr><tr><td rowspan=1 colspan=1> Mel-Spectrogram Decoder Layers</td><td rowspan=1 colspan=1>4</td><td rowspan=1 colspan=1>4</td></tr><tr><td rowspan=1 colspan=1>Mel-Spectrogram Decoder Hidden</td><td rowspan=1 colspan=1>256</td><td rowspan=1 colspan=1>256</td></tr><tr><td rowspan=1 colspan=1>Mel-Spectrogram Decoder Conv1D Kernel</td><td rowspan=1 colspan=1>9</td><td rowspan=1 colspan=1>9</td></tr><tr><td rowspan=1 colspan=1>Mel-Spectrogram Decoder Conv1D Filter Size</td><td rowspan=1 colspan=1>1024</td><td rowspan=1 colspan=1>1024</td></tr><tr><td rowspan=1 colspan=1>Mel-Spectrogram Decoder Attention Headers</td><td rowspan=1 colspan=1>2</td><td rowspan=1 colspan=1>2</td></tr><tr><td rowspan=1 colspan=1>Encoder/Decoder Dropout</td><td rowspan=1 colspan=1>0.1</td><td rowspan=1 colspan=1>0.1</td></tr><tr><td rowspan=1 colspan=1>Variance Predictor Conv1DKernel</td><td rowspan=1 colspan=1>1</td><td rowspan=1 colspan=1>3</td></tr><tr><td rowspan=1 colspan=1>Variance Predictor Conv1DFilter Size</td><td rowspan=1 colspan=1>1</td><td rowspan=1 colspan=1>256</td></tr><tr><td rowspan=1 colspan=1>Variance Predictor Dropout</td><td rowspan=1 colspan=1>/</td><td rowspan=1 colspan=1>0.5</td></tr><tr><td rowspan=1 colspan=1>Waveform Decoder ConvolutionBlocks</td><td rowspan=1 colspan=1>1</td><td rowspan=1 colspan=1>30</td></tr><tr><td rowspan=1 colspan=1>Waveform Decoder Dilated Conv1D Kernel size</td><td rowspan=1 colspan=1>1</td><td rowspan=1 colspan=1>3</td></tr><tr><td rowspan=1 colspan=1>Waveform Decoder Transposed Conv1D Filter Size</td><td rowspan=1 colspan=1>/</td><td rowspan=1 colspan=1>64</td></tr><tr><td rowspan=1 colspan=1>WaveformDecoderSkip Channlel Size</td><td rowspan=1 colspan=1>/</td><td rowspan=1 colspan=1>64</td></tr><tr><td rowspan=1 colspan=1>Batch Size</td><td rowspan=1 colspan=1>48</td><td rowspan=1 colspan=1>48/48/12</td></tr><tr><td rowspan=1 colspan=1>Total Numberof Parameters</td><td rowspan=1 colspan=1>24M</td><td rowspan=1 colspan=1>23M/27M/28M</td></tr></table>
+
+# B TRAINING AND INFERENCE
+
+We train FastSpeech 2 on 1 NVIDIA V100 GPU, with batchsize of 48 sentences. We use the Adam optimizer (Kingma & Ba, 2014) with $\beta _ { 1 } = 0 . 9$ , $\beta _ { 2 } = 0 . 9 8$ , $\varepsilon = 1 0 ^ { - 9 }$ and follow the same learning rate schedule in Vaswani et al. (2017). It takes $1 6 0 \mathrm { k }$ steps for training until convergence. In the inference process, the output mel-spectrograms of our FastSpeech 2 are transformed into audio samples using pre-trained Parallel WaveGAN (Yamamoto et al., $2 0 2 0 ) ^ { 9 }$ . For FastSpeech 2s, we train the model on 2 NVIDIA V100 GPUs, with batchsize of 6 sentences on each GPU. The waveform decoder takes the sliced hidden states corresponding to 20,480 waveform sample clips as input. The optimizer and learning rate schedule for FastSpeech 2s are the same as FastSpeech 2. The details of the adversarial training follow Parallel WaveGAN (Yamamoto et al., 2020). It takes $6 0 0 \mathrm { k }$ steps for training until convergence for FastSpeech 2s.
+
+# C MODELING PITCH WITH CONTINUOUS WAVELET TRANSFORM
+
+# C.1 CONTINUOUS WAVELET TRANSFORM
+
+Given a continous pitch contour function $F _ { 0 }$ , we can convert it to pitch spectrogram $W ( \tau , t )$ using continuous wavelet transform (Tuteur, 1988; Grossmann $\&$ Morlet, 1984):
+
+$$
+W ( \tau , t ) = \tau ^ { - 1 / 2 } \int _ { - \infty } ^ { + \infty } F _ { 0 } ( x ) \psi ( \frac { x - t } { \tau } ) d x
+$$
+
+where $\psi$ is the Mexican hat mother wavelet (Ryan, 1994), $F _ { 0 } ( x )$ is the pitch value in position $x$ , $\tau$ and $t$ are scale and position of wavelet respectively. The original pitch contour $F _ { 0 }$ can be recovered from the wavelet representation $W ( \tau , t )$ by inverse continuous wavelet transform (iCWT) using the following formula:
+
+$$
+F _ { 0 } ( t ) = \int _ { - \infty } ^ { + \infty } \int _ { 0 } ^ { + \infty } W \left( \tau , t \right) \tau ^ { - 5 / 2 } \psi \left( \frac { x - t } { \tau } \right) d x d \tau
+$$
+
+Suppose that we decompose the pitch contour $F _ { 0 }$ into 10 scales (Ming et al., 2016), $F _ { 0 }$ can be represented by 10 separate components given by:
+
+$$
+W _ { i } ( t ) = { W ( 2 ^ { i + 1 } \tau _ { 0 } , t ) ( i + 2 . 5 ) ^ { - 5 / 2 } }
+$$
+
+where $i = 1 , . . . , 1 0$ and $\tau _ { 0 } = 5 m s$ , which is originally proposed in Suni et al. (2013). Given 10 wavelet components ${ \hat { W } } _ { i } ( t )$ , we can recompose pitch contour $\hat { F } _ { 0 }$ by the following formula (Ming et al., 2016):
+
+$$
+\hat { F _ { 0 } } ( t ) = \sum _ { i = 1 } ^ { 1 0 } \hat { W _ { i } } ( t ) ( i + 2 . 5 ) ^ { - 5 / 2 }
+$$
+
+# C.2 IMPLEMENTATION DETAILS
+
+First we extract the pitch contour using PyWorldVocoder10. Since CWT is very sensitive to discontinuous signals, we preprocess the pitch contour as follows: 1) we use linear interpolation to fill the unvoiced frame in pitch contour; 2) we transform the resulting pitch contour to logarithmic scale; 3) we normalize it to zero mean and unit variance for each utterance, and we have to save the original utterance-level mean and variance for pitch contour reconstruction; and 4) we convert the normalized pitch contour to pitch spectrogram using continuous wavelet transform following Equation 1.
+
+As shown in Figure 2, pitch predictor consists of a 2-layer 1Dconvolutional network with ReLU activation, each followed by the layer normalization and the dropout layer, and an extra linear layer to project the hidden states into the pitch spectrogram. To predict the mean/variance of recovered pitch contour for each utterance, we average the hidden states output by the 1D-convolutional network on the time dimension to a global vector and project it to mean and variance using a linear layer.
+
+We train the pitch predictor with ground-truth pitch spectrogram and the mean/variance of pitch contour and optimize it with mean square error. During inference, we predict the pitch spectrogram and the mean/variance of recovered pitch contour using pitch predictor, inverse the pitch spectrogram to pitch contour with inverse continuous wavelet transform (iCWT) following Equation 2, and finally denormalize it with the predicted mean/variance.
+
+![](images/bf9bed2a42dc1a351732e545084a5a753e996bbef70e51460ae9a1546298efa6.jpg)  
+Figure 2: Details in pitch predictor. CWT and iCWT denote continuous wavelet transform and inverse continuous wavelet transform respectively.
+
+# D CASE STUDY ON PITCH CONTOUR
+
+In this section, we conduct the case study on pitch contours of the audios generated by different methods. We randomly choose 1 utterance from the test set and plot the pitch countor of groundtruth audio samples and that generated by FastSpeech, FastSpeech 2, FastSpeech $2 s$ in Figure 3. We can see that FastSpeech 2 and 2s can capture the variations in pitch better than FastSpeech thanks to taking pitch information as input.
+
+![](images/49fcd4b77521aaa914be775df287f82d91643e9b73be51681aa45eefa274bd8a.jpg)  
+Figure 3: Pitch contours extracted from generated and ground-truth audio samples. We only plot the voiced part of pitch contour. The input text is “The worst, which perhaps was the English, was a terrible falling-off from the work of the earlier presses”.
+
+# E VARIANCE CONTROL
+
+FastSpeech 2 and 2s introduce several variance information to ease the one-to-many mapping problem in TTS. As a byproduct, they also make the synthesized speech more controllable and can be used to manually control pitch, duration and energy (volume) of synthesized audio. As a demonstration, we manipulate pitch input to control the pitch of synthesized speech in this subsubsection. We show the mel-spectrograms before and after the pitch manipulation in Figure 4. From the samples, we can see that FastSpeech 2 generates high-quality mel-spectrograms after adjusting the $\hat { F } _ { 0 }$ from 0.75 to 1.50 times. Such manipulation can also be applied to FastSpeech 2s and the results are put in the supplementary materials. We also put the audio samples controlled by other variance information in supplementary materials.
+
+![](images/5968f23f25df75c0e7431a42294dd9f4f6378cc2bbfd946461216707be862aa9.jpg)  
+Figure 4: The mel-spectrograms of the voice with different $\hat { F } _ { 0 }$ . $F _ { 0 }$ is the fundamental frequency of original audio. The red curves denote $\hat { F } _ { 0 }$ contours. The input text is “They discarded this for a more completely Roman and far less beautiful letter.”

parse/train/piLPYqxtWuA/piLPYqxtWuA_content_list.json

@@ -0,0 +1,1779 @@
+[
+    {
+        "type": "text",
+        "text": "FASTSPEECH 2: FAST AND HIGH-QUALITY END-TOEND TEXT TO SPEECH ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            98,
+            821,
+            146
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Yi Ren1∗, Chenxu $\\mathbf { H } \\mathbf { u } ^ { 1 }$ ∗, Xu Tan2, Tao $\\mathbf { Q } \\mathbf { i n } ^ { 2 }$ , Sheng Zhao3, Zhou Zhao1†, Tie-Yan Liu2 ",
+        "bbox": [
+            181,
+            167,
+            812,
+            185
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1Zhejiang University {rayeren,chenxuhu,zhaozhou}@zju.edu.cn ",
+        "bbox": [
+            184,
+            198,
+            553,
+            227
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "2Microsoft Research Asia {xuta,taoqin,tyliu}@microsoft.com ",
+        "bbox": [
+            184,
+            239,
+            506,
+            268
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "3Microsoft Azure Speech Sheng.Zhao@microsoft.com ",
+        "bbox": [
+            184,
+            282,
+            423,
+            310
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "ABSTRACT ",
+        "text_level": 1,
+        "bbox": [
+            454,
+            348,
+            544,
+            363
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Non-autoregressive text to speech (TTS) models such as FastSpeech (Ren et al., 2019) can synthesize speech significantly faster than previous autoregressive models with comparable quality. The training of FastSpeech model relies on an autoregressive teacher model for duration prediction (to provide more information as input) and knowledge distillation (to simplify the data distribution in output), which can ease the one-to-many mapping problem (i.e., multiple speech variations correspond to the same text) in TTS. However, FastSpeech has several disadvantages: 1) the teacher-student distillation pipeline is complicated and time-consuming, 2) the duration extracted from the teacher model is not accurate enough, and the target mel-spectrograms distilled from teacher model suffer from information loss due to data simplification, both of which limit the voice quality. In this paper, we propose FastSpeech 2, which addresses the issues in FastSpeech and better solves the one-to-many mapping problem in TTS by 1) directly training the model with ground-truth target instead of the simplified output from teacher, and 2) introducing more variation information of speech (e.g., pitch, energy and more accurate duration) as conditional inputs. Specifically, we extract duration, pitch and energy from speech waveform and directly take them as conditional inputs in training and use predicted values in inference. We further design FastSpeech 2s, which is the first attempt to directly generate speech waveform from text in parallel, enjoying the benefit of fully end-to-end inference. Experimental results show that 1) FastSpeech 2 achieves a 3x training speed-up over FastSpeech, and FastSpeech 2s enjoys even faster inference speed; 2) FastSpeech 2 and 2s outperform FastSpeech in voice quality, and FastSpeech 2 can even surpass autoregressive models. Audio samples are available at https://speechresearch.github.io/fastspeech2/. ",
+        "bbox": [
+            232,
+            380,
+            764,
+            727
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 INTRODUCTION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            755,
+            336,
+            771
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Neural network based text to speech (TTS) has made rapid progress and attracted a lot of attention in the machine learning and speech community in recent years (Wang et al., 2017; Shen et al., 2018; Ming et al., 2016; Arik et al., 2017; Ping et al., 2018; Ren et al., 2019; Li et al., 2019). Previous neural TTS models (Wang et al., 2017; Shen et al., 2018; Ping et al., 2018; Li et al., 2019) first generate mel-spectrograms autoregressively from text and then synthesize speech from the generated mel-spectrograms using a separately trained vocoder (Van Den Oord et al., 2016; Oord et al., 2017; Prenger et al., 2019; Kim et al., 2018; Yamamoto et al., 2020; Kumar et al., ",
+        "bbox": [
+            174,
+            787,
+            825,
+            886
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "2019). They usually suffer from slow inference speed and robustness (word skipping and repeating) issues (Ren et al., 2019; Chen et al., 2020). In recent years, non-autoregressive TTS models (Ren et al., 2019; Łancucki, 2020; Kim et al., 2020; Lim et al., 2020; Miao et al., 2020; Peng et al., 2019) ´ are designed to address these issues, which generate mel-spectrograms with extremely fast speed and avoid robustness issues, while achieving comparable voice quality with previous autoregressive models. ",
+        "bbox": [
+            174,
+            103,
+            825,
+            186
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Among those non-autoregressive TTS methods, FastSpeech (Ren et al., 2019) is one of the most successful models. FastSpeech designs two ways to alleviate the one-to-many mapping problem: 1) Reducing data variance in the target side by using the generated mel-spectrogram from an autoregressive teacher model as the training target (i.e., knowledge distillation). 2) Introducing the duration information (extracted from the attention map of the teacher model) to expand the text sequence to match the length of the mel-spectrogram sequence. While these designs in FastSpeech ease the learning of the one-to-many mapping problem (see Section 2.1) in TTS, they also bring several disadvantages: 1) The two-stage teacher-student training pipeline makes the training process complicated. 2) The target mel-spectrograms generated from the teacher model have some information loss1 compared with the ground-truth ones, since the quality of the audio synthesized from the generated mel-spectrograms is usually worse than that from the ground-truth ones. 3) The duration extracted from the attention map of teacher model is not accurate enough. ",
+        "bbox": [
+            174,
+            194,
+            825,
+            361
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "In this work, we propose FastSpeech 2 to address the issues in FastSpeech and better handle the one-to-many mapping problem in non-autoregressive TTS. To simplify the training pipeline and avoid the information loss due to data simplification in teacher-student distillation, we directly train the FastSpeech 2 model with ground-truth target instead of the simplified output from a teacher. To reduce the information gap (input does not contain all the information to predict the target) between the input (text sequence) and target output (mel-spectrograms) and alleviate the one-to-many mapping problem for non-autoregressive TTS model training, we introduce some variation information of speech including pitch, energy and more accurate duration into FastSpeech: in training, we extract duration, pitch and energy from the target speech waveform and directly take them as conditional inputs; in inference, we use values predicted by the predictors that are jointly trained with the FastSpeech 2 model. Considering the pitch is important for the prosody of speech and is also difficult to predict due to the large fluctuations along time, we convert the pitch contour into pitch spectrogram using continuous wavelet transform (Tuteur, 1988; Grossmann & Morlet, 1984) and predict the pitch in the frequency domain, which can improve the accuracy of predicted pitch. To further simplify the speech synthesis pipeline, we introduce FastSpeech 2s, which does not use mel-spectrograms as intermediate output and directly generates speech waveform from text in inference, enjoying low latency in inference. Experiments on the LJSpeech (Ito, 2017) dataset show that 1) FastSpeech 2 enjoys much simpler training pipeline (3x training time reduction) than FastSpeech while inherits its advantages of fast, robust and controllable (even more controllable in pitch and energy) speech synthesis, and FastSpeech 2s enjoys even faster inference speed; 2) FastSpeech 2 and 2s outperform FastSpeech in voice quality, and FastSpeech 2 can even surpass autoregressive models. We attach audio samples generated by FastSpeech 2 and 2s at https://speechresearch.github.io/fastspeech2/. ",
+        "bbox": [
+            173,
+            367,
+            825,
+            686
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "The main contributions of this work are summarized as follows: ",
+        "bbox": [
+            174,
+            694,
+            593,
+            708
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "• FastSpeech 2 achieves a 3x training speed-up over FastSpeech by simplifying the training pipeline.   \n• FastSpeech 2 alleviates the one-to-many mapping problem in TTS and achieves better voice quality.   \n• FastSpeech 2s further simplifies the inference pipeline for speech synthesis while maintaining high voice quality, by directly generating speech waveform from text. ",
+        "bbox": [
+            174,
+            718,
+            825,
+            811
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2 FASTSPEECH 2 AND 2S ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            829,
+            398,
+            845
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "In this section, we first describe the motivation of the design in FastSpeech 2, and then introduce the architecture of FastSpeech 2, which aims to improve FastSpeech to better handle the one-to",
+        "bbox": [
+            176,
+            861,
+            821,
+            890
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "image",
+        "img_path": "images/c4eac523ab73b3722b1bf9ee27b2fe85770fe8eba476e2f0b528a407fa242280.jpg",
+        "image_caption": [
+            "Figure 1: The overall architecture for FastSpeech 2 and 2s. LR in subfigure (b) denotes the length regulator proposed in FastSpeech. LN in subfigure (c) denotes layer normalization. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            183,
+            117,
+            812,
+            354
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "many mapping problem, with simpler training pipeline and higher voice quality. At last, we extend FastSpeech 2 to FastSpeech 2s for fully end-to-end text-to-waveform synthesis2. ",
+        "bbox": [
+            176,
+            411,
+            821,
+            440
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "2.1 MOTIVATION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            457,
+            305,
+            470
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "TTS is a typical one-to-many mapping problem (Wang et al., 2017; Zhu et al., 2017; Jayne et al., 2012; Gadermayr et al., 2020; Chen et al., 2021), since multiple possible speech sequences can correspond to a text sequence due to variations in speech, such as pitch, duration, sound volume and prosody. In non-autoregressive TTS, the only input information is text which is not enough to fully predict the variance in speech. In this case, the model is prone to overfit to the variations of the target speech in the training set, resulting in poor generalization ability. As mentioned in Section 1, although FastSpeech designs two ways to alleviate the one-to-many mapping problem, they also bring about several issues including 1) the complicated training pipeline; 2) information loss of target mel-spectrogram as analyzed in Table 1; and 3) not accurate enough ground-truth duration as shown in Table 5a. In the following subsection, we introduce the detailed design of FastSpeech 2 which aims to address these issues. ",
+        "bbox": [
+            174,
+            483,
+            825,
+            636
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "2.2 MODEL OVERVIEW ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            654,
+            348,
+            667
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "The overall model architecture of FastSpeech 2 is shown in Figure 1a. The encoder converts the phoneme embedding sequence into the phoneme hidden sequence, and then the variance adaptor adds different variance information such as duration, pitch and energy into the hidden sequence, finally the mel-spectrogram decoder converts the adapted hidden sequence into mel-spectrogram sequence in parallel. We use the feed-forward Transformer block, which is a stack of selfattention (Vaswani et al., 2017) layer and 1D-convolution as in FastSpeech (Ren et al., 2019), as the basic structure for the encoder and mel-spectrogram decoder. Different from FastSpeech that relies on a teacher-student distillation pipeline and the phoneme duration from a teacher model, FastSpeech 2 makes several improvements. First, we remove the teacher-student distillation pipeline, and directly use ground-truth mel-spectrograms as target for model training, which can avoid the information loss in distilled mel-spectrograms and increase the upper bound of the voice quality. Second, our variance adaptor consists of not only duration predictor but also pitch and energy predictors, where 1) the duration predictor uses the phoneme duration obtained by forced alignment (McAuliffe et al., 2017) as training target, which is more accurate than that extracted from the attention map of autoregressive teacher model as verified experimentally in Section 3.2.2; and 2) the additional pitch and energy predictors can provide more variance information, which is important to ease the one-to-many mapping problem in TTS. Third, to further simplify the training pipeline and push it towards a fully end-to-end system, we propose FastSpeech 2s, which directly generates waveform from text, without cascaded mel-spectrogram generation (acoustic model) and waveform generation (vocoder). In the following subsections, we describe detailed designs of the variance adaptor and direct waveform generation in our method. ",
+        "bbox": [
+            174,
+            680,
+            825,
+            887
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            103,
+            825,
+            186
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "2.3 VARIANCE ADAPTOR ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            204,
+            361,
+            218
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "The variance adaptor aims to add variance information (e.g., duration, pitch, energy, etc.) to the phoneme hidden sequence, which can provide enough information to predict variant speech for the one-to-many mapping problem in TTS. We briefly introduce the variance information as follows: 1) phoneme duration, which represents how long the speech voice sounds; 2) pitch, which is a key feature to convey emotions and greatly affects the speech prosody; 3) energy, which indicates framelevel magnitude of mel-spectrograms and directly affects the volume and prosody of speech. More variance information can be added in the variance adaptor, such as emotion, style and speaker, and we leave it for future work. Correspondingly, the variance adaptor consists of 1) a duration predictor (i.e., the length regulator, as used in FastSpeech), 2) a pitch predictor, and 3) an energy predictor, as shown in Figure 1b. In training, we take the ground-truth value of duration, pitch and energy extracted from the recordings as input into the hidden sequence to predict the target speech. At the same time, we use the ground-truth duration, pitch and energy as targets to train the duration, pitch and energy predictors, which are used in inference to synthesize target speech. As shown in Figure 1c, the duration, pitch and energy predictors share similar model structure (but different model parameters), which consists of a 2-layer 1D-convolutional network with ReLU activation, each followed by the layer normalization and the dropout layer, and an extra linear layer to project the hidden states into the output sequence. In the following paragraphs, we describe the details of the three predictors respectively. ",
+        "bbox": [
+            174,
+            232,
+            825,
+            479
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Duration Predictor The duration predictor takes the phoneme hidden sequence as input and predicts the duration of each phoneme, which represents how many mel frames correspond to this phoneme, and is converted into logarithmic domain for ease of prediction. The duration predictor is optimized with mean square error (MSE) loss, taking the extracted duration as training target. Instead of extracting the phoneme duration using a pre-trained autoregressive TTS model in FastSpeech, we use Montreal forced alignment (MFA) (McAuliffe et al., 2017) tool3 to extract the phoneme duration, in order to improve the alignment accuracy and thus reduce the information gap between the model input and output. ",
+        "bbox": [
+            174,
+            496,
+            825,
+            608
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Pitch Predictor Previous neural network based TTS systems with pitch prediction (Arik et al., 2017; Gibiansky et al., 2017) often predict pitch contour directly. However, due to high variations of ground-truth pitch, the distribution of predicted pitch values is very different from ground-truth distribution, as analyzed in Section 3.2.2. To better predict the variations in pitch contour, we use continuous wavelet transform (CWT) to decompose the continuous pitch series into pitch spectrogram (Suni et al., 2013; Hirose & Tao, 2015) and take the pitch spectrogram as the training target for the pitch predictor which is optimized with MSE loss. In inference, the pitch predictor predicts the pitch spectrogram, which is further converted back into pitch contour using inverse continuous wavelet transform (iCWT). We describe the details of pitch extraction, CWT, iCWT and pitch predictor architecture in Appendix D. To take the pitch contour as input in both training and inference, we quantize pitch $F _ { 0 }$ (ground-truth/predicted value for train/inference respectively) of each frame to 256 possible values in log-scale and further convert it into pitch embedding vector $p$ and add it to the expanded hidden sequence. ",
+        "bbox": [
+            174,
+            623,
+            825,
+            803
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Energy Predictor We compute L2-norm of the amplitude of each short-time Fourier transform (STFT) frame as the energy. Then we quantize energy of each frame to 256 possible values uniformly, encoded it into energy embedding $e$ and add it to the expanded hidden sequence similarly to pitch. We use an energy predictor to predict the original values of energy instead of the quantized values and optimize the energy predictor with MSE loss4. ",
+        "bbox": [
+            174,
+            819,
+            825,
+            861
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            103,
+            823,
+            132
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "2.4 FASTSPEECH 2S ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            148,
+            326,
+            162
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "To enable fully end-to-end text-to-waveform generation, in this subsection, we extend FastSpeech 2 to FastSpeech 2s, which directly generates waveform from text, without cascaded mel-spectrogram generation (acoustic model) and waveform generation (vocoder). As shown in Figure 1a, FastSpeech 2s generates waveform conditioning on intermediate hidden, which makes it more compact in inference by discarding mel-spectrogram decoder and achieve comparable performance with a cascaded system. We first discuss the challenges in non-autoregressive text-to-waveform generation, then describe details of FastSpeech 2s, including model structure and training and inference processes. ",
+        "bbox": [
+            174,
+            174,
+            825,
+            272
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Challenges in Text-to-Waveform Generation When pushing TTS pipeline towards fully endto-end framework, there are several challenges: 1) Since the waveform contains more variance information (e.g., phase) than mel-spectrograms, the information gap between the input and output is larger than that in text-to-spectrogram generation. 2) It is difficult to train on the audio clip that corresponds to the full text sequence due to the extremely long waveform samples and limited GPU memory. As a result, we can only train on a short audio clip that corresponds to a partial text sequence which makes it hard for the model to capture the relationship among phonemes in different partial text sequences and thus harms the text feature extraction. ",
+        "bbox": [
+            173,
+            286,
+            825,
+            398
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Our Method To tackle the challenges above, we make several designs in the waveform decoder: 1) Considering that the phase information is difficult to predict using a variance predictor (Engel et al., 2020), we introduce adversarial training in the waveform decoder to force it to implicitly recover the phase information by itself (Yamamoto et al., 2020). 2) We leverage the mel-spectrogram decoder of FastSpeech 2, which is trained on the full text sequence to help on the text feature extraction. As shown in Figure 1d, the waveform decoder is based on the structure of WaveNet (Van Den Oord et al., 2016) including non-causal convolutions and gated activation (Van den Oord et al., 2016). The waveform decoder takes a sliced hidden sequence corresponding to a short audio clip as input and upsamples it with transposed 1D-convolution to match the length of audio clip. The discriminator in the adversarial training adopts the same structure in Parallel WaveGAN (Yamamoto et al., 2020) which consists of ten layers of non-causal dilated 1-D convolutions with leaky ReLU activation function. The waveform decoder is optimized by the multi-resolution STFT loss and the LSGAN discriminator loss following Parallel WaveGAN. In inference, we discard the mel-spectrogram decoder and only use the waveform decoder to synthesize speech audio. ",
+        "bbox": [
+            173,
+            414,
+            825,
+            608
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "2.5 DISCUSSIONS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            625,
+            310,
+            638
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "In this subsection, we discuss how FastSpeech 2 and 2s differentiate from previous and concurrent works. ",
+        "bbox": [
+            176,
+            651,
+            823,
+            679
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Compared with Deep Voice (Arik et al., 2017), Deep Voice 2 (Gibiansky et al., 2017) and other methods Fan et al. (2014); Ze et al. (2013) which generate waveform autoregressively and also predict variance information such as duration and pitch, Fastspeech 2 and 2s adopt self-attention based feed-forward network to generate mel-spectrograms or waveform in parallel. While some existing non-autoregressive acoustic models (Zeng et al., 2020; Lim et al., 2020; Kim et al., 2020) mostly focus on improving the duration accuracy, FastSpeech 2 and 2s provide more variation information (duration, pitch and energy) as inputs to reduce the information gap between the input and output. A concurrent work (Łancucki, 2020) employs pitch prediction in phoneme level, while FastSpeech 2 ´ and 2s predict more fine-grained pitch contour in frame level. In addition, to improve the prosody in synthesized speech, FastSpeech 2 and 2s further introduce continuous wavelet transform to model the variations in pitch. ",
+        "bbox": [
+            174,
+            685,
+            825,
+            838
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "While some text-to-waveform models such as ClariNet (Ping et al., 2019) jointly train an autoregressive acoustic model and a non-autoregressive vocoder, FastSpeech 2s embraces the fully nonautoregressive architecture for fast inference. A concurrent work called EATS (Donahue et al., 2020) ",
+        "bbox": [
+            174,
+            845,
+            825,
+            887
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "also employs non-autoregressive architecture and adversarial training to convert text to waveform directly and mainly focuses on predicting the duration of each phoneme end-to-end using a differentiable monotonic interpolation scheme. Compared with EATS, FastSpeech 2s additionally provides more variation information to ease the one-to-many mapping problem in TTS. ",
+        "bbox": [
+            174,
+            103,
+            823,
+            159
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Previous non-autoregressive vocoders (Oord et al., 2017; Prenger et al., 2019; Yamamoto et al., 2020; Kumar et al., 2019) are not complete text-to-speech systems, since they convert time aligned linguistic features to waveforms, and require a separate linguistic model to convert input text to linguistic features or an acoustic model to convert input text to acoustic features (e.g., melspectrograms). FastSpeech 2s is the first attempt to directly generate waveform from phoneme sequence fully in parallel, instead of linguistic features or mel-spectrograms. ",
+        "bbox": [
+            174,
+            166,
+            825,
+            251
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "3 EXPERIMENTS AND RESULTS ",
+        "text_level": 1,
+        "bbox": [
+            178,
+            270,
+            447,
+            285
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "3.1 EXPERIMENTAL SETUP ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            300,
+            375,
+            314
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Datasets We evaluate FastSpeech 2 and 2s on LJSpeech dataset (Ito, 2017). LJSpeech contains 13,100 English audio clips (about 24 hours) and corresponding text transcripts. We split the dataset into three sets: 12,228 samples for training, 349 samples (with document title LJ003) for validation and 523 samples (with document title LJ001 and LJ002) for testing. For subjective evaluation, we randomly choose 100 samples in test set. To alleviate the mispronunciation problem, we convert the text sequence into the phoneme sequence (Arik et al., 2017; Wang et al., 2017; Shen et al., 2018; Sun et al., 2019) with an open-source grapheme-to-phoneme tool5. We transform the raw waveform into mel-spectrograms following Shen et al. (2018) and set frame size and hop size to 1024 and 256 with respect to the sample rate 22050. ",
+        "bbox": [
+            174,
+            325,
+            825,
+            450
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Model Configuration Our FastSpeech 2 consists of 4 feed-forward Transformer (FFT) blocks (Ren et al., 2019) in the encoder and the mel-spectrogram decoder. The output linear layer in the decoder converts the hidden states into 80-dimensional mel-spectrograms and our model is optimized with mean absolute error (MAE). We add more detailed configurations of FastSpeech 2 and 2s used in our experiments in Appendix A. The details of training and inference are added in Appendix B. ",
+        "bbox": [
+            174,
+            465,
+            825,
+            549
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "3.2 RESULTS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            565,
+            277,
+            580
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "table",
+        "img_path": "images/5d2d5684152a166a9297c7fba3bcb9fe371be485e0549c0c9f94b9892d4cfb72.jpg",
+        "table_caption": [],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Method</td><td>CMOS</td></tr><tr><td>FastSpeech 2</td><td>一 0.000</td></tr><tr><td>FastSpeech Transformer TTS</td><td>-0.885 -0.235</td></tr></table>",
+        "bbox": [
+            611,
+            619,
+            795,
+            693
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "table",
+        "img_path": "images/920d572ffca8b8c81818c300a2fef98691d0ffde7486b66f476d99dd1124ed5f.jpg",
+        "table_caption": [
+            "Table 1: Audio quality comparison. "
+        ],
+        "table_footnote": [
+            "(a) The MOS with $9 5 \\%$ confidence intervals. "
+        ],
+        "table_body": "<table><tr><td>Method</td><td>MOS</td></tr><tr><td>GT</td><td>4.30± 0.07</td></tr><tr><td>GT (Mel + PWG)</td><td>3.92 ± 0.08</td></tr><tr><td>Tacotron 2 (Shen et al.,2018) (Mel + PWG)</td><td>3.70± 0.08</td></tr><tr><td>Transformer TTS (Li et al.,2019) (Mel + PWG)</td><td>3.72 ± 0.07</td></tr><tr><td>FastSpeech (Ren et al.,2019) (Mel + PWG)</td><td>3.68± 0.09</td></tr><tr><td>FastSpeech 2 (Mel + PWG)</td><td>3.83 ± 0.08</td></tr><tr><td>FastSpeech 2s</td><td>3.71 ± 0.09</td></tr></table>",
+        "bbox": [
+            191,
+            593,
+            586,
+            729
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "(b) CMOS comparison. ",
+        "bbox": [
+            635,
+            733,
+            774,
+            747
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "In this section, we first evaluate the audio quality, training and inference speedup of FastSpeech 2 and 2s. Then we conduct analyses and ablation studies of our method6. ",
+        "bbox": [
+            173,
+            780,
+            825,
+            808
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "3.2.1 MODEL PERFORMANCE ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            823,
+            393,
+            837
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Audio Quality To evaluate the perceptual quality, we perform mean opinion score (MOS) (Chu & Peng, 2006) evaluation on the test set. Twenty native English speakers are asked to make quality judgments about the synthesized speech samples. The text content keeps consistent among different systems so that all testers only examine the audio quality without other interference factors. We compare the MOS of the audio samples generated by FastSpeech 2 and FastSpeech $2 s$ with other systems, including 1) $G T .$ , the ground-truth recordings; 2) GT $( M e l + P W G )$ ), where we first convert the ground-truth audio into mel-spectrograms, and then convert the mel-spectrograms back to audio using Parallel WaveGAN (Yamamoto et al., 2020) (PWG); 3) Tacotron 2 (Shen et al., 2018) $( M e l + P W G )$ ; 4) Transformer TTS (Li et al., 2019) $( M e l + P W G )$ ; 5) FastSpeech (Ren et al., 2019) $( M e l + P W G )$ . All the systems in 3), 4) and 5) use Parallel WaveGAN as the vocoder for a fair comparison. The results are shown in Table 1. It can be seen that FastSpeech 2 can surpass and FastSpeech 2s can match the voice quality of autoregressive models Transformer TTS and Tacotron 2. Importantly, FastSpeech 2 outperforms FastSpeech, which demonstrates the effectiveness of providing variance information such as pitch, energy and more accurate duration and directly taking ground-truth speech as training target without using teacher-student distillation pipeline. ",
+        "bbox": [
+            174,
+            847,
+            823,
+            876
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "table",
+        "img_path": "images/764aae824c78169261e5d705476a40567f787dd9994e4b5f9c16b6f9d03464de.jpg",
+        "table_caption": [
+            "Table 2: The comparison of training time and inference latency in waveform synthesis. The training time of FastSpeech includes teacher and student training. RTF denotes the real-time factor, that is the time (in seconds) required for the system to synthesize one second waveform. The training and inference latency tests are conducted on a server with 36 Intel Xeon CPUs, 256GB memory, 1 NVIDIA V100 GPU and batch size of 48 for training and 1 for inference. Besides, we do not include the time of GPU memory garbage collection and transferring input and output data between the CPU and the GPU. The speedup in waveform synthesis for FastSpeech is larger than that reported in Ren et al. (2019) since we use Parallel WaveGAN as the vocoder which is much faster than WaveGlow. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Method</td><td>Training Time (h)</td><td>Inference Speed (RTF)</td><td>Inference Speedup</td></tr><tr><td>Transformer TTS (Li et al.,2019)</td><td>38.64</td><td>9.32 × 10-1</td><td>/</td></tr><tr><td>FastSpeech (Ren et al.,2019)</td><td>53.12</td><td>1.92 × 10-2</td><td>48.5×</td></tr><tr><td>FastSpeech 2</td><td>17.02</td><td>1.95 × 10-2</td><td>47.8×</td></tr><tr><td>FastSpeech 2s</td><td>92.18</td><td>1.80 × 10-2</td><td>51.8×</td></tr></table>",
+        "bbox": [
+            184,
+            102,
+            812,
+            184
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            329,
+            825,
+            511
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Training and Inference Speedup FastSpeech 2 simplifies the training pipeline of FastSpeech by removing the teacher-student distillation process, and thus reduces the training time. We list the total training time of Transformer TTS (the autoregressive teacher model), FastSpeech (including the training of Transformer TTS teacher model and FastSpeech student model) and FastSpeech 2 in Table 2. It can be seen that FastSpeech 2 reduces the total training time by $3 . 1 2 \\times$ compared with FastSpeech. Note that training time here only includes acoustic model training, without considering the vocoder training. Therefore, we do not compare the training time of FastSpeech 2s here. We then evaluate the inference latency of FastSpeech 2 and 2s compared with the autoregressive Transformer TTS model, which has the similar number of model parameters with FastSpeech 2 and 2s. We show the inference speedup for waveform generation in Table 2. It can be seen that compared with the Transformer TTS model, FastSpeech 2 and 2s speeds up the audio generation by $4 7 . 8 \\times$ and $5 1 . 8 \\times$ respectively in waveform synthesis. We can also see that FastSpeech 2s is faster than FastSpeech 2 due to fully end-to-end generation. ",
+        "bbox": [
+            173,
+            530,
+            825,
+            712
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "table",
+        "img_path": "images/87346be1654cb6d1e58a05cb634ba6b79b1e78fd678628288e27ac0dfdbf0eec.jpg",
+        "table_caption": [
+            "3.2.2 ANALYSES ON VARIANCE INFORMATION "
+        ],
+        "table_footnote": [
+            "Table 3: Standard deviation $( \\sigma )$ , skewness $( \\gamma )$ , kurtosis $( \\kappa )$ and average DTW distances (DTW) of pitch in ground-truth and synthesized audio. "
+        ],
+        "table_body": "<table><tr><td>Method</td><td>9</td><td>Y</td><td>K</td><td>DTW</td></tr><tr><td>GT</td><td>54.4</td><td>0.836</td><td>0.977</td><td>/</td></tr><tr><td>Tacotron 2</td><td>44.1</td><td>1.28</td><td>1.311</td><td>26.32</td></tr><tr><td>TransformerTTS</td><td>40.8</td><td>0.703</td><td>1.419</td><td>24.40</td></tr><tr><td>FastSpeech</td><td>50.8</td><td>0.724</td><td>-0.041</td><td>24.89</td></tr><tr><td>FastSpeech 2</td><td>54.1</td><td>0.881</td><td>0.996</td><td>24.39</td></tr><tr><td>FastSpeech 2 - CWT</td><td>42.3</td><td>0.771</td><td>1.115</td><td>25.13</td></tr><tr><td>FastSpeech 2s</td><td>53.9</td><td>0.872</td><td>0.998</td><td>24.37</td></tr></table>",
+        "bbox": [
+            320,
+            766,
+            678,
+            895
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "More Accurate Variance Information in Synthesized Speech In the paragraph, we measure if providing more variance information (e.g., pitch and energy) as input in FastSpeech 2 and 2s can indeed synthesize speech with more accurate pitch and energy. ",
+        "bbox": [
+            174,
+            103,
+            823,
+            146
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "For pitch, we compute the moments (standard deviation $( \\sigma )$ , skewness $( \\gamma )$ and kurtosis $( \\kappa )$ ) (Andreeva et al., 2014; Niebuhr & Skarnitzl, 2019) and average dynamic time warping (DTW) Muller ¨ (2007) distance of the pitch distribution for the ground-truth speech and synthesized speech. The results are shown in Table 3. It can be seen that compared with FastSpeech, the moments $( \\sigma , \\gamma$ and $\\kappa$ ) of generated audio of FastSpeech 2/2s are more close to the ground-truth audio and the average DTW distances to the ground-truth pitch are smaller than other methods, demonstrating that FastSpeech 2/2s can generate speech with more natural pitch contour (which can result in better prosody) than FastSpeech. We also conduct a case study on generated pitch contours in Appendix D. ",
+        "bbox": [
+            173,
+            152,
+            825,
+            277
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "table",
+        "img_path": "images/d2d2bd1178e4ddd6c7a57c0c0e5eaf3c4af6757180a5f55419fa8eb8f35e1001.jpg",
+        "table_caption": [],
+        "table_footnote": [],
+        "table_body": "<table><tr><td></td><td></td><td></td><td>Method|FastSpeech |FastSpeech 2|FastSpeech 2s</td></tr><tr><td>MAE</td><td>0.142</td><td>0.131</td><td>0.133</td></tr></table>",
+        "bbox": [
+            320,
+            287,
+            676,
+            329
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Table 4: The mean absolute error (MAE) of the energy in synthesized speech audio. ",
+        "bbox": [
+            222,
+            339,
+            769,
+            354
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "For energy, we compute the mean absolute error (MAE) between the frame-wise energy extracted from the generated waveform and the ground-truth speech. To ensure that the numbers of frames in the synthesized and ground-truth speech are the same, we use the ground-truth duration extracted by MFA in both FastSpeech and FastSpeech 2. The results are shown in Table 4. We can see that the MAE of the energy for FastSpeech 2/2s are smaller than that for FastSpeech, indicating that they both synthesize speech audio with more similar energy to the ground-truth audio. ",
+        "bbox": [
+            173,
+            362,
+            825,
+            446
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "More Accurate Duration for Model Training We then analyze the accuracy of the provided duration information to train the duration predictor and the effectiveness of more accurate duration for better voice quality based on FastSpeech. We manually align 50 audio generated by the teacher model and the corresponding text in phoneme level and get the ground-truth phoneme-level duration. We compute the average of absolute phoneme boundary differences (McAuliffe et al., 2017) using the duration from the teacher model of FastSpeech and from MFA as used in this paper respectively. The results are shown in Table 5a. We can see that MFA can generate more accurate duration than the teacher model of FastSpeech. Next, we replace the duration used in FastSpeech (from teacher model) with that extracted by MFA, and conduct the CMOS (Loizou, 2011) test to compare the voice quality between the two FastSpeech models trained with different durations7. The results are listed in Table 5b and it can be seen that more accurate duration information improves the voice quality of FastSpeech, which verifies the effectiveness of our improved duration from MFA. ",
+        "bbox": [
+            174,
+            462,
+            825,
+            627
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "table",
+        "img_path": "images/4a2714ca84fc1897b56373db25468067c4b2b7bf2291b118200f2c6df0be78f3.jpg",
+        "table_caption": [],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Method</td><td>△(ms)</td></tr><tr><td>Duration from teacher model</td><td>19.68</td></tr><tr><td>Duration from MFA</td><td>12.47</td></tr></table>",
+        "bbox": [
+            218,
+            641,
+            475,
+            695
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "table",
+        "img_path": "images/515fa78c55b2ea4e8b7c1cff4aca5052ae8d4581087371681a3c04f832894477.jpg",
+        "table_caption": [],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Setting</td><td>CMOS</td></tr><tr><td>FastSpeech + Duration from teacher</td><td>0</td></tr><tr><td>FastSpeech + Duration from MFA</td><td>+0.195</td></tr></table>",
+        "bbox": [
+            501,
+            641,
+            802,
+            694
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "(a) Alignment accuracy comparison. ",
+        "bbox": [
+            238,
+            700,
+            455,
+            713
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "(b) CMOS comparison. ",
+        "bbox": [
+            580,
+            700,
+            720,
+            713
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Table 5: The comparison of the duration from teacher model and MFA. $\\Delta$ means the average of absolute boundary differences. ",
+        "bbox": [
+            173,
+            724,
+            823,
+            753
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "3.2.3 ABLATION STUDY ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            766,
+            354,
+            781
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Pitch and Energy Input We conduct ablation studies to demonstrate the effectiveness of several variance information of FastSpeech 2 and 2s, including pitch and energy8. We conduct CMOS evaluation for these ablation studies. The results are shown in Table 6. We find that removing the energy (Row 3 in both subtables) in FastSpeech 2 and 2s results in performance drop in terms of voice quality (-0.040 and -0.160 CMOS respectively), indicating that energy is effective for FastSpeech 2 in improving the voice quality, and more effective for FastSpeech 2s. We also find that removing the pitch (Row 4 in both subtables) in FastSpeech 2 and 2s results in -0.245 and -1.130 CMOS respectively, which demonstrates the effectiveness of pitch. When we remove both pitch and energy (the last row in both subtables), the voice quality further drops, indicating that both pitch and energy can help improve the performance of FastSpeech 2 and 2s. ",
+        "bbox": [
+            173,
+            790,
+            825,
+            875
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            103,
+            823,
+            159
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Predicting Pitch in Frequency Domain To study the effectiveness of predicting pitch in frequency domain using continuous wavelet transform (CWT) as described in Section 2.3, we directly fit the pitch contour with mean square error like energy in FastSpeech 2 and 2s. We conduct CMOS evaluation and get CMOS drops of 0.185 and 0.201 for FastSpeech 2 and 2s respectively. We also compute the moments of pitch and average DTW distance to the ground-truth pitch as shown in row 6 (denoeted as FastSpeech $2 \\cdot C W T$ ) in Table 3. The results demonstrate that CWT can help model the pitch better and improve the prosody of synthesized speech, and thus obtaining better CMOS score. ",
+        "bbox": [
+            174,
+            174,
+            825,
+            285
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Mel-Spectrogram Decoder in FastSpeech 2s To verify the effectiveness of the mel-spectrogram decoder in FastSpeech 2s on text feature extraction as described in Section 2.4, we remove the mel-spectrogram decoder and conduct CMOS evaluation. It causes a 0.285 CMOS drop, which demonstrates that the mel-spectrogram decoder is essential to high-quality waveform generation. ",
+        "bbox": [
+            174,
+            300,
+            825,
+            357
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "table",
+        "img_path": "images/0c6a0d90d327debd201c0301e2a5b36e6dc8344a996b5cda80a30a4c2142af38.jpg",
+        "table_caption": [
+            "Table 6: CMOS comparison in the ablation studies. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Setting</td><td>CMOS</td></tr><tr><td>FastSpeech 2</td><td>0</td></tr><tr><td>FastSpeech 2 - energy</td><td>-0.040</td></tr><tr><td>FastSpeech2-pitch</td><td>-0.245</td></tr><tr><td>FastSpeech 2-pitch -energy</td><td>-0.370</td></tr></table>",
+        "bbox": [
+            215,
+            368,
+            470,
+            454
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "table",
+        "img_path": "images/69872a0607c99baaff632a2c88ad75e3941020bc4c9771831ef5245ab9f0402e.jpg",
+        "table_caption": [],
+        "table_footnote": [
+            "(b) CMOS comparison for FastSpeech 2s. "
+        ],
+        "table_body": "<table><tr><td>Setting</td><td>CMOS</td></tr><tr><td>FastSpeech 2s</td><td>0</td></tr><tr><td>FastSpeech 2s - energy</td><td>-0.160</td></tr><tr><td>FastSpeech 2s-pitch</td><td>-1.130</td></tr><tr><td>FastSpeech 2s-pitch -energy</td><td>-1.355</td></tr></table>",
+        "bbox": [
+            524,
+            368,
+            784,
+            454
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "(a) CMOS comparison for FastSpeech 2. ",
+        "bbox": [
+            222,
+            459,
+            464,
+            473
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "4 CONCLUSION ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            515,
+            318,
+            531
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "In this work, we proposed FastSpeech 2, a fast and high-quality end-to-end TTS system, to address the issues in FastSpeech and ease the one-to-many mapping problem: 1) we directly train the model with ground-truth mel-spectrograms to simplify the training pipeline and also avoid information loss compared with FastSpeech; and 2) we improve the duration accuracy and introduce more variance information including pitch and energy to ease the one-to-many mapping problem, and improve pitch prediction by introducing continuous wavelet transform. Moreover, based on FastSpeech 2, we further developed FastSpeech 2s, a non-autoregressive text-to-waveform generation model, which enjoys the benefit of fully end-to-end inference and achieves faster inference speed. Our experimental results show that FastSpeech 2 and 2s outperform FastSpeech, and FastSpeech 2 can even surpass autoregressive models in terms of voice quality, with much simpler training pipeline while inheriting the advantages of fast, robust and controllable speech synthesis of FastSpeech. ",
+        "bbox": [
+            174,
+            545,
+            825,
+            699
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "High quality, fast and fully end-to-end training without any external libraries is definitely the ultimate goal of neural TTS and also a very challenging problem. To ensure high quality of FastSpeech 2, we use an external high-performance alignment tool and pitch extraction tools, which may seem a little complicated, but are very helpful for high-quality and fast speech synthesis. We believe there will be more simpler solutions to achieve this goal in the future and we will certainly work on fully end-to-end TTS without external alignment models and tools. We will also consider more variance information (Zhang et al., 2021) to further improve the voice quality and speed up the inference with more light-weight model (Luo et al., 2021). ",
+        "bbox": [
+            174,
+            705,
+            825,
+            818
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "ACKNOWLEDGMENTS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            838,
+            356,
+            852
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "This work was supported in part by the National Key R&D Program of China (Grant No.2018AAA0100603), National Natural Science Foundation of China (Grant No.62072397), Zhejiang Natural Science Foundation (Grant No.LR19F020006), National Natural Science Foundation of China (Grant No.61836002) and X Lab, the Second Academy of CASIC, Beijing, 100854, China. ",
+        "bbox": [
+            174,
+            867,
+            823,
+            922
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "REFERENCES ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            103,
+            287,
+            117
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Bistra Andreeva, Grazyna Demenko, Bernd M ˙ obius, Frank Zimmerer, Jeanin J ¨ ugler, and Magdalena ¨ Oleskowicz-Popiel. Differences of pitch profiles in germanic and slavic languages. In Fifteenth Annual Conference of the International Speech Communication Association, 2014. ",
+        "bbox": [
+            176,
+            126,
+            823,
+            169
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Sercan O Arik, Mike Chrzanowski, Adam Coates, Gregory Diamos, Andrew Gibiansky, Yongguo Kang, Xian Li, John Miller, Andrew Ng, Jonathan Raiman, et al. Deep voice: Real-time neural text-to-speech. arXiv preprint arXiv:1702.07825, 2017. ",
+        "bbox": [
+            176,
+            176,
+            821,
+            219
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Mingjian Chen, Xu Tan, Yi Ren, Jin Xu, Hao Sun, Sheng Zhao, and Tao Qin. Multispeech: Multispeaker text to speech with transformer. In INTERSPEECH, pp. 4024–4028, 2020. ",
+        "bbox": [
+            169,
+            227,
+            823,
+            257
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Mingjian Chen, Xu Tan, Bohan Li, Yanqing Liu, Tao Qin, sheng zhao, and Tie-Yan Liu. Adaspeech: Adaptive text to speech for custom voice. In International Conference on Learning Representations, 2021. URL https://openreview.net/forum?id $\\underline { { \\underline { { \\mathbf { \\Pi } } } } } =$ Drynvt7gg4L. ",
+        "bbox": [
+            174,
+            265,
+            821,
+            309
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Min Chu and Hu Peng. Objective measure for estimating mean opinion score of synthesized speech, April 4 2006. US Patent 7,024,362. ",
+        "bbox": [
+            171,
+            316,
+            823,
+            345
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Jeff Donahue, Sander Dieleman, Mikołaj Binkowski, Erich Elsen, and Karen Simonyan. End-to-end ´ adversarial text-to-speech. arXiv preprint arXiv:2006.03575, 2020. ",
+        "bbox": [
+            171,
+            353,
+            823,
+            383
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Jesse Engel, Lamtharn Hantrakul, Chenjie Gu, and Adam Roberts. Ddsp: Differentiable digital signal processing. arXiv preprint arXiv:2001.04643, 2020. ",
+        "bbox": [
+            169,
+            390,
+            823,
+            420
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Yuchen Fan, Yao Qian, Feng-Long Xie, and Frank K Soong. Tts synthesis with bidirectional lstm based recurrent neural networks. In Fifteenth Annual Conference of the International Speech Communication Association, 2014. ",
+        "bbox": [
+            176,
+            428,
+            823,
+            472
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Michael Gadermayr, Maximilian Tschuchnig, Dorit Merhof, Nils Kramer, Daniel Truhn, and ¨ Burkhard Gess. An asymetric cycle-consistency loss for dealing with many-to-one mappings in image translation: A study on thigh mr scans. arXiv preprint arXiv:2004.11001, 2020. ",
+        "bbox": [
+            174,
+            479,
+            823,
+            523
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Andrew Gibiansky, Sercan Arik, Gregory Diamos, John Miller, Kainan Peng, Wei Ping, Jonathan Raiman, and Yanqi Zhou. Deep voice 2: Multi-speaker neural text-to-speech. In Advances in neural information processing systems, pp. 2962–2970, 2017. ",
+        "bbox": [
+            176,
+            531,
+            821,
+            574
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Alexander Grossmann and Jean Morlet. Decomposition of hardy functions into square integrable wavelets of constant shape. SIAM journal on mathematical analysis, 15(4):723–736, 1984. ",
+        "bbox": [
+            173,
+            582,
+            821,
+            611
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Keikichi Hirose and Jianhua Tao. Speech Prosody in Speech Synthesis: Modeling and generation of prosody for high quality and flexible speech synthesis. Springer, 2015. ",
+        "bbox": [
+            174,
+            619,
+            821,
+            648
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Keith Ito. The lj speech dataset. https://keithito.com/LJ-Speech-Dataset/, 2017. ",
+        "bbox": [
+            173,
+            656,
+            820,
+            672
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Chrisina Jayne, Andreas Lanitis, and Chris Christodoulou. One-to-many neural network mapping techniques for face image synthesis. Expert Systems with Applications, 39(10):9778–9787, 2012. ",
+        "bbox": [
+            173,
+            680,
+            823,
+            709
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Jaehyeon Kim, Sungwon Kim, Jungil Kong, and Sungroh Yoon. Glow-tts: A generative flow for text-to-speech via monotonic alignment search. arXiv preprint arXiv:2005.11129, 2020. ",
+        "bbox": [
+            171,
+            717,
+            823,
+            747
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Sungwon Kim, Sang-gil Lee, Jongyoon Song, Jaehyeon Kim, and Sungroh Yoon. Flowavenet: A generative flow for raw audio. arXiv preprint arXiv:1811.02155, 2018. ",
+        "bbox": [
+            173,
+            755,
+            823,
+            785
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Diederik P Kingma and Jimmy Ba. Adam: A method for stochastic optimization. arXiv preprint arXiv:1412.6980, 2014. ",
+        "bbox": [
+            173,
+            792,
+            823,
+            821
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Kundan Kumar, Rithesh Kumar, Thibault de Boissiere, Lucas Gestin, Wei Zhen Teoh, Jose Sotelo, Alexandre de Brebisson, Yoshua Bengio, and Aaron C Courville. Melgan: Generative adversarial´ networks for conditional waveform synthesis. In Advances in Neural Information Processing Systems, pp. 14881–14892, 2019. ",
+        "bbox": [
+            173,
+            830,
+            825,
+            886
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Adrian Łancucki. Fastpitch: Parallel text-to-speech with pitch prediction. ´ arXiv preprint arXiv:2006.06873, 2020. ",
+        "bbox": [
+            173,
+            895,
+            821,
+            924
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Naihan Li, Shujie Liu, Yanqing Liu, Sheng Zhao, and Ming Liu. Neural speech synthesis with transformer network. In Proceedings of the AAAI Conference on Artificial Intelligence, volume 33, pp. 6706–6713, 2019. ",
+        "bbox": [
+            173,
+            103,
+            823,
+            146
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Dan Lim, Won Jang, Hyeyeong Park, Bongwan Kim, Jesam Yoon, et al. Jdi-t: Jointly trained duration informed transformer for text-to-speech without explicit alignment. arXiv preprint arXiv:2005.07799, 2020. ",
+        "bbox": [
+            173,
+            156,
+            823,
+            199
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Philipos C Loizou. Speech quality assessment. In Multimedia analysis, processing and communications, pp. 623–654. Springer, 2011. ",
+        "bbox": [
+            171,
+            209,
+            821,
+            238
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Renqian Luo, Xu Tan, Rui Wang, Tao Qin, Jinzhu Li, Sheng Zhao, Enhong Chen, and Tie-Yan Liu. Lightspeech: Lightweight and fast text to speech with neural architecture search. In 2021 IEEE International Conference on Acoustics, Speech and Signal Processing (ICASSP). IEEE, 2021. ",
+        "bbox": [
+            173,
+            247,
+            826,
+            291
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Michael McAuliffe, Michaela Socolof, Sarah Mihuc, Michael Wagner, and Morgan Sonderegger. Montreal forced aligner: Trainable text-speech alignment using kaldi. In Interspeech, pp. 498– 502, 2017. ",
+        "bbox": [
+            173,
+            301,
+            823,
+            343
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Chenfeng Miao, Shuang Liang, Minchuan Chen, Jun Ma, Shaojun Wang, and Jing Xiao. Flowtts: A non-autoregressive network for text to speech based on flow. In ICASSP 2020-2020 IEEE International Conference on Acoustics, Speech and Signal Processing (ICASSP), pp. 7209–7213. IEEE, 2020. ",
+        "bbox": [
+            173,
+            353,
+            825,
+            410
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Huaiping Ming, Dongyan Huang, Lei Xie, Jie Wu, Minghui Dong, and Haizhou Li. Deep bidirectional lstm modeling of timbre and prosody for emotional voice conversion. 2016. ",
+        "bbox": [
+            171,
+            420,
+            820,
+            450
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Meinard Muller. Dynamic time warping. ¨ Information retrieval for music and motion, pp. 69–84, 2007. ",
+        "bbox": [
+            173,
+            460,
+            823,
+            488
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Oliver Niebuhr and Radek Skarnitzl. Measuring a speaker’s acoustic correlates of pitch–but which? a contrastive analysis based on perceived speaker charisma. In Proceedings of 19th International Congress of Phonetic Sciences, 2019. ",
+        "bbox": [
+            173,
+            500,
+            826,
+            541
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Aaron van den Oord, Yazhe Li, Igor Babuschkin, Karen Simonyan, Oriol Vinyals, Koray Kavukcuoglu, George van den Driessche, Edward Lockhart, Luis C Cobo, Florian Stimberg, et al. Parallel wavenet: Fast high-fidelity speech synthesis. arXiv preprint arXiv:1711.10433, 2017. ",
+        "bbox": [
+            174,
+            551,
+            821,
+            594
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Kainan Peng, Wei Ping, Zhao Song, and Kexin Zhao. Parallel neural text-to-speech. arXiv preprint arXiv:1905.08459, 2019. ",
+        "bbox": [
+            171,
+            604,
+            823,
+            633
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Wei Ping, Kainan Peng, Andrew Gibiansky, Sercan O. Arik, Ajay Kannan, Sharan Narang, Jonathan Raiman, and John Miller. Deep voice 3: 2000-speaker neural text-to-speech. In International Conference on Learning Representations, 2018. ",
+        "bbox": [
+            174,
+            643,
+            825,
+            688
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Wei Ping, Kainan Peng, and Jitong Chen. Clarinet: Parallel wave generation in end-to-end text-tospeech. In International Conference on Learning Representations, 2019. ",
+        "bbox": [
+            174,
+            696,
+            823,
+            727
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Ryan Prenger, Rafael Valle, and Bryan Catanzaro. Waveglow: A flow-based generative network for speech synthesis. In ICASSP 2019-2019 IEEE International Conference on Acoustics, Speech and Signal Processing (ICASSP), pp. 3617–3621. IEEE, 2019. ",
+        "bbox": [
+            173,
+            736,
+            825,
+            779
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Yi Ren, Yangjun Ruan, Xu Tan, Tao Qin, Sheng Zhao, Zhou Zhao, and Tie-Yan Liu. Fastspeech: Fast, robust and controllable text to speech. In Advances in Neural Information Processing Systems, pp. 3165–3174, 2019. ",
+        "bbox": [
+            174,
+            789,
+            823,
+            832
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Harold Ryan. Ricker, ormsby; klander, bntterwo-a choice of wavelets, 1994. ",
+        "bbox": [
+            173,
+            842,
+            674,
+            857
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Jonathan Shen, Ruoming Pang, Ron J Weiss, Mike Schuster, Navdeep Jaitly, Zongheng Yang, Zhifeng Chen, Yu Zhang, Yuxuan Wang, Rj Skerrv-Ryan, et al. Natural tts synthesis by conditioning wavenet on mel spectrogram predictions. In 2018 IEEE International Conference on Acoustics, Speech and Signal Processing (ICASSP), pp. 4779–4783. IEEE, 2018. ",
+        "bbox": [
+            174,
+            867,
+            825,
+            924
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Hao Sun, Xu Tan, Jun-Wei Gan, Hongzhi Liu, Sheng Zhao, Tao Qin, and Tie-Yan Liu. Token-level ensemble distillation for grapheme-to-phoneme conversion. In INTERSPEECH, 2019. ",
+        "bbox": [
+            171,
+            103,
+            823,
+            132
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Antti Santeri Suni, Daniel Aalto, Tuomo Raitio, Paavo Alku, Martti Vainio, et al. Wavelets for intonation modeling in hmm speech synthesis. In 8th ISCA Workshop on Speech Synthesis, Proceedings, Barcelona, August 31-September 2, 2013. ISCA, 2013. ",
+        "bbox": [
+            174,
+            141,
+            823,
+            184
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Franz B Tuteur. Wavelet transformations in signal detection. IFAC Proceedings Volumes, 21(9): 1061–1065, 1988. ",
+        "bbox": [
+            168,
+            193,
+            823,
+            222
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Aaron Van Den Oord, Sander Dieleman, Heiga Zen, Karen Simonyan, Oriol Vinyals, Alex Graves, ¨ Nal Kalchbrenner, Andrew W Senior, and Koray Kavukcuoglu. Wavenet: A generative model for raw audio. SSW, 125, 2016. ",
+        "bbox": [
+            173,
+            231,
+            823,
+            272
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Aaron Van den Oord, Nal Kalchbrenner, Lasse Espeholt, Oriol Vinyals, Alex Graves, et al. Conditional image generation with pixelcnn decoders. In Advances in neural information processing systems, pp. 4790–4798, 2016. ",
+        "bbox": [
+            173,
+            281,
+            823,
+            324
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Ashish Vaswani, Noam Shazeer, Niki Parmar, Jakob Uszkoreit, Llion Jones, Aidan N Gomez, Łukasz Kaiser, and Illia Polosukhin. Attention is all you need. In Advances in Neural Information Processing Systems, pp. 5998–6008, 2017. ",
+        "bbox": [
+            173,
+            333,
+            823,
+            376
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Yuxuan Wang, RJ Skerry-Ryan, Daisy Stanton, Yonghui Wu, Ron J Weiss, Navdeep Jaitly, Zongheng Yang, Ying Xiao, Zhifeng Chen, Samy Bengio, et al. Tacotron: Towards end-to-end speech synthesis. arXiv preprint arXiv:1703.10135, 2017. ",
+        "bbox": [
+            174,
+            385,
+            823,
+            428
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Ryuichi Yamamoto, Eunwoo Song, and Jae-Min Kim. Parallel wavegan: A fast waveform generation model based on generative adversarial networks with multi-resolution spectrogram. In ICASSP 2020-2020 IEEE International Conference on Acoustics, Speech and Signal Processing (ICASSP), pp. 6199–6203. IEEE, 2020. ",
+        "bbox": [
+            173,
+            435,
+            826,
+            493
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Heiga Ze, Andrew Senior, and Mike Schuster. Statistical parametric speech synthesis using deep neural networks. In 2013 ieee international conference on acoustics, speech and signal processing, pp. 7962–7966. IEEE, 2013. ",
+        "bbox": [
+            176,
+            501,
+            823,
+            545
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Zhen Zeng, Jianzong Wang, Ning Cheng, Tian Xia, and Jing Xiao. Aligntts: Efficient feed-forward text-to-speech system without explicit alignment. In ICASSP 2020-2020 IEEE International Conference on Acoustics, Speech and Signal Processing (ICASSP), pp. 6714–6718. IEEE, 2020. ",
+        "bbox": [
+            174,
+            553,
+            823,
+            597
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Chen Zhang, Yi Ren, Xu Tan, Jinglin Liu, Kejun Zhang, Tao Qin, Sheng Zhao, and Tie-Yan Liu. Denoispeech: Denoising text to speech with frame-level noise modeling. In 2021 IEEE International Conference on Acoustics, Speech and Signal Processing (ICASSP). IEEE, 2021. ",
+        "bbox": [
+            176,
+            604,
+            821,
+            648
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Jun-Yan Zhu, Richard Zhang, Deepak Pathak, Trevor Darrell, Alexei A Efros, Oliver Wang, and Eli Shechtman. Toward multimodal image-to-image translation. In Advances in neural information processing systems, pp. 465–476, 2017. ",
+        "bbox": [
+            174,
+            656,
+            825,
+            700
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "A MODEL CONFIGURATION ",
+        "text_level": 1,
+        "bbox": [
+            178,
+            102,
+            419,
+            117
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Our FastSpeech 2 consists of 4 feed-forward Transformer (FFT) blocks (Ren et al., 2019) in the encoder and the mel-spectrogram decoder. In each FFT block, the dimension of phoneme embeddings and the hidden size of the self-attention are set to 256. The number of attention heads is set to 2 and the kernel sizes of the 1D-convolution in the 2-layer convolutional network after the self-attention layer are set to 9 and 1, with input/output size of 256/1024 for the first layer and 1024/256 in the second layer. The size of the phoneme vocabulary is 76, including punctuations. In the variance predictor, the kernel sizes of the 1D-convolution are set to 3, with input/output sizes of 256/256 for both layers and the dropout rate is set to 0.5. Our waveform decoder consists of 1-layer transposed 1D-convolution with filter size 64 and 30 dilated residual convolution blocks, whose skip channel size and kernel size of 1D-convolution are set to 64 and 3. The configurations of the discriminator in FastSpeech 2s are the same as Parallel WaveGAN (Yamamoto et al., 2020). We list hyperparameters and configurations of all models used in our experiments in Table 7. ",
+        "bbox": [
+            174,
+            137,
+            825,
+            304
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "table",
+        "img_path": "images/6213612414a35f13d9948ab1b81a42d1fb000b47a73df4cee0ceb013ebdc3431.jpg",
+        "table_caption": [
+            "Table 7: Hyperparameters of Transformer TTS, FastSpeech and FastSpeech 2/2s. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=1 colspan=1>Hyperparameter</td><td rowspan=1 colspan=1>TransformerTTS</td><td rowspan=1 colspan=1>FastSpeech/FastSpeech 2/2s</td></tr><tr><td rowspan=1 colspan=1>Phoneme Embedding Dimension</td><td rowspan=1 colspan=1>256</td><td rowspan=1 colspan=1>256</td></tr><tr><td rowspan=1 colspan=1>Pre-netLayers</td><td rowspan=1 colspan=1>3</td><td rowspan=1 colspan=1>1</td></tr><tr><td rowspan=1 colspan=1>Pre-net Hidden</td><td rowspan=1 colspan=1>256</td><td rowspan=1 colspan=1>/</td></tr><tr><td rowspan=1 colspan=1>EncoderLayers</td><td rowspan=1 colspan=1>4</td><td rowspan=1 colspan=1>4</td></tr><tr><td rowspan=1 colspan=1>EncoderHidden</td><td rowspan=1 colspan=1>256</td><td rowspan=1 colspan=1>256</td></tr><tr><td rowspan=1 colspan=1>Encoder Conv1D Kernel</td><td rowspan=1 colspan=1>9</td><td rowspan=1 colspan=1>9</td></tr><tr><td rowspan=1 colspan=1>Encoder Conv1D Filter Size</td><td rowspan=1 colspan=1>1024</td><td rowspan=1 colspan=1>1024</td></tr><tr><td rowspan=1 colspan=1>Encoder Attention Heads</td><td rowspan=1 colspan=1>2</td><td rowspan=1 colspan=1>2</td></tr><tr><td rowspan=1 colspan=1> Mel-Spectrogram Decoder Layers</td><td rowspan=1 colspan=1>4</td><td rowspan=1 colspan=1>4</td></tr><tr><td rowspan=1 colspan=1>Mel-Spectrogram Decoder Hidden</td><td rowspan=1 colspan=1>256</td><td rowspan=1 colspan=1>256</td></tr><tr><td rowspan=1 colspan=1>Mel-Spectrogram Decoder Conv1D Kernel</td><td rowspan=1 colspan=1>9</td><td rowspan=1 colspan=1>9</td></tr><tr><td rowspan=1 colspan=1>Mel-Spectrogram Decoder Conv1D Filter Size</td><td rowspan=1 colspan=1>1024</td><td rowspan=1 colspan=1>1024</td></tr><tr><td rowspan=1 colspan=1>Mel-Spectrogram Decoder Attention Headers</td><td rowspan=1 colspan=1>2</td><td rowspan=1 colspan=1>2</td></tr><tr><td rowspan=1 colspan=1>Encoder/Decoder Dropout</td><td rowspan=1 colspan=1>0.1</td><td rowspan=1 colspan=1>0.1</td></tr><tr><td rowspan=1 colspan=1>Variance Predictor Conv1DKernel</td><td rowspan=1 colspan=1>1</td><td rowspan=1 colspan=1>3</td></tr><tr><td rowspan=1 colspan=1>Variance Predictor Conv1DFilter Size</td><td rowspan=1 colspan=1>1</td><td rowspan=1 colspan=1>256</td></tr><tr><td rowspan=1 colspan=1>Variance Predictor Dropout</td><td rowspan=1 colspan=1>/</td><td rowspan=1 colspan=1>0.5</td></tr><tr><td rowspan=1 colspan=1>Waveform Decoder ConvolutionBlocks</td><td rowspan=1 colspan=1>1</td><td rowspan=1 colspan=1>30</td></tr><tr><td rowspan=1 colspan=1>Waveform Decoder Dilated Conv1D Kernel size</td><td rowspan=1 colspan=1>1</td><td rowspan=1 colspan=1>3</td></tr><tr><td rowspan=1 colspan=1>Waveform Decoder Transposed Conv1D Filter Size</td><td rowspan=1 colspan=1>/</td><td rowspan=1 colspan=1>64</td></tr><tr><td rowspan=1 colspan=1>WaveformDecoderSkip Channlel Size</td><td rowspan=1 colspan=1>/</td><td rowspan=1 colspan=1>64</td></tr><tr><td rowspan=1 colspan=1>Batch Size</td><td rowspan=1 colspan=1>48</td><td rowspan=1 colspan=1>48/48/12</td></tr><tr><td rowspan=1 colspan=1>Total Numberof Parameters</td><td rowspan=1 colspan=1>24M</td><td rowspan=1 colspan=1>23M/27M/28M</td></tr></table>",
+        "bbox": [
+            173,
+            324,
+            825,
+            643
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "B TRAINING AND INFERENCE ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            712,
+            436,
+            727
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "We train FastSpeech 2 on 1 NVIDIA V100 GPU, with batchsize of 48 sentences. We use the Adam optimizer (Kingma & Ba, 2014) with $\\beta _ { 1 } = 0 . 9$ , $\\beta _ { 2 } = 0 . 9 8$ , $\\varepsilon = 1 0 ^ { - 9 }$ and follow the same learning rate schedule in Vaswani et al. (2017). It takes $1 6 0 \\mathrm { k }$ steps for training until convergence. In the inference process, the output mel-spectrograms of our FastSpeech 2 are transformed into audio samples using pre-trained Parallel WaveGAN (Yamamoto et al., $2 0 2 0 ) ^ { 9 }$ . For FastSpeech 2s, we train the model on 2 NVIDIA V100 GPUs, with batchsize of 6 sentences on each GPU. The waveform decoder takes the sliced hidden states corresponding to 20,480 waveform sample clips as input. The optimizer and learning rate schedule for FastSpeech 2s are the same as FastSpeech 2. The details of the adversarial training follow Parallel WaveGAN (Yamamoto et al., 2020). It takes $6 0 0 \\mathrm { k }$ steps for training until convergence for FastSpeech 2s. ",
+        "bbox": [
+            174,
+            747,
+            825,
+            887
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "C MODELING PITCH WITH CONTINUOUS WAVELET TRANSFORM ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            101,
+            727,
+            119
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "C.1 CONTINUOUS WAVELET TRANSFORM ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            133,
+            478,
+            148
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "Given a continous pitch contour function $F _ { 0 }$ , we can convert it to pitch spectrogram $W ( \\tau , t )$ using continuous wavelet transform (Tuteur, 1988; Grossmann $\\&$ Morlet, 1984): ",
+        "bbox": [
+            174,
+            160,
+            823,
+            189
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "equation",
+        "img_path": "images/294cd90b8c8915030286471f7b9e8392c20c7f39c20949c995289f68d9a0b1d1.jpg",
+        "text": "$$\nW ( \\tau , t ) = \\tau ^ { - 1 / 2 } \\int _ { - \\infty } ^ { + \\infty } F _ { 0 } ( x ) \\psi ( \\frac { x - t } { \\tau } ) d x\n$$",
+        "text_format": "latex",
+        "bbox": [
+            357,
+            196,
+            640,
+            233
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "where $\\psi$ is the Mexican hat mother wavelet (Ryan, 1994), $F _ { 0 } ( x )$ is the pitch value in position $x$ , $\\tau$ and $t$ are scale and position of wavelet respectively. The original pitch contour $F _ { 0 }$ can be recovered from the wavelet representation $W ( \\tau , t )$ by inverse continuous wavelet transform (iCWT) using the following formula: ",
+        "bbox": [
+            173,
+            247,
+            826,
+            305
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "equation",
+        "img_path": "images/920728e78b0e70118c7a94b24c0e841658b4de33e0f53e2025f7ff848b02c469.jpg",
+        "text": "$$\nF _ { 0 } ( t ) = \\int _ { - \\infty } ^ { + \\infty } \\int _ { 0 } ^ { + \\infty } W \\left( \\tau , t \\right) \\tau ^ { - 5 / 2 } \\psi \\left( \\frac { x - t } { \\tau } \\right) d x d \\tau\n$$",
+        "text_format": "latex",
+        "bbox": [
+            316,
+            311,
+            681,
+            349
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "Suppose that we decompose the pitch contour $F _ { 0 }$ into 10 scales (Ming et al., 2016), $F _ { 0 }$ can be represented by 10 separate components given by: ",
+        "bbox": [
+            173,
+            356,
+            821,
+            385
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "equation",
+        "img_path": "images/936cea555ec9fae93ad7665cfb7c83fc9d823b290cfeca9c105a12cfbfdf1af5.jpg",
+        "text": "$$\nW _ { i } ( t ) = { W ( 2 ^ { i + 1 } \\tau _ { 0 } , t ) ( i + 2 . 5 ) ^ { - 5 / 2 } }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            377,
+            392,
+            620,
+            412
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "where $i = 1 , . . . , 1 0$ and $\\tau _ { 0 } = 5 m s$ , which is originally proposed in Suni et al. (2013). Given 10 wavelet components ${ \\hat { W } } _ { i } ( t )$ , we can recompose pitch contour $\\hat { F } _ { 0 }$ by the following formula (Ming et al., 2016): ",
+        "bbox": [
+            174,
+            419,
+            825,
+            463
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "equation",
+        "img_path": "images/7bd48b7fff7ba570cd0cf157098a21ceaac9c753c5422f816d2730b2f59f4843.jpg",
+        "text": "$$\n\\hat { F _ { 0 } } ( t ) = \\sum _ { i = 1 } ^ { 1 0 } \\hat { W _ { i } } ( t ) ( i + 2 . 5 ) ^ { - 5 / 2 }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            390,
+            463,
+            607,
+            507
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "C.2 IMPLEMENTATION DETAILS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            522,
+            408,
+            537
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "First we extract the pitch contour using PyWorldVocoder10. Since CWT is very sensitive to discontinuous signals, we preprocess the pitch contour as follows: 1) we use linear interpolation to fill the unvoiced frame in pitch contour; 2) we transform the resulting pitch contour to logarithmic scale; 3) we normalize it to zero mean and unit variance for each utterance, and we have to save the original utterance-level mean and variance for pitch contour reconstruction; and 4) we convert the normalized pitch contour to pitch spectrogram using continuous wavelet transform following Equation 1. ",
+        "bbox": [
+            173,
+            547,
+            647,
+            675
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "As shown in Figure 2, pitch predictor consists of a 2-layer 1Dconvolutional network with ReLU activation, each followed by the layer normalization and the dropout layer, and an extra linear layer to project the hidden states into the pitch spectrogram. To predict the mean/variance of recovered pitch contour for each utterance, we average the hidden states output by the 1D-convolutional network on the time dimension to a global vector and project it to mean and variance using a linear layer. ",
+        "bbox": [
+            174,
+            681,
+            647,
+            792
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "We train the pitch predictor with ground-truth pitch spectrogram and the mean/variance of pitch contour and optimize it with mean square error. During inference, we predict the pitch spectrogram and the mean/variance of recovered pitch contour using pitch predictor, inverse the pitch spectrogram to pitch contour with inverse continuous wavelet transform (iCWT) following Equation 2, and finally denormalize it with the predicted mean/variance. ",
+        "bbox": [
+            174,
+            799,
+            645,
+            897
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "image",
+        "img_path": "images/bf9bed2a42dc1a351732e545084a5a753e996bbef70e51460ae9a1546298efa6.jpg",
+        "image_caption": [
+            "Figure 2: Details in pitch predictor. CWT and iCWT denote continuous wavelet transform and inverse continuous wavelet transform respectively. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            669,
+            531,
+            813,
+            761
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "D CASE STUDY ON PITCH CONTOUR ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            102,
+            496,
+            118
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "In this section, we conduct the case study on pitch contours of the audios generated by different methods. We randomly choose 1 utterance from the test set and plot the pitch countor of groundtruth audio samples and that generated by FastSpeech, FastSpeech 2, FastSpeech $2 s$ in Figure 3. We can see that FastSpeech 2 and 2s can capture the variations in pitch better than FastSpeech thanks to taking pitch information as input. ",
+        "bbox": [
+            174,
+            133,
+            825,
+            204
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "image",
+        "img_path": "images/49fcd4b77521aaa914be775df287f82d91643e9b73be51681aa45eefa274bd8a.jpg",
+        "image_caption": [
+            "Figure 3: Pitch contours extracted from generated and ground-truth audio samples. We only plot the voiced part of pitch contour. The input text is “The worst, which perhaps was the English, was a terrible falling-off from the work of the earlier presses”. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            187,
+            220,
+            808,
+            500
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "E VARIANCE CONTROL ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            582,
+            383,
+            598
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "FastSpeech 2 and 2s introduce several variance information to ease the one-to-many mapping problem in TTS. As a byproduct, they also make the synthesized speech more controllable and can be used to manually control pitch, duration and energy (volume) of synthesized audio. As a demonstration, we manipulate pitch input to control the pitch of synthesized speech in this subsubsection. We show the mel-spectrograms before and after the pitch manipulation in Figure 4. From the samples, we can see that FastSpeech 2 generates high-quality mel-spectrograms after adjusting the $\\hat { F } _ { 0 }$ from 0.75 to 1.50 times. Such manipulation can also be applied to FastSpeech 2s and the results are put in the supplementary materials. We also put the audio samples controlled by other variance information in supplementary materials. ",
+        "bbox": [
+            173,
+            613,
+            825,
+            741
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "image",
+        "img_path": "images/5968f23f25df75c0e7431a42294dd9f4f6378cc2bbfd946461216707be862aa9.jpg",
+        "image_caption": [
+            "Figure 4: The mel-spectrograms of the voice with different $\\hat { F } _ { 0 }$ . $F _ { 0 }$ is the fundamental frequency of original audio. The red curves denote $\\hat { F } _ { 0 }$ contours. The input text is “They discarded this for a more completely Roman and far less beautiful letter.” "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            183,
+            755,
+            813,
+            847
+        ],
+        "page_idx": 14
+    }
+]