Re-upload MinerU batch e0533878-c6c3-46a8-8b07-dcee15e7ce39

data/2020/2101_07xxx/2101.07206/full.md

@@ -1,3 +1,576 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:bf50681171aacf9b7056a35e39b6695b1c08541d551b0af4dc79c205e993166f
-size 63896
+# DeepGreen: Deep Learning of Green's Functions for Nonlinear Boundary Value Problems
+
+Craig R. Gin $^{1*}$ , Daniel E. Shea $^{2*}$ , Steven L. Brunton $^{3}$ , and J. Nathan Kutz $^{4}$
+
+$^{1}$ Department of Population Health and Pathobiology, North Carolina State University, Raleigh, NC 27695, United States
+
+$^{2}$ Department of Materials Science and Engineering, University of Washington, Seattle, WA 98195, United States
+
+$^{3}$ Department of Mechanical Engineering, University of Washington, Seattle, WA 98195, United States
+
+$^{4}$ Department of Applied Mathematics, University of Washington, Seattle, WA 98195, United States
+
+*Co-first authors and corresponding authors. Email: crgin@ncsu.edu and sheadan@uw.edu.
+
+# Abstract
+
+Boundary value problems (BVPs) play a central role in the mathematical analysis of constrained physical systems subjected to external forces. Consequently, BVPs frequently emerge in nearly every engineering discipline and span problem domains including fluid mechanics, electromagnetics, quantum mechanics, and elasticity. The fundamental solution, or Green's function, is a leading method for solving linear BVPs that enables facile computation of new solutions to systems under any external forcing. However, fundamental Green's function solutions for nonlinear BVPs are not feasible since linear superposition no longer holds. In this work, we propose a flexible deep learning approach to solve nonlinear BVPs using a dual-autoencoder architecture. The autoencoders discover an invertible coordinate transform that linearizes the nonlinear BVP and identifies both a linear operator  $L$  and Green's function  $G$  which can be used to solve new nonlinear BVPs. We find that the method succeeds on a variety of nonlinear systems including nonlinear Helmholtz and Sturm-Liouville problems, nonlinear elasticity, and a 2D nonlinear Poisson equation. The method merges the strengths of the universal approximation capabilities of deep learning with the physics knowledge of Green's functions to yield a flexible tool for identifying fundamental solutions to a variety of nonlinear systems.
+
+Keywords: Deep learning, Green's function, Nonlinearity, Koopman operator theory
+
+# 1 Introduction
+
+Boundary value problems (BVPs) are ubiquitous in the sciences (1). From elasticity to quantum electronics, BVPs have been fundamental in the development and engineering design of numerous transformative technologies of the 20th century. Historically, the formulation of many canonical problems in physics and engineering result in linear BVPs: from Fourier formulating the heat equation in 1822 (2) to more modern applications such as designing chip architectures in the semi-conductor industry (3,4). Much of our theoretical understanding of BVPs comes from the construction of the fundamental solution of the BVP, commonly known as the Green's function (5). The Green's function solution relies on a common property of many BVPs: linearity. Specifically, general solutions rely on linear superposition to hold, thus limiting their usefulness in many modern applica
+
+tions where BVPs are often heterogeneous and nonlinear. By leveraging modern deep learning, we are able to learn linearizing transformations of BVPs that render nonlinear BVPs linear so that we can construct the Green's function solution. Our deep learning of Green's functions, Deep-Green, provides a transformative architecture for modern solutions of nonlinear BVPs.
+
+DeepGreen is inspired by recent works which use deep neural networks (DNNs) to discover advantageous coordinate transformations for dynamical systems (6-15). The universal approximation properties of DNNs (16, 17) are ideal for learning coordinate transformations that linearize nonlinear BVPs, ODEs and PDEs. Specifically, such linearizing transforms fall broadly under the umbrella of Koopman operator theory (18), which has a modern interpretation in terms of dynamical systems theory (19-22). There are only limited cases in which Koopman operators can only be
+
+constructed explicitly (23). However Dynamic Mode Decomposition (DMD) (24) provides a numerical algorithm for approximating the Koopman operator (25), with many recent extensions that improve on the DMD approximation (26). More recently, neural networks have been used to construct Koopman embeddings (6, 8-13, 15). This is an alternative to enriching the observables of DMD (27-33). Thus, neural networks have emerged as a highly effective mathematical tool for approximating complex data (34, 35) with a linear model. DNNs have been used in this context to discover time-stepping algorithms for complex systems (36-40). Moreover, DNNs have been used to approximate constitutive models of BVPs (41).
+
+DeepGreen leverages the success of DNNs for dynamical systems to discover coordinate transformations that linearize nonlinear BVPs so that the Green's function solution can be recovered. This allows for the discovery of the fundamental solutions for nonlinear BVPs, opening many opportunities for the engineering and physical sciences. DeepGreen exploits physics-informed learning by using autoenconders (AEs) to take data from the original high-dimensional input space to the new coordinates at the intrinsic rank of the underlying physics (6, 7, 42). The architecture also leverages the success of Deep Residual Networks (DRN) (43) which enables our approach to efficiently handle near-identity coordinate transformations (15).
+
+The Green's function constructs the solution to a BVP for any given forcing by superposition. Specifically, consider the classical linear BVP (5)
+
+$$
+L [ v (\mathbf {x}) ] = f (\mathbf {x}) \tag {1}
+$$
+
+where  $L$  is a linear differential operator,  $f$  is a forcing,  $\mathbf{x} \in \Omega$  is the spatial coordinate, and  $\Omega$  is an open set. The boundary conditions  $B\nu(\mathbf{x}) = 0$  are imposed on  $\partial \Omega$  with a linear operator  $B$ . The fundamental solution is constructed by considering the adjoint equation
+
+$$
+L ^ {\dagger} [ G (\mathbf {x}, \xi) ] = \delta (\mathbf {x} - \xi) \tag {2}
+$$
+
+where  $L^{\dagger}$  is the adjoint operator (along with its associated boundary conditions) and  $\delta (\mathbf{x} - \boldsymbol {\xi})$  is the Dirac delta function. Taking the inner product of (1) with respect to the Green's function gives the fundamental solution
+
+$$
+v (\mathbf {x}) = (f (\xi), G (\xi , \mathbf {x})) = \int_ {\Omega} G (\xi , \mathbf {x}) f (\xi) d \xi , \tag {3}
+$$
+
+which is valid for any forcing  $f(\mathbf{x})$ . Thus once the Green's function is computed, the solution for arbitrary forcing functions can be easily extracted from integration. This integration represents a superposition of a continuum of delta function forcings that are used to represent  $f(\mathbf{x})$ .
+
+In many modern applications, nonlinearity plays a fundamental role so that the BVP is of the form
+
+$$
+N [ u (\mathbf {x}) ] = F (\mathbf {x}) \tag {4}
+$$
+
+where  $N[\cdot]$  is a nonlinear differential operator. For this case, the principle of linear superposition no longer holds and the notion of a fundamental solution is lost. However, modern deep learning algorithms allow us the flexibility of learning a coordinate transformation (and their inverses) of the form
+
+$$
+v = \psi (u), \tag {5a}
+$$
+
+$$
+f = \phi (F), \tag {5b}
+$$
+
+such that  $\nu$  and  $f$  satisfy the linear BVP (1) for which we generated the fundamental solution (3). This gives a nonlinear fundamental solution through use of this deep learning transformation.
+
+DeepGreen is a supervised learning algorithm which is ultimately a high-dimensional interpolation problem (44) for learning the coordinate transformations  $\psi(u)$  and  $\phi(F)$ . DeepGreen is enabled by a physics-informed deep autoencoder coordinate transformation which establishes superposition for nonlinear BVPs, thus enabling a Koopman BVP framework. The learned Green's function enables accurate construction of solutions with new forcing functions in the same way as a linear BVP. We demonstrate the DeepGreen method on a variety of nonlinear boundary value problems, including a nonlinear 2D Poisson problem, showing that such an architecture can be used in many modern and diverse applications in aerospace, electromagnetics, elasticity, materials, and chemical reactors.
+
+# 2 Deep Autoencoders for Linearizing BVPs
+
+Deep AEs have been used to linearize dynamical systems, which are initial value problems. We extend this idea to BVPs. To be precise, we consider BVPs of the form
+
+$$
+N [ u (\mathbf {x}) ] = F (\mathbf {x}), \quad \mathbf {x} \in \Omega , \tag {6a}
+$$
+
+$$
+B [ u (\mathbf {x}) ] = 0, \quad \mathbf {x} \in \partial \Omega , \tag {6b}
+$$
+
+where  $\Omega$  is a simply connected open set in  $\mathbb{R}^n$  with boundary  $\partial \Omega$ ,  $N$  is a nonlinear differential operator,  $F(\mathbf{x})$  is the nonhomogeneous forcing function,  $B$  is a boundary condition, and  $u(\mathbf{x})$  is the solution to the BVP. We wish to find a pair of coordinate transformations of the form (5) such that  $\nu$  and  $f$  satisfy a linear BVP
+
+$$
+L [ v (\widehat {\mathbf {x}}) ] = f (\widehat {\mathbf {x}}), \quad \widehat {\mathbf {x}} \in \widehat {\Omega}, \tag {7a}
+$$
+
+$$
+\widehat {B} [ v (\widehat {\mathbf {x}}) ] = 0, \quad \widehat {\mathbf {x}} \in \partial \widehat {\Omega}, \tag {7b}
+$$
+
+![](images/d5eae06288c45eab53b7ea7969d3ad91932b8e6e9d7115315587aa80d9c675db.jpg)  
+Figure 1: DeepGreen solves nonlinear BVPs by identifying the Green's Function of the nonlinear problem using a deep learning approach with a dual autoencoder architecture. An nonhomogenous linear BVP can be solved using the Green's function approach, but a nonlinear BVP cannot. DeepGreen transforms a nonlinear BVP to a linear BVP, solves the linearized BVP, and then inverse transforms the linear solution to solve the nonlinear BVP.
+
+where  $L$  is a linear differential operator,  $\widehat{\mathbf{x}}$  is the spatial coordinate in the transformed domain  $\widehat{\Omega}$  with boundary  $\partial \widehat{\Omega}$ . Because  $L$  is linear, there is a Green's function  $G(\widehat{\mathbf{x}},\xi)$  such that the solution  $\nu$  to the BVP (7) can be obtained through convolution of the Green's function and transformed forcing function
+
+$$
+v (\widehat {\mathbf {x}}) = \int_ {\widehat {\Omega}} G (\xi , \widehat {\mathbf {x}}) f (\xi) d \xi . \tag {8}
+$$
+
+The coordinate transformation along with the Green's function of the linearized BVP provide the analog of a Green's function for the nonlinear BVP (6). In particular, for a forcing function  $F(\mathbf{x})$ , the transformed forcing function is  $f = \phi(F)$ . The solution to the linearized BVP can be obtained using the Green's function  $\nu = \int G(\xi, \widehat{\mathbf{x}}) f(\xi) d\xi$ . Then the solution to the nonlinear BVP (6) is obtained by inverting the coordinate transformation  $u = \psi^{-1}(\nu)$  to obtain the solution to the nonlinear BVP,  $u(\mathbf{x})$ .
+
+The question that remains is how to discover the appropriate coordinate transformations  $\psi$  and  $\phi$ . We leverage the universal approximation properties of neural networks in order to learn these transformations. In order to use neural networks, we first need to discretize the BVP. Let  $\mathbf{u}$  be a spatial discretization of  $u(\mathbf{x})$  and  $\mathbf{F}$  be a discretization of  $F(\mathbf{x})$ .
+
+Then the discretized version of the BVP (6) is
+
+$$
+\mathbf {N} [ \mathbf {u} ] = \mathbf {F}, \tag {9a}
+$$
+
+$$
+\mathbf {B} [ \mathbf {u} ] = \mathbf {0}. \tag {9b}
+$$
+
+Neural networks  $\psi_{u}$  and  $\phi_F$  are used to transform  $\mathbf{u}$  and  $\mathbf{F}$  to the latent space vectors  $\mathbf{v}$  and  $\mathbf{f}$
+
+$$
+\mathbf {v} = \psi_ {u} (\mathbf {u}), \tag {10a}
+$$
+
+$$
+\mathbf {f} = \phi_ {F} (\mathbf {F}), \tag {10b}
+$$
+
+where  $\mathbf{v}$  and  $\mathbf{f}$  satisfy the linear equation
+
+$$
+\mathbf {L} \mathbf {v} = \mathbf {f}, \tag {11}
+$$
+
+for some matrix  $\mathbf{L}$ , which is also learned. In order to learn invertible transforms  $\psi_{u}$  and  $\phi_F$ , we construct the problem as a pair of autoencoder networks.
+
+In this construction, the transforms  $\psi_{u}$  and  $\phi_F$  are the encoders and the transform inverses are the decoders. The network architecture and loss functions are shown in Figure 2. The neural network is trained using numerous and diverse solutions to the nonlinear BVP (9), which can be obtained with many different forcings  $\mathbf{F}_k$ . Consider a dataset comprised of pairs of discretized solutions and forcing functions  $\{\mathbf{u}_k,\mathbf{F}_k\}_{k = 1}^N$ . The loss function for training the network is
+
+![](images/f6f2248dcc80ac5f68097aa26a673d4e723376ca6d805d815514fa4c825aed13.jpg)
+
+![](images/7100d9cacce5262a49b32ddcafd98afec9d8b47b53632154d02de73f6a50c33e.jpg)  
+Figure 2: DeepGreen architecture. Two autoencoders learn invertible coordinate transformations that linearize a nonlinear boundary value problem. The latent space is constrained to exhibit properties of a linear system, including linear superposition, which enables discovery of a Green's function for nonlinear boundary value problems.
+
+![](images/b162c8ab2981961634689c811a54250845e08bf797e948986e9cc3dc72a0d94d.jpg)
+
+Loss Functions  
+
+<table><tr><td rowspan="2">Autoencoder</td><td>u = ψu-1ψu u</td><td>(L1)</td></tr><tr><td>F = φF-1φFF</td><td>(L2)</td></tr><tr><td rowspan="2">Linearity</td><td>Lv = f</td><td>(L3)</td></tr><tr><td>Lv i + Lv j = fi + fj</td><td>(L4)</td></tr><tr><td rowspan="2">Cross-Mapping</td><td>F = φF-1○L○ψu u</td><td>(L5)</td></tr><tr><td>u = ψu-1○G○φFF</td><td>(L6)</td></tr></table>
+
+the sum of six losses, each of which enforces a desired condition. The loss functions can be split into three categories:
+
+1. Autoencoder losses: We wish to learn invertible coordinate transformations given by equations (10a) and (10b). In order to do so, we use two autoencoders. The autoencoder for  $\mathbf{u}$  consists of an encoder  $\psi_{u}$  which performs the transformation (10a) and a decoder  $\psi_{u}^{-1}$  which inverts the transformation. In order to enforce that the encoder and decoder are inverses, we use the autoencoder loss
+
+$$
+\mathcal {L} _ {1} = \frac {1}{N} \sum_ {k = 1} ^ {N} \frac {\left\| \mathbf {u} _ {k} - \boldsymbol {\psi} _ {u} ^ {- 1} \circ \boldsymbol {\psi} _ {u} (\mathbf {u} _ {k}) \right\| _ {2} ^ {2}}{\left\| \mathbf {u} _ {k} \right\| _ {2} ^ {2}}. \tag {12}
+$$
+
+Similarly, there is an autoencoder for  $\mathbf{F}$  where the encoder  $\phi_F$  performs the transformation (10b). This transformation also has an inverse enforced by the associated autoencoder loss function
+
+$$
+\mathcal {L} _ {2} = \frac {1}{N} \sum_ {k = 1} ^ {N} \frac {\left\| \mathbf {F} _ {k} - \phi_ {F} ^ {- 1} \circ \phi_ {F} (\mathbf {F} _ {k}) \right\| _ {2} ^ {2}}{\left\| \mathbf {F} _ {k} \right\| _ {2} ^ {2}}. \tag {13}
+$$
+
+2. Linearity losses: In the transformed coordinate system, we wish for the BVP to be linear so that the operator can be represented by a matrix  $\mathbf{L}$ . The matrix  $\mathbf{L}$
+
+and the encoded vectors  $\mathbf{v}$  and  $\mathbf{f}$  should satisfy equation (11). This is enforced with the linear operator loss
+
+$$
+\mathcal {L} _ {3} = \frac {1}{N} \sum_ {k = 1} ^ {N} \frac {\left\| \mathbf {f} _ {k} - \mathbf {L} \mathbf {v} _ {k} \right\| _ {2} ^ {2}}{\left\| \mathbf {f} _ {k} \right\| _ {2} ^ {2}}. \tag {14}
+$$
+
+The major advantage of working with a linear operator is that linear superposition holds. We use a linear superposition loss in order to further enforce the linearity of the operator in the latent space
+
+$$
+\mathcal {L} _ {4} = \frac {1}{N ^ {2}} \sum_ {j = 1} ^ {N} \sum_ {i = 1} ^ {N} \frac {\left\| \left(\mathbf {f} _ {i} + \mathbf {f} _ {j}\right) - \mathbf {L} \left(\mathbf {v} _ {i} + \mathbf {v} _ {j}\right) \right\| _ {2} ^ {2}}{\left\| \mathbf {f} _ {i} + \mathbf {f} _ {j} \right\| _ {2} ^ {2}}. \tag {15}
+$$
+
+3. Cross-mapping losses: The losses described above are theoretically sufficient to find coordinate transformations for  $\mathbf{u}$  and  $\mathbf{F}$  as well as a linear operator  $\mathbf{L}$ . However, in practice the two autoencoders were not capable of generating the Green's function solution. To rectify this, we add two "cross-mapping" loss functions that incorporate parts of both autoencoders. The first cross-mapping loss enforces the following mapping from  $\mathbf{u}$  to  $\mathbf{F}$ . First, one of the solutions from the dataset  $\mathbf{u}_k$  is encoded with  $\psi_u$ . This is an approximation for  $\mathbf{v}_k$ . This is then multiplied by the matrix  $\mathbf{L}$ , giving an approximation of  $\mathbf{f}_k$ . Then the result is decoded with  $\phi_F^{-1}$ .
+
+This gives an approximation of  $\mathbf{F}_k$ . The  $\mathbf{u}$  to  $\mathbf{F}$  cross-mapping loss is given by the formula
+
+$$
+\mathcal {L} _ {5} = \frac {1}{N} \sum_ {k = 1} ^ {N} \frac {\left\| \mathbf {F} _ {k} - \phi_ {F} ^ {- 1} \circ \mathbf {L} \circ \psi_ {u} (\mathbf {u} _ {k}) \right\| _ {2} ^ {2}}{\left\| \mathbf {F} _ {k} \right\| _ {2} ^ {2}}. \tag {16}
+$$
+
+We can similarly define a cross-mapping from  $\mathbf{F}$  to  $\mathbf{u}$ . For a forcing function  $\mathbf{F}_k$  from the dataset, it is encoded with  $\phi_F$ , multiplied by the Green's function  $(\mathbf{G} = \mathbf{L}^{-1})$ , and then decoded with  $\psi_u^{-1}$  to give an approximation of  $\mathbf{u}_k$ . The  $\mathbf{F}$  to  $\mathbf{u}$  cross-mapping loss is
+
+$$
+\mathcal {L} _ {6} = \frac {1}{N} \sum_ {k = 1} ^ {N} \frac {\left\| \mathbf {u} _ {k} - \psi_ {u} ^ {- 1} \circ \mathbf {L} ^ {- 1} \circ \phi_ {F} (\mathbf {F} _ {k}) \right\| _ {2} ^ {2}}{\left\| \mathbf {u} _ {k} \right\| _ {2} ^ {2}}. \tag {17}
+$$
+
+Note that this final loss function gives the best indication of the performance of the network to solve the nonlinear BVP (9) using the Green's function. The strategy for solving (9) for a given discrete forcing function  $\mathbf{F}$  is to encode the forcing function to obtain  $\mathbf{f} = \phi_F(\mathbf{F})$ , apply the Green's function as in equation (8) to obtain  $\mathbf{v}$ , and then decode this function to get the solution  $\mathbf{u} = \psi_u^{-1}(\mathbf{v})$ . The discrete version of the convolution with the Green's function given in equation (8) is multiplication by the matrix  $\mathbf{L}^{-1}$ .
+
+For the encoders  $\phi$  and  $\psi$  and decoders  $\phi^{-1}$  and  $\psi^{-1}$ , we use a residual neural network (ResNet) architecture (43). The ResNet architecture has been successful in learning coordinate transformations for physical systems (15) and is motivated by near-identity transformations in physics. The linear operator  $\mathbf{L}$  is constrained to be a real symmetric matrix and therefore is self-adjoint. Additionally,  $\mathbf{L}$  is initialized as the identity matrix. Therefore,  $\mathbf{L}$  is strictly diagonally dominant for at least the early parts of training which guarantees  $\mathbf{L}$  is invertible and well-conditioned. For more information on the network architecture and training procedure, see Appendix B.
+
+# 3 Results
+
+The DeepGreen architecture, which is highlighted in Fig. 2 and whose detailed loss functions are discussed in the last section, is demonstrated on a number of canonical nonlinear BVPs. The first three BVPs are one-dimensional systems and the final one is a two-dimensional system. The nonlinearities in these problems do not allow for a fundamental solution, thus recourse is typically made to numerical computations to achieve a solution. DeepGreen, however, can produce a fundamental solution which can then be used for any new forcing of the BVP.
+
+![](images/09b3833928335daef0f14802cd536be04405170612817679f9ab037b11e366a8.jpg)  
+Figure 3: Learning curve. This is a typical learning curve for the DeepGreen architecture. The vertical dashed line indicates where the training procedure transitions from autoencoders-only (only  $\mathcal{L}_1$  and  $\mathcal{L}_2$ ) to a full-network training procedure (all losses).
+
+# 3.1 Cubic Helmholtz
+
+The architecture and methodology is best illustrated using a basic example problem. The example problem uses a nonhomogeneous second-order nonlinear Sturm-Liouville model with constant coefficients and a cubic nonlinearity, thus making it a cubic Helmholtz equation. The differential equation is given by
+
+$$
+u ^ {\prime \prime} + \alpha u + \varepsilon u ^ {3} = F (x), \tag {18a}
+$$
+
+$$
+u (0) = u (2 \pi) = 0, \tag {18b}
+$$
+
+where  $u = u(x)$  is the solution when the system is forced with  $F(x)$  with  $x \in (0, 2\pi)$ ,  $\alpha = -1$  and  $\varepsilon = -0.3$ . The notation  $u''$  denotes  $\frac{d^2}{dx^2} u(x)$ . The dataset contains discretized solutions and forcings,  $\{\mathbf{u}_k, \mathbf{F}_k\}_{k=1}^N$ . The forcing functions used for training are cosine and Gaussian functions; details of data generation and the forcing functions are provided in Appendix A. The data is divided into three groups: training, validation, and test. The training and validation sets are used for training the model. The test set is used to evaluate the results. The training set contains  $N_{train} = 8906$  vector pairs  $\mathbf{u}_k$  and  $\mathbf{F}_k$ . The validation set contains  $N_{validation} = 2227$  and test set contains  $N_{test} = 1238$ .
+
+# 3.1.1 Training the Model
+
+The autoencoders used in this example are constructed with fully connected layers. In both autoencoders, a ResNet-like identity skip connection connects the input layer to the layer before dimension reduction in the encoder, and the first full-dimension layer in the decoder with the final output layer (see Figure 14).
+
+![](images/ea5851fe293e51cdc3d72d87efc22f0d569f854e9af41765e74b83b22bb7a69c.jpg)  
+Figure 4: Latent space representations  $\mathbf{v}_k$  and  $\mathbf{f}_k$ . The autoencoder transformation  $\psi_u$  encodes  $\mathbf{u}_k$  to the latent space, producing the vector  $\mathbf{v}_k$  (orange). The forcing vector  $\mathbf{F}_k$  is transformed by  $\psi_F$  to the encoded vector  $\mathbf{f}_v$  (blue).
+
+The model is trained in a two-step procedure. First, the autoencoders are trained, without connection in the latent space, to condition the networks as autoencoders. In this first phase, only the autoencoder loss functions listed in Figure 2 are active ( $\mathcal{L}_1$  and  $\mathcal{L}_2$ ). After a set number of epochs, the latent spaces are connected by an invertible matrix operator,  $\mathbf{L}$ , and the remaining 4 loss functions in Figure 2 become active ( $\mathcal{L}_3 - \mathcal{L}_6$ ). In the final phase of training, the autoencoder learns to encode a latent space representation of the system where properties associated with linear systems hold true, such as linear superposition.
+
+Figure 3 shows a typical training loss curve. The vertical dashed line indicates the transition between the two training phases. The models in this work are trained for 75 epochs in the first autoencoder-only phase and 2750 epochs in the final phase. The first-phase epoch count was tuned empirically based on final model performance. The final phase epoch count was selected for practical reasons; the training curve tended to flatten around 2750 epochs in all of our tested systems. The autoencoder latent spaces are critically important. The latent space is the transformed vector space where linear properties (e.g. superposition) are enforced which enables the solution of nonlinear problems. In the one-dimensional problems, the latent spaces vectors  $\mathbf{v}$  and  $\mathbf{f}$  are in  $\mathbb{R}^{20}$ .
+
+The latent spaces did not have any obvious physical interpretation, and qualitatively appeared similar to the representations shown in Figure 4. We trained 100 models to check the consistency in the learned model and latent space representations, but discovered the latent spaces varied considerably (see Appendix C). This implies the existence of an infinity of solutions to the coordinate transform problem, which indicates further constraints could be placed on the model.
+
+Despite lacking obvious physical interpretations, the latent space enables discovery of an invertible operator  $\mathbf{L}$  which described the linear system  $\mathbf{L}[\mathbf{v}_k] = \mathbf{f}_k$ . The operator
+
+matrix  $\mathbf{L}$  can be inverted to yield the Green's function matrix  $\mathbf{G}$ , which allows computation of solutions to the linearized system  $\mathbf{v}_k = \mathbf{G}[\mathbf{f}_k]$ . An example of the operator  $\mathbf{L}$  and its inverse  $\mathbf{G}$  are shown in Figure 5. The operator and Green's function shown in Figure 5 display an important prominent feature seen in all of the results: a diagonally-dominant structure. We initialize the operator as an identity matrix, but the initialization had little impact on the diagonally-dominant form of the learned operator and Green's function matrices (see Appendix C). The diagonally-dominant operators indicate that the deep learning network tends to discover a coordinate transform yielding a nearly-orthonormal basis, which mirrors the common approach of diagonalization in spectral theory for Hermitian operators. Furthermore, diagonally-dominant matrices guarantee favorable properties for this application such as being well-conditioned and non-singular.
+
+We emphasize that training parameters and model construction choices used in this work were not extensively optimized. We expect the model performance can be improved in a myriad of ways including extending training times, optimizing model architecture, modifying the size of the latent spaces, restricting the form of the operator, and applying additional constraints to the model. However, these topics are not the main scope of the present work; our focus is to illustrate the use of autoencoders as a coordinate transform for finding solutions to nonlinear BVPs.
+
+# 3.1.2 Evaluating the Model
+
+The goal for this model is to find a Green's function  $\mathbf{G}$  for computing solutions  $\mathbf{u}_k$  to a nonlinear BVP governed by (6) for a given forcing function  $\mathbf{F}_k$ . Similarly, we can estimate the forcing term,  $\mathbf{F}_k$ , given the solution  $\mathbf{u}_k$ . The model is consequently evaluated by its ability to use the learned Green's function and operator for predicting solutions and forcings, respectively, for new problems from a withheld test data set.
+
+Recall the original model is trained on data where the forcing function is a cosine or Gaussian function. As shown in Figure 6, the model performs well on withheld test data where the forcing functions are cosine or Gaussian functions, producing a cumulative loss around  $10^{-4}$ . The solutions  $\mathbf{u}_k$  and forcing  $\mathbf{F}_k$  are depicted for the best, mean, and worst samples scored by cumulative loss.
+
+It's important to note the test data used in Figure 6 is similar to the training and validation data. Because ML models typically work extremely well in interpolation problems, it is reasonable to expect the model to perform well on this test data set.
+
+As an interesting test to demonstrate the ability of the model to extrapolate, we prepared a separate set of test data
+
+![](images/277aba0c7c57fced215d10189c5ded4c2ebb968b5aacfba38bd1d5555f5069b3.jpg)  
+Figure 5: Visualized operator and Green's function. Discovered Green's function  $\mathbf{G} = \mathbf{L}^{-1}$  and corresponding linear operator  $\mathbf{L}$ .
+
+![](images/9dfdbe5a11afbbf4f300723cc93d56b501b871eff658572e5d496162128184a2.jpg)
+
+![](images/fc0e103bcbda520e49846339c6d3765130ae283be558517daa26d4352bfb52d1.jpg)
+
+![](images/948693799902bc7be96f381e9185de0b61b1fa1fdf5289f43462c45b02388080.jpg)
+
+![](images/c6fff6974004d214f7865ad2486da6f49f2af1c61efad2025078d27e7e223924.jpg)
+
+Figure 6: Model predictions on test data. The top row shows the true solution  $\mathbf{u}_k(x)$  and the solution predicted by the network given the forcing  $\mathbf{F}_k(x)$  using the Green's function  $\mathbf{G}$ . The bottom row shows the true forcing function  $\mathbf{F}_k(x)$  compared to the forcing computed by applying the operator  $\mathbf{L}$  to the solution  $\mathbf{u}_k$ . Three columns show the best, mean, and worst case samples as evaluated by the sum of normalized  $\ell 2$  reconstruction errors.  
+![](images/66b3182ac71088e04ecf56a9b72354a410e9c87a4e8f49943a626fde2bfe8202.jpg)  
+True  $\mathbf{u}(x)$  True  $\mathbf{F}(x)$  Predicted  $\mathbf{u}(x),\mathbf{F}(x)$
+
+![](images/929b7dbaaa16309ebe0d910921bf8040339756b698423fcb5afc1c8c5de31125.jpg)
+
+![](images/df72d49d72beb00e3f0221f23a157bc2778d7f1bb2e45681987aab19a2ce9523.jpg)
+
+$\{\mathbf{u}_k,\mathbf{F}_k\}_{k = 1}^N$  containing solutions where  $\mathbf{F}_k$  are cubic polynomial forcing functions. This type of data was not present in training, and provides some insight into the generality of the learned linear operator and Green's function matrices. Figure 7 shows examples of how the model performs on these cubic polynomial-type forcing functions. Similar to Figure 6, the best, mean, and worst samples are shown as graded by overall loss. Figures 6 and 7 provide some qualitative insight into the model's performance on specific instances selected from the pool of evaluated data. A quantitative perspective of the model's performance is presented in Figure 8. This box plot shows statistics (median value,  $Q_{1}$ ,  $Q_{3}$ , and range) for four of the loss functions evaluated on the similar (cosine and Gaussian) test data. Note the superposition loss function is not scored in this plot because the superposition loss function can only be evaluated within a single batch,
+
+and the loss depends on batch size and composition.
+
+In conclusion, the DeepGreen architecture enables discovery of invertible, linearizing transformations that facilitate identification of a linear operator and Green's function to solve nonlinear BVPs. It is tested on data similar and dissimilar to the training data, and evaluated on the loss functions that guide the training procedure. The discovered operator and Green's function take on a surprisingly diagonally-dominant structure, which hints at the model's preference to learn an optimal basis. The model appears to extrapolate beyond the test data, suggesting that the learned operator is somewhat general to the system.
+
+![](images/4b017d31cc4f5411062fb5b3ceb08404d837e1eaee53e8aa1f6d2f4434bdd120.jpg)
+
+![](images/3c0ab8f526fb192bd3bc50b02c8d26770957f64db0a193fafcf696731422e3e1.jpg)
+
+![](images/3db07ce75c645f33923b8b0912407481e6474e376002e511d9be02173b3286bb.jpg)
+
+![](images/239069ec9ea74bd74a8d672a0637ed20baae0f2172ac16b7c19399614183efe5.jpg)
+
+![](images/fcd95e9b810006e534dd97015ae442abfe1f8d36cfe1ba5add8d115f36e21b15.jpg)
+
+![](images/4e5debfafaee15114c82085453c87137bb39c9745bec5e072d8902de9a68356a.jpg)
+
+![](images/1045dbb0362948ae2e5a008d5889b42e55bb367c6289a73e4b9f0378cd4d77bd.jpg)
+
+![](images/ee83b12fd6ca16a3a3971e14286719dc9295d8b250132895152a72c207244767.jpg)  
+Figure 7: Model predictions on cubic Helmholtz forced system. The top row shows the true solution  $\mathbf{u}_k(x)$  and the solution predicted by the network given the forcing  $\mathbf{F}_k(x)$  using the Green's function  $\mathbf{G}$ . The bottom row shows the true forcing function  $\mathbf{F}_k(x)$  compared to the forcing computed by applying the operator  $\mathbf{L}$  to the solution  $\mathbf{u}_k$ . Three columns show the best, mean, and worst case samples as evaluated by the sum of normalized  $\ell 2$  reconstruction errors.
+
+![](images/7fcdb42c1b3d66d1f38f09dc95594e92597b59540202feb44a3b398712222b10.jpg)  
+Figure 8: Model performance summary. Distribution of loss values are shown for every sample in the test data set. Model loss functions are minimized during training, making them a natural metric to use for summarizing performance.
+
+# 3.2 Nonlinear Sturm-Liouville and Biharmonic Operators
+
+In addition to the example system described above, the approach was applied to two other one-dimensional systems. We used the same training procedure and forcing functions that were described in Section 3.1. The first is a system governed by the nonlinear Sturm-Liouville equation
+
+$$
+[ - p (x) u ^ {\prime} ] ^ {\prime} + q (x) (u + \varepsilon u ^ {3}) = F (x),
+$$
+
+$$
+u (0) = u (2 \pi) = 0,
+$$
+
+where  $\varepsilon = 0.4$  controls the extent of nonlinearity, and  $p(x)$  and  $q(x)$  are spatially-varying coefficients
+
+$$
+p (x) = 0. 5 \sin (x) - 3,
+$$
+
+$$
+q (x) = 0. 6 \sin (x) - 2,
+$$
+
+with  $x \in [0, 2\pi]$ . The final one-dimensional system is a biharmonic operator with an added cubic nonlinearity
+
+$$
+\left[ - p u ^ {\prime \prime} \right] ^ {\prime \prime} + q \left(u + \varepsilon u ^ {3}\right) = F (x),
+$$
+
+$$
+u (0) = u (2 \pi) = u ^ {\prime} (0) = u ^ {\prime} (2 \pi) = 0,
+$$
+
+where  $p = -4$  and  $q = 2$  are the coefficients and  $\varepsilon = 0.4$  controls the nonlinearity. As in the prior example, the forcing functions in the training data are cosine and Gaussian functions, which are described further in Appendix A.
+
+Results for all the one-dimensional models, including the cubic Helmholtz example from Section 3.1, are presented in Table 1. Model performance is quantitatively summarized by box plots and the Green's function matrix is shown for each model.
+
+Importantly, the learned Green's function matrices consist
+
+<table><tr><td>Nonlinear cubic Helmholtz (constant coefficients) u&#x27;&#x27; + αu + εu3 = F u(0) = u(L) = 0</td><td>Nonlinear Sturm-Liouville (varying p(x), q(x)) [−pu&#x27;]&#x27; + qu + αqu3 = F u(0) = u(L) = 0</td><td>Nonlinear Biharmonic operator (constant coefficients) −pu&#x27;&#x27;&#x27; + qu + αqu3 = F u(0) = u(L) = 0</td></tr><tr><td>G(x,ξ)</td><td>G(x,ξ)</td><td>G(x,ξ)</td></tr><tr><td>0.2</td><td>0.1</td><td>0.5</td></tr><tr><td>0.0</td><td>0.0</td><td>0.0</td></tr><tr><td>-0.2</td><td>-0.1</td><td>-0.5</td></tr><tr><td>2π</td><td>2π</td><td>2π</td></tr><tr><td>x</td><td>x</td><td>x</td></tr><tr><td>Normalized MSE</td><td>L1 L2 L3 L4 L5 L6</td><td>L3 L1 L6</td></tr></table>
+
+Table 1: Summary of results for three one-dimensional models. The models are provided with the Green's function learned by DeepGreen. A summary box plot shows the relative losses  $\mathcal{L}_1$ ,  $\mathcal{L}_2$ ,  $\mathcal{L}_3$ ,  $\mathcal{L}_5$ , and  $\mathcal{L}_6$  for all three model systems.
+
+tently exhibit diagonally-dominant structure. The losses for the nonlinear cubic Helmholtz equation and the nonlinear Sturm-Liouville equation are similar which indicates that spatially-varying coefficients do not make the problem significantly more difficult for the DeepGreen architecture. In contrast, the loss for the nonlinear biharmonic equation are about an order of magnitude higher than the other two systems. This result implies the fourth-order problem is more difficult than the second-order problems. Also of note is that the linear operator loss  $\mathcal{L}_3$  is consistently the highest loss across all models. Therefore, it is easier for DeepGreen to find invertible transformations for the solutions and forcing functions than it is to find a linear operator that connects the two latent spaces.
+
+# 3.3 Nonlinear Poisson Equation
+
+We also tested our method on a two-dimensional system. The two-dimensional model is a nonlinear version of the Poisson equation with Dirichlet boundary conditions
+
+$$
+- \nabla \cdot \left[ \left(1 + u ^ {2}\right) \nabla u \right] = F (\mathbf {x}), \quad \mathbf {x} \in \Omega , \tag {19a}
+$$
+
+$$
+u = 0, \quad \mathbf {x} \in \partial \Omega , \tag {19b}
+$$
+
+where  $\Omega := (0,2\pi) \times (0,2\pi)$ . Similar to the one-dimensional models, the forcing functions used to train the model are cosine and Gaussian functions, the details of which are provided in Appendix A. The sizes of the data sets are also similar to the one-dimensional data sets. The training data contains  $N_{train} = 9806$  vector pairs  $\mathbf{u}_k$  and  $\mathbf{F}_k$ , the validation data contains  $N_{validation} = 2452$ , and the test data contains  $N_{test} = 1363$ .
+
+The network architecture of the encoders and decoders for the two-dimensional example differs from the one-dimensional examples. Instead of fully connected layers, convolutional layers were used in the encoders and decoders. However, we still use a ResNet architecture. Additionally, the latent space vectors are in  $\mathbb{R}^{200}$ . Full details on the network architecture can be found in Appendix B. Note that the method proposed for discovering Green's functions allows for any network architecture to be used for the encoders and decoders. For the one-dimensional example, similar results were obtained using fully connected and convolutional layers. However, the convolutional architecture was better in the two-layer case and also allowed for a more manageable number of parameters for the wider network
+
+![](images/e9db65ccb11ec04b0294fa8bfeec9c00f4eca640ae7a4932f57a1ca30e33b8e3.jpg)  
+(a)
+
+![](images/28e94546be6b6b8bc1a8e61af88d20b0ecdeac4ea647f9f76fc67bba5670a138.jpg)
+
+![](images/424173575812cff27c0122b01e34f1e429e7588cb6d3012573e4d73977d19efc.jpg)
+
+![](images/9ac7384fe15648cca6b0532a14ea8f7874d266c33ce6a9cd6dbf35005235fd0b.jpg)  
+(b)
+
+![](images/803bbc5e5d5c0132ca00c8b82d2af60bc28a0d2969b3386503b7f65d3715aebe.jpg)
+
+![](images/7adbd2ba06736d3418c3e59a4412a705c923c12d16cda3ac620b292dc43d5fcf.jpg)
+
+![](images/64d04c0275cd10a579617c86dde977be61a9d83711a29f73ddac5a369f323a91.jpg)
+
+![](images/32e0aaa7d44b372629abcceab3653447f03091650680fdcea43818dbdb1885f7.jpg)
+
+![](images/88d5ab09c3f9a638ad18506023920dee70c545ab741c765e6a8fa0e79e8cd497.jpg)
+
+![](images/23063adab60da3fac660de995ca953f5cc423c5180629b3ef475fdb85db275f8.jpg)  
+Figure 9: Model predictions for the (a) best and (b) worst examples from test data with Gaussian and cosine forcings. In both (a) and (b), the top row shows the true solution  $\mathbf{u}(\mathbf{x})$ , the predicted solution using the Green's function, and the difference between the true and predicted solution. The bottom row shows the true forcing function  $\mathbf{F}(\mathbf{x})$ , the predicted forcing function, and the difference between the true and predicted forces. In order to account for the difference in scale between  $\mathbf{u}(\mathbf{x})$  and  $\mathbf{F}(\mathbf{x})$ , the differences are scaled by the infinity norm of the true solution or forcing function  $(\text{Difference} = (\text{True} - \text{Predicted}) / ||\text{True}||_{\infty})$ .
+
+![](images/ed8169ff7c84de55682087c871408dbc4f09f275ccb66ae30f25f739c8b659fa.jpg)
+
+![](images/997b8abb4b2de7c43ea520a5dc0543d85539c94e56573178d40ad48781e5e63b.jpg)
+
+that resulted from discretizing the two-dimensional space.
+
+The operator and Green's function for the two-dimensional model are similar to those displayed in shown in Figure 5. The diagonal dominance is even more prevalent in this case than the one-dimensional example. The model was evaluated on test data containing cosine and Gaussian forcing functions. Figure 9a shows the true solution  $\mathbf{u}(x)$  and forcing function  $\mathbf{F}(x)$  as well as the network predictions for the example from the test data for which the model performed the best (i.e. the smallest value of the loss). The difference between the true and predicted functions is shown in the right column of Figure 9a and is scaled by the infinity norm of the true solution or forcing functions. Figure 9b
+
+shows similar results but for the worst example from the test data. In both cases, the model gives a qualitatively correct solution for both  $\mathbf{u}(x)$  and  $\mathbf{F}(x)$ . Unsurprisingly, the network struggles most on highly localized forcing functions and has the highest error in the region where the forcing occurs.
+
+The model was also evaluated on test data that has cubic polynomial forcing functions, a type of forcing function not found in the training data. The best and worst examples are shown in Figure 10. Although the model does not perform as well for test data which is not similar to the training data, the qualitative features of the predicted solutions are still consistent with the true solutions. Figure 11 shows a box plot of the model's performance on the similar (cosine
+
+![](images/16df3d54e223e39d4ac87f0636827325ba78028e21a745e374b57a2d65e2c66b.jpg)  
+(a)  
+Figure 10: Model predictions for the (a) best and (b) worst examples from test data with cubic polynomial forcings. In both (a) and (b), the top row shows the true solution  $\mathbf{u}(\mathbf{x})$ , the predicted solution using the Green's function, and the difference between the true and predicted solution. The bottom row shows the true forcing function  $\mathbf{F}(\mathbf{x})$ , the predicted forcing function, and the difference between the true and predicted forces. In order to account for the difference in scale between  $\mathbf{u}(\mathbf{x})$  and  $\mathbf{F}(\mathbf{x})$ , the differences are scaled by the infinity norm of the true solution or forcing function  $(\text{Difference} = (\text{True} - \text{Predicted}) / ||\text{True}||_{\infty})$ .
+
+and Gaussian forcing test data). The results are similar to the one-dimensional results, and, in fact, better than the bi-harmonic operator model.
+
+# 4 Conclusion
+
+We have leveraged the expressive capabilities of deep learning to discover linearizing coordinates for nonlinear BVPs, thus allowing for the construction of the fundamental solution or nonlinear Green's function. Much like the Koopman operator for time-dependent problems, the linearizing transformation provides a framework whereby the fundamental
+
+solution of the linear operator can be constructed and used for any arbitrary forcing. This provides a broadly applicable mathematical architecture for constructing solutions for nonlinear BVPs, which typically rely on numerical methods to achieve solutions. Our DeepGreen architecture can achieve solutions for arbitrary forcings by simply computing the convolution of the forcing with the Green's function in the linearized coordinates.
+
+Given the critical role that BVPs play in the mathematical analysis of constrained physical systems subjected to external forces, the DeepGreen architecture can be broadly applied in nearly every engineering discipline since BVPs are
+
+![](images/2b6e51d5c2fce293a7274060ad49518f4e54ef2ead81f16e5c047e4ff6492e4e.jpg)  
+Figure 11: Two-dimensional Poisson model performance summary. Distribution of loss values are shown for every sample in the test data set. Model loss functions are minimized during training, making them a natural metric to use for summarizing performance.
+
+prevalent in diverse problem domains including fluid mechanics, electromagnetics, quantum mechanics, and elasticity. Importantly, DeepGreen provides a bridge between a classic and widely used solution technique to nonlinear BVP problems which generically do not have principled techniques for achieving solutions aside from brute-force computation. DeepGreen establishes this bridge by providing a transformation which allows linear superposition to hold. DeepGreen is a flexible, data-driven, deep learning approach to solving nonlinear boundary value problems (BVPs) using a dual-autoencoder architecture. The autoencoders discover an invertible coordinate transform that linearizes the nonlinear BVP and identifies both a linear operator  $L$  and Green's function  $G$  which can be used to solve new nonlinear BVPs. We demonstrated that the method succeeds on a variety of nonlinear systems including nonlinear Helmholtz and Sturm-Liouville problems, nonlinear elasticity, and a 2D nonlinear Poisson equation. The method merges the strengths of the universal approximation capabilities of deep learning with the physics knowledge of Green's functions to yield a flexible tool for identifying fundamental solutions to a variety of nonlinear systems.
+
+# Acknowledgments
+
+SLB is grateful for funding support from the Army Research Office (ARO W911NF-17-1-0306). JNK acknowledges support from the Air Force Office of Scientific Research (FA9550-19-1-0011).
+
+# References
+
+1. I. Stakgold, Boundary Value Problems of Mathematical Physics: 2-Volume Set, vol. 29 (Siam, 2000).
+
+2. J.-B. J. Fourier, Théorie analytique de la chaleur (Chez Firmin Didot, 1822).  
+3. J. D. Jackson, Classical electrodynamics (John Wiley & Sons, 2007).  
+4. A. Yariv, Quantum Electronics (John Wiley & Sons, 1989).  
+5. I. Stakgold, M. J. Holst, *Green's functions and boundary value problems*, vol. 99 (John Wiley & Sons, 2011).  
+6. B. Lusch, J. N. Kutz, S. L. Brunton, Deep learning for universal linear embeddings of nonlinear dynamics. Nature communications 9, 4950 (2018).  
+7. K. Champion, B. Lusch, J. N. Kutz, S. L. Brunton, Data-driven discovery of coordinates and governing equations. Proceedings of the National Academy of Sciences 116, 22445-22451 (2019).  
+8. C. Wehmeyer, F. Noé, Time-lagged autoencoders: Deep learning of slow collective variables for molecular kinetics. The Journal of Chemical Physics 148, 241703 (2017).  
+9. A. Mardt, L. Pasquali, H. Wu, F. Noé, VAMPnets: Deep learning of molecular kinetics. Nature Communications 9 (2018).  
+10. N. Takeishi, Y. Kawahara, T. Yairi, Advances in Neural Information Processing Systems (2017), pp. 1130-1140.  
+11. E. Yeung, S. Kundu, N. Hodas, 2019 American Control Conference (ACC) (2019), pp. 4832-4839.  
+12. S. E. Otto, C. W. Rowley, Linearly-recurrent autoencoder networks for learning dynamics. SIAM Journal on Applied Dynamical Systems 18, 558-593 (2019).  
+13. Q. Li, F. Dietrich, E. M. Bollt, I. G. Kevrekidis, Extended dynamic mode decomposition with dictionary learning: A data-driven adaptive spectral decomposition of the koopman operator. Chaos: An Interdisciplinary Journal of Nonlinear Science 27, 103111 (2017).  
+14. C. J. Dsilva, R. Talmon, R. R. Coifman, I. G. Kevrekidis, Parsimonious representation of nonlinear dynamical systems through manifold learning: A chemotaxis case study. Applied and Computational Harmonic Analysis 44, 759-773 (2018).  
+15. C. Gin, B. Lusch, J. N. Kutz, S. L. Brunton, Deep learning models for global coordinate transformations that linearize PDEs. To appear in the European Journal of Applied Mathematics (2020). Preprint Available: arXiv:1911.02710.
+
+16. G. Cybenko, Approximation by superpositions of a sigmoidal function. Mathematics of Control, Signals, and Systems (MCSS) 2, 303-314 (1989).  
+17. K. Hornik, M. Stinchcombe, H. White, Universal approximation of an unknown mapping and its derivatives using multilayer feedforward networks. *Neural networks* 3, 551-560 (1990).  
+18. B. O. Koopman, Hamiltonian systems and transformation in Hilbert space. Proceedings of the National Academy of Sciences 17, 315-318 (1931).  
+19. I. Mezić, A. Banaszuk, Comparison of systems with complex behavior. Physica D: Nonlinear Phenomena 197, 101 - 133 (2004).  
+20. I. Mezić, Spectral properties of dynamical systems, model reduction and decompositions. *Nonlinear Dynamics* 41, 309-325 (2005).  
+21. M. Budisic, I. Mezić, Geometry of the ergodic quotient reveals coherent structures in flows. Physica D: Nonlinear Phenomena 241, 1255-1269 (2012).  
+22. I. Mezić, Analysis of fluid flows via spectral properties of the Koopman operator. Annual Review of Fluid Mechanics 45, 357-378 (2013).  
+23. S. L. Brunton, B. W. Brunton, J. L. Proctor, J. N. Kutz, Koopman invariant subspaces and finite linear representations of nonlinear dynamical systems for control. PLOS ONE 11, 1-19 (2016).  
+24. P. J. Schmid, Dynamic mode decomposition of numerical and experimental data. Journal of Fluid Mechanics 656, 5-28 (2010).  
+25. C. W. Rowley, I. Mezić, S. Bagheri, P. Schlatter, D. Henningson, Spectral analysis of nonlinear flows. J. Fluid Mech. 645, 115-127 (2009).  
+26. J. N. Kutz, S. L. Brunton, B. W. Brunton, J. L. Proctor, Dynamic Mode Decomposition: Data-Driven Modeling of Complex Systems (SIAM, 2016).  
+27. F. Noé, F. Nuske, A variational approach to modeling slow processes in stochastic dynamical systems. Multiscale Modeling & Simulation 11, 635-655 (2013).  
+28. F. Nuske, B. G. Keller, G. Pérez-Hernández, A. S. Mey, F. Noé, Variational approach to molecular kinetics. Journal of chemical theory and computation 10, 1739-1752 (2014).  
+29. M. O. Williams, I. G. Kevrekidis, C. W. Rowley, A data-driven approximation of the Koopman operator: Extending dynamic mode decomposition. Journal of Nonlinear Science 25, 1307-1346 (2015).  
+30. M. O. Williams, C. W. Rowley, I. G. Kevrekidis, A kernel-based method for data-driven Koopman spectral analysis. Journal of Computational Dynamics 2, 247-265 (2015).  
+31. S. Klus, F. Nuske, P. Koltai, H. Wu, I. Kevrekidis, C. Schütte, F. Noé, Data-driven model reduction and transfer operator approximation. Journal of Nonlinear Science 28, 985-1010 (2018).  
+32. J. N. Kutz, J. L. Proctor, S. L. Brunton, Applied Koopman theory for partial differential equations and data-driven modeling of spatio-temporal systems. Complexity 2018, 1-16 (2018).  
+33. J. Page, R. R. Kerswell, Koopman analysis of burgers equation. Physical Review Fluids 3, 071901 (2018).  
+34. C. Bishop, Pattern Recognition and Machine Learning (Springer, 2006).
+
+35. I. Goodfellow, Y. Bengio, A. Courville, Deep Learning (MIT Press, 2016).  
+36. R. Rico-Martinez, I. Kevrekidis, K. Krischer, Nonlinear system identification using neural networks: dynamics and instabilities. Neural networks for chemical engineers pp. 409-442 (1995).  
+37. R. Gonzalez-Garcia, R. Rico-Martinez, I. Kevrekidis, Identification of distributed parameter systems: A neural net based approach. Computers & chemical engineering 22, S965-S968 (1998).  
+38. S. H. Rudy, J. N. Kutz, S. L. Brunton, Deep learning of dynamics and signal-noise decomposition with time-stepping constraints. Journal of Computational Physics 396, 483-506 (2019).  
+39. H. Lange, S. L. Brunton, N. Kutz, From fourier to koopman: Spectral methods for long-term time series prediction. arXiv preprint arXiv:2004.00574 (2020).  
+40. Y. Liu, J. N. Kutz, S. L. Brunton, Hierarchical deep learning of multiscale differential equation time-steppers. arXiv preprint arXiv:2008.09768 (2020).  
+41. D. Z. Huang, K. Xu, C. Farhat, E. Darve, Learning constitutive relations from indirect observations using deep neural networks. Journal of Computational Physics 416, 109491 (2020).  
+42. S. Pan, K. Duraisamy, Physics-informed probabilistic learning of linear embeddings of nonlinear dynamics with guaranteed stability. SIAM Journal on Applied Dynamical Systems 19, 480-509 (2020).  
+43. K. He, X. Zhang, S. Ren, J. Sun, Proceedings of the IEEE conference on computer vision and pattern recognition (2016), pp. 770-778.  
+44. S. Mallat, Understanding deep convolutional networks. Philosophical Transactions of the Royal Society A: Mathematical, Physical and Engineering Sciences 374, 20150203 (2016).  
+45. A. Logg, G. N. Wells, Dolfin: Automated finite element computing. ACM Transactions on Mathematical Software 37 (2010).  
+46. M. S. Alnæs, J. Blechta, J. Hake, A. Johansson, B. Kehlet, A. Logg, C. Richardson, J. Ring, M. E. Rognes, G. N. Wells, The fenics project version 1.5. Archive of Numerical Software 3 (2015).  
+47. A. Logg, K.-A. Mardal, G. N. Wells, et al., Automated Solution of Differential Equations by the Finite Element Method (Springer, 2012).
+
+# Appendix A Data Generation
+
+# A.1 1D Problems
+
+The data for all of the one-dimensional systems are created using the same method and forcing functions. Each solution is computed on an evenly-spaced 128-point grid using MATLAB's bvp5c solver with a relative error tolerance of  $10^{-8}$  and an absolute error tolerance of  $10^{-10}$ . The forcing functions  $\mathbf{F}_k(x)$  are designed to yield a variety of solutions  $\mathbf{u}_k$  such that  $\| \mathbf{u}_k\|_2\simeq 1$ .
+
+The training data consists of two types of systems: Gaussian-forced and cosine-forced systems. The Gaussian-forced systems have forcing functions of the form
+
+$$
+F _ {k} (x) = a \exp \left(\frac {- (x - b) ^ {2}}{2 c ^ {2}}\right),
+$$
+
+where  $a \in \{-25, -20, -15, -10, -5, 5, 10, 15, 20, 25\}$ ,  $b \in \{0, 2\pi/19, 4\pi/19, \ldots, 2\pi\}$ , and  $c \in \{0.1, 0.3, 0.5, \ldots, 4.9\}$ . The cosine forcing functions are of the form
+
+$$
+F _ {k} (x) = \alpha \cos (\beta x),
+$$
+
+where  $\alpha \in \{1, 1.1, 1.2, \ldots, 10\}$  and  $\beta \in \{1, 1.05, 1.10, \ldots, 5\}$ . This gives a total of 5000 Gaussian-forced solutions and 7371 cosine-forced solutions. For the cubic Helmholtz equation and the nonlinear Sturm-Liouville equation with spatially-varying coefficients, all of the 12371 solutions were within the error tolerance. However, there were 97 solutions of the nonlinear biharmonic equation that did not meet the error tolerance and were therefore discarded. Of the remaining data,  $10\%$  are randomly chosen and withheld as test data,  $80\%$  are used as training data, and  $20\%$  are used as validation data.
+
+In order to test the ability of the network to generalize, we also have another test data set that consists of solutions with cubic forcing functions of the form
+
+$$
+F _ {i} (x) = \gamma (x - \pi) ^ {3},
+$$
+
+where  $\gamma \in \{0.01, 0.03, 0.05, \ldots, 0.29\}$ , and cubic forcing functions of the form
+
+$$
+F _ {i} (x) = \gamma (x - \pi) ^ {3} + \zeta (x - \pi) ^ {2} + \psi ,
+$$
+
+where  $\gamma \in \{0.01, 0.03, 0.05, \ldots, 0.29\}, \zeta \in \{0.01, 0.03, 0.05, \ldots, 0.49\}$ , and  $\psi \in \{-5, -4, -3, \ldots, 5\}$ . There are a total of 4140 solutions with cubic forcing functions.
+
+# A.2 2D Problem
+
+The two-dimensional data satisfies the nonlinear Poisson equation (19). The solutions are computed with a finite element method using the DOLFIN library (45) of the FEn-iCS Project (46, 47). The forcing functions are similar to
+
+the one-dimensional data in that there are Gaussian and cosine forcing functions along with a separate data set of cubic polynomial forcing functions used to test the ability of the network to generalize. The Gaussian forcing functions are of the form
+
+$$
+F _ {k} (x, y) = a \exp \left(\frac {- (x - b _ {x}) ^ {2} - (y - b _ {y}) ^ {2}}{2 c ^ {2}}\right),
+$$
+
+where  $a \in \{-25, -20, -15, -10, -5, 5, 10, 15, 20, 25\}$ ,  $b_x, b_y \in \{\pi/3, 2\pi/3, \pi, 4\pi/3, 5\pi/3\}$ , and  $c \in \{0.1, 0.3, 0.5, \ldots, 4.9\}$ . The cosine forcing functions are of the form
+
+$$
+F _ {k} (x, y) = \alpha \cos (\beta_ {x} x) \cos (\beta_ {y} y),
+$$
+
+where  $\alpha \in \{1,1.1,1.2,\dots ,10\}$  and  $\beta_{x},\beta_{y}\in$ $\{1,1.5,2,\ldots ,5\}$  . The cubic forcing functions are of the form
+
+$$
+F _ {i} (x, y) = \gamma_ {x} (x - \pi) ^ {3} + \gamma_ {y} (y - \pi) ^ {3},
+$$
+
+where  $\gamma_x, \gamma_y \in \{0.01 + 0.28k/3 | k = 0, 1, 2, 3\}$ , and cubic forcing functions of the form
+
+$$
+\begin{array}{l} F _ {i} (x, y) = \gamma_ {x} (x - \pi) ^ {3} + \gamma_ {y} (y - \pi) ^ {3} \\ + \zeta_ {x} (x - \pi) ^ {2} + \zeta_ {y} (y - \pi) ^ {2} + \psi , \\ \end{array}
+$$
+
+where  $\gamma_x, \gamma_y \in \{0.01 + 0.28k/3 | k = 0,1,2,3\}$ ,  $\zeta_x, \zeta_y \in \{0.01,0.07,0.13,0.19,0.25\}$ , and  $\psi \in \{-5,-4,-3,\ldots,5\}$ . There are 6250 solutions with Gaussian forcing functions, 7371 solutions with cosine forcing functions, and 4416 solutions with cubic forcing functions.
+
+# Appendix B Neural Network Implementation Details
+
+The model training procedure is kept constant for all of the examples in this work. The networks are optimized with an Adam optimizer  $(\beta_{1} = 0.9, \beta_{2} = 0.999)$ . Every numerical experiment starts by training a set of 20 models for a 'small' number of epochs. Each of the 20 models has a randomly selected learning rate for the Adam optimizer, uniformly selected between  $10^{-2}$  and  $10^{-5}$ . The initial training period consists of two phases: autoencoder-only (75 epochs) and full model (250 epochs). The autoencoder-only phase only enforces the autoencoder losses  $\mathcal{L}_1$  and  $\mathcal{L}_2$  during backpropagation. A checkpoint algorithm is used to keep track of the model with the lowest overall loss throughout the training procedure. At the end of the initial period, the best model is selected and the others are eliminated. The best model is trained for an additional 2500 epochs.
+
+![](images/a9968e9e87198623b8cbfadfc0a44ae62fbdc9119d282af2d4c06ff03ee63b7d.jpg)  
+Figure 12: Encoder network architecture for the two-dimensional data. All convolutional layers use  $4 \times 4$  kernels with stride size 1, zero-padding, and ReLU activation functions. All pooling layers are average pooling layers with pool size 2 and stride size 2.
+
+![](images/e26184c30f9eecab4019311bcddd1b7cf32e2f70e56bbf30e5f8288d5a0d90a5.jpg)  
+Figure 13: Decoder network architecture for the two-dimensional data. All transposed convolutional layers use  $4 \times 4$  kernels with stride size 2, zero-padding, and ReLU activation functions except for the last layer which has stride size 1.
+
+![](images/5e2346b6fdf8f733b14f857b3e3ab6f0d4d133d087a843ebb26d5d0adebf0032.jpg)  
+Figure 14: Layer-by-layer autoencoder architecture for 1D problems.
+
+There are two network architectures in this work. The architectures depicted in Figures 12 and 13 are applied to the two-dimensional nonlinear Poisson BVP. The architecture depicted in Figure 14, is applied to one-dimensional prob
+
+lems.
+
+The two architectures have a few training variables in common. Both models use variance scaling initialization,  $\ell_2$  regularization  $(\lambda = 10^{-6})$ , and ReLu activation functions for fully connected (1D architecture) and convolutional (2D architecture) layers. Notably, the two layers immediately before and after the latent space do not have activation functions. A normalized mean squared error loss function is used for all of the loss functions, as described in Section 2. The models are trained in batches of 64 samples.
+
+The 2D architecture utilizes convolutional layers and pooling layers, as shown in Figures 12 and 13. All convolutional layers use a kernel size of  $4 \times 4$ . There are differences between the convolutional layers in the encoder and the convolutional layers in the decoder. The encoder convolutional layers use a stride size of  $1 \times 1$  and an increasing number of filters (8, 16, 32, 64). The deconvolutional layers use a stride size of  $2 \times 2$  with decreasing filter size (32, 16, 8). Pooling layers are similar for both the encoder and decoder with a stride size of  $2 \times 2$  and a pool size of  $2 \times 2$ .
+
+# Appendix C Additional Results
+
+The repeatability of the results and models learned by the DeepGreen architecture are interesting to study from the
+
+![](images/3356c80982f93ed88323b99af56f0cfe5e11fbb7f164cecdb5c41b514dfc5231.jpg)  
+Figure 15: Initial vs learned operators for an operator matrix  $L$  for different initial conditions. The top row shows identity matrix initialization, the middle row shows random initialization (He normal), and the bottom row shows a Toeplitz gradient initialization.
+
+perspective of operator convergence and latent space representations. In both cases, we aim to investigate the convergence of the model parameters to determine if the learned latent spaces and operators are unique or non-unique.
+
+# C.1 Operator Initialization
+
+We repeat the training procedure for DeepGreen with three different initialization approaches for the operator  $L$ . Again, we train with data from the example nonlinear cubic Helmholtz model. This experiment focuses on comparing the initial values of the operator  $L$  with the final values of the operator at the end of training to determine if the DeepGreen approach tends to converge to a specific operator construction. The results in Figure 15 show the initial and final operator for identity-initialized, randomly initialized, and Toeplitz-initialized operator matrices. Impressively, the result shows that the network tends to learn operators with diagonal dominance for all of the tested initialization strategies. This approach, which DeepGreen appears to prefer, draws strong parallels to the coordinate diagonalization approach commonly used in physics.
+
+# C.2 Latent Space Analysis
+
+We repeat the training procedure for the example system, the nonlinear cubic Helmholtz model, a total of one hundred times. A single sample was selected from the training data and the latent space representation,  $\mathbf{v}_i$  and  $\mathbf{f}_i$ , of the input vectors  $\mathbf{u}_i$  and  $\mathbf{F}_i$  are computed. Statistics for the latent space representations are presented in Figure 16. It is evident that the latent space vectors are not identical between runs, and that the values in the vector do not follow any particular statistical distribution. This information implies that the learned weights in the model, and the learned latent space representations, vary for each training instance and do not appear to converge to a single representation.
+
+# C.3 Residual network architecture
+
+All of the autoencoders used in this work use a residual network (ResNet) architecture. In order to demonstrate the advantage of the ResNet architecture, we trained six models using the DeepGreen architecture for each of the four systems. Three of the models use the ResNet skip connections, while three do not use the ResNet architecture.
+
+For the two simplest systems, the nonlinear cubic Helmholtz equation and the nonlinear Sturm-Liouville equation, the difference between the models with and without the ResNet skip connections was negligible. For the nonlinear cubic Helmholtz equation, the mean validation loss for the non-ResNet models was  $2.7 \times 10^{-3}$  and the median validation loss was  $2.4 \times 10^{-3}$ . Using the ResNet architecture resulted in a mean validation loss of  $3.5 \times 10^{-3}$  and a median validation loss of  $8.8 \times 10^{-4}$ . The ResNet architecture resulted in a lower median validation loss but a higher mean due to one of the three models performing much more poorly than the other two. The results for the nonlinear Sturm-Liouville system are analogous. With a non-ResNet architecture, the mean validation loss was  $4.5 \times 10^{-3}$  and the median validation loss was  $4.0 \times 10^{-3}$ . With a ResNet architecture, the mean validation loss was  $5.7 \times 10^{-3}$  and the median validation loss was  $3.1 \times 10^{-3}$ . Therefore, the use of the ResNet architecture produced similar results to a non-ResNet architecture for these two simple systems.
+
+For the two systems that had larger losses - the nonlinear biharmonic equation in 1D and the 2D nonlinear Poisson equation - the ResNet architecture was clearly superior to a non-ResNet architecture. For the nonlinear biharmonic equation, the ResNet architecture yields a mean validation loss of  $2.5 \times 10^{-2}$  and median validation loss of  $2.8 \times 10^{-2}$  for the three models, compared with  $3.8 \times 10^{-2}$  and  $4.0 \times 10^{-2}$ , respectively, for the non-ResNet architecture. Therefore, the ResNet architecture performed better in terms of both the mean and median loss. The ResNet ar
+
+![](images/ab08214492df667dd9b2cb8aa75ac96b9b8cc0eff70a4e0fef5e08324e31f32a.jpg)  
+Figure 16: Statistics of latent space values of a single sample over 100 experimental runs.
+
+![](images/3caf8355ba9c8033aae1db835a64924a49590c7b3a83f6e2105ad9f1e2e9a401.jpg)
+
+chitecture is absolutely vital for the nonlinear Poisson system. Without the ResNet architecture, the model essentially did not converge. Both the mean and median validation losses were  $1.9 \times 10^{0}$ . In contrast, the ResNet architecture had a mean validation loss of  $1.8 \times 10^{-2}$  and a median of  $1.9 \times 10^{-3}$ .

data/2021/2101_00xxx/2101.00117/b1510fde-b32e-4443-bd7a-7c6aed392142_content_list.json

@@ -1,3 +1,1495 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:c26559082ac27eb347bfbc6b400d994892c6e34b11670de760752c16a6b518d7
-size 74862
+[
+    {
+        "type": "text",
+        "text": "Multi-task Retrieval for Knowledge-Intensive Tasks",
+        "text_level": 1,
+        "bbox": [
+            231,
+            80,
+            771,
+            101
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Jean Maillard* Vladimir Karpukhin* Fabio Petroni  \nWen-tau Yih Barlas Oğuz Veselin Stoyanov Gargi Ghosh  \nFacebook AI",
+        "bbox": [
+            228,
+            134,
+            779,
+            181
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "{jeanm,vladk, fabiopetroni, scottyih, barlaso, ves, gghosh}@fb.com",
+        "bbox": [
+            136,
+            184,
+            870,
+            200
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Abstract",
+        "text_level": 1,
+        "bbox": [
+            262,
+            263,
+            342,
+            279
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Retrieving relevant contexts from a large corpus is a crucial step for tasks such as open-domain question answering and fact checking. Although neural retrieval outperforms traditional methods like tfidf and BM25, its performance degrades considerably when applied to out-of-domain data. Driven by the question of whether a neural retrieval model can be universal and perform robustly on a wide variety of problems, we propose a multi-task trained model. Our approach not only outperforms previous methods in the few-shot setting, but also rivals specialised neural retrievers, even when in-domain training data is abundant. With the help of our retriever, we improve existing models for downstream tasks and closely match or improve the state of the art on multiple benchmarks.",
+        "bbox": [
+            142,
+            294,
+            463,
+            551
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 Introduction",
+        "text_level": 1,
+        "bbox": [
+            115,
+            567,
+            260,
+            583
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Knowledge-intensive tasks is the common designation for a class of real-world NLP problems which, because of their nature, require large amounts of knowledge about the world (Petroni et al., 2020). For example, open-domain question answering requires producing answers to general factoid questions; fact checking involves determining the veracity of claims based on a database of trusted evidence. Practical solutions to these tasks usually involve an efficient retrieval component that, given an input query, selects a limited subset of relevant information from a large knowledge source. Sophisticated downstream models then consider the input only in the context of the retrieved information, and perform the final task.",
+        "bbox": [
+            114,
+            595,
+            492,
+            835
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "The standard retrieval component in many systems (e.g., Thorne et al., 2018; Wang et al., 2018; Chen et al., 2017) has long relied on term-matching methods, such as tfidf or BM25 (Robertson and Zaragoza, 2009). These methods rely on efficient algorithms and usually perform reasonably well regardless of the problem. In contrast, recent neural retrieval models, such as ICT (Lee et al., 2019), DPR (Karpukhin et al., 2020) and RAG (Lewis et al., 2020b) achieve better results by learning directly from task-specific training data and going beyond simple keyword matching. While task specialisation results in improved task performance, researchers have observed that a retriever trained for one specific domain will typically achieve low out-of-domain performance, and even lower performance on entirely different tasks (Petroni et al., 2020). This has two implications. First, unlike tfidf or BM25, neural retrieval models are unsuitable for low data regimes such as few- and zero-shot settings. Second, task-specific retrievers complicate practical applications where multiple knowledge-intensive tasks may need to be performed using the same supporting database or over the same input text. It may not be practical to deploy multiple separate specialised models due to computational performance or memory concerns.",
+        "bbox": [
+            509,
+            263,
+            887,
+            697
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "We ask the following question in this work: can we develop a universal neural retriever? Namely, we target a retriever that can perform well on a wide variety of problems, without task-specific fine-tuning, but, if additional in-domain labelled data is available, it can be further fine-tuned to improve the performance. We perform a large experimental study to attempt to build such a universal retrieval model. We find that, by jointly training on an extensive selection of retrieval tasks, we obtain a model which is not only more robust than previous approaches, but also can lead to better performance on the downstream knowledge-intensive tasks when",
+        "bbox": [
+            509,
+            700,
+            887,
+            910
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "aside_text",
+        "text": "arXiv:2101.00117v1 [cs.CL] 1 Jan 2021",
+        "bbox": [
+            21,
+            322,
+            60,
+            717
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "page_footnote",
+        "text": "* Equal Contribution.",
+        "bbox": [
+            139,
+            846,
+            275,
+            859
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "page_footnote",
+        "text": "<sup>1</sup>While large pre-trained neural models have been shown to incorporate real-world knowledge in their parameters and thus may skip retrieval (Petroni et al., 2019), they still have limited capacity and suffer from a lack of explainability.",
+        "bbox": [
+            115,
+            859,
+            489,
+            909
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "plugged into an existing system. Our approach combines the benefits from IR-based models with those of task-specific neural retrievers – namely, good performance when no (or not enough) training data is available and high task performance due to its ability to learn highly specialised representations.",
+        "bbox": [
+            114,
+            74,
+            490,
+            185
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Our contributions can be summarised as follows.",
+        "bbox": [
+            134,
+            187,
+            490,
+            203
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "list",
+        "sub_type": "text",
+        "list_items": [
+            "- We propose a single general-purpose \"universal\" retrieval model, able to perform comparably or better than specialised retriever approaches in both zero-shot (leave-one-out) and few-shot retrieval. We investigate several model variants, shedding light on what are the aspects of the architecture that affect its performance.",
+            "- We show that our model's gains in terms of retrieval directly translate into performance gains for a variety of downstream knowledge-intensive tasks.",
+            "- We will share the implementation as well as our best model. This is in the form of a readily available BERT checkpoint which, as we will show, can be used by NLP practitioners as a strong out-of-the-box retrieval system, but which can also undergo further in-domain training for even higher performance."
+        ],
+        "bbox": [
+            137,
+            212,
+            490,
+            537
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2 Background",
+        "text_level": 1,
+        "bbox": [
+            115,
+            546,
+            257,
+            564
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "In this section, we first give an overview of retrieval methods based on sparse and dense representations. We then discuss a wide range of knowledge-intensive NLP tasks, where retrieval plays a crucial role in solving the problems.",
+        "bbox": [
+            114,
+            573,
+            490,
+            653
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2.1 Retrieval methods",
+        "text_level": 1,
+        "bbox": [
+            115,
+            663,
+            305,
+            678
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Given a large collection of unstructured text passages, information retrieval (IR) can be broadly defined as finding a small set of passages that satisfies an information need, often presented in the form of a short-text query (Manning et al., 2008). Traditional IR methods, such as tfidf and BM25 (Robertson and Zaragoza, 2009), match keywords efficiently with an inverted index. Such methods can be seen as representing queries and passages in high-dimensional, sparse vectors, where each dimension corresponds to a term in the vocabulary and the weight indicates its importance.",
+        "bbox": [
+            114,
+            684,
+            490,
+            876
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "In contrast to tfidf and BM25, dense retrieval methods encode text as a latent semantic vector of",
+        "bbox": [
+            115,
+            877,
+            490,
+            909
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "a fixed, much smaller dimensionality. Whether a passage is relevant to a given query is determined by the distance of their vectors (Deerwester et al., 1990). Although dense representations do not encode tokens explicitly and can potentially map paraphrases of completely different tokens to close vectors, performance of early dense retrieval methods was often inferior to term-matching approaches, except when large labelled data is available (Yih et al., 2011; Gao et al., 2011; Huang et al., 2013). Thanks to success of large pre-trained models (Devlin et al., 2019; Liu et al., 2019b), however, recent dense retrieval methods have shown to outperform the sparse counterparts, when fine-tuned on a small set of in-domain labelled data (Karpukhin et al., 2020; Lewis et al., 2020b; Xiong et al., 2020). Efficient index and search of dense vectors are made possible by maximum inner product search (MIPS) algorithms (e.g., Shrivastava and Li, 2014; Guo et al., 2016), as well as tools like FAISS (Johnson et al., 2019).",
+        "bbox": [
+            507,
+            74,
+            885,
+            412
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Our work is built upon the Dense Passage Retriever (DPR) architecture of Karpukhin et al. (2020), which was initially proposed for the task of open-domain question answering. DPR is a neural bi-encoder model which embeds queries with an encoder  $\\pmb{f}(\\cdot)$  and passages with a separate encoder  $\\pmb{g}(\\cdot)$ . Given an input query  $x$  and a target passage  $y$ , we have",
+        "bbox": [
+            509,
+            413,
+            885,
+            542
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "equation",
+        "text": "\n$$\n\\mathrm {p} (x \\mid y) \\propto \\operatorname {s i m} (x, y),\n$$\n",
+        "text_format": "latex",
+        "bbox": [
+            611,
+            555,
+            781,
+            571
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "where the similarity score  $\\operatorname{sim}(x, y)$  is defined as the inner product of the embeddings of its arguments,  $f(x) \\cdot g(y)$ . Given a query at inference time, calculating its similarity with every possible passage would be prohibitive for large knowledge sources. Therefore, DPR makes use of the FAISS library (Johnson et al., 2019) to perform fast approximate nearest neighbour search in sub-linear time.",
+        "bbox": [
+            509,
+            585,
+            885,
+            727
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Training is based on a contrastive loss. Given a query  $x$ , a relevant passage  $y$ , and a set of  $n$  irrelevant passages  $y_{i}^{-}$ , we train the model by optimising the following negative log likelihood:",
+        "bbox": [
+            509,
+            727,
+            885,
+            783
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "equation",
+        "text": "\n$$\n\\mathcal {L} = - \\log \\frac {\\exp (\\sin (x , y))}{\\exp (\\sin (x , y)) + \\sum_ {i = 1} ^ {n} \\exp (\\sin \\left(x , y _ {i} ^ {-}\\right))}.\n$$\n",
+        "text_format": "latex",
+        "bbox": [
+            524,
+            793,
+            870,
+            825
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "As the set of irrelevant passages, we use the relevant passages for other queries within the same batch, as well as a specially selected \"hard\" confounder. This is a passage which has high lexical",
+        "bbox": [
+            509,
+            845,
+            885,
+            910
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "image",
+        "img_path": "images/621902d35d1bf24b48bdcdbf60ce2d59b0143827fe860dd1388b9ae45571b499.jpg",
+        "image_caption": [
+            "Figure 1: Training of DPR (Karpukhin et al., 2020), a bi-encoder model for open-domain question answering. Queries and passages are encoded as vectors, and retrieval is performed as a maximum inner product search."
+        ],
+        "image_footnote": [],
+        "bbox": [
+            117,
+            74,
+            497,
+            209
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "overlap with the query (high BM25 score), but is not among the set of relevant passages for the given data point. Karpukhin et al. (2020) have shown that the inclusion of such \"hard\" confounders leads to substantially improved training results. This training process is illustrated in Figure 1.",
+        "bbox": [
+            114,
+            322,
+            489,
+            418
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "2.2 Knowledge-intensive Tasks",
+        "text_level": 1,
+        "bbox": [
+            115,
+            443,
+            374,
+            458
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "For the training and evaluation of all models in the paper we make use of KILT, a benchmark and library of datasets (Petroni et al., 2020). KILT consists of a selection of datasets spanning five varied classes of knowledge-intensive tasks (i.e., question answering, slot filling, fact checking, dialogue, entity linking), with the aim to cover many different ways of seeking knowledge. Input queries can vary wildly from one task to the other, and include classic examples of open-domain retrieval tasks such as natural language questions and claims to be verified, as well as more unusual examples like conversation fragments and long chunks of annotated text. Crucially, all datasets distributed in KILT have been re-aligned such that they are all grounded in the same snapshot of Wikipedia, which the authors distribute. The knowledge required to answer any of the queries in the library of tasks can thus be found within the same unified knowledge source.",
+        "bbox": [
+            114,
+            470,
+            489,
+            776
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "To illustrate the variety of ways in which the input queries for different tasks can be formulated, we provide a few simple examples in Table 1. In spite of the differences between query formulations, all these tasks share one crucial aspect: they all require a retriever to fetch the relevant passages from the knowledge source, in order to support the final downstream task.",
+        "bbox": [
+            114,
+            781,
+            489,
+            908
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3 Methods",
+        "text_level": 1,
+        "bbox": [
+            510,
+            74,
+            621,
+            87
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3.1 Universal retrieval",
+        "text_level": 1,
+        "bbox": [
+            510,
+            99,
+            705,
+            112
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Using task-specific models to tackle our collection of retrieval tasks would involve completely separate models, one per dataset. As illustrated in Figure 2, this would lead to a proliferation of models and data, down to separate indexed copies of the knowledge source itself (Wikipedia). This setup will form one of our baselines.",
+        "bbox": [
+            509,
+            120,
+            885,
+            231
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "image",
+        "img_path": "images/41bc26ece836270c36eb8528cdf2d4e8a134c890b3217324417fb9514d3c77c6.jpg",
+        "image_caption": [
+            "Figure 2: Two retrieval tasks performed by two fully-specialised models."
+        ],
+        "image_footnote": [],
+        "bbox": [
+            510,
+            243,
+            899,
+            351
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Multi-task training has been successfully used to allow models to leverage cross-task data, as well as to provide a regularisation effect leading to better generalisation ability (Liu et al., 2019a). We apply this concept to neural retrievers, with the aim of improving performance by jointly leveraging multiple different retrieval datasets.",
+        "bbox": [
+            509,
+            405,
+            885,
+            516
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "image",
+        "img_path": "images/623eb7950ef004cb9855c8a3421984cd9d064b466b281ef895f1503a37d4a238.jpg",
+        "image_caption": [
+            "(a) Separate query encoders.",
+            "Figure 3: Parameter sharing between neural retrievers."
+        ],
+        "image_footnote": [],
+        "bbox": [
+            519,
+            526,
+            690,
+            653
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "image",
+        "img_path": "images/eba6035b726d121e906989332cbda4da7e5b94070803d58fad586d8cd3a1e147.jpg",
+        "image_caption": [
+            "(b) A single retrieval model."
+        ],
+        "image_footnote": [],
+        "bbox": [
+            705,
+            544,
+            875,
+            653
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Our base setup is illustrated in Figure 3b and involves using a shared passage encoder — so that a single index of encoded passages can be used — as well as a query encoder that is shared across all tasks. In essence, in this setup a single DPR model is used to perform all retrieval tasks.",
+        "bbox": [
+            509,
+            715,
+            885,
+            810
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Due to the complexity of training and evaluating retrieval models (which involves training the retriever, embedding all of Wikipedia, and building an index), our main set of experiments is all based on this configuration, which was found to work well in preliminary experiments. However, in order",
+        "bbox": [
+            509,
+            813,
+            885,
+            909
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "table",
+        "img_path": "images/e70ef89c384f0a7c0ebee7364135e6d5c3faba0d7cf3d995089cf2baf402a9e2.jpg",
+        "table_caption": [],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Task</td><td>Example query</td><td>Answer</td><td>Relevant doc.</td></tr><tr><td>Question Answering</td><td>Who is playing the Halftime Show at Super Bowl 2016?</td><td>Coldplay</td><td>The Super Bowl 50 Halftime Show took place on February 7, 2016 ... It was headlined by the British rock group Coldplay.</td></tr><tr><td>Fact Checking</td><td>Bermuda Triangle is in the western part of the Himalayas</td><td>REFUTES</td><td>The Bermuda Triangle ... is a loosely defined region in the western part of the North Atlantic Ocean</td></tr><tr><td>Slot Filling</td><td>Piner Creek [sep] mouth of the watercourse</td><td>Santa Rosa Creek</td><td>Piner Creek discharges to Santa Rosa Creek which in turn ...</td></tr><tr><td>Entity Linking</td><td>Leicestershire take over at top after innings victory. London. [start_ent]West Indian [end_ent] all-rounder Phil Simmons ...</td><td>West Indies cricket team</td><td>The West Indies cricket team is a multi-national men&#x27;s cricket team representing the Anglophone Caribbean region</td></tr><tr><td>Dialogue</td><td>I am a big fan of Star Trek [sep] I don&#x27;t know much about it. When did the first episode air? [sep] It debuted in .. [sep] What is the plot of the show?</td><td>William Shatner plays the role of Captain Kirk</td><td>It followed the interstellar adventures of Captain James T. Kirk (William Shatner) and his crew ...</td></tr></table>",
+        "bbox": [
+            126,
+            72,
+            878,
+            326
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Table 1: Illustrative examples of some of the tasks within KILT, and how varied their query formulations can be.",
+        "bbox": [
+            119,
+            336,
+            875,
+            351
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "to report on the performance of alternative architectures, we also investigate the following additional variants in a restricted experimental setting, limited to a few tasks:",
+        "bbox": [
+            114,
+            376,
+            490,
+            441
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "list",
+        "sub_type": "text",
+        "list_items": [
+            "- Task-specific query encoder. A different query encoder is used for each family of tasks, e.g. all question answering tasks use the same query encoder, but fact checking uses a different one. This is meant to allow for potentially different needs in processing queries, given the fundamentally diverse nature of the tasks at hand. This setup configuration is illustrated in Figure 3a.",
+            "- Task markers. This approach is similar to our base setup, where a single model performs all tasks. Additionally, we introduce specialised tokens which are inserted at the beginning of each query. Their aim is to help the model distinguish between the different tasks, by marking them. We use one task marker for each of the five task classes of KILT, such that all question answering tasks share the same marker."
+        ],
+        "bbox": [
+            137,
+            450,
+            490,
+            765
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3.2 Adversarial confounder selection",
+        "text_level": 1,
+        "bbox": [
+            115,
+            776,
+            421,
+            791
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "We saw in § 2.1 how \"hard\" confounder passages are collected using a BM25 baseline, following the standard approach in DPR. However, any other retriever can be used to select such confounders, including the very retriever being trained, leading to an iterative, self-adversarial training. Concretely, this amounts to following steps: (1) a first version",
+        "bbox": [
+            114,
+            797,
+            490,
+            910
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "of the retriever is trained with BM25 confounders; (2) new confounders are selected with the trained model, by retrieving high-ranking passages which are not among the set of relevant ones; (3) a second version of the model is trained using the additional new confounders.",
+        "bbox": [
+            509,
+            376,
+            884,
+            472
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Intuitively, it is expected that this approach should lead to higher quality confounders compared to those selected by BM25 based on simple keyword matching. Based on our own experience as well as relevant literature (Khattab et al., 2020), this adversarial approach has been shown to work well for question answering.",
+        "bbox": [
+            509,
+            485,
+            885,
+            599
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "As a way of further pushing the performance of the model, we experiment with this adversarial confounder selection on two datasets, Natural Questions (Kwiatkowski et al., 2019) and TriviaQA (Joshi et al., 2017). We selected these two datasets since, out of all of the tasks we are considering, they have an easy way of checking whether a certain passage is relevant or not for a given query – namely, by checking whether the answer is present in the passage. This enabled us to automatically build sets of confounders, ensuring relevant passages would be excluded.",
+        "bbox": [
+            509,
+            609,
+            885,
+            802
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "page_footnote",
+        "text": "${}^{2}$  Strictly speaking,assuming a passage to be irrelevant because of the absence of the answer span is not formally correct. However, experiments show a good correlation between this simple check and the overall model quality.",
+        "bbox": [
+            509,
+            859,
+            885,
+            910
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "table",
+        "img_path": "images/11f6def3eb26c414f526585b1d5b413e9b5ed21b606e437e383ab67e829f8904.jpg",
+        "table_caption": [],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Dataset</td><td>Task class</td><td>#Train</td></tr><tr><td>FEVER</td><td>Fact Checking</td><td>71 k</td></tr><tr><td>AIDA-YAGO 2</td><td>Entity Linking</td><td>18 k</td></tr><tr><td>T-REx</td><td>Slot Filling</td><td>2,284 k</td></tr><tr><td>Zero Shot RE</td><td>Slot Filling</td><td>132 k</td></tr><tr><td>Natural Questions</td><td>QA</td><td>77 k</td></tr><tr><td>HotpotQA</td><td>QA</td><td>69 k</td></tr><tr><td>TriviaQA</td><td>QA</td><td>53 k</td></tr><tr><td>Wizard of Wikipedia</td><td>Dialogue</td><td>80 k</td></tr></table>",
+        "bbox": [
+            117,
+            72,
+            497,
+            234
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Table 2: KILT datasets used in this work, and the size of our converted training sets for each.",
+        "bbox": [
+            114,
+            243,
+            489,
+            273
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "4 Experiments",
+        "text_level": 1,
+        "bbox": [
+            115,
+            298,
+            262,
+            313
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "4.1 Experimental settings",
+        "text_level": 1,
+        "bbox": [
+            115,
+            325,
+            332,
+            340
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Dataset selection For our experiments we select the eight KILT datasets listed in Table 2, which cover all five task classes and include a training split, a validation split, and a held-out test split.",
+        "bbox": [
+            114,
+            347,
+            489,
+            411
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Preprocessing Starting from the raw KILT data, we split each Wikipedia article into disjoint 100-token chunks which form our basic retrieval units, following the approach of Wang et al. (2019) and Karpukhin et al. (2020). To maintain the same language introduced in §3, we will simply call these chunks passages.",
+        "bbox": [
+            114,
+            420,
+            490,
+            533
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "This preprocessing results in a knowledge source of 36 million passages. In order to harmonise all datasets to the same knowledge source, KILT used a mapping strategy based on the BLEU metric to map relevant passages in the original versions of its datasets to passages in its own shared knowledge source (Petroni et al., 2020). Entries included in the KILT training sets which have a mapping BLEU score below 0.5 are likely to be noise, and we exclude them from training.",
+        "bbox": [
+            114,
+            535,
+            489,
+            695
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Multi-tasking Training is performed on the union of all training sets. Since two of the training sets are of different orders of magnitude, we use a simple downsampling strategy to bring them to the same order of magnitude as the others. Preliminary experiments with more complex sampling methods, like resampling all datasets so that each epoch would see an equal number of samples from each, found that they had no measurable effect compared to this simpler approach.",
+        "bbox": [
+            114,
+            706,
+            489,
+            866
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Encoders Our query and passage encoders are initialised as two distinct BERT base uncased en",
+        "bbox": [
+            115,
+            877,
+            489,
+            908
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "coders (Devlin et al., 2019), trained separately. As pooling mechanism we find it effective to simply take the [CLS] token representation at the topmost layer.",
+        "bbox": [
+            509,
+            74,
+            884,
+            139
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Training We train our models for up to 80 epochs. To select the best checkpoint, we perform full evaluations of the validation set retrieval performance at regular intervals. We use the Adam optimiser (Kingma and Ba, 2015) with a learning rate of  $2 \\cdot 10^{-5}$  with warmup and a linear decay schedule, and a dropout rate of 0.1. The batch size is set to 128 samples, and in preliminary experiments we found no benefit in increasing this further. We use an additional \"hard\" confounder per batch, selected based on BM25 score as in (Karpukhin et al., 2020).",
+        "bbox": [
+            509,
+            147,
+            885,
+            338
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Downstream evaluation When evaluating our retriever within a larger architecture to perform a knowledge-intensive task, we replicate the DPR + BART setup of Petroni et al. (2020). This uses DPR to retrieve and comprehend the top 3 passages to the query, which is then processed by a task-specific fine-tuned BART model to generate the final answer for the end task.",
+        "bbox": [
+            509,
+            348,
+            885,
+            475
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "4.2 Universal retrieval",
+        "text_level": 1,
+        "bbox": [
+            510,
+            486,
+            705,
+            500
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "The results of the evaluations reported in (Petroni et al., 2020) show that retrievers trained for question answering have poor performance outside of their domain. We would like to understand if it is possible to design a single model which can accurately satisfy the information needs of a wide variety of knowledge-intensive tasks. In short: Can a neural retriever be universal?",
+        "bbox": [
+            509,
+            507,
+            885,
+            634
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "We perform a comprehensive evaluation of several models on the eight tasks of Table 2. The setups we evaluate include eight task-specific models (one trained on each of the eight datasets), for which we measure both in-domain and out-of-domain performance, and a BM25 baseline. Additionally, we include a multi-task trained model - as described in §3.1 - with the hope that it can learn to perform all tasks satisfyingly. This amounts to 10 models evaluated on eight tasks each, for a total of 80 evaluations.",
+        "bbox": [
+            509,
+            636,
+            885,
+            810
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "To measure retrieval performance, we adopt the main metric used for the KILT benchmark,  $R$ -precision. This is calculated as  $r / R$ , where  $R$  is the total number of relevant passages for a given query, and  $r$  is the number of relevant passages returned among the top-  $R$  retrieval results. For the",
+        "bbox": [
+            509,
+            813,
+            884,
+            909
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "table",
+        "img_path": "images/1bda402b6767ab51523423567418aef5d4a1c8b797946c7dcdaeaafef015b582.jpg",
+        "table_caption": [],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=\"2\">model</td><td rowspan=\"2\">Fact Check. FEV</td><td rowspan=\"2\">Ent. L. AY2</td><td colspan=\"2\">Slot Filling</td><td colspan=\"3\">Open Domain QA</td><td rowspan=\"2\">Dial. WoW</td></tr><tr><td>T-REx</td><td>zsRE</td><td>NQ</td><td>HoPo</td><td>TQA</td></tr><tr><td>Multi-task</td><td>74.72/46.96</td><td>83.78</td><td>69.18/53.54</td><td>77.23/41.70</td><td>61.51/28.80</td><td>44.21/38.42</td><td>61.95/24.56</td><td>39.70/24.07</td></tr><tr><td>BM25</td><td>50.13/40.06</td><td>3.47</td><td>58.60/51.64</td><td>66.43/52.98</td><td>25.83/14.20</td><td>43.95/38.38</td><td>29.44/16.16</td><td>27.50/18.41</td></tr><tr><td colspan=\"9\">Task-specific models</td></tr><tr><td>FEVER</td><td>73.60/43.92</td><td>5.62</td><td>19.50/10.02</td><td>42.88/19.98</td><td>36.69/18.05</td><td>23.18/17.59</td><td>45.08/22.24</td><td>41.27/19.85</td></tr><tr><td>AY2</td><td>47.36/37.58</td><td>81.77</td><td>5.52/4.08</td><td>8.94/5.50</td><td>10.22/6.77</td><td>11.69/10.71</td><td>15.11/8.47</td><td>17.59/13.08</td></tr><tr><td>T-REx</td><td>45.63/25.22</td><td>1.05</td><td>69.08/58.54</td><td>71.64/40.95</td><td>17.10/8.71</td><td>22.31/15.63</td><td>18.10/8.06</td><td>4.02/1.83</td></tr><tr><td>zsRE</td><td>70.10/33.12</td><td>0.42</td><td>68.34/57.40</td><td>97.74/78.81</td><td>25.98/13.81</td><td>22.23/18.35</td><td>28.68/14.44</td><td>10.40/2.09</td></tr><tr><td>NQ</td><td>68.16/14.81</td><td>1.44</td><td>31.78/7.20</td><td>61.12/12.92</td><td>63.24/28.13</td><td>29.39/11.33</td><td>48.39/14.42</td><td>30.77/11.81</td></tr><tr><td>HoPo</td><td>56.18/40.03</td><td>2.07</td><td>35.76/27.62</td><td>44.44/31.15</td><td>35.60/23.26</td><td>46.63/43.47</td><td>41.18/29.37</td><td>23.51/16.02</td></tr><tr><td>TQA</td><td>70.06/10.68</td><td>4.95</td><td>32.22/12.52</td><td>60.37/17.43</td><td>45.01/12.97</td><td>32.62/13.05</td><td>65.12/23.79</td><td>41.17/8.11</td></tr><tr><td>WoW</td><td>59.16/42.79</td><td>3.11</td><td>20.92/18.52</td><td>41.14/35.26</td><td>33.27/22.52</td><td>20.36/17.66</td><td>39.37/23.15</td><td>40.32/20.73</td></tr></table>",
+        "bbox": [
+            124,
+            72,
+            878,
+            258
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Table 3: Page- and passage-level  $R$  -precision on KILT validation data. For the AIDA-YAGO 2 dataset, due to the nature of the task, only page-level retrieval is defined.",
+        "bbox": [
+            114,
+            268,
+            884,
+            297
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "case of  $R = 1$  this is therefore equivalent to precision@1. Table 3 shows retrieval performance on the validation data, with the best performance on a given dataset marked in bold, and the second best performance underlined.",
+        "bbox": [
+            114,
+            323,
+            490,
+            403
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "While the KILT evaluation focuses on retrieval at the level of Wikipedia pages (thereby marking as \"hits\" any results that lie within the correct page), we are also interested in performing an evaluation at a more fine-grained level. We therefore also evaluate our models at the passage level, using a modified version of the official KILT evaluation scripts. These are shown as the second number in each column.",
+        "bbox": [
+            112,
+            405,
+            490,
+            548
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "We straight away notice that the task-specific models tend to achieve high performance on their respective tasks, often taking one of the top two spots. Interestingly, we also note that these neural retrievers consistently outperform the BM25 baseline, showing that the result which Karpukhin et al. (2020) achieved for open-domain question answering also holds for other knowledge-intensive tasks.",
+        "bbox": [
+            114,
+            552,
+            489,
+            695
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "The results reveal a strong performance for the multi-task model, confirming the hypothesis that a single model can be successfully trained to perform a wide variety of retrieval tasks. With the exception of one dataset, the shared model achieves the best retrieval performance or is within a few percentage points of the top score. We note that the one exception is the Zero-shot RE task (Levy et al., 2017), a trivial task in which the query will always contain the title of the page to be retrieved. Indeed, the model specific to this task manages to achieve a near-perfect score.",
+        "bbox": [
+            114,
+            699,
+            489,
+            890
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Another task which stands out for being",
+        "bbox": [
+            132,
+            894,
+            489,
+            910
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "markedly different in formulation is AIDA-YAGO 2 (Hoffart et al., 2011). As shown in Table 2, models that were not trained on this specific task perform it very poorly. Entity linking is a task that is normally better performed by models which are explicitly designed for it (Cao et al., 2020). We nevertheless include it to showcase the ability of neural retrievers to adapt to it, and note how well the multi-task retriever performs on it in spite of its unusual nature.",
+        "bbox": [
+            509,
+            323,
+            885,
+            482
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "4.3 Downstream performance",
+        "text_level": 1,
+        "bbox": [
+            510,
+            498,
+            764,
+            514
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "We saw that our proposed approach achieves strong performance across a variety of retrieval tasks. However, our interest in neural retrievers stems from their use as components within larger systems, to perform tasks such as question answering. Our next experimental question is therefore: Can a universal retriever lead to better downstream performance in knowledge-intensive tasks?",
+        "bbox": [
+            509,
+            521,
+            885,
+            649
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "We perform a downstream evaluation of our approach used in conjunction with BART (Lewis et al., 2020a) as the generative component or classifier, adopting the same setup as Petroni et al. (2020). Results are reported in Table 4, with bold and underline marking the best and second best scores respectively.",
+        "bbox": [
+            509,
+            651,
+            885,
+            762
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "The  $DPR + BART$  line refers to a setup similar to our own, but with the simpler retriever of Karpukhin et al. (2020). Therefore, comparing its performance to ours gives us a clear indication of the contribution of multi-task training on the overall performance on knowledge-intensive tasks. Our proposed model achieves significantly better performance than this baseline in AY2, zsRE and HoPo; while for the other tasks, the discrepancy",
+        "bbox": [
+            509,
+            765,
+            885,
+            910
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "table",
+        "img_path": "images/860c68c2e852a27a1083ca7af8a8e2581de205656fffee4595064a947dbc4f66.jpg",
+        "table_caption": [],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=\"2\">Model</td><td rowspan=\"2\">Fact Check. FEV</td><td rowspan=\"2\">Ent. L. AY2</td><td rowspan=\"2\">Slot Fill. zsRE</td><td colspan=\"3\">Open Domain QA</td><td rowspan=\"2\">Dial. WoW</td><td rowspan=\"2\">Avg.</td></tr><tr><td>NQ</td><td>HoPo</td><td>TQA</td></tr><tr><td>Multi-task + BART</td><td>86.32</td><td>82.61</td><td>57.95</td><td>39.75</td><td>31.77</td><td>59.60</td><td>15.33</td><td>53.33</td></tr><tr><td>DPR + BART</td><td>86.74</td><td>75.49</td><td>30.43</td><td>41.27</td><td>25.18</td><td>58.55</td><td>15.55</td><td>47.60</td></tr><tr><td>RAG</td><td>86.31</td><td>72.62</td><td>44.74</td><td>44.39</td><td>26.97</td><td>71.27</td><td>13.22</td><td>51.36</td></tr><tr><td>T5</td><td>76.30</td><td>74.05</td><td>9.02</td><td>19.60</td><td>12.64</td><td>18.11</td><td>13.49</td><td>31.89</td></tr></table>",
+        "bbox": [
+            127,
+            72,
+            878,
+            192
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Table 4: KILT test scores on the downstream evaluation. Results in the bottom section are as reported in Petroni et al. (2020). The score metrics are accuracy for fact checking, entirely linking and slot filling; exact match for QA; and F1 score for dialogue. $^3$",
+        "bbox": [
+            114,
+            200,
+            884,
+            246
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "is always below two points. This fact is reflected in the last column too, showing that on average multi-task training leads to better downstream performance. The model also compares favourably to RAG (Lewis et al., 2020b), a more advanced system in which the query encoder is fine-tuned on the end task.",
+        "bbox": [
+            114,
+            269,
+            489,
+            381
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "4.4 Zero- and few-shot performance",
+        "text_level": 1,
+        "bbox": [
+            115,
+            394,
+            415,
+            409
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Task-specific neural retrievers can achieve higher performance than IR-based methods, but they are not suitable for cases where no training data (or not enough) is available. In those cases, tfidf and BM25 are the better choice. To evaluate the performance of a multi-task retriever as a suitable replacement for them in this scenario, we run a series of experiments in the low data regimes (few-shot and zero-shot).",
+        "bbox": [
+            114,
+            414,
+            489,
+            558
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "We start by training a set of multi-task retrievers (using the base setup) in the leave-one-out setting for each of the datasets, in order to see how a neural retriever will perform when trained on all domains except for the one it is to be evaluated on. The results of these zero-shot experiments are reported in the second line of Table 5 (again, text here is in bold for the best overall performance, and underlined for second best). They show that, even in the zero-shot setting, the multi-task neural retriever achieves performance that is competitive to BM25, with retrieval being 10 points higher at the page level and 5 points lower at the passage level on average.",
+        "bbox": [
+            114,
+            561,
+            489,
+            785
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "The advantage of neural retrievers over BM25 lies in their ability to improve with training. We therefore look at few-shot training for each task, and create two smaller copies for each of the orig",
+        "bbox": [
+            114,
+            785,
+            489,
+            850
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "inal training sets with a random sample of 128 and 1,024 examples respectively. In order to evaluate the suitability of a multi-task trained retriever as a starting checkpoint for few-shot training, we take the various leave-one-out models and finetune them on our few-shot training sets. To check whether multi-task pre-training is effective, we also compare these to DPR models (which are just initialised with BERT weights) fine-tuned on the same data.",
+        "bbox": [
+            509,
+            269,
+            884,
+            430
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "The bottom two sections of Table 5 report the results. The most dramatic gains from fine-tuning are seen for AY2, an \"outlier\" task whose formulation differs from that of the other tasks, and which seems to benefit the most from seeing in-domain data. The zsRE performance does not seem to improve from fine-tuning on the smaller dataset, but sees a very big jump when switching to the larger dataset. As a reminder, in this trivial task the title of the page to be retrieved always appears at the start of the query. It is therefore not surprising that models specifically fine-tuned on it can achieve near-perfect scores, as long as enough training data is provided.",
+        "bbox": [
+            509,
+            434,
+            884,
+            658
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "In spite of the fine-tuning, we note that both DPR and the multi-task model fail to improve on their performance for T-REx, suggesting that large amounts of training data are required to learn this task. Nevertheless, the multi-task model proves itself more robust, and achieves the top performance on it.",
+        "bbox": [
+            509,
+            662,
+            884,
+            772
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Finally, we note for 2 out of 8 tasks, namely zsRE and WoW, DPR achieves lower page-level retrieval scores than the multi-task model, but performs better at the passage level. This shows that fine-grained and coarse-grained retrieval performance are not always perfectly correlated.",
+        "bbox": [
+            509,
+            778,
+            884,
+            873
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Overall, the experiments show strong results for the multi-task model, with the average zero-shot",
+        "bbox": [
+            509,
+            877,
+            882,
+            910
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "page_footnote",
+        "text": "3Performing this evaluation required retrieving relevant documents for all training sets. Due to the very large size of T-REx, this particular dataset could not be included in this section.",
+        "bbox": [
+            114,
+            859,
+            489,
+            908
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "table",
+        "img_path": "images/d83d4bb26b364066a9d58039acf6e23590cac900387ce8c26904ba91626deb4f.jpg",
+        "table_caption": [],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Model</td><td>FEV</td><td>AY2</td><td>T-REx</td><td>zsRE</td><td>NQ</td><td>HoPo</td><td>TQA</td><td>WoW</td><td>Avg.</td></tr><tr><td>BM25</td><td>50.13/40.06</td><td>3.47</td><td>58.60/51.64</td><td>66.43/52.98</td><td>25.83/14.20</td><td>43.95/38.38</td><td>29.44/16.16</td><td>27.50/18.41</td><td>38.17/33.12</td></tr><tr><td colspan=\"10\">Leave-one-out multi-task models</td></tr><tr><td>Zero-shot</td><td>74.11/37.09</td><td>4.16</td><td>67.54/44.84</td><td>73.42/32.65</td><td>47.23/21.50</td><td>34.72/16.52</td><td>49.08/28.06</td><td>36.92/16.19</td><td>48.40/28.12</td></tr><tr><td>Finetune (128)</td><td>75.95/32.75</td><td>32.38</td><td>67.54/44.84</td><td>73.41/32.65</td><td>47.48/14.98</td><td>34.72/27.82</td><td>54.71/19.82</td><td>48.36/17.46</td><td>54.23/27.19</td></tr><tr><td>Finetune (1k)</td><td>73.08/40.83</td><td>70.40</td><td>67.54/44.84</td><td>93.04/58.67</td><td>51.00/19.90</td><td>39.19/35.43</td><td>59.08/20.22</td><td>47.65/19.75</td><td>62.62/34.23</td></tr><tr><td colspan=\"10\">Vanilla DPR models</td></tr><tr><td>Finetune (128)</td><td>37.99/25.31</td><td>26.23</td><td>0.20/0.02</td><td>0.16/0.00</td><td>20.92/9.52</td><td>14.46/14.08</td><td>26.85/10.54</td><td>30.31/17.20</td><td>19.64/10.95</td></tr><tr><td>Finetune (1k)</td><td>70.87/47.82</td><td>72.49</td><td>0.20/0.02</td><td>90.33/80.20</td><td>43.43/19.81</td><td>30.75/30.50</td><td>52.50/17.33</td><td>44.70/24.92</td><td>50.66/31.51</td></tr></table>",
+        "bbox": [
+            122,
+            71,
+            884,
+            211
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "performance being competitive to BM25, and the average few-shot performance being markedly better than the alternatives. The discrepancy in performance between a vanilla DPR model and the leave-one-out multi-task model is especially noticeable when using the smaller of the two datasets, in which case average performance for the latter is more than double that of vanilla DPR.",
+        "bbox": [
+            114,
+            272,
+            490,
+            401
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "4.5 Model variants",
+        "text_level": 1,
+        "bbox": [
+            115,
+            412,
+            282,
+            426
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "table",
+        "img_path": "images/aa23591cab1d7e0e1d594419600dccce763206545ef6cb41425d39c2b1b8c6e4.jpg",
+        "table_caption": [
+            "Table 5: Page- and passage-level  $R$  -Precision in the zero-shot setting and with additional fine-tuning of 128 and 1,024 examples. We also compare to a BM25 retriever and a DPR model initialised with BERT weights."
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>variant</td><td>FEV</td><td>NQ</td><td>TQA</td></tr><tr><td>Base</td><td>76.38/40.76</td><td>60.91/24.50</td><td>64.77/21.75</td></tr><tr><td>Task markers</td><td>75.84/40.79</td><td>62.31/25.10</td><td>64.04/20.86</td></tr><tr><td>Task-spec. enc.</td><td>73.53/40.02</td><td>61.05/25.52</td><td>64.17/21.23</td></tr></table>",
+        "bbox": [
+            119,
+            441,
+            487,
+            507
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Table 6: Multi-task model variants evaluated on a subset of tasks ( $R$ -precision on validation data at page/passage level).",
+        "bbox": [
+            114,
+            516,
+            489,
+            558
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "In this set of experiments we compare our base multi-task model with the two variants described in § 3.1. Due to the high memory consumption of the \"task-specific encoders\" variant (requiring one full query encoder per task family, in addition to the passage encoder), it was only possible to perform these evaluations in a restricted setting of three datasets. The results in Table 6 do not reveal a clear winner, suggesting that the base architecture might be the better choice due to its simplicity and generally good performance. $^4$",
+        "bbox": [
+            114,
+            579,
+            489,
+            755
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "4.6 Adversarial confounder selection",
+        "text_level": 1,
+        "bbox": [
+            115,
+            766,
+            421,
+            781
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Finally, we evaluate the adversarial confounder selection method described in § 3.2. This involves augmenting our regular training sets with additional confounders for TriviaQA and Natural Ques",
+        "bbox": [
+            114,
+            787,
+            490,
+            851
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "tions, selected using our top multi-task trained model. A new multi-task model is then trained from scratch on this augmented data. Its performance is reported in Table 7, showing an overall improvement across multiple tasks. While this approach is demonstrated here on our multi-task model, it is in fact orthogonal to it, and could be applied to any other neural retrievers trained with a contrastive loss.",
+        "bbox": [
+            509,
+            273,
+            885,
+            416
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "5 Related work",
+        "text_level": 1,
+        "bbox": [
+            510,
+            431,
+            663,
+            445
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "The approach most closely related to ours is DPR (Karpukhin et al., 2020), upon which we built all our retrieval systems. This model is covered in detail in § 2.1, in addition to the historical context. Another closely related approach is the Retrieval-Augmented Generation (RAG) model of Lewis et al. (2020b). In its base configuration it augments DPR with a generative reader, and it trains the query encoder end-to-end (differing from traditional retriever-reader architectures which treat the two steps as disjoint). A natural extension of the work we have presented would be to combine RAG with our joint learning approach, to study whether it can lead to further gains in performance or robustness.",
+        "bbox": [
+            507,
+            458,
+            885,
+            697
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "A number of promising techniques to boost retrieval performance have been proposed recently. These are orthogonal to our work, and as such they could be combined with it. Amongst these, pretraining methods form one class. Inverse Cloze Task (Lee et al., 2019) and its extensions (Chang et al., 2020) are self-supervised pre-training methods designed for retrieval in open-domain question answering. Whether such specific pre-training is beneficial to tasks other than question answering remains an open question. CERT (Fang et al., 2020) is an alternative pre-training approach, inspired by some recent advances in computer vision. While to",
+        "bbox": [
+            507,
+            700,
+            885,
+            910
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "page_footnote",
+        "text": "4Not included in this table, due to very poor performance in preliminary experiments, are two further variants: a base model with a single encoder for both queries and passages, and a base model trained from scratch without BERT pre-training.",
+        "bbox": [
+            114,
+            859,
+            489,
+            910
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "table",
+        "img_path": "images/e938ea3401d9fbf01044d7701b4503bc75fabe9e3b5fbb56039936cfd15d5557.jpg",
+        "table_caption": [],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=\"2\">confounders</td><td rowspan=\"2\">Fact Check. FEV</td><td rowspan=\"2\">Ent. L. AY2</td><td rowspan=\"2\">Slot Filling T-REx</td><td rowspan=\"2\">zsRE</td><td colspan=\"3\">Open Domain QA</td><td rowspan=\"2\">Dial. WoW</td></tr><tr><td>NQ</td><td>HoPo</td><td>TQA</td></tr><tr><td>BM25</td><td>74.72/46.96</td><td>83.78</td><td>69.18/53.54</td><td>77.23/41.70</td><td>61.51/28.80</td><td>44.21/38.42</td><td>61.95/24.56</td><td>39.70/24.07</td></tr><tr><td>BM25 + adv</td><td>74.79/52.12</td><td>84.86</td><td>71.36/61.40</td><td>80.04/54.08</td><td>59.25/40.11</td><td>44.08/41.04</td><td>59.19/34.17</td><td>41.04/24.62</td></tr></table>",
+        "bbox": [
+            124,
+            72,
+            880,
+            137
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Table 7: Comparison of two confounder selection methods for the multi-task model: simple BM25, and BM25 augmented with adversarial confounders ( $R$ -precision on validation data at page/passage level).",
+        "bbox": [
+            114,
+            147,
+            882,
+            177
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "our knowledge this has not been applied to retrieval problems, we believe it might be promising due to its focus on sentence-level semantics (as opposed to the more standard masked language modelling pre-training, which focuses on the token-level).",
+        "bbox": [
+            114,
+            202,
+            489,
+            282
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Another class of orthogonal improvements to dense retrieval involves models which embed passages into multiple fixed-size vectors. Of these, ColBERT (Khattab and Zaharia, 2020) and MEBERT (Luan et al., 2020) are two representative examples. One further approach is ColBERT-QA (Khattab et al., 2020), which additionally uses a data augmentation strategy closely related to our own approach described in § 3.2.",
+        "bbox": [
+            114,
+            284,
+            490,
+            428
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Finally two entity linkers, GENRE (Cao et al., 2020) and BLINK (Wu et al., 2020), are worth mentioning. Being trained specifically for entity linking, these models will generally outperform retrieval-based approaches on that task. While they are not comparable to retrieval models and will not generally be applicable to information retrieval tasks, we mention them here to provide readers with a fuller context of the existing literature.",
+        "bbox": [
+            114,
+            429,
+            489,
+            576
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "6 Conclusions",
+        "text_level": 1,
+        "bbox": [
+            115,
+            589,
+            257,
+            605
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "We have conducted a large-scale experimental study on knowledge-intensive tasks, and how retrieval models that tackle them seek the required information from knowledge bases such as Wikipedia.",
+        "bbox": [
+            114,
+            617,
+            489,
+            697
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "The study started with the question of whether the way in which information is embedded for retrieval purposes is universal. Section 4.2 provided evidence that to a large extent it is, with a single \"universal\" retriever, trained jointly on 8 datasets, often performing comparably to task-specific models.",
+        "bbox": [
+            114,
+            699,
+            490,
+            810
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Armed with this knowledge, in Section 4.3 we plugged our single model in a larger pipeline, in order to see its contribution to the downstream performance on a wide range of knowledge-intensive tasks. This led to an overall improvement in downstream performance, setting new top results for a",
+        "bbox": [
+            114,
+            813,
+            490,
+            910
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "number of tasks in the KILT benchmark.",
+        "bbox": [
+            510,
+            202,
+            815,
+            217
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Next, in Section 4.4, we evaluated the model's performance in the zero-shot and few-shot settings. By evaluating on a wide range of tasks, we were able to show that our proposed approach performs comparably to BM25 in the zero-shot setting, and quickly overtakes it even with minimal in-domain training.",
+        "bbox": [
+            509,
+            219,
+            885,
+            332
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "In Section 4.5 we evaluated a number of more complex variants of the model involving task specialisation, but failed to see clear performance improvements. Finally, in Section 4.6 we saw how a simple iterative approach to data augmentation can lead to better performance.",
+        "bbox": [
+            509,
+            332,
+            885,
+            429
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "In the coming months we will provide a pretrained snapshot of our best-performing model, in the form of a BERT checkpoint. As shown, this model will be useful in zero-shot and few-shot settings as a better performing alternative to both IR-based approaches such as BM25, as well as task-specific models. The multi-task training approach demonstrated here can also be useful in industry settings where several retrieval operations may need to be performed on the same piece of content, and the deployment of multiple task-specific models might not be possible due to space or computational performance concerns.",
+        "bbox": [
+            509,
+            431,
+            885,
+            640
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "References",
+        "text_level": 1,
+        "bbox": [
+            512,
+            670,
+            610,
+            684
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "list",
+        "sub_type": "ref_text",
+        "list_items": [
+            "Nicola De Cao, Gautier Izacard, Sebastian Riedel, and Fabio Petroni. 2020. Autoregressive entity retrieval. ArXiv, abs/2010.00904.",
+            "Wei-Cheng Chang, Felix X. Yu, Yin-Wen Chang, Yiming Yang, and Sanjiv Kumar. 2020. Pre-training tasks for embedding-based large-scale retrieval. In International Conference on Learning Representations.",
+            "Danqi Chen, Adam Fisch, Jason Weston, and Antoine Bordes. 2017. Reading Wikipedia to answer open-domain questions. In Proceedings of the 55th Annual Meeting of the Association for Computational"
+        ],
+        "bbox": [
+            510,
+            694,
+            885,
+            883
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "page_footnote",
+        "text": "E.g. fact checking and hate speech detection.",
+        "bbox": [
+            531,
+            894,
+            815,
+            909
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "list",
+        "sub_type": "ref_text",
+        "list_items": [
+            "Linguistics (Volume 1: Long Papers), pages 1870-1879, Vancouver, Canada. Association for Computational Linguistics.",
+            "Scott Deerwester, Susan T Dumais, George W Furnas, Thomas K Landauer, and Richard Harshman. 1990. Indexing by latent semantic analysis. Journal of the American society for information science, 41(6):391-407.",
+            "Jacob Devlin, Ming-Wei Chang, Kenton Lee, and Kristina Toutanova. 2019. BERT: Pre-training of deep bidirectional transformers for language understanding. In Proceedings of the 2019 Conference of the North American Chapter of the Association for Computational Linguistics: Human Language Technologies, Volume 1 (Long and Short Papers), pages 4171-4186, Minneapolis, Minnesota. Association for Computational Linguistics.",
+            "Hongchao Fang, Sicheng Wang, Meng Zhou, Jiayuan Ding, and Pengtao Xie. 2020. CERT: Contrastive self-supervised learning for language understanding. ArXiv, abs/2005.12766.",
+            "Jianfeng Gao, Kristina Toutanova, and Wen-tau Yih. 2011. Clickthrough-based latent semantic models for web search. In Proceedings of the 34th international ACM SIGIR conference on Research and development in Information Retrieval, pages 675-684. ACM.",
+            "Ruiqi Guo, Sanjiv Kumar, Krzysztof Choromanski, and David Simcha. 2016. Quantization based fast inner product search. In Artificial Intelligence and Statistics, pages 482-490.",
+            "Johannes Hoffart, Mohamed Amir Yosef, Ilaria Bordino, Hagen Fürstenau, Manfred Pinkal, Marc Spanirol, Bilyana Taneva, Stefan Thater, and Gerhard Weikum. 2011. Robust disambiguation of named entities in text. In Proceedings of the 2011 Conference on Empirical Methods in Natural Language Processing, pages 782-792, Edinburgh, Scotland, UK. Association for Computational Linguistics.",
+            "Po-Sen Huang, Xiaodong He, Jianfeng Gao, Li Deng, Alex Acero, and Larry Heck. 2013. Learning deep structured semantic models for web search using clickthrough data. In Proceedings of the 22nd ACM International Conference on Information and Knowledge Management, page 2333-2338, New York, NY, USA. Association for Computing Machinery.",
+            "J. Johnson, M. Douze, and H. Jégou. 2019. Billion-scale similarity search with GPUs. IEEE Transactions on Big Data, pages 1-1.",
+            "Mandar Joshi, Eunsol Choi, Daniel Weld, and Luke Zettlemoyer. 2017. TriviaQA: A large scale distantly supervised challenge dataset for reading comprehension. In Proceedings of the 55th Annual Meeting of the Association for Computational Linguistics"
+        ],
+        "bbox": [
+            117,
+            76,
+            490,
+            908
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "list",
+        "sub_type": "ref_text",
+        "list_items": [
+            "(Volume 1: Long Papers), pages 1601-1611, Vancouver, Canada. Association for Computational Linguistics.",
+            "Vladimir Karpukhin, Barlas Oğuz, Sewon Min, Patrick Lewis, Ledell Wu, Sergey Edunov, Danqi Chen, and Wen-tau Yih. 2020. Dense passage retrieval for open-domain question answering. In Proceedings of the 2020 Conference on Empirical Methods in Natural Language Processing (EMNLP). Association for Computational Linguistics.",
+            "Omar Khattab, Christopher Potts, and Matei Zaharia. 2020. Relevance-guided supervision for OpenQA with ColBERT. ArXiv, abs/2007.00814.",
+            "Omar Khattab and Matei Zaharia. 2020. ColBERT: Efficient and effective passage search via contextualized late interaction over BERT. In Proceedings of the 43rd international ACM SIGIR conference on Research and development in Information Retrieval.",
+            "Diederick P Kingma and Jimmy Ba. 2015. Adam: A method for stochastic optimization. In International Conference on Learning Representations (ICLR).",
+            "Tom Kwiatkowski, Jennimaria Palomaki, Olivia Redfield, Michael Collins, Ankur Parikh, Chris Alberti, Danielle Epstein, Illia Polosukhin, Matthew Kelcey, Jacob Devlin, Kenton Lee, Kristina N. Toutanova, Llion Jones, Ming-Wei Chang, Andrew Dai, Jakob Uszkoreit, Quoc Le, and Slav Petrov. 2019. Natural questions: a benchmark for question answering research. Transactions of the Association of Computational Linguistics.",
+            "Kenton Lee, Ming-Wei Chang, and Kristina Toutanova. 2019. Latent retrieval for weakly supervised open domain question answering. In Proceedings of the 57th Annual Meeting of the Association for Computational Linguistics, pages 6086-6096, Florence, Italy. Association for Computational Linguistics.",
+            "Omer Levy, Minjoon Seo, Eunsol Choi, and Luke Zettlemoyer. 2017. Zero-shot relation extraction via reading comprehension. In Proceedings of the 21st Conference on Computational Natural Language Learning (CoNLL 2017), pages 333-342, Vancouver, Canada. Association for Computational Linguistics.",
+            "Mike Lewis, Yinhan Liu, Naman Goyal, Marjan Ghazvininejad, Abdelrahman Mohamed, Omer Levy, Veselin Stoyanov, and Luke Zettlemoyer. 2020a. BART: Denoising sequence-to-sequence pretraining for natural language generation, translation, and comprehension. In Proceedings of the 58th Annual Meeting of the Association for Computational Linguistics, pages 7871-7880, Online. Association for Computational Linguistics.",
+            "Patrick Lewis, Ethan Perez, Aleksandara Piktus, Fabio Petroni, Vladimir Karpukhin, Naman Goyal, Heinrich Kuttler, Mike Lewis, Wen-tau Yih, Tim Roektaschel, Sebastian Riedel, and Douwe"
+        ],
+        "bbox": [
+            512,
+            76,
+            884,
+            907
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "list",
+        "sub_type": "ref_text",
+        "list_items": [
+            "Kiela. 2020b. Retrieval-augmented generation for knowledge-intensive NLP tasks. In Advances in Neural Information Processing Systems (NeurIPS).",
+            "Xiaodong Liu, Pengcheng He, Weizhu Chen, and Jianfeng Gao. 2019a. Multi-task deep neural networks for natural language understanding. In Proceedings of the 57th Annual Meeting of the Association for Computational Linguistics, pages 4487-4496, Florence, Italy. Association for Computational Linguistics.",
+            "Yinhan Liu, Myle Ott, Naman Goyal, Jingfei Du, Mandar Joshi, Danqi Chen, Omer Levy, Mike Lewis, Luke Zettlemoyer, and Veselin Stoyanov. 2019b. Roberta: A robustly optimized bert pretraining approach. ArXiv, abs/1907.11692.",
+            "Yi Luan, Jacob Eisenstein, Kristina Toutanova, and Michael Collins. 2020. Sparse, dense, and attentional representations for text retrieval. *ArXiv*, abs/2005.00181.",
+            "Christopher D Manning, Hinrich Schütze, and Prabhakar Raghavan. 2008. Introduction to information retrieval. Cambridge university press.",
+            "Fabio Petroni, Aleksandra Piktus, Angela Fan, Patrick Lewis, Majid Yazdani, Nicola De Cao, James Thorne, Yacine Jernite, Vassilis Plachouras, Tim Roktaschel, and Sebastian Riedel. 2020. KILT: a benchmark for knowledge intensive language tasks. In arXiv:2009.02252.",
+            "Fabio Petroni, Tim Rocttäschel, Patrick Lewis, Anton Bakhtin, Yuxiang Wu, Alexander H Miller, and Sebastian Riedel. 2019. Language models as knowledge bases? EMNLP.",
+            "Stephen Robertson and Hugo Zaragoza. 2009. The probabilistic relevance framework: BM25 and beyond. Foundations and Trends in Information Retrieval, 3(4):333-389.",
+            "Anshumali Shrivastava and Ping Li. 2014. Asymmetric LSH (ALSH) for sublinear time maximum inner product search (MIPS). In Advances in Neural Information Processing Systems (NIPS), pages 2321-2329.",
+            "James Thorne, Andreas Vlachos, Christos Christodoulopoulos, and Arpit Mittal. 2018. FEVER: a large-scale dataset for fact extraction and VERIFICATION. In Proceedings of the 2018 Conference of the North American Chapter of the Association for Computational Linguistics: Human Language Technologies, Volume 1 (Long Papers), pages 809-819, New Orleans, Louisiana. Association for Computational Linguistics.",
+            "Shuohang Wang, Mo Yu, Xiaoxiao Guo, Z. Wang, Tim Klinger, Wei Zhang, S. Chang, G. Tesauro, Bowen Zhou, and Jing Jiang. 2018. R3: Reinforced ranker-reader for open-domain question answering. In AAAI."
+        ],
+        "bbox": [
+            117,
+            76,
+            490,
+            907
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "list",
+        "sub_type": "ref_text",
+        "list_items": [
+            "Zhiguo Wang, Patrick Ng, Xiaofei Ma, Ramesh Nallapati, and Bing Xiang. 2019. Multi-passage BERT: A globally normalized BERT model for open-domain question answering. In Proceedings of the 2019 Conference on Empirical Methods in Natural Language Processing and the 9th International Joint Conference on Natural Language Processing (EMNLP-IJCNLP), pages 5878-5882, Hong Kong, China. Association for Computational Linguistics.",
+            "Ledell Wu, Fabio Petroni, Martin Josifoski, Sebastian Riedel, and Luke Zettlemoyer. 2020. Scalable zero-shot entity linking with dense entity retrieval. In Proceedings of the 2020 Conference on Empirical Methods in Natural Language Processing (EMNLP), pages 6397-6407, Online. Association for Computational Linguistics.",
+            "Lee Xiong, Chenyan Xiong, Ye Li, Kwok-Fung Tang, Jialin Liu, Paul Bennett, Junaid Ahmed, and Arnold Overwijk. 2020. Approximate nearest neighbor negative contrastive learning for dense text retrieval. ArXiv, abs/2007.00808.",
+            "Wen-tau Yih, Kristina Toutanova, John C Platt, and Christopher Meek. 2011. Learning discriminative projections for text similarity measures. In Proceedings of the Fifteenth Conference on Computational Natural Language Learning, pages 247-256. Association for Computational Linguistics."
+        ],
+        "bbox": [
+            512,
+            76,
+            885,
+            461
+        ],
+        "page_idx": 10
+    }
+]

data/2021/2101_00xxx/2101.00117/b1510fde-b32e-4443-bd7a-7c6aed392142_model.json

@@ -1,3 +1,1938 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:21360338df3af3dc4e9ae150f26b8d4d9a0287541ea1ce947fc347811a5027bf
-size 89529
+[
+    [
+        {
+            "type": "aside_text",
+            "bbox": [
+                0.023,
+                0.323,
+                0.061,
+                0.718
+            ],
+            "angle": 270,
+            "content": "arXiv:2101.00117v1 [cs.CL] 1 Jan 2021"
+        },
+        {
+            "type": "title",
+            "bbox": [
+                0.233,
+                0.081,
+                0.773,
+                0.102
+            ],
+            "angle": 0,
+            "content": "Multi-task Retrieval for Knowledge-Intensive Tasks"
+        },
+        {
+            "type": "text",
+            "bbox": [
+                0.23,
+                0.135,
+                0.78,
+                0.183
+            ],
+            "angle": 0,
+            "content": "Jean Maillard* Vladimir Karpukhin* Fabio Petroni  \nWen-tau Yih Barlas Oğuz Veselin Stoyanov Gargi Ghosh  \nFacebook AI"
+        },
+        {
+            "type": "text",
+            "bbox": [
+                0.137,
+                0.185,
+                0.871,
+                0.202
+            ],
+            "angle": 0,
+            "content": "{jeanm,vladk, fabiopetroni, scottyih, barlaso, ves, gghosh}@fb.com"
+        },
+        {
+            "type": "title",
+            "bbox": [
+                0.263,
+                0.265,
+                0.344,
+                0.28
+            ],
+            "angle": 0,
+            "content": "Abstract"
+        },
+        {
+            "type": "text",
+            "bbox": [
+                0.144,
+                0.296,
+                0.465,
+                0.552
+            ],
+            "angle": 0,
+            "content": "Retrieving relevant contexts from a large corpus is a crucial step for tasks such as open-domain question answering and fact checking. Although neural retrieval outperforms traditional methods like tfidf and BM25, its performance degrades considerably when applied to out-of-domain data. Driven by the question of whether a neural retrieval model can be universal and perform robustly on a wide variety of problems, we propose a multi-task trained model. Our approach not only outperforms previous methods in the few-shot setting, but also rivals specialised neural retrievers, even when in-domain training data is abundant. With the help of our retriever, we improve existing models for downstream tasks and closely match or improve the state of the art on multiple benchmarks."
+        },
+        {
+            "type": "title",
+            "bbox": [
+                0.117,
+                0.568,
+                0.262,
+                0.584
+            ],
+            "angle": 0,
+            "content": "1 Introduction"
+        },
+        {
+            "type": "text",
+            "bbox": [
+                0.115,
+                0.596,
+                0.494,
+                0.837
+            ],
+            "angle": 0,
+            "content": "Knowledge-intensive tasks is the common designation for a class of real-world NLP problems which, because of their nature, require large amounts of knowledge about the world (Petroni et al., 2020). For example, open-domain question answering requires producing answers to general factoid questions; fact checking involves determining the veracity of claims based on a database of trusted evidence. Practical solutions to these tasks usually involve an efficient retrieval component that, given an input query, selects a limited subset of relevant information from a large knowledge source. Sophisticated downstream models then consider the input only in the context of the retrieved information, and perform the final task."
+        },
+        {
+            "type": "text",
+            "bbox": [
+                0.51,
+                0.265,
+                0.889,
+                0.699
+            ],
+            "angle": 0,
+            "content": "The standard retrieval component in many systems (e.g., Thorne et al., 2018; Wang et al., 2018; Chen et al., 2017) has long relied on term-matching methods, such as tfidf or BM25 (Robertson and Zaragoza, 2009). These methods rely on efficient algorithms and usually perform reasonably well regardless of the problem. In contrast, recent neural retrieval models, such as ICT (Lee et al., 2019), DPR (Karpukhin et al., 2020) and RAG (Lewis et al., 2020b) achieve better results by learning directly from task-specific training data and going beyond simple keyword matching. While task specialisation results in improved task performance, researchers have observed that a retriever trained for one specific domain will typically achieve low out-of-domain performance, and even lower performance on entirely different tasks (Petroni et al., 2020). This has two implications. First, unlike tfidf or BM25, neural retrieval models are unsuitable for low data regimes such as few- and zero-shot settings. Second, task-specific retrievers complicate practical applications where multiple knowledge-intensive tasks may need to be performed using the same supporting database or over the same input text. It may not be practical to deploy multiple separate specialised models due to computational performance or memory concerns."
+        },
+        {
+            "type": "text",
+            "bbox": [
+                0.51,
+                0.701,
+                0.889,
+                0.911
+            ],
+            "angle": 0,
+            "content": "We ask the following question in this work: can we develop a universal neural retriever? Namely, we target a retriever that can perform well on a wide variety of problems, without task-specific fine-tuning, but, if additional in-domain labelled data is available, it can be further fine-tuned to improve the performance. We perform a large experimental study to attempt to build such a universal retrieval model. We find that, by jointly training on an extensive selection of retrieval tasks, we obtain a model which is not only more robust than previous approaches, but also can lead to better performance on the downstream knowledge-intensive tasks when"
+        },
+        {
+            "type": "page_footnote",
+            "bbox": [
+                0.14,
+                0.847,
+                0.276,
+                0.86
+            ],
+            "angle": 0,
+            "content": "* Equal Contribution."
+        },
+        {
+            "type": "page_footnote",
+            "bbox": [
+                0.117,
+                0.86,
+                0.49,
+                0.91
+            ],
+            "angle": 0,
+            "content": "<sup>1</sup>While large pre-trained neural models have been shown to incorporate real-world knowledge in their parameters and thus may skip retrieval (Petroni et al., 2019), they still have limited capacity and suffer from a lack of explainability."
+        }
+    ],
+    [
+        {
+            "type": "text",
+            "bbox": [
+                0.115,
+                0.076,
+                0.492,
+                0.186
+            ],
+            "angle": 0,
+            "content": "plugged into an existing system. Our approach combines the benefits from IR-based models with those of task-specific neural retrievers – namely, good performance when no (or not enough) training data is available and high task performance due to its ability to learn highly specialised representations."
+        },
+        {
+            "type": "text",
+            "bbox": [
+                0.135,
+                0.188,
+                0.492,
+                0.204
+            ],
+            "angle": 0,
+            "content": "Our contributions can be summarised as follows."
+        },
+        {
+            "type": "text",
+            "bbox": [
+                0.138,
+                0.213,
+                0.492,
+                0.342
+            ],
+            "angle": 0,
+            "content": "- We propose a single general-purpose \"universal\" retrieval model, able to perform comparably or better than specialised retriever approaches in both zero-shot (leave-one-out) and few-shot retrieval. We investigate several model variants, shedding light on what are the aspects of the architecture that affect its performance."
+        },
+        {
+            "type": "text",
+            "bbox": [
+                0.138,
+                0.351,
+                0.491,
+                0.415
+            ],
+            "angle": 0,
+            "content": "- We show that our model's gains in terms of retrieval directly translate into performance gains for a variety of downstream knowledge-intensive tasks."
+        },
+        {
+            "type": "text",
+            "bbox": [
+                0.138,
+                0.425,
+                0.492,
+                0.538
+            ],
+            "angle": 0,
+            "content": "- We will share the implementation as well as our best model. This is in the form of a readily available BERT checkpoint which, as we will show, can be used by NLP practitioners as a strong out-of-the-box retrieval system, but which can also undergo further in-domain training for even higher performance."
+        },
+        {
+            "type": "list",
+            "bbox": [
+                0.138,
+                0.213,
+                0.492,
+                0.538
+            ],
+            "angle": 0,
+            "content": null
+        },
+        {
+            "type": "title",
+            "bbox": [
+                0.116,
+                0.548,
+                0.258,
+                0.565
+            ],
+            "angle": 0,
+            "content": "2 Background"
+        },
+        {
+            "type": "text",
+            "bbox": [
+                0.115,
+                0.574,
+                0.491,
+                0.655
+            ],
+            "angle": 0,
+            "content": "In this section, we first give an overview of retrieval methods based on sparse and dense representations. We then discuss a wide range of knowledge-intensive NLP tasks, where retrieval plays a crucial role in solving the problems."
+        },
+        {
+            "type": "title",
+            "bbox": [
+                0.116,
+                0.664,
+                0.307,
+                0.679
+            ],
+            "angle": 0,
+            "content": "2.1 Retrieval methods"
+        },
+        {
+            "type": "text",
+            "bbox": [
+                0.115,
+                0.685,
+                0.491,
+                0.877
+            ],
+            "angle": 0,
+            "content": "Given a large collection of unstructured text passages, information retrieval (IR) can be broadly defined as finding a small set of passages that satisfies an information need, often presented in the form of a short-text query (Manning et al., 2008). Traditional IR methods, such as tfidf and BM25 (Robertson and Zaragoza, 2009), match keywords efficiently with an inverted index. Such methods can be seen as representing queries and passages in high-dimensional, sparse vectors, where each dimension corresponds to a term in the vocabulary and the weight indicates its importance."
+        },
+        {
+            "type": "text",
+            "bbox": [
+                0.116,
+                0.878,
+                0.492,
+                0.91
+            ],
+            "angle": 0,
+            "content": "In contrast to tfidf and BM25, dense retrieval methods encode text as a latent semantic vector of"
+        },
+        {
+            "type": "text",
+            "bbox": [
+                0.509,
+                0.075,
+                0.887,
+                0.413
+            ],
+            "angle": 0,
+            "content": "a fixed, much smaller dimensionality. Whether a passage is relevant to a given query is determined by the distance of their vectors (Deerwester et al., 1990). Although dense representations do not encode tokens explicitly and can potentially map paraphrases of completely different tokens to close vectors, performance of early dense retrieval methods was often inferior to term-matching approaches, except when large labelled data is available (Yih et al., 2011; Gao et al., 2011; Huang et al., 2013). Thanks to success of large pre-trained models (Devlin et al., 2019; Liu et al., 2019b), however, recent dense retrieval methods have shown to outperform the sparse counterparts, when fine-tuned on a small set of in-domain labelled data (Karpukhin et al., 2020; Lewis et al., 2020b; Xiong et al., 2020). Efficient index and search of dense vectors are made possible by maximum inner product search (MIPS) algorithms (e.g., Shrivastava and Li, 2014; Guo et al., 2016), as well as tools like FAISS (Johnson et al., 2019)."
+        },
+        {
+            "type": "text",
+            "bbox": [
+                0.51,
+                0.414,
+                0.887,
+                0.543
+            ],
+            "angle": 0,
+            "content": "Our work is built upon the Dense Passage Retriever (DPR) architecture of Karpukhin et al. (2020), which was initially proposed for the task of open-domain question answering. DPR is a neural bi-encoder model which embeds queries with an encoder \\( \\pmb{f}(\\cdot) \\) and passages with a separate encoder \\( \\pmb{g}(\\cdot) \\). Given an input query \\( x \\) and a target passage \\( y \\), we have"
+        },
+        {
+            "type": "equation",
+            "bbox": [
+                0.613,
+                0.556,
+                0.782,
+                0.573
+            ],
+            "angle": 0,
+            "content": "\\[\n\\mathrm {p} (x \\mid y) \\propto \\operatorname {s i m} (x, y),\n\\]"
+        },
+        {
+            "type": "text",
+            "bbox": [
+                0.51,
+                0.586,
+                0.886,
+                0.728
+            ],
+            "angle": 0,
+            "content": "where the similarity score \\(\\operatorname{sim}(x, y)\\) is defined as the inner product of the embeddings of its arguments, \\(f(x) \\cdot g(y)\\). Given a query at inference time, calculating its similarity with every possible passage would be prohibitive for large knowledge sources. Therefore, DPR makes use of the FAISS library (Johnson et al., 2019) to perform fast approximate nearest neighbour search in sub-linear time."
+        },
+        {
+            "type": "text",
+            "bbox": [
+                0.51,
+                0.728,
+                0.886,
+                0.784
+            ],
+            "angle": 0,
+            "content": "Training is based on a contrastive loss. Given a query \\( x \\), a relevant passage \\( y \\), and a set of \\( n \\) irrelevant passages \\( y_{i}^{-} \\), we train the model by optimising the following negative log likelihood:"
+        },
+        {
+            "type": "equation",
+            "bbox": [
+                0.525,
+                0.794,
+                0.871,
+                0.826
+            ],
+            "angle": 0,
+            "content": "\\[\n\\mathcal {L} = - \\log \\frac {\\exp (\\sin (x , y))}{\\exp (\\sin (x , y)) + \\sum_ {i = 1} ^ {n} \\exp (\\sin \\left(x , y _ {i} ^ {-}\\right))}.\n\\]"
+        },
+        {
+            "type": "text",
+            "bbox": [
+                0.51,
+                0.846,
+                0.886,
+                0.911
+            ],
+            "angle": 0,
+            "content": "As the set of irrelevant passages, we use the relevant passages for other queries within the same batch, as well as a specially selected \"hard\" confounder. This is a passage which has high lexical"
+        }
+    ],
+    [
+        {
+            "type": "image",
+            "bbox": [
+                0.118,
+                0.075,
+                0.498,
+                0.21
+            ],
+            "angle": 0,
+            "content": null
+        },
+        {
+            "type": "image_caption",
+            "bbox": [
+                0.115,
+                0.219,
+                0.49,
+                0.288
+            ],
+            "angle": 0,
+            "content": "Figure 1: Training of DPR (Karpukhin et al., 2020), a bi-encoder model for open-domain question answering. Queries and passages are encoded as vectors, and retrieval is performed as a maximum inner product search."
+        },
+        {
+            "type": "text",
+            "bbox": [
+                0.115,
+                0.323,
+                0.49,
+                0.419
+            ],
+            "angle": 0,
+            "content": "overlap with the query (high BM25 score), but is not among the set of relevant passages for the given data point. Karpukhin et al. (2020) have shown that the inclusion of such \"hard\" confounders leads to substantially improved training results. This training process is illustrated in Figure 1."
+        },
+        {
+            "type": "title",
+            "bbox": [
+                0.116,
+                0.444,
+                0.375,
+                0.459
+            ],
+            "angle": 0,
+            "content": "2.2 Knowledge-intensive Tasks"
+        },
+        {
+            "type": "text",
+            "bbox": [
+                0.115,
+                0.472,
+                0.49,
+                0.777
+            ],
+            "angle": 0,
+            "content": "For the training and evaluation of all models in the paper we make use of KILT, a benchmark and library of datasets (Petroni et al., 2020). KILT consists of a selection of datasets spanning five varied classes of knowledge-intensive tasks (i.e., question answering, slot filling, fact checking, dialogue, entity linking), with the aim to cover many different ways of seeking knowledge. Input queries can vary wildly from one task to the other, and include classic examples of open-domain retrieval tasks such as natural language questions and claims to be verified, as well as more unusual examples like conversation fragments and long chunks of annotated text. Crucially, all datasets distributed in KILT have been re-aligned such that they are all grounded in the same snapshot of Wikipedia, which the authors distribute. The knowledge required to answer any of the queries in the library of tasks can thus be found within the same unified knowledge source."
+        },
+        {
+            "type": "text",
+            "bbox": [
+                0.115,
+                0.782,
+                0.49,
+                0.909
+            ],
+            "angle": 0,
+            "content": "To illustrate the variety of ways in which the input queries for different tasks can be formulated, we provide a few simple examples in Table 1. In spite of the differences between query formulations, all these tasks share one crucial aspect: they all require a retriever to fetch the relevant passages from the knowledge source, in order to support the final downstream task."
+        },
+        {
+            "type": "title",
+            "bbox": [
+                0.512,
+                0.075,
+                0.623,
+                0.089
+            ],
+            "angle": 0,
+            "content": "3 Methods"
+        },
+        {
+            "type": "title",
+            "bbox": [
+                0.511,
+                0.1,
+                0.706,
+                0.114
+            ],
+            "angle": 0,
+            "content": "3.1 Universal retrieval"
+        },
+        {
+            "type": "text",
+            "bbox": [
+                0.51,
+                0.121,
+                0.886,
+                0.233
+            ],
+            "angle": 0,
+            "content": "Using task-specific models to tackle our collection of retrieval tasks would involve completely separate models, one per dataset. As illustrated in Figure 2, this would lead to a proliferation of models and data, down to separate indexed copies of the knowledge source itself (Wikipedia). This setup will form one of our baselines."
+        },
+        {
+            "type": "image",
+            "bbox": [
+                0.512,
+                0.244,
+                0.9,
+                0.352
+            ],
+            "angle": 0,
+            "content": null
+        },
+        {
+            "type": "image_caption",
+            "bbox": [
+                0.51,
+                0.361,
+                0.886,
+                0.39
+            ],
+            "angle": 0,
+            "content": "Figure 2: Two retrieval tasks performed by two fully-specialised models."
+        },
+        {
+            "type": "text",
+            "bbox": [
+                0.51,
+                0.406,
+                0.886,
+                0.517
+            ],
+            "angle": 0,
+            "content": "Multi-task training has been successfully used to allow models to leverage cross-task data, as well as to provide a regularisation effect leading to better generalisation ability (Liu et al., 2019a). We apply this concept to neural retrievers, with the aim of improving performance by jointly leveraging multiple different retrieval datasets."
+        },
+        {
+            "type": "image",
+            "bbox": [
+                0.52,
+                0.527,
+                0.691,
+                0.655
+            ],
+            "angle": 0,
+            "content": null
+        },
+        {
+            "type": "image_caption",
+            "bbox": [
+                0.519,
+                0.66,
+                0.691,
+                0.673
+            ],
+            "angle": 0,
+            "content": "(a) Separate query encoders."
+        },
+        {
+            "type": "image",
+            "bbox": [
+                0.706,
+                0.545,
+                0.876,
+                0.655
+            ],
+            "angle": 0,
+            "content": null
+        },
+        {
+            "type": "image_caption",
+            "bbox": [
+                0.706,
+                0.66,
+                0.876,
+                0.673
+            ],
+            "angle": 0,
+            "content": "(b) A single retrieval model."
+        },
+        {
+            "type": "image_caption",
+            "bbox": [
+                0.512,
+                0.684,
+                0.882,
+                0.699
+            ],
+            "angle": 0,
+            "content": "Figure 3: Parameter sharing between neural retrievers."
+        },
+        {
+            "type": "text",
+            "bbox": [
+                0.51,
+                0.717,
+                0.886,
+                0.812
+            ],
+            "angle": 0,
+            "content": "Our base setup is illustrated in Figure 3b and involves using a shared passage encoder — so that a single index of encoded passages can be used — as well as a query encoder that is shared across all tasks. In essence, in this setup a single DPR model is used to perform all retrieval tasks."
+        },
+        {
+            "type": "text",
+            "bbox": [
+                0.51,
+                0.814,
+                0.886,
+                0.91
+            ],
+            "angle": 0,
+            "content": "Due to the complexity of training and evaluating retrieval models (which involves training the retriever, embedding all of Wikipedia, and building an index), our main set of experiments is all based on this configuration, which was found to work well in preliminary experiments. However, in order"
+        }
+    ],
+    [
+        {
+            "type": "table",
+            "bbox": [
+                0.127,
+                0.073,
+                0.88,
+                0.328
+            ],
+            "angle": 0,
+            "content": "<table><tr><td>Task</td><td>Example query</td><td>Answer</td><td>Relevant doc.</td></tr><tr><td>Question Answering</td><td>Who is playing the Halftime Show at Super Bowl 2016?</td><td>Coldplay</td><td>The Super Bowl 50 Halftime Show took place on February 7, 2016 ... It was headlined by the British rock group Coldplay.</td></tr><tr><td>Fact Checking</td><td>Bermuda Triangle is in the western part of the Himalayas</td><td>REFUTES</td><td>The Bermuda Triangle ... is a loosely defined region in the western part of the North Atlantic Ocean</td></tr><tr><td>Slot Filling</td><td>Piner Creek [sep] mouth of the watercourse</td><td>Santa Rosa Creek</td><td>Piner Creek discharges to Santa Rosa Creek which in turn ...</td></tr><tr><td>Entity Linking</td><td>Leicestershire take over at top after innings victory. London. [start_ent]West Indian [end_ent] all-rounder Phil Simmons ...</td><td>West Indies cricket team</td><td>The West Indies cricket team is a multi-national men&#x27;s cricket team representing the Anglophone Caribbean region</td></tr><tr><td>Dialogue</td><td>I am a big fan of Star Trek [sep] I don&#x27;t know much about it. When did the first episode air? [sep] It debuted in .. [sep] What is the plot of the show?</td><td>William Shatner plays the role of Captain Kirk</td><td>It followed the interstellar adventures of Captain James T. Kirk (William Shatner) and his crew ...</td></tr></table>"
+        },
+        {
+            "type": "table_caption",
+            "bbox": [
+                0.121,
+                0.337,
+                0.877,
+                0.352
+            ],
+            "angle": 0,
+            "content": "Table 1: Illustrative examples of some of the tasks within KILT, and how varied their query formulations can be."
+        },
+        {
+            "type": "text",
+            "bbox": [
+                0.115,
+                0.378,
+                0.491,
+                0.442
+            ],
+            "angle": 0,
+            "content": "to report on the performance of alternative architectures, we also investigate the following additional variants in a restricted experimental setting, limited to a few tasks:"
+        },
+        {
+            "type": "text",
+            "bbox": [
+                0.138,
+                0.451,
+                0.49,
+                0.596
+            ],
+            "angle": 0,
+            "content": "- Task-specific query encoder. A different query encoder is used for each family of tasks, e.g. all question answering tasks use the same query encoder, but fact checking uses a different one. This is meant to allow for potentially different needs in processing queries, given the fundamentally diverse nature of the tasks at hand. This setup configuration is illustrated in Figure 3a."
+        },
+        {
+            "type": "text",
+            "bbox": [
+                0.138,
+                0.607,
+                0.492,
+                0.766
+            ],
+            "angle": 0,
+            "content": "- Task markers. This approach is similar to our base setup, where a single model performs all tasks. Additionally, we introduce specialised tokens which are inserted at the beginning of each query. Their aim is to help the model distinguish between the different tasks, by marking them. We use one task marker for each of the five task classes of KILT, such that all question answering tasks share the same marker."
+        },
+        {
+            "type": "list",
+            "bbox": [
+                0.138,
+                0.451,
+                0.492,
+                0.766
+            ],
+            "angle": 0,
+            "content": null
+        },
+        {
+            "type": "title",
+            "bbox": [
+                0.116,
+                0.777,
+                0.422,
+                0.792
+            ],
+            "angle": 0,
+            "content": "3.2 Adversarial confounder selection"
+        },
+        {
+            "type": "text",
+            "bbox": [
+                0.115,
+                0.798,
+                0.491,
+                0.911
+            ],
+            "angle": 0,
+            "content": "We saw in § 2.1 how \"hard\" confounder passages are collected using a BM25 baseline, following the standard approach in DPR. However, any other retriever can be used to select such confounders, including the very retriever being trained, leading to an iterative, self-adversarial training. Concretely, this amounts to following steps: (1) a first version"
+        },
+        {
+            "type": "text",
+            "bbox": [
+                0.51,
+                0.378,
+                0.885,
+                0.473
+            ],
+            "angle": 0,
+            "content": "of the retriever is trained with BM25 confounders; (2) new confounders are selected with the trained model, by retrieving high-ranking passages which are not among the set of relevant ones; (3) a second version of the model is trained using the additional new confounders."
+        },
+        {
+            "type": "text",
+            "bbox": [
+                0.51,
+                0.486,
+                0.886,
+                0.6
+            ],
+            "angle": 0,
+            "content": "Intuitively, it is expected that this approach should lead to higher quality confounders compared to those selected by BM25 based on simple keyword matching. Based on our own experience as well as relevant literature (Khattab et al., 2020), this adversarial approach has been shown to work well for question answering."
+        },
+        {
+            "type": "text",
+            "bbox": [
+                0.51,
+                0.611,
+                0.886,
+                0.803
+            ],
+            "angle": 0,
+            "content": "As a way of further pushing the performance of the model, we experiment with this adversarial confounder selection on two datasets, Natural Questions (Kwiatkowski et al., 2019) and TriviaQA (Joshi et al., 2017). We selected these two datasets since, out of all of the tasks we are considering, they have an easy way of checking whether a certain passage is relevant or not for a given query – namely, by checking whether the answer is present in the passage. This enabled us to automatically build sets of confounders, ensuring relevant passages would be excluded."
+        },
+        {
+            "type": "page_footnote",
+            "bbox": [
+                0.51,
+                0.86,
+                0.887,
+                0.911
+            ],
+            "angle": 0,
+            "content": "\\( {}^{2} \\) Strictly speaking,assuming a passage to be irrelevant because of the absence of the answer span is not formally correct. However, experiments show a good correlation between this simple check and the overall model quality."
+        }
+    ],
+    [
+        {
+            "type": "table",
+            "bbox": [
+                0.118,
+                0.073,
+                0.498,
+                0.235
+            ],
+            "angle": 0,
+            "content": "<table><tr><td>Dataset</td><td>Task class</td><td>#Train</td></tr><tr><td>FEVER</td><td>Fact Checking</td><td>71 k</td></tr><tr><td>AIDA-YAGO 2</td><td>Entity Linking</td><td>18 k</td></tr><tr><td>T-REx</td><td>Slot Filling</td><td>2,284 k</td></tr><tr><td>Zero Shot RE</td><td>Slot Filling</td><td>132 k</td></tr><tr><td>Natural Questions</td><td>QA</td><td>77 k</td></tr><tr><td>HotpotQA</td><td>QA</td><td>69 k</td></tr><tr><td>TriviaQA</td><td>QA</td><td>53 k</td></tr><tr><td>Wizard of Wikipedia</td><td>Dialogue</td><td>80 k</td></tr></table>"
+        },
+        {
+            "type": "table_caption",
+            "bbox": [
+                0.115,
+                0.244,
+                0.49,
+                0.274
+            ],
+            "angle": 0,
+            "content": "Table 2: KILT datasets used in this work, and the size of our converted training sets for each."
+        },
+        {
+            "type": "title",
+            "bbox": [
+                0.116,
+                0.299,
+                0.263,
+                0.315
+            ],
+            "angle": 0,
+            "content": "4 Experiments"
+        },
+        {
+            "type": "title",
+            "bbox": [
+                0.116,
+                0.326,
+                0.334,
+                0.341
+            ],
+            "angle": 0,
+            "content": "4.1 Experimental settings"
+        },
+        {
+            "type": "text",
+            "bbox": [
+                0.115,
+                0.348,
+                0.49,
+                0.412
+            ],
+            "angle": 0,
+            "content": "Dataset selection For our experiments we select the eight KILT datasets listed in Table 2, which cover all five task classes and include a training split, a validation split, and a held-out test split."
+        },
+        {
+            "type": "text",
+            "bbox": [
+                0.115,
+                0.422,
+                0.492,
+                0.534
+            ],
+            "angle": 0,
+            "content": "Preprocessing Starting from the raw KILT data, we split each Wikipedia article into disjoint 100-token chunks which form our basic retrieval units, following the approach of Wang et al. (2019) and Karpukhin et al. (2020). To maintain the same language introduced in §3, we will simply call these chunks passages."
+        },
+        {
+            "type": "text",
+            "bbox": [
+                0.115,
+                0.536,
+                0.49,
+                0.696
+            ],
+            "angle": 0,
+            "content": "This preprocessing results in a knowledge source of 36 million passages. In order to harmonise all datasets to the same knowledge source, KILT used a mapping strategy based on the BLEU metric to map relevant passages in the original versions of its datasets to passages in its own shared knowledge source (Petroni et al., 2020). Entries included in the KILT training sets which have a mapping BLEU score below 0.5 are likely to be noise, and we exclude them from training."
+        },
+        {
+            "type": "text",
+            "bbox": [
+                0.115,
+                0.707,
+                0.49,
+                0.867
+            ],
+            "angle": 0,
+            "content": "Multi-tasking Training is performed on the union of all training sets. Since two of the training sets are of different orders of magnitude, we use a simple downsampling strategy to bring them to the same order of magnitude as the others. Preliminary experiments with more complex sampling methods, like resampling all datasets so that each epoch would see an equal number of samples from each, found that they had no measurable effect compared to this simpler approach."
+        },
+        {
+            "type": "text",
+            "bbox": [
+                0.116,
+                0.878,
+                0.49,
+                0.909
+            ],
+            "angle": 0,
+            "content": "Encoders Our query and passage encoders are initialised as two distinct BERT base uncased en"
+        },
+        {
+            "type": "text",
+            "bbox": [
+                0.51,
+                0.076,
+                0.885,
+                0.14
+            ],
+            "angle": 0,
+            "content": "coders (Devlin et al., 2019), trained separately. As pooling mechanism we find it effective to simply take the [CLS] token representation at the topmost layer."
+        },
+        {
+            "type": "text",
+            "bbox": [
+                0.51,
+                0.148,
+                0.886,
+                0.34
+            ],
+            "angle": 0,
+            "content": "Training We train our models for up to 80 epochs. To select the best checkpoint, we perform full evaluations of the validation set retrieval performance at regular intervals. We use the Adam optimiser (Kingma and Ba, 2015) with a learning rate of \\(2 \\cdot 10^{-5}\\) with warmup and a linear decay schedule, and a dropout rate of 0.1. The batch size is set to 128 samples, and in preliminary experiments we found no benefit in increasing this further. We use an additional \"hard\" confounder per batch, selected based on BM25 score as in (Karpukhin et al., 2020)."
+        },
+        {
+            "type": "text",
+            "bbox": [
+                0.51,
+                0.349,
+                0.886,
+                0.476
+            ],
+            "angle": 0,
+            "content": "Downstream evaluation When evaluating our retriever within a larger architecture to perform a knowledge-intensive task, we replicate the DPR + BART setup of Petroni et al. (2020). This uses DPR to retrieve and comprehend the top 3 passages to the query, which is then processed by a task-specific fine-tuned BART model to generate the final answer for the end task."
+        },
+        {
+            "type": "title",
+            "bbox": [
+                0.511,
+                0.487,
+                0.706,
+                0.501
+            ],
+            "angle": 0,
+            "content": "4.2 Universal retrieval"
+        },
+        {
+            "type": "text",
+            "bbox": [
+                0.51,
+                0.508,
+                0.886,
+                0.635
+            ],
+            "angle": 0,
+            "content": "The results of the evaluations reported in (Petroni et al., 2020) show that retrievers trained for question answering have poor performance outside of their domain. We would like to understand if it is possible to design a single model which can accurately satisfy the information needs of a wide variety of knowledge-intensive tasks. In short: Can a neural retriever be universal?"
+        },
+        {
+            "type": "text",
+            "bbox": [
+                0.51,
+                0.637,
+                0.886,
+                0.812
+            ],
+            "angle": 0,
+            "content": "We perform a comprehensive evaluation of several models on the eight tasks of Table 2. The setups we evaluate include eight task-specific models (one trained on each of the eight datasets), for which we measure both in-domain and out-of-domain performance, and a BM25 baseline. Additionally, we include a multi-task trained model - as described in §3.1 - with the hope that it can learn to perform all tasks satisfyingly. This amounts to 10 models evaluated on eight tasks each, for a total of 80 evaluations."
+        },
+        {
+            "type": "text",
+            "bbox": [
+                0.51,
+                0.814,
+                0.885,
+                0.91
+            ],
+            "angle": 0,
+            "content": "To measure retrieval performance, we adopt the main metric used for the KILT benchmark, \\( R \\)-precision. This is calculated as \\( r / R \\), where \\( R \\) is the total number of relevant passages for a given query, and \\( r \\) is the number of relevant passages returned among the top- \\( R \\) retrieval results. For the"
+        }
+    ],
+    [
+        {
+            "type": "table",
+            "bbox": [
+                0.126,
+                0.073,
+                0.88,
+                0.259
+            ],
+            "angle": 0,
+            "content": "<table><tr><td rowspan=\"2\">model</td><td rowspan=\"2\">Fact Check. FEV</td><td rowspan=\"2\">Ent. L. AY2</td><td colspan=\"2\">Slot Filling</td><td colspan=\"3\">Open Domain QA</td><td rowspan=\"2\">Dial. WoW</td></tr><tr><td>T-REx</td><td>zsRE</td><td>NQ</td><td>HoPo</td><td>TQA</td></tr><tr><td>Multi-task</td><td>74.72/46.96</td><td>83.78</td><td>69.18/53.54</td><td>77.23/41.70</td><td>61.51/28.80</td><td>44.21/38.42</td><td>61.95/24.56</td><td>39.70/24.07</td></tr><tr><td>BM25</td><td>50.13/40.06</td><td>3.47</td><td>58.60/51.64</td><td>66.43/52.98</td><td>25.83/14.20</td><td>43.95/38.38</td><td>29.44/16.16</td><td>27.50/18.41</td></tr><tr><td colspan=\"9\">Task-specific models</td></tr><tr><td>FEVER</td><td>73.60/43.92</td><td>5.62</td><td>19.50/10.02</td><td>42.88/19.98</td><td>36.69/18.05</td><td>23.18/17.59</td><td>45.08/22.24</td><td>41.27/19.85</td></tr><tr><td>AY2</td><td>47.36/37.58</td><td>81.77</td><td>5.52/4.08</td><td>8.94/5.50</td><td>10.22/6.77</td><td>11.69/10.71</td><td>15.11/8.47</td><td>17.59/13.08</td></tr><tr><td>T-REx</td><td>45.63/25.22</td><td>1.05</td><td>69.08/58.54</td><td>71.64/40.95</td><td>17.10/8.71</td><td>22.31/15.63</td><td>18.10/8.06</td><td>4.02/1.83</td></tr><tr><td>zsRE</td><td>70.10/33.12</td><td>0.42</td><td>68.34/57.40</td><td>97.74/78.81</td><td>25.98/13.81</td><td>22.23/18.35</td><td>28.68/14.44</td><td>10.40/2.09</td></tr><tr><td>NQ</td><td>68.16/14.81</td><td>1.44</td><td>31.78/7.20</td><td>61.12/12.92</td><td>63.24/28.13</td><td>29.39/11.33</td><td>48.39/14.42</td><td>30.77/11.81</td></tr><tr><td>HoPo</td><td>56.18/40.03</td><td>2.07</td><td>35.76/27.62</td><td>44.44/31.15</td><td>35.60/23.26</td><td>46.63/43.47</td><td>41.18/29.37</td><td>23.51/16.02</td></tr><tr><td>TQA</td><td>70.06/10.68</td><td>4.95</td><td>32.22/12.52</td><td>60.37/17.43</td><td>45.01/12.97</td><td>32.62/13.05</td><td>65.12/23.79</td><td>41.17/8.11</td></tr><tr><td>WoW</td><td>59.16/42.79</td><td>3.11</td><td>20.92/18.52</td><td>41.14/35.26</td><td>33.27/22.52</td><td>20.36/17.66</td><td>39.37/23.15</td><td>40.32/20.73</td></tr></table>"
+        },
+        {
+            "type": "table_caption",
+            "bbox": [
+                0.115,
+                0.269,
+                0.885,
+                0.298
+            ],
+            "angle": 0,
+            "content": "Table 3: Page- and passage-level \\( R \\) -precision on KILT validation data. For the AIDA-YAGO 2 dataset, due to the nature of the task, only page-level retrieval is defined."
+        },
+        {
+            "type": "text",
+            "bbox": [
+                0.115,
+                0.324,
+                0.492,
+                0.404
+            ],
+            "angle": 0,
+            "content": "case of \\( R = 1 \\) this is therefore equivalent to precision@1. Table 3 shows retrieval performance on the validation data, with the best performance on a given dataset marked in bold, and the second best performance underlined."
+        },
+        {
+            "type": "text",
+            "bbox": [
+                0.114,
+                0.406,
+                0.491,
+                0.549
+            ],
+            "angle": 0,
+            "content": "While the KILT evaluation focuses on retrieval at the level of Wikipedia pages (thereby marking as \"hits\" any results that lie within the correct page), we are also interested in performing an evaluation at a more fine-grained level. We therefore also evaluate our models at the passage level, using a modified version of the official KILT evaluation scripts. These are shown as the second number in each column."
+        },
+        {
+            "type": "text",
+            "bbox": [
+                0.115,
+                0.553,
+                0.49,
+                0.696
+            ],
+            "angle": 0,
+            "content": "We straight away notice that the task-specific models tend to achieve high performance on their respective tasks, often taking one of the top two spots. Interestingly, we also note that these neural retrievers consistently outperform the BM25 baseline, showing that the result which Karpukhin et al. (2020) achieved for open-domain question answering also holds for other knowledge-intensive tasks."
+        },
+        {
+            "type": "text",
+            "bbox": [
+                0.115,
+                0.7,
+                0.49,
+                0.891
+            ],
+            "angle": 0,
+            "content": "The results reveal a strong performance for the multi-task model, confirming the hypothesis that a single model can be successfully trained to perform a wide variety of retrieval tasks. With the exception of one dataset, the shared model achieves the best retrieval performance or is within a few percentage points of the top score. We note that the one exception is the Zero-shot RE task (Levy et al., 2017), a trivial task in which the query will always contain the title of the page to be retrieved. Indeed, the model specific to this task manages to achieve a near-perfect score."
+        },
+        {
+            "type": "text",
+            "bbox": [
+                0.134,
+                0.895,
+                0.49,
+                0.911
+            ],
+            "angle": 0,
+            "content": "Another task which stands out for being"
+        },
+        {
+            "type": "text",
+            "bbox": [
+                0.51,
+                0.324,
+                0.886,
+                0.483
+            ],
+            "angle": 0,
+            "content": "markedly different in formulation is AIDA-YAGO 2 (Hoffart et al., 2011). As shown in Table 2, models that were not trained on this specific task perform it very poorly. Entity linking is a task that is normally better performed by models which are explicitly designed for it (Cao et al., 2020). We nevertheless include it to showcase the ability of neural retrievers to adapt to it, and note how well the multi-task retriever performs on it in spite of its unusual nature."
+        },
+        {
+            "type": "title",
+            "bbox": [
+                0.511,
+                0.499,
+                0.765,
+                0.515
+            ],
+            "angle": 0,
+            "content": "4.3 Downstream performance"
+        },
+        {
+            "type": "text",
+            "bbox": [
+                0.51,
+                0.522,
+                0.886,
+                0.65
+            ],
+            "angle": 0,
+            "content": "We saw that our proposed approach achieves strong performance across a variety of retrieval tasks. However, our interest in neural retrievers stems from their use as components within larger systems, to perform tasks such as question answering. Our next experimental question is therefore: Can a universal retriever lead to better downstream performance in knowledge-intensive tasks?"
+        },
+        {
+            "type": "text",
+            "bbox": [
+                0.51,
+                0.652,
+                0.886,
+                0.763
+            ],
+            "angle": 0,
+            "content": "We perform a downstream evaluation of our approach used in conjunction with BART (Lewis et al., 2020a) as the generative component or classifier, adopting the same setup as Petroni et al. (2020). Results are reported in Table 4, with bold and underline marking the best and second best scores respectively."
+        },
+        {
+            "type": "text",
+            "bbox": [
+                0.51,
+                0.766,
+                0.886,
+                0.911
+            ],
+            "angle": 0,
+            "content": "The \\(DPR + BART\\) line refers to a setup similar to our own, but with the simpler retriever of Karpukhin et al. (2020). Therefore, comparing its performance to ours gives us a clear indication of the contribution of multi-task training on the overall performance on knowledge-intensive tasks. Our proposed model achieves significantly better performance than this baseline in AY2, zsRE and HoPo; while for the other tasks, the discrepancy"
+        }
+    ],
+    [
+        {
+            "type": "table",
+            "bbox": [
+                0.128,
+                0.073,
+                0.88,
+                0.193
+            ],
+            "angle": 0,
+            "content": "<table><tr><td rowspan=\"2\">Model</td><td rowspan=\"2\">Fact Check. FEV</td><td rowspan=\"2\">Ent. L. AY2</td><td rowspan=\"2\">Slot Fill. zsRE</td><td colspan=\"3\">Open Domain QA</td><td rowspan=\"2\">Dial. WoW</td><td rowspan=\"2\">Avg.</td></tr><tr><td>NQ</td><td>HoPo</td><td>TQA</td></tr><tr><td>Multi-task + BART</td><td>86.32</td><td>82.61</td><td>57.95</td><td>39.75</td><td>31.77</td><td>59.60</td><td>15.33</td><td>53.33</td></tr><tr><td>DPR + BART</td><td>86.74</td><td>75.49</td><td>30.43</td><td>41.27</td><td>25.18</td><td>58.55</td><td>15.55</td><td>47.60</td></tr><tr><td>RAG</td><td>86.31</td><td>72.62</td><td>44.74</td><td>44.39</td><td>26.97</td><td>71.27</td><td>13.22</td><td>51.36</td></tr><tr><td>T5</td><td>76.30</td><td>74.05</td><td>9.02</td><td>19.60</td><td>12.64</td><td>18.11</td><td>13.49</td><td>31.89</td></tr></table>"
+        },
+        {
+            "type": "table_caption",
+            "bbox": [
+                0.115,
+                0.202,
+                0.885,
+                0.247
+            ],
+            "angle": 0,
+            "content": "Table 4: KILT test scores on the downstream evaluation. Results in the bottom section are as reported in Petroni et al. (2020). The score metrics are accuracy for fact checking, entirely linking and slot filling; exact match for QA; and F1 score for dialogue.\\(^3\\)"
+        },
+        {
+            "type": "text",
+            "bbox": [
+                0.115,
+                0.271,
+                0.49,
+                0.382
+            ],
+            "angle": 0,
+            "content": "is always below two points. This fact is reflected in the last column too, showing that on average multi-task training leads to better downstream performance. The model also compares favourably to RAG (Lewis et al., 2020b), a more advanced system in which the query encoder is fine-tuned on the end task."
+        },
+        {
+            "type": "title",
+            "bbox": [
+                0.116,
+                0.395,
+                0.416,
+                0.41
+            ],
+            "angle": 0,
+            "content": "4.4 Zero- and few-shot performance"
+        },
+        {
+            "type": "text",
+            "bbox": [
+                0.115,
+                0.416,
+                0.49,
+                0.56
+            ],
+            "angle": 0,
+            "content": "Task-specific neural retrievers can achieve higher performance than IR-based methods, but they are not suitable for cases where no training data (or not enough) is available. In those cases, tfidf and BM25 are the better choice. To evaluate the performance of a multi-task retriever as a suitable replacement for them in this scenario, we run a series of experiments in the low data regimes (few-shot and zero-shot)."
+        },
+        {
+            "type": "text",
+            "bbox": [
+                0.115,
+                0.562,
+                0.49,
+                0.786
+            ],
+            "angle": 0,
+            "content": "We start by training a set of multi-task retrievers (using the base setup) in the leave-one-out setting for each of the datasets, in order to see how a neural retriever will perform when trained on all domains except for the one it is to be evaluated on. The results of these zero-shot experiments are reported in the second line of Table 5 (again, text here is in bold for the best overall performance, and underlined for second best). They show that, even in the zero-shot setting, the multi-task neural retriever achieves performance that is competitive to BM25, with retrieval being 10 points higher at the page level and 5 points lower at the passage level on average."
+        },
+        {
+            "type": "text",
+            "bbox": [
+                0.115,
+                0.787,
+                0.49,
+                0.851
+            ],
+            "angle": 0,
+            "content": "The advantage of neural retrievers over BM25 lies in their ability to improve with training. We therefore look at few-shot training for each task, and create two smaller copies for each of the orig"
+        },
+        {
+            "type": "text",
+            "bbox": [
+                0.51,
+                0.271,
+                0.885,
+                0.431
+            ],
+            "angle": 0,
+            "content": "inal training sets with a random sample of 128 and 1,024 examples respectively. In order to evaluate the suitability of a multi-task trained retriever as a starting checkpoint for few-shot training, we take the various leave-one-out models and finetune them on our few-shot training sets. To check whether multi-task pre-training is effective, we also compare these to DPR models (which are just initialised with BERT weights) fine-tuned on the same data."
+        },
+        {
+            "type": "text",
+            "bbox": [
+                0.51,
+                0.435,
+                0.885,
+                0.659
+            ],
+            "angle": 0,
+            "content": "The bottom two sections of Table 5 report the results. The most dramatic gains from fine-tuning are seen for AY2, an \"outlier\" task whose formulation differs from that of the other tasks, and which seems to benefit the most from seeing in-domain data. The zsRE performance does not seem to improve from fine-tuning on the smaller dataset, but sees a very big jump when switching to the larger dataset. As a reminder, in this trivial task the title of the page to be retrieved always appears at the start of the query. It is therefore not surprising that models specifically fine-tuned on it can achieve near-perfect scores, as long as enough training data is provided."
+        },
+        {
+            "type": "text",
+            "bbox": [
+                0.51,
+                0.663,
+                0.885,
+                0.774
+            ],
+            "angle": 0,
+            "content": "In spite of the fine-tuning, we note that both DPR and the multi-task model fail to improve on their performance for T-REx, suggesting that large amounts of training data are required to learn this task. Nevertheless, the multi-task model proves itself more robust, and achieves the top performance on it."
+        },
+        {
+            "type": "text",
+            "bbox": [
+                0.51,
+                0.779,
+                0.885,
+                0.875
+            ],
+            "angle": 0,
+            "content": "Finally, we note for 2 out of 8 tasks, namely zsRE and WoW, DPR achieves lower page-level retrieval scores than the multi-task model, but performs better at the passage level. This shows that fine-grained and coarse-grained retrieval performance are not always perfectly correlated."
+        },
+        {
+            "type": "text",
+            "bbox": [
+                0.51,
+                0.878,
+                0.884,
+                0.911
+            ],
+            "angle": 0,
+            "content": "Overall, the experiments show strong results for the multi-task model, with the average zero-shot"
+        },
+        {
+            "type": "page_footnote",
+            "bbox": [
+                0.115,
+                0.86,
+                0.49,
+                0.909
+            ],
+            "angle": 0,
+            "content": "3Performing this evaluation required retrieving relevant documents for all training sets. Due to the very large size of T-REx, this particular dataset could not be included in this section."
+        }
+    ],
+    [
+        {
+            "type": "table",
+            "bbox": [
+                0.124,
+                0.072,
+                0.885,
+                0.212
+            ],
+            "angle": 0,
+            "content": "<table><tr><td>Model</td><td>FEV</td><td>AY2</td><td>T-REx</td><td>zsRE</td><td>NQ</td><td>HoPo</td><td>TQA</td><td>WoW</td><td>Avg.</td></tr><tr><td>BM25</td><td>50.13/40.06</td><td>3.47</td><td>58.60/51.64</td><td>66.43/52.98</td><td>25.83/14.20</td><td>43.95/38.38</td><td>29.44/16.16</td><td>27.50/18.41</td><td>38.17/33.12</td></tr><tr><td colspan=\"10\">Leave-one-out multi-task models</td></tr><tr><td>Zero-shot</td><td>74.11/37.09</td><td>4.16</td><td>67.54/44.84</td><td>73.42/32.65</td><td>47.23/21.50</td><td>34.72/16.52</td><td>49.08/28.06</td><td>36.92/16.19</td><td>48.40/28.12</td></tr><tr><td>Finetune (128)</td><td>75.95/32.75</td><td>32.38</td><td>67.54/44.84</td><td>73.41/32.65</td><td>47.48/14.98</td><td>34.72/27.82</td><td>54.71/19.82</td><td>48.36/17.46</td><td>54.23/27.19</td></tr><tr><td>Finetune (1k)</td><td>73.08/40.83</td><td>70.40</td><td>67.54/44.84</td><td>93.04/58.67</td><td>51.00/19.90</td><td>39.19/35.43</td><td>59.08/20.22</td><td>47.65/19.75</td><td>62.62/34.23</td></tr><tr><td colspan=\"10\">Vanilla DPR models</td></tr><tr><td>Finetune (128)</td><td>37.99/25.31</td><td>26.23</td><td>0.20/0.02</td><td>0.16/0.00</td><td>20.92/9.52</td><td>14.46/14.08</td><td>26.85/10.54</td><td>30.31/17.20</td><td>19.64/10.95</td></tr><tr><td>Finetune (1k)</td><td>70.87/47.82</td><td>72.49</td><td>0.20/0.02</td><td>90.33/80.20</td><td>43.43/19.81</td><td>30.75/30.50</td><td>52.50/17.33</td><td>44.70/24.92</td><td>50.66/31.51</td></tr></table>"
+        },
+        {
+            "type": "table_caption",
+            "bbox": [
+                0.115,
+                0.219,
+                0.884,
+                0.248
+            ],
+            "angle": 0,
+            "content": "Table 5: Page- and passage-level \\( R \\) -Precision in the zero-shot setting and with additional fine-tuning of 128 and 1,024 examples. We also compare to a BM25 retriever and a DPR model initialised with BERT weights."
+        },
+        {
+            "type": "text",
+            "bbox": [
+                0.115,
+                0.273,
+                0.492,
+                0.402
+            ],
+            "angle": 0,
+            "content": "performance being competitive to BM25, and the average few-shot performance being markedly better than the alternatives. The discrepancy in performance between a vanilla DPR model and the leave-one-out multi-task model is especially noticeable when using the smaller of the two datasets, in which case average performance for the latter is more than double that of vanilla DPR."
+        },
+        {
+            "type": "title",
+            "bbox": [
+                0.116,
+                0.413,
+                0.283,
+                0.427
+            ],
+            "angle": 0,
+            "content": "4.5 Model variants"
+        },
+        {
+            "type": "table",
+            "bbox": [
+                0.12,
+                0.442,
+                0.488,
+                0.508
+            ],
+            "angle": 0,
+            "content": "<table><tr><td>variant</td><td>FEV</td><td>NQ</td><td>TQA</td></tr><tr><td>Base</td><td>76.38/40.76</td><td>60.91/24.50</td><td>64.77/21.75</td></tr><tr><td>Task markers</td><td>75.84/40.79</td><td>62.31/25.10</td><td>64.04/20.86</td></tr><tr><td>Task-spec. enc.</td><td>73.53/40.02</td><td>61.05/25.52</td><td>64.17/21.23</td></tr></table>"
+        },
+        {
+            "type": "table_caption",
+            "bbox": [
+                0.115,
+                0.517,
+                0.49,
+                0.56
+            ],
+            "angle": 0,
+            "content": "Table 6: Multi-task model variants evaluated on a subset of tasks (\\(R\\)-precision on validation data at page/passage level)."
+        },
+        {
+            "type": "text",
+            "bbox": [
+                0.115,
+                0.58,
+                0.49,
+                0.756
+            ],
+            "angle": 0,
+            "content": "In this set of experiments we compare our base multi-task model with the two variants described in § 3.1. Due to the high memory consumption of the \"task-specific encoders\" variant (requiring one full query encoder per task family, in addition to the passage encoder), it was only possible to perform these evaluations in a restricted setting of three datasets. The results in Table 6 do not reveal a clear winner, suggesting that the base architecture might be the better choice due to its simplicity and generally good performance.\\(^4\\)"
+        },
+        {
+            "type": "title",
+            "bbox": [
+                0.116,
+                0.767,
+                0.422,
+                0.782
+            ],
+            "angle": 0,
+            "content": "4.6 Adversarial confounder selection"
+        },
+        {
+            "type": "text",
+            "bbox": [
+                0.115,
+                0.788,
+                0.492,
+                0.852
+            ],
+            "angle": 0,
+            "content": "Finally, we evaluate the adversarial confounder selection method described in § 3.2. This involves augmenting our regular training sets with additional confounders for TriviaQA and Natural Ques"
+        },
+        {
+            "type": "text",
+            "bbox": [
+                0.51,
+                0.274,
+                0.886,
+                0.417
+            ],
+            "angle": 0,
+            "content": "tions, selected using our top multi-task trained model. A new multi-task model is then trained from scratch on this augmented data. Its performance is reported in Table 7, showing an overall improvement across multiple tasks. While this approach is demonstrated here on our multi-task model, it is in fact orthogonal to it, and could be applied to any other neural retrievers trained with a contrastive loss."
+        },
+        {
+            "type": "title",
+            "bbox": [
+                0.511,
+                0.432,
+                0.664,
+                0.447
+            ],
+            "angle": 0,
+            "content": "5 Related work"
+        },
+        {
+            "type": "text",
+            "bbox": [
+                0.509,
+                0.459,
+                0.886,
+                0.699
+            ],
+            "angle": 0,
+            "content": "The approach most closely related to ours is DPR (Karpukhin et al., 2020), upon which we built all our retrieval systems. This model is covered in detail in § 2.1, in addition to the historical context. Another closely related approach is the Retrieval-Augmented Generation (RAG) model of Lewis et al. (2020b). In its base configuration it augments DPR with a generative reader, and it trains the query encoder end-to-end (differing from traditional retriever-reader architectures which treat the two steps as disjoint). A natural extension of the work we have presented would be to combine RAG with our joint learning approach, to study whether it can lead to further gains in performance or robustness."
+        },
+        {
+            "type": "text",
+            "bbox": [
+                0.509,
+                0.701,
+                0.886,
+                0.911
+            ],
+            "angle": 0,
+            "content": "A number of promising techniques to boost retrieval performance have been proposed recently. These are orthogonal to our work, and as such they could be combined with it. Amongst these, pretraining methods form one class. Inverse Cloze Task (Lee et al., 2019) and its extensions (Chang et al., 2020) are self-supervised pre-training methods designed for retrieval in open-domain question answering. Whether such specific pre-training is beneficial to tasks other than question answering remains an open question. CERT (Fang et al., 2020) is an alternative pre-training approach, inspired by some recent advances in computer vision. While to"
+        },
+        {
+            "type": "page_footnote",
+            "bbox": [
+                0.115,
+                0.86,
+                0.49,
+                0.911
+            ],
+            "angle": 0,
+            "content": "4Not included in this table, due to very poor performance in preliminary experiments, are two further variants: a base model with a single encoder for both queries and passages, and a base model trained from scratch without BERT pre-training."
+        }
+    ],
+    [
+        {
+            "type": "table",
+            "bbox": [
+                0.126,
+                0.073,
+                0.882,
+                0.139
+            ],
+            "angle": 0,
+            "content": "<table><tr><td rowspan=\"2\">confounders</td><td rowspan=\"2\">Fact Check. FEV</td><td rowspan=\"2\">Ent. L. AY2</td><td rowspan=\"2\">Slot Filling T-REx</td><td rowspan=\"2\">zsRE</td><td colspan=\"3\">Open Domain QA</td><td rowspan=\"2\">Dial. WoW</td></tr><tr><td>NQ</td><td>HoPo</td><td>TQA</td></tr><tr><td>BM25</td><td>74.72/46.96</td><td>83.78</td><td>69.18/53.54</td><td>77.23/41.70</td><td>61.51/28.80</td><td>44.21/38.42</td><td>61.95/24.56</td><td>39.70/24.07</td></tr><tr><td>BM25 + adv</td><td>74.79/52.12</td><td>84.86</td><td>71.36/61.40</td><td>80.04/54.08</td><td>59.25/40.11</td><td>44.08/41.04</td><td>59.19/34.17</td><td>41.04/24.62</td></tr></table>"
+        },
+        {
+            "type": "table_caption",
+            "bbox": [
+                0.115,
+                0.148,
+                0.884,
+                0.178
+            ],
+            "angle": 0,
+            "content": "Table 7: Comparison of two confounder selection methods for the multi-task model: simple BM25, and BM25 augmented with adversarial confounders (\\(R\\)-precision on validation data at page/passage level)."
+        },
+        {
+            "type": "text",
+            "bbox": [
+                0.115,
+                0.203,
+                0.49,
+                0.284
+            ],
+            "angle": 0,
+            "content": "our knowledge this has not been applied to retrieval problems, we believe it might be promising due to its focus on sentence-level semantics (as opposed to the more standard masked language modelling pre-training, which focuses on the token-level)."
+        },
+        {
+            "type": "text",
+            "bbox": [
+                0.115,
+                0.285,
+                0.492,
+                0.429
+            ],
+            "angle": 0,
+            "content": "Another class of orthogonal improvements to dense retrieval involves models which embed passages into multiple fixed-size vectors. Of these, ColBERT (Khattab and Zaharia, 2020) and MEBERT (Luan et al., 2020) are two representative examples. One further approach is ColBERT-QA (Khattab et al., 2020), which additionally uses a data augmentation strategy closely related to our own approach described in § 3.2."
+        },
+        {
+            "type": "text",
+            "bbox": [
+                0.115,
+                0.43,
+                0.49,
+                0.577
+            ],
+            "angle": 0,
+            "content": "Finally two entity linkers, GENRE (Cao et al., 2020) and BLINK (Wu et al., 2020), are worth mentioning. Being trained specifically for entity linking, these models will generally outperform retrieval-based approaches on that task. While they are not comparable to retrieval models and will not generally be applicable to information retrieval tasks, we mention them here to provide readers with a fuller context of the existing literature."
+        },
+        {
+            "type": "title",
+            "bbox": [
+                0.116,
+                0.59,
+                0.258,
+                0.606
+            ],
+            "angle": 0,
+            "content": "6 Conclusions"
+        },
+        {
+            "type": "text",
+            "bbox": [
+                0.115,
+                0.618,
+                0.49,
+                0.699
+            ],
+            "angle": 0,
+            "content": "We have conducted a large-scale experimental study on knowledge-intensive tasks, and how retrieval models that tackle them seek the required information from knowledge bases such as Wikipedia."
+        },
+        {
+            "type": "text",
+            "bbox": [
+                0.115,
+                0.7,
+                0.492,
+                0.811
+            ],
+            "angle": 0,
+            "content": "The study started with the question of whether the way in which information is embedded for retrieval purposes is universal. Section 4.2 provided evidence that to a large extent it is, with a single \"universal\" retriever, trained jointly on 8 datasets, often performing comparably to task-specific models."
+        },
+        {
+            "type": "text",
+            "bbox": [
+                0.115,
+                0.814,
+                0.492,
+                0.911
+            ],
+            "angle": 0,
+            "content": "Armed with this knowledge, in Section 4.3 we plugged our single model in a larger pipeline, in order to see its contribution to the downstream performance on a wide range of knowledge-intensive tasks. This led to an overall improvement in downstream performance, setting new top results for a"
+        },
+        {
+            "type": "text",
+            "bbox": [
+                0.511,
+                0.203,
+                0.816,
+                0.218
+            ],
+            "angle": 0,
+            "content": "number of tasks in the KILT benchmark."
+        },
+        {
+            "type": "text",
+            "bbox": [
+                0.51,
+                0.22,
+                0.886,
+                0.333
+            ],
+            "angle": 0,
+            "content": "Next, in Section 4.4, we evaluated the model's performance in the zero-shot and few-shot settings. By evaluating on a wide range of tasks, we were able to show that our proposed approach performs comparably to BM25 in the zero-shot setting, and quickly overtakes it even with minimal in-domain training."
+        },
+        {
+            "type": "text",
+            "bbox": [
+                0.51,
+                0.334,
+                0.886,
+                0.43
+            ],
+            "angle": 0,
+            "content": "In Section 4.5 we evaluated a number of more complex variants of the model involving task specialisation, but failed to see clear performance improvements. Finally, in Section 4.6 we saw how a simple iterative approach to data augmentation can lead to better performance."
+        },
+        {
+            "type": "text",
+            "bbox": [
+                0.51,
+                0.432,
+                0.886,
+                0.641
+            ],
+            "angle": 0,
+            "content": "In the coming months we will provide a pretrained snapshot of our best-performing model, in the form of a BERT checkpoint. As shown, this model will be useful in zero-shot and few-shot settings as a better performing alternative to both IR-based approaches such as BM25, as well as task-specific models. The multi-task training approach demonstrated here can also be useful in industry settings where several retrieval operations may need to be performed on the same piece of content, and the deployment of multiple task-specific models might not be possible due to space or computational performance concerns."
+        },
+        {
+            "type": "title",
+            "bbox": [
+                0.513,
+                0.671,
+                0.611,
+                0.685
+            ],
+            "angle": 0,
+            "content": "References"
+        },
+        {
+            "type": "ref_text",
+            "bbox": [
+                0.512,
+                0.695,
+                0.886,
+                0.735
+            ],
+            "angle": 0,
+            "content": "Nicola De Cao, Gautier Izacard, Sebastian Riedel, and Fabio Petroni. 2020. Autoregressive entity retrieval. ArXiv, abs/2010.00904."
+        },
+        {
+            "type": "ref_text",
+            "bbox": [
+                0.512,
+                0.749,
+                0.886,
+                0.815
+            ],
+            "angle": 0,
+            "content": "Wei-Cheng Chang, Felix X. Yu, Yin-Wen Chang, Yiming Yang, and Sanjiv Kumar. 2020. Pre-training tasks for embedding-based large-scale retrieval. In International Conference on Learning Representations."
+        },
+        {
+            "type": "ref_text",
+            "bbox": [
+                0.512,
+                0.829,
+                0.886,
+                0.884
+            ],
+            "angle": 0,
+            "content": "Danqi Chen, Adam Fisch, Jason Weston, and Antoine Bordes. 2017. Reading Wikipedia to answer open-domain questions. In Proceedings of the 55th Annual Meeting of the Association for Computational"
+        },
+        {
+            "type": "list",
+            "bbox": [
+                0.512,
+                0.695,
+                0.886,
+                0.884
+            ],
+            "angle": 0,
+            "content": null
+        },
+        {
+            "type": "page_footnote",
+            "bbox": [
+                0.532,
+                0.895,
+                0.816,
+                0.91
+            ],
+            "angle": 0,
+            "content": "E.g. fact checking and hate speech detection."
+        }
+    ],
+    [
+        {
+            "type": "ref_text",
+            "bbox": [
+                0.135,
+                0.077,
+                0.491,
+                0.116
+            ],
+            "angle": 0,
+            "content": "Linguistics (Volume 1: Long Papers), pages 1870-1879, Vancouver, Canada. Association for Computational Linguistics."
+        },
+        {
+            "type": "ref_text",
+            "bbox": [
+                0.119,
+                0.128,
+                0.492,
+                0.194
+            ],
+            "angle": 0,
+            "content": "Scott Deerwester, Susan T Dumais, George W Furnas, Thomas K Landauer, and Richard Harshman. 1990. Indexing by latent semantic analysis. Journal of the American society for information science, 41(6):391-407."
+        },
+        {
+            "type": "ref_text",
+            "bbox": [
+                0.119,
+                0.207,
+                0.491,
+                0.324
+            ],
+            "angle": 0,
+            "content": "Jacob Devlin, Ming-Wei Chang, Kenton Lee, and Kristina Toutanova. 2019. BERT: Pre-training of deep bidirectional transformers for language understanding. In Proceedings of the 2019 Conference of the North American Chapter of the Association for Computational Linguistics: Human Language Technologies, Volume 1 (Long and Short Papers), pages 4171-4186, Minneapolis, Minnesota. Association for Computational Linguistics."
+        },
+        {
+            "type": "ref_text",
+            "bbox": [
+                0.119,
+                0.337,
+                0.49,
+                0.388
+            ],
+            "angle": 0,
+            "content": "Hongchao Fang, Sicheng Wang, Meng Zhou, Jiayuan Ding, and Pengtao Xie. 2020. CERT: Contrastive self-supervised learning for language understanding. ArXiv, abs/2005.12766."
+        },
+        {
+            "type": "ref_text",
+            "bbox": [
+                0.119,
+                0.402,
+                0.491,
+                0.479
+            ],
+            "angle": 0,
+            "content": "Jianfeng Gao, Kristina Toutanova, and Wen-tau Yih. 2011. Clickthrough-based latent semantic models for web search. In Proceedings of the 34th international ACM SIGIR conference on Research and development in Information Retrieval, pages 675-684. ACM."
+        },
+        {
+            "type": "ref_text",
+            "bbox": [
+                0.119,
+                0.492,
+                0.49,
+                0.545
+            ],
+            "angle": 0,
+            "content": "Ruiqi Guo, Sanjiv Kumar, Krzysztof Choromanski, and David Simcha. 2016. Quantization based fast inner product search. In Artificial Intelligence and Statistics, pages 482-490."
+        },
+        {
+            "type": "ref_text",
+            "bbox": [
+                0.119,
+                0.557,
+                0.491,
+                0.662
+            ],
+            "angle": 0,
+            "content": "Johannes Hoffart, Mohamed Amir Yosef, Ilaria Bordino, Hagen Fürstenau, Manfred Pinkal, Marc Spanirol, Bilyana Taneva, Stefan Thater, and Gerhard Weikum. 2011. Robust disambiguation of named entities in text. In Proceedings of the 2011 Conference on Empirical Methods in Natural Language Processing, pages 782-792, Edinburgh, Scotland, UK. Association for Computational Linguistics."
+        },
+        {
+            "type": "ref_text",
+            "bbox": [
+                0.119,
+                0.675,
+                0.49,
+                0.78
+            ],
+            "angle": 0,
+            "content": "Po-Sen Huang, Xiaodong He, Jianfeng Gao, Li Deng, Alex Acero, and Larry Heck. 2013. Learning deep structured semantic models for web search using clickthrough data. In Proceedings of the 22nd ACM International Conference on Information and Knowledge Management, page 2333-2338, New York, NY, USA. Association for Computing Machinery."
+        },
+        {
+            "type": "ref_text",
+            "bbox": [
+                0.119,
+                0.792,
+                0.49,
+                0.831
+            ],
+            "angle": 0,
+            "content": "J. Johnson, M. Douze, and H. Jégou. 2019. Billion-scale similarity search with GPUs. IEEE Transactions on Big Data, pages 1-1."
+        },
+        {
+            "type": "ref_text",
+            "bbox": [
+                0.119,
+                0.843,
+                0.491,
+                0.909
+            ],
+            "angle": 0,
+            "content": "Mandar Joshi, Eunsol Choi, Daniel Weld, and Luke Zettlemoyer. 2017. TriviaQA: A large scale distantly supervised challenge dataset for reading comprehension. In Proceedings of the 55th Annual Meeting of the Association for Computational Linguistics"
+        },
+        {
+            "type": "list",
+            "bbox": [
+                0.119,
+                0.077,
+                0.492,
+                0.909
+            ],
+            "angle": 0,
+            "content": null
+        },
+        {
+            "type": "ref_text",
+            "bbox": [
+                0.533,
+                0.077,
+                0.885,
+                0.116
+            ],
+            "angle": 0,
+            "content": "(Volume 1: Long Papers), pages 1601-1611, Vancouver, Canada. Association for Computational Linguistics."
+        },
+        {
+            "type": "ref_text",
+            "bbox": [
+                0.514,
+                0.127,
+                0.885,
+                0.219
+            ],
+            "angle": 0,
+            "content": "Vladimir Karpukhin, Barlas Oğuz, Sewon Min, Patrick Lewis, Ledell Wu, Sergey Edunov, Danqi Chen, and Wen-tau Yih. 2020. Dense passage retrieval for open-domain question answering. In Proceedings of the 2020 Conference on Empirical Methods in Natural Language Processing (EMNLP). Association for Computational Linguistics."
+        },
+        {
+            "type": "ref_text",
+            "bbox": [
+                0.514,
+                0.23,
+                0.885,
+                0.269
+            ],
+            "angle": 0,
+            "content": "Omar Khattab, Christopher Potts, and Matei Zaharia. 2020. Relevance-guided supervision for OpenQA with ColBERT. ArXiv, abs/2007.00814."
+        },
+        {
+            "type": "ref_text",
+            "bbox": [
+                0.514,
+                0.28,
+                0.885,
+                0.346
+            ],
+            "angle": 0,
+            "content": "Omar Khattab and Matei Zaharia. 2020. ColBERT: Efficient and effective passage search via contextualized late interaction over BERT. In Proceedings of the 43rd international ACM SIGIR conference on Research and development in Information Retrieval."
+        },
+        {
+            "type": "ref_text",
+            "bbox": [
+                0.514,
+                0.357,
+                0.884,
+                0.396
+            ],
+            "angle": 0,
+            "content": "Diederick P Kingma and Jimmy Ba. 2015. Adam: A method for stochastic optimization. In International Conference on Learning Representations (ICLR)."
+        },
+        {
+            "type": "ref_text",
+            "bbox": [
+                0.514,
+                0.407,
+                0.885,
+                0.525
+            ],
+            "angle": 0,
+            "content": "Tom Kwiatkowski, Jennimaria Palomaki, Olivia Redfield, Michael Collins, Ankur Parikh, Chris Alberti, Danielle Epstein, Illia Polosukhin, Matthew Kelcey, Jacob Devlin, Kenton Lee, Kristina N. Toutanova, Llion Jones, Ming-Wei Chang, Andrew Dai, Jakob Uszkoreit, Quoc Le, and Slav Petrov. 2019. Natural questions: a benchmark for question answering research. Transactions of the Association of Computational Linguistics."
+        },
+        {
+            "type": "ref_text",
+            "bbox": [
+                0.514,
+                0.535,
+                0.885,
+                0.614
+            ],
+            "angle": 0,
+            "content": "Kenton Lee, Ming-Wei Chang, and Kristina Toutanova. 2019. Latent retrieval for weakly supervised open domain question answering. In Proceedings of the 57th Annual Meeting of the Association for Computational Linguistics, pages 6086-6096, Florence, Italy. Association for Computational Linguistics."
+        },
+        {
+            "type": "ref_text",
+            "bbox": [
+                0.514,
+                0.625,
+                0.885,
+                0.716
+            ],
+            "angle": 0,
+            "content": "Omer Levy, Minjoon Seo, Eunsol Choi, and Luke Zettlemoyer. 2017. Zero-shot relation extraction via reading comprehension. In Proceedings of the 21st Conference on Computational Natural Language Learning (CoNLL 2017), pages 333-342, Vancouver, Canada. Association for Computational Linguistics."
+        },
+        {
+            "type": "ref_text",
+            "bbox": [
+                0.514,
+                0.728,
+                0.885,
+                0.845
+            ],
+            "angle": 0,
+            "content": "Mike Lewis, Yinhan Liu, Naman Goyal, Marjan Ghazvininejad, Abdelrahman Mohamed, Omer Levy, Veselin Stoyanov, and Luke Zettlemoyer. 2020a. BART: Denoising sequence-to-sequence pretraining for natural language generation, translation, and comprehension. In Proceedings of the 58th Annual Meeting of the Association for Computational Linguistics, pages 7871-7880, Online. Association for Computational Linguistics."
+        },
+        {
+            "type": "ref_text",
+            "bbox": [
+                0.514,
+                0.856,
+                0.885,
+                0.908
+            ],
+            "angle": 0,
+            "content": "Patrick Lewis, Ethan Perez, Aleksandara Piktus, Fabio Petroni, Vladimir Karpukhin, Naman Goyal, Heinrich Kuttler, Mike Lewis, Wen-tau Yih, Tim Roektaschel, Sebastian Riedel, and Douwe"
+        },
+        {
+            "type": "list",
+            "bbox": [
+                0.514,
+                0.077,
+                0.885,
+                0.908
+            ],
+            "angle": 0,
+            "content": null
+        }
+    ],
+    [
+        {
+            "type": "ref_text",
+            "bbox": [
+                0.135,
+                0.077,
+                0.49,
+                0.119
+            ],
+            "angle": 0,
+            "content": "Kiela. 2020b. Retrieval-augmented generation for knowledge-intensive NLP tasks. In Advances in Neural Information Processing Systems (NeurIPS)."
+        },
+        {
+            "type": "ref_text",
+            "bbox": [
+                0.119,
+                0.127,
+                0.492,
+                0.219
+            ],
+            "angle": 0,
+            "content": "Xiaodong Liu, Pengcheng He, Weizhu Chen, and Jianfeng Gao. 2019a. Multi-task deep neural networks for natural language understanding. In Proceedings of the 57th Annual Meeting of the Association for Computational Linguistics, pages 4487-4496, Florence, Italy. Association for Computational Linguistics."
+        },
+        {
+            "type": "ref_text",
+            "bbox": [
+                0.119,
+                0.23,
+                0.492,
+                0.297
+            ],
+            "angle": 0,
+            "content": "Yinhan Liu, Myle Ott, Naman Goyal, Jingfei Du, Mandar Joshi, Danqi Chen, Omer Levy, Mike Lewis, Luke Zettlemoyer, and Veselin Stoyanov. 2019b. Roberta: A robustly optimized bert pretraining approach. ArXiv, abs/1907.11692."
+        },
+        {
+            "type": "ref_text",
+            "bbox": [
+                0.119,
+                0.307,
+                0.492,
+                0.358
+            ],
+            "angle": 0,
+            "content": "Yi Luan, Jacob Eisenstein, Kristina Toutanova, and Michael Collins. 2020. Sparse, dense, and attentional representations for text retrieval. *ArXiv*, abs/2005.00181."
+        },
+        {
+            "type": "ref_text",
+            "bbox": [
+                0.119,
+                0.37,
+                0.492,
+                0.411
+            ],
+            "angle": 0,
+            "content": "Christopher D Manning, Hinrich Schütze, and Prabhakar Raghavan. 2008. Introduction to information retrieval. Cambridge university press."
+        },
+        {
+            "type": "ref_text",
+            "bbox": [
+                0.119,
+                0.421,
+                0.492,
+                0.5
+            ],
+            "angle": 0,
+            "content": "Fabio Petroni, Aleksandra Piktus, Angela Fan, Patrick Lewis, Majid Yazdani, Nicola De Cao, James Thorne, Yacine Jernite, Vassilis Plachouras, Tim Roktaschel, and Sebastian Riedel. 2020. KILT: a benchmark for knowledge intensive language tasks. In arXiv:2009.02252."
+        },
+        {
+            "type": "ref_text",
+            "bbox": [
+                0.119,
+                0.511,
+                0.492,
+                0.563
+            ],
+            "angle": 0,
+            "content": "Fabio Petroni, Tim Rocttäschel, Patrick Lewis, Anton Bakhtin, Yuxiang Wu, Alexander H Miller, and Sebastian Riedel. 2019. Language models as knowledge bases? EMNLP."
+        },
+        {
+            "type": "ref_text",
+            "bbox": [
+                0.119,
+                0.574,
+                0.492,
+                0.627
+            ],
+            "angle": 0,
+            "content": "Stephen Robertson and Hugo Zaragoza. 2009. The probabilistic relevance framework: BM25 and beyond. Foundations and Trends in Information Retrieval, 3(4):333-389."
+        },
+        {
+            "type": "ref_text",
+            "bbox": [
+                0.119,
+                0.638,
+                0.492,
+                0.703
+            ],
+            "angle": 0,
+            "content": "Anshumali Shrivastava and Ping Li. 2014. Asymmetric LSH (ALSH) for sublinear time maximum inner product search (MIPS). In Advances in Neural Information Processing Systems (NIPS), pages 2321-2329."
+        },
+        {
+            "type": "ref_text",
+            "bbox": [
+                0.119,
+                0.715,
+                0.492,
+                0.833
+            ],
+            "angle": 0,
+            "content": "James Thorne, Andreas Vlachos, Christos Christodoulopoulos, and Arpit Mittal. 2018. FEVER: a large-scale dataset for fact extraction and VERIFICATION. In Proceedings of the 2018 Conference of the North American Chapter of the Association for Computational Linguistics: Human Language Technologies, Volume 1 (Long Papers), pages 809-819, New Orleans, Louisiana. Association for Computational Linguistics."
+        },
+        {
+            "type": "ref_text",
+            "bbox": [
+                0.119,
+                0.843,
+                0.492,
+                0.908
+            ],
+            "angle": 0,
+            "content": "Shuohang Wang, Mo Yu, Xiaoxiao Guo, Z. Wang, Tim Klinger, Wei Zhang, S. Chang, G. Tesauro, Bowen Zhou, and Jing Jiang. 2018. R3: Reinforced ranker-reader for open-domain question answering. In AAAI."
+        },
+        {
+            "type": "list",
+            "bbox": [
+                0.119,
+                0.077,
+                0.492,
+                0.908
+            ],
+            "angle": 0,
+            "content": null
+        },
+        {
+            "type": "ref_text",
+            "bbox": [
+                0.513,
+                0.077,
+                0.886,
+                0.196
+            ],
+            "angle": 0,
+            "content": "Zhiguo Wang, Patrick Ng, Xiaofei Ma, Ramesh Nallapati, and Bing Xiang. 2019. Multi-passage BERT: A globally normalized BERT model for open-domain question answering. In Proceedings of the 2019 Conference on Empirical Methods in Natural Language Processing and the 9th International Joint Conference on Natural Language Processing (EMNLP-IJCNLP), pages 5878-5882, Hong Kong, China. Association for Computational Linguistics."
+        },
+        {
+            "type": "ref_text",
+            "bbox": [
+                0.513,
+                0.205,
+                0.886,
+                0.297
+            ],
+            "angle": 0,
+            "content": "Ledell Wu, Fabio Petroni, Martin Josifoski, Sebastian Riedel, and Luke Zettlemoyer. 2020. Scalable zero-shot entity linking with dense entity retrieval. In Proceedings of the 2020 Conference on Empirical Methods in Natural Language Processing (EMNLP), pages 6397-6407, Online. Association for Computational Linguistics."
+        },
+        {
+            "type": "ref_text",
+            "bbox": [
+                0.513,
+                0.307,
+                0.886,
+                0.372
+            ],
+            "angle": 0,
+            "content": "Lee Xiong, Chenyan Xiong, Ye Li, Kwok-Fung Tang, Jialin Liu, Paul Bennett, Junaid Ahmed, and Arnold Overwijk. 2020. Approximate nearest neighbor negative contrastive learning for dense text retrieval. ArXiv, abs/2007.00808."
+        },
+        {
+            "type": "ref_text",
+            "bbox": [
+                0.513,
+                0.382,
+                0.886,
+                0.462
+            ],
+            "angle": 0,
+            "content": "Wen-tau Yih, Kristina Toutanova, John C Platt, and Christopher Meek. 2011. Learning discriminative projections for text similarity measures. In Proceedings of the Fifteenth Conference on Computational Natural Language Learning, pages 247-256. Association for Computational Linguistics."
+        },
+        {
+            "type": "list",
+            "bbox": [
+                0.513,
+                0.077,
+                0.886,
+                0.462
+            ],
+            "angle": 0,
+            "content": null
+        }
+    ]
+]

data/2021/2101_00xxx/2101.00117/full.md

@@ -1,3 +1,284 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:3c5e7ba99203850f0a043ed2c1fbd2d0550084addd9f71e53fc55082e3ba1e43
-size 49151
+# Multi-task Retrieval for Knowledge-Intensive Tasks
+
+Jean Maillard* Vladimir Karpukhin* Fabio Petroni  
+Wen-tau Yih Barlas Oğuz Veselin Stoyanov Gargi Ghosh  
+Facebook AI
+
+{jeanm,vladk, fabiopetroni, scottyih, barlaso, ves, gghosh}@fb.com
+
+# Abstract
+
+Retrieving relevant contexts from a large corpus is a crucial step for tasks such as open-domain question answering and fact checking. Although neural retrieval outperforms traditional methods like tfidf and BM25, its performance degrades considerably when applied to out-of-domain data. Driven by the question of whether a neural retrieval model can be universal and perform robustly on a wide variety of problems, we propose a multi-task trained model. Our approach not only outperforms previous methods in the few-shot setting, but also rivals specialised neural retrievers, even when in-domain training data is abundant. With the help of our retriever, we improve existing models for downstream tasks and closely match or improve the state of the art on multiple benchmarks.
+
+# 1 Introduction
+
+Knowledge-intensive tasks is the common designation for a class of real-world NLP problems which, because of their nature, require large amounts of knowledge about the world (Petroni et al., 2020). For example, open-domain question answering requires producing answers to general factoid questions; fact checking involves determining the veracity of claims based on a database of trusted evidence. Practical solutions to these tasks usually involve an efficient retrieval component that, given an input query, selects a limited subset of relevant information from a large knowledge source. Sophisticated downstream models then consider the input only in the context of the retrieved information, and perform the final task.
+
+The standard retrieval component in many systems (e.g., Thorne et al., 2018; Wang et al., 2018; Chen et al., 2017) has long relied on term-matching methods, such as tfidf or BM25 (Robertson and Zaragoza, 2009). These methods rely on efficient algorithms and usually perform reasonably well regardless of the problem. In contrast, recent neural retrieval models, such as ICT (Lee et al., 2019), DPR (Karpukhin et al., 2020) and RAG (Lewis et al., 2020b) achieve better results by learning directly from task-specific training data and going beyond simple keyword matching. While task specialisation results in improved task performance, researchers have observed that a retriever trained for one specific domain will typically achieve low out-of-domain performance, and even lower performance on entirely different tasks (Petroni et al., 2020). This has two implications. First, unlike tfidf or BM25, neural retrieval models are unsuitable for low data regimes such as few- and zero-shot settings. Second, task-specific retrievers complicate practical applications where multiple knowledge-intensive tasks may need to be performed using the same supporting database or over the same input text. It may not be practical to deploy multiple separate specialised models due to computational performance or memory concerns.
+
+We ask the following question in this work: can we develop a universal neural retriever? Namely, we target a retriever that can perform well on a wide variety of problems, without task-specific fine-tuning, but, if additional in-domain labelled data is available, it can be further fine-tuned to improve the performance. We perform a large experimental study to attempt to build such a universal retrieval model. We find that, by jointly training on an extensive selection of retrieval tasks, we obtain a model which is not only more robust than previous approaches, but also can lead to better performance on the downstream knowledge-intensive tasks when
+
+plugged into an existing system. Our approach combines the benefits from IR-based models with those of task-specific neural retrievers – namely, good performance when no (or not enough) training data is available and high task performance due to its ability to learn highly specialised representations.
+
+Our contributions can be summarised as follows.
+
+- We propose a single general-purpose "universal" retrieval model, able to perform comparably or better than specialised retriever approaches in both zero-shot (leave-one-out) and few-shot retrieval. We investigate several model variants, shedding light on what are the aspects of the architecture that affect its performance.  
+- We show that our model's gains in terms of retrieval directly translate into performance gains for a variety of downstream knowledge-intensive tasks.  
+- We will share the implementation as well as our best model. This is in the form of a readily available BERT checkpoint which, as we will show, can be used by NLP practitioners as a strong out-of-the-box retrieval system, but which can also undergo further in-domain training for even higher performance.
+
+# 2 Background
+
+In this section, we first give an overview of retrieval methods based on sparse and dense representations. We then discuss a wide range of knowledge-intensive NLP tasks, where retrieval plays a crucial role in solving the problems.
+
+# 2.1 Retrieval methods
+
+Given a large collection of unstructured text passages, information retrieval (IR) can be broadly defined as finding a small set of passages that satisfies an information need, often presented in the form of a short-text query (Manning et al., 2008). Traditional IR methods, such as tfidf and BM25 (Robertson and Zaragoza, 2009), match keywords efficiently with an inverted index. Such methods can be seen as representing queries and passages in high-dimensional, sparse vectors, where each dimension corresponds to a term in the vocabulary and the weight indicates its importance.
+
+In contrast to tfidf and BM25, dense retrieval methods encode text as a latent semantic vector of
+
+a fixed, much smaller dimensionality. Whether a passage is relevant to a given query is determined by the distance of their vectors (Deerwester et al., 1990). Although dense representations do not encode tokens explicitly and can potentially map paraphrases of completely different tokens to close vectors, performance of early dense retrieval methods was often inferior to term-matching approaches, except when large labelled data is available (Yih et al., 2011; Gao et al., 2011; Huang et al., 2013). Thanks to success of large pre-trained models (Devlin et al., 2019; Liu et al., 2019b), however, recent dense retrieval methods have shown to outperform the sparse counterparts, when fine-tuned on a small set of in-domain labelled data (Karpukhin et al., 2020; Lewis et al., 2020b; Xiong et al., 2020). Efficient index and search of dense vectors are made possible by maximum inner product search (MIPS) algorithms (e.g., Shrivastava and Li, 2014; Guo et al., 2016), as well as tools like FAISS (Johnson et al., 2019).
+
+Our work is built upon the Dense Passage Retriever (DPR) architecture of Karpukhin et al. (2020), which was initially proposed for the task of open-domain question answering. DPR is a neural bi-encoder model which embeds queries with an encoder  $\pmb{f}(\cdot)$  and passages with a separate encoder  $\pmb{g}(\cdot)$ . Given an input query  $x$  and a target passage  $y$ , we have
+
+$$
+\mathrm {p} (x \mid y) \propto \operatorname {s i m} (x, y),
+$$
+
+where the similarity score  $\operatorname{sim}(x, y)$  is defined as the inner product of the embeddings of its arguments,  $f(x) \cdot g(y)$ . Given a query at inference time, calculating its similarity with every possible passage would be prohibitive for large knowledge sources. Therefore, DPR makes use of the FAISS library (Johnson et al., 2019) to perform fast approximate nearest neighbour search in sub-linear time.
+
+Training is based on a contrastive loss. Given a query  $x$ , a relevant passage  $y$ , and a set of  $n$  irrelevant passages  $y_{i}^{-}$ , we train the model by optimising the following negative log likelihood:
+
+$$
+\mathcal {L} = - \log \frac {\exp (\sin (x , y))}{\exp (\sin (x , y)) + \sum_ {i = 1} ^ {n} \exp (\sin \left(x , y _ {i} ^ {-}\right))}.
+$$
+
+As the set of irrelevant passages, we use the relevant passages for other queries within the same batch, as well as a specially selected "hard" confounder. This is a passage which has high lexical
+
+![](images/621902d35d1bf24b48bdcdbf60ce2d59b0143827fe860dd1388b9ae45571b499.jpg)  
+Figure 1: Training of DPR (Karpukhin et al., 2020), a bi-encoder model for open-domain question answering. Queries and passages are encoded as vectors, and retrieval is performed as a maximum inner product search.
+
+overlap with the query (high BM25 score), but is not among the set of relevant passages for the given data point. Karpukhin et al. (2020) have shown that the inclusion of such "hard" confounders leads to substantially improved training results. This training process is illustrated in Figure 1.
+
+# 2.2 Knowledge-intensive Tasks
+
+For the training and evaluation of all models in the paper we make use of KILT, a benchmark and library of datasets (Petroni et al., 2020). KILT consists of a selection of datasets spanning five varied classes of knowledge-intensive tasks (i.e., question answering, slot filling, fact checking, dialogue, entity linking), with the aim to cover many different ways of seeking knowledge. Input queries can vary wildly from one task to the other, and include classic examples of open-domain retrieval tasks such as natural language questions and claims to be verified, as well as more unusual examples like conversation fragments and long chunks of annotated text. Crucially, all datasets distributed in KILT have been re-aligned such that they are all grounded in the same snapshot of Wikipedia, which the authors distribute. The knowledge required to answer any of the queries in the library of tasks can thus be found within the same unified knowledge source.
+
+To illustrate the variety of ways in which the input queries for different tasks can be formulated, we provide a few simple examples in Table 1. In spite of the differences between query formulations, all these tasks share one crucial aspect: they all require a retriever to fetch the relevant passages from the knowledge source, in order to support the final downstream task.
+
+# 3 Methods
+
+# 3.1 Universal retrieval
+
+Using task-specific models to tackle our collection of retrieval tasks would involve completely separate models, one per dataset. As illustrated in Figure 2, this would lead to a proliferation of models and data, down to separate indexed copies of the knowledge source itself (Wikipedia). This setup will form one of our baselines.
+
+![](images/41bc26ece836270c36eb8528cdf2d4e8a134c890b3217324417fb9514d3c77c6.jpg)  
+Figure 2: Two retrieval tasks performed by two fully-specialised models.
+
+Multi-task training has been successfully used to allow models to leverage cross-task data, as well as to provide a regularisation effect leading to better generalisation ability (Liu et al., 2019a). We apply this concept to neural retrievers, with the aim of improving performance by jointly leveraging multiple different retrieval datasets.
+
+![](images/623eb7950ef004cb9855c8a3421984cd9d064b466b281ef895f1503a37d4a238.jpg)  
+(a) Separate query encoders.  
+Figure 3: Parameter sharing between neural retrievers.
+
+![](images/eba6035b726d121e906989332cbda4da7e5b94070803d58fad586d8cd3a1e147.jpg)  
+(b) A single retrieval model.
+
+Our base setup is illustrated in Figure 3b and involves using a shared passage encoder — so that a single index of encoded passages can be used — as well as a query encoder that is shared across all tasks. In essence, in this setup a single DPR model is used to perform all retrieval tasks.
+
+Due to the complexity of training and evaluating retrieval models (which involves training the retriever, embedding all of Wikipedia, and building an index), our main set of experiments is all based on this configuration, which was found to work well in preliminary experiments. However, in order
+
+<table><tr><td>Task</td><td>Example query</td><td>Answer</td><td>Relevant doc.</td></tr><tr><td>Question Answering</td><td>Who is playing the Halftime Show at Super Bowl 2016?</td><td>Coldplay</td><td>The Super Bowl 50 Halftime Show took place on February 7, 2016 ... It was headlined by the British rock group Coldplay.</td></tr><tr><td>Fact Checking</td><td>Bermuda Triangle is in the western part of the Himalayas</td><td>REFUTES</td><td>The Bermuda Triangle ... is a loosely defined region in the western part of the North Atlantic Ocean</td></tr><tr><td>Slot Filling</td><td>Piner Creek [sep] mouth of the watercourse</td><td>Santa Rosa Creek</td><td>Piner Creek discharges to Santa Rosa Creek which in turn ...</td></tr><tr><td>Entity Linking</td><td>Leicestershire take over at top after innings victory. London. [start_ent]West Indian [end_ent] all-rounder Phil Simmons ...</td><td>West Indies cricket team</td><td>The West Indies cricket team is a multi-national men&#x27;s cricket team representing the Anglophone Caribbean region</td></tr><tr><td>Dialogue</td><td>I am a big fan of Star Trek [sep] I don&#x27;t know much about it. When did the first episode air? [sep] It debuted in .. [sep] What is the plot of the show?</td><td>William Shatner plays the role of Captain Kirk</td><td>It followed the interstellar adventures of Captain James T. Kirk (William Shatner) and his crew ...</td></tr></table>
+
+Table 1: Illustrative examples of some of the tasks within KILT, and how varied their query formulations can be.
+
+to report on the performance of alternative architectures, we also investigate the following additional variants in a restricted experimental setting, limited to a few tasks:
+
+- Task-specific query encoder. A different query encoder is used for each family of tasks, e.g. all question answering tasks use the same query encoder, but fact checking uses a different one. This is meant to allow for potentially different needs in processing queries, given the fundamentally diverse nature of the tasks at hand. This setup configuration is illustrated in Figure 3a.  
+- Task markers. This approach is similar to our base setup, where a single model performs all tasks. Additionally, we introduce specialised tokens which are inserted at the beginning of each query. Their aim is to help the model distinguish between the different tasks, by marking them. We use one task marker for each of the five task classes of KILT, such that all question answering tasks share the same marker.
+
+# 3.2 Adversarial confounder selection
+
+We saw in § 2.1 how "hard" confounder passages are collected using a BM25 baseline, following the standard approach in DPR. However, any other retriever can be used to select such confounders, including the very retriever being trained, leading to an iterative, self-adversarial training. Concretely, this amounts to following steps: (1) a first version
+
+of the retriever is trained with BM25 confounders; (2) new confounders are selected with the trained model, by retrieving high-ranking passages which are not among the set of relevant ones; (3) a second version of the model is trained using the additional new confounders.
+
+Intuitively, it is expected that this approach should lead to higher quality confounders compared to those selected by BM25 based on simple keyword matching. Based on our own experience as well as relevant literature (Khattab et al., 2020), this adversarial approach has been shown to work well for question answering.
+
+As a way of further pushing the performance of the model, we experiment with this adversarial confounder selection on two datasets, Natural Questions (Kwiatkowski et al., 2019) and TriviaQA (Joshi et al., 2017). We selected these two datasets since, out of all of the tasks we are considering, they have an easy way of checking whether a certain passage is relevant or not for a given query – namely, by checking whether the answer is present in the passage. This enabled us to automatically build sets of confounders, ensuring relevant passages would be excluded.
+
+<table><tr><td>Dataset</td><td>Task class</td><td>#Train</td></tr><tr><td>FEVER</td><td>Fact Checking</td><td>71 k</td></tr><tr><td>AIDA-YAGO 2</td><td>Entity Linking</td><td>18 k</td></tr><tr><td>T-REx</td><td>Slot Filling</td><td>2,284 k</td></tr><tr><td>Zero Shot RE</td><td>Slot Filling</td><td>132 k</td></tr><tr><td>Natural Questions</td><td>QA</td><td>77 k</td></tr><tr><td>HotpotQA</td><td>QA</td><td>69 k</td></tr><tr><td>TriviaQA</td><td>QA</td><td>53 k</td></tr><tr><td>Wizard of Wikipedia</td><td>Dialogue</td><td>80 k</td></tr></table>
+
+Table 2: KILT datasets used in this work, and the size of our converted training sets for each.
+
+# 4 Experiments
+
+# 4.1 Experimental settings
+
+Dataset selection For our experiments we select the eight KILT datasets listed in Table 2, which cover all five task classes and include a training split, a validation split, and a held-out test split.
+
+Preprocessing Starting from the raw KILT data, we split each Wikipedia article into disjoint 100-token chunks which form our basic retrieval units, following the approach of Wang et al. (2019) and Karpukhin et al. (2020). To maintain the same language introduced in §3, we will simply call these chunks passages.
+
+This preprocessing results in a knowledge source of 36 million passages. In order to harmonise all datasets to the same knowledge source, KILT used a mapping strategy based on the BLEU metric to map relevant passages in the original versions of its datasets to passages in its own shared knowledge source (Petroni et al., 2020). Entries included in the KILT training sets which have a mapping BLEU score below 0.5 are likely to be noise, and we exclude them from training.
+
+Multi-tasking Training is performed on the union of all training sets. Since two of the training sets are of different orders of magnitude, we use a simple downsampling strategy to bring them to the same order of magnitude as the others. Preliminary experiments with more complex sampling methods, like resampling all datasets so that each epoch would see an equal number of samples from each, found that they had no measurable effect compared to this simpler approach.
+
+Encoders Our query and passage encoders are initialised as two distinct BERT base uncased en
+
+coders (Devlin et al., 2019), trained separately. As pooling mechanism we find it effective to simply take the [CLS] token representation at the topmost layer.
+
+Training We train our models for up to 80 epochs. To select the best checkpoint, we perform full evaluations of the validation set retrieval performance at regular intervals. We use the Adam optimiser (Kingma and Ba, 2015) with a learning rate of  $2 \cdot 10^{-5}$  with warmup and a linear decay schedule, and a dropout rate of 0.1. The batch size is set to 128 samples, and in preliminary experiments we found no benefit in increasing this further. We use an additional "hard" confounder per batch, selected based on BM25 score as in (Karpukhin et al., 2020).
+
+Downstream evaluation When evaluating our retriever within a larger architecture to perform a knowledge-intensive task, we replicate the DPR + BART setup of Petroni et al. (2020). This uses DPR to retrieve and comprehend the top 3 passages to the query, which is then processed by a task-specific fine-tuned BART model to generate the final answer for the end task.
+
+# 4.2 Universal retrieval
+
+The results of the evaluations reported in (Petroni et al., 2020) show that retrievers trained for question answering have poor performance outside of their domain. We would like to understand if it is possible to design a single model which can accurately satisfy the information needs of a wide variety of knowledge-intensive tasks. In short: Can a neural retriever be universal?
+
+We perform a comprehensive evaluation of several models on the eight tasks of Table 2. The setups we evaluate include eight task-specific models (one trained on each of the eight datasets), for which we measure both in-domain and out-of-domain performance, and a BM25 baseline. Additionally, we include a multi-task trained model - as described in §3.1 - with the hope that it can learn to perform all tasks satisfyingly. This amounts to 10 models evaluated on eight tasks each, for a total of 80 evaluations.
+
+To measure retrieval performance, we adopt the main metric used for the KILT benchmark,  $R$ -precision. This is calculated as  $r / R$ , where  $R$  is the total number of relevant passages for a given query, and  $r$  is the number of relevant passages returned among the top-  $R$  retrieval results. For the
+
+<table><tr><td rowspan="2">model</td><td rowspan="2">Fact Check. FEV</td><td rowspan="2">Ent. L. AY2</td><td colspan="2">Slot Filling</td><td colspan="3">Open Domain QA</td><td rowspan="2">Dial. WoW</td></tr><tr><td>T-REx</td><td>zsRE</td><td>NQ</td><td>HoPo</td><td>TQA</td></tr><tr><td>Multi-task</td><td>74.72/46.96</td><td>83.78</td><td>69.18/53.54</td><td>77.23/41.70</td><td>61.51/28.80</td><td>44.21/38.42</td><td>61.95/24.56</td><td>39.70/24.07</td></tr><tr><td>BM25</td><td>50.13/40.06</td><td>3.47</td><td>58.60/51.64</td><td>66.43/52.98</td><td>25.83/14.20</td><td>43.95/38.38</td><td>29.44/16.16</td><td>27.50/18.41</td></tr><tr><td colspan="9">Task-specific models</td></tr><tr><td>FEVER</td><td>73.60/43.92</td><td>5.62</td><td>19.50/10.02</td><td>42.88/19.98</td><td>36.69/18.05</td><td>23.18/17.59</td><td>45.08/22.24</td><td>41.27/19.85</td></tr><tr><td>AY2</td><td>47.36/37.58</td><td>81.77</td><td>5.52/4.08</td><td>8.94/5.50</td><td>10.22/6.77</td><td>11.69/10.71</td><td>15.11/8.47</td><td>17.59/13.08</td></tr><tr><td>T-REx</td><td>45.63/25.22</td><td>1.05</td><td>69.08/58.54</td><td>71.64/40.95</td><td>17.10/8.71</td><td>22.31/15.63</td><td>18.10/8.06</td><td>4.02/1.83</td></tr><tr><td>zsRE</td><td>70.10/33.12</td><td>0.42</td><td>68.34/57.40</td><td>97.74/78.81</td><td>25.98/13.81</td><td>22.23/18.35</td><td>28.68/14.44</td><td>10.40/2.09</td></tr><tr><td>NQ</td><td>68.16/14.81</td><td>1.44</td><td>31.78/7.20</td><td>61.12/12.92</td><td>63.24/28.13</td><td>29.39/11.33</td><td>48.39/14.42</td><td>30.77/11.81</td></tr><tr><td>HoPo</td><td>56.18/40.03</td><td>2.07</td><td>35.76/27.62</td><td>44.44/31.15</td><td>35.60/23.26</td><td>46.63/43.47</td><td>41.18/29.37</td><td>23.51/16.02</td></tr><tr><td>TQA</td><td>70.06/10.68</td><td>4.95</td><td>32.22/12.52</td><td>60.37/17.43</td><td>45.01/12.97</td><td>32.62/13.05</td><td>65.12/23.79</td><td>41.17/8.11</td></tr><tr><td>WoW</td><td>59.16/42.79</td><td>3.11</td><td>20.92/18.52</td><td>41.14/35.26</td><td>33.27/22.52</td><td>20.36/17.66</td><td>39.37/23.15</td><td>40.32/20.73</td></tr></table>
+
+Table 3: Page- and passage-level  $R$  -precision on KILT validation data. For the AIDA-YAGO 2 dataset, due to the nature of the task, only page-level retrieval is defined.
+
+case of  $R = 1$  this is therefore equivalent to precision@1. Table 3 shows retrieval performance on the validation data, with the best performance on a given dataset marked in bold, and the second best performance underlined.
+
+While the KILT evaluation focuses on retrieval at the level of Wikipedia pages (thereby marking as "hits" any results that lie within the correct page), we are also interested in performing an evaluation at a more fine-grained level. We therefore also evaluate our models at the passage level, using a modified version of the official KILT evaluation scripts. These are shown as the second number in each column.
+
+We straight away notice that the task-specific models tend to achieve high performance on their respective tasks, often taking one of the top two spots. Interestingly, we also note that these neural retrievers consistently outperform the BM25 baseline, showing that the result which Karpukhin et al. (2020) achieved for open-domain question answering also holds for other knowledge-intensive tasks.
+
+The results reveal a strong performance for the multi-task model, confirming the hypothesis that a single model can be successfully trained to perform a wide variety of retrieval tasks. With the exception of one dataset, the shared model achieves the best retrieval performance or is within a few percentage points of the top score. We note that the one exception is the Zero-shot RE task (Levy et al., 2017), a trivial task in which the query will always contain the title of the page to be retrieved. Indeed, the model specific to this task manages to achieve a near-perfect score.
+
+Another task which stands out for being
+
+markedly different in formulation is AIDA-YAGO 2 (Hoffart et al., 2011). As shown in Table 2, models that were not trained on this specific task perform it very poorly. Entity linking is a task that is normally better performed by models which are explicitly designed for it (Cao et al., 2020). We nevertheless include it to showcase the ability of neural retrievers to adapt to it, and note how well the multi-task retriever performs on it in spite of its unusual nature.
+
+# 4.3 Downstream performance
+
+We saw that our proposed approach achieves strong performance across a variety of retrieval tasks. However, our interest in neural retrievers stems from their use as components within larger systems, to perform tasks such as question answering. Our next experimental question is therefore: Can a universal retriever lead to better downstream performance in knowledge-intensive tasks?
+
+We perform a downstream evaluation of our approach used in conjunction with BART (Lewis et al., 2020a) as the generative component or classifier, adopting the same setup as Petroni et al. (2020). Results are reported in Table 4, with bold and underline marking the best and second best scores respectively.
+
+The  $DPR + BART$  line refers to a setup similar to our own, but with the simpler retriever of Karpukhin et al. (2020). Therefore, comparing its performance to ours gives us a clear indication of the contribution of multi-task training on the overall performance on knowledge-intensive tasks. Our proposed model achieves significantly better performance than this baseline in AY2, zsRE and HoPo; while for the other tasks, the discrepancy
+
+<table><tr><td rowspan="2">Model</td><td rowspan="2">Fact Check. FEV</td><td rowspan="2">Ent. L. AY2</td><td rowspan="2">Slot Fill. zsRE</td><td colspan="3">Open Domain QA</td><td rowspan="2">Dial. WoW</td><td rowspan="2">Avg.</td></tr><tr><td>NQ</td><td>HoPo</td><td>TQA</td></tr><tr><td>Multi-task + BART</td><td>86.32</td><td>82.61</td><td>57.95</td><td>39.75</td><td>31.77</td><td>59.60</td><td>15.33</td><td>53.33</td></tr><tr><td>DPR + BART</td><td>86.74</td><td>75.49</td><td>30.43</td><td>41.27</td><td>25.18</td><td>58.55</td><td>15.55</td><td>47.60</td></tr><tr><td>RAG</td><td>86.31</td><td>72.62</td><td>44.74</td><td>44.39</td><td>26.97</td><td>71.27</td><td>13.22</td><td>51.36</td></tr><tr><td>T5</td><td>76.30</td><td>74.05</td><td>9.02</td><td>19.60</td><td>12.64</td><td>18.11</td><td>13.49</td><td>31.89</td></tr></table>
+
+Table 4: KILT test scores on the downstream evaluation. Results in the bottom section are as reported in Petroni et al. (2020). The score metrics are accuracy for fact checking, entirely linking and slot filling; exact match for QA; and F1 score for dialogue. $^3$
+
+is always below two points. This fact is reflected in the last column too, showing that on average multi-task training leads to better downstream performance. The model also compares favourably to RAG (Lewis et al., 2020b), a more advanced system in which the query encoder is fine-tuned on the end task.
+
+# 4.4 Zero- and few-shot performance
+
+Task-specific neural retrievers can achieve higher performance than IR-based methods, but they are not suitable for cases where no training data (or not enough) is available. In those cases, tfidf and BM25 are the better choice. To evaluate the performance of a multi-task retriever as a suitable replacement for them in this scenario, we run a series of experiments in the low data regimes (few-shot and zero-shot).
+
+We start by training a set of multi-task retrievers (using the base setup) in the leave-one-out setting for each of the datasets, in order to see how a neural retriever will perform when trained on all domains except for the one it is to be evaluated on. The results of these zero-shot experiments are reported in the second line of Table 5 (again, text here is in bold for the best overall performance, and underlined for second best). They show that, even in the zero-shot setting, the multi-task neural retriever achieves performance that is competitive to BM25, with retrieval being 10 points higher at the page level and 5 points lower at the passage level on average.
+
+The advantage of neural retrievers over BM25 lies in their ability to improve with training. We therefore look at few-shot training for each task, and create two smaller copies for each of the orig
+
+inal training sets with a random sample of 128 and 1,024 examples respectively. In order to evaluate the suitability of a multi-task trained retriever as a starting checkpoint for few-shot training, we take the various leave-one-out models and finetune them on our few-shot training sets. To check whether multi-task pre-training is effective, we also compare these to DPR models (which are just initialised with BERT weights) fine-tuned on the same data.
+
+The bottom two sections of Table 5 report the results. The most dramatic gains from fine-tuning are seen for AY2, an "outlier" task whose formulation differs from that of the other tasks, and which seems to benefit the most from seeing in-domain data. The zsRE performance does not seem to improve from fine-tuning on the smaller dataset, but sees a very big jump when switching to the larger dataset. As a reminder, in this trivial task the title of the page to be retrieved always appears at the start of the query. It is therefore not surprising that models specifically fine-tuned on it can achieve near-perfect scores, as long as enough training data is provided.
+
+In spite of the fine-tuning, we note that both DPR and the multi-task model fail to improve on their performance for T-REx, suggesting that large amounts of training data are required to learn this task. Nevertheless, the multi-task model proves itself more robust, and achieves the top performance on it.
+
+Finally, we note for 2 out of 8 tasks, namely zsRE and WoW, DPR achieves lower page-level retrieval scores than the multi-task model, but performs better at the passage level. This shows that fine-grained and coarse-grained retrieval performance are not always perfectly correlated.
+
+Overall, the experiments show strong results for the multi-task model, with the average zero-shot
+
+<table><tr><td>Model</td><td>FEV</td><td>AY2</td><td>T-REx</td><td>zsRE</td><td>NQ</td><td>HoPo</td><td>TQA</td><td>WoW</td><td>Avg.</td></tr><tr><td>BM25</td><td>50.13/40.06</td><td>3.47</td><td>58.60/51.64</td><td>66.43/52.98</td><td>25.83/14.20</td><td>43.95/38.38</td><td>29.44/16.16</td><td>27.50/18.41</td><td>38.17/33.12</td></tr><tr><td colspan="10">Leave-one-out multi-task models</td></tr><tr><td>Zero-shot</td><td>74.11/37.09</td><td>4.16</td><td>67.54/44.84</td><td>73.42/32.65</td><td>47.23/21.50</td><td>34.72/16.52</td><td>49.08/28.06</td><td>36.92/16.19</td><td>48.40/28.12</td></tr><tr><td>Finetune (128)</td><td>75.95/32.75</td><td>32.38</td><td>67.54/44.84</td><td>73.41/32.65</td><td>47.48/14.98</td><td>34.72/27.82</td><td>54.71/19.82</td><td>48.36/17.46</td><td>54.23/27.19</td></tr><tr><td>Finetune (1k)</td><td>73.08/40.83</td><td>70.40</td><td>67.54/44.84</td><td>93.04/58.67</td><td>51.00/19.90</td><td>39.19/35.43</td><td>59.08/20.22</td><td>47.65/19.75</td><td>62.62/34.23</td></tr><tr><td colspan="10">Vanilla DPR models</td></tr><tr><td>Finetune (128)</td><td>37.99/25.31</td><td>26.23</td><td>0.20/0.02</td><td>0.16/0.00</td><td>20.92/9.52</td><td>14.46/14.08</td><td>26.85/10.54</td><td>30.31/17.20</td><td>19.64/10.95</td></tr><tr><td>Finetune (1k)</td><td>70.87/47.82</td><td>72.49</td><td>0.20/0.02</td><td>90.33/80.20</td><td>43.43/19.81</td><td>30.75/30.50</td><td>52.50/17.33</td><td>44.70/24.92</td><td>50.66/31.51</td></tr></table>
+
+performance being competitive to BM25, and the average few-shot performance being markedly better than the alternatives. The discrepancy in performance between a vanilla DPR model and the leave-one-out multi-task model is especially noticeable when using the smaller of the two datasets, in which case average performance for the latter is more than double that of vanilla DPR.
+
+# 4.5 Model variants
+
+Table 5: Page- and passage-level  $R$  -Precision in the zero-shot setting and with additional fine-tuning of 128 and 1,024 examples. We also compare to a BM25 retriever and a DPR model initialised with BERT weights.  
+
+<table><tr><td>variant</td><td>FEV</td><td>NQ</td><td>TQA</td></tr><tr><td>Base</td><td>76.38/40.76</td><td>60.91/24.50</td><td>64.77/21.75</td></tr><tr><td>Task markers</td><td>75.84/40.79</td><td>62.31/25.10</td><td>64.04/20.86</td></tr><tr><td>Task-spec. enc.</td><td>73.53/40.02</td><td>61.05/25.52</td><td>64.17/21.23</td></tr></table>
+
+Table 6: Multi-task model variants evaluated on a subset of tasks ( $R$ -precision on validation data at page/passage level).
+
+In this set of experiments we compare our base multi-task model with the two variants described in § 3.1. Due to the high memory consumption of the "task-specific encoders" variant (requiring one full query encoder per task family, in addition to the passage encoder), it was only possible to perform these evaluations in a restricted setting of three datasets. The results in Table 6 do not reveal a clear winner, suggesting that the base architecture might be the better choice due to its simplicity and generally good performance. $^4$
+
+# 4.6 Adversarial confounder selection
+
+Finally, we evaluate the adversarial confounder selection method described in § 3.2. This involves augmenting our regular training sets with additional confounders for TriviaQA and Natural Ques
+
+tions, selected using our top multi-task trained model. A new multi-task model is then trained from scratch on this augmented data. Its performance is reported in Table 7, showing an overall improvement across multiple tasks. While this approach is demonstrated here on our multi-task model, it is in fact orthogonal to it, and could be applied to any other neural retrievers trained with a contrastive loss.
+
+# 5 Related work
+
+The approach most closely related to ours is DPR (Karpukhin et al., 2020), upon which we built all our retrieval systems. This model is covered in detail in § 2.1, in addition to the historical context. Another closely related approach is the Retrieval-Augmented Generation (RAG) model of Lewis et al. (2020b). In its base configuration it augments DPR with a generative reader, and it trains the query encoder end-to-end (differing from traditional retriever-reader architectures which treat the two steps as disjoint). A natural extension of the work we have presented would be to combine RAG with our joint learning approach, to study whether it can lead to further gains in performance or robustness.
+
+A number of promising techniques to boost retrieval performance have been proposed recently. These are orthogonal to our work, and as such they could be combined with it. Amongst these, pretraining methods form one class. Inverse Cloze Task (Lee et al., 2019) and its extensions (Chang et al., 2020) are self-supervised pre-training methods designed for retrieval in open-domain question answering. Whether such specific pre-training is beneficial to tasks other than question answering remains an open question. CERT (Fang et al., 2020) is an alternative pre-training approach, inspired by some recent advances in computer vision. While to
+
+<table><tr><td rowspan="2">confounders</td><td rowspan="2">Fact Check. FEV</td><td rowspan="2">Ent. L. AY2</td><td rowspan="2">Slot Filling T-REx</td><td rowspan="2">zsRE</td><td colspan="3">Open Domain QA</td><td rowspan="2">Dial. WoW</td></tr><tr><td>NQ</td><td>HoPo</td><td>TQA</td></tr><tr><td>BM25</td><td>74.72/46.96</td><td>83.78</td><td>69.18/53.54</td><td>77.23/41.70</td><td>61.51/28.80</td><td>44.21/38.42</td><td>61.95/24.56</td><td>39.70/24.07</td></tr><tr><td>BM25 + adv</td><td>74.79/52.12</td><td>84.86</td><td>71.36/61.40</td><td>80.04/54.08</td><td>59.25/40.11</td><td>44.08/41.04</td><td>59.19/34.17</td><td>41.04/24.62</td></tr></table>
+
+Table 7: Comparison of two confounder selection methods for the multi-task model: simple BM25, and BM25 augmented with adversarial confounders ( $R$ -precision on validation data at page/passage level).
+
+our knowledge this has not been applied to retrieval problems, we believe it might be promising due to its focus on sentence-level semantics (as opposed to the more standard masked language modelling pre-training, which focuses on the token-level).
+
+Another class of orthogonal improvements to dense retrieval involves models which embed passages into multiple fixed-size vectors. Of these, ColBERT (Khattab and Zaharia, 2020) and MEBERT (Luan et al., 2020) are two representative examples. One further approach is ColBERT-QA (Khattab et al., 2020), which additionally uses a data augmentation strategy closely related to our own approach described in § 3.2.
+
+Finally two entity linkers, GENRE (Cao et al., 2020) and BLINK (Wu et al., 2020), are worth mentioning. Being trained specifically for entity linking, these models will generally outperform retrieval-based approaches on that task. While they are not comparable to retrieval models and will not generally be applicable to information retrieval tasks, we mention them here to provide readers with a fuller context of the existing literature.
+
+# 6 Conclusions
+
+We have conducted a large-scale experimental study on knowledge-intensive tasks, and how retrieval models that tackle them seek the required information from knowledge bases such as Wikipedia.
+
+The study started with the question of whether the way in which information is embedded for retrieval purposes is universal. Section 4.2 provided evidence that to a large extent it is, with a single "universal" retriever, trained jointly on 8 datasets, often performing comparably to task-specific models.
+
+Armed with this knowledge, in Section 4.3 we plugged our single model in a larger pipeline, in order to see its contribution to the downstream performance on a wide range of knowledge-intensive tasks. This led to an overall improvement in downstream performance, setting new top results for a
+
+number of tasks in the KILT benchmark.
+
+Next, in Section 4.4, we evaluated the model's performance in the zero-shot and few-shot settings. By evaluating on a wide range of tasks, we were able to show that our proposed approach performs comparably to BM25 in the zero-shot setting, and quickly overtakes it even with minimal in-domain training.
+
+In Section 4.5 we evaluated a number of more complex variants of the model involving task specialisation, but failed to see clear performance improvements. Finally, in Section 4.6 we saw how a simple iterative approach to data augmentation can lead to better performance.
+
+In the coming months we will provide a pretrained snapshot of our best-performing model, in the form of a BERT checkpoint. As shown, this model will be useful in zero-shot and few-shot settings as a better performing alternative to both IR-based approaches such as BM25, as well as task-specific models. The multi-task training approach demonstrated here can also be useful in industry settings where several retrieval operations may need to be performed on the same piece of content, and the deployment of multiple task-specific models might not be possible due to space or computational performance concerns.
+
+# References
+
+Nicola De Cao, Gautier Izacard, Sebastian Riedel, and Fabio Petroni. 2020. Autoregressive entity retrieval. ArXiv, abs/2010.00904.  
+Wei-Cheng Chang, Felix X. Yu, Yin-Wen Chang, Yiming Yang, and Sanjiv Kumar. 2020. Pre-training tasks for embedding-based large-scale retrieval. In International Conference on Learning Representations.  
+Danqi Chen, Adam Fisch, Jason Weston, and Antoine Bordes. 2017. Reading Wikipedia to answer open-domain questions. In Proceedings of the 55th Annual Meeting of the Association for Computational
+
+Linguistics (Volume 1: Long Papers), pages 1870-1879, Vancouver, Canada. Association for Computational Linguistics.  
+Scott Deerwester, Susan T Dumais, George W Furnas, Thomas K Landauer, and Richard Harshman. 1990. Indexing by latent semantic analysis. Journal of the American society for information science, 41(6):391-407.  
+Jacob Devlin, Ming-Wei Chang, Kenton Lee, and Kristina Toutanova. 2019. BERT: Pre-training of deep bidirectional transformers for language understanding. In Proceedings of the 2019 Conference of the North American Chapter of the Association for Computational Linguistics: Human Language Technologies, Volume 1 (Long and Short Papers), pages 4171-4186, Minneapolis, Minnesota. Association for Computational Linguistics.  
+Hongchao Fang, Sicheng Wang, Meng Zhou, Jiayuan Ding, and Pengtao Xie. 2020. CERT: Contrastive self-supervised learning for language understanding. ArXiv, abs/2005.12766.  
+Jianfeng Gao, Kristina Toutanova, and Wen-tau Yih. 2011. Clickthrough-based latent semantic models for web search. In Proceedings of the 34th international ACM SIGIR conference on Research and development in Information Retrieval, pages 675-684. ACM.  
+Ruiqi Guo, Sanjiv Kumar, Krzysztof Choromanski, and David Simcha. 2016. Quantization based fast inner product search. In Artificial Intelligence and Statistics, pages 482-490.  
+Johannes Hoffart, Mohamed Amir Yosef, Ilaria Bordino, Hagen Fürstenau, Manfred Pinkal, Marc Spanirol, Bilyana Taneva, Stefan Thater, and Gerhard Weikum. 2011. Robust disambiguation of named entities in text. In Proceedings of the 2011 Conference on Empirical Methods in Natural Language Processing, pages 782-792, Edinburgh, Scotland, UK. Association for Computational Linguistics.  
+Po-Sen Huang, Xiaodong He, Jianfeng Gao, Li Deng, Alex Acero, and Larry Heck. 2013. Learning deep structured semantic models for web search using clickthrough data. In Proceedings of the 22nd ACM International Conference on Information and Knowledge Management, page 2333-2338, New York, NY, USA. Association for Computing Machinery.  
+J. Johnson, M. Douze, and H. Jégou. 2019. Billion-scale similarity search with GPUs. IEEE Transactions on Big Data, pages 1-1.  
+Mandar Joshi, Eunsol Choi, Daniel Weld, and Luke Zettlemoyer. 2017. TriviaQA: A large scale distantly supervised challenge dataset for reading comprehension. In Proceedings of the 55th Annual Meeting of the Association for Computational Linguistics
+
+(Volume 1: Long Papers), pages 1601-1611, Vancouver, Canada. Association for Computational Linguistics.  
+Vladimir Karpukhin, Barlas Oğuz, Sewon Min, Patrick Lewis, Ledell Wu, Sergey Edunov, Danqi Chen, and Wen-tau Yih. 2020. Dense passage retrieval for open-domain question answering. In Proceedings of the 2020 Conference on Empirical Methods in Natural Language Processing (EMNLP). Association for Computational Linguistics.  
+Omar Khattab, Christopher Potts, and Matei Zaharia. 2020. Relevance-guided supervision for OpenQA with ColBERT. ArXiv, abs/2007.00814.  
+Omar Khattab and Matei Zaharia. 2020. ColBERT: Efficient and effective passage search via contextualized late interaction over BERT. In Proceedings of the 43rd international ACM SIGIR conference on Research and development in Information Retrieval.  
+Diederick P Kingma and Jimmy Ba. 2015. Adam: A method for stochastic optimization. In International Conference on Learning Representations (ICLR).  
+Tom Kwiatkowski, Jennimaria Palomaki, Olivia Redfield, Michael Collins, Ankur Parikh, Chris Alberti, Danielle Epstein, Illia Polosukhin, Matthew Kelcey, Jacob Devlin, Kenton Lee, Kristina N. Toutanova, Llion Jones, Ming-Wei Chang, Andrew Dai, Jakob Uszkoreit, Quoc Le, and Slav Petrov. 2019. Natural questions: a benchmark for question answering research. Transactions of the Association of Computational Linguistics.  
+Kenton Lee, Ming-Wei Chang, and Kristina Toutanova. 2019. Latent retrieval for weakly supervised open domain question answering. In Proceedings of the 57th Annual Meeting of the Association for Computational Linguistics, pages 6086-6096, Florence, Italy. Association for Computational Linguistics.  
+Omer Levy, Minjoon Seo, Eunsol Choi, and Luke Zettlemoyer. 2017. Zero-shot relation extraction via reading comprehension. In Proceedings of the 21st Conference on Computational Natural Language Learning (CoNLL 2017), pages 333-342, Vancouver, Canada. Association for Computational Linguistics.  
+Mike Lewis, Yinhan Liu, Naman Goyal, Marjan Ghazvininejad, Abdelrahman Mohamed, Omer Levy, Veselin Stoyanov, and Luke Zettlemoyer. 2020a. BART: Denoising sequence-to-sequence pretraining for natural language generation, translation, and comprehension. In Proceedings of the 58th Annual Meeting of the Association for Computational Linguistics, pages 7871-7880, Online. Association for Computational Linguistics.  
+Patrick Lewis, Ethan Perez, Aleksandara Piktus, Fabio Petroni, Vladimir Karpukhin, Naman Goyal, Heinrich Kuttler, Mike Lewis, Wen-tau Yih, Tim Roektaschel, Sebastian Riedel, and Douwe
+
+Kiela. 2020b. Retrieval-augmented generation for knowledge-intensive NLP tasks. In Advances in Neural Information Processing Systems (NeurIPS).  
+Xiaodong Liu, Pengcheng He, Weizhu Chen, and Jianfeng Gao. 2019a. Multi-task deep neural networks for natural language understanding. In Proceedings of the 57th Annual Meeting of the Association for Computational Linguistics, pages 4487-4496, Florence, Italy. Association for Computational Linguistics.  
+Yinhan Liu, Myle Ott, Naman Goyal, Jingfei Du, Mandar Joshi, Danqi Chen, Omer Levy, Mike Lewis, Luke Zettlemoyer, and Veselin Stoyanov. 2019b. Roberta: A robustly optimized bert pretraining approach. ArXiv, abs/1907.11692.  
+Yi Luan, Jacob Eisenstein, Kristina Toutanova, and Michael Collins. 2020. Sparse, dense, and attentional representations for text retrieval. *ArXiv*, abs/2005.00181.  
+Christopher D Manning, Hinrich Schütze, and Prabhakar Raghavan. 2008. Introduction to information retrieval. Cambridge university press.  
+Fabio Petroni, Aleksandra Piktus, Angela Fan, Patrick Lewis, Majid Yazdani, Nicola De Cao, James Thorne, Yacine Jernite, Vassilis Plachouras, Tim Roktaschel, and Sebastian Riedel. 2020. KILT: a benchmark for knowledge intensive language tasks. In arXiv:2009.02252.  
+Fabio Petroni, Tim Rocttäschel, Patrick Lewis, Anton Bakhtin, Yuxiang Wu, Alexander H Miller, and Sebastian Riedel. 2019. Language models as knowledge bases? EMNLP.  
+Stephen Robertson and Hugo Zaragoza. 2009. The probabilistic relevance framework: BM25 and beyond. Foundations and Trends in Information Retrieval, 3(4):333-389.  
+Anshumali Shrivastava and Ping Li. 2014. Asymmetric LSH (ALSH) for sublinear time maximum inner product search (MIPS). In Advances in Neural Information Processing Systems (NIPS), pages 2321-2329.  
+James Thorne, Andreas Vlachos, Christos Christodoulopoulos, and Arpit Mittal. 2018. FEVER: a large-scale dataset for fact extraction and VERIFICATION. In Proceedings of the 2018 Conference of the North American Chapter of the Association for Computational Linguistics: Human Language Technologies, Volume 1 (Long Papers), pages 809-819, New Orleans, Louisiana. Association for Computational Linguistics.  
+Shuohang Wang, Mo Yu, Xiaoxiao Guo, Z. Wang, Tim Klinger, Wei Zhang, S. Chang, G. Tesauro, Bowen Zhou, and Jing Jiang. 2018. R3: Reinforced ranker-reader for open-domain question answering. In AAAI.
+
+Zhiguo Wang, Patrick Ng, Xiaofei Ma, Ramesh Nallapati, and Bing Xiang. 2019. Multi-passage BERT: A globally normalized BERT model for open-domain question answering. In Proceedings of the 2019 Conference on Empirical Methods in Natural Language Processing and the 9th International Joint Conference on Natural Language Processing (EMNLP-IJCNLP), pages 5878-5882, Hong Kong, China. Association for Computational Linguistics.  
+Ledell Wu, Fabio Petroni, Martin Josifoski, Sebastian Riedel, and Luke Zettlemoyer. 2020. Scalable zero-shot entity linking with dense entity retrieval. In Proceedings of the 2020 Conference on Empirical Methods in Natural Language Processing (EMNLP), pages 6397-6407, Online. Association for Computational Linguistics.  
+Lee Xiong, Chenyan Xiong, Ye Li, Kwok-Fung Tang, Jialin Liu, Paul Bennett, Junaid Ahmed, and Arnold Overwijk. 2020. Approximate nearest neighbor negative contrastive learning for dense text retrieval. ArXiv, abs/2007.00808.  
+Wen-tau Yih, Kristina Toutanova, John C Platt, and Christopher Meek. 2011. Learning discriminative projections for text similarity measures. In Proceedings of the Fifteenth Conference on Computational Natural Language Learning, pages 247-256. Association for Computational Linguistics.

data/2021/2101_00xxx/2101.00121/10de5b4b-1a6e-40ba-bf75-79fb29a7975d_content_list.json

@@ -1,3 +1,1679 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:2d251ff1962b0b0df5f1902cc41e59e68238405ba54eebf2b6780520532be37c
-size 82258
+[
+    {
+        "type": "text",
+        "text": "WARP: Word-level Adversarial ReProgramming",
+        "text_level": 1,
+        "bbox": [
+            245,
+            80,
+            754,
+            99
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Karen Hambardzumyan<sup>1</sup>, Hrant Khachatrian<sup>1,2</sup>, Jonathan May<sup>3</sup>",
+        "bbox": [
+            213,
+            133,
+            794,
+            151
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "$^{1}$ YerevaNN,  $^{2}$ Yerevan State University,",
+        "bbox": [
+            344,
+            151,
+            660,
+            167
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "<sup>3</sup>Information Sciences Institute, University of Southern California",
+        "bbox": [
+            233,
+            167,
+            769,
+            183
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "mahnerak@yerevann.com, hrant@yerevann.com, jonmay@isi.edu",
+        "bbox": [
+            149,
+            185,
+            840,
+            200
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Abstract",
+        "text_level": 1,
+        "bbox": [
+            262,
+            263,
+            342,
+            279
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Transfer learning from pretrained language models recently became the dominant approach for solving many NLP tasks. A common approach to transfer learning for multiple tasks that maximize parameter sharing trains one or more task-specific layers on top of the language model. In this paper, we present an alternative approach based on adversarial reprogramming, which extends earlier work on automatic prompt generation. Adversarial reprogramming attempts to learn task-specific word embeddings that, when concatenated to the input text, instruct the language model to solve the specified task. Using up to 25K trainable parameters per task, this approach outperforms all existing methods with up to 25M trainable parameters on the public leaderboard of the GLUE benchmark. Our method, initialized with task-specific human-readable prompts, also works in a few-shot setting, outperforming GPT-3 on two SuperGLUE tasks with just 32 training samples.",
+        "bbox": [
+            142,
+            294,
+            460,
+            608
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 Introduction",
+        "text_level": 1,
+        "bbox": [
+            115,
+            624,
+            260,
+            639
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Language model pretraining has had a tremendous impact on solving many natural language processing tasks (Peters et al., 2018; Radford et al., 2018; Devlin et al., 2019; Liu et al., 2019). The most popular two approaches take a pretrained model and use a straightforward supervised learning objective. In the first approach, the parameters of the language model are frozen and a task-specific head is trained on top of them (Peters et al., 2018). The second approach fine-tunes all model parameters (Radford et al., 2018). The latter can sometimes yield better results (Peters et al., 2019), while the first one usually offers better stability for smaller datasets. The approach based on frozen features does not require storing task-specific language models.",
+        "bbox": [
+            114,
+            652,
+            489,
+            910
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "A recent alternative is based on so called adapters (Houlsby et al., 2019; Pfeiffer et al., 2021), a technique that adds new weights at every layer of the pretrained language model while the original parameters are kept frozen. This enables a smaller set of task-specific parameters while achieving results comparable to the fine-tuning approach.",
+        "bbox": [
+            509,
+            263,
+            884,
+            391
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Another approach of leveraging pretrained language models for downstream tasks, introduced by Radford et al. (2019), provides \"task descriptions\" without using any labeled examples. GPT-3 (Brown et al., 2020) demonstrates impressive few-shot learning performance with priming: by providing the language model a few inputs and outputs (\"analogies\") as a context. The language model contextually \"learns\" from these examples and outputs the answer with a single forward pass without any trainable parameters. These methods, however, require huge language models (1.5B and 175B parameters, respectively).",
+        "bbox": [
+            509,
+            393,
+            884,
+            601
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "The success of task reformulation-based approaches suggest that language models are capable of solving various natural language processing tasks given a well-crafted prompt. We hypothesize that it is possible to find such prompts. In other words, we can discover extra tokens that, when added to the input, can exploit language model capabilities better than the manually-designed ones.",
+        "bbox": [
+            509,
+            602,
+            882,
+            731
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "In this paper, we introduce a novel technique to find optimal prompts. We call our method WARP: Word-level Adversarial ReProgramming<sup>1</sup>. The method is inspired by adversarial reprogramming (Elsayed et al., 2019) — a method of adding adversarial perturbations to an input image that reprograms a pretrained neural network to perform classification on a task other than the one it was originally trained for.",
+        "bbox": [
+            509,
+            732,
+            882,
+            876
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "page_footnote",
+        "text": "1Our implementation is publicly available at: https://github.com/YerevaNN/WARP",
+        "bbox": [
+            510,
+            883,
+            880,
+            908
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "aside_text",
+        "text": "arXiv:2101.00121v2 [cs.CL] 2 Jun 2021",
+        "bbox": [
+            21,
+            319,
+            60,
+            717
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "image",
+        "img_path": "images/bf66c6df047a9c7ed30c88e96ed74d3210ac6981e0c447d1635d011b02e78431.jpg",
+        "image_caption": [
+            "Figure 1: An example of an adversarial program that causes Inception V3 ImageNet model to function as an MNIST classifier, from Elsayed et al. (2019)"
+        ],
+        "image_footnote": [],
+        "bbox": [
+            189,
+            72,
+            416,
+            231
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "We show that our method, using up to 25K trainable parameters per task, achieves 81.6 test score on the GLUE Leaderboard, outperforming all the other submissions that use up to three orders of magnitude more trainable parameters. We show that it is possible to inject knowledge into WARP models using manually designed initialization of the prompt, which is especially useful on tasks with a small number of examples. Moreover, WARP shows impressive few-shot performance on two tasks from the SuperGLUE benchmark with just 32 examples, outperforming GPT-3 results. Finally, we discuss the advantages of our method in real-life applications.",
+        "bbox": [
+            114,
+            318,
+            489,
+            544
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2 Related Work",
+        "text_level": 1,
+        "bbox": [
+            115,
+            568,
+            272,
+            583
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2.1 Towards Fewer Trainable Parameters",
+        "text_level": 1,
+        "bbox": [
+            115,
+            604,
+            458,
+            619
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Jiao et al. (2020) show that knowledge distillation may help reduce the size of their model 7.5 times while almost preserving the performance, but finetuning such models still requires storage of separate task-specific models. As seen in Section 6, this approach does not scale when we want to apply it to many tasks at once.",
+        "bbox": [
+            114,
+            632,
+            489,
+            743
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Another approach, called Adapters (Houlsby et al., 2019; Pfeiffer et al., 2021), introduces new task-specific parameters that are added at every layer of the Transformer network. Only these newly initialized weights are trained, which allows separation of general and task-specific knowledge. In contrast, our method does not inject task-specific knowledge inside the body of the pretrained language model. Instead, it focuses on learning task-specific input-level prompts.",
+        "bbox": [
+            114,
+            749,
+            489,
+            910
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "image",
+        "img_path": "images/59ba3c48bea62432583f5692e2aeec03ff6d3e356e04f655e6a4eea8d6fa0e18.jpg",
+        "image_caption": [
+            "Figure 2: WARP adds a few trainable embeddings around the input, which causes the masked language model to predict the sentiment of the sentence."
+        ],
+        "image_footnote": [],
+        "bbox": [
+            512,
+            71,
+            884,
+            231
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2.2 Task Reformulation",
+        "text_level": 1,
+        "bbox": [
+            510,
+            310,
+            714,
+            324
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "In GPT-2, Radford et al. (2019) introduce a completely unsupervised way for transferring knowledge to downstream tasks by reformulating various natural language understanding tasks into language modeling problems. This approach does not make use of the available training examples. Brown et al. (2020) demonstrate an effective few-shot transfer by reformulating downstream tasks into input-output analogies in the context without a need for further fine-tuning. Nonetheless, the number of training examples is limited to the context size and is not scalable to a traditional supervised learning scenario.",
+        "bbox": [
+            507,
+            331,
+            884,
+            539
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Schick and Schütze (2021b) show the effectiveness of reformulating a number of tasks into Cloze-style tasks by fine-tuning masked language models (Devlin et al., 2019). The method, called Pattern Exploited Training (PET), additionally uses training samples and performs few-shot learning even without huge models such as GPT-3.",
+        "bbox": [
+            509,
+            539,
+            882,
+            651
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Our method is also based on masked language models, but unlike PET, we focus on finding the best prompt using the training examples. This eliminates the need for manually-designed prompts, however, our method can also benefit from similar prior knowledge about the task by careful initialization of the prompts.",
+        "bbox": [
+            509,
+            653,
+            882,
+            765
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2.3 Adversarial Reprogramming",
+        "text_level": 1,
+        "bbox": [
+            510,
+            776,
+            786,
+            791
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Adversarial Reprogramming (Elsayed et al., 2019) demonstrates the reprogramming of pretrained ImageNet classifiers by adding input-level adversarial perturbations to make them perform well on MNIST and CIFAR-10 image classification tasks. The adversarial perturbation is designed to be image padding added to the original input, as illus",
+        "bbox": [
+            509,
+            797,
+            882,
+            910
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "image",
+        "img_path": "images/44d6b26302cfdab70e7425e45ec40185e6c9dcfad10695e177396540e518eb96.jpg",
+        "image_caption": [
+            "Figure 3: Illustration of WARP. The prompt tokens [P_1], [P_2], ..., [P_N] are inserted before, between, and after the sentences. Only the prompt and class embeddings are trainable (colored in green). The masked language modeling Head is applied without the decoder; instead, the matrix of [V_1], [V_2], ..., [V_N] is applied as a linear layer. Finally, a regular task-specific loss is computed on the resulting logits."
+        ],
+        "image_footnote": [],
+        "bbox": [
+            163,
+            71,
+            838,
+            331
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "trated in Figure 1. Then the perturbation parameter is trained to optimize the target classification task objective using the annotated image data.",
+        "bbox": [
+            114,
+            424,
+            489,
+            470
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "While in the case of image classification it is not obvious why adversarial reprogramming should ever work, e.g. why a network trained on ImageNet should have the capacity to solve MNIST when surrounded with a particular bitmap, for NLP tasks, there is more intuition. Many NLP tasks can be reformulated as language models, a shared space for both program and data.",
+        "bbox": [
+            114,
+            473,
+            489,
+            601
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Adversarial reprogramming has been adapted to text classification tasks with LSTM networks in (Neekhara et al., 2019). They operate in the vocabulary space and reprogram a model trained for one task to perform another task. More recently, AutoPrompt (Shin et al., 2020a) attempts to find prompts for large language models automatically without adding any parameters to the model. Unlike AutoPrompt, we perform gradient-based optimization in the space of word embeddings which gives our model more degrees of freedom and eventually better performance on the downstream tasks (Section 6.2).",
+        "bbox": [
+            114,
+            602,
+            489,
+            810
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "In a more general sense, guiding an NLP model with special tokens appended to the input is an even older idea. In particular, multilingual neural machine translation models use special tokens in the input to control the target language (Ha et al., 2016; Johnson et al., 2017) or politeness",
+        "bbox": [
+            114,
+            813,
+            489,
+            910
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "of the translation (Sennrich et al., 2016). Another method to reprogram a BERT-based model is proposed by Artetxe et al. (2020), where a model tuned on an English version of a particular task is transformed to work in another language by changing only the embedding matrices.",
+        "bbox": [
+            509,
+            424,
+            884,
+            520
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "In parallel work, Li and Liang (2021) propose a similar method and successfully apply it on two text generation tasks. Apart from the different types of tasks and our characterization of the task as a form of Adversarial Reprogramming, the main difference between their approach and ours is that they use an additional parameterization trick to stabilize the training.",
+        "bbox": [
+            509,
+            521,
+            885,
+            651
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3 WARP",
+        "text_level": 1,
+        "bbox": [
+            510,
+            670,
+            606,
+            686
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "We follow a setup similar to Elsayed et al. (2019) with some NLP-specific modifications depicted in Figure 2.",
+        "bbox": [
+            509,
+            702,
+            884,
+            749
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Our goal is to find the best prompt that will make a pretrained masked language model predict the desired answer (verbalizer token) for a training example's masked token $^2$ . We search for such prompts in the (continuous) embedding space. In other words, we want to find parameters  $\\Theta = \\{\\Theta^P,\\Theta^V\\}$  for prompt and verbalizer embed",
+        "bbox": [
+            509,
+            752,
+            885,
+            866
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "page_footnote",
+        "text": "2This approach can be easily extended to autoregressive language modeling.",
+        "bbox": [
+            510,
+            883,
+            885,
+            910
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "dings, respectively, such that:",
+        "bbox": [
+            115,
+            74,
+            337,
+            90
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "text": "\n$$\n\\Theta^ {*} = \\arg \\max  _ {\\Theta} (- \\log P _ {\\Theta} (y | x))\n$$\n",
+        "text_format": "latex",
+        "bbox": [
+            181,
+            102,
+            421,
+            124
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "and the probabilities are given by:",
+        "bbox": [
+            115,
+            135,
+            371,
+            151
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "text": "\n$$\nP _ {\\Theta} (y | x) = \\frac {\\exp \\Theta_ {y} ^ {V} f \\left(T _ {\\Theta^ {P}} (x)\\right)}{\\sum_ {i \\in C} \\exp \\Theta_ {i} ^ {V} f \\left(T _ {\\Theta^ {P}} (x)\\right)}\n$$\n",
+        "text_format": "latex",
+        "bbox": [
+            168,
+            159,
+            435,
+            206
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "where  $T_{\\Theta^P}(x)$  is the template that inserts the prompt embeddings  $\\Theta^P$  into predefined positions,  $C$  is the set of classes, and  $f(x)$  is the masked language model output (without the last decoder layer, which is simply the transposed word embedding matrix). Both  $\\Theta^P$  and  $\\Theta^V$  are vectors in the same embeddings space as the word embeddings.",
+        "bbox": [
+            114,
+            218,
+            487,
+            330
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "In Figure 2, the template  $T_{\\Theta^P}(x)$  prepends  $\\Theta_1^P$  and appends  $\\Theta_2^P, \\Theta_3^P, \\Theta_4^P$  parameters to the word embeddings and uses  $\\Theta_+^V$  and  $\\Theta_-^V$  to calculate the probabilities on the masked token position for positive and negative classes.",
+        "bbox": [
+            114,
+            331,
+            489,
+            411
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3.1 Method",
+        "text_level": 1,
+        "bbox": [
+            115,
+            422,
+            225,
+            435
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Similar to Elsayed et al. (2019), we employ stochastic gradient descent to find the best adversarial perturbation on the text that will minimize the task objective. First, we insert special prompt tokens [P_1], [P_2], ... [P_K] and an additional [MASK] token into the input sequence. These tokens might be placed before or after the sentences, depending on the prompt template.",
+        "bbox": [
+            114,
+            442,
+            489,
+            571
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "We set the optimization objective to a cross-entropy loss between the head output of the masked language model and the verbalizer tokens [V_1], [V_2], ..., [V_C] for classes 1...C accordingly.",
+        "bbox": [
+            115,
+            571,
+            489,
+            651
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "The only trainable parameters are the word embeddings for [P_1], ..., [P_K] and [V_1], ..., [V_C]. In case we want to train models for multiple tasks, these are the only task-specific parameters we need to store. The entire \"body\" of the large language model (all attention layers, feedforward layers, and all other word embeddings) remains untouched.",
+        "bbox": [
+            115,
+            652,
+            489,
+            778
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Note that, unlike most adversarial attacks, we do not update the embeddings of the original tokens of the input. This follows the intuition from Elsayed et al. (2019), when the pixels of MNIST or CIFAR images are left untouched, and only padding pixels are updated.",
+        "bbox": [
+            114,
+            780,
+            489,
+            876
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "We train these parameters by minimizing the loss on the training set of the downstream task.",
+        "bbox": [
+            115,
+            877,
+            489,
+            909
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3.2 Implementation Details",
+        "text_level": 1,
+        "bbox": [
+            510,
+            74,
+            742,
+            90
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "WARP is implemented in the AllenNLP framework. For all the GLUE benchmark tasks we use the roberta-large (Liu et al., 2019) model from the PyTorch implementation of huggingface transformers (Wolf et al., 2020) library. For the few-shot experiments, we use albert-xxlarge-v2 in order to directly compare to iPET (Schick and Schütze, 2021b). For the GLUE and SuperGLUE tasks we use dataset loaders and metrics implementations from the huggingface datasets library.",
+        "bbox": [
+            509,
+            96,
+            885,
+            272
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "The prompt tokens are initialized either with word embeddings of [MASK] or similar to the vectors from the word embedding layer. For the answer prompts, we use the masked language model head, which usually consists of a feedforward network and a decoder on top of it, where the weights of the decoder are shared with the word embeddings used for the input. We calculate the softmax over the verbalizer tokens [V_1], ... [V_C].",
+        "bbox": [
+            509,
+            273,
+            885,
+            434
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "We choose the Adam optimizer with a slanted triangular schedule for the learning rate with  $6\\%$  warm-up steps and train for 10-20 epochs on each task. Each batch consists of examples containing at most 1024 tokens and 8 examples.",
+        "bbox": [
+            509,
+            435,
+            882,
+            514
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "In order to speed up the training, we disable the dropout of the pretrained language model. All the experiments are performed on two Titan Vs and two RTX 3080 GPUs, with mixed precision training. In practice, WARP is 2.5-3 times faster than regular fine-tuning and 2 times slower than frozen-features experiments in terms of epoch duration with the same batch sizes.",
+        "bbox": [
+            509,
+            514,
+            885,
+            643
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Details about the hyperparameters can be found in the Supplementary material.",
+        "bbox": [
+            509,
+            644,
+            882,
+            676
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "4 Experiments on GLUE",
+        "text_level": 1,
+        "bbox": [
+            510,
+            689,
+            744,
+            706
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Following prior work, we evaluate our method on the GLUE Benchmark (Wang et al., 2019b), which consists of 9 natural language understanding tasks. Generally, we perform single-task WARP training, with early stopping and model selection using the original validation sets, if not stated otherwise.",
+        "bbox": [
+            509,
+            715,
+            882,
+            810
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "4.1 Tasks",
+        "text_level": 1,
+        "bbox": [
+            510,
+            822,
+            603,
+            837
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Almost all the tasks from the GLUE Benchmark are either sentence classification or sentence pair classification tasks, so WARP requires very few modifications to adapt to each of the tasks.",
+        "bbox": [
+            509,
+            845,
+            882,
+            909
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "table",
+        "img_path": "images/695e02cb81240a9dba7d40bb95d2772afa576e7f8cb11052dad917868f04d448.jpg",
+        "table_caption": [],
+        "table_footnote": [
+            "Table 1: Test set results on GLUE Benchmark. The results are obtained from the GLUE Evaluation server. The subscript next to TinyBERT corresponds to the number of layers in the model. WARP for RTE, STS-B and MRPC are initialized from the MNLI parameters. Results for WNLI are not shown, although they are counted in the averaged GLUE score (AVG column). The last column # shows the number of trainable parameters. WARP's average performance is higher than all models with up to three orders of magnitude more trainable parameters. Fully fine-tuned RoBERTa and the current state-of-the-art method (DeBERT) score higher by 6.5 and 9.2 points, respectively."
+        ],
+        "table_body": "<table><tr><td></td><td>MNLI</td><td>QNLI</td><td>QQP</td><td>RTE</td><td>SST</td><td>MRPC</td><td>CoLA</td><td>STS-B</td><td>AVG</td><td>#</td></tr><tr><td>Human Baselines</td><td>92.0 / 92.8</td><td>91.2</td><td>59.5 / 80.4</td><td>93.6</td><td>97.8</td><td>86.3 / 80.8</td><td>66.4</td><td>92.7 / 92.6</td><td>87.1</td><td></td></tr><tr><td>DeBERT3</td><td>91.9 / 91.6</td><td>99.2</td><td>76.2 / 90.8</td><td>93.2</td><td>97.5</td><td>94.0 / 92.0</td><td>71.5</td><td>92.9 / 92.6</td><td>90.8</td><td>3·109</td></tr><tr><td>RoBERTa</td><td>90.8 / 90.2</td><td>95.4</td><td>74.3 / 90.2</td><td>88.2</td><td>96.7</td><td>92.3 / 89.8</td><td>67.8</td><td>92.2 / 91.9</td><td>88.1</td><td>355·106</td></tr><tr><td>BERTlarge</td><td>86.7 / 85.9</td><td>92.7</td><td>72.1 / 89.3</td><td>70.1</td><td>94.9</td><td>89.3 / 85.4</td><td>60.5</td><td>87.6 / 86.5</td><td>80.5</td><td>355·106</td></tr><tr><td>BERTbase</td><td>84.6 / 83.4</td><td>90.5</td><td>71.2 / 89.2</td><td>66.4</td><td>93.5</td><td>88.9 / 84.8</td><td>52.1</td><td>87.1 / 85.8</td><td>78.3</td><td>110·106</td></tr><tr><td>TinyBERT6</td><td>84.6 / 83.2</td><td>90.4</td><td>71.6 / 89.1</td><td>70.0</td><td>93.1</td><td>87.3 / 82.6</td><td>51.1</td><td>85.0 / 83.7</td><td>78.1</td><td>67·106</td></tr><tr><td>TinyBERT4</td><td>82.5 / 81.8</td><td>87.7</td><td>71.3 / 89.2</td><td>66.6</td><td>92.6</td><td>86.4 / 81.2</td><td>44.1</td><td>81.9 / 80.4</td><td>75.9</td><td>15·106</td></tr><tr><td>ELECTRAsmall</td><td>81.6 / 81.2</td><td>88.3</td><td>70.4 / 88.0</td><td>63.6</td><td>91.1</td><td>89.0 / 84.9</td><td>55.6</td><td>85.6 / 84.6</td><td>77.4</td><td>14·106</td></tr><tr><td>Adapters (BERT)</td><td>85.4 / 85.0</td><td>92.4</td><td>71.5 / 89.4</td><td>71.6</td><td>94.3</td><td>88.7 / 84.3</td><td>59.2</td><td>87.3 / 86.1</td><td>80.2</td><td>1.2·106</td></tr><tr><td>WARP (RoBERTa)</td><td>88.0 / 88.2</td><td>93.5</td><td>68.6 / 87.7</td><td>84.3</td><td>96.3</td><td>88.2 / 83.9</td><td>53.9</td><td>89.5 / 88.8</td><td>81.6</td><td>&lt;25K</td></tr></table>",
+        "bbox": [
+            115,
+            71,
+            885,
+            236
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "SST-2 (Sentence Sentiment Treebank, Socher et al., 2013) is a single sentence binary classification task. For the prompt, we put a [MASK] token after the sentence, and the trainable prompt tokens are both appended and prepended to the sentence.",
+        "bbox": [
+            114,
+            370,
+            487,
+            450
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "CoLA (Corpus of Linguistic Acceptability, Warstadt et al., 2019) is a single sentence classification task as well, so we treat both the same way with the only difference that as a validation metric we use accuracy for SST-2, and Matthew's correlation for CoLA.",
+        "bbox": [
+            114,
+            451,
+            489,
+            546
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "MNLI (MultiNLI, Multi-Genre Natural Language Inference, Williams et al., 2018), QNLI (Question Natural Language Inference, Rajpurkar et al., 2016) and RTE (Recognizing Textual Entailment, Dagan et al., 2006; Bar Haim et al., 2006; Giampiccolo et al., 2007; Bentivogli et al., 2009) are sentence pair classification tasks. Similar to Schick and Schütze (2021a), we may have prompt tokens before, after and between the two sentences, but the [MASK] token is always put between the sentences. For MNLI, we use matched accuracy as a validation metric and use the same model for the mismatched version. In our few-shot attempt for the RTE task, we use a different training and evaluation setup discussed in Section 5.2. QQP (Quora Question Pairs $^4$ ) and MRPC (Microsoft Research Paraphrase Corpus, Dolan and Brockett, 2005) follow the same prompt pattern as NLI tasks. As a validation metric  $F_1$  score is used,",
+        "bbox": [
+            114,
+            548,
+            489,
+            852
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "STS-B (Semantic Textual Similarity Bench",
+        "bbox": [
+            132,
+            854,
+            487,
+            872
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "mark, Cer et al., 2017), unlike the other tasks in the benchmark, is formulated as a regression task. The prompt pattern is the same, but instead of introducing new embeddings for  $[V\\_ 1]$ ,  $[V\\_ 2]$ , ...,  $[V\\_ C]$  verbalizer tokens, we add a regression head to the last hidden state of MLM head and use Mean Squares Error optimization objective, similar to (Liu et al., 2019). Pearson Correlation is used as the validation metric. During inference, we clip the scores within [1, 5].",
+        "bbox": [
+            509,
+            370,
+            884,
+            530
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "We follow Liu et al. and train models for MRPC, STS-B, and RTE tasks initialized with the parameters from the best MNLI model but do not apply any task-specific tricks to WNLI (Winograd Schema Challenge NLI, Levesque et al., 2011) and always predict the majority label.",
+        "bbox": [
+            509,
+            532,
+            885,
+            629
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "4.2 Results",
+        "text_level": 1,
+        "bbox": [
+            510,
+            644,
+            616,
+            657
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Table 1 presents the results on the test set obtained from the GLUE evaluation server. Besides our best WARP models, we also include the human baselines, current state-of-the-art model (He et al., 2020), the regular fine-tuned pretrained model we use, and also include relatively small language models, including (Jiao et al., 2020), (Clark et al., 2020), (Houlsby et al., 2019).",
+        "bbox": [
+            509,
+            667,
+            884,
+            794
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "With the GLUE Score, WARP outperforms all the models that train less than 25 million parameters on the leaderboard. We explain the relatively strong WARP results on textual entailment tasks by the easier reformulation of such tasks. Likewise, we explain the relatively weak performance on CoLA by the difficulties of reformulating the",
+        "bbox": [
+            509,
+            797,
+            885,
+            910
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "page_footnote",
+        "text": "4https://www.quora.com/q/quoradata/First-QuoraDataset-Release-Question-Pairs",
+        "bbox": [
+            115,
+            882,
+            445,
+            909
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "table",
+        "img_path": "images/da0365f5b939deefe423b55f356ae63a439c47415b162fadcbcc0c6cee111b40.jpg",
+        "table_caption": [],
+        "table_footnote": [
+            "Table 2: Dev set results on GLUE tasks. The last column shows the number of trainable parameters only.  $\\mathsf{WARP}_i$  corresponds to WARP training with prompt consisting of  $i$  prompt tokens.  $\\mathsf{WARP}_{\\mathsf{MNLI}}$  corresponds to WARP training initialized with the best MNLI parameters. All the models are based on pretrained roberta-large, and for Adapters and WARP-based approaches require to store  $355 \\cdot 10^{6}$  frozen parameters shared across all the GLUE tasks. We show the primary validation metric for each task, described at Subsection 4.1. The AVG column shows the average of shown metrics and is not comparable to the Test server GLUE Score. The number of parameters for WARP methods may vary because of a difference in the number of classes. Underlined numbers correspond to our GLUE submission."
+        ],
+        "table_body": "<table><tr><td>train size</td><td>MNLI 392702</td><td>QNLI 104743</td><td>QQP 363846</td><td>RTE 2490</td><td>SST 67349</td><td>MRPC 3668</td><td>CoLA 8551</td><td>STS-B 5749</td><td>AVG</td><td>#</td></tr><tr><td>Fine-Tuning</td><td>90.2</td><td>94.7</td><td>92.2</td><td>86.6</td><td>96.4</td><td>90.9</td><td>68.0</td><td>92.4</td><td>88.9</td><td>\\( {355} \\cdot {10}^{6} \\)</td></tr><tr><td>Adapters</td><td>90.4</td><td>94.7</td><td>88.5</td><td>83.4</td><td>96.3</td><td>92.9</td><td>67.4</td><td>92.5</td><td>88.3</td><td>\\( 3 \\cdot {10}^{6} \\)</td></tr><tr><td>Linear Classifier</td><td>64.2</td><td>78.1</td><td>74.9</td><td>59.2</td><td>88.4</td><td>82.5</td><td>48.9</td><td>71.8</td><td>71.0</td><td>≤ 3072</td></tr><tr><td>\\( {\\mathrm{{WARP}}}_{0} \\)</td><td>70.9</td><td>78.8</td><td>77.1</td><td>72.2</td><td>89.8</td><td>83.8</td><td>32.8</td><td>73.8</td><td>72.4</td><td>≤ 3072</td></tr><tr><td>\\( {\\mathrm{{WARP}}}_{1} \\)</td><td>83.9</td><td>87.6</td><td>81.6</td><td>72.6</td><td>93.8</td><td>84.7</td><td>46.1</td><td>80.4</td><td>78.8</td><td>≤ 4096</td></tr><tr><td>\\( {\\mathrm{{WARP}}}_{2} \\)</td><td>85.4</td><td>88.0</td><td>81.5</td><td>69.7</td><td>94.3</td><td>85.3</td><td>54.4</td><td>80.8</td><td>79.9</td><td>≤ 5120</td></tr><tr><td>\\( {\\mathrm{{WARP}}}_{4} \\)</td><td>86.9</td><td>92.4</td><td>83.1</td><td>68.2</td><td>95.9</td><td>85.0</td><td>56.0</td><td>75.5</td><td>80.4</td><td>≤ 7168</td></tr><tr><td>\\( {\\mathrm{{WARP}}}_{8} \\)</td><td>87.6</td><td>93.0</td><td>83.8</td><td>72.9</td><td>95.4</td><td>85.6</td><td>57.4</td><td>81.0</td><td>82.1</td><td>&lt; 11K</td></tr><tr><td>\\( {\\mathrm{{WARP}}}_{\\text{init }} \\)</td><td>86.8</td><td>90.4</td><td>83.6</td><td>80.1</td><td>96.0</td><td>86.0</td><td>51.7</td><td>86.9</td><td>82.7</td><td>&lt; 11K</td></tr><tr><td>\\( {\\mathrm{{WARP}}}_{20} \\)</td><td>\\( \\underline{88.2} \\)</td><td>\\( \\underline{93.5} \\)</td><td>\\( \\underline{84.5} \\)</td><td>75.8</td><td>\\( \\underline{96.0} \\)</td><td>90.8</td><td>\\( \\underline{60.6} \\)</td><td>88.6</td><td>84.8</td><td>&lt; 25K</td></tr><tr><td>\\( {\\mathrm{{WARP}}}_{\\mathrm{{MNLI}}} \\)</td><td></td><td></td><td></td><td>\\( \\underline{86.3} \\)</td><td></td><td>\\( \\underline{91.2} \\)</td><td></td><td>\\( \\underline{91.0} \\)</td><td>86.4</td><td>&lt; 25K</td></tr></table>",
+        "bbox": [
+            117,
+            71,
+            884,
+            263
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "task into a Cloze task.",
+        "bbox": [
+            114,
+            413,
+            282,
+            426
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "To further analyze WARP, we conduct several experiments and focus on dev set results. In order to directly compare WARP with existing methods, we report in Table 2 different methods that use RoBERTa, including fine-tuning, linear classifiers on top, AutoPrompt, and Adapters. For WARP experiments, we compare performance with different numbers of prompt tokens.",
+        "bbox": [
+            114,
+            430,
+            487,
+            558
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "The  $\\mathrm{WARP_0}$  model does not introduce any prompt parameters. The only difference between  $\\mathrm{WARP_0}$  and Linear Classifier is that for  $\\mathrm{WARP_0}$ , [MASK] is added to the input of each sample, and we get sentence representations from the MLM head at the masked position. By contrast, in the case of the Linear Classifier, we use the average of non-special token embeddings as sentence representations. As we can see, pooling with MLM is significantly better.",
+        "bbox": [
+            114,
+            560,
+            489,
+            720
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Table 2 shows that, as we decrease the number of trainable prompt parameters, the performance decreases, but the model still works. Similar behavior was observed by Elsayed et al. (2019) in experiments with different padding parameter sizes. However, in contrast to WARP, the number of trainable parameters in that work are much greater than the size of the input.",
+        "bbox": [
+            114,
+            722,
+            489,
+            851
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "An important benefit of using WARP is that",
+        "bbox": [
+            134,
+            852,
+            489,
+            869
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "it can be initialized with manual prompts. In addition to the regular models where we initialize with [MASK] tokens, we performed a run on the GLUE datasets with the same prompt [CLS] \"S1\"? [MASK]. \"S2\"! [SEP] for all the tasks (without S2 for single-sentence tasks). We denote these results as WARPinit in Table 2. WARPinit outperforms WARP8 on tasks with relatively few training examples — RTE, MRPC and STSB, which indicates its potential in the low-data regime.",
+        "bbox": [
+            509,
+            412,
+            884,
+            594
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "5 Few-Shot Experiments",
+        "text_level": 1,
+        "bbox": [
+            510,
+            607,
+            742,
+            625
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "The fact that WARP can be initialized using manually designed natural prompts suggests that we can similarly benefit from such human attribution similar to iPET (Schick and Schütze, 2021b), especially in scenarios with limited training data.",
+        "bbox": [
+            509,
+            634,
+            882,
+            715
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "5.1 Setup",
+        "text_level": 1,
+        "bbox": [
+            510,
+            727,
+            603,
+            741
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "For our few-shot experiments we build WARP on top of ALBERT (Lan et al., 2020), the same pretrained model used by PET and iPET. To initialize WARP prompts, we use the same Prompt-Verbalizer Patterns (PVP) from Schick and Schütze (2021b): the embeddings for [P_1], [P_2]... [P_N] are initialized with PVP's prompt token embeddings, and embeddings for [V_1], [V_2]... [V_C] are initialized with verbalizer token embeddings for their corre",
+        "bbox": [
+            509,
+            747,
+            884,
+            910
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "page_footnote",
+        "text": "5Unlike in Table 2,Adapters in Table 1 are built on bert-large-uncased model.",
+        "bbox": [
+            114,
+            882,
+            489,
+            909
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "sponding classes. Unlike roberta-large, the alberta-xxlarge-v2 uses word embeddings of size 128 (8 times smaller than RoBERTa).",
+        "bbox": [
+            115,
+            74,
+            489,
+            122
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "5.2 Tasks",
+        "text_level": 1,
+        "bbox": [
+            115,
+            139,
+            206,
+            153
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "In order to compare with GPT-3, PET, and iPET, we use two tasks from FewGLUE (Schick and Schütze, 2021b), which is a few-shot subset of the SuperGLUE benchmark (Wang et al., 2019a) consisting of 32 examples for each task. The dataset also provides 20000 additional unlabeled examples, however, we do not make use of them and work in a purely supervised setup.",
+        "bbox": [
+            114,
+            162,
+            489,
+            291
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "CB: CommitmentBank (de Marneffe et al., 2019) is a textual entailment task which we treat like the other sentence pair classification tasks. To initialize the prompt we use the template [CLS] \"h\"? [MASK]. \"p\" [SEP]. We also initialize [V-1], [V-2], [V-3] token embeddings with _yes, _no and _maybe (respectively for entailment, contradiction and neutral).",
+        "bbox": [
+            114,
+            294,
+            489,
+            443
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "RTE: Unlike experiments on the RTE task for the full-sized training in the GLUE benchmark, we do not initialize the model with vectors from MNLI. Instead, the prompt is initialized exactly the same way as in the CB task. The only difference is that we have only the two tokens [V_1] and [V_2] initialized with _yes and _instead (for entailment and not_ entailment, respectively).",
+        "bbox": [
+            114,
+            445,
+            489,
+            589
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "5.3 Model Selection",
+        "text_level": 1,
+        "bbox": [
+            115,
+            606,
+            287,
+            621
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Although all trainable parameters are manually initialized in this setup, different random seeds can yield different results because of the order the training examples appear during an epoch.",
+        "bbox": [
+            114,
+            631,
+            487,
+            695
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "In the few-shot setup we cannot access the original validation set. Thus, we disable early stopping and simply pick the last checkpoint.",
+        "bbox": [
+            114,
+            697,
+            487,
+            745
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "In order to find the best initial learning rate, we conduct 20 runs of WARP with the same learning rate each time by randomly choosing 16 training examples and taking the rest for a development set. We repeat this for all candidate learning rates and choose the one with the best average validation performance across all the random seeds.",
+        "bbox": [
+            114,
+            747,
+            487,
+            859
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Finally, in order to eliminate the effect of different random seeds, we build an ensemble model from 20 WARP runs using simple majority vote.",
+        "bbox": [
+            114,
+            860,
+            487,
+            910
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "table",
+        "img_path": "images/f93f634ede20138b3d197860da84b1da9ba45c1f474b223b4b8b540f02b43405.jpg",
+        "table_caption": [],
+        "table_footnote": [],
+        "table_body": "<table><tr><td></td><td>Model</td><td>CB\nF1 / Acc.</td><td>RTE\nAcc.</td></tr><tr><td rowspan=\"6\">dev</td><td>GPT-3 Small</td><td>26.1 / 42.9</td><td>52.3</td></tr><tr><td>GPT-3 Med</td><td>40.4 / 58.9</td><td>48.4</td></tr><tr><td>GPT-3</td><td>57.2 / 82.1</td><td>72.9</td></tr><tr><td>PET (ALBERT)</td><td>59.4 / 85.1</td><td>69.8</td></tr><tr><td>iPET (ALBERT)</td><td>92.4 / 92.9</td><td>74.0</td></tr><tr><td>WARPinit (ALBERT)</td><td>84.0 / 87.5</td><td>71.8</td></tr><tr><td rowspan=\"4\">test</td><td>GPT-3</td><td>52.0 / 75.6</td><td>69.0</td></tr><tr><td>PET (ALBERT)</td><td>60.2 / 87.2</td><td>67.2</td></tr><tr><td>iPET (ALBERT)</td><td>79.9 / 88.8</td><td>70.8</td></tr><tr><td>WARPinit (ALBERT)</td><td>70.2 / 82.4</td><td>69.1</td></tr></table>",
+        "bbox": [
+            512,
+            72,
+            884,
+            271
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Table 3: Results on SuperGLUE benchmark. The results for the test set are obtained from SuperGLUE evaluation server. We only show systems performing in a similar few-shot training setup using 32 examples.",
+        "bbox": [
+            509,
+            279,
+            884,
+            337
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "5.4 Results",
+        "text_level": 1,
+        "bbox": [
+            510,
+            362,
+            615,
+            376
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "As seen in Table 3, WARP outperforms PET and GPT-3 baselines, but stays behind iPET on both tasks. GPT-3 has 170B parameters, but none of them is being trained for the given tasks. PET and iPET have 255M parameters, and all of them are trained for these tasks. Additionally, they leverage unlabeled examples using distillation. WARP has roughly the same 255M parameters, but only 1024 of them are trained for any single model. An ensemble of 20 WARP models has slightly more than 20K trainable parameters.",
+        "bbox": [
+            509,
+            382,
+            884,
+            561
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "6 Discussion",
+        "text_level": 1,
+        "bbox": [
+            510,
+            573,
+            636,
+            587
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "6.1 Interpreting tokens learned by WARP",
+        "text_level": 1,
+        "bbox": [
+            509,
+            599,
+            855,
+            614
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "WARP learns prompt embeddings in a continuous space. In this section, we explore those embeddings by looking at the nearby token vectors. Table 6 in the Supplementary material lists the closest tokens (in terms of cosine similarity) to the learned embeddings. All GLUE tasks are initialized with [MASK] token, except for RTE, MRPC, and STS-B, which are initialized from the pretrained MNLI model. The prompt tokens of the solutions for those three tasks are quite close to the ones from the MNLI solution. We have seen similar behavior on SuperGLUE experiments with manual initializations. The solution for CoLA (which is one of the worst-performing tasks) is close to the initialized point.",
+        "bbox": [
+            509,
+            619,
+            884,
+            860
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "We do not see any prompt tokens that are meaningful in the context of the tasks. As expected, the verbalized tokens are more interpretable. For",
+        "bbox": [
+            509,
+            860,
+            882,
+            910
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/1c15f1e61742af3895fa977d64e9716372756814a9a1b5d5cb49ae9f271faf4b.jpg",
+        "image_caption": [
+            "Figure 4: The effect of the training data size for SST-2 task (dev set). Horizontal axis is the number of training examples. Solid lines represent median over 10 runs, and the error bars show minimum and maximum performance. All methods use roberta-large model. The results for AutoPrompt and fine-tuning are taken from (Shin et al., 2020b)"
+        ],
+        "image_footnote": [],
+        "bbox": [
+            117,
+            70,
+            489,
+            273
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "example, the embedding for the \"contradiction\" class of MNLI is close to the token \"Unless\". The embeddings for \"negative\" and \"positive\" classes of SST-2 task are close to \"defective\" and \"important\", respectively. Other verbalized tokens are non-interpretable (e.g. \"470\" or word pieces with non-Latin characters).",
+        "bbox": [
+            114,
+            420,
+            489,
+            533
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "6.2 Comparison with AutoPrompt",
+        "text_level": 1,
+        "bbox": [
+            115,
+            548,
+            401,
+            563
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "AutoPrompt (Shin et al., 2020b) learns a prompt for the given task in the finite space of vocabulary tokens. Their best version uses 3 or 6 prompt tokens and reaches  $91.2\\%$  accuracy on the development set of SST-2. The search space of WARP is significantly larger, which allows WARP to get better performance with just a single prompt token  $(93.8\\%)$ .",
+        "bbox": [
+            114,
+            569,
+            489,
+            697
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "AutoPrompt does not achieve meaningful results on RTE or CB tasks. WARP succeeds on both without manual initialization. Moreover, with manual initialization, WARP gets good performance on both tasks even with just 32 examples (Table 3).",
+        "bbox": [
+            114,
+            699,
+            489,
+            795
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Figure 4 shows the dependence of the accuracy on SST-2 development set from the number of training samples. Both WARP and AutoPrompt use 10 prompt tokens. With a few hundred training samples or fewer, the difference between the two algorithms is not significant. WARP starts to perform better with more training samples.",
+        "bbox": [
+            114,
+            797,
+            489,
+            910
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "table",
+        "img_path": "images/0f6552d6fd8a632b3d31fc9c98c4089f2236df42ebfca8ea8593dc4911b5a54d.jpg",
+        "table_caption": [],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Approach</td><td># of parameters to store</td></tr><tr><td>Linear probing</td><td>M + ECN</td></tr><tr><td>Full fine-tuning</td><td>MN</td></tr><tr><td>Single layer</td><td>M + NE(E + C)</td></tr><tr><td>TinyBERT</td><td>M0N</td></tr><tr><td>Adapters</td><td>M + NEE&#x27;</td></tr><tr><td>WARP</td><td>M + NE(C + K)</td></tr></table>",
+        "bbox": [
+            512,
+            71,
+            857,
+            189
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Table 4: The number of parameters to be stored to serve  $N$  text classification tasks with at most  $C$  classes each, using a pretrained language model with  $M$  parameters.  $E$  is the dimension of embeddings (1024 in the case of RoBERTa). In TinyBERT,  $M_0$  can be up to 10 times less than  $M$ . In Adapters,  $E'$  is roughly equal to  $E$ , as the number of layers to which adapters are attached roughly compensates the smaller size of the bottleneck layer. In WARP,  $K$  is the number of prompts (usually fewer than 10).",
+        "bbox": [
+            509,
+            198,
+            884,
+            340
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Shin et al. (2020b) include results with a manually designed prompt which performs pretty well (shown as a dashed line). We also compare with the manually initialized version of WARP, which performs very well with just 100 examples.",
+        "bbox": [
+            509,
+            367,
+            882,
+            448
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "6.3 Real-world applications",
+        "text_level": 1,
+        "bbox": [
+            510,
+            460,
+            744,
+            475
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "The importance of NLP systems like WARP can be demonstrated by the following application. Suppose we want to build a system that needs to serve  $N >> 1$  classification tasks simultaneously. Let the number of classes for each task be bounded by  $C$ . The system can be based on a large pretrained language model with  $M$  parameters, using word embedding size  $E$ . How many parameters should the system store in the device memory to be able to serve all  $N$  tasks?",
+        "bbox": [
+            509,
+            481,
+            882,
+            640
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "If we take the approach with frozen features, we can reuse  $M$  parameters for all tasks and store additional ECN task-specific parameters. This is optimal in terms of storage but will not perform well. The other extreme is to fine-tune the whole model for each task and store at least MN parameters. Table 4 shows the trade-offs offered by the other solutions. Methods like TinyBERT decrease the number of parameters from  $MN$  by only  $M$ . WARP, on the other hand, needs to store only  $M + NE(C + K)$  parameters, where  $K$  is the number of trainable prompt tokens.",
+        "bbox": [
+            509,
+            643,
+            882,
+            835
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "page_footnote",
+        "text": "6 SENT. this movie was ____ as a prompt, and “terrible” and “fantastic” as verbalizer tokens",
+        "bbox": [
+            510,
+            847,
+            882,
+            876
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "page_footnote",
+        "text": "7 SENT, and finally, the movie overall was very ____! as a prompt, and \"good\" and \"bad\" as verbalizer tokens",
+        "bbox": [
+            510,
+            878,
+            875,
+            909
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "In practice, WARP additionally allows performing inference on inputs for different tasks in parallel, using samples of multiple tasks in the same batch. Every input sentence can be concatenated with task-specific pretrained prompts in advance. Then, the forward pass of the network is identical for all tasks. The final task-specific linear layers can be concatenated to form a single large linear layer with at most  $NC$  output neurons.",
+        "bbox": [
+            114,
+            74,
+            489,
+            219
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "This approach can be especially useful in the systems that provide machine learning models as a service. By storing one copy of a pretrained language model, it is possible to serve a large number of user-specific models in parallel with little overhead.",
+        "bbox": [
+            114,
+            222,
+            489,
+            317
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "7 Conclusion",
+        "text_level": 1,
+        "bbox": [
+            115,
+            338,
+            247,
+            355
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "In this paper we have proposed an alternative way to transfer knowledge from large pretrained language models to downstream tasks by appending carefully optimized embeddings to the input text. The method outperforms existing methods with significantly more trainable parameters on GLUE benchmark tasks and shows an impressive performance in a few-shot setting on two SuperGLUE tasks. On the sentiment analysis task, the performance is comparable to the fully fine-tuned language models. This method can save a lot of storage in software applications designed to serve large numbers of sentence classification tasks.",
+        "bbox": [
+            114,
+            370,
+            489,
+            580
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Acknowledgments",
+        "text_level": 1,
+        "bbox": [
+            115,
+            601,
+            278,
+            618
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "This work is based in part on research sponsored by Air Force Research Laboratory (AFRL) under agreement number FA8750-19-1-1000. The U.S. Government is authorized to reproduce and distribute reprints for Government purposes notwithstanding any copyright notation therein. The views and conclusions contained herein are those of the authors and should not be interpreted as necessarily representing the official policies or endorsements, either expressed or implied, of Air Force Laboratory, DARPA or the U.S. Government.",
+        "bbox": [
+            114,
+            633,
+            489,
+            825
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "The work was supported by the RA Science Committee, in the frames of the research project No. 20TTAT-AIa024. Most experiments were performed on GPUs donated by NVIDIA.",
+        "bbox": [
+            114,
+            829,
+            489,
+            892
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "References",
+        "text_level": 1,
+        "bbox": [
+            512,
+            74,
+            610,
+            89
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "list",
+        "sub_type": "ref_text",
+        "list_items": [
+            "Mikel Artetxe, Sebastian Ruder, and Dani Yogatama. 2020. On the cross-lingual transferability of monolingual representations. In Proceedings of the 58th Annual Meeting of the Association for Computational Linguistics, pages 4623–4637, Online. Association for Computational Linguistics.",
+            "Roy Bar Haim, Ido Dagan, Bill Dolan, Lisa Ferro, Danilo Giampiccolo, Bernardo Magnini, and Idan Szpektor. 2006. The second PASCAL recognising textual entailment challenge.",
+            "Luisa Bentivogli, Ido Dagan, Hoa Trang Dang, Danilo Giampiccolo, and Bernardo Magnini. 2009. The fifth PASCAL recognizing textual entailment challenge.",
+            "T. Brown, B. Mann, Nick Ryder, Melanie Subbiah, J. Kaplan, Prafulla Dhariwal, Arvind Neelakantan, Pranav Shyam, Girish Sastry, Amanda Askell, Sandhini Agarwal, Ariel Herbert-Voss, G. Krüger, T. Henighan, R. Child, Aditya Ramesh, D. Ziegler, Jeffrey Wu, Clemens Winter, Christopher Hesse, Mark Chen, E. Sigler, Mateusz Litwin, Scott Gray, Benjamin Chess, J. Clark, Christopher Berner, Sam McCandlish, A. Radford, Ilya Sutskever, and Dario Amodei. 2020. Language models are few-shot learners. *ArXiv*, abs/2005.14165.",
+            "Daniel Cer, Mona Diab, Eneko Agirre, Inigo Lopez-Gazpio, and Lucia Specia. 2017. SemEval-2017 task 1: Semantic textual similarity multilingual and crosslingual focused evaluation. In Proceedings of the 11th International Workshop on Semantic Evaluation (SemEval-2017), pages 1-14, Vancouver, Canada. Association for Computational Linguistics.",
+            "Kevin Clark, Minh-Thang Luong, Quoc Le, and Christopher D. Manning. 2020. Pre-training transformers as energy-based cloze models. In Proceedings of the 2020 Conference on Empirical Methods in Natural Language Processing (EMNLP), pages 285-294, Online. Association for Computational Linguistics.",
+            "Ido Dagan, Oren Glickman, and Bernardo Magnini. 2006. The PASCAL recognising textual entailment challenge. In Machine learning challenges. evaluating predictive uncertainty, visual object classification, and recognising textual entailment, pages 177-190. Springer.",
+            "Jacob Devlin, Ming-Wei Chang, Kenton Lee, and Kristina Toutanova. 2019. BERT: Pre-training of deep bidirectional transformers for language understanding. In Proceedings of the 2019 Conference of the North American Chapter of the Association for Computational Linguistics: Human Language Technologies, Volume 1 (Long and Short Papers), pages 4171-4186, Minneapolis, Minnesota. Association for Computational Linguistics."
+        ],
+        "bbox": [
+            512,
+            98,
+            884,
+            910
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "list",
+        "sub_type": "ref_text",
+        "list_items": [
+            "William B Dolan and Chris Brockett. 2005. Automatically constructing a corpus of sentential paraphrases. In Proceedings of the International Workshop on Paraphrasing.",
+            "Gamaleldin F. Elsayed, Ian Goodfellow, and Jascha Sohl-Dickstein. 2019. Adversarial reprogramming of neural networks. In International Conference on Learning Representations.",
+            "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. Association for Computational Linguistics.",
+            "Thanh-Le Ha, Jan Niehues, and Alexander Waibel. 2016. Toward multilingual neural machine translation with universal encoder and decoder.",
+            "Pengcheng He, Xiaodong Liu, Jianfeng Gao, and Weizhu Chen. 2020. DeBERTa: Decoding-enhanced bert with disentangled attention. arXiv preprint arXiv:2006.03654.",
+            "N. Houlsby, Andrei Giurgiu, Stanislaw Jastrzebski, Bruna Morrone, Quentin de Laroussilhe, Andrea Gesmundo, Mona Attariyan, and S. Gelly. 2019. Parameter-efficient transfer learning for nlp. In ICML.",
+            "Xiaoqi Jiao, Yichun Yin, Lifeng Shang, Xin Jiang, Xiao Chen, Linlin Li, Fang Wang, and Qun Liu. 2020. TinyBERT: Distilling BERT for natural language understanding. In Findings of the Association for Computational Linguistics: EMNLP 2020, pages 4163-4174, Online. Association for Computational Linguistics.",
+            "Melvin Johnson, Mike Schuster, Quoc V. Le, Maxim Krikun, Yonghui Wu, Zhifeng Chen, Nikhil Thorat, Fernanda Viégas, Martin Wattenberg, Greg Corrado, Macduff Hughes, and Jeffrey Dean. 2017. Google's multilingual neural machine translation system: Enabling zero-shot translation. Transactions of the Association for Computational Linguistics, 5:339-351.",
+            "Zhenzhong Lan, Mingda Chen, Sebastian Goodman, Kevin Gimpel, Piyush Sharma, and Radu Soricut. 2020. ALBERT: A lite BERT for self-supervised learning of language representations. In International Conference on Learning Representations.",
+            "Hector J Levesque, Ernest Davis, and Leora Morgenstern. 2011. The Winograd schema challenge. In AAAI Spring Symposium: Logical Formalizations of Commonsense Reasoning, volume 46, page 47.",
+            "Xiang Lisa Li and Percy Liang. 2021. Prefix-Tuning: Optimizing continuous prompts for generation. arXiv preprint arXiv:2101.00190.",
+            "Y. Liu, Myle Ott, Naman Goyal, Jingfei Du, Mandar Joshi, Danqi Chen, Omer Levy, M. Lewis, Luke Zettlemoyer, and Veselin Stoyanov. 2019."
+        ],
+        "bbox": [
+            117,
+            76,
+            489,
+            908
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "list",
+        "sub_type": "ref_text",
+        "list_items": [
+            "RoBERTa: A robustly optimized BERT pretraining approach. ArXiv, abs/1907.11692.",
+            "Marie-Catherine de Marneffe, Mandy Simons, and Judith Tonhauser. 2019. The Commitment Bank: Investigating projection in naturally occurring discourse. Proceedings of Sinn und Bedeutung, 23(2):107-124.",
+            "Paarth Neekhara, Shehzeen Hussain, Shlomo Dubnov, and Farinaz Koushanfar. 2019. Adversarial reprogramming of text classification neural networks. In Proceedings of the 2019 Conference on Empirical Methods in Natural Language Processing and the 9th International Joint Conference on Natural Language Processing (EMNLP-IJCNLP), pages 5216-5225, Hong Kong, China. Association for Computational Linguistics.",
+            "Matthew Peters, Mark Neumann, Mohit Iyyer, Matt Gardner, Christopher Clark, Kenton Lee, and Luke Zettlemoyer. 2018. Deep contextualized word representations. In Proceedings of the 2018 Conference of the North American Chapter of the Association for Computational Linguistics: Human Language Technologies, Volume 1 (Long Papers), pages 2227-2237, New Orleans, Louisiana. Association for Computational Linguistics.",
+            "Matthew E. Peters, Sebastian Ruder, and Noah A. Smith. 2019. To tune or not to tune? adapting pretrained representations to diverse tasks. In Proceedings of the 4th Workshop on Representation Learning for NLP (RepL4NLP-2019), pages 7-14, Florence, Italy. Association for Computational Linguistics.",
+            "Jonas Pfeiffer, Aishwarya Kamath, Andreas Rückle, Kyunghyun Cho, and Iryna Gurevych. 2021. AdapterFusion: Non-destructive task composition for transfer learning. In Proceedings of the 16th Conference of the European Chapter of the Association for Computational Linguistics: Main Volume, pages 487-503, Online. Association for Computational Linguistics.",
+            "Alec Radford, Karthik Narasimhan, Tim Salimans, and Ilya Sutskever. 2018. Improving language understanding by generative pre-training.",
+            "Alec Radford, Jeffrey Wu, Rewon Child, David Luan, Dario Amodei, and Ilya Sutskever. 2019. Language models are unsupervised multitask learners.",
+            "Pranav Rajpurkar, Jian Zhang, Konstantin Lopyrev, and Percy Liang. 2016. SQuAD: 100,000+ questions for machine comprehension of text. In Proceedings of the 2016 Conference on Empirical Methods in Natural Language Processing, pages 2383-2392, Austin, Texas. Association for Computational Linguistics.",
+            "Timo Schick and Hinrich Schütze. 2021a. Exploiting cloze-questions for few-shot text classification and natural language inference. In Proceedings of the"
+        ],
+        "bbox": [
+            512,
+            76,
+            882,
+            908
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "list",
+        "sub_type": "ref_text",
+        "list_items": [
+            "16th Conference of the European Chapter of the Association for Computational Linguistics: Main Volume, pages 255-269, Online. Association for Computational Linguistics.",
+            "Timo Schick and Hinrich Schütze. 2021b. It's not just size that matters: Small language models are also few-shot learners. In Proceedings of the 2021 Conference of the North American Chapter of the Association for Computational Linguistics: Human Language Technologies, pages 2339-2352, Online. Association for Computational Linguistics.",
+            "Rico Sennrich, Barry Haddow, and Alexandra Birch. 2016. Controlling politeness in neural machine translation via side constraints. In Proceedings of the 2016 Conference of the North American Chapter of the Association for Computational Linguistics: Human Language Technologies, pages 35-40, San Diego, California. Association for Computational Linguistics.",
+            "Taylor Shin, Yasaman Razeghi, Robert L. Logan IV, Eric Wallace, and Sameer Singh. 2020a. AutoPrompt: Eliciting Knowledge from Language Models with Automatically Generated Prompts. In Proceedings of the 2020 Conference on Empirical Methods in Natural Language Processing (EMNLP), pages 4222-4235, Online. Association for Computational Linguistics.",
+            "Taylor Shin, Yasaman Razeghi, Robert L. Logan IV, Eric Wallace, and Sameer Singh. 2020b. AutoPrompt: Eliciting Knowledge from Language Models with Automatically Generated Prompts. In Proceedings of the 2020 Conference on Empirical Methods in Natural Language Processing (EMNLP), pages 4222-4235, Online. Association for Computational Linguistics.",
+            "Richard Socher, Alex Perelygin, Jean Wu, Jason Chuang, Christopher D Manning, Andrew Ng, and Christopher Potts. 2013. Recursive deep models for semantic compositionality over a sentiment treebank. In Proceedings of EMNLP, pages 1631-1642.",
+            "Alex Wang, Yada Pruksachatkun, Nikita Nangia, Amanpreet Singh, Julian Michael, Felix Hill, Omer Levy, and Samuel R. Bowman. 2019a. SuperGLUE: A stickier benchmark for general-purpose language understanding systems. In NeurIPS.",
+            "Alex Wang, Amanpreet Singh, Julian Michael, Felix Hill, Omer Levy, and Samuel R. Bowman. 2019b. GLUE: A multi-task benchmark and analysis platform for natural language understanding. In International Conference on Learning Representations.",
+            "Alex Warstadt, Amanpreet Singh, and Samuel R. Bowman. 2019. Neural network acceptability judgments. Transactions of the Association for Computational Linguistics, 7:625-641.",
+            "Adina Williams, Nikita Nangia, and Samuel Bowman. 2018. A broad-coverage challenge corpus for sentence understanding through inference. In Proceedings of the 2018 Conference of the North American"
+        ],
+        "bbox": [
+            117,
+            76,
+            489,
+            908
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "list",
+        "sub_type": "ref_text",
+        "list_items": [
+            "Chapter of the Association for Computational Linguistics: Human Language Technologies, Volume 1 (Long Papers), pages 1112-1122, New Orleans, Louisiana. Association for Computational Linguistics.",
+            "Thomas Wolf, Lysandre Debut, Victor Sanh, Julien Chaumont, Clement Delangue, Anthony Moi, Pierric Cistac, Tim Rault, Remi Louf, Morgan Funtowicz, Joe Davison, Sam Shleifer, Patrick von Platen, Clara Ma, Yacine Jernite, Julien Plu, Canwen Xu, Teven Le Scao, Sylvain Gugger, Mariama Drame, Quentin Lhoest, and Alexander Rush. 2020. Transformers: State-of-the-art natural language processing. In Proceedings of the 2020 Conference on Empirical Methods in Natural Language Processing: System Demonstrations, pages 38-45, Online. Association for Computational Linguistics."
+        ],
+        "bbox": [
+            512,
+            76,
+            884,
+            309
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "A Hyperparameters",
+        "text_level": 1,
+        "bbox": [
+            115,
+            74,
+            309,
+            91
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "For each of the tasks, we performed hyperparameter search in the following space:",
+        "bbox": [
+            115,
+            99,
+            487,
+            131
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "list",
+        "sub_type": "text",
+        "list_items": [
+            "- Learning rate is chosen from the set  $\\{10^{-2}, 3 \\cdot 10^{-3}, 10^{-3}, 3 \\cdot 10^{-4}, 10^{-4}, 3 \\cdot 10^{-5}\\}$ ,",
+            "- Number of epochs is chosen as either 10 or 20. This determines the behavior of the slanted triangular learning rate scheduler.",
+            "- Initialization is performed either with the embedding of the [MASK] token, or randomly initialized from a normal distribution, with the mean and variance taken from the matrix of RoBERTa's word embeddings."
+        ],
+        "bbox": [
+            137,
+            145,
+            487,
+            344
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "The hyperparameter search took roughly 4 days on two Titan V GPUs. The final choices for each task are shown in Table 5. Initialization with [MASK] performed better than the random initialization.",
+        "bbox": [
+            115,
+            357,
+            487,
+            436
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "We disable all dropouts inside Transformer. We use huggingface implementation of AdamW optimizer with weight decay disabled. The gradient is normalized to the value 1.0. For the batch sampling we use bucketing with padding noise of 0.1. In order to use the device memory more effectively, we also set maximum number of tokens per batch to 2048. The maximum sequence length is truncated to 512 tokens. We enable mixed precision and pad all sequence lengths to the multiples of 8 for the effective usage of TensorCores<sup>8</sup>.",
+        "bbox": [
+            115,
+            439,
+            489,
+            615
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "B Learned Tokens",
+        "text_level": 1,
+        "bbox": [
+            510,
+            74,
+            687,
+            87
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Table 6 lists the closest vocabulary words to the learned embeddings. Most tasks have two input sentences, so the prompts consist of three parts: one is added before the first sentence, the second one is added between the sentences and the third one is appended next to the second sentence. For the single-sentence tasks, the second and third parts of the prompt are simply concatenated. Each task has trainable verbalizer tokens, one per output class.",
+        "bbox": [
+            509,
+            99,
+            882,
+            258
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "The prompts of RTE, MRPC and STS-B are pretty similar to MNLI's prompts, as the models for these tasks were initialized from pretrained MNLI models. The other tasks were initialized with [MASK] tokens. The final model for CoLA didn't move too far from its initialization.",
+        "bbox": [
+            509,
+            260,
+            882,
+            355
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "$^{8}$ https://docs.nvidia.com/deeplearning/performance/mixed-precision-training/index.html",
+        "bbox": [
+            115,
+            625,
+            495,
+            651
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "table",
+        "img_path": "images/a9295a0bccdf65735d4676d7c71494de3b7c950ed83cc9165b73d507bcf67ac9.jpg",
+        "table_caption": [],
+        "table_footnote": [
+            "Table 5: Hyperparameters of our best-performing models. [MASK] means the prompts are initialized with the word embedding of same token, and MNLI means the prompt is initialized with the prompts of out best MNLI run."
+        ],
+        "table_body": "<table><tr><td>Task</td><td>Learning rate</td><td>Epochs</td><td>Init.</td></tr><tr><td>MNLI</td><td>0.001</td><td>10</td><td>[MASK]</td></tr><tr><td>QNLI</td><td>0.001</td><td>10</td><td>[MASK]</td></tr><tr><td>QQP</td><td>0.0003</td><td>20</td><td>[MASK]</td></tr><tr><td>RTE</td><td>0.001</td><td>20</td><td>MNLI</td></tr><tr><td>SST-2</td><td>0.003</td><td>20</td><td>[MASK]</td></tr><tr><td>MRPC</td><td>0.001</td><td>20</td><td>MNLI</td></tr><tr><td>CoLA</td><td>0.001</td><td>20</td><td>[MASK]</td></tr><tr><td>STS-B</td><td>0.001</td><td>20</td><td>MNLI</td></tr></table>",
+        "bbox": [
+            117,
+            673,
+            484,
+            825
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "table",
+        "img_path": "images/2a9c0bf80fbf532476dc797dfe5c728c537dee038e1209939341f1179c64b3fc.jpg",
+        "table_caption": [],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=\"6\">MNLI</td><td rowspan=\"3\">Prompts</td><td>before</td><td>A-A-A-A-A-A-A-A-A-A-A-A-A-A-A-A-A-Tomorrow Ale .aGj * .</td></tr><tr><td>between</td><td>_MUCH irin [/ _a (@ [MASK] _dL aHJ E [MASK] _aKH</td></tr><tr><td>after</td><td>_&lt;!-_informing inyl _entit dim</td></tr><tr><td rowspan=\"3\">Verbalizers</td><td>entailment</td><td>_categories</td></tr><tr><td>neutral</td><td>gomery</td></tr><tr><td>contradiction</td><td>Unless</td></tr><tr><td rowspan=\"5\">QNLI</td><td rowspan=\"3\">Prompts</td><td>before</td><td>*. _neigh [MASK] U {}</td></tr><tr><td>between</td><td>aG-aG- [MASK] olitan _pronouns [MASK] [MASK] [MASK] @@@[MASK]_Choi [MASK]</td></tr><tr><td>after</td><td></td></tr><tr><td rowspan=\"2\">Verbalizers</td><td>entailment</td><td>_VIDE</td></tr><tr><td>not_ entailment</td><td>470</td></tr><tr><td rowspan=\"5\">QQP</td><td rowspan=\"3\">Prompts</td><td>before</td><td>_resembling_swarm_Calm_Membership</td></tr><tr><td>between</td><td>.derive rics [MASK] alias iary [MASK] _omnip [MASK] [MASK] [MASK] _sham</td></tr><tr><td>after</td><td>[MASK] _forb [MASK] _Firefly _THEY</td></tr><tr><td rowspan=\"2\">Verbalizers</td><td>notDuplicate</td><td>ende</td></tr><tr><td>duplicate</td><td>_sugg</td></tr><tr><td rowspan=\"5\">RTE</td><td rowspan=\"3\">Prompts</td><td>before</td><td>A-A-A-A-A-A-A-A-A-A-A-A-A-A-A-A-Tomorrow ALE .aGj * .</td></tr><tr><td>between</td><td>_MUCH irin [/ _a (@ [MASK] _aHJ femin [MASK] _aK</td></tr><tr><td>after</td><td>ahiahi _informing # _entit OOOO</td></tr><tr><td rowspan=\"2\">Verbalizers</td><td>entailment</td><td>e!</td></tr><tr><td>not_ entailment</td><td>_blames</td></tr><tr><td rowspan=\"5\">SST-2</td><td rowspan=\"3\">Prompts</td><td>before</td><td>choes _charms_sorely _&quot;akijakij</td></tr><tr><td>between</td><td>a ffe Pae _charred _masked [MASK] _Fall _babys _smartest ik /</td></tr><tr><td>after</td><td>dL forums _bio _mang A+</td></tr><tr><td rowspan=\"2\">Verbalizers</td><td>negative</td><td>_defective</td></tr><tr><td>positive</td><td>很重要的</td></tr><tr><td rowspan=\"5\">MRPC</td><td rowspan=\"3\">Prompts</td><td>before</td><td>A-A-A-A-A-A-A-A-A-A-A-A-A-A-A-A-Tomorrow rison .aGj * .</td></tr><tr><td>between</td><td>_MUCH irin [/ _a jay [MASK] _dL aHJ femin [MASK] .?</td></tr><tr><td>after</td><td>_&gt; _informing # _entit OOOO</td></tr><tr><td rowspan=\"2\">Verbalizers</td><td>entailment</td><td>_categories</td></tr><tr><td>neutral</td><td>gomery</td></tr><tr><td rowspan=\"5\">CoLA</td><td rowspan=\"3\">Prompts</td><td>before</td><td>[MASK] [MASK] [MASK] [MASK]</td></tr><tr><td>between</td><td>[MASK] [MASK] [MASK] [MASK] [MASK] [MASK] [MASK] [MASK] [MASK]</td></tr><tr><td>after</td><td>[MASK] [MASK] [MASK] [MASK] [MASK]</td></tr><tr><td rowspan=\"2\">Verbalizers</td><td>unacceptable</td><td>_additionally</td></tr><tr><td>acceptable</td><td>o</td></tr><tr><td rowspan=\"3\">STS-B</td><td rowspan=\"3\">Prompts</td><td>before</td><td>A-A-A-A-A-A-A-A-A-A-A-A-A-A-A-A-A-A-A-A-A-A-A-A-A-A-A-A-A-A-A-A-A-A-A-A-A-A-A-A-A-A-A-A-A-A-A-A-A-A-A-A-A-A-A-A-A-A-A-A-A-A-A-A-A-A-A-A-A-A-A-A-A-A-A-A-A-A-A-A-A-A-A-A-A-A-A-A-A-A-A-A-A-A-A-A-A-A-A-A-A</td></tr><tr><td>between</td><td>_Kers irin [/ _a (@ [MASK] _dL AhAHAhAH femin [MASK] _aKH</td></tr><tr><td>after</td><td>A-A-A-A-A-A-A-A-A-A-A-A-A-A-A-A-A-A-A-A-A-A-A-A-A-A-A-A-A-A-A-A-A-A-A-A-A-A-A-A-A-A-A-A-A-A-A-A-A-A-A-A-A-A-A-A-A-A-A-A-A-A-A-A-A-A-A-A-A-A-A-A-A-A-A-A-A-A-A-A-A-A-A-A-A-A-A-A-A-A-A-A-A-A-A-A-A-A</td></tr></table>",
+        "bbox": [
+            117,
+            101,
+            890,
+            820
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Table 6: The closest words to the prompt and verbalizer token embeddings for the best model for each task. We use cosine distance to measure the distance. [MASK] tokens highlighted in bold indicate the positions we use to output the prediction.",
+        "bbox": [
+            114,
+            831,
+            884,
+            875
+        ],
+        "page_idx": 12
+    }
+]

data/2021/2101_00xxx/2101.00121/full.md

@@ -1,3 +1,322 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:147a6911e08e4deda9d62f31556bf1c929e30cef02f193b8b5dbce894408c9a8
-size 54103
+# WARP: Word-level Adversarial ReProgramming
+
+Karen Hambardzumyan<sup>1</sup>, Hrant Khachatrian<sup>1,2</sup>, Jonathan May<sup>3</sup>
+
+$^{1}$ YerevaNN,  $^{2}$ Yerevan State University,
+
+<sup>3</sup>Information Sciences Institute, University of Southern California
+
+mahnerak@yerevann.com, hrant@yerevann.com, jonmay@isi.edu
+
+# Abstract
+
+Transfer learning from pretrained language models recently became the dominant approach for solving many NLP tasks. A common approach to transfer learning for multiple tasks that maximize parameter sharing trains one or more task-specific layers on top of the language model. In this paper, we present an alternative approach based on adversarial reprogramming, which extends earlier work on automatic prompt generation. Adversarial reprogramming attempts to learn task-specific word embeddings that, when concatenated to the input text, instruct the language model to solve the specified task. Using up to 25K trainable parameters per task, this approach outperforms all existing methods with up to 25M trainable parameters on the public leaderboard of the GLUE benchmark. Our method, initialized with task-specific human-readable prompts, also works in a few-shot setting, outperforming GPT-3 on two SuperGLUE tasks with just 32 training samples.
+
+# 1 Introduction
+
+Language model pretraining has had a tremendous impact on solving many natural language processing tasks (Peters et al., 2018; Radford et al., 2018; Devlin et al., 2019; Liu et al., 2019). The most popular two approaches take a pretrained model and use a straightforward supervised learning objective. In the first approach, the parameters of the language model are frozen and a task-specific head is trained on top of them (Peters et al., 2018). The second approach fine-tunes all model parameters (Radford et al., 2018). The latter can sometimes yield better results (Peters et al., 2019), while the first one usually offers better stability for smaller datasets. The approach based on frozen features does not require storing task-specific language models.
+
+A recent alternative is based on so called adapters (Houlsby et al., 2019; Pfeiffer et al., 2021), a technique that adds new weights at every layer of the pretrained language model while the original parameters are kept frozen. This enables a smaller set of task-specific parameters while achieving results comparable to the fine-tuning approach.
+
+Another approach of leveraging pretrained language models for downstream tasks, introduced by Radford et al. (2019), provides "task descriptions" without using any labeled examples. GPT-3 (Brown et al., 2020) demonstrates impressive few-shot learning performance with priming: by providing the language model a few inputs and outputs ("analogies") as a context. The language model contextually "learns" from these examples and outputs the answer with a single forward pass without any trainable parameters. These methods, however, require huge language models (1.5B and 175B parameters, respectively).
+
+The success of task reformulation-based approaches suggest that language models are capable of solving various natural language processing tasks given a well-crafted prompt. We hypothesize that it is possible to find such prompts. In other words, we can discover extra tokens that, when added to the input, can exploit language model capabilities better than the manually-designed ones.
+
+In this paper, we introduce a novel technique to find optimal prompts. We call our method WARP: Word-level Adversarial ReProgramming<sup>1</sup>. The method is inspired by adversarial reprogramming (Elsayed et al., 2019) — a method of adding adversarial perturbations to an input image that reprograms a pretrained neural network to perform classification on a task other than the one it was originally trained for.
+
+![](images/bf66c6df047a9c7ed30c88e96ed74d3210ac6981e0c447d1635d011b02e78431.jpg)  
+Figure 1: An example of an adversarial program that causes Inception V3 ImageNet model to function as an MNIST classifier, from Elsayed et al. (2019)
+
+We show that our method, using up to 25K trainable parameters per task, achieves 81.6 test score on the GLUE Leaderboard, outperforming all the other submissions that use up to three orders of magnitude more trainable parameters. We show that it is possible to inject knowledge into WARP models using manually designed initialization of the prompt, which is especially useful on tasks with a small number of examples. Moreover, WARP shows impressive few-shot performance on two tasks from the SuperGLUE benchmark with just 32 examples, outperforming GPT-3 results. Finally, we discuss the advantages of our method in real-life applications.
+
+# 2 Related Work
+
+# 2.1 Towards Fewer Trainable Parameters
+
+Jiao et al. (2020) show that knowledge distillation may help reduce the size of their model 7.5 times while almost preserving the performance, but finetuning such models still requires storage of separate task-specific models. As seen in Section 6, this approach does not scale when we want to apply it to many tasks at once.
+
+Another approach, called Adapters (Houlsby et al., 2019; Pfeiffer et al., 2021), introduces new task-specific parameters that are added at every layer of the Transformer network. Only these newly initialized weights are trained, which allows separation of general and task-specific knowledge. In contrast, our method does not inject task-specific knowledge inside the body of the pretrained language model. Instead, it focuses on learning task-specific input-level prompts.
+
+![](images/59ba3c48bea62432583f5692e2aeec03ff6d3e356e04f655e6a4eea8d6fa0e18.jpg)  
+Figure 2: WARP adds a few trainable embeddings around the input, which causes the masked language model to predict the sentiment of the sentence.
+
+# 2.2 Task Reformulation
+
+In GPT-2, Radford et al. (2019) introduce a completely unsupervised way for transferring knowledge to downstream tasks by reformulating various natural language understanding tasks into language modeling problems. This approach does not make use of the available training examples. Brown et al. (2020) demonstrate an effective few-shot transfer by reformulating downstream tasks into input-output analogies in the context without a need for further fine-tuning. Nonetheless, the number of training examples is limited to the context size and is not scalable to a traditional supervised learning scenario.
+
+Schick and Schütze (2021b) show the effectiveness of reformulating a number of tasks into Cloze-style tasks by fine-tuning masked language models (Devlin et al., 2019). The method, called Pattern Exploited Training (PET), additionally uses training samples and performs few-shot learning even without huge models such as GPT-3.
+
+Our method is also based on masked language models, but unlike PET, we focus on finding the best prompt using the training examples. This eliminates the need for manually-designed prompts, however, our method can also benefit from similar prior knowledge about the task by careful initialization of the prompts.
+
+# 2.3 Adversarial Reprogramming
+
+Adversarial Reprogramming (Elsayed et al., 2019) demonstrates the reprogramming of pretrained ImageNet classifiers by adding input-level adversarial perturbations to make them perform well on MNIST and CIFAR-10 image classification tasks. The adversarial perturbation is designed to be image padding added to the original input, as illus
+
+![](images/44d6b26302cfdab70e7425e45ec40185e6c9dcfad10695e177396540e518eb96.jpg)  
+Figure 3: Illustration of WARP. The prompt tokens [P_1], [P_2], ..., [P_N] are inserted before, between, and after the sentences. Only the prompt and class embeddings are trainable (colored in green). The masked language modeling Head is applied without the decoder; instead, the matrix of [V_1], [V_2], ..., [V_N] is applied as a linear layer. Finally, a regular task-specific loss is computed on the resulting logits.
+
+trated in Figure 1. Then the perturbation parameter is trained to optimize the target classification task objective using the annotated image data.
+
+While in the case of image classification it is not obvious why adversarial reprogramming should ever work, e.g. why a network trained on ImageNet should have the capacity to solve MNIST when surrounded with a particular bitmap, for NLP tasks, there is more intuition. Many NLP tasks can be reformulated as language models, a shared space for both program and data.
+
+Adversarial reprogramming has been adapted to text classification tasks with LSTM networks in (Neekhara et al., 2019). They operate in the vocabulary space and reprogram a model trained for one task to perform another task. More recently, AutoPrompt (Shin et al., 2020a) attempts to find prompts for large language models automatically without adding any parameters to the model. Unlike AutoPrompt, we perform gradient-based optimization in the space of word embeddings which gives our model more degrees of freedom and eventually better performance on the downstream tasks (Section 6.2).
+
+In a more general sense, guiding an NLP model with special tokens appended to the input is an even older idea. In particular, multilingual neural machine translation models use special tokens in the input to control the target language (Ha et al., 2016; Johnson et al., 2017) or politeness
+
+of the translation (Sennrich et al., 2016). Another method to reprogram a BERT-based model is proposed by Artetxe et al. (2020), where a model tuned on an English version of a particular task is transformed to work in another language by changing only the embedding matrices.
+
+In parallel work, Li and Liang (2021) propose a similar method and successfully apply it on two text generation tasks. Apart from the different types of tasks and our characterization of the task as a form of Adversarial Reprogramming, the main difference between their approach and ours is that they use an additional parameterization trick to stabilize the training.
+
+# 3 WARP
+
+We follow a setup similar to Elsayed et al. (2019) with some NLP-specific modifications depicted in Figure 2.
+
+Our goal is to find the best prompt that will make a pretrained masked language model predict the desired answer (verbalizer token) for a training example's masked token $^2$ . We search for such prompts in the (continuous) embedding space. In other words, we want to find parameters  $\Theta = \{\Theta^P,\Theta^V\}$  for prompt and verbalizer embed
+
+dings, respectively, such that:
+
+$$
+\Theta^ {*} = \arg \max  _ {\Theta} (- \log P _ {\Theta} (y | x))
+$$
+
+and the probabilities are given by:
+
+$$
+P _ {\Theta} (y | x) = \frac {\exp \Theta_ {y} ^ {V} f \left(T _ {\Theta^ {P}} (x)\right)}{\sum_ {i \in C} \exp \Theta_ {i} ^ {V} f \left(T _ {\Theta^ {P}} (x)\right)}
+$$
+
+where  $T_{\Theta^P}(x)$  is the template that inserts the prompt embeddings  $\Theta^P$  into predefined positions,  $C$  is the set of classes, and  $f(x)$  is the masked language model output (without the last decoder layer, which is simply the transposed word embedding matrix). Both  $\Theta^P$  and  $\Theta^V$  are vectors in the same embeddings space as the word embeddings.
+
+In Figure 2, the template  $T_{\Theta^P}(x)$  prepends  $\Theta_1^P$  and appends  $\Theta_2^P, \Theta_3^P, \Theta_4^P$  parameters to the word embeddings and uses  $\Theta_+^V$  and  $\Theta_-^V$  to calculate the probabilities on the masked token position for positive and negative classes.
+
+# 3.1 Method
+
+Similar to Elsayed et al. (2019), we employ stochastic gradient descent to find the best adversarial perturbation on the text that will minimize the task objective. First, we insert special prompt tokens [P_1], [P_2], ... [P_K] and an additional [MASK] token into the input sequence. These tokens might be placed before or after the sentences, depending on the prompt template.
+
+We set the optimization objective to a cross-entropy loss between the head output of the masked language model and the verbalizer tokens [V_1], [V_2], ..., [V_C] for classes 1...C accordingly.
+
+The only trainable parameters are the word embeddings for [P_1], ..., [P_K] and [V_1], ..., [V_C]. In case we want to train models for multiple tasks, these are the only task-specific parameters we need to store. The entire "body" of the large language model (all attention layers, feedforward layers, and all other word embeddings) remains untouched.
+
+Note that, unlike most adversarial attacks, we do not update the embeddings of the original tokens of the input. This follows the intuition from Elsayed et al. (2019), when the pixels of MNIST or CIFAR images are left untouched, and only padding pixels are updated.
+
+We train these parameters by minimizing the loss on the training set of the downstream task.
+
+# 3.2 Implementation Details
+
+WARP is implemented in the AllenNLP framework. For all the GLUE benchmark tasks we use the roberta-large (Liu et al., 2019) model from the PyTorch implementation of huggingface transformers (Wolf et al., 2020) library. For the few-shot experiments, we use albert-xxlarge-v2 in order to directly compare to iPET (Schick and Schütze, 2021b). For the GLUE and SuperGLUE tasks we use dataset loaders and metrics implementations from the huggingface datasets library.
+
+The prompt tokens are initialized either with word embeddings of [MASK] or similar to the vectors from the word embedding layer. For the answer prompts, we use the masked language model head, which usually consists of a feedforward network and a decoder on top of it, where the weights of the decoder are shared with the word embeddings used for the input. We calculate the softmax over the verbalizer tokens [V_1], ... [V_C].
+
+We choose the Adam optimizer with a slanted triangular schedule for the learning rate with  $6\%$  warm-up steps and train for 10-20 epochs on each task. Each batch consists of examples containing at most 1024 tokens and 8 examples.
+
+In order to speed up the training, we disable the dropout of the pretrained language model. All the experiments are performed on two Titan Vs and two RTX 3080 GPUs, with mixed precision training. In practice, WARP is 2.5-3 times faster than regular fine-tuning and 2 times slower than frozen-features experiments in terms of epoch duration with the same batch sizes.
+
+Details about the hyperparameters can be found in the Supplementary material.
+
+# 4 Experiments on GLUE
+
+Following prior work, we evaluate our method on the GLUE Benchmark (Wang et al., 2019b), which consists of 9 natural language understanding tasks. Generally, we perform single-task WARP training, with early stopping and model selection using the original validation sets, if not stated otherwise.
+
+# 4.1 Tasks
+
+Almost all the tasks from the GLUE Benchmark are either sentence classification or sentence pair classification tasks, so WARP requires very few modifications to adapt to each of the tasks.
+
+<table><tr><td></td><td>MNLI</td><td>QNLI</td><td>QQP</td><td>RTE</td><td>SST</td><td>MRPC</td><td>CoLA</td><td>STS-B</td><td>AVG</td><td>#</td></tr><tr><td>Human Baselines</td><td>92.0 / 92.8</td><td>91.2</td><td>59.5 / 80.4</td><td>93.6</td><td>97.8</td><td>86.3 / 80.8</td><td>66.4</td><td>92.7 / 92.6</td><td>87.1</td><td></td></tr><tr><td>DeBERT3</td><td>91.9 / 91.6</td><td>99.2</td><td>76.2 / 90.8</td><td>93.2</td><td>97.5</td><td>94.0 / 92.0</td><td>71.5</td><td>92.9 / 92.6</td><td>90.8</td><td>3·109</td></tr><tr><td>RoBERTa</td><td>90.8 / 90.2</td><td>95.4</td><td>74.3 / 90.2</td><td>88.2</td><td>96.7</td><td>92.3 / 89.8</td><td>67.8</td><td>92.2 / 91.9</td><td>88.1</td><td>355·106</td></tr><tr><td>BERTlarge</td><td>86.7 / 85.9</td><td>92.7</td><td>72.1 / 89.3</td><td>70.1</td><td>94.9</td><td>89.3 / 85.4</td><td>60.5</td><td>87.6 / 86.5</td><td>80.5</td><td>355·106</td></tr><tr><td>BERTbase</td><td>84.6 / 83.4</td><td>90.5</td><td>71.2 / 89.2</td><td>66.4</td><td>93.5</td><td>88.9 / 84.8</td><td>52.1</td><td>87.1 / 85.8</td><td>78.3</td><td>110·106</td></tr><tr><td>TinyBERT6</td><td>84.6 / 83.2</td><td>90.4</td><td>71.6 / 89.1</td><td>70.0</td><td>93.1</td><td>87.3 / 82.6</td><td>51.1</td><td>85.0 / 83.7</td><td>78.1</td><td>67·106</td></tr><tr><td>TinyBERT4</td><td>82.5 / 81.8</td><td>87.7</td><td>71.3 / 89.2</td><td>66.6</td><td>92.6</td><td>86.4 / 81.2</td><td>44.1</td><td>81.9 / 80.4</td><td>75.9</td><td>15·106</td></tr><tr><td>ELECTRAsmall</td><td>81.6 / 81.2</td><td>88.3</td><td>70.4 / 88.0</td><td>63.6</td><td>91.1</td><td>89.0 / 84.9</td><td>55.6</td><td>85.6 / 84.6</td><td>77.4</td><td>14·106</td></tr><tr><td>Adapters (BERT)</td><td>85.4 / 85.0</td><td>92.4</td><td>71.5 / 89.4</td><td>71.6</td><td>94.3</td><td>88.7 / 84.3</td><td>59.2</td><td>87.3 / 86.1</td><td>80.2</td><td>1.2·106</td></tr><tr><td>WARP (RoBERTa)</td><td>88.0 / 88.2</td><td>93.5</td><td>68.6 / 87.7</td><td>84.3</td><td>96.3</td><td>88.2 / 83.9</td><td>53.9</td><td>89.5 / 88.8</td><td>81.6</td><td>&lt;25K</td></tr></table>
+
+Table 1: Test set results on GLUE Benchmark. The results are obtained from the GLUE Evaluation server. The subscript next to TinyBERT corresponds to the number of layers in the model. WARP for RTE, STS-B and MRPC are initialized from the MNLI parameters. Results for WNLI are not shown, although they are counted in the averaged GLUE score (AVG column). The last column # shows the number of trainable parameters. WARP's average performance is higher than all models with up to three orders of magnitude more trainable parameters. Fully fine-tuned RoBERTa and the current state-of-the-art method (DeBERT) score higher by 6.5 and 9.2 points, respectively.
+
+SST-2 (Sentence Sentiment Treebank, Socher et al., 2013) is a single sentence binary classification task. For the prompt, we put a [MASK] token after the sentence, and the trainable prompt tokens are both appended and prepended to the sentence.
+
+CoLA (Corpus of Linguistic Acceptability, Warstadt et al., 2019) is a single sentence classification task as well, so we treat both the same way with the only difference that as a validation metric we use accuracy for SST-2, and Matthew's correlation for CoLA.
+
+MNLI (MultiNLI, Multi-Genre Natural Language Inference, Williams et al., 2018), QNLI (Question Natural Language Inference, Rajpurkar et al., 2016) and RTE (Recognizing Textual Entailment, Dagan et al., 2006; Bar Haim et al., 2006; Giampiccolo et al., 2007; Bentivogli et al., 2009) are sentence pair classification tasks. Similar to Schick and Schütze (2021a), we may have prompt tokens before, after and between the two sentences, but the [MASK] token is always put between the sentences. For MNLI, we use matched accuracy as a validation metric and use the same model for the mismatched version. In our few-shot attempt for the RTE task, we use a different training and evaluation setup discussed in Section 5.2. QQP (Quora Question Pairs $^4$ ) and MRPC (Microsoft Research Paraphrase Corpus, Dolan and Brockett, 2005) follow the same prompt pattern as NLI tasks. As a validation metric  $F_1$  score is used,
+
+STS-B (Semantic Textual Similarity Bench
+
+mark, Cer et al., 2017), unlike the other tasks in the benchmark, is formulated as a regression task. The prompt pattern is the same, but instead of introducing new embeddings for  $[V\_ 1]$ ,  $[V\_ 2]$ , ...,  $[V\_ C]$  verbalizer tokens, we add a regression head to the last hidden state of MLM head and use Mean Squares Error optimization objective, similar to (Liu et al., 2019). Pearson Correlation is used as the validation metric. During inference, we clip the scores within [1, 5].
+
+We follow Liu et al. and train models for MRPC, STS-B, and RTE tasks initialized with the parameters from the best MNLI model but do not apply any task-specific tricks to WNLI (Winograd Schema Challenge NLI, Levesque et al., 2011) and always predict the majority label.
+
+# 4.2 Results
+
+Table 1 presents the results on the test set obtained from the GLUE evaluation server. Besides our best WARP models, we also include the human baselines, current state-of-the-art model (He et al., 2020), the regular fine-tuned pretrained model we use, and also include relatively small language models, including (Jiao et al., 2020), (Clark et al., 2020), (Houlsby et al., 2019).
+
+With the GLUE Score, WARP outperforms all the models that train less than 25 million parameters on the leaderboard. We explain the relatively strong WARP results on textual entailment tasks by the easier reformulation of such tasks. Likewise, we explain the relatively weak performance on CoLA by the difficulties of reformulating the
+
+<table><tr><td>train size</td><td>MNLI 392702</td><td>QNLI 104743</td><td>QQP 363846</td><td>RTE 2490</td><td>SST 67349</td><td>MRPC 3668</td><td>CoLA 8551</td><td>STS-B 5749</td><td>AVG</td><td>#</td></tr><tr><td>Fine-Tuning</td><td>90.2</td><td>94.7</td><td>92.2</td><td>86.6</td><td>96.4</td><td>90.9</td><td>68.0</td><td>92.4</td><td>88.9</td><td>\( {355} \cdot {10}^{6} \)</td></tr><tr><td>Adapters</td><td>90.4</td><td>94.7</td><td>88.5</td><td>83.4</td><td>96.3</td><td>92.9</td><td>67.4</td><td>92.5</td><td>88.3</td><td>\( 3 \cdot {10}^{6} \)</td></tr><tr><td>Linear Classifier</td><td>64.2</td><td>78.1</td><td>74.9</td><td>59.2</td><td>88.4</td><td>82.5</td><td>48.9</td><td>71.8</td><td>71.0</td><td>≤ 3072</td></tr><tr><td>\( {\mathrm{{WARP}}}_{0} \)</td><td>70.9</td><td>78.8</td><td>77.1</td><td>72.2</td><td>89.8</td><td>83.8</td><td>32.8</td><td>73.8</td><td>72.4</td><td>≤ 3072</td></tr><tr><td>\( {\mathrm{{WARP}}}_{1} \)</td><td>83.9</td><td>87.6</td><td>81.6</td><td>72.6</td><td>93.8</td><td>84.7</td><td>46.1</td><td>80.4</td><td>78.8</td><td>≤ 4096</td></tr><tr><td>\( {\mathrm{{WARP}}}_{2} \)</td><td>85.4</td><td>88.0</td><td>81.5</td><td>69.7</td><td>94.3</td><td>85.3</td><td>54.4</td><td>80.8</td><td>79.9</td><td>≤ 5120</td></tr><tr><td>\( {\mathrm{{WARP}}}_{4} \)</td><td>86.9</td><td>92.4</td><td>83.1</td><td>68.2</td><td>95.9</td><td>85.0</td><td>56.0</td><td>75.5</td><td>80.4</td><td>≤ 7168</td></tr><tr><td>\( {\mathrm{{WARP}}}_{8} \)</td><td>87.6</td><td>93.0</td><td>83.8</td><td>72.9</td><td>95.4</td><td>85.6</td><td>57.4</td><td>81.0</td><td>82.1</td><td>&lt; 11K</td></tr><tr><td>\( {\mathrm{{WARP}}}_{\text{init }} \)</td><td>86.8</td><td>90.4</td><td>83.6</td><td>80.1</td><td>96.0</td><td>86.0</td><td>51.7</td><td>86.9</td><td>82.7</td><td>&lt; 11K</td></tr><tr><td>\( {\mathrm{{WARP}}}_{20} \)</td><td>\( \underline{88.2} \)</td><td>\( \underline{93.5} \)</td><td>\( \underline{84.5} \)</td><td>75.8</td><td>\( \underline{96.0} \)</td><td>90.8</td><td>\( \underline{60.6} \)</td><td>88.6</td><td>84.8</td><td>&lt; 25K</td></tr><tr><td>\( {\mathrm{{WARP}}}_{\mathrm{{MNLI}}} \)</td><td></td><td></td><td></td><td>\( \underline{86.3} \)</td><td></td><td>\( \underline{91.2} \)</td><td></td><td>\( \underline{91.0} \)</td><td>86.4</td><td>&lt; 25K</td></tr></table>
+
+Table 2: Dev set results on GLUE tasks. The last column shows the number of trainable parameters only.  $\mathsf{WARP}_i$  corresponds to WARP training with prompt consisting of  $i$  prompt tokens.  $\mathsf{WARP}_{\mathsf{MNLI}}$  corresponds to WARP training initialized with the best MNLI parameters. All the models are based on pretrained roberta-large, and for Adapters and WARP-based approaches require to store  $355 \cdot 10^{6}$  frozen parameters shared across all the GLUE tasks. We show the primary validation metric for each task, described at Subsection 4.1. The AVG column shows the average of shown metrics and is not comparable to the Test server GLUE Score. The number of parameters for WARP methods may vary because of a difference in the number of classes. Underlined numbers correspond to our GLUE submission.
+
+task into a Cloze task.
+
+To further analyze WARP, we conduct several experiments and focus on dev set results. In order to directly compare WARP with existing methods, we report in Table 2 different methods that use RoBERTa, including fine-tuning, linear classifiers on top, AutoPrompt, and Adapters. For WARP experiments, we compare performance with different numbers of prompt tokens.
+
+The  $\mathrm{WARP_0}$  model does not introduce any prompt parameters. The only difference between  $\mathrm{WARP_0}$  and Linear Classifier is that for  $\mathrm{WARP_0}$ , [MASK] is added to the input of each sample, and we get sentence representations from the MLM head at the masked position. By contrast, in the case of the Linear Classifier, we use the average of non-special token embeddings as sentence representations. As we can see, pooling with MLM is significantly better.
+
+Table 2 shows that, as we decrease the number of trainable prompt parameters, the performance decreases, but the model still works. Similar behavior was observed by Elsayed et al. (2019) in experiments with different padding parameter sizes. However, in contrast to WARP, the number of trainable parameters in that work are much greater than the size of the input.
+
+An important benefit of using WARP is that
+
+it can be initialized with manual prompts. In addition to the regular models where we initialize with [MASK] tokens, we performed a run on the GLUE datasets with the same prompt [CLS] "S1"? [MASK]. "S2"! [SEP] for all the tasks (without S2 for single-sentence tasks). We denote these results as WARPinit in Table 2. WARPinit outperforms WARP8 on tasks with relatively few training examples — RTE, MRPC and STSB, which indicates its potential in the low-data regime.
+
+# 5 Few-Shot Experiments
+
+The fact that WARP can be initialized using manually designed natural prompts suggests that we can similarly benefit from such human attribution similar to iPET (Schick and Schütze, 2021b), especially in scenarios with limited training data.
+
+# 5.1 Setup
+
+For our few-shot experiments we build WARP on top of ALBERT (Lan et al., 2020), the same pretrained model used by PET and iPET. To initialize WARP prompts, we use the same Prompt-Verbalizer Patterns (PVP) from Schick and Schütze (2021b): the embeddings for [P_1], [P_2]... [P_N] are initialized with PVP's prompt token embeddings, and embeddings for [V_1], [V_2]... [V_C] are initialized with verbalizer token embeddings for their corre
+
+sponding classes. Unlike roberta-large, the alberta-xxlarge-v2 uses word embeddings of size 128 (8 times smaller than RoBERTa).
+
+# 5.2 Tasks
+
+In order to compare with GPT-3, PET, and iPET, we use two tasks from FewGLUE (Schick and Schütze, 2021b), which is a few-shot subset of the SuperGLUE benchmark (Wang et al., 2019a) consisting of 32 examples for each task. The dataset also provides 20000 additional unlabeled examples, however, we do not make use of them and work in a purely supervised setup.
+
+CB: CommitmentBank (de Marneffe et al., 2019) is a textual entailment task which we treat like the other sentence pair classification tasks. To initialize the prompt we use the template [CLS] "h"? [MASK]. "p" [SEP]. We also initialize [V-1], [V-2], [V-3] token embeddings with _yes, _no and _maybe (respectively for entailment, contradiction and neutral).
+
+RTE: Unlike experiments on the RTE task for the full-sized training in the GLUE benchmark, we do not initialize the model with vectors from MNLI. Instead, the prompt is initialized exactly the same way as in the CB task. The only difference is that we have only the two tokens [V_1] and [V_2] initialized with _yes and _instead (for entailment and not_ entailment, respectively).
+
+# 5.3 Model Selection
+
+Although all trainable parameters are manually initialized in this setup, different random seeds can yield different results because of the order the training examples appear during an epoch.
+
+In the few-shot setup we cannot access the original validation set. Thus, we disable early stopping and simply pick the last checkpoint.
+
+In order to find the best initial learning rate, we conduct 20 runs of WARP with the same learning rate each time by randomly choosing 16 training examples and taking the rest for a development set. We repeat this for all candidate learning rates and choose the one with the best average validation performance across all the random seeds.
+
+Finally, in order to eliminate the effect of different random seeds, we build an ensemble model from 20 WARP runs using simple majority vote.
+
+<table><tr><td></td><td>Model</td><td>CB
+F1 / Acc.</td><td>RTE
+Acc.</td></tr><tr><td rowspan="6">dev</td><td>GPT-3 Small</td><td>26.1 / 42.9</td><td>52.3</td></tr><tr><td>GPT-3 Med</td><td>40.4 / 58.9</td><td>48.4</td></tr><tr><td>GPT-3</td><td>57.2 / 82.1</td><td>72.9</td></tr><tr><td>PET (ALBERT)</td><td>59.4 / 85.1</td><td>69.8</td></tr><tr><td>iPET (ALBERT)</td><td>92.4 / 92.9</td><td>74.0</td></tr><tr><td>WARPinit (ALBERT)</td><td>84.0 / 87.5</td><td>71.8</td></tr><tr><td rowspan="4">test</td><td>GPT-3</td><td>52.0 / 75.6</td><td>69.0</td></tr><tr><td>PET (ALBERT)</td><td>60.2 / 87.2</td><td>67.2</td></tr><tr><td>iPET (ALBERT)</td><td>79.9 / 88.8</td><td>70.8</td></tr><tr><td>WARPinit (ALBERT)</td><td>70.2 / 82.4</td><td>69.1</td></tr></table>
+
+Table 3: Results on SuperGLUE benchmark. The results for the test set are obtained from SuperGLUE evaluation server. We only show systems performing in a similar few-shot training setup using 32 examples.
+
+# 5.4 Results
+
+As seen in Table 3, WARP outperforms PET and GPT-3 baselines, but stays behind iPET on both tasks. GPT-3 has 170B parameters, but none of them is being trained for the given tasks. PET and iPET have 255M parameters, and all of them are trained for these tasks. Additionally, they leverage unlabeled examples using distillation. WARP has roughly the same 255M parameters, but only 1024 of them are trained for any single model. An ensemble of 20 WARP models has slightly more than 20K trainable parameters.
+
+# 6 Discussion
+
+# 6.1 Interpreting tokens learned by WARP
+
+WARP learns prompt embeddings in a continuous space. In this section, we explore those embeddings by looking at the nearby token vectors. Table 6 in the Supplementary material lists the closest tokens (in terms of cosine similarity) to the learned embeddings. All GLUE tasks are initialized with [MASK] token, except for RTE, MRPC, and STS-B, which are initialized from the pretrained MNLI model. The prompt tokens of the solutions for those three tasks are quite close to the ones from the MNLI solution. We have seen similar behavior on SuperGLUE experiments with manual initializations. The solution for CoLA (which is one of the worst-performing tasks) is close to the initialized point.
+
+We do not see any prompt tokens that are meaningful in the context of the tasks. As expected, the verbalized tokens are more interpretable. For
+
+![](images/1c15f1e61742af3895fa977d64e9716372756814a9a1b5d5cb49ae9f271faf4b.jpg)  
+Figure 4: The effect of the training data size for SST-2 task (dev set). Horizontal axis is the number of training examples. Solid lines represent median over 10 runs, and the error bars show minimum and maximum performance. All methods use roberta-large model. The results for AutoPrompt and fine-tuning are taken from (Shin et al., 2020b)
+
+example, the embedding for the "contradiction" class of MNLI is close to the token "Unless". The embeddings for "negative" and "positive" classes of SST-2 task are close to "defective" and "important", respectively. Other verbalized tokens are non-interpretable (e.g. "470" or word pieces with non-Latin characters).
+
+# 6.2 Comparison with AutoPrompt
+
+AutoPrompt (Shin et al., 2020b) learns a prompt for the given task in the finite space of vocabulary tokens. Their best version uses 3 or 6 prompt tokens and reaches  $91.2\%$  accuracy on the development set of SST-2. The search space of WARP is significantly larger, which allows WARP to get better performance with just a single prompt token  $(93.8\%)$ .
+
+AutoPrompt does not achieve meaningful results on RTE or CB tasks. WARP succeeds on both without manual initialization. Moreover, with manual initialization, WARP gets good performance on both tasks even with just 32 examples (Table 3).
+
+Figure 4 shows the dependence of the accuracy on SST-2 development set from the number of training samples. Both WARP and AutoPrompt use 10 prompt tokens. With a few hundred training samples or fewer, the difference between the two algorithms is not significant. WARP starts to perform better with more training samples.
+
+<table><tr><td>Approach</td><td># of parameters to store</td></tr><tr><td>Linear probing</td><td>M + ECN</td></tr><tr><td>Full fine-tuning</td><td>MN</td></tr><tr><td>Single layer</td><td>M + NE(E + C)</td></tr><tr><td>TinyBERT</td><td>M0N</td></tr><tr><td>Adapters</td><td>M + NEE&#x27;</td></tr><tr><td>WARP</td><td>M + NE(C + K)</td></tr></table>
+
+Table 4: The number of parameters to be stored to serve  $N$  text classification tasks with at most  $C$  classes each, using a pretrained language model with  $M$  parameters.  $E$  is the dimension of embeddings (1024 in the case of RoBERTa). In TinyBERT,  $M_0$  can be up to 10 times less than  $M$ . In Adapters,  $E'$  is roughly equal to  $E$ , as the number of layers to which adapters are attached roughly compensates the smaller size of the bottleneck layer. In WARP,  $K$  is the number of prompts (usually fewer than 10).
+
+Shin et al. (2020b) include results with a manually designed prompt which performs pretty well (shown as a dashed line). We also compare with the manually initialized version of WARP, which performs very well with just 100 examples.
+
+# 6.3 Real-world applications
+
+The importance of NLP systems like WARP can be demonstrated by the following application. Suppose we want to build a system that needs to serve  $N >> 1$  classification tasks simultaneously. Let the number of classes for each task be bounded by  $C$ . The system can be based on a large pretrained language model with  $M$  parameters, using word embedding size  $E$ . How many parameters should the system store in the device memory to be able to serve all  $N$  tasks?
+
+If we take the approach with frozen features, we can reuse  $M$  parameters for all tasks and store additional ECN task-specific parameters. This is optimal in terms of storage but will not perform well. The other extreme is to fine-tune the whole model for each task and store at least MN parameters. Table 4 shows the trade-offs offered by the other solutions. Methods like TinyBERT decrease the number of parameters from  $MN$  by only  $M$ . WARP, on the other hand, needs to store only  $M + NE(C + K)$  parameters, where  $K$  is the number of trainable prompt tokens.
+
+In practice, WARP additionally allows performing inference on inputs for different tasks in parallel, using samples of multiple tasks in the same batch. Every input sentence can be concatenated with task-specific pretrained prompts in advance. Then, the forward pass of the network is identical for all tasks. The final task-specific linear layers can be concatenated to form a single large linear layer with at most  $NC$  output neurons.
+
+This approach can be especially useful in the systems that provide machine learning models as a service. By storing one copy of a pretrained language model, it is possible to serve a large number of user-specific models in parallel with little overhead.
+
+# 7 Conclusion
+
+In this paper we have proposed an alternative way to transfer knowledge from large pretrained language models to downstream tasks by appending carefully optimized embeddings to the input text. The method outperforms existing methods with significantly more trainable parameters on GLUE benchmark tasks and shows an impressive performance in a few-shot setting on two SuperGLUE tasks. On the sentiment analysis task, the performance is comparable to the fully fine-tuned language models. This method can save a lot of storage in software applications designed to serve large numbers of sentence classification tasks.
+
+# Acknowledgments
+
+This work is based in part on research sponsored by Air Force Research Laboratory (AFRL) under agreement number FA8750-19-1-1000. The U.S. Government is authorized to reproduce and distribute reprints for Government purposes notwithstanding any copyright notation therein. The views and conclusions contained herein are those of the authors and should not be interpreted as necessarily representing the official policies or endorsements, either expressed or implied, of Air Force Laboratory, DARPA or the U.S. Government.
+
+The work was supported by the RA Science Committee, in the frames of the research project No. 20TTAT-AIa024. Most experiments were performed on GPUs donated by NVIDIA.
+
+# References
+
+Mikel Artetxe, Sebastian Ruder, and Dani Yogatama. 2020. On the cross-lingual transferability of monolingual representations. In Proceedings of the 58th Annual Meeting of the Association for Computational Linguistics, pages 4623–4637, Online. Association for Computational Linguistics.  
+Roy Bar Haim, Ido Dagan, Bill Dolan, Lisa Ferro, Danilo Giampiccolo, Bernardo Magnini, and Idan Szpektor. 2006. The second PASCAL recognising textual entailment challenge.  
+Luisa Bentivogli, Ido Dagan, Hoa Trang Dang, Danilo Giampiccolo, and Bernardo Magnini. 2009. The fifth PASCAL recognizing textual entailment challenge.  
+T. Brown, B. Mann, Nick Ryder, Melanie Subbiah, J. Kaplan, Prafulla Dhariwal, Arvind Neelakantan, Pranav Shyam, Girish Sastry, Amanda Askell, Sandhini Agarwal, Ariel Herbert-Voss, G. Krüger, T. Henighan, R. Child, Aditya Ramesh, D. Ziegler, Jeffrey Wu, Clemens Winter, Christopher Hesse, Mark Chen, E. Sigler, Mateusz Litwin, Scott Gray, Benjamin Chess, J. Clark, Christopher Berner, Sam McCandlish, A. Radford, Ilya Sutskever, and Dario Amodei. 2020. Language models are few-shot learners. *ArXiv*, abs/2005.14165.  
+Daniel Cer, Mona Diab, Eneko Agirre, Inigo Lopez-Gazpio, and Lucia Specia. 2017. SemEval-2017 task 1: Semantic textual similarity multilingual and crosslingual focused evaluation. In Proceedings of the 11th International Workshop on Semantic Evaluation (SemEval-2017), pages 1-14, Vancouver, Canada. Association for Computational Linguistics.  
+Kevin Clark, Minh-Thang Luong, Quoc Le, and Christopher D. Manning. 2020. Pre-training transformers as energy-based cloze models. In Proceedings of the 2020 Conference on Empirical Methods in Natural Language Processing (EMNLP), pages 285-294, Online. Association for Computational Linguistics.  
+Ido Dagan, Oren Glickman, and Bernardo Magnini. 2006. The PASCAL recognising textual entailment challenge. In Machine learning challenges. evaluating predictive uncertainty, visual object classification, and recognising textual entailment, pages 177-190. Springer.  
+Jacob Devlin, Ming-Wei Chang, Kenton Lee, and Kristina Toutanova. 2019. BERT: Pre-training of deep bidirectional transformers for language understanding. In Proceedings of the 2019 Conference of the North American Chapter of the Association for Computational Linguistics: Human Language Technologies, Volume 1 (Long and Short Papers), pages 4171-4186, Minneapolis, Minnesota. Association for Computational Linguistics.
+
+William B Dolan and Chris Brockett. 2005. Automatically constructing a corpus of sentential paraphrases. In Proceedings of the International Workshop on Paraphrasing.  
+Gamaleldin F. Elsayed, Ian Goodfellow, and Jascha Sohl-Dickstein. 2019. Adversarial reprogramming of neural networks. In International Conference on Learning Representations.  
+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. Association for Computational Linguistics.  
+Thanh-Le Ha, Jan Niehues, and Alexander Waibel. 2016. Toward multilingual neural machine translation with universal encoder and decoder.  
+Pengcheng He, Xiaodong Liu, Jianfeng Gao, and Weizhu Chen. 2020. DeBERTa: Decoding-enhanced bert with disentangled attention. arXiv preprint arXiv:2006.03654.  
+N. Houlsby, Andrei Giurgiu, Stanislaw Jastrzebski, Bruna Morrone, Quentin de Laroussilhe, Andrea Gesmundo, Mona Attariyan, and S. Gelly. 2019. Parameter-efficient transfer learning for nlp. In ICML.  
+Xiaoqi Jiao, Yichun Yin, Lifeng Shang, Xin Jiang, Xiao Chen, Linlin Li, Fang Wang, and Qun Liu. 2020. TinyBERT: Distilling BERT for natural language understanding. In Findings of the Association for Computational Linguistics: EMNLP 2020, pages 4163-4174, Online. Association for Computational Linguistics.  
+Melvin Johnson, Mike Schuster, Quoc V. Le, Maxim Krikun, Yonghui Wu, Zhifeng Chen, Nikhil Thorat, Fernanda Viégas, Martin Wattenberg, Greg Corrado, Macduff Hughes, and Jeffrey Dean. 2017. Google's multilingual neural machine translation system: Enabling zero-shot translation. Transactions of the Association for Computational Linguistics, 5:339-351.  
+Zhenzhong Lan, Mingda Chen, Sebastian Goodman, Kevin Gimpel, Piyush Sharma, and Radu Soricut. 2020. ALBERT: A lite BERT for self-supervised learning of language representations. In International Conference on Learning Representations.  
+Hector J Levesque, Ernest Davis, and Leora Morgenstern. 2011. The Winograd schema challenge. In AAAI Spring Symposium: Logical Formalizations of Commonsense Reasoning, volume 46, page 47.  
+Xiang Lisa Li and Percy Liang. 2021. Prefix-Tuning: Optimizing continuous prompts for generation. arXiv preprint arXiv:2101.00190.  
+Y. Liu, Myle Ott, Naman Goyal, Jingfei Du, Mandar Joshi, Danqi Chen, Omer Levy, M. Lewis, Luke Zettlemoyer, and Veselin Stoyanov. 2019.
+
+RoBERTa: A robustly optimized BERT pretraining approach. ArXiv, abs/1907.11692.  
+Marie-Catherine de Marneffe, Mandy Simons, and Judith Tonhauser. 2019. The Commitment Bank: Investigating projection in naturally occurring discourse. Proceedings of Sinn und Bedeutung, 23(2):107-124.  
+Paarth Neekhara, Shehzeen Hussain, Shlomo Dubnov, and Farinaz Koushanfar. 2019. Adversarial reprogramming of text classification neural networks. In Proceedings of the 2019 Conference on Empirical Methods in Natural Language Processing and the 9th International Joint Conference on Natural Language Processing (EMNLP-IJCNLP), pages 5216-5225, Hong Kong, China. Association for Computational Linguistics.  
+Matthew Peters, Mark Neumann, Mohit Iyyer, Matt Gardner, Christopher Clark, Kenton Lee, and Luke Zettlemoyer. 2018. Deep contextualized word representations. In Proceedings of the 2018 Conference of the North American Chapter of the Association for Computational Linguistics: Human Language Technologies, Volume 1 (Long Papers), pages 2227-2237, New Orleans, Louisiana. Association for Computational Linguistics.  
+Matthew E. Peters, Sebastian Ruder, and Noah A. Smith. 2019. To tune or not to tune? adapting pretrained representations to diverse tasks. In Proceedings of the 4th Workshop on Representation Learning for NLP (RepL4NLP-2019), pages 7-14, Florence, Italy. Association for Computational Linguistics.  
+Jonas Pfeiffer, Aishwarya Kamath, Andreas Rückle, Kyunghyun Cho, and Iryna Gurevych. 2021. AdapterFusion: Non-destructive task composition for transfer learning. In Proceedings of the 16th Conference of the European Chapter of the Association for Computational Linguistics: Main Volume, pages 487-503, Online. Association for Computational Linguistics.  
+Alec Radford, Karthik Narasimhan, Tim Salimans, and Ilya Sutskever. 2018. Improving language understanding by generative pre-training.  
+Alec Radford, Jeffrey Wu, Rewon Child, David Luan, Dario Amodei, and Ilya Sutskever. 2019. Language models are unsupervised multitask learners.  
+Pranav Rajpurkar, Jian Zhang, Konstantin Lopyrev, and Percy Liang. 2016. SQuAD: 100,000+ questions for machine comprehension of text. In Proceedings of the 2016 Conference on Empirical Methods in Natural Language Processing, pages 2383-2392, Austin, Texas. Association for Computational Linguistics.  
+Timo Schick and Hinrich Schütze. 2021a. 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, pages 255-269, Online. Association for Computational Linguistics.  
+Timo Schick and Hinrich Schütze. 2021b. It's not just size that matters: Small language models are also few-shot learners. In Proceedings of the 2021 Conference of the North American Chapter of the Association for Computational Linguistics: Human Language Technologies, pages 2339-2352, Online. Association for Computational Linguistics.  
+Rico Sennrich, Barry Haddow, and Alexandra Birch. 2016. Controlling politeness in neural machine translation via side constraints. In Proceedings of the 2016 Conference of the North American Chapter of the Association for Computational Linguistics: Human Language Technologies, pages 35-40, San Diego, California. Association for Computational Linguistics.  
+Taylor Shin, Yasaman Razeghi, Robert L. Logan IV, Eric Wallace, and Sameer Singh. 2020a. AutoPrompt: Eliciting Knowledge from Language Models with Automatically Generated Prompts. In Proceedings of the 2020 Conference on Empirical Methods in Natural Language Processing (EMNLP), pages 4222-4235, Online. Association for Computational Linguistics.  
+Taylor Shin, Yasaman Razeghi, Robert L. Logan IV, Eric Wallace, and Sameer Singh. 2020b. AutoPrompt: Eliciting Knowledge from Language Models with Automatically Generated Prompts. In Proceedings of the 2020 Conference on Empirical Methods in Natural Language Processing (EMNLP), pages 4222-4235, Online. Association for Computational Linguistics.  
+Richard Socher, Alex Perelygin, Jean Wu, Jason Chuang, Christopher D Manning, Andrew Ng, and Christopher Potts. 2013. Recursive deep models for semantic compositionality over a sentiment treebank. In Proceedings of EMNLP, pages 1631-1642.  
+Alex Wang, Yada Pruksachatkun, Nikita Nangia, Amanpreet Singh, Julian Michael, Felix Hill, Omer Levy, and Samuel R. Bowman. 2019a. SuperGLUE: A stickier benchmark for general-purpose language understanding systems. In NeurIPS.  
+Alex Wang, Amanpreet Singh, Julian Michael, Felix Hill, Omer Levy, and Samuel R. Bowman. 2019b. GLUE: A multi-task benchmark and analysis platform for natural language understanding. In International Conference on Learning Representations.  
+Alex Warstadt, Amanpreet Singh, and Samuel R. Bowman. 2019. Neural network acceptability judgments. Transactions of the Association for Computational Linguistics, 7:625-641.  
+Adina Williams, Nikita Nangia, and Samuel Bowman. 2018. A broad-coverage challenge corpus for sentence understanding through inference. In Proceedings of the 2018 Conference of the North American
+
+Chapter of the Association for Computational Linguistics: Human Language Technologies, Volume 1 (Long Papers), pages 1112-1122, New Orleans, Louisiana. Association for Computational Linguistics.  
+Thomas Wolf, Lysandre Debut, Victor Sanh, Julien Chaumont, Clement Delangue, Anthony Moi, Pierric Cistac, Tim Rault, Remi Louf, Morgan Funtowicz, Joe Davison, Sam Shleifer, Patrick von Platen, Clara Ma, Yacine Jernite, Julien Plu, Canwen Xu, Teven Le Scao, Sylvain Gugger, Mariama Drame, Quentin Lhoest, and Alexander Rush. 2020. Transformers: State-of-the-art natural language processing. In Proceedings of the 2020 Conference on Empirical Methods in Natural Language Processing: System Demonstrations, pages 38-45, Online. Association for Computational Linguistics.
+
+# A Hyperparameters
+
+For each of the tasks, we performed hyperparameter search in the following space:
+
+- Learning rate is chosen from the set  $\{10^{-2}, 3 \cdot 10^{-3}, 10^{-3}, 3 \cdot 10^{-4}, 10^{-4}, 3 \cdot 10^{-5}\}$ ,  
+- Number of epochs is chosen as either 10 or 20. This determines the behavior of the slanted triangular learning rate scheduler.  
+- Initialization is performed either with the embedding of the [MASK] token, or randomly initialized from a normal distribution, with the mean and variance taken from the matrix of RoBERTa's word embeddings.
+
+The hyperparameter search took roughly 4 days on two Titan V GPUs. The final choices for each task are shown in Table 5. Initialization with [MASK] performed better than the random initialization.
+
+We disable all dropouts inside Transformer. We use huggingface implementation of AdamW optimizer with weight decay disabled. The gradient is normalized to the value 1.0. For the batch sampling we use bucketing with padding noise of 0.1. In order to use the device memory more effectively, we also set maximum number of tokens per batch to 2048. The maximum sequence length is truncated to 512 tokens. We enable mixed precision and pad all sequence lengths to the multiples of 8 for the effective usage of TensorCores<sup>8</sup>.
+
+# B Learned Tokens
+
+Table 6 lists the closest vocabulary words to the learned embeddings. Most tasks have two input sentences, so the prompts consist of three parts: one is added before the first sentence, the second one is added between the sentences and the third one is appended next to the second sentence. For the single-sentence tasks, the second and third parts of the prompt are simply concatenated. Each task has trainable verbalizer tokens, one per output class.
+
+The prompts of RTE, MRPC and STS-B are pretty similar to MNLI's prompts, as the models for these tasks were initialized from pretrained MNLI models. The other tasks were initialized with [MASK] tokens. The final model for CoLA didn't move too far from its initialization.
+
+$^{8}$ https://docs.nvidia.com/deeplearning/performance/mixed-precision-training/index.html
+
+<table><tr><td>Task</td><td>Learning rate</td><td>Epochs</td><td>Init.</td></tr><tr><td>MNLI</td><td>0.001</td><td>10</td><td>[MASK]</td></tr><tr><td>QNLI</td><td>0.001</td><td>10</td><td>[MASK]</td></tr><tr><td>QQP</td><td>0.0003</td><td>20</td><td>[MASK]</td></tr><tr><td>RTE</td><td>0.001</td><td>20</td><td>MNLI</td></tr><tr><td>SST-2</td><td>0.003</td><td>20</td><td>[MASK]</td></tr><tr><td>MRPC</td><td>0.001</td><td>20</td><td>MNLI</td></tr><tr><td>CoLA</td><td>0.001</td><td>20</td><td>[MASK]</td></tr><tr><td>STS-B</td><td>0.001</td><td>20</td><td>MNLI</td></tr></table>
+
+Table 5: Hyperparameters of our best-performing models. [MASK] means the prompts are initialized with the word embedding of same token, and MNLI means the prompt is initialized with the prompts of out best MNLI run.
+
+<table><tr><td rowspan="6">MNLI</td><td rowspan="3">Prompts</td><td>before</td><td>A-A-A-A-A-A-A-A-A-A-A-A-A-A-A-A-A-Tomorrow Ale .aGj * .</td></tr><tr><td>between</td><td>_MUCH irin [/ _a (@ [MASK] _dL aHJ E [MASK] _aKH</td></tr><tr><td>after</td><td>_&lt;!-_informing inyl _entit dim</td></tr><tr><td rowspan="3">Verbalizers</td><td>entailment</td><td>_categories</td></tr><tr><td>neutral</td><td>gomery</td></tr><tr><td>contradiction</td><td>Unless</td></tr><tr><td rowspan="5">QNLI</td><td rowspan="3">Prompts</td><td>before</td><td>*. _neigh [MASK] U {}</td></tr><tr><td>between</td><td>aG-aG- [MASK] olitan _pronouns [MASK] [MASK] [MASK] @@@[MASK]_Choi [MASK]</td></tr><tr><td>after</td><td></td></tr><tr><td rowspan="2">Verbalizers</td><td>entailment</td><td>_VIDE</td></tr><tr><td>not_ entailment</td><td>470</td></tr><tr><td rowspan="5">QQP</td><td rowspan="3">Prompts</td><td>before</td><td>_resembling_swarm_Calm_Membership</td></tr><tr><td>between</td><td>.derive rics [MASK] alias iary [MASK] _omnip [MASK] [MASK] [MASK] _sham</td></tr><tr><td>after</td><td>[MASK] _forb [MASK] _Firefly _THEY</td></tr><tr><td rowspan="2">Verbalizers</td><td>notDuplicate</td><td>ende</td></tr><tr><td>duplicate</td><td>_sugg</td></tr><tr><td rowspan="5">RTE</td><td rowspan="3">Prompts</td><td>before</td><td>A-A-A-A-A-A-A-A-A-A-A-A-A-A-A-A-Tomorrow ALE .aGj * .</td></tr><tr><td>between</td><td>_MUCH irin [/ _a (@ [MASK] _aHJ femin [MASK] _aK</td></tr><tr><td>after</td><td>ahiahi _informing # _entit OOOO</td></tr><tr><td rowspan="2">Verbalizers</td><td>entailment</td><td>e!</td></tr><tr><td>not_ entailment</td><td>_blames</td></tr><tr><td rowspan="5">SST-2</td><td rowspan="3">Prompts</td><td>before</td><td>choes _charms_sorely _&quot;akijakij</td></tr><tr><td>between</td><td>a ffe Pae _charred _masked [MASK] _Fall _babys _smartest ik /</td></tr><tr><td>after</td><td>dL forums _bio _mang A+</td></tr><tr><td rowspan="2">Verbalizers</td><td>negative</td><td>_defective</td></tr><tr><td>positive</td><td>很重要的</td></tr><tr><td rowspan="5">MRPC</td><td rowspan="3">Prompts</td><td>before</td><td>A-A-A-A-A-A-A-A-A-A-A-A-A-A-A-A-Tomorrow rison .aGj * .</td></tr><tr><td>between</td><td>_MUCH irin [/ _a jay [MASK] _dL aHJ femin [MASK] .?</td></tr><tr><td>after</td><td>_&gt; _informing # _entit OOOO</td></tr><tr><td rowspan="2">Verbalizers</td><td>entailment</td><td>_categories</td></tr><tr><td>neutral</td><td>gomery</td></tr><tr><td rowspan="5">CoLA</td><td rowspan="3">Prompts</td><td>before</td><td>[MASK] [MASK] [MASK] [MASK]</td></tr><tr><td>between</td><td>[MASK] [MASK] [MASK] [MASK] [MASK] [MASK] [MASK] [MASK] [MASK]</td></tr><tr><td>after</td><td>[MASK] [MASK] [MASK] [MASK] [MASK]</td></tr><tr><td rowspan="2">Verbalizers</td><td>unacceptable</td><td>_additionally</td></tr><tr><td>acceptable</td><td>o</td></tr><tr><td rowspan="3">STS-B</td><td rowspan="3">Prompts</td><td>before</td><td>A-A-A-A-A-A-A-A-A-A-A-A-A-A-A-A-A-A-A-A-A-A-A-A-A-A-A-A-A-A-A-A-A-A-A-A-A-A-A-A-A-A-A-A-A-A-A-A-A-A-A-A-A-A-A-A-A-A-A-A-A-A-A-A-A-A-A-A-A-A-A-A-A-A-A-A-A-A-A-A-A-A-A-A-A-A-A-A-A-A-A-A-A-A-A-A-A-A-A-A-A</td></tr><tr><td>between</td><td>_Kers irin [/ _a (@ [MASK] _dL AhAHAhAH femin [MASK] _aKH</td></tr><tr><td>after</td><td>A-A-A-A-A-A-A-A-A-A-A-A-A-A-A-A-A-A-A-A-A-A-A-A-A-A-A-A-A-A-A-A-A-A-A-A-A-A-A-A-A-A-A-A-A-A-A-A-A-A-A-A-A-A-A-A-A-A-A-A-A-A-A-A-A-A-A-A-A-A-A-A-A-A-A-A-A-A-A-A-A-A-A-A-A-A-A-A-A-A-A-A-A-A-A-A-A-A</td></tr></table>
+
+Table 6: The closest words to the prompt and verbalizer token embeddings for the best model for each task. We use cosine distance to measure the distance. [MASK] tokens highlighted in bold indicate the positions we use to output the prediction.

data/2021/2101_00xxx/2101.00133/full.md

@@ -1,3 +1,412 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:1271cc9d903a2caa7bedbe93ff0ab810be384af376f9cb4c1e8f6d0c58caac5a
-size 77046
+# NeurIPS 2020 EfficientQA Competition: Systems, Analyses and Lessons Learned
+
+<table><tr><td>Sewon Min2</td><td>SEWON@CS.WASHINGTON.EDU</td></tr><tr><td>Jordan Boyd-Graber3</td><td>JBG@UMIACS.umd.EDU</td></tr><tr><td>Chris Alberti1</td><td>CHRISALBERTI@google.com</td></tr><tr><td>Danqi Chen4</td><td>DANQIC@CS.PRINCETON.EDU</td></tr><tr><td>Eunsol Choi5</td><td>EUNSOL@CS.UTEXAS.EDU</td></tr><tr><td>Michael Collins1</td><td>MJCOLLINS@google.com</td></tr><tr><td>Kelvin Guu1</td><td>KGUU@google.com</td></tr><tr><td>Hannaneh Hajishirzi1</td><td>HANNANEH@CS.WASHINGTON.EDU</td></tr><tr><td>Kenton Lee1</td><td>KENTONL@google.com</td></tr><tr><td>Jennimaria Palomaki1</td><td>JPALOMAKI@google.com</td></tr><tr><td>Colin Raffel1</td><td>CRAFFEL@google.com</td></tr><tr><td>Adam Roberts1</td><td>ADAROB@google.com</td></tr><tr><td>Tom Kwiatkowski1</td><td>TOMKWIAT@google.com</td></tr></table>
+
+<sup>1</sup>Google Research, New York City, NY, USA; Mountain View, CA, USA; Seattle, WA, USA  
+$^{2}$ University of Washington, Seattle, WA, USA  
+<sup>3</sup> University of Maryland, College Park, MD, USA  
+4Princeton University, Princeton, NJ, USA  
+<sup>5</sup>University of Texas at Austin, Austin, TX, USA
+
+Patrick Lewis $^{T1}$ , Yuxiang Wu $^{T1}$ , Heinrich Kuttler $^{T1}$ , Linqing Liu $^{T1}$ , Pasquale Minervini $^{T1}$ , Pontus Stenetorp $^{T1}$ , Sebastian Riedel $^{T1,3}$ , Sohee Yang $^{T2}$ , Minjoon Seo $^{T2}$ , Gautier Izacard $^{T3,7}$ , Fabio Petroni $^{T3,7}$ , Lucas Hosseini $^{T3,7}$ , Nicola De Cao $^{T3}$ , Edouard Grave $^{T3,7}$ , Ikuya Yamada $^{T4}$ , Sonse Shimaoka $^{T4}$ , Masatoshi Suzuki $^{T4}$ , Shumpei Miyawaki $^{T4}$ , Shun Sato $^{T4}$ , Ryo Takahashi $^{T4}$ , Jun Suzuki $^{T4}$ , Martin Fajcik $^{T5}$ , Martin Docekal $^{T5}$ , Karel Ondrej $^{T5}$ , Pavel Smrz $^{T5}$ , Hao Cheng $^{T6}$ , Yelong Shen $^{T6}$ , Xiaodong Liu $^{T6}$ , Pengcheng He $^{T6}$ , Weizhu Chen $^{T6}$ , Jianfeng Gao $^{T6}$ , Barlas Oguz $^{T7}$ , Xilun Chen $^{T7}$ , Vladimir Karpukhin $^{T7}$ , Stan Peshterliev $^{T7}$ , Dmytro Okhonko $^{T7}$ , Michael Schlichtkrull $^{T7}$ , Sonal Gupta $^{T7}$ , Yashar Mehdad $^{T7}$ , Wen-tau Yih $^{T7}$
+
+$^{\mathrm{T1}}$ UCLNLP & Facebook AI;  $^{\mathrm{T2}}$ NAVER Clova;  $^{\mathrm{T3}}$ Facebook AI Paris & London;  
+$^{\mathrm{T4}}$  Studio Ousia, Tohoku University & RIKEN;  $^{\mathrm{T5}}$  Brno University of Technology;  
+$^{\mathrm{T6}}$  Microsoft Research & Dynamic 365 AI;  ${}^{\mathrm{T7}}$  Facebook AI
+
+Editors: Hugo Jair Escalante and Katja Hofmann
+
+# Abstract
+
+We review the EfficientQA competition<sup>1</sup> from NeurIPS 2020<sup>2</sup>. The competition focused on open-domain question answering (QA), where systems take natural language questions as input and return natural language answers. The aim of the competition was to build systems that can predict correct answers while also satisfying strict on-disk memory budgets. These memory budgets were designed to encourage contestants to explore the trade-off between storing retrieval corpora or the parameters of learned models. In this report, we describe the motivation and organization of the competition, review the best submissions, and analyze system predictions to inform a discussion of evaluation for open-domain QA.
+
+Keywords: Question answering, Memory efficiency, Knowledge representation
+
+# 1. Introduction
+
+Open-domain question answering (QA) is emerging as a benchmark method of measuring computational systems' abilities to retrieve, represent, and read knowledge (Voorhees and Tice, 2000; Chen et al., 2017; Seo et al., 2019; Lee et al., 2019). Recently, this task has been addressed by a diverse set of approaches that navigate multiple documents (Min et al., 2019b; Asai et al., 2019), index large corpora of text (Lee et al., 2019; Guu et al., 2020; Karpukhin et al., 2020), represent world knowledge in the parameters of a neural network (Roberts et al., 2020), or consolidate knowledge from multiple passages (Izacard and Grave, 2020). More comprehensive background is provided in Chen and Yih (2020).
+
+The EfficientQA competition, held at NeurIPS 2020, required contestants to build self-contained systems that contain all of the knowledge required to answer open-domain questions. There were no constraints on how the knowledge is stored—it could be in documents, databases, the parameters of a neural network, or any other form. However, the competition encouraged systems that store and access this knowledge using the smallest number of bytes, including code, corpora, and model parameters. Specifically, EfficientQA had four tracks: 1) best accuracy overall (unconstrained); 2) best accuracy, system size under 6GiB; 3) best accuracy, system size under 500MiB; 4) smallest system to get  $25\%$  accuracy. These memory budgets were designed to encourage contestants to explore the trade-off between storing and accessing large, redundant, retrieval corpora, structured data stores, or the parameters of large learned models.
+
+This paper summarizes the findings from the competition. Section 2 describes the competition in detail; Section 3 presents a description of the best performing submissions in each track; Section 4 introduces a new human evaluation of system accuracy, and Section 5 provides results and an analysis based on automatic and human evaluation. Finally, Section 6 pits the top systems against human trivia experts.
+
+# 1.1. Key takeaways
+
+The top submissions in each of EfficientQA's four tracks significantly outperformed the provided baselines. All top submissions use a retrieval corpus and a neural network answering module. However, the nature of the retrieval corpus and answering module differs drastically across the tracks (Table 1).
+
+<table><tr><td>Track</td><td>Model</td><td>Affiliation</td><td>retr</td><td>answer</td><td>others</td></tr><tr><td rowspan="4">Unrest- ricted</td><td>REALM</td><td>Organizers</td><td>p</td><td>ext</td><td></td></tr><tr><td>DPR</td><td>Organizers</td><td>p</td><td>ext</td><td></td></tr><tr><td>MS UnitedQA</td><td>Microsoft &amp; Dynamics 365</td><td>p</td><td>ext+gen</td><td></td></tr><tr><td>FB Hybrid</td><td>Facebook AI</td><td>p</td><td>gen</td><td>lists/tables</td></tr><tr><td rowspan="5">6GiB</td><td>DPR-subset</td><td>Organizers</td><td>p (pruned)</td><td>ext</td><td></td></tr><tr><td>T5-XL+SSM</td><td>Organizers</td><td>X</td><td>gen</td><td></td></tr><tr><td>FB system</td><td>FAIR-Paris&amp;London</td><td>p (pruned)</td><td>gen</td><td>lists, lrzip compression</td></tr><tr><td>Ousia-Tohoku Soseki</td><td>Studio Ousia, Tohoku U &amp; RIKEN</td><td>p (pruned)</td><td>ext</td><td>ZPAQ compression</td></tr><tr><td>BUT R2-D2</td><td>Brno U of Technology</td><td>p (pruned)</td><td>ext+gen</td><td></td></tr><tr><td rowspan="3">500MiB</td><td>T5-Small+SSM</td><td>Organizers</td><td>X</td><td>gen</td><td></td></tr><tr><td>UCLNLP-FB system</td><td>UCL &amp; FAIR</td><td>(q,a)</td><td>-</td><td>data augmentation</td></tr><tr><td>NAVER RDR</td><td>NAVER Clova</td><td>p (pruned)</td><td>ext</td><td>single Transformer</td></tr><tr><td rowspan="2">25% smallest</td><td>T5-XL+SSM</td><td>Organizers</td><td>X</td><td>gen</td><td></td></tr><tr><td>UCLNLP-FB system (29M)</td><td>UCL &amp; FAIR</td><td>(q,a)</td><td>-</td><td>data augmentation</td></tr></table>
+
+Table 1: A list of the baselines and systems from participants, along with the team affiliation and key distinction between systems. retr means what the systems retrieves, e.g., passages  $(p)$ , question-answer pairs  $((q, a))$ , or none (X). pruned indicates the Wikipedia corpus is pruned. answer indicates whether the answer is extracted (ext) or generated (gen). Other key distinctions are shown in the last column.
+
+Unrestricted and 6GiB tracks The top submissions to the unrestricted track and the 6GiB track (Section 3.1; 3.2) outperformed the state-of-the-art baselines from April 2020 by nearly  $20\%$ . They achieved this improvement by combining the state-of-the-art retrieval systems (Karpukhin et al., 2020; Mao et al., 2020) with answer generation (Izacard and Grave, 2020); leveraging the state-of-the-art in text generation (Raffel et al., 2020) and text encoding (Clark et al., 2020); modeling not only text but also tables and lists from Wikipedia; and combining the extractive and generative answer prediction. The top submissions to the 6GiB track additionally massively reduced the size of their indexed corpus and made use of the state-of-the-art in compression, with minimal impact on accuracy.
+
+500MiB and smallest tracks To get under 500MB (Section 3.3), the systems made more drastic changes. The submission from Naver Clova drastically reduced the size of their indexed corpus and reused a single Transformer model for the retriever and the reader, winning the 500MiB track according to the human evaluation. The even smaller UCLNLP-FB system took a novel approach in generating a large corpus of question-answer pairs, indexing it, and retrieving the most similar question to the input question. This approach, with two systems with different sizes in question-answer corpus, won both the 500MiB track and the smallest  $25\%$  track according to the automatic evaluation.
+
+Automatic vs. human evaluation The human evaluation supports the observation that automatic metrics often incorrectly penalize correct predictions in the open-domain setting (Voorhees and Tice, 2000; Roberts et al., 2020). We also investigate the effect of question ambiguity on evaluation—the questions from NQ are often ambiguous without the associated evidence document (Min et al., 2020). In Section 4 we define an annotation
+
+scheme that supports multiple estimations of accuracy, corresponding to different definitions of correctness for answers to ambiguous questions. Almost all systems' accuracy increased by  $20\% - 25\%$  under the strictest definition of correctness. The increase doubled when we relaxed the definition of correctness to permit any semantically valid interpretation of the question. We present a discussion as well as suggestions for future evaluation (Section 5.2).
+
+# 2. Competition Overview
+
+Data The competition uses English questions and answers from the Natural Questions dataset (Kwiatkowski et al., 2019, NQ): real user questions issued to the Google search engine, along with reference answers from Wikipedia<sup>3</sup>. Real user questions in NQ are interpretable outside of a document context (unlike SQuAD (Rajpurkar et al., 2016)), and less amenable to traditional IR approaches than over-complete trivia questions (Joshi et al., 2017), as discussed in Lee et al. (2019). While the original NQ task was posed as a reading comprehension task, in which evidence documents are provided, recent work has adapted the NQ data to the open-domain setting (Lee et al., 2019; Min et al., 2019a,b; Asai et al., 2019; Guu et al., 2020; Roberts et al., 2020; Karpukhin et al., 2020) by taking examples with short answers (up to five tokens) and discarding evidence documents. In the open-domain setting, NQ contains 88k one-way annotated training examples and 4k five-way annotated development examples. For EfficientQA, we introduce a new test and development set constructed in the same way as the original NQ, but labeled slightly after (early 2019 rather than through 2018).<sup>4</sup> Our test set was kept hidden from contestants, and submissions were made by uploading solutions to an automatic leaderboard.
+
+System size All submissions to the three restricted tracks were submitted as self-contained Docker<sup>5</sup> images. We defined system size to be the on-disk, at-rest size of this image. We chose this approach to avoid confusion about distinctions between data, model parameters, and code. However, this choice did lead to a significant engineering efforts for the very smallest systems, which were not able to build on the standard Docker templates for the predominant deep-learning libraries. While the organizers did provide a small reference system based on T5 (Roberts et al., 2020) that used TensorFlow serving<sup>6</sup>, this did not support most submissions, and the very smallest systems required clever compilation strategies on top of their modeling enhancements.
+
+Evaluation metrics We measured the performance of different systems through automatic and human evaluation. For automatic evaluation, the accuracy of each systems' predicted answers is judged against reference annotations, annotated by five human workers. We follow the literature in using exact match between predicted and reference answers after minor normalization (Lee et al., 2019). Due to the ambiguities inherent in language and question-answering in general, five reference answers are often not exhaustive, and systems predict correct answers that are judged incorrect according to the automatic metrics.
+
+![](images/323c2ec06be645f3a4f5ab00edadc8332d1a021d207d615dd8568393dd840d64.jpg)  
+Figure 1: Memory footprint of each system component.
+
+To rectify this, we sent predictions from each of the systems for further human rating by three raters, to get a better estimation of accuracy, as detailed in Section 4.
+
+Competition schedule The competition was announced in June 2020, along with baselines and tutorials. The official leaderboard for restricted settings was launched on September 14th, 2020, and participants had two months to submit their systems (November 14th, 2020). Finally, predictions from the top systems from each leaderboard were sent for human evaluation, which was completed in the end of November. The same set of top systems was invited to present their systems at the NeurIPS event on December 12th and in this paper. The human vs. computer competition was held on December 6th (details in Section 6).
+
+In total, we had 39 submissions from 18 unique teams, seven of which were affiliated or co-affiliated with universities.
+
+# 3. Systems
+
+We describe a set of provided baselines and systems from participants. Systems from participants include the top 1-3 submissions per track based on automatic measure, considering margins between the submissions. Table 1 summarizes the key distinctions between the systems, and Figure 1 shows the memory footprint of each system component.
+
+# 3.1. Unconstrained track
+
+Both of the top two submissions make use of the previous state-of-the-art system, such as DPR (Karpukhin et al., 2020) and a generative reader (Izacard and Grave, 2020). They are greatly enhanced by a better training objective, aggregating the answers from the extractive and generative models, or incorporating lists and tables from Wikipedia.
+
+Baselines: REALM/DPR Both REALM (Guu et al., 2020) and DPR (Karpukhine et al., 2020) use the retrieval-reader framework. They retrieve the top  $K$  passages from Wikipedia by mapping the question and each passage to dense vectors and employing a maximum inner product search. The top  $K$  passages are then fed into an extractive reader which predicts the start and the end position of the answer. A key distinction between REALM and DPR is that REALM is trained with a self-supervised, joint objective, while DPR is trained in a pipeline manner with gold positives and distantly supervised negatives.
+
+MS UnitedQA The UnitedQA system consists of three components: Retrieval, Reading, and Re-ranking. First, it uses DPR to fetch top 100 passages from the English Wikipedia dump for a given question. Second, a hybrid approach, combining both generative and extractive readers, is used to produce answer candidates from the collection of retrieved passages. The generative reader is Fusion-in-Decoder (Izacard and Grave, 2020) based on T5 (Raffel et al., 2020), and the extractive reader is based on ELECTRA (Clark et al., 2020). Several techniques are applied to facilitate the training of the readers: posterior differential regularization (PDR, Cheng et al. (2020b), improved loss-term (Cheng et al., 2020a) are explored for the extractive model, and adversarial training (Ju et al., 2019) approach, attention bias (Lewis et al., 2020a) for the generative model. At the final re-ranking stage, it combines the generative and extractive model predictions with linear interpolation, and produce the final answer. More details of the system can be found in Cheng et al. (2021).
+
+FB Hybrid This system uses a retriever-reader architecture. The retriever is a combination of DPR and Generation Augmented Retrieval (GAR) (Mao et al., 2020), where each of them retrieves 50 passages. The DPR encoders are trained iteratively, where better hard negatives are mined at each step using the model at the previous step—two iterations are found to be sufficient. Its dense index includes lists and tables, as well as regular text passages. Specifically, 455907 tables and infoboxes are processed from the NQ training corpus using a trivial linearization, which concatenates the text representation of each row with a newline character.<sup>7</sup> Tables are chunked at 100 tokens with the header included in each chunk. The reader is Fusion-in-Decoder based on T5-large, which is given 100 passages from the retriever and generates an answer. More details of the system are in Oguz et al. (2020).
+
+# 3.2. 6GiB track
+
+For this track, we provided two baselines. One retrieval-based, and one generative model. However, all of the top three submissions are retrieval-based, and reduce the memory footprint by drastically pruning the Wikipedia corpus, either by a learned model or based on a page view. They also made use of model quantization and the state-of-the-art in compression to limit their system's footprint. They additionally enhanced the previous state-of-the-art as done in an unrestricted track.
+
+Retrieval-based baseline: DPR-subset We create a variant of DPR with pruned Wikipedia. Specifically, we only keep passages from the pages that are paired with the questions on the training set of NQ, reducing the number of passages from 21M to 1.6M.
+
+Generative baseline: T5-XL+SSM T5 (Raffel et al., 2020) is a text-to-text Transformer language model utilizing an encoder-decoder architecture that was pre-trained using a "span corruption" objective on Common CWEl. This approach is based on Roberts et al. (2020) which demonstrated a "closed-book" setting where the model was only able to access the knowledge stored in its parameters after fine-tuning on the task. Following Roberts et al. (2020), the model is additionally pre-trained using a "salient span masking" objective (Guu et al., 2020) before fine-tuning. The XL model has approximately 3B parameters.
+
+FB system This system is based on a retriever-reader approach. The retriever is an ensemble of a dense retriever and GAR. The dense retriever is initialized from BERT-base and is trained by distilling the cross-attention scores of the reader. GAR (Mao et al., 2020) is a retriever with generative query augmentation, based on BM25. The Lucene $^8$  index is built on the fly. The reader is Fusion-in-Decoder initialized from T5 large.
+
+The text corpus initially included 26M passages including the plain text and the lists, but went through an article-level filtering to include 18.8M passages. Specifically, it uses a linear classifier where each Wikipedia article is represented by its title and list of categories.
+
+The model weights are stored using float16, taking 1.6GB of memory. The dense index is compressed by relying on three strategies, described in Izacard et al. (2020): 1) the vector representations go through dimension reduction from 768 to 256, 2) they are further quantized through product quantization, using 2 bits per dimension, and 3) the text of Wikipedia is compressed using  $\mathrm{lrzip}^9$ .
+
+Ousia-Tohoku Soseki Soseki is an open-domain QA system that adopts a two-stage approach consisting of Retriever for passage retrieval, and Reader for reading comprehension. Given a question, Retriever obtains top-k candidate passages from Wikipedia. Then, Reader selects the most relevant passage from them and extracts an answer from the passage.
+
+Retriever is based on a re-implementation of DPR, where two BERT-base-uncased models are used to embed questions and passages. We also quantize passage embeddings to reduce the system size. Embeddings of Wikipedia passages are precomputed and stored using Faiss (Johnson et al., 2017). Reader is a reading comprehension model based on ELECTRA-large (Clark et al., 2020). We added one dense layer for selecting the most relevant passage, and two dense layers for detecting the start and end positions of the answer. All modules are trained on the NQ dataset.
+
+To reduce the system size under 6GB, we compressed the models, passages, and other data files using ZPAQ $^{10}$  and excluded Wikipedia passages with less than 40 monthly page views, resulting in 18M passages. These tricks do not drop the accuracy.
+
+BUT R2-D2 R2-D2 is composed of a dense retriever, a re-ranker and two readers. The dense retriever is based on RoBERTa (Liu et al., 2019) and is trained via an objective known from DPR. It retrieves  $K = 400$  passages from a pruned version of Wikipedia, reduced from 21M to 1.6M passages. Pruning is done via a simple binary classifier based on RoBERTa trained on the data created from the golden passages and negative passages randomly sampled from the index. This classifier obtains  $90.2\%$  accuracy. The re-ranker (based on Longformer (Beltagy et al., 2020)) concatenates retrieved passages, assigns a score for each passage, and selects  $V = 20$  passages. The extractive reader (based on ELECTRA) reads  $V$  passages in a similar way as in Fajcik et al. (2020). It is trained via the marginal likelihood objective combined with the compound objective. The generative reader follows the Fusion-in-Decoder schema and generates the answers. R2-D2 aggregates the output from these two readers using two fusioning methods. First, it reranks the top spans from the extractive reader by feeding them to a generative reader and combines its log likelihood with the log likelihood from the extractive reader through a linear combination. They
+
+are then further aggregated with abstractive answers from the generative reader that are generated independently, through another linear combination. The parameters are stored in float16 and compressed using ZIP. More details of the system are in Fajcik et al. (2021).
+
+# 3.3. 500MiB track
+
+The top performing submissions in this track made more drastic changes to get under 500MiB. They have completely different approaches from each other.
+
+Baseline: T5-Small+SSM This is a smaller version of the T5-XL+SSM baseline above, with 512 hidden dimension instead of 4096, 6 layers instead of 24, and 8 attention heads instead of 64. It contains 60M parameters in total.
+
+UCLNLP-FB system This system is based on the approach from Lewis et al. (2020c), consisting of a database of question-answer pairs and a retriever which returns the answer of the most similar stored question to an input question. This approach is attractive as it performs well using low parameter-count models, and less space is needed to store question-answer pairs than full Wikipedia passages.
+
+The Question-Answer Pair Generator is similar to Alberti et al. (2019); Lewis et al. (2019). First, a passage selection model  $P(c)$  is trained to identify appropriate passages from Wikipedia. For high-probability passages (w.r.t.  $P(c)$ ), the system performs Named Entity Recognition to extract likely answers  $a$ , and generates questions  $q$  from  $(c, a)$  using a BART (Lewis et al., 2020b) model  $P(q \mid a, c)$  fine-tuned on NQ. Finally, the system filters question-answer pairs with a "global consistency filter"—if an open-domain QA system (Izacard and Grave, 2020) is given  $q$  and generates an answer that is consistent with  $a$ , the  $(q, a)$  pair is added to the database. This is because generated  $(q, a)$  pairs are sometimes incorrect or unanswerable without the passage they were generated from. The final database consists of NQ, the EfficientQA development set and 2.3M generated question-answer pairs. The Retriever consists of TF-IDF and a bi-encoder retriever based on ALBERT-base (Lan et al., 2020). The Reranker is a cross-encoder module based on ALBERT-large; it reranks the top-10 question-answer pairs from the retriever, and the answer of the top-1 question-answer pair is chosen as the final answer.
+
+The system is further compressed using TFLite, quantization, and Alpine Linux. More details can be found from Lewis et al. (2021).
+
+NAVER RDR RDR is a lightweight retrieve-and-read system, consisting of a single Transformer (MobileBERT (Sun et al., 2020)) that performs both retrieval and reading, an index of dense passage vectors and the filtered Wikipedia corpus. The Transformer serves as a dense retriever as DPR does with two differences: (1) a single Transformer is used to encode both the question and the passage, and (2) the embeddings are defined as the first 128 out of 512 dimensions of the output vectors from the Transformer that correspond to the [CLS] token. The same Transformer serves as an extractive reader by producing the scores of the start and the end of the answer span as well as the passage reranking score. A distillation technique is used for training, by minimizing the KL divergence between its start, end, and reranking scores and those of a fully trained DPR reader. The Transformer is further finetuned in an iterative manner as a retriever and as a reader.
+
+The index consists of 1.2M 128-dimensional INT8 vectors (scalar-quantized and unsigned), which are the dense embeddings of the subset of the 21M passages in Wikipedia, filtered by a RoBERTa (Liu et al., 2019)-based binary classifier trained with logistic regression to exclude uninformative passages. Positives to train this classifier are the top 200 passages for each question on NQ dataset and EfficientQA development set, retrieved by Yang and Seo (2020), a DPR retriever further finetuned on hard negatives using knowledge distillation from a DPR reader. Negatives are uniformly drawn from the set of 21M passages, excluding positives. More details can be found from Yang and Seo (2021).
+
+# 3.4.  $25\%$  smallest track
+
+Baseline: T5-XL+SSM Among the provided baselines, the smallest system with an accuracy of over  $25\%$  is T5-XL+SSM, the same system described in Section 3.2. This system is 5.65GB and achieves an accuracy of  $28\%$ .
+
+UCLNLP-FB system (29M) This system is the same system as UCLNLP-FB system in the 500MiB track with following minor modifications, to further decrease the memory: (1) the retriever is just TF-IDF instead of a combination of TF-IDF and a bi-encoder, (2) the reranker uses ALBERT-base instead of ALBERT-large, and (3) there are 40k generated question-answer pairs, instead of 2.3M.
+
+# 4. Human Annotations of Correctness
+
+The EfficientQA development and test sets have up to five reference answers per question. Due to the variability of language, these five answer strings are often not exhaustive, and systems predict correct answers that are judged incorrect according to the automatic metrics. To rectify this, we sent predictions from each of the systems in Section 3 for human rating to get a better estimation of accuracy.
+
+Each system prediction was sent for rating by three separate annotators: 1) the annotator first works on understanding the meaning and intent of the question (with a web search if necessary). 2) The annotator then determines whether the question is ambiguous, i.e., whether the question can lead to multiple different answers depending on factors such as: when the query was asked; where the query was asked; some unspoken intent of the questioner; or the opinion of the person giving the answer. 3) Finally, the annotator determines whether each answer is "definitely correct" (correct given a usual interpretation of the question), "possibly correct" (could be correct, given some interpretation of the question), or "definitely incorrect".
+
+Since the original NQ data was collected more than a year before the start of the EfficientQA competition, the denotation of some questions may have changed over time (e.g. "who won the last season of bake-off"). Rather than determine a single correct point in time for these questions, we asked our annotators to assume that the query could have been asked at any time since the web has existed and choose the "possibly correct" label for answers that may or may not have been correct when the question was asked.
+
+The final rating is an aggregation of ratings from three annotators: if at least 2/3 raters determined it to be "definitely correct", the label is "definitely correct". If at least 2/3 raters determined it to be either "definitely correct" or "possibly correct", the label is "possibly
+
+<table><tr><td rowspan="2">Track</td><td rowspan="2">Model</td><td rowspan="2">Automatic eval</td><td colspan="2">Human eval</td></tr><tr><td>Definitely</td><td>Possibly</td></tr><tr><td rowspan="2">Unrestricted</td><td>MS UnitedQA</td><td>54.00</td><td>65.80 (+21.9%)</td><td>78.12 (+44.7%)</td></tr><tr><td>FB Hybrid</td><td>53.89</td><td>67.38 (+25.0%)</td><td>79.88 (+48.2%)</td></tr><tr><td rowspan="3">6GiB</td><td>FB system</td><td>53.33</td><td>65.18 (+22.2%)</td><td>76.09 (+42.7%)</td></tr><tr><td>Ousia-Tohoku Soseki</td><td>50.17</td><td>62.01 (+23.6%)</td><td>73.83 (+47.2%)</td></tr><tr><td>BUT R2-D2</td><td>47.28</td><td>58.96 (+24.7%)</td><td>70.33 (+49.2%)</td></tr><tr><td rowspan="2">500MiB</td><td>UCLNLP-FB system</td><td>33.44</td><td>39.40 (+17.8%)</td><td>47.37 (+41.7%)</td></tr><tr><td>NAVER RDR</td><td>32.06</td><td>42.23 (+31.7%)</td><td>54.95 (+71.4%)</td></tr><tr><td>25% smallest</td><td>UCLNLP-FB system (29M)</td><td>26.78</td><td>32.45 (+21.2%)</td><td>41.21 (+53.9%)</td></tr></table>
+
+Table 2: Summary of the result. For human evaluation result, relative improvements over the automatic evaluation are indicated in parenthesis. Following our analysis of the annotations, we use 'Definitely correct' human ratings as a primary metric.
+
+correct". The pairwise agreements of the human ratings are  $69.2\%$  (Cohen's  $\kappa = 53.8$ ) for 3-way ratings,  $85.7\%$  (Cohen's  $\kappa = 71.4$ ) for whether the prediction is definitely correct or not, and  $76.7\%$  (Cohen's  $\kappa = 53.4$ ) for whether the prediction is possibly correct or not.[11]
+
+# 5. Results & Analyses
+
+# 5.1. Results
+
+All of the five systems in the unrestricted track and the 6GiB track significantly outperform the state-of-the-art (Table 2) at the beginning of the competition—DPR  $(36.6\%)$  and REALM  $(35.9\%)$ . Systems in the 6GiB track approach the unrestricted track's accuracy; for instance, the accuracy FB system is comparable to the accuracy of the top systems in the unrestricted track. The improvements in the  $500\mathrm{MiB}$  track are also impressive; both the top two systems significantly beat T5-small  $(17.6\%)$ .
+
+Discrepancy between automatic eval and human eval Human raters find  $13\%$  and  $17\%$  of the predictions that do not match the reference answers to be definitely correct or possibly correct, respectively, overall increasing the accuracy of the systems. Most systems showed  $17 - 25\%$  and  $41 - 54\%$  improvement in accuracy when using definitely correct and possibly correct human evaluation respectively, compared to automatic evaluation metric which only consider exact string match to existing reference answers. An exception is Naver RDR, which achieves significantly larger improvements (  $32\%$  and  $71\%$ , respectively). We also found that when the gap in automatic measure between systems is marginal (around or smaller than  $1\%$ ), human evaluation may change the rankings between the models.
+
+Agreement between system predictions Figure 2 (left) shows the agreement between system predictions, based on exact match in automatic evaluation. The largest agreement is made between FB Hybrid and FB system, likely because they are both based on DPR and Fusion-in-Decoder. Agreements between systems in the unrestricted and the 6GiB tracks
+
+![](images/71963c2560f39c554bf42334002d9d9ebb3e20d6a2ed32519ac37ffe2c32fa40.jpg)  
+Figure 2: (Left) Agreement between system predictions. (Right) Ensemble oracle accuracy, which considers a prediction correct if at least one of the system predictions is correct (based on "definitely correct" human evaluation).
+
+![](images/0ae505156d4ab051cc7bd338dcb20b84d81d79554499060fc3a96fcab53abf31.jpg)
+
+are generally higher, likely because they are all based on retrieval-reader framework and pruning Wikipedia does not hurt too much. Two systems in the 500MiB track have smaller agreement with the other systems, and agree with each other even less.
+
+Ensemble oracle accuracy of the systems Figure 2 (right) reports the ensemble oracle accuracy for each system pair, which considers a prediction to be correct if either system prediction is correct. The FB Hybrid & Ousia-Tohoku Soseki pair achieves the highest ensemble oracle accuracy, indicating that their system predictions are substantially different from each other compared to other pairs with top performing systems.
+
+# 5.2. Analyses
+
+We present an analysis of the 50 sample questions where at least one prediction does not match with the gold answer, but is judged as correct by human raters, with a "definitely correct" label or a "possibly correct" label, respectively. The samples are largely divided into three classes: as valid as gold (judged as either definitely correct or possibly correct), valid but not the best (judged as possibly correct), and closer to invalid (judged as possibly correct). We describe fine-grained categories and their percentage $^{12}$ (definitely correct and possibly correct) here, with examples shown in Appendix A (Table 7).
+
+The following describes categories on predictions that are as valid as the gold answers.
+
+- Semantically the same (60%, 22%): The prediction is semantically equivalent to the gold, e.g., "about 930 BCE" and "around 930 BCE".<sup>13</sup>  
+- Open-ended question (6%, 4%): There is a large set of distinct, plausible answers, mainly because the question is vague or open-ended.  
+- Ambiguous entity/event references (20%, 20%): There is a set of distinct answers because the question contains ambiguous references of entities or events. For instance,
+
+"Gold woman" in the example in Table 7 may refer to the fictional character ("Ayesh") or the actress ("Elizabeth Debick").
+
+- Different granularity (14%, 6%): The prediction and the gold answer have different granularity, such as the year (1982) vs. the month (October 1982), or the city (Pawtucket) vs. the state (Rhode Island).  
+- Incorrect gold (2%, 6%): The gold annotation is incorrect.
+
+The following describes categories on possibly correct predictions that are as valid but not the best answers.
+
+- Ambiguous answer type (20%): There is a unique entity or event that can be the answer to the question, but there is ambiguity on which exact text should be presented as the answer. For instance, both the episode title (“Somber News”) and the air date (“February 23 2013”) are the valid answer to the question in Table 7.  
+- Answer is time-dependent (18%): The answer depends on the time of the question being asked. Questions in this category usually involve recurring events such as sports games or elections.
+
+Finally, we present categories for predictions that are closer to invalid answers.
+
+- Conflicting information in Wikipedia (4%): While the gold is the only valid answer, the English Wikipedia contains incorrect information that supports that prediction is the answer to the question. Consider the question in Table 7. While “Fort Hood” is an incorrect answer by a fact, the Wikipedia page<sup>14</sup> states “Fort Hood is the most populous U.S. military installation in the world.”<sup>15</sup>  
+- Plausible only in certain conditions (4%): Prediction may be valid in certain conditions, but is incorrect in general cases. For instance, for the question in the table, "president of India" may only be valid in India.  
+- Mismatch with question intent (8%): The prediction is somewhat valid but supposedly not the intended answer to the question. For instance, the example question in Table 7 is supposedly asking for the answer that is different from the great depression.  
+- Incorrect prediction (2%): The prediction is definitely incorrect.
+
+Our two main takeaways are as follows. First, the automatic evaluation confirms the observation of Voorhees and Tice (2000) that it is insufficient in capturing semantically equivalent answers, which are responsible for  $60\%$  of the definitely correct predictions. Second, ambiguity arises frequently in the questions in different levels, allowing multiple, semantically different answers to be valid. This is a consistent with Min et al. (2020), which reported that around half of the questions in NQ contain ambiguity, due to ambiguous references of entities, events or properties, or time-dependency of the answer. Based on our human evaluation, annotations on ambiguity have low agreement rate ( $61.3\%$ , Cohen's  $\kappa = 22.6$ ), and predictions with the same level of plausibility are often marked as "definitely correct" or "possibly correct" by different human raters. We note the notions of
+
+<table><tr><td rowspan="2">Model</td><td colspan="2">All</td><td colspan="2">Unambiguous Qs</td></tr><tr><td>Definitely</td><td>Possibly</td><td>Definitely</td><td>Possibly</td></tr><tr><td>MS UnitedQA</td><td>65.80</td><td>78.12</td><td>78.24</td><td>81.18</td></tr><tr><td>FB Hybrid</td><td>67.38</td><td>79.88</td><td>82.65</td><td>85.59</td></tr><tr><td>FB system</td><td>65.18</td><td>76.09</td><td>79.12</td><td>81.47</td></tr><tr><td>Ousia-Tohoku Soseki</td><td>62.01</td><td>73.83</td><td>72.94</td><td>75.00</td></tr><tr><td>BUT R2-D2</td><td>58.96</td><td>70.55</td><td>69.71</td><td>72.06</td></tr><tr><td>UCLNLP-FB system</td><td>39.40</td><td>47.37</td><td>42.06</td><td>43.24</td></tr><tr><td>NAVER RDR</td><td>42.23</td><td>54.95</td><td>49.71</td><td>53.24</td></tr><tr><td>UCLNLP-FB system (29M)</td><td>32.45</td><td>41.21</td><td>28.53</td><td>30.29</td></tr></table>
+
+Table 3: Human evaluation on the original set and a subset of unambiguous questions.
+
+"correctness" and "plausibility" are not binary, and are instead often dependent on pragmatic interpretation of the questioner's intent. For example, the question "who has the most superbowl rings" could be read as "which person (including coaches) has the most superbowl rings", "which player has the most superbowl rings", "which team has the most superbowl rings". All three annotators identified this question as being ambiguous but they disagreed about the validity of the different readings. The three raters were split three ways when rating the correct answer ("Pittsburgh Steelers") for the last interpretation. Meanwhile there were no "incorrect" ratings, and 2/3 "definitely correct" ratings given to the correct answer ("Tom Brady") for the second interpretation, despite the fact that two coaches have more superbowl rings. Clearly, the annotators are applying some personal interpretation of the questioner's intent and answer plausibility.
+
+While we believe that many real world questions do require some non-literal assumptions about the questioner's intent, and we believe that the natural language processing community should not shy away from that task, we also acknowledge that there is work to be done in creating better, non-binary, definitions of correctness. Section 6 contrasts these interpretations of correctness with the more rigid definition used by the Trivia community.
+
+Performance on unambiguous questions To better understand the effect of ambiguity on the ranking of different solutions, we also evaluate system performance on a subset of the questions that are unambiguous. We define unambiguous questions to be those that (1) have at least three out of five reference answers contain valid short answers $^{16}$ , and (2) are not labeled as ambiguous by any of three human raters, resulting in  $51.5\%$  of the original set. Table 3 shows human evaluation on the original set and this subset of unambiguous questions. Most systems, except UCLNLP-FB system, achieve higher accuracy on unambiguous questions, with the first three systems achieving over or near  $80\%$ . Unsurprisingly, the gap between "definitely correct" accuracy and "possibly correct" accuracy is marginal on unambiguous questions.
+
+Importantly, the overall rankings are unchanged when we restrict our evaluation set to only unambiguous answers. This suggests that, while question ambiguity may lead to disagreement between annotators at a per-example level, it is not adversely impacting our ability to consistently rank solutions. More analyses can be found in Appendix A.
+
+![](images/8dc9e401e1d47b6ee66a0419452da15c11c9b6289e0093717e9e6d92aee45092.jpg)  
+Figure 3: (Left) Screenshot from our final game between computer systems and trivia experts. Full videos of the human-computer competition are available at https://go.umd.edu/2020eqa. (Right) The human-computer competition is broken into three phases, where each phase allows the participants to use more resources. While most questions were answered in Phase 1 (where humans had a distinct advantage), in Phase 2 computers had a slight advantage; there were diminishing returns in Phase 3.
+
+![](images/4a8cdcd0d4c526e3197906bd5a3a31bcfded8fc35b3b96a8837592794f722291.jpg)
+
+# 6. Trivia Experts vs Computer Systems
+
+The questions in NQ are posed by humans to computers, and the competition attracted some of the strongest and most efficient QA systems available today. However, humans also answer questions for fun and recreation (Jennings, 2006) and the ultimate goal of artificial intelligence is to create machines that answer questions as well as humans (Turing, 1995, known as the Turing test). Moreover, existing comparisons of human question answering ability often use unskilled humans (Rajpurkar et al., 2016), leading to claims of computers "putting millions of jobs at risk" (Cuthbertson, 2018). Or, in competitions with trivia experts (Ferrucci et al., 2010), arcane rules of competitions can tilt the playing field toward computers (Boyd-Graber and Borschinger, 2020) or use unnatural questions (Boyd-Graber et al., 2012; Rodriguez et al., 2019).
+
+# 6.1. A Fair Comparison
+
+We advertised our competition to trivia enthusiasts on social media. Teams of up to eight players applied to be part of the competition. We selected five teams to participate in the preliminary competition (results in Section 6.2).
+
+To create a fair competition and to showcase all of the tiers of the efficient QA competition, we offered three ways to answer each question where either humans or computers have more resources to answer a question (Table 4).
+
+To complement the 500MiB systems, humans had to instantly signal when they knew the answer to a question. This reflects instant recall of a fact by a single individual. In the next phase in competition with the 6GiB systems, both humans and computers had more resources: the human team could discuss the answer for thirty seconds, arguing why they believe their answer is correct and computers had over ten times the memory. Finally, to focus one reading comprehension, unlimited systems faced off against the human teams who also had access to snippets from search results using the question as a query. As with the previous phase, they have thirty seconds to discuss their answer.
+
+We selected questions for the human eval based on the following criteria:
+
+<table><tr><td>Phase</td><td>Human</td><td>Computer</td><td>Points</td></tr><tr><td>1</td><td>Single player “buzz in”</td><td>500MiB</td><td>3</td></tr><tr><td>2</td><td>Team discussion</td><td>6GiB</td><td>2</td></tr><tr><td>3</td><td>Team discussion w/ search results</td><td>Unlimited</td><td>1</td></tr></table>
+
+Table 4: Phases of the human-computer competition. On odd questions the humans go first, while on even questions the computers go first. If neither team has a correct answer in a phase, we move on to the next phase.  
+
+<table><tr><td>Team</td><td>Margin</td></tr><tr><td>B</td><td>0.4 ppq</td></tr><tr><td>C</td><td>0.1 ppq</td></tr><tr><td>D</td><td>-0.1 ppq</td></tr><tr><td>A</td><td>-0.2 ppq</td></tr><tr><td>E</td><td>-0.6 ppq</td></tr></table>
+
+Table 5: Marin per question of the human teams at the preliminary competition.
+
+- Diverse over topic, ensuring there were questions about history, literature, philosophy, sports, and popular culture. This results in fewer questions about sports and popular culture than the standard NQ distribution.  
+- Not tied to 2018; we excluded questions that depend on the date being asked.  
+- Interesting questions. While not strictly adversarial, we wanted to showcase both human and computer ability, so we excluded questions that many humans would not know (e.g., "how many us states are there") or questions with answers that are difficult to evaluate in the NQ framework ("how many words are in Les Misérables?").  
+- To avoid the issues described in Section 4, we avoided questions that were overly ambiguous (answer changes based on time the question was asked, unclear answer type, mismatch with question intention, etc).
+
+Thus, for the human competition, we exclude the broader interpretation of correct adopted in Section 5.2 to a standard we called "actually correct", consistent with traditional trivia interpretations Jennings (2006). A human judge researched all of the answers to the questions and evaluated whether an answer was correct or not. This allows for more permissive answers lines such as "to pass away" to be accepted for questions like "what does it mean to cross over the rainbow bridge" even though the answer line only lists "heaven". Again, consistent with trivia best practice, we only required full names in the case of confusion (e.g., "Theodore Roosevelt" or "Franklin D. Roosevelt" instead of just "Roosevelt").
+
+# 6.2. Preliminary Competition
+
+To select which of the human teams faced off against the top computers in the final competition and to let the humans teams practice this unconventional format, we had the human teams face off against the baseline systems: T5 (500MiB), DPR (6GiB), and REALM (Unlimited).
+
+We set aside an hour for each team. Because better teams can get through more questions, to normalize comparisons per team, we computed the average margin per question (Table 5). Only two teams had higher scores than the computer baseline teams. The top team (Team B), which had multiple professors and trivia champions was clearly the best human team on this set of questions.
+
+# 6.3. Final Game
+
+The winning team (Team B) went up against the winning computer systems in a final match with fifty questions. Most questions were answered in Phase 1, and those that were not were typically answered in Phase 2 (Figure 3 (right)). Only four questions reached Phase 3; these questions that stumped both humans and computers:
+
+- Kimi no na wa what does it mean  
+- Who said there are old pilots and there are bold pilots  
+- What is the second largest city in ethiopia  
+Who said i'll make mincemeat out of you
+
+Of these questions, only the second largest city in Ethiopia was answered correctly (the humans were working through a list of cities in Ethiopia they knew). The other questions represent questions that cannot be answered by Wikipedia ("old pilots"), questions that require language capabilities beyond question answering ("kimi no na wa"), or that have a more nuanced answer than NQ can provide. For example, on the questions "who said i'll make mincemeat out of you", the human team reasonably thought that the question meant who originated the phrase, while NQ's answer was the cartoon character who is most associated with the phrase (Klondike Kat).
+
+# 6.4. Reflection
+
+For question answering, there are multiple interpretations of the phrase "human evaluation". Human evaluation of answers are important for exposing problems in the dataset, revealing ambiguity, and measuring whether the answers are useful. However, for the ultimate questions of where we have achieved artificial intelligence (Turing, 1995), we need fair comparisons with skilled humans. Moreover, to measure whether question answering systems are useful for people, we need to create socio-technical systems where humans and computers can answer questions together (Feng and Boyd-Graber, 2019). More importantly, trivia games are fun. They help illustrate the strengths and weaknesses of the underlying dataset and the QA methods with a spoonful of sugar to make otherwise dull evaluations more interesting.
+
+# 7. Conclusions and Future Work
+
+The EfficientQA competition was held to encourage research in open-domain question answering that focuses on both accuracy and memory footprint. All top performing submissions have a retriever-reader framework. Submissions to the unrestricted and the 6GiB track are enhanced over the state-of-the-art that retrieves a subset of Wikipedia passages and employs the extractive and/or generative answer modules; systems in the 6GiB track additionally cleverly select a small subset of Wikipedia, only marginally sacrificing accuracy when combined with state-of-the-art compression. In more restricted tracks, systems explore novel approaches and achieve impressive improvements over the baselines. They either generate a large corpus of question-answer pairs and retrieves the closest question to the input question, or dramatically filter Wikipedia and use a single Transformer model for
+
+retrieval and answer extraction. Still, they are behind the unrestricted systems in performance by  $20\%$ , indicating significant room for improvements in memory-restricted settings.
+
+A human analysis shows that automatic evaluations of QA systems are not sufficient for thorough evaluations. Human raters find  $30\%$  of the predictions that do not match reference answers but are nonetheless correct. This does not affect all systems equally: relative accuracy rises using definitely correct (between 18–32%) and possibly correct (between 42 and a whopping  $71\%$ ). The rise is mainly due to automatic evaluation failing to capture semantically equivalent answers, time-dependence of the answers, or underlying ambiguity in the questions (Min et al., 2020).
+
+Future work in efficient open-domain question answering should continue to explore the tradeoff between system size, accuracy, and abstaining (He et al., 2016; Rajpurkar et al., 2018). Moreover, it is important to continue to refine the quality of QA evaluation: not all annotation and not all annotators are created equal. Using trivia enthusiasts for annotation and human benchmarks is a fun and effective evaluation of relative computer QA ability. We would encourage future leaderboards to use some element of human verification in important evaluations (e.g., an annual bake off), removing ambiguity in questions (Min et al., 2020), crafting adversarial examples (Jia and Liang, 2017; Wallace et al., 2019; Dua et al., 2019; Bartolo et al., 2020), or evaluating whether a response is useful to a user (Fan et al., 2019; Feng and Boyd-Graber, 2019).
+
+# Acknowledgments
+
+We thank all the participants for taking part and making this a successful competition. We thank Google for providing prizes for computer participants. Boyd-Graber is supported by NSF Grant IIS-1822494. Any opinions, findings, conclusions, or recommendations expressed here are those of the authors and do not necessarily reflect the view of the sponsor.
+
+# References
+
+Chris Alberti, Daniel Andor, Emily Pitler, Jacob Devlin, and Michael Collins. Synthetic QA corpora generation with roundtrip consistency. In Proceedings of the Annual Meeting of the Association for Computational Linguistics, July 2019.  
+Akari Asai, Kazuma Hashimoto, Hannaneh Hajishirzi, Richard Socher, and Caiming Xiong. Learning to retrieve reasoning paths over wikipedia graph for question answering. In Proceedings of the International Conference on Learning Representations, 2019.  
+Max Bartolo, A. Roberts, Johannes Welbl, Sebastian Riedel, and Pontus Stenetorp. Beat the AI: Investigating adversarial human annotation for reading comprehension. Transactions of the Association for Computational Linguistics, 8:662-678, 2020.  
+Iz Beltagy, Matthew E Peters, and Arman Cohan. Longformer: The long-document transformer. arXiv preprint arXiv:2004.05150, 2020.  
+Jordan Boyd-Graber and Benjamin Borschinger. What question answering can learn from trivia nerds. ArXiv, 10, 2020. URL https://arxiv.org/abs/1910.14464.
+
+Jordan Boyd-Graber, Brianna Satinoff, He He, and Hal Daume III. Besting the quiz master: Crowdsourcing incremental classification games. In Proceedings of Empirical Methods in Natural Language Processing, 2012.  
+Danqi Chen and Wen-tau Yih. Open-domain question answering. In Proceedings of the 58th Annual Meeting of the Association for Computational Linguistics: Tutorial Abstracts, pages 34-37, 2020.  
+Danqi Chen, Adam Fisch, Jason Weston, and Antoine Bordes. Reading Wikipedia to answer open-domain questions. In Proceedings of the Annual Meeting of the Association for Computational Linguistics, 2017.  
+Hao Cheng, Ming-Wei Chang, Kenton Lee, and Kristina Toutanova. Probabilistic assumptions matter: Improved models for distantly-supervised document-level question answering. In Proceedings of the 58th Annual Meeting of the Association for Computational Linguistics, pages 5657-5667, Online, July 2020a. Association for Computational Linguistics. doi: 10.18653/v1/2020.acl-main.501. URL https://www.aclweb.org/anthology/2020.acl-main.501.  
+Hao Cheng, Xiaodong Liu, Lis Pereira, Yaoliang Yu, and Jianfeng Gao. Posterior differential regularization with f-divergence for improving model robustness, 2020b.  
+Hao Cheng, Yelong Shen, Xiaodong Liu, Pengcheng He, Weizhu Chen, and Jianfeng Gao. Unitedqa: A hybrid approach for open domain question answering. arXiv preprint arXiv:2101.00178, 2021.  
+Kevin Clark, Minh-Thang Luong, Quoc V Le, and Christopher D Manning. Electra: Pretraining text encoders as discriminators rather than generators. In Proceedings of the International Conference on Learning Representations, 2020.  
+Anthony Cuthbertson. Robots can now read better than humans, putting millions of jobs at risk, 2018. URL https://www.newsweek.com/ robots-can-now-read-better-humans-putting-million-jobs-risk-781393.  
+Dheeru Dua, Yizhong Wang, Pradeep Dasigi, Gabriel Stanovsky, Sameer Singh, and Matt Gardner. DROP: A reading comprehension benchmark requiring discrete reasoning over paragraphs. In *Conference of the North American Chapter of the Association for Computational Linguistics*, pages 2368-2378, Minneapolis, Minnesota, June 2019. doi: 10.18653/v1/N19-1246. URL https://www.aclweb.org/anthology/N19-1246.  
+Martin Fajcik, Josef Jon, Santosh Kesiraju, and Pavel Smrz. Rethinking the objectives of extractive question answering. arXiv preprint arXiv:2008.12804, 2020.  
+Martin Fajcik, Martin Docekal, Karel Ondrej, and Pavel Smrz. Pruning the index contents for memory efficient open-domain qa. arXiv preprint arXiv:2102.10697, 2021.  
+Angela Fan, Yacine Jernite, Ethan Perez, David Grangier, Jason Weston, and Michael Auli. Eli5: Long form question answering. arXiv preprint arXiv:1907.09190, 2019.
+
+Shi Feng and Jordan Boyd-Graber. What AI can do for me: Evaluating machine learning interpretations in cooperative play. In International Conference on Intelligent User Interfaces, 2019.  
+David Ferrucci, Eric Brown, Jennifer Chu-Carroll, James Fan, David Gondek, Aditya A. Kalyanpur, Adam Lally, J. William Murdock, Eric Nyberg, John Prager, Nico Schlaefer, and Chris Welty. Building Watson: An Overview of the DeepQA Project. AI Magazine, 31(3), 2010.  
+Kelvin Guu, Kenton Lee, Zora Tung, Panupong Pasupat, and Ming-Wei Chang. REALM: Retrieval-augmented language model pre-training. In Proceedings of the Conference on Machine Learning, 2020.  
+He He, Jordan Boyd-Graber, Kevin Kwok, and Hal Daumé III. Opponent modeling in deep reinforcement learning. In Proceedings of the International Conference of Machine Learning, 2016.  
+Gautier Izacard and Edouard Grave. Leveraging passage retrieval with generative models for open domain question answering. arXiv preprint arXiv:2007.01282, 2020.  
+Gautier Izacard, Fabio Petroni, Lucas Hosseini, Nicola De Cao, Sebastian Riedel, and Edouard Grave. A memory efficient baseline for open domain question answering, 2020.  
+Ken Jennings. *Brainiac: adventures in the curious, competitive, compulsive world of trivia* *buffs*. Villard, 2006. ISBN 9781400064458.  
+Robin Jia and Percy Liang. Adversarial examples for evaluating reading comprehension systems. In Proceedings of the 2017 Conference on Empirical Methods in Natural Language Processing, pages 2021-2031, Copenhagen, Denmark, September 2017. Association for Computational Linguistics. doi: 10.18653/v1/D17-1215. URL https://www.aclweb.org/anthology/D17-1215.  
+Jeff Johnson, Matthijs Douze, and Hervé Jégou. Billion-scale similarity search with GPUs. arXiv preprint arXiv:1702.08734, 2017.  
+Mandar Joshi, Eunsol Choi, Daniel Weld, and Luke Zettlemoyer. TriviaQA: A large scale distantly supervised challenge dataset for reading comprehension. In Proceedings of the 55th Annual Meeting of the Association for Computational Linguistics (Volume 1: Long Papers), volume 1, pages 1601-1611, 2017.  
+Ying Ju, Fubang Zhao, Shijie Chen, Bowen Zheng, Xuefeng Yang, and Yunfeng Liu. Technical report on conversational question answering, 2019.  
+Vladimir Karpukhin, Barlas Oguz, Sewon Min, Ledell Wu, Sergey Edunov, Danqi Chen, and Wen-tau Yih. Dense passage retrieval for open-domain question answering. In Proceedings of Empirical Methods in Natural Language Processing, 2020.  
+Divyansh Kaushik and Zachary C. Lipton. How much reading does reading comprehension require? a critical investigation of popular benchmarks. In Proceedings of Empirical Methods in Natural Language Processing, 2018.
+
+Tom Kwiatkowski, Jennimaria Palomaki, Olivia Redfield, Michael Collins, Ankur Parikh, Chris Alberti, Danielle Epstein, Illia Polosukhin, Matthew Kelcey, Jacob Devlin, Kenton Lee, Kristina N. Toutanova, Llion Jones, Ming-Wei Chang, Andrew Dai, Jakob Uszkoreit, Quoc Le, and Slav Petrov. Natural Questions: a benchmark for question answering research. Transactions of the Association of Computational Linguistics, 2019.  
+Zhenzhong Lan, Mingda Chen, Sebastian Goodman, Kevin Gimpel, Piyush Sharma, and Radu Soricut. ALBERT: A lite BERT for self-supervised learning of language representations. In Proceedings of the International Conference on Learning Representations, 2020.  
+Kenton Lee, Ming-Wei Chang, and Kristina Toutanova. Latent retrieval for weakly supervised open domain question answering. In Proceedings of the Conference of Association for Computational Linguistics, 2019.  
+Mike Lewis, Marjan Ghazvininejad, Gargi Ghosh, Armen Aghajanyan, Sida Wang, and Luke Zettlemoyer. Pre-training via paraphrasing, 2020a.  
+Mike Lewis, Yinhan Liu, Naman Goyal, Marjan Ghazvininejad, Abdelrahman Mohamed, Omer Levy, Veselin Stoyanov, and Luke Zettlemoyer. BART: denoising sequence-to-sequence pre-training for natural language generation, translation, and comprehension. In Proceedings of the Annual Meeting of the Association for Computational Linguistics, 2020b.  
+Patrick Lewis, Ludovic Denoyer, and Sebastian Riedel. Unsupervised question answering by cloze translation. In Proceedings of the Annual Meeting of the Association for Computational Linguistics, July 2019.  
+Patrick Lewis, Pontus Stenetorp, and Sebastian Riedel. Question and answer test-train overlap in open-domain question answering datasets, 2020c.  
+Patrick Lewis, Yuxiang Wu, Linqing Liu, Pasquale Minervini, Heinrich Küttler, Aleksandra Piktus, Pontus Stenetorp, and Sebastian Riedel. Paq: 65 million probably-asked questions and what you can do with them. arXiv preprint arXiv:2102.07033, 2021.  
+Yinhan Liu, Myle Ott, Naman Goyal, Jingfei Du, Mandar Joshi, Danqi Chen, Omer Levy, Mike Lewis, Luke Zettlemoyer, and Veselin Stoyanov. RoBERTa: A robustly optimized bert pretraining approach. arXiv preprint arXiv:1907.11692, 2019.  
+Yuning Mao, Pengcheng He, Xiaodong Liu, Yelong Shen, Jianfeng Gao, Jiawei Han, and Weizhu Chen. Generation-augmented retrieval for open-domain question answering. arXiv preprint arXiv:2009.08553, 2020.  
+Sewon Min, Danqi Chen, Hannaneh Hajishirzi, and Luke Zettlemoyer. A discrete hard EM approach for weakly supervised question answering. In Proceedings of the Conference on Empirical Methods in Natural Language Processing, November 2019a.  
+Sewon Min, Danqi Chen, Luke Zettlemoyer, and Hannaneh Hajishirzi. Knowledge guided text retrieval and reading for open domain question answering, 2019b.
+
+Sewon Min, Julian Michael, Hannaneh Hajishirzi, and Luke Zettlemoyer. AmbigQA: Answering ambiguous open-domain questions. In Proceedings of the Conference on Empirical Methods in Natural Language Processing, 2020.  
+Barlas Oguz, Xilun Chen, Vladimir Karpukhin, Stan Peshterliev, Dmytro Okhonko, Michael Schlichtkrull, Sonal Gupta, Yashar Mehdad, and Wen-tau Yih. Unified open-domain question answering with structured and unstructured knowledge. arXiv preprint, 2020.  
+Colin Raffel, Noam Shazeer, Adam Roberts, Katherine Lee, Sharan Narang, Michael Matena, Yanqi Zhou, Wei Li, and Peter J Liu. Exploring the limits of transfer learning with a unified text-to-text transformer. Journal of Machine Learning Research, 2020.  
+Pranav Rajpurkar, Jian Zhang, Konstantin Lopyrev, and Percy Liang. SQuAD: 100,000+ questions for machine comprehension of text. In Proceedings of Empirical Methods in Natural Language Processing, 2016.  
+Pranav Rajpurkar, Robin Jia, and Percy Liang. Know what you don't know: Unanswerable questions for SQuAD. In Proceedings of the Association for Computational Linguistics, July 2018. doi: 10.18653/v1/P18-2124. URL https://www.aclweb.org/anthology/P18-2124.  
+Adam Roberts, Colin Raffel, and Noam Shazeer. How much knowledge can you pack into the parameters of a language model? In Proceedings of the Conference on Empirical Methods in Natural Language Processing, 2020.  
+Pedro Rodriguez, Shi Feng, Mohit Iyyer, He He, and Jordan Boyd-Graber. Quizbowl: The case for incremental question answering. CoRR, abs/1904.04792, 2019. URL http://arxiv.org/abs/1904.04792.  
+Minjoon Seo, Jinhyuk Lee, Tom Kwiatkowski, Ankur Parikh, Ali Farhadi, and Hannaneh Hajishirzi. Real-time open-domain question answering with dense-sparse phrase index. In Proceedings of the Annual Meeting of the Association for Computational Linguistics, July 2019.  
+Saku Sugawara, Kentaro Inui, Satoshi Sekine, and Akiko Aizawa. What makes reading comprehension questions easier? In Proceedings of Empirical Methods in Natural Language Processing, 2018. doi: 10.18653/v1/D18-1453. URL https://www.aclweb.org/anthology/D18-1453.  
+Zhiqing Sun, Hongkun Yu, Xiaodan Song, Renjie Liu, Yiming Yang, and Denny Zhou. MobileBERT: a compact task-agnostic bert for resource-limited devices. In Proceedings of the Annual Meeting of the Association for Computational Linguistics, 2020.  
+Alan M. Turing. Computers & thought. Mind, pages 11-35, 1995. URL http://dl.acm.org/citation.cfm?id=216408.216410.  
+Ellen M Voorhees and Dawn M Tice. Building a question answering test collection. In Proceedings of the 23rd annual international ACM SIGIR conference on Research and development in information retrieval, pages 200-207. ACM, 2000.
+
+Eric Wallace, Pedro Rodriguez, Shi Feng, Ikuya Yamada, and Jordan Boyd-Graber. Trick me if you can: Human-in-the-loop generation of adversarial question answering examples. Transactions of the Association of Computational Linguistics, 10, 2019.  
+Sohee Yang and Minjoon Seo. Is retriever merely an approximator of reader? arXiv preprint arXiv:2010.10999, 2020.  
+Sohee Yang and Minjoon Seo. Designing a minimal retrieve-and-read system for open-domain question answering. In NAACL-HLT, 2021.
+
+<table><tr><td>Category</td><td>definitely (%)</td><td>possibly (%)</td></tr><tr><td colspan="3">As valid as gold</td></tr><tr><td>Semantically the same</td><td>60</td><td>22</td></tr><tr><td>Open-ended question</td><td>6</td><td>4</td></tr><tr><td>Ambiguous entity/event references</td><td>20</td><td>20</td></tr><tr><td>Answer has different granularity</td><td>14</td><td>6</td></tr><tr><td>Gold is incorrect</td><td>2</td><td>6</td></tr><tr><td colspan="3">Valid but not the best</td></tr><tr><td>Ambiguous answer type</td><td>0</td><td>20</td></tr><tr><td>Answer is time-dependent</td><td>0</td><td>18</td></tr><tr><td colspan="3">Less plausible</td></tr><tr><td>Conflicting info in Wikipedia</td><td>0</td><td>4</td></tr><tr><td>Plausible only in certain condition</td><td>0</td><td>4</td></tr><tr><td>Mismatch with question intent</td><td>0</td><td>8</td></tr><tr><td>Incorrect prediction</td><td>0</td><td>2</td></tr></table>
+
+Table 6: Analysis of predictions that are rated as definitely correct or possibly correct by human raters. Examples of each category are shown in Table 7. Note that the total is over  $100\%$  as one question may fall into multiple categories.
+
+# Appendix A. Analyses
+
+Characteristics of easy and hard questions Table 8 shows questions that are answered correctly by all seven systems (easy), or answered incorrectly by all seven systems (hard). A common feature of easy questions (Sugawara et al., 2018; Kaushik and Lipton, 2018) is that a sentence from Wikipedia provides an explicit support to the question. Such supporting sentences have high lexical overlap with the question and require little paraphrasing (e.g. "the highest population" vs. "the most populous"). Even when the question is not well-formed, all systems may find the correct answer if there is high lexical overlap between the question and the supporting sentence (e.g. the fifth example question in Table 8).
+
+Many of the hard questions have their answers in the tables (e.g. the first question in Table 8). This likely makes them "hard" because all systems except FB Hybrid do not consider the tables, and even FB Hybrid may miss such cases. In the other cases, systems make mistakes even when there is the text that supports the answer (e.g. the next two questions in Table 8). Though the reason for the mistake would be different depending on the systems, we conjecture that such supporting sentences are harder to retrieve or do not support the answer as explicitly as other examples. Occasionally, the question is not well-formed, such as the last one in Table 8.
+
+Error Analysis We further present an error analysis of the top two systems in the 500MiB track: UCLNLP-FB system and Naver RDR. We choose these two systems because their approaches differ significantly from each other and the 500MiB track fits the main motivation of the EfficientQA competition. We randomly sample 100 questions from the devel
+
+<table><tr><td>Category</td><td>Example</td></tr><tr><td colspan="2">As valid as gold</td></tr><tr><td>Semantically the same</td><td>Q: When did israel split into israel and judahGold: about 930 BCE / Prediction: around 930 BCEQ: What movie is bring it on the musical based off ofGold: Bring It On / Prediction: 2000 film of the same name</td></tr><tr><td>Open-ended question</td><td>Q: City belonging to mid west of united statesGold: Des Moines / Prediction: kansas city</td></tr><tr><td>Ambiguous entity/event references</td><td>Q: Gold woman in guardians of the galaxy 2Gold: Ayesha / Prediction: Elizabeth Debicki</td></tr><tr><td>Answer has different granularity</td><td>Q: When did the musical cats open on broadwayGold: 1982, 7 October 1982 / Prediction: october 1982Q: Where did the industrial revolution in the united states beginGold: in Pawtucket / Prediction: rhode island</td></tr><tr><td>Gold is incorrect</td><td>Q: When did universal studios become a theme parkGold: 1965 / Prediction: july 15 1964, 1964</td></tr><tr><td colspan="2">Valid but not the best</td></tr><tr><td>Ambiguous answer type</td><td>Q: When did naruto find out about jiraiya&#x27;s deathGold: “Somber News” / Prediction: february 23 2013</td></tr><tr><td>Answer is time-dependent</td><td>Q: Who goes to the big 12 championship gameGold: Oklahoma Sooners / Prediction: tcu horned frogs</td></tr><tr><td colspan="2">Less plausible</td></tr><tr><td>Conflicting info in Wikipedia</td><td>Q: Based on population what is the largest military base in the united states / Gold: Fort Bragg / Prediction: fort hood</td></tr><tr><td>Plausible only in certain condition</td><td>Q: Who appointed the chief justice of high courtGold: President / Prediction: president of india</td></tr><tr><td>Mismatch with question intent</td><td>Q: While the united states dealt with the depression it was also facingGold: Racial tensions / Prediction: great depression, economic downturns</td></tr><tr><td>Incorrect</td><td>Q: When were banded iron formations formed on the sea floorGold: Precambrian / Prediction: some 185 billion years ago</td></tr></table>
+
+Table 7: Examples of predictions rated as definitely correct or possibly correct by human.
+
+opment data. 40, 33 and 27 questions are answered correctly by both systems, one of the systems, and none of the systems, respectively.
+
+Table 9 shows the breakdown of the predictions from UCLNLP-FB system, where 50 questions are answered correctly, and the other 50 are not. A majority of the error cases (47 out of 50) is due to retrieving an incorrect question. Out of 47, 25 cases retrieve the question with a different topic from the input questions, many of which discuss different entities (e.g., "don't it make you feel like dancing" vs. "you make me feel like dancing"). The other 19 cases retrieve the question that discusses the same topic or contains the same key entity, but is asking about different details. For instance, in the example in Table 9, the input question asks the amount spent for a film, while the retrieved question asks the amount
+
+<table><tr><td>Easy questions
+Q: What city in america has the highest population / Gold: New York City
+New York City: New York City is the most populous city in the United States ...</td></tr><tr><td>Q: Who plays 11 in stranger things on netflix / Gold: Millie Bobby Brown
+Millie Bobby Brown: She gained notability for her role as Eleven in the first season of Netflix science fiction series Stranger Things.</td></tr><tr><td>Q: Where did leave it to beaver take place / Gold: Mayfield
+Leave It to Beaver: Leave It to Beaver is set in the fictitious community of Mayfield and its environs.</td></tr><tr><td>Q: The substance that is dissolved in the solution / Gold: solute
+Solution: A solute is a substance dissolved in another substance, known as a solvent.</td></tr><tr><td>Q: This means that in dna cytosine is always paired with / Gold: guanine
+Guanine: In DNA, guanine is paired with cytosine.</td></tr><tr><td>Hard questions
+Q: What is the area code for colombo sri lanka / Gold: 036
+Telephone numbers in Sri Lanka: (Answer in the table)</td></tr><tr><td>Q: Which country is highest oil producer in the world / Gold: United States / Predictions: Russia
+History of the petroleum industry in the United States: For much of the 19th and 20th centuries, the US was the largest oil producing country in the world.
+List of countries by oil production: (Answer in the table)
+Russia: Russia is the world&#x27;s leading natural gas exporter and second largest natural gas producer, while also the second largest oil exporter and the third largest oil producer.</td></tr><tr><td>Q: Who did gibbs shoot in season 10 finale / Gold: Mendez
+Predictions: fbi agent tobias fornell (from all systems in unrestricted/6Gb track)
+Past, Present and Future (NCIS) Gibbs realizes that Mendez is .. The show then returns to the scene depicted in a scene from season 10 finale&#x27;s ... shoots and kills Mendez.</td></tr><tr><td>Q: The girl next door film based on a true story / Gold: loosely / Prediction: girl next door</td></tr></table>
+
+Table 8: Samples of easy questions (all systems predict correct answers) and hard questions (all systems predict incorrect answers).
+
+made by the film. It is also worth noting that the system sometimes gets the correct answer from the retrieved question with a different meaning from the input question, e.g., "What republican is running for mayor of phoenix" vs. "Who is the current mayor of phoenix", which have the same answer because the current mayor of Phoenix is Republican.
+
+Table 10 shows the breakdown of the predictions from NAVER RDR, where 63 questions are answered correctly, and 37 are not. Failure due to pruning the gold passage is rare, being responsible for only  $3\%$ . More of the failure cases are due to missing the gold passage, either when choosing 80 passages through dense retrieval  $(12\%)$ , or during cross-attention re-ranking 80 passages to decide on the top 1 passage  $(15\%)$ . Finally, in  $7\%$  of the cases, the top 1 passage contains the gold answer but the system fails to extract the correct answer. The gold passages in this category have valid but implicit support of the answer, e.g., the last example in Table 10.
+
+<table><tr><td rowspan="2">Correct</td><td>Captured by automatic eval (32%) 
+Input: Who played apollo creed in the original rocky (A: carl weathers) 
+Retrieved: Who played apollo creed in the first rocky movie (A: carl weathers)</td></tr><tr><td>Captured by manual eval (18%) 
+Input: When does the new season of snl air (A: September 29, 2018) 
+Retrieved: When does the new season of snl 2017 start (A: September 30, 2017)</td></tr><tr><td rowspan="5">Incorrect</td><td>Retrieved Q is not related to input Q in topics (25%) 
+Input: Who sings don&#x27;t it make you feel like dancing 
+Retrieved: Who sings the song you make me feel like dancing</td></tr><tr><td>Retrieved Q is related but is asking different detail (19%) 
+Input: How much did it cost to make bohemian rhapsody film 
+Retrieved: How much money did the movie rhapsody make</td></tr><tr><td>Retrieved Q is related but contains incorrect ‘wh’ word (3%) 
+Input: When was the current season of top chef filmed 
+Retrieved: What is the new season of top chef</td></tr><tr><td>Retrieved Q is context-dependent (1%) 
+Input: Who won the war of 1812 between russia and france 
+Retrieved: Who did we fight in the war of 1812</td></tr><tr><td>Retrieved Q has incorrect answer (2%) 
+Input: When was the last time florida state had a losing record 
+Retrieved: When was the last time florida state football had a losing season</td></tr></table>
+
+Table 9: Breakdown of the predictions from UCLNLP-FB system on 100 random samples.  
+
+<table><tr><td rowspan="2">Correct</td><td>Captured by automatic eval (34%) 
+Q: Who played apollo creed in the original rocky / Gold: Carl Weathers / Prediction: Carl Weathers 
+Retrieved P: Carl Weathers: He is best known for portraying apollo creed in the “rocky” series of films.</td></tr><tr><td>Captured by manual eval (29%) 
+Q: what was the shelby in gone in 60 seconds / Gold: Shelby Mustang GT500 / Prediction: gt500 
+Retrieved P: Eleanor: The eleanor name is reused for a shelby mustang gt500 in the 2000 gone in 60 seconds remake.</td></tr><tr><td rowspan="4">Incorrect</td><td>No answer found in pruned Wiki (3%) 
+Q: Who has been chosen for the 2017 saraswati samman 
+Gold: Sitanshu Yashaschandra / Prediction Vijayendra saraswathi 
+Retrieved P: jayendra saraswathi: The mutt&#x27;s pontiff sri vijayendra saraswathi performed the poojas for his guru and predecessor. 
+Gold P: Sitanshu Yashaschandra: He received Saraswati Samman (2017) for his poetry collection..</td></tr><tr><td>Fail to retrieve the gold passage (12%) 
+Q: Who sings don&#x27;t it make you feel like dancing / Gold: the Headpins / Prediction: leo sayer 
+Retrieved P: you make me feel like dancing is a song by the british singer leo sayer ..</td></tr><tr><td>Fail to rerank the gold passage (15%) 
+Q: Who says all animals are equal but some are more equal than others 
+Gold: The pigs / Prediction: aristotle 
+Retrieved P: moral status of animals in the ancient world: Aristotle perceived some similarities between humans and other species and developed a sort of “psychological continuum”, recognising that human and non-human animals differ only by degree in possessing certain temperaments.</td></tr><tr><td>Fail to extract the correct answer (7%) 
+Q: Which is the smallest continent in size in the world / Gold: Australia / Prediction: Asia 
+Retrieved P: Continent ...Ordered from largest in area to smallest, they are: Asia, Africa, North America, South America, Antarctica, Europe, and Australia</td></tr></table>
+
+Table 10: Breakdown of the predictions from Naver RDR on 100 random samples.

data/2021/2101_00xxx/2101.00178/431507cf-6cad-41d1-9637-1521a5ac3935_content_list.json

@@ -1,3 +1,1479 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:bc9087903eeec675a19cebd342b0adb48a5a4d532a053d93130e12aea55ff1ad
-size 74143
+[
+    {
+        "type": "text",
+        "text": "UnitedQA: A Hybrid Approach for Open Domain Question Answering",
+        "text_level": 1,
+        "bbox": [
+            134,
+            79,
+            867,
+            101
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Hao Cheng $^{1*}$ , Yelong Shen $^{2*}$ , Xiaodong Liu $^{1}$ , Pengcheng He $^{2}$ , Weizhu Chen $^{2}$ , Jianfeng Gao $^{1}$",
+        "bbox": [
+            242,
+            131,
+            766,
+            167
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "<sup>1</sup> Microsoft Research <sup>2</sup> Microsoft Azure AI",
+        "bbox": [
+            327,
+            167,
+            678,
+            181
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "{chehao, yeshe, xiaodl, penhe, wzchen, jfgao}@microsoft.com",
+        "bbox": [
+            178,
+            185,
+            830,
+            200
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Abstract",
+        "text_level": 1,
+        "bbox": [
+            263,
+            263,
+            341,
+            278
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "To date, most of recent work under the retrieval-reader framework for open-domain QA focuses on either extractive or generative reader exclusively. In this paper, we study a hybrid approach for leveraging the strengths of both models. We apply novel techniques to enhance both extractive and generative readers built upon recent pretrained neural language models, and find that proper training methods can provide large improvements over previous state-of-the-art models. We demonstrate that an hybrid approach by combining answers from both readers can effectively take advantages of extractive and generative answer inference strategies and outperform single models as well as homogeneous ensembles. Our approach outperforms previous state-of-the-art models by 3.3 and 2.7 points in exact match on NaturalQuestions and TriviaQA respectively.",
+        "bbox": [
+            142,
+            294,
+            460,
+            565
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 Introduction",
+        "text_level": 1,
+        "bbox": [
+            115,
+            583,
+            260,
+            596
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Open-domain question answering (QA) has been a long standing problem in natural language understanding, information retrieval, and related fields (Chen and Yih, 2020). An typical open-domain QA system follows the retrieval-reader framework (Chen et al., 2017; Guu et al., 2020; Karpukhin et al., 2020), where the relevant passages are first retrieved from a large text corpus, and a reader module then navigates multiple passages for answer inference. In this work, we study two paradigms of reader modules, i.e. extractive (Karpukhin et al., 2020; Guu et al., 2020) and generative (Lewis et al., 2020; Izacard and Grave, 2021) readers. The extractive reader extracts contiguous spans from the retrieved passages whereas the generative reader sequentially decodes the answer string which might not be contained in the retrieved passages.",
+        "bbox": [
+            114,
+            609,
+            490,
+            883
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Recent work on open-domain QA (Karpukhin et al., 2020; Guu et al., 2020; Lewis et al., 2020; Izacard and Grave, 2021) explores either an extractive reader or a generative reader exclusively. We hypothesize that extractive and generative readers adopt different answer inference strategies, thus a hybrid extractive/generative reader can be a better option for open-domain QA tasks. As shown in Figure 1, compared with prediction agreement among only generative or extractive readers (top-left and bottom-right), the cross prediction agreement between extractive and generative readers (bottom-left) is relatively low ( $<50\\%$ ). It indicates that answers produced by those two types of models are different and they can be complementary to each other. Therefore, we propose a hybrid reader approach, UnitedQA, which is a simple ensemble approach to combine the predictions from extractive and generative readers. It achieves state-of-the-art results on NaturalQuestions (Kwiatkowski et al., 2019) and TriviaQA (Joshi et al., 2017).",
+        "bbox": [
+            509,
+            263,
+            885,
+            601
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "In UnitedQA, the extractive reader (UnitedQA-E) and generative reader (UnitedQA-G) are built upon the pretrained language models, ELECTRA (Clark et al., 2020) and T5 (Raffel et al., 2020), respectively. For the UnitedQA-E, we adopt a weakly-supervised training objective to address the noisy supervision issue caused by the heuristics-based labeling and incorporate the posterior differential regularization (PDR) (Cheng et al., 2021) to improve the model robustness. The UnitedQA-G follows the T5 Fusion-in-Decoder (FID) (Izacard and Grave, 2021) and we make two improvements: first, we add a group of attention bias parameters into the decoder cross-attention block to feature the ranking information of retrieved contexts; second, we add the adversarial training (Ju et al., 2019; Jiang et al., 2020; Pereira et al., 2021) to improve the model generalization ability.",
+        "bbox": [
+            509,
+            602,
+            885,
+            891
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "The experimental results highlight the effec",
+        "bbox": [
+            529,
+            892,
+            884,
+            909
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "aside_text",
+        "text": "arXiv:2101.00178v2 [cs.CL] 2 Jun 2021",
+        "bbox": [
+            21,
+            319,
+            60,
+            717
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "page_footnote",
+        "text": "* Equal Contribution",
+        "bbox": [
+            144,
+            895,
+            270,
+            909
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "image",
+        "img_path": "images/e639adf81015e2d37b03aae3c3c09bd6ca0af5b6c190dc1da6d84a01523c4b93.jpg",
+        "image_caption": [
+            "Figure 1: Pairwise prediction agreement ratio. G-1, G-2, G-3 and E-1, E-2, E-3 are three different generative and extractive readers respectively. All readers achieve similar performance ( $\\approx$ $52\\%$  exact match) on NaturalQuestions. Higher agreement ( $>50\\%$ ) in red and lower agreement ( $<50\\%$ ) in gray. The agreement is calculated based on exact string match."
+        ],
+        "image_footnote": [],
+        "bbox": [
+            147,
+            95,
+            433,
+            272
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "tiveness of the simple hybrid approach of UnitedQA. With both improved extractive and generative readers, UnitedQA sets new state-of-the-art results on two popular open-domain QA datasets, i.e. 54.7 and 70.3 in exact match on NaturalQuestions (Kwiatkowski et al., 2019) and TriviaQA (Joshi et al., 2017), respectively. It is worth noting that our UnitedQA model not only outperforms each single model but also brings more pronounced improvements over homogeneous ensembles of either extractive or generative readers. Last, based on our analyses, UnitedQA-E and UnitedQA-G have advantages in different cases, suggesting they may use different reasoning strategies.",
+        "bbox": [
+            114,
+            428,
+            492,
+            653
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2 Method",
+        "text_level": 1,
+        "bbox": [
+            115,
+            669,
+            220,
+            686
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "In this section, we present the overall pipeline of the UnitedQA system, which consists of three components: Retrieval, Reading, and Re-ranking. First, the retrieval module fetches a list of relevant passages from a Wikipedia dump for a given question. Then, the module of hybrid readers produces answer candidates from the set of retrieved passages. Last, the re-ranking module combines the answer candidates with linear interpolation and produces the final answer.",
+        "bbox": [
+            114,
+            697,
+            490,
+            858
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Retrieval Following Karpukhin et al. (2020), we consider two methods, BM25 and dense passage retrieval (DPR), for retrieving the support passages",
+        "bbox": [
+            114,
+            860,
+            489,
+            910
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "for a given question. For BM25, passages are encoded as bag of words (BOW), and inverse document frequencies are used as the ranking function. For DPR, passages and questions are represented as dense vectors based on two BERT (Devlin et al., 2019) models. The relevance score is then computed based on the dot production between the query and passage vectors. In this paper, we adopt the same implementation as Karpukhin et al. (2020) for retrieving passages. Specifically, the English Wikipedia dump from Dec. 20, 2018 is used as the source documents for retrieval, with the removal of semi-structured data, such as tables or lists. Each document is split into disjoint 100-word passages as the basic retrieval unit. The top-100 passages are then passed for reading.",
+        "bbox": [
+            509,
+            74,
+            885,
+            332
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Reading We combine the generative reader and the extractive reader to produce answer candidates over the retrieved passages. Here, we only give a high-level description of our approach. More details regarding our improved extractive and generative models are presented in §2.1 and §2.2 respectively.",
+        "bbox": [
+            509,
+            334,
+            885,
+            431
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "The generative reader is based on a sequence-to-sequence model pre-trained in a forward-generation fashion on a large corpus, i.e. T5 (Raffel et al., 2020). Similar to Izacard and Grave (2021), the model takes the question and its relevant passages as input, and then generates the answer string token by token. Specifically, the concatenation of all retrieved passages and the corresponding question is used as the encoder input. Then, the decoder performs reasoning over the concatenation of all evidence through an attention mechanism.",
+        "bbox": [
+            509,
+            432,
+            885,
+            608
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Following state-of-the-art extractive QA models (Devlin et al., 2019; Karpukhin et al., 2020), our extractive reader is based on a Transformer neural network pre-trained with a cloze style self-supervised objective, i.e. ELECTRA (Clark et al., 2020). Here, a pair of a given question and a support passage is jointly encoded into neural text representations. These representations are then used to define scores or probabilities of possible answer begin and end positions, which are in turn used to define probabilities over possible answer spans. Finally, the answer string probabilities are based on the aggregation over all possible answer spans from the entire set of support passages.",
+        "bbox": [
+            509,
+            611,
+            885,
+            837
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2.1 UnitedQA-E",
+        "text_level": 1,
+        "bbox": [
+            510,
+            852,
+            658,
+            869
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "In §2.1.2, we give the problem definition of open-domain QA for extractive reader. Then, we detail",
+        "bbox": [
+            509,
+            877,
+            885,
+            910
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "the improvements of UnitedQA-E in  $\\S 2.1.2$",
+        "bbox": [
+            115,
+            74,
+            443,
+            90
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "2.1.1 Extractive Reader",
+        "text_level": 1,
+        "bbox": [
+            115,
+            99,
+            319,
+            115
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Given a question  $\\mathbf{q}$  and a set of  $K$  retrieved passages  $\\mathfrak{p}_1, \\ldots, \\mathfrak{p}_K$ , a text encoder produces contextualized representations:  $\\mathbf{h}_1^k, \\ldots, \\mathbf{h}_T^k \\in \\mathbb{R}^n$  for the question-passage pair  $(\\mathbf{q}, \\mathbf{p}_k)$  in the form of \"[CLS] question [SEP] passage [SEP]\", where [CLS] and [SEP] are special tokens for encoding inputs,  $T$  is the maximum sequence length of the input text, and  $\\mathbf{h}_i^k$  indicates the contextualized embedding of the  $i$ -th token in  $(\\mathbf{q}, \\mathbf{p}_k)$ .",
+        "bbox": [
+            112,
+            118,
+            490,
+            265
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "The extractive reader computes the span-begin score of the  $i$ -th token as  $s_b(i^k) = \\mathbf{w}_b^T\\mathbf{h}_i^k$  using a weight vector  $\\mathbf{w}_b \\in \\mathbb{R}^d$ . The span-end score  $s_e(j^k)$  is defined in the same way. Thus, the probabilities of a start position  $i^k$  and an end position  $j^k$  are  $P_b(i^k) = \\frac{\\exp(s_b(i^k))}{Z_b}$ ,  $P_e(j^k) = \\frac{\\exp(s_e(j^k))}{Z_e}$ , where  $Z_b, Z_e$  are normalizing factors defined by the corresponding probability space. The probability of an answer span from  $i^k$  to  $j^k$  is defined as  $P_s(i^k, j^k) = P_b(i^k)P_e(j^k)$ .",
+        "bbox": [
+            114,
+            266,
+            489,
+            428
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Here, we consider two probability spaces, passage level and multi-passage level, with the only difference in the computing of  $Z_{b}, Z_{e}$ . Specifically, the passage-level probability of each answer begins and ends is computed by normalizing all possible positions in the respective passage, i.e.  $Z_{b} = Z_{b}^{k} = \\sum_{\\mathcal{I}^{k} \\cup \\mathrm{NULL}} \\exp(s_{b}(i))$ ,  $Z_{e} = Z_{e}^{k} = \\sum_{\\mathcal{I}^{k} \\cup \\mathrm{NULL}} \\exp(s_{e}(j))$ , where  $\\mathcal{I}^{k}$  is the set of all possible positions from the  $k$ -th passage and NULL indicates special positions if  $p_{k}$  does not support answering the question. Similarly, the multi-passage level probability is computed by normalizing over each answer positions across all  $K$  relevant passages, i.e.  $Z_{b} = Z_{b}^{*} = \\sum_{k} \\sum_{\\mathcal{I}^{k}} \\exp(s_{b}(i))$ ,  $Z_{e} = Z_{e}^{*} = \\sum_{k} \\sum_{\\mathcal{I}^{k}} \\exp(s_{e}(j))$ , respectively.",
+        "bbox": [
+            114,
+            430,
+            490,
+            671
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Since there are usually multiple plausible mentions for open-domain QA, during training, it is typical to maximize either the marginal log-likelihood (MML) of all correct spans (Karpukhin et al., 2020) or the log-likelihood of the most likely correct span (HardEM) (Min et al., 2019). During inference, the prediction is made based on the candidate answer string score, obtaining as  $P_{a}(y) = \\sum_{(i,j)\\in \\mathcal{Y}}P_{s}(i,j)$ , where  $\\mathcal{Y}$  is the set of spans corresponding to the answer string  $y$ .",
+        "bbox": [
+            114,
+            671,
+            490,
+            832
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "2.1.2 Improvement Method",
+        "text_level": 1,
+        "bbox": [
+            115,
+            841,
+            349,
+            857
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "In addition to better text representations from Clark et al. (2020), we consider two methods for improving the training of the extractive reader.",
+        "bbox": [
+            114,
+            860,
+            490,
+            910
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Multi-objective for Weakly-supervised QA The multi-objective formulation is introduced in Cheng et al. (2020) for improving weakly supervised document-level QA. Different from Cheng et al. (2020) where only MML is considered for the multi-objective formulation, we found combining HardEM with MML is more effective for open-domain QA based on our experiments (§4.1). Specifically, we combine a multi-passage HardEM loss with  $K$  passage-level MML losses over a batch of  $K$  passages",
+        "bbox": [
+            509,
+            74,
+            885,
+            252
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "text": "\n$$\n\\begin{array}{l} \\mathcal{L}_{\\mathrm{EXT}}  =   \\log \\max_{(i,j)}P_{s}^{M}(i,j) + \\\\ \\frac {1}{K} \\sum_ {k} \\log \\sum_ {\\left(i ^ {k}, j ^ {k}\\right)} P _ {s} ^ {P} \\left(i ^ {k}, j ^ {k}\\right), \\tag {1} \\\\ \\end{array}\n$$\n",
+        "text_format": "latex",
+        "bbox": [
+            544,
+            262,
+            882,
+            332
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "where  $P_{s}^{M}, P_{s}^{P}$  is the multi-passage level and passage level span probabilities respectively.",
+        "bbox": [
+            509,
+            344,
+            885,
+            376
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Posterior Differential Regularization Due to the noisy supervision for open-domain QA (Chen et al., 2017), we investigate the posterior differential regularization (PDR) (Cheng et al., 2021) to improve the robustness of the extractive reader. Different from Cheng et al. (2021) where only clean supervision setting is considered, in this work, we apply PDR to the weakly supervised open-domain QA scenario. Given it is computationally expensive to enumerate all possible spans, we apply two separate regularization terms for the begin and end probabilities at the multi-passage level, respectively,",
+        "bbox": [
+            509,
+            376,
+            885,
+            570
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "text": "\n$$\n\\mathcal {L} _ {\\mathrm {P D R}} = D \\left(P _ {b} (i) \\mid P _ {b} ^ {\\prime} (i)\\right) + D \\left(P _ {e} (j) \\mid P _ {e} ^ {\\prime} (j)\\right), \\tag {2}\n$$\n",
+        "text_format": "latex",
+        "bbox": [
+            514,
+            581,
+            882,
+            600
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "where  $D(\\cdot |\\cdot)$  is the squared Hellinger distance, and  $P_b^{\\prime},P_e^{\\prime}$  are the probabilities of start and end positions with additive input noise to the token embeddings. Specifically, we sample noise vectors  $\\epsilon_{1},\\ldots ,\\epsilon_{T}$  from  $\\mathcal{N}(0,c^2 I)$ , and add them to the token embeddings as the noisy input, i.e.  $\\mathbf{v}_1 + \\epsilon_1,\\dots ,\\mathbf{v}_T + \\epsilon_T$  where  $c$  is fixed to 1e-3 throughout our experiments.",
+        "bbox": [
+            509,
+            611,
+            885,
+            739
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Based on this, the overall training objective for the extractive reader is",
+        "bbox": [
+            509,
+            740,
+            882,
+            771
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "text": "\n$$\n\\mathcal {L} ^ {1} = \\mathcal {L} _ {\\mathrm {E X T}} + \\gamma \\mathcal {L} _ {\\mathrm {P D R}}, \\tag {3}\n$$\n",
+        "text_format": "latex",
+        "bbox": [
+            596,
+            783,
+            882,
+            801
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "where  $\\gamma$  is a regularization scalar hyperparameter.",
+        "bbox": [
+            509,
+            814,
+            877,
+            829
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "2.2 UnitedQA-G",
+        "text_level": 1,
+        "bbox": [
+            510,
+            840,
+            660,
+            856
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Here, we first formally define the setup of generative reader for open-domain QA in § 2.2.1 and then present our improvements in § 2.2.2.",
+        "bbox": [
+            509,
+            860,
+            885,
+            910
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "2.2.1 Generative Reader",
+        "text_level": 1,
+        "bbox": [
+            115,
+            74,
+            326,
+            89
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Given a question  $\\mathbf{q}$  and a set of  $K$  retrieved passages  $\\mathfrak{p}_1, \\ldots, \\mathfrak{p}_K$ , the encoder model encodes each  $(\\mathfrak{q}, \\mathfrak{p}_k)$  pair independently, and produces contextualized representation for each token:  $\\mathbf{h}_i^k \\in \\mathbb{R}^d$  for the  $i$ -th token of the  $k$ -th pair. The decoder then performs attention over the concatenation of the representations of all the retrieved passages, and generates the answer string.",
+        "bbox": [
+            114,
+            93,
+            490,
+            222
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Let  $\\mathbf{x}$  denote the input of the question and all retrieved passages  $\\mathbf{x} = ((\\mathbf{q},\\mathbf{p}_1),\\dots,(\\mathbf{q},\\mathbf{p}_K))$  ,and  $\\mathbf{y}$  the answer string with its tokens as  $(y_{1},\\ldots ,y_{N})$  The generative reader is trained to maximize a sequence-to-sequence objective for a given  $(\\mathbf{x},\\mathbf{y})$",
+        "bbox": [
+            114,
+            223,
+            490,
+            305
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "text": "\n$$\n\\mathcal {L} (\\mathbf {x}, \\mathbf {y}; \\theta) = \\sum_ {i} ^ {N} \\log P _ {\\theta} \\left(y _ {i} \\mid \\mathbf {x}, y _ {1: i - 1}\\right), \\tag {4}\n$$\n",
+        "text_format": "latex",
+        "bbox": [
+            161,
+            309,
+            489,
+            353
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "where  $\\theta$  is the model parameter. During inference, a greedy decoding is used to produce the answer.",
+        "bbox": [
+            115,
+            357,
+            489,
+            390
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "2.2.2 Improvement Method",
+        "text_level": 1,
+        "bbox": [
+            115,
+            398,
+            349,
+            413
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Decoder Attention Bias The decoder in the T5 transformer model adopts a cross-attention mechanism to compute attention scores between the decoding answer tokens and all the retrieved passage tokens. Specifically, let  $\\mathbf{y}_i\\in \\mathbb{R}^d$  be the query vector of the  $i$ -th decoding token $^1$ , and  $\\mathbf{m}_j^k\\in \\mathbb{R}^d$  be the key vector of the  $j$ -th token in  $(q),p_k)$ . The multi-head cross-attention scores in T5 (Raffel et al., 2020)  $\\mathbf{s}_{i,j}^{k}$  is calculated as",
+        "bbox": [
+            114,
+            417,
+            490,
+            563
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "text": "\n$$\n\\mathbf {s} _ {i, j} ^ {k} = \\operatorname {M u l t i H e a d A t t} \\left(\\mathbf {y} _ {i}, \\mathbf {m} _ {j} ^ {k}\\right) \\in \\mathbb {R} ^ {\\left| \\text {H e a d} \\right|} \\tag {5}\n$$\n",
+        "text_format": "latex",
+        "bbox": [
+            142,
+            570,
+            487,
+            592
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "where  $|\\mathrm{Head}|$  is the number of attention heads. However, it doesn't capture the relevance information of retrieved passages into the reader in (5). To add the relevance feature into the attention block, we revise (5) by incorporating the attention bias",
+        "bbox": [
+            114,
+            596,
+            490,
+            677
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "text": "\n$$\n\\mathbf {s} _ {i, j} ^ {k} = \\operatorname {M u l t i H e a d A t t} \\left(\\mathbf {y} _ {i}, \\mathbf {m} _ {j} ^ {k}\\right) + \\mathbf {b} _ {k}, \\tag {6}\n$$\n",
+        "text_format": "latex",
+        "bbox": [
+            164,
+            683,
+            489,
+            703
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "where  $\\mathbf{b}_k\\in \\mathbb{R}^{|Head|}$  is a trainable attention bias vector for all the tokens in the  $k$  -th retrieved passage. In the experiments, the maximum retrieved passages is by default set to 100. Thus, the decoder attention bias introduces additional  $100*|\\mathrm{Head}|$  parameters for each layer.",
+        "bbox": [
+            114,
+            709,
+            490,
+            806
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Adversarial Training Adversarial training creates adversarial examples by adding small perturbations to the embedding layer. Assuming the word(-piece) embedding layer is parameterized by a matrix  $\\mathbf{V} \\in \\mathcal{R}^{|V| \\times d}$ ,  $|V|$  is the vocabulary size, and  $d$",
+        "bbox": [
+            114,
+            807,
+            490,
+            888
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "table",
+        "img_path": "images/901718d482af3bc4e31ec34c0dfb481a1f2d1e9fcf260bc422dc3b8086ca5ffa.jpg",
+        "table_caption": [],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Dataset</td><td>Train</td><td>Dev</td><td>Test</td></tr><tr><td>NQ</td><td>79168</td><td>8757</td><td>3610</td></tr><tr><td>TriviaQA</td><td>78785</td><td>8837</td><td>11313</td></tr><tr><td>EffcientQA</td><td>-</td><td>1800</td><td>-</td></tr></table>",
+        "bbox": [
+            549,
+            72,
+            848,
+            154
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Table 1: Number of questions in each QA dataset.",
+        "bbox": [
+            526,
+            162,
+            867,
+            178
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "is the embed-dimension. The adversarial embedding matrix  $\\hat{\\mathbf{V}}$  can be obtained by",
+        "bbox": [
+            509,
+            200,
+            885,
+            233
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "text": "\n$$\ng _ {\\mathbf {V}} = - \\nabla_ {\\mathbf {V}} \\mathcal {L} (\\mathbf {x}, \\mathbf {y}; \\theta), \\tag {7}\n$$\n",
+        "text_format": "latex",
+        "bbox": [
+            630,
+            243,
+            882,
+            260
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "text": "\n$$\n\\hat {\\mathbf {V}} = \\mathbf {V} + \\operatorname {S G} \\left(\\epsilon g _ {\\mathbf {V}} / \\| g _ {\\mathbf {V}} \\| _ {2}\\right), \\tag {8}\n$$\n",
+        "text_format": "latex",
+        "bbox": [
+            589,
+            263,
+            882,
+            281
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "where  $\\mathrm{SG}(\\cdot)$  is the stop-gradient operation. We use the adversarial embedding matrix  $\\hat{\\mathbf{V}}$  to replace the original  $\\mathbf{V}$  in model parameters  $\\theta$ , and obtain  $\\hat{\\theta}$ . Thus the adversarial loss can be calculated as",
+        "bbox": [
+            509,
+            290,
+            885,
+            354
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "text": "\n$$\n\\mathcal {L} _ {\\mathrm {A T}} (\\mathbf {x}, \\mathbf {y}; \\theta) = \\mathcal {L} (\\mathbf {x}, \\mathbf {y}; \\hat {\\theta}). \\tag {9}\n$$\n",
+        "text_format": "latex",
+        "bbox": [
+            596,
+            363,
+            882,
+            381
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Therefore, the overall training objective of the generative reader is",
+        "bbox": [
+            509,
+            390,
+            882,
+            422
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "text": "\n$$\n\\mathcal {L} ^ {2} = \\alpha \\mathcal {L} (\\mathbf {x}, \\mathbf {y}; \\theta) + \\beta \\mathcal {L} _ {\\mathrm {A T}} (\\mathbf {x}, \\mathbf {y}; \\theta), \\tag {10}\n$$\n",
+        "text_format": "latex",
+        "bbox": [
+            547,
+            430,
+            882,
+            449
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "where  $\\alpha = 0.5, \\beta = 0.5$  in all of the experiments.",
+        "bbox": [
+            509,
+            457,
+            878,
+            473
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "2.3 UnitedQA System",
+        "text_level": 1,
+        "bbox": [
+            510,
+            483,
+            699,
+            499
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "The UnitedQA system combines outputs from both extractive and generative models for a given question during inference. Since the output spaces of extractive and generative models are different, we use a simple linear interpolation based on best predictions from each model<sup>2</sup>. Denote the predicted strings from  $M$  extractive and  $N$  generative models as  $y_1^E, \\ldots, y_M^E$  and  $y_1^G, \\ldots, y_N^G$ , respectively. The hybrid prediction  $y^*$  is obtained by",
+        "bbox": [
+            509,
+            504,
+            885,
+            649
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "text": "\n$$\n\\underset {y \\in \\mathcal {Y}} {\\operatorname {a r g m a x}} \\tau \\sum_ {m = 1} ^ {M} \\mathbf {1} \\left(y, y _ {m} ^ {E}\\right) + \\delta \\sum_ {n = 1} ^ {N} \\mathbf {1} \\left(y, y _ {n} ^ {G}\\right), \\tag {11}\n$$\n",
+        "text_format": "latex",
+        "bbox": [
+            524,
+            656,
+            882,
+            700
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "where  $\\mathcal{V}$  is the set of all predicted strings,  $\\mathbf{1}(y,y^{\\prime})$  is an indicator function and  $\\tau = 0.6$ ,  $\\delta = 0.4$ .",
+        "bbox": [
+            509,
+            707,
+            885,
+            739
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3 Experiments",
+        "text_level": 1,
+        "bbox": [
+            510,
+            751,
+            658,
+            766
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3.1 Experiment Setup",
+        "text_level": 1,
+        "bbox": [
+            510,
+            776,
+            700,
+            791
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "We use two representative QA datasets and adopt the same training/dev/testing splits as in previous",
+        "bbox": [
+            509,
+            796,
+            882,
+            829
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "page_footnote",
+        "text": "2We have also tried a few more complex approaches for combining the extractive and generative models. For example, we first train an extractive model, and then append the top-k answer strings from the extractive model at the end of the input for training a generative model. None of them is as good as the simple ensemble approach.",
+        "bbox": [
+            509,
+            835,
+            885,
+            910
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "page_footnote",
+        "text": "we omit the layer notation for simplification",
+        "bbox": [
+            137,
+            894,
+            415,
+            909
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "table",
+        "img_path": "images/fa5e3a0cc0b9374adf1babbc874451ce0c1811a212298d881329b5d691266938.jpg",
+        "table_caption": [],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Model</td><td>Reader Type</td><td>Reader Size (M)</td><td>NQ</td><td>TriviaQA</td></tr><tr><td>REALM(Guu et al., 2020)</td><td>Extractive</td><td>110</td><td>40.4</td><td>N/A</td></tr><tr><td>RAG(Lewis et al., 2020)</td><td>Generative</td><td>400</td><td>44.5</td><td>56.1</td></tr><tr><td>DPR(Karpukhin et al., 2020)</td><td>Extractive</td><td>110</td><td>41.5</td><td>57.9</td></tr><tr><td>T5-FIDbase(Izacard and Grave, 2021)</td><td>Generative</td><td>220</td><td>48.2</td><td>65.0</td></tr><tr><td>T5-FIDlarge(Izacard and Grave, 2021)</td><td>Generative</td><td>770</td><td>51.4</td><td>67.6</td></tr><tr><td>UnitedQA-Ebase(Ours)</td><td>Extractive</td><td>110</td><td>47.7</td><td>66.3</td></tr><tr><td>UnitedQA-ELarge(Ours)</td><td>Extractive</td><td>330</td><td>51.8</td><td>68.9</td></tr><tr><td>UnitedQA-Glarge(Ours)</td><td>Generative</td><td>770</td><td>52.3</td><td>68.6</td></tr><tr><td>UnitedQA-ELarge++ (Ours)</td><td>Ensemble</td><td>3x330</td><td>52.4</td><td>69.6</td></tr><tr><td>UnitedQA-GLarge++ (Ours)</td><td>Ensemble</td><td>3x770</td><td>53.3</td><td>69.2</td></tr><tr><td>UnitedQA (Ours)</td><td>Hybrid</td><td>2x770+330</td><td>54.7</td><td>70.5</td></tr></table>",
+        "bbox": [
+            144,
+            72,
+            853,
+            303
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Table 2: Comparison to state-of-the-art models on the test sets of NaturalQuestions (NQ) and TriviaQA. Exact match score is used for evaluation. The overall best model is in  $\\square$ , the best single model is in  $\\square$ , and the best model with the smallest reader size is in  $\\square$ .",
+        "bbox": [
+            114,
+            313,
+            882,
+            356
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "work (Lee et al., 2019; Karpukhin et al., 2020). Both datasets (see Table 1 for statistics) have been heavily studied in recent work (Lee et al., 2019; Min et al., 2019; Karpukhin et al., 2020; Guu et al., 2020). We follow the standard evaluation protocol and use exact match (EM) as the evaluation metric.",
+        "bbox": [
+            114,
+            381,
+            490,
+            476
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "NaturalQuestions (Kwiatkowski et al., 2019) is composed of questions by real users to Google Search, each with answers identified by human annotators in Wikipedia. The open-domain version of NaturalQuestions (Lee et al., 2019) only consider questions with short answers, i.e. answers with less than 5 tokens. In the NaturalQuestions, the questions are considered to be more information seeking given that the question askers didn't know the answer beforehand. In addition, we use another evaluation set, i.e. the dev set introduced recently by the EfficientQA competition (Min et al., 2021), which is constructed in the same way as the original NaturalQuestions dataset.",
+        "bbox": [
+            114,
+            482,
+            490,
+            707
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "TriviaQA (Joshi et al., 2017) contains trivia question-answer pairs that were scraped from the web. Different from NaturalQuestions, the questions here are written with known answers in mind. Specifically, the unfiltered set has been used for developing open-domain QA models.",
+        "bbox": [
+            114,
+            712,
+            490,
+            808
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Implementation details For a fair comparison, we use the same retrieval module as Karpukhin et al. (2020) for NaturalQuestions and TriviaQA to mitigate the impact of retrieval difference. Specifically, we use DPR (single) for NaturalQuestions and BM25+DPR (multi) for TriviaQA because of",
+        "bbox": [
+            114,
+            813,
+            490,
+            909
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "their best end-to-end performance (Karpukhin et al. 2020). For all the experiments, we use 8 and 16 V100-32GB for base and large model training respectively. We train our models with Adam optimizer of a linear scheduler with a warmup raito of 0.1. The extractive models are trained for up to 8 epochs with a learning rate of  $2\\mathrm{e} - 5$  and a batch passage size per question of 16. The generative models are trained for up to 10 epochs with a learning rate of  $1\\mathrm{e} - 4$ , a batch size of 64, and 100 retrieved passages per question for model training. We select  $\\gamma$  in  $\\{4,8\\}$ . After the best configuration is selected based on the dev set, we run our best models 3 times independently with different random seeds and report the median performance on the test set. We also report ensemble results which are based on the linear interpolation over answer predictions from the 3 models.",
+        "bbox": [
+            509,
+            381,
+            885,
+            671
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "3.2 Main results",
+        "text_level": 1,
+        "bbox": [
+            510,
+            690,
+            658,
+            703
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Single Model Results: We first compare our models to two recent models, REALM (Guu et al., 2020) and RAG (Lewis et al., 2020), which are first pre-trained with different retrieval augmented objectives and then fine-tuned for open-domain QA. In addition, we include as baselines DPR (Karpukhin et al., 2020) and T5-FID (Izacard and Grave, 2021), both of which are based on the same retriever as ours. As shown in Table 2, both our extractive and generative models achieve new state-of-the-art results for both studied datasets. Compared with the recent state-of-the-art extractive",
+        "bbox": [
+            509,
+            715,
+            885,
+            909
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "model (DPR), our base model leads to pronounced  $15\\%$  relative improvements for both NaturalQuestions  $(+6.2$  absolute improvement) and TriviaQA  $(+8.4$  absolute improvement). More importantly, UnitedQA-  $\\mathbf{E}_{\\mathrm{base}}$  achieves comparable or even better performance with regard to generative models of larger size, i.e. RAG and T5-FIDbase. It highlights the importance of proper training strategies for open-domain QA models.",
+        "bbox": [
+            114,
+            74,
+            492,
+            219
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Hybrid Model Results: In order to evaluate the advantage of the hybrid of the extractive and generative models (UnitedQA), we include two homogeneous ensemble baselines, one consisting of only extractive readers (UnitedQA-E++) and the other ensemble of exclusively generative models (UnitedQA-G++.). For homogeneous ensemble cases, the three-way majority prediction is used. For the hybrid of extractive and generative readers, we select a three-model combination from the set of three generative and three extractive models based on the dev set. We observed that combining predictions from two generative models and one extractive model results in the best hybrid model for both datasets. As expected, all ensemble models show an improvement over their single model counterparts. However, the two homogeneous ensemble baselines, UnitedQA-E++ and UnitedQA-G++, only provide marginal gains over the corresponding best single models. The significant improvement brought by our proposed hybrid approach indicates the benefit of combining extractive and generative readers for open-domain QA.",
+        "bbox": [
+            114,
+            225,
+            492,
+            596
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Discussion: Although the proposed hybrid approach has been shown to be highly effective for open-domain QA, we point out that the improved performance comes with increased computational cost. The best combination requires approximately three times the computational cost of a single generative model. Therefore, it would be interesting to explore more efficient hybrid methods, such as effective parameter sharing strategies or unified formulations. Another interesting future direction is to explore customized compression approaches for reducing the model size of retriever and reader separately or jointly through pruning (Han et al., 2016), quantization (Hubara et al., 2018), and knowledge distillation (Hinton et al., 2015). Specifically, given that the hybrid model is more effective, it is likely that a student model can learn more effectively from a hybrid teacher model via knowledge distillation for open-domain QA.",
+        "bbox": [
+            114,
+            602,
+            492,
+            910
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "table",
+        "img_path": "images/e417a4fbc4b8ca697c576e4d37f04ef17665fc4c19dff0f506d7b6a1b2b32cc2.jpg",
+        "table_caption": [],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Model</td><td>NQ</td><td>TriviaQA</td></tr><tr><td>(Cheng et al., 2020) +PDR</td><td>43.3</td><td>60.1</td></tr><tr><td>BERTbase</td><td>44.2</td><td>62.2</td></tr><tr><td>-Multi-object</td><td>43.5</td><td>61.3</td></tr><tr><td>-PDR</td><td>41.8</td><td>60.2</td></tr><tr><td>-Multi-object &amp; PDR</td><td>40.6</td><td>58.5</td></tr><tr><td>UnitedQA-Ebase</td><td>46.0</td><td>65.4</td></tr><tr><td>-Multi-object</td><td>45.2</td><td>64.3</td></tr><tr><td>-PDR</td><td>43.1</td><td>63.8</td></tr><tr><td>-Multi-object &amp; PDR</td><td>42.5</td><td>61.2</td></tr></table>",
+        "bbox": [
+            517,
+            72,
+            880,
+            256
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Table 3: Ablation experiments of the extractive model on the dev sets of NaturalQuestions (NQ) and TriviaQA. Exact match score is reported. The top and bottom models are built on BERTbase and ELECTRAbase, respectively.",
+        "bbox": [
+            509,
+            266,
+            885,
+            338
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "4 Analysis",
+        "text_level": 1,
+        "bbox": [
+            510,
+            367,
+            620,
+            384
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "In this section, we first carry out ablation study on the extractive and generative model improvements. Moreover, we aim to take a deeper look and understand the difference between the two models.",
+        "bbox": [
+            509,
+            399,
+            885,
+            463
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "4.1 Ablation Study",
+        "text_level": 1,
+        "bbox": [
+            510,
+            482,
+            675,
+            497
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "In Table 3, we present ablation experiments on the effectiveness of different textual representations and methods for improving the extractive model UnitedQA-Ebase. Here, we focus on base models, i.e. BERTbase and ELECTRAbase. Note that the row UnitedQA-Ebase is the corresponding base model reported in Table 2. Compared with the MML-based multi-objective (Cheng et al., 2020), we find that a new multi-objective with HardEM at the multi-passage level and MML at the passage level is more effective for open-domain QA. In addition to the multi-objective training, there is a noticeable improvement brought by the regularization method (PDR) which indicates the importance of proper regularization for learning with noisy supervision. Last but not least, the large improvement of ELECTRA over BERT indicates the importance of deriving better text representations for weakly supervised NLP problems. For the UnitedQA-G, we present the ablation study on analyzing the effectiveness of decoder attention bias component and adversarial training mechanism in Table 4. Both techniques contribute to decent improvements over T5-FID with more pronounced gains brought by adversarial training.",
+        "bbox": [
+            509,
+            507,
+            885,
+            910
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "table",
+        "img_path": "images/942fdb4eb5e81ba91a80a3df3506104f14c8d7eec207ceeafc088d83778fe1a6.jpg",
+        "table_caption": [],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Model</td><td>NQ</td><td>TriviaQA</td></tr><tr><td>T5-FIDlarge</td><td>51.4</td><td>67.6</td></tr><tr><td>UnitiedQA-Glarge</td><td>52.3</td><td>68.6</td></tr><tr><td>-Adv Training</td><td>52.0</td><td>68.2</td></tr><tr><td>-Attention Bias</td><td>51.8</td><td>68.1</td></tr></table>",
+        "bbox": [
+            132,
+            72,
+            470,
+            168
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "table",
+        "img_path": "images/a98b932ca098aea95e827b393acc7fcfcf37ad9b647b1f7d66c0f11e9cbfce1a.jpg",
+        "table_caption": [
+            "Table 4: Ablation experiments of the generative model on the test sets of NaturalQuestions (NQ) and TriviaQA. Exact match score is reported."
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td></td><td></td><td>Top-20</td><td>Top-100</td><td>Δ</td></tr><tr><td rowspan=\"3\">NQ</td><td>Retrieval</td><td>78.4</td><td>85.4</td><td>+9%</td></tr><tr><td>United-E</td><td>49.8</td><td>51.8</td><td>+4%</td></tr><tr><td>United-G</td><td>49.3</td><td>52.3</td><td>+6%</td></tr><tr><td rowspan=\"3\">TriviaQA</td><td>Retrieval</td><td>79.9</td><td>84.4</td><td>+6%</td></tr><tr><td>United-E</td><td>67.1</td><td>68.9</td><td>+3%</td></tr><tr><td>United-G</td><td>65.4</td><td>68.6</td><td>+5%</td></tr></table>",
+        "bbox": [
+            117,
+            237,
+            492,
+            372
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Table 5: Retrieval top-  $k$  accuracy and end-to-end QA extract match scores on the test sets of NaturalQuestions (NQ) and TriviaQA. United-E and United-G stand for our extractive and generative models respectively.",
+        "bbox": [
+            114,
+            382,
+            489,
+            441
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "4.2 Impact of Retrieval Accuracy",
+        "text_level": 1,
+        "bbox": [
+            115,
+            467,
+            394,
+            483
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Here, we vary the number of retrieved passages during inference and report the evaluation results in terms of end-to-end QA exact match score of UnitedQA-E and UnitedQA-G along with the corresponding top- $k$  retrieval accuracy. The results are summarized in Table 5. As expected, when the number of retrieved passages increases, both top- $k$  retrieval accuracy and the end-to-end QA performance improve. However, there is a noticeable gap between the improvement of retrieving more passages (i.e., recall) and that of the corresponding end-to-end QA performance, especially for the extractive reader. This is likely caused by additional noise introduced with improved retrieval recall. Specifically, only half of the retriever improvement can be effectively utilized by the extractive model while the generative model can benefit more from retrieving more passages. This suggests that by concatenating all passages in vector space, the generative model are more effective in de-noising in comparison to the extractive model.",
+        "bbox": [
+            114,
+            489,
+            489,
+            826
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "4.3 Breakdown Evaluation",
+        "text_level": 1,
+        "bbox": [
+            115,
+            839,
+            344,
+            853
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Following Lewis et al. (2021), we carry out a breakdown evaluation of model performance over the NaturalQuestions and TriviaQA test sets. Given",
+        "bbox": [
+            114,
+            860,
+            489,
+            909
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "their superior performance, we again only consider our improved extractive and generative models, i.e. UnitedQA-Elarge and UnitedQA-G respectively. The evaluation is summarized in Table 6. In comparison to their corresponding overall performance, both the extractive and generative models achieve much better performance on the \"Overlap\" categories (i.e. \"Question Overlap\" and \"Answer Overlap\") for both NaturalQuestions and TrivaQA, which indicates that both models perform well for question and answer memorization. Different from question and answer memorization, there is a pronounced performance drop for both models on the \"Answer Overlap Only\" category where certain amount of relevance inference capability is required to succeed. Lastly, we see that both extractive and generative models suffer some significant performance degradation for the \"No Overlap\" column which highlights model's generalization evaluation. Nevertheless, the extractive model demonstrate a better QA generalization by achieving a better overall performance on the \"No Overlap\" category for both datasets.",
+        "bbox": [
+            509,
+            74,
+            885,
+            445
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "4.4 Error Analysis",
+        "text_level": 1,
+        "bbox": [
+            510,
+            463,
+            673,
+            479
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Here, we conduct analyses into prediction errors made by the extractive and generative models based on automatic evaluation. For this study, we use the EfficientQA dev set (Min et al., 2021) which is constructed in the same way as the original NaturalQuestions dataset. Specifically, we group prediction errors into three categorizes: 1) common prediction errors made by both the extractive and generative models, 2) prediction errors made by the extractive model, 3) prediction errors produced by the generative model. In the following, we first carry out a manual inspection into the common errors. Then, we compare the prediction errors made by extractive and generative models, respectively.",
+        "bbox": [
+            509,
+            488,
+            885,
+            714
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "First of all, there is an error rate of  $29\\%$  of those consensus predictions made by both extractive and generative models according to the automatic evaluation. Based on 30 randomly selected examples, we find that around  $30\\%$  of those predictions are actually valid answers as shown in the top part of Table 7. In addition to predictions that are answers at different granularity or semantically equivalent ones, some of those prediction errors are likely caused by the ambiguity in questions. As the given example in Table 7, based on the specificity, the model prediction is also a valid answer. This high-",
+        "bbox": [
+            509,
+            715,
+            885,
+            909
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "table",
+        "img_path": "images/c7684f13c12511c878bfd6b84e617aa88df996943558556557fb1c19a838009e.jpg",
+        "table_caption": [],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Dataset</td><td>Model</td><td>Total</td><td>Question Overlap</td><td>No Question Overlap</td><td>Answer Overlap</td><td>Answer Overlap Only</td><td>No Overlap</td></tr><tr><td rowspan=\"2\">NQ</td><td>UnitedQA-G</td><td>52.3</td><td>72.2</td><td>40.5</td><td>62.7</td><td>45.4</td><td>34.0</td></tr><tr><td>UnitedQA-E</td><td>51.8</td><td>69.4</td><td>41.5</td><td>60.1</td><td>45.1</td><td>37.6</td></tr><tr><td rowspan=\"2\">TriviaQA</td><td>UnitedQA-G</td><td>68.6</td><td>88.4</td><td>62.5</td><td>78.1</td><td>69.6</td><td>44.5</td></tr><tr><td>UnitedQA-E</td><td>68.9</td><td>89.3</td><td>62.7</td><td>78.6</td><td>70.6</td><td>44.3</td></tr></table>",
+        "bbox": [
+            144,
+            72,
+            860,
+            209
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "table",
+        "img_path": "images/2578ed96651d5a7d7e3f7d011e29ff323ed181652d2dfe46f5d109c30d289961.jpg",
+        "table_caption": [
+            "Table 6: Breakdown evaluation on NaturalQuestions (NQ) and TriviaQA based on test splits defined in (Lewis et al., 2021). Exact match scores are reported. UnitedQA-E and UnitedQA-G denote our extractive and generative models respectively."
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td colspan=\"2\">Valid Answers</td></tr><tr><td>Different granularity</td><td>Q: When was harry potter and the deathly hallows part 2 movie released\nPrediction: 2011 / Gold: 15 July 2011</td></tr><tr><td>Semantically equivalent</td><td>Q: minimum age limit for chief justic of india\nPrediction: 65 / Gold: 65 years</td></tr><tr><td>Ambiguity question</td><td>Q: who won her first tennis grand slam in 2018\nPrediction: Carolin Wozniacki / Gold: Simona Halep</td></tr><tr><td colspan=\"2\">Wrong Answers</td></tr><tr><td>Part as whole error</td><td>Q: the official U.S. poverty line is based on the cost of what\nPrediction: food / Gold: ICP purchasing power</td></tr><tr><td>Entity confusion</td><td>Q: actor who played tommy in terms of endearment\nPrediction: Jeff Daniels / Gold: Troy Bishop</td></tr><tr><td>Event confusion</td><td>Q: when did the saturdaywanan roughriders last won the grey cup\nPrediction: 2007 / Gold: 2013</td></tr></table>",
+        "bbox": [
+            137,
+            274,
+            863,
+            532
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Table 7: Examples of prediction errors as judged by the automatic evaluation.",
+        "bbox": [
+            235,
+            539,
+            759,
+            555
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "lights the limitation of the current evaluation metric, which does not accurately estimate the existing open-domain QA system capabilities. As shown in the bottom part of Table 7, most of representative errors are due to the confusion of related concepts, entities or events that are mentioned frequently together with the corresponding gold answers.",
+        "bbox": [
+            114,
+            580,
+            490,
+            693
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Next, all questions from the dev set are categorized based on WH question word, i.e. what, which, when, who, how, where. We then report the relative performance change of each WH category for both extractive and generative models over their corresponding overall prediction accuracy in Figure 2. First, it is easy to see that both extractive and generative models achieve the best performance for entity related who questions, which is likely to be the result of high ratio of samples of this type seen during training. In contrast, the answers to what questions can play a much richer syntactic role in context, making it more difficult for both extractive",
+        "bbox": [
+            114,
+            700,
+            492,
+            910
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "and generative models to perform well. Interestingly, the generative model exhibits the strength for temporal reasoning, whereas the extractive model does not. This difference suggests that it is worth exploring better temporal modeling strategies to improve the extractive model in the future.",
+        "bbox": [
+            509,
+            580,
+            885,
+            677
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "5 Related Work",
+        "text_level": 1,
+        "bbox": [
+            510,
+            689,
+            665,
+            703
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Open-domain QA Open-domain QA requires a system to answer questions based on evidence retrieved from a large corpus such as Wikipedia (Voorhees, 2000; Chen et al., 2017). Recent progress has been made towards improving evidence retrieval through both sparse vector models like TF-IDF or BM25 (Chen et al., 2017; Min et al., 2019), and dense vector models based on BERT (Lee et al., 2019; Karpukhin et al., 2020; Guu et al., 2020; Qu et al., 2021). Generally, the dense representations complement the sparse vector methods for passage retrieval as they can potentially give",
+        "bbox": [
+            509,
+            715,
+            885,
+            910
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "image",
+        "img_path": "images/d788d1edae44080357e825ab943ff3d3bd9ccb34708b4cf69c0396d357b5d961.jpg",
+        "image_caption": [
+            "Figure 2: Relative accuracy of different  $WH$  questions. The relative accuracy is the relative change of a  $WH$  category accuracy to the overall model accuracy."
+        ],
+        "image_footnote": [],
+        "bbox": [
+            119,
+            73,
+            480,
+            243
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "high similarity to semantically related text pairs, even without exact lexical overlap. Unlike most work focusing on a pipeline model, Lee et al. (2019) propose a pre-training objective for jointly training both the retrieval encoder and reader. It is further extended by Guu et al. (2020) with a dynamic update of the passage index during the training. Instead, in this work, we focus on a hybrid reader approach for open-domain QA. By simply combining answer predictions from extractive and generative models, our UnitedQA achieves significant improvements over state-of-the-art models.",
+        "bbox": [
+            114,
+            328,
+            490,
+            521
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Reading Comprehension with Noisy Labels There has been a line of work on improving distantly-supervised reading comprehension models by developing learning methods and model architectures that can better use noisy labels. Most of them focus on the document-level QA, where all paragraphs share the same document context. Clark and Gardner (2018) propose a paragraph-pair ranking objective for learning with multiple paragraphs so that the model can distinguish relevant paragraphs from irrelevant ones. In (Lin et al., 2018), a coarse-to-fine model is proposed to handle label noise by aggregating information from relevant paragraphs and then extracting answers from selected ones. Min et al. (2019) propose a hard EM learning scheme where only passage-level loss is considered for document-level QA. More recently, different probabilistic assumptions with corresponding training and inference methods are examined in (Cheng et al., 2020) again for document-level QA with distant supervision. In our work, we further extend the multi-objective formulation proposed in (Cheng et al., 2020) with the hard EM learning (Min et al., 2019) for enhancing extrac",
+        "bbox": [
+            114,
+            523,
+            492,
+            910
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "tive open-domain QA, where the input passages are given by a retrieval model and are typically from different documents.",
+        "bbox": [
+            509,
+            74,
+            884,
+            121
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "6 Conclusion",
+        "text_level": 1,
+        "bbox": [
+            510,
+            135,
+            643,
+            149
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "In this study, we propose a hybrid model for open-domain QA, called UnitedQA, which combines the strengths of extractive and generative readers. We demonstrate the effectiveness of UnitedQA on two popular open-domain QA benchmarks, NaturalQuestions and TriviaQA. Our results show that the proposed UnitedQA model significantly outperforms single extractive and generative models as well as their corresponding homogeneous ensembles, and sets new state-of-the-art on both benchmarks. We also perform a comprehensive empirical study to investigate the relative contributions of different components of our model and the techniques we use to improve the readers.",
+        "bbox": [
+            507,
+            162,
+            887,
+            385
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "For future work, it would be interesting to explore model compression approaches for reducing the model size of retriever and reader separately or jointly through pruning, quantization, and knowledge distillation.",
+        "bbox": [
+            507,
+            387,
+            885,
+            467
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Acknowledgments",
+        "text_level": 1,
+        "bbox": [
+            510,
+            480,
+            672,
+            495
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "We would like to thank the anonymous reviewers for valuable suggestions, Yuning Mao for valuable discussions and comments, and Microsoft Research Technology Engineering team for computing support.",
+        "bbox": [
+            509,
+            506,
+            885,
+            586
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "References",
+        "text_level": 1,
+        "bbox": [
+            510,
+            613,
+            610,
+            629
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "list",
+        "sub_type": "ref_text",
+        "list_items": [
+            "Danqi Chen, Adam Fisch, Jason Weston, and Antoine Bordes. 2017. Reading Wikipedia to answer open-domain questions. In Proceedings of the 55th Annual Meeting of the Association for Computational Linguistics (Volume 1: Long Papers), pages 1870-1879. Association for Computational Linguistics.",
+            "Danqi Chen and Wen-tau Yih. 2020. Open-domain question answering. In Proceedings of the 58th Annual Meeting of the Association for Computational Linguistics: Tutorial Abstracts, pages 34-37, Online. Association for Computational Linguistics.",
+            "Hao Cheng, Ming-Wei Chang, Kenton Lee, and Kristina Toutanova. 2020. Probabilistic assumptions matter: Improved models for distantly-supervised document-level question answering. In Proceedings of the 58th Annual Meeting of the Association for Computational Linguistics, pages 5657-5667, Online. Association for Computational Linguistics."
+        ],
+        "bbox": [
+            510,
+            636,
+            885,
+            910
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "list",
+        "sub_type": "ref_text",
+        "list_items": [
+            "Hao Cheng, Xiaodong Liu, Lis Pereira, Yaoliang Yu, and Jianfeng Gao. 2021. Posterior differential regularization with f-divergence for improving model robustness. In Proceedings of the 2021 Conference of the North American Chapter of the Association for Computational Linguistics: Human Language Technologies, pages 1078-1089, Online. Association for Computational Linguistics.",
+            "Christopher Clark and Matt Gardner. 2018. Simple and effective multi-paragraph reading comprehension. In Proceedings of the 56th Annual Meeting of the Association for Computational Linguistics (Volume 1: Long Papers), pages 845-855. Association for Computational Linguistics.",
+            "Kevin Clark, Minh-Thang Luong, Quoc V. Le, and Christopher D. Manning. 2020. ELECTRA: Pretraining text encoders as discriminators rather than generators. In International Conference on Learning Representations (ICLR).",
+            "Jacob Devlin, Ming-Wei Chang, Kenton Lee, and Kristina Toutanova. 2019. BERT: Pre-training of deep bidirectional transformers for language understanding. In Proceedings of the 2019 Conference of the North American Chapter of the Association for Computational Linguistics: Human Language Technologies, Volume 1 (Long and Short Papers), pages 4171-4186, Minneapolis, Minnesota. Association for Computational Linguistics.",
+            "Kelvin Guu, Kenton Lee, Zora Tung, Panupong Papat, and Mingwei Chang. 2020. Retrieval augmented language model pre-training. In Proceedings of the 37th International Conference on Machine Learning, volume 119 of Proceedings of Machine Learning Research, pages 3929-3938. PMLR.",
+            "Song Han, Huizi Mao, and William J. Dally. 2016. Deep compression: Compressing deep neural network with pruning, trained quantization and huffman coding. In 4th International Conference on Learning Representations, ICLR 2016, San Juan, Puerto Rico, May 2-4, 2016, Conference Track Proceedings.",
+            "Geoffrey Hinton, Oriol Vinyals, and Jeffrey Dean. 2015. Distilling the knowledge in a neural network. In NIPS Deep Learning and Representation Learning Workshop.",
+            "Itay Hubara, Matthieu Courbariaux, Daniel Soudry, Ran El-Yaniv, and Yoshua Bengio. 2018. Quantized neural networks: Training neural networks with low precision weights and activations. Journal of Machine Learning Research, 18(187):1-30.",
+            "Gautier Izacard and Edouard Grave. 2021. Leveraging passage retrieval with generative models for open domain question answering. In Proceedings of the 16th Conference of the European Chapter of the Association for Computational Linguistics: Main Volume, pages 874-880, Online. Association for Computational Linguistics."
+        ],
+        "bbox": [
+            117,
+            76,
+            490,
+            909
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "list",
+        "sub_type": "ref_text",
+        "list_items": [
+            "Haoming Jiang, Pengcheng He, Weizhu Chen, Xiaodong Liu, Jianfeng Gao, and Tuo Zhao. 2020. SMART: Robust and efficient fine-tuning for pretrained natural language models through principled regularized optimization. In Proceedings of the 58th Annual Meeting of the Association for Computational Linguistics, pages 2177-2190, Online. Association for Computational Linguistics.",
+            "Mandar Joshi, Eunsol Choi, Daniel Weld, and Luke Zettlemoyer. 2017. TriviaQA: A large scale distantly supervised challenge dataset for reading comprehension. In Proceedings of the 55th Annual Meeting of the Association for Computational Linguistics (Volume 1: Long Papers), pages 1601-1611, Vancouver, Canada. Association for Computational Linguistics.",
+            "Ying Ju, Fubang Zhao, Shijie Chen, Bowen Zheng, Xuefeng Yang, and Yunfeng Liu. 2019. Technical report on conversational question answering.",
+            "Vladimir Karpukhin, Barlas Oguz, Sewon Min, Patrick Lewis, Ledell Wu, Sergey Edunov, Danqi Chen, and Wen-tau Yih. 2020. Dense passage retrieval for open-domain question answering. In Proceedings of the 2020 Conference on Empirical Methods in Natural Language Processing (EMNLP), pages 6769-6781, Online. Association for Computational Linguistics.",
+            "Tom Kwiatkowski, Jennimaria Palomaki, Olivia Redfield, Michael Collins, Ankur Parikh, Chris Alberti, Danielle Epstein, Illia Polosukhin, Jacob Devlin, Kenton Lee, Kristina Toutanova, Llion Jones, Matthew Kelcey, Ming-Wei Chang, Andrew M. Dai, Jakob Uszkoreit, Quoc Le, and Slav Petrov. 2019. Natural questions: A benchmark for question answering research. Transactions of the Association for Computational Linguistics, 7:453-466.",
+            "Kenton Lee, Ming-Wei Chang, and Kristina Toutanova. 2019. Latent retrieval for weakly supervised open domain question answering. In Proceedings of the 57th Annual Meeting of the Association for Computational Linguistics, pages 6086-6096. Association for Computational Linguistics.",
+            "Patrick Lewis, Ethan Perez, Aleksandra Piktus, Fabio Petroni, Vladimir Karpukhin, Naman Goyal, Heinrich Kuttler, Mike Lewis, Wen-tau Yih, Tim Rocktäschel, Sebastian Riedel, and Douwe Kiela. 2020. Retrieval-augmented generation for knowledge-intensive nlp tasks. In Advances in Neural Information Processing Systems, volume 33, pages 9459-9474. Curran Associates, Inc.",
+            "Patrick Lewis, Pontus Stenetorp, and Sebastian Riedel. 2021. Question and answer test-train overlap in open-domain question answering datasets. In Proceedings of the 16th Conference of the European Chapter of the Association for Computational Linguistics: Main Volume, pages 1000-1008, Online. Association for Computational Linguistics."
+        ],
+        "bbox": [
+            512,
+            76,
+            885,
+            909
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "list",
+        "sub_type": "ref_text",
+        "list_items": [
+            "Yankai Lin, Haozhe Ji, Zhiyuan Liu, and Maosong Sun. 2018. Denoising distantly supervised open-domain question answering. In Proceedings of the 56th Annual Meeting of the Association for Computational Linguistics (Volume 1: Long Papers), pages 1736-1745.",
+            "Sewon Min, Jordan Boyd-Graber, Chris Alberti, Danqi Chen, Eunsol Choi, Michael Collins, Kelvin Guu, Hannaneh Hajishirzi, Kenton Lee, Jennimaria Palomaki, Colin Raffel, Adam Roberts, Tom Kwiatkowski, Patrick Lewis, Yuxiang Wu, Heinrich Kuttler, Linqing Liu, Pasquale Minervini, Pontus Stenetorp, Sebastian Riedel, Sohee Yang, Minjoon Seo, Gautier Izacard, Fabio Petroni, Lucas Hosseini, Nicola De Cao, Edouard Grave, Ikuya Yamada, Sonse Shimaoka, Masatoshi Suzuki, Shumpei Miyawaki, Shun Sato, Ryo Takahashi, Jun Suzuki, Martin Fajcik, Martin Docekal, Korel Ondrej, Pavel Smrz, Hao Cheng, Yelong Shen, Xiaodong Liu, Pengcheng He, Weizhu Chen, Jianfeng Gao, Barlas Oguz, Xilun Chen, Vladimir Karpukhin, Stan Peshterliev, Dmytro Okhonko, Michael Schlichtkrull, Sonal Gupta, Yashar Mehdad, and Wen tau Yih. 2021. NeurIPS 2020 EfficientQA competition: Systems, analyses and lessons learned.",
+            "Sewon Min, Danqi Chen, Hannaneh Hajishirzi, and Luke Zettlemoyer. 2019. A discrete hard EM approach for weakly supervised question answering. In Proceedings of the 2019 Conference on Empirical Methods in Natural Language Processing and the 9th International Joint Conference on Natural Language Processing (EMNLP-IJCNLP), pages 2851-2864, Hong Kong, China. Association for Computational Linguistics.",
+            "Lis Pereira, Xiaodong Liu, Hao Cheng, Hoifung Poon, Jianfeng Gao, and Ichiro Kobayashi. 2021. Targeted adversarial training for natural language understanding. In Proceedings of the 2021 Conference of the North American Chapter of the Association for Computational Linguistics: Human Language Technologies, pages 5385-5393, Online. Association for Computational Linguistics.",
+            "Yingqi Qu, Yuchen Ding, Jing Liu, Kai Liu, Ruiyang Ren, Wayne Xin Zhao, Daxiang Dong, Hua Wu, and Haifeng Wang. 2021. RocketQA: An optimized training approach to dense passage retrieval for open-domain question answering. In Proceedings of the 2021 Conference of the North American Chapter of the Association for Computational Linguistics: Human Language Technologies, pages 5835-5847, Online. Association for Computational Linguistics.",
+            "Colin Raffel, Noam Shazeer, Adam Roberts, Katherine Lee, Sharan Narang, Michael Matena, Yanqi Zhou, Wei Li, and Peter J. Liu. 2020. Exploring the limits of transfer learning with a unified text-to-text transformer. Journal of Machine Learning Research, 21(140):1-67.",
+            "Ellen Voorhees. 2000. The TREC-8 question answering track report."
+        ],
+        "bbox": [
+            117,
+            76,
+            490,
+            908
+        ],
+        "page_idx": 10
+    }
+]

data/2021/2101_00xxx/2101.00178/431507cf-6cad-41d1-9637-1521a5ac3935_model.json

@@ -1,3 +1,1740 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:c7ed8eaa75763cbb00bb6ed267e95db8bca41411136a282f190b3d3fddc3e9eb
-size 85180
+[
+    [
+        {
+            "type": "aside_text",
+            "bbox": [
+                0.023,
+                0.32,
+                0.061,
+                0.718
+            ],
+            "angle": 270,
+            "content": "arXiv:2101.00178v2 [cs.CL] 2 Jun 2021"
+        },
+        {
+            "type": "title",
+            "bbox": [
+                0.136,
+                0.08,
+                0.868,
+                0.102
+            ],
+            "angle": 0,
+            "content": "UnitedQA: A Hybrid Approach for Open Domain Question Answering"
+        },
+        {
+            "type": "text",
+            "bbox": [
+                0.243,
+                0.133,
+                0.768,
+                0.168
+            ],
+            "angle": 0,
+            "content": "Hao Cheng\\(^{1*}\\), Yelong Shen\\(^{2*}\\), Xiaodong Liu\\(^{1}\\), Pengcheng He\\(^{2}\\), Weizhu Chen\\(^{2}\\), Jianfeng Gao\\(^{1}\\)"
+        },
+        {
+            "type": "text",
+            "bbox": [
+                0.328,
+                0.168,
+                0.679,
+                0.183
+            ],
+            "angle": 0,
+            "content": "<sup>1</sup> Microsoft Research <sup>2</sup> Microsoft Azure AI"
+        },
+        {
+            "type": "text",
+            "bbox": [
+                0.179,
+                0.186,
+                0.831,
+                0.201
+            ],
+            "angle": 0,
+            "content": "{chehao, yeshe, xiaodl, penhe, wzchen, jfgao}@microsoft.com"
+        },
+        {
+            "type": "title",
+            "bbox": [
+                0.264,
+                0.265,
+                0.342,
+                0.279
+            ],
+            "angle": 0,
+            "content": "Abstract"
+        },
+        {
+            "type": "text",
+            "bbox": [
+                0.144,
+                0.296,
+                0.462,
+                0.566
+            ],
+            "angle": 0,
+            "content": "To date, most of recent work under the retrieval-reader framework for open-domain QA focuses on either extractive or generative reader exclusively. In this paper, we study a hybrid approach for leveraging the strengths of both models. We apply novel techniques to enhance both extractive and generative readers built upon recent pretrained neural language models, and find that proper training methods can provide large improvements over previous state-of-the-art models. We demonstrate that an hybrid approach by combining answers from both readers can effectively take advantages of extractive and generative answer inference strategies and outperform single models as well as homogeneous ensembles. Our approach outperforms previous state-of-the-art models by 3.3 and 2.7 points in exact match on NaturalQuestions and TriviaQA respectively."
+        },
+        {
+            "type": "title",
+            "bbox": [
+                0.117,
+                0.584,
+                0.262,
+                0.598
+            ],
+            "angle": 0,
+            "content": "1 Introduction"
+        },
+        {
+            "type": "text",
+            "bbox": [
+                0.115,
+                0.611,
+                0.491,
+                0.884
+            ],
+            "angle": 0,
+            "content": "Open-domain question answering (QA) has been a long standing problem in natural language understanding, information retrieval, and related fields (Chen and Yih, 2020). An typical open-domain QA system follows the retrieval-reader framework (Chen et al., 2017; Guu et al., 2020; Karpukhin et al., 2020), where the relevant passages are first retrieved from a large text corpus, and a reader module then navigates multiple passages for answer inference. In this work, we study two paradigms of reader modules, i.e. extractive (Karpukhin et al., 2020; Guu et al., 2020) and generative (Lewis et al., 2020; Izacard and Grave, 2021) readers. The extractive reader extracts contiguous spans from the retrieved passages whereas the generative reader sequentially decodes the answer string which might not be contained in the retrieved passages."
+        },
+        {
+            "type": "text",
+            "bbox": [
+                0.51,
+                0.265,
+                0.887,
+                0.602
+            ],
+            "angle": 0,
+            "content": "Recent work on open-domain QA (Karpukhin et al., 2020; Guu et al., 2020; Lewis et al., 2020; Izacard and Grave, 2021) explores either an extractive reader or a generative reader exclusively. We hypothesize that extractive and generative readers adopt different answer inference strategies, thus a hybrid extractive/generative reader can be a better option for open-domain QA tasks. As shown in Figure 1, compared with prediction agreement among only generative or extractive readers (top-left and bottom-right), the cross prediction agreement between extractive and generative readers (bottom-left) is relatively low (\\(<50\\%\\)). It indicates that answers produced by those two types of models are different and they can be complementary to each other. Therefore, we propose a hybrid reader approach, UnitedQA, which is a simple ensemble approach to combine the predictions from extractive and generative readers. It achieves state-of-the-art results on NaturalQuestions (Kwiatkowski et al., 2019) and TriviaQA (Joshi et al., 2017)."
+        },
+        {
+            "type": "text",
+            "bbox": [
+                0.51,
+                0.604,
+                0.886,
+                0.892
+            ],
+            "angle": 0,
+            "content": "In UnitedQA, the extractive reader (UnitedQA-E) and generative reader (UnitedQA-G) are built upon the pretrained language models, ELECTRA (Clark et al., 2020) and T5 (Raffel et al., 2020), respectively. For the UnitedQA-E, we adopt a weakly-supervised training objective to address the noisy supervision issue caused by the heuristics-based labeling and incorporate the posterior differential regularization (PDR) (Cheng et al., 2021) to improve the model robustness. The UnitedQA-G follows the T5 Fusion-in-Decoder (FID) (Izacard and Grave, 2021) and we make two improvements: first, we add a group of attention bias parameters into the decoder cross-attention block to feature the ranking information of retrieved contexts; second, we add the adversarial training (Ju et al., 2019; Jiang et al., 2020; Pereira et al., 2021) to improve the model generalization ability."
+        },
+        {
+            "type": "text",
+            "bbox": [
+                0.53,
+                0.894,
+                0.885,
+                0.91
+            ],
+            "angle": 0,
+            "content": "The experimental results highlight the effec"
+        },
+        {
+            "type": "page_footnote",
+            "bbox": [
+                0.145,
+                0.896,
+                0.272,
+                0.91
+            ],
+            "angle": 0,
+            "content": "* Equal Contribution"
+        }
+    ],
+    [
+        {
+            "type": "image",
+            "bbox": [
+                0.149,
+                0.096,
+                0.434,
+                0.273
+            ],
+            "angle": 0,
+            "content": null
+        },
+        {
+            "type": "image_caption",
+            "bbox": [
+                0.115,
+                0.3,
+                0.493,
+                0.402
+            ],
+            "angle": 0,
+            "content": "Figure 1: Pairwise prediction agreement ratio. G-1, G-2, G-3 and E-1, E-2, E-3 are three different generative and extractive readers respectively. All readers achieve similar performance (\\(\\approx\\) \\(52\\%\\) exact match) on NaturalQuestions. Higher agreement (\\(>50\\%\\)) in red and lower agreement (\\(<50\\%\\)) in gray. The agreement is calculated based on exact string match."
+        },
+        {
+            "type": "text",
+            "bbox": [
+                0.115,
+                0.429,
+                0.493,
+                0.655
+            ],
+            "angle": 0,
+            "content": "tiveness of the simple hybrid approach of UnitedQA. With both improved extractive and generative readers, UnitedQA sets new state-of-the-art results on two popular open-domain QA datasets, i.e. 54.7 and 70.3 in exact match on NaturalQuestions (Kwiatkowski et al., 2019) and TriviaQA (Joshi et al., 2017), respectively. It is worth noting that our UnitedQA model not only outperforms each single model but also brings more pronounced improvements over homogeneous ensembles of either extractive or generative readers. Last, based on our analyses, UnitedQA-E and UnitedQA-G have advantages in different cases, suggesting they may use different reasoning strategies."
+        },
+        {
+            "type": "title",
+            "bbox": [
+                0.116,
+                0.67,
+                0.221,
+                0.687
+            ],
+            "angle": 0,
+            "content": "2 Method"
+        },
+        {
+            "type": "text",
+            "bbox": [
+                0.115,
+                0.699,
+                0.491,
+                0.859
+            ],
+            "angle": 0,
+            "content": "In this section, we present the overall pipeline of the UnitedQA system, which consists of three components: Retrieval, Reading, and Re-ranking. First, the retrieval module fetches a list of relevant passages from a Wikipedia dump for a given question. Then, the module of hybrid readers produces answer candidates from the set of retrieved passages. Last, the re-ranking module combines the answer candidates with linear interpolation and produces the final answer."
+        },
+        {
+            "type": "text",
+            "bbox": [
+                0.115,
+                0.862,
+                0.49,
+                0.911
+            ],
+            "angle": 0,
+            "content": "Retrieval Following Karpukhin et al. (2020), we consider two methods, BM25 and dense passage retrieval (DPR), for retrieving the support passages"
+        },
+        {
+            "type": "text",
+            "bbox": [
+                0.51,
+                0.076,
+                0.887,
+                0.333
+            ],
+            "angle": 0,
+            "content": "for a given question. For BM25, passages are encoded as bag of words (BOW), and inverse document frequencies are used as the ranking function. For DPR, passages and questions are represented as dense vectors based on two BERT (Devlin et al., 2019) models. The relevance score is then computed based on the dot production between the query and passage vectors. In this paper, we adopt the same implementation as Karpukhin et al. (2020) for retrieving passages. Specifically, the English Wikipedia dump from Dec. 20, 2018 is used as the source documents for retrieval, with the removal of semi-structured data, such as tables or lists. Each document is split into disjoint 100-word passages as the basic retrieval unit. The top-100 passages are then passed for reading."
+        },
+        {
+            "type": "text",
+            "bbox": [
+                0.51,
+                0.335,
+                0.887,
+                0.432
+            ],
+            "angle": 0,
+            "content": "Reading We combine the generative reader and the extractive reader to produce answer candidates over the retrieved passages. Here, we only give a high-level description of our approach. More details regarding our improved extractive and generative models are presented in §2.1 and §2.2 respectively."
+        },
+        {
+            "type": "text",
+            "bbox": [
+                0.51,
+                0.433,
+                0.887,
+                0.609
+            ],
+            "angle": 0,
+            "content": "The generative reader is based on a sequence-to-sequence model pre-trained in a forward-generation fashion on a large corpus, i.e. T5 (Raffel et al., 2020). Similar to Izacard and Grave (2021), the model takes the question and its relevant passages as input, and then generates the answer string token by token. Specifically, the concatenation of all retrieved passages and the corresponding question is used as the encoder input. Then, the decoder performs reasoning over the concatenation of all evidence through an attention mechanism."
+        },
+        {
+            "type": "text",
+            "bbox": [
+                0.51,
+                0.612,
+                0.887,
+                0.838
+            ],
+            "angle": 0,
+            "content": "Following state-of-the-art extractive QA models (Devlin et al., 2019; Karpukhin et al., 2020), our extractive reader is based on a Transformer neural network pre-trained with a cloze style self-supervised objective, i.e. ELECTRA (Clark et al., 2020). Here, a pair of a given question and a support passage is jointly encoded into neural text representations. These representations are then used to define scores or probabilities of possible answer begin and end positions, which are in turn used to define probabilities over possible answer spans. Finally, the answer string probabilities are based on the aggregation over all possible answer spans from the entire set of support passages."
+        },
+        {
+            "type": "title",
+            "bbox": [
+                0.511,
+                0.853,
+                0.66,
+                0.87
+            ],
+            "angle": 0,
+            "content": "2.1 UnitedQA-E"
+        },
+        {
+            "type": "text",
+            "bbox": [
+                0.51,
+                0.878,
+                0.886,
+                0.911
+            ],
+            "angle": 0,
+            "content": "In §2.1.2, we give the problem definition of open-domain QA for extractive reader. Then, we detail"
+        }
+    ],
+    [
+        {
+            "type": "text",
+            "bbox": [
+                0.116,
+                0.076,
+                0.444,
+                0.091
+            ],
+            "angle": 0,
+            "content": "the improvements of UnitedQA-E in \\(\\S 2.1.2\\)"
+        },
+        {
+            "type": "title",
+            "bbox": [
+                0.116,
+                0.101,
+                0.32,
+                0.116
+            ],
+            "angle": 0,
+            "content": "2.1.1 Extractive Reader"
+        },
+        {
+            "type": "text",
+            "bbox": [
+                0.114,
+                0.12,
+                0.491,
+                0.266
+            ],
+            "angle": 0,
+            "content": "Given a question \\( \\mathbf{q} \\) and a set of \\( K \\) retrieved passages \\( \\mathfrak{p}_1, \\ldots, \\mathfrak{p}_K \\), a text encoder produces contextualized representations: \\( \\mathbf{h}_1^k, \\ldots, \\mathbf{h}_T^k \\in \\mathbb{R}^n \\) for the question-passage pair \\( (\\mathbf{q}, \\mathbf{p}_k) \\) in the form of \"[CLS] question [SEP] passage [SEP]\", where [CLS] and [SEP] are special tokens for encoding inputs, \\( T \\) is the maximum sequence length of the input text, and \\( \\mathbf{h}_i^k \\) indicates the contextualized embedding of the \\( i \\)-th token in \\( (\\mathbf{q}, \\mathbf{p}_k) \\)."
+        },
+        {
+            "type": "text",
+            "bbox": [
+                0.115,
+                0.267,
+                0.49,
+                0.429
+            ],
+            "angle": 0,
+            "content": "The extractive reader computes the span-begin score of the \\(i\\)-th token as \\(s_b(i^k) = \\mathbf{w}_b^T\\mathbf{h}_i^k\\) using a weight vector \\(\\mathbf{w}_b \\in \\mathbb{R}^d\\). The span-end score \\(s_e(j^k)\\) is defined in the same way. Thus, the probabilities of a start position \\(i^k\\) and an end position \\(j^k\\) are \\(P_b(i^k) = \\frac{\\exp(s_b(i^k))}{Z_b}\\), \\(P_e(j^k) = \\frac{\\exp(s_e(j^k))}{Z_e}\\), where \\(Z_b, Z_e\\) are normalizing factors defined by the corresponding probability space. The probability of an answer span from \\(i^k\\) to \\(j^k\\) is defined as \\(P_s(i^k, j^k) = P_b(i^k)P_e(j^k)\\)."
+        },
+        {
+            "type": "text",
+            "bbox": [
+                0.115,
+                0.431,
+                0.492,
+                0.672
+            ],
+            "angle": 0,
+            "content": "Here, we consider two probability spaces, passage level and multi-passage level, with the only difference in the computing of \\( Z_{b}, Z_{e} \\). Specifically, the passage-level probability of each answer begins and ends is computed by normalizing all possible positions in the respective passage, i.e. \\( Z_{b} = Z_{b}^{k} = \\sum_{\\mathcal{I}^{k} \\cup \\mathrm{NULL}} \\exp(s_{b}(i)) \\), \\( Z_{e} = Z_{e}^{k} = \\sum_{\\mathcal{I}^{k} \\cup \\mathrm{NULL}} \\exp(s_{e}(j)) \\), where \\( \\mathcal{I}^{k} \\) is the set of all possible positions from the \\( k \\)-th passage and NULL indicates special positions if \\( p_{k} \\) does not support answering the question. Similarly, the multi-passage level probability is computed by normalizing over each answer positions across all \\( K \\) relevant passages, i.e. \\( Z_{b} = Z_{b}^{*} = \\sum_{k} \\sum_{\\mathcal{I}^{k}} \\exp(s_{b}(i)) \\), \\( Z_{e} = Z_{e}^{*} = \\sum_{k} \\sum_{\\mathcal{I}^{k}} \\exp(s_{e}(j)) \\), respectively."
+        },
+        {
+            "type": "text",
+            "bbox": [
+                0.115,
+                0.672,
+                0.492,
+                0.833
+            ],
+            "angle": 0,
+            "content": "Since there are usually multiple plausible mentions for open-domain QA, during training, it is typical to maximize either the marginal log-likelihood (MML) of all correct spans (Karpukhin et al., 2020) or the log-likelihood of the most likely correct span (HardEM) (Min et al., 2019). During inference, the prediction is made based on the candidate answer string score, obtaining as \\( P_{a}(y) = \\sum_{(i,j)\\in \\mathcal{Y}}P_{s}(i,j) \\), where \\( \\mathcal{Y} \\) is the set of spans corresponding to the answer string \\( y \\)."
+        },
+        {
+            "type": "title",
+            "bbox": [
+                0.116,
+                0.843,
+                0.35,
+                0.858
+            ],
+            "angle": 0,
+            "content": "2.1.2 Improvement Method"
+        },
+        {
+            "type": "text",
+            "bbox": [
+                0.115,
+                0.862,
+                0.491,
+                0.911
+            ],
+            "angle": 0,
+            "content": "In addition to better text representations from Clark et al. (2020), we consider two methods for improving the training of the extractive reader."
+        },
+        {
+            "type": "text",
+            "bbox": [
+                0.51,
+                0.075,
+                0.886,
+                0.253
+            ],
+            "angle": 0,
+            "content": "Multi-objective for Weakly-supervised QA The multi-objective formulation is introduced in Cheng et al. (2020) for improving weakly supervised document-level QA. Different from Cheng et al. (2020) where only MML is considered for the multi-objective formulation, we found combining HardEM with MML is more effective for open-domain QA based on our experiments (§4.1). Specifically, we combine a multi-passage HardEM loss with \\(K\\) passage-level MML losses over a batch of \\(K\\) passages"
+        },
+        {
+            "type": "equation",
+            "bbox": [
+                0.545,
+                0.263,
+                0.884,
+                0.334
+            ],
+            "angle": 0,
+            "content": "\\[\n\\begin{array}{l} \\mathcal{L}_{\\mathrm{EXT}}  =   \\log \\max_{(i,j)}P_{s}^{M}(i,j) + \\\\ \\frac {1}{K} \\sum_ {k} \\log \\sum_ {\\left(i ^ {k}, j ^ {k}\\right)} P _ {s} ^ {P} \\left(i ^ {k}, j ^ {k}\\right), \\tag {1} \\\\ \\end{array}\n\\]"
+        },
+        {
+            "type": "text",
+            "bbox": [
+                0.51,
+                0.345,
+                0.886,
+                0.378
+            ],
+            "angle": 0,
+            "content": "where \\(P_{s}^{M}, P_{s}^{P}\\) is the multi-passage level and passage level span probabilities respectively."
+        },
+        {
+            "type": "text",
+            "bbox": [
+                0.51,
+                0.378,
+                0.886,
+                0.571
+            ],
+            "angle": 0,
+            "content": "Posterior Differential Regularization Due to the noisy supervision for open-domain QA (Chen et al., 2017), we investigate the posterior differential regularization (PDR) (Cheng et al., 2021) to improve the robustness of the extractive reader. Different from Cheng et al. (2021) where only clean supervision setting is considered, in this work, we apply PDR to the weakly supervised open-domain QA scenario. Given it is computationally expensive to enumerate all possible spans, we apply two separate regularization terms for the begin and end probabilities at the multi-passage level, respectively,"
+        },
+        {
+            "type": "equation",
+            "bbox": [
+                0.515,
+                0.582,
+                0.884,
+                0.601
+            ],
+            "angle": 0,
+            "content": "\\[\n\\mathcal {L} _ {\\mathrm {P D R}} = D \\left(P _ {b} (i) \\mid P _ {b} ^ {\\prime} (i)\\right) + D \\left(P _ {e} (j) \\mid P _ {e} ^ {\\prime} (j)\\right), \\tag {2}\n\\]"
+        },
+        {
+            "type": "text",
+            "bbox": [
+                0.51,
+                0.612,
+                0.886,
+                0.74
+            ],
+            "angle": 0,
+            "content": "where \\(D(\\cdot |\\cdot)\\) is the squared Hellinger distance, and \\(P_b^{\\prime},P_e^{\\prime}\\) are the probabilities of start and end positions with additive input noise to the token embeddings. Specifically, we sample noise vectors \\(\\epsilon_{1},\\ldots ,\\epsilon_{T}\\) from \\(\\mathcal{N}(0,c^2 I)\\), and add them to the token embeddings as the noisy input, i.e. \\(\\mathbf{v}_1 + \\epsilon_1,\\dots ,\\mathbf{v}_T + \\epsilon_T\\) where \\(c\\) is fixed to 1e-3 throughout our experiments."
+        },
+        {
+            "type": "text",
+            "bbox": [
+                0.51,
+                0.741,
+                0.884,
+                0.772
+            ],
+            "angle": 0,
+            "content": "Based on this, the overall training objective for the extractive reader is"
+        },
+        {
+            "type": "equation",
+            "bbox": [
+                0.598,
+                0.784,
+                0.884,
+                0.802
+            ],
+            "angle": 0,
+            "content": "\\[\n\\mathcal {L} ^ {1} = \\mathcal {L} _ {\\mathrm {E X T}} + \\gamma \\mathcal {L} _ {\\mathrm {P D R}}, \\tag {3}\n\\]"
+        },
+        {
+            "type": "text",
+            "bbox": [
+                0.51,
+                0.815,
+                0.878,
+                0.831
+            ],
+            "angle": 0,
+            "content": "where \\(\\gamma\\) is a regularization scalar hyperparameter."
+        },
+        {
+            "type": "title",
+            "bbox": [
+                0.511,
+                0.841,
+                0.661,
+                0.857
+            ],
+            "angle": 0,
+            "content": "2.2 UnitedQA-G"
+        },
+        {
+            "type": "text",
+            "bbox": [
+                0.51,
+                0.862,
+                0.886,
+                0.911
+            ],
+            "angle": 0,
+            "content": "Here, we first formally define the setup of generative reader for open-domain QA in § 2.2.1 and then present our improvements in § 2.2.2."
+        }
+    ],
+    [
+        {
+            "type": "title",
+            "bbox": [
+                0.116,
+                0.076,
+                0.327,
+                0.09
+            ],
+            "angle": 0,
+            "content": "2.2.1 Generative Reader"
+        },
+        {
+            "type": "text",
+            "bbox": [
+                0.115,
+                0.094,
+                0.491,
+                0.223
+            ],
+            "angle": 0,
+            "content": "Given a question \\( \\mathbf{q} \\) and a set of \\( K \\) retrieved passages \\( \\mathfrak{p}_1, \\ldots, \\mathfrak{p}_K \\), the encoder model encodes each \\( (\\mathfrak{q}, \\mathfrak{p}_k) \\) pair independently, and produces contextualized representation for each token: \\( \\mathbf{h}_i^k \\in \\mathbb{R}^d \\) for the \\( i \\)-th token of the \\( k \\)-th pair. The decoder then performs attention over the concatenation of the representations of all the retrieved passages, and generates the answer string."
+        },
+        {
+            "type": "text",
+            "bbox": [
+                0.115,
+                0.224,
+                0.492,
+                0.306
+            ],
+            "angle": 0,
+            "content": "Let \\(\\mathbf{x}\\) denote the input of the question and all retrieved passages \\(\\mathbf{x} = ((\\mathbf{q},\\mathbf{p}_1),\\dots,(\\mathbf{q},\\mathbf{p}_K))\\) ,and \\(\\mathbf{y}\\) the answer string with its tokens as \\((y_{1},\\ldots ,y_{N})\\) The generative reader is trained to maximize a sequence-to-sequence objective for a given \\((\\mathbf{x},\\mathbf{y})\\)"
+        },
+        {
+            "type": "equation",
+            "bbox": [
+                0.162,
+                0.31,
+                0.49,
+                0.354
+            ],
+            "angle": 0,
+            "content": "\\[\n\\mathcal {L} (\\mathbf {x}, \\mathbf {y}; \\theta) = \\sum_ {i} ^ {N} \\log P _ {\\theta} \\left(y _ {i} \\mid \\mathbf {x}, y _ {1: i - 1}\\right), \\tag {4}\n\\]"
+        },
+        {
+            "type": "text",
+            "bbox": [
+                0.116,
+                0.359,
+                0.49,
+                0.391
+            ],
+            "angle": 0,
+            "content": "where \\(\\theta\\) is the model parameter. During inference, a greedy decoding is used to produce the answer."
+        },
+        {
+            "type": "title",
+            "bbox": [
+                0.116,
+                0.399,
+                0.35,
+                0.414
+            ],
+            "angle": 0,
+            "content": "2.2.2 Improvement Method"
+        },
+        {
+            "type": "text",
+            "bbox": [
+                0.115,
+                0.418,
+                0.491,
+                0.564
+            ],
+            "angle": 0,
+            "content": "Decoder Attention Bias The decoder in the T5 transformer model adopts a cross-attention mechanism to compute attention scores between the decoding answer tokens and all the retrieved passage tokens. Specifically, let \\(\\mathbf{y}_i\\in \\mathbb{R}^d\\) be the query vector of the \\(i\\)-th decoding token\\(^1\\), and \\(\\mathbf{m}_j^k\\in \\mathbb{R}^d\\) be the key vector of the \\(j\\)-th token in \\((q),p_k)\\). The multi-head cross-attention scores in T5 (Raffel et al., 2020) \\(\\mathbf{s}_{i,j}^{k}\\) is calculated as"
+        },
+        {
+            "type": "equation",
+            "bbox": [
+                0.143,
+                0.571,
+                0.489,
+                0.593
+            ],
+            "angle": 0,
+            "content": "\\[\n\\mathbf {s} _ {i, j} ^ {k} = \\operatorname {M u l t i H e a d A t t} \\left(\\mathbf {y} _ {i}, \\mathbf {m} _ {j} ^ {k}\\right) \\in \\mathbb {R} ^ {\\left| \\text {H e a d} \\right|} \\tag {5}\n\\]"
+        },
+        {
+            "type": "text",
+            "bbox": [
+                0.115,
+                0.598,
+                0.492,
+                0.678
+            ],
+            "angle": 0,
+            "content": "where \\(|\\mathrm{Head}|\\) is the number of attention heads. However, it doesn't capture the relevance information of retrieved passages into the reader in (5). To add the relevance feature into the attention block, we revise (5) by incorporating the attention bias"
+        },
+        {
+            "type": "equation",
+            "bbox": [
+                0.166,
+                0.684,
+                0.49,
+                0.705
+            ],
+            "angle": 0,
+            "content": "\\[\n\\mathbf {s} _ {i, j} ^ {k} = \\operatorname {M u l t i H e a d A t t} \\left(\\mathbf {y} _ {i}, \\mathbf {m} _ {j} ^ {k}\\right) + \\mathbf {b} _ {k}, \\tag {6}\n\\]"
+        },
+        {
+            "type": "text",
+            "bbox": [
+                0.115,
+                0.71,
+                0.491,
+                0.807
+            ],
+            "angle": 0,
+            "content": "where \\(\\mathbf{b}_k\\in \\mathbb{R}^{|Head|}\\) is a trainable attention bias vector for all the tokens in the \\(k\\) -th retrieved passage. In the experiments, the maximum retrieved passages is by default set to 100. Thus, the decoder attention bias introduces additional \\(100*|\\mathrm{Head}|\\) parameters for each layer."
+        },
+        {
+            "type": "text",
+            "bbox": [
+                0.115,
+                0.808,
+                0.492,
+                0.889
+            ],
+            "angle": 0,
+            "content": "Adversarial Training Adversarial training creates adversarial examples by adding small perturbations to the embedding layer. Assuming the word(-piece) embedding layer is parameterized by a matrix \\(\\mathbf{V} \\in \\mathcal{R}^{|V| \\times d}\\), \\(|V|\\) is the vocabulary size, and \\(d\\)"
+        },
+        {
+            "type": "table",
+            "bbox": [
+                0.55,
+                0.073,
+                0.849,
+                0.155
+            ],
+            "angle": 0,
+            "content": "<table><tr><td>Dataset</td><td>Train</td><td>Dev</td><td>Test</td></tr><tr><td>NQ</td><td>79168</td><td>8757</td><td>3610</td></tr><tr><td>TriviaQA</td><td>78785</td><td>8837</td><td>11313</td></tr><tr><td>EffcientQA</td><td>-</td><td>1800</td><td>-</td></tr></table>"
+        },
+        {
+            "type": "table_caption",
+            "bbox": [
+                0.527,
+                0.164,
+                0.868,
+                0.179
+            ],
+            "angle": 0,
+            "content": "Table 1: Number of questions in each QA dataset."
+        },
+        {
+            "type": "text",
+            "bbox": [
+                0.51,
+                0.202,
+                0.886,
+                0.234
+            ],
+            "angle": 0,
+            "content": "is the embed-dimension. The adversarial embedding matrix \\(\\hat{\\mathbf{V}}\\) can be obtained by"
+        },
+        {
+            "type": "equation",
+            "bbox": [
+                0.631,
+                0.244,
+                0.884,
+                0.261
+            ],
+            "angle": 0,
+            "content": "\\[\ng _ {\\mathbf {V}} = - \\nabla_ {\\mathbf {V}} \\mathcal {L} (\\mathbf {x}, \\mathbf {y}; \\theta), \\tag {7}\n\\]"
+        },
+        {
+            "type": "equation",
+            "bbox": [
+                0.59,
+                0.264,
+                0.884,
+                0.282
+            ],
+            "angle": 0,
+            "content": "\\[\n\\hat {\\mathbf {V}} = \\mathbf {V} + \\operatorname {S G} \\left(\\epsilon g _ {\\mathbf {V}} / \\| g _ {\\mathbf {V}} \\| _ {2}\\right), \\tag {8}\n\\]"
+        },
+        {
+            "type": "text",
+            "bbox": [
+                0.51,
+                0.291,
+                0.886,
+                0.355
+            ],
+            "angle": 0,
+            "content": "where \\(\\mathrm{SG}(\\cdot)\\) is the stop-gradient operation. We use the adversarial embedding matrix \\(\\hat{\\mathbf{V}}\\) to replace the original \\(\\mathbf{V}\\) in model parameters \\(\\theta\\), and obtain \\(\\hat{\\theta}\\). Thus the adversarial loss can be calculated as"
+        },
+        {
+            "type": "equation",
+            "bbox": [
+                0.597,
+                0.364,
+                0.884,
+                0.382
+            ],
+            "angle": 0,
+            "content": "\\[\n\\mathcal {L} _ {\\mathrm {A T}} (\\mathbf {x}, \\mathbf {y}; \\theta) = \\mathcal {L} (\\mathbf {x}, \\mathbf {y}; \\hat {\\theta}). \\tag {9}\n\\]"
+        },
+        {
+            "type": "text",
+            "bbox": [
+                0.51,
+                0.391,
+                0.884,
+                0.423
+            ],
+            "angle": 0,
+            "content": "Therefore, the overall training objective of the generative reader is"
+        },
+        {
+            "type": "equation",
+            "bbox": [
+                0.549,
+                0.431,
+                0.884,
+                0.45
+            ],
+            "angle": 0,
+            "content": "\\[\n\\mathcal {L} ^ {2} = \\alpha \\mathcal {L} (\\mathbf {x}, \\mathbf {y}; \\theta) + \\beta \\mathcal {L} _ {\\mathrm {A T}} (\\mathbf {x}, \\mathbf {y}; \\theta), \\tag {10}\n\\]"
+        },
+        {
+            "type": "text",
+            "bbox": [
+                0.51,
+                0.458,
+                0.88,
+                0.474
+            ],
+            "angle": 0,
+            "content": "where \\(\\alpha = 0.5, \\beta = 0.5\\) in all of the experiments."
+        },
+        {
+            "type": "title",
+            "bbox": [
+                0.511,
+                0.484,
+                0.7,
+                0.5
+            ],
+            "angle": 0,
+            "content": "2.3 UnitedQA System"
+        },
+        {
+            "type": "text",
+            "bbox": [
+                0.51,
+                0.505,
+                0.886,
+                0.65
+            ],
+            "angle": 0,
+            "content": "The UnitedQA system combines outputs from both extractive and generative models for a given question during inference. Since the output spaces of extractive and generative models are different, we use a simple linear interpolation based on best predictions from each model<sup>2</sup>. Denote the predicted strings from \\( M \\) extractive and \\( N \\) generative models as \\( y_1^E, \\ldots, y_M^E \\) and \\( y_1^G, \\ldots, y_N^G \\), respectively. The hybrid prediction \\( y^* \\) is obtained by"
+        },
+        {
+            "type": "equation",
+            "bbox": [
+                0.525,
+                0.657,
+                0.884,
+                0.701
+            ],
+            "angle": 0,
+            "content": "\\[\n\\underset {y \\in \\mathcal {Y}} {\\operatorname {a r g m a x}} \\tau \\sum_ {m = 1} ^ {M} \\mathbf {1} \\left(y, y _ {m} ^ {E}\\right) + \\delta \\sum_ {n = 1} ^ {N} \\mathbf {1} \\left(y, y _ {n} ^ {G}\\right), \\tag {11}\n\\]"
+        },
+        {
+            "type": "text",
+            "bbox": [
+                0.51,
+                0.708,
+                0.886,
+                0.74
+            ],
+            "angle": 0,
+            "content": "where \\(\\mathcal{V}\\) is the set of all predicted strings, \\(\\mathbf{1}(y,y^{\\prime})\\) is an indicator function and \\(\\tau = 0.6\\), \\(\\delta = 0.4\\)."
+        },
+        {
+            "type": "title",
+            "bbox": [
+                0.511,
+                0.752,
+                0.659,
+                0.768
+            ],
+            "angle": 0,
+            "content": "3 Experiments"
+        },
+        {
+            "type": "title",
+            "bbox": [
+                0.511,
+                0.777,
+                0.702,
+                0.793
+            ],
+            "angle": 0,
+            "content": "3.1 Experiment Setup"
+        },
+        {
+            "type": "text",
+            "bbox": [
+                0.51,
+                0.797,
+                0.884,
+                0.83
+            ],
+            "angle": 0,
+            "content": "We use two representative QA datasets and adopt the same training/dev/testing splits as in previous"
+        },
+        {
+            "type": "page_footnote",
+            "bbox": [
+                0.51,
+                0.836,
+                0.886,
+                0.911
+            ],
+            "angle": 0,
+            "content": "2We have also tried a few more complex approaches for combining the extractive and generative models. For example, we first train an extractive model, and then append the top-k answer strings from the extractive model at the end of the input for training a generative model. None of them is as good as the simple ensemble approach."
+        },
+        {
+            "type": "page_footnote",
+            "bbox": [
+                0.138,
+                0.895,
+                0.416,
+                0.91
+            ],
+            "angle": 0,
+            "content": "we omit the layer notation for simplification"
+        }
+    ],
+    [
+        {
+            "type": "table",
+            "bbox": [
+                0.146,
+                0.073,
+                0.855,
+                0.304
+            ],
+            "angle": 0,
+            "content": "<table><tr><td>Model</td><td>Reader Type</td><td>Reader Size (M)</td><td>NQ</td><td>TriviaQA</td></tr><tr><td>REALM(Guu et al., 2020)</td><td>Extractive</td><td>110</td><td>40.4</td><td>N/A</td></tr><tr><td>RAG(Lewis et al., 2020)</td><td>Generative</td><td>400</td><td>44.5</td><td>56.1</td></tr><tr><td>DPR(Karpukhin et al., 2020)</td><td>Extractive</td><td>110</td><td>41.5</td><td>57.9</td></tr><tr><td>T5-FIDbase(Izacard and Grave, 2021)</td><td>Generative</td><td>220</td><td>48.2</td><td>65.0</td></tr><tr><td>T5-FIDlarge(Izacard and Grave, 2021)</td><td>Generative</td><td>770</td><td>51.4</td><td>67.6</td></tr><tr><td>UnitedQA-Ebase(Ours)</td><td>Extractive</td><td>110</td><td>47.7</td><td>66.3</td></tr><tr><td>UnitedQA-ELarge(Ours)</td><td>Extractive</td><td>330</td><td>51.8</td><td>68.9</td></tr><tr><td>UnitedQA-Glarge(Ours)</td><td>Generative</td><td>770</td><td>52.3</td><td>68.6</td></tr><tr><td>UnitedQA-ELarge++ (Ours)</td><td>Ensemble</td><td>3x330</td><td>52.4</td><td>69.6</td></tr><tr><td>UnitedQA-GLarge++ (Ours)</td><td>Ensemble</td><td>3x770</td><td>53.3</td><td>69.2</td></tr><tr><td>UnitedQA (Ours)</td><td>Hybrid</td><td>2x770+330</td><td>54.7</td><td>70.5</td></tr></table>"
+        },
+        {
+            "type": "table_caption",
+            "bbox": [
+                0.115,
+                0.314,
+                0.884,
+                0.357
+            ],
+            "angle": 0,
+            "content": "Table 2: Comparison to state-of-the-art models on the test sets of NaturalQuestions (NQ) and TriviaQA. Exact match score is used for evaluation. The overall best model is in \\(\\square\\), the best single model is in \\(\\square\\), and the best model with the smallest reader size is in \\(\\square\\)."
+        },
+        {
+            "type": "text",
+            "bbox": [
+                0.115,
+                0.382,
+                0.492,
+                0.478
+            ],
+            "angle": 0,
+            "content": "work (Lee et al., 2019; Karpukhin et al., 2020). Both datasets (see Table 1 for statistics) have been heavily studied in recent work (Lee et al., 2019; Min et al., 2019; Karpukhin et al., 2020; Guu et al., 2020). We follow the standard evaluation protocol and use exact match (EM) as the evaluation metric."
+        },
+        {
+            "type": "text",
+            "bbox": [
+                0.115,
+                0.483,
+                0.491,
+                0.708
+            ],
+            "angle": 0,
+            "content": "NaturalQuestions (Kwiatkowski et al., 2019) is composed of questions by real users to Google Search, each with answers identified by human annotators in Wikipedia. The open-domain version of NaturalQuestions (Lee et al., 2019) only consider questions with short answers, i.e. answers with less than 5 tokens. In the NaturalQuestions, the questions are considered to be more information seeking given that the question askers didn't know the answer beforehand. In addition, we use another evaluation set, i.e. the dev set introduced recently by the EfficientQA competition (Min et al., 2021), which is constructed in the same way as the original NaturalQuestions dataset."
+        },
+        {
+            "type": "text",
+            "bbox": [
+                0.115,
+                0.713,
+                0.492,
+                0.809
+            ],
+            "angle": 0,
+            "content": "TriviaQA (Joshi et al., 2017) contains trivia question-answer pairs that were scraped from the web. Different from NaturalQuestions, the questions here are written with known answers in mind. Specifically, the unfiltered set has been used for developing open-domain QA models."
+        },
+        {
+            "type": "text",
+            "bbox": [
+                0.115,
+                0.814,
+                0.492,
+                0.91
+            ],
+            "angle": 0,
+            "content": "Implementation details For a fair comparison, we use the same retrieval module as Karpukhin et al. (2020) for NaturalQuestions and TriviaQA to mitigate the impact of retrieval difference. Specifically, we use DPR (single) for NaturalQuestions and BM25+DPR (multi) for TriviaQA because of"
+        },
+        {
+            "type": "text",
+            "bbox": [
+                0.51,
+                0.382,
+                0.887,
+                0.673
+            ],
+            "angle": 0,
+            "content": "their best end-to-end performance (Karpukhin et al. 2020). For all the experiments, we use 8 and 16 V100-32GB for base and large model training respectively. We train our models with Adam optimizer of a linear scheduler with a warmup raito of 0.1. The extractive models are trained for up to 8 epochs with a learning rate of \\(2\\mathrm{e} - 5\\) and a batch passage size per question of 16. The generative models are trained for up to 10 epochs with a learning rate of \\(1\\mathrm{e} - 4\\), a batch size of 64, and 100 retrieved passages per question for model training. We select \\(\\gamma\\) in \\(\\{4,8\\}\\). After the best configuration is selected based on the dev set, we run our best models 3 times independently with different random seeds and report the median performance on the test set. We also report ensemble results which are based on the linear interpolation over answer predictions from the 3 models."
+        },
+        {
+            "type": "title",
+            "bbox": [
+                0.511,
+                0.691,
+                0.659,
+                0.705
+            ],
+            "angle": 0,
+            "content": "3.2 Main results"
+        },
+        {
+            "type": "text",
+            "bbox": [
+                0.51,
+                0.717,
+                0.886,
+                0.91
+            ],
+            "angle": 0,
+            "content": "Single Model Results: We first compare our models to two recent models, REALM (Guu et al., 2020) and RAG (Lewis et al., 2020), which are first pre-trained with different retrieval augmented objectives and then fine-tuned for open-domain QA. In addition, we include as baselines DPR (Karpukhin et al., 2020) and T5-FID (Izacard and Grave, 2021), both of which are based on the same retriever as ours. As shown in Table 2, both our extractive and generative models achieve new state-of-the-art results for both studied datasets. Compared with the recent state-of-the-art extractive"
+        }
+    ],
+    [
+        {
+            "type": "text",
+            "bbox": [
+                0.115,
+                0.075,
+                0.493,
+                0.22
+            ],
+            "angle": 0,
+            "content": "model (DPR), our base model leads to pronounced \\(15\\%\\) relative improvements for both NaturalQuestions \\((+6.2\\) absolute improvement) and TriviaQA \\((+8.4\\) absolute improvement). More importantly, UnitedQA- \\(\\mathbf{E}_{\\mathrm{base}}\\) achieves comparable or even better performance with regard to generative models of larger size, i.e. RAG and T5-FIDbase. It highlights the importance of proper training strategies for open-domain QA models."
+        },
+        {
+            "type": "text",
+            "bbox": [
+                0.115,
+                0.227,
+                0.493,
+                0.597
+            ],
+            "angle": 0,
+            "content": "Hybrid Model Results: In order to evaluate the advantage of the hybrid of the extractive and generative models (UnitedQA), we include two homogeneous ensemble baselines, one consisting of only extractive readers (UnitedQA-E++) and the other ensemble of exclusively generative models (UnitedQA-G++.). For homogeneous ensemble cases, the three-way majority prediction is used. For the hybrid of extractive and generative readers, we select a three-model combination from the set of three generative and three extractive models based on the dev set. We observed that combining predictions from two generative models and one extractive model results in the best hybrid model for both datasets. As expected, all ensemble models show an improvement over their single model counterparts. However, the two homogeneous ensemble baselines, UnitedQA-E++ and UnitedQA-G++, only provide marginal gains over the corresponding best single models. The significant improvement brought by our proposed hybrid approach indicates the benefit of combining extractive and generative readers for open-domain QA."
+        },
+        {
+            "type": "text",
+            "bbox": [
+                0.115,
+                0.604,
+                0.493,
+                0.911
+            ],
+            "angle": 0,
+            "content": "Discussion: Although the proposed hybrid approach has been shown to be highly effective for open-domain QA, we point out that the improved performance comes with increased computational cost. The best combination requires approximately three times the computational cost of a single generative model. Therefore, it would be interesting to explore more efficient hybrid methods, such as effective parameter sharing strategies or unified formulations. Another interesting future direction is to explore customized compression approaches for reducing the model size of retriever and reader separately or jointly through pruning (Han et al., 2016), quantization (Hubara et al., 2018), and knowledge distillation (Hinton et al., 2015). Specifically, given that the hybrid model is more effective, it is likely that a student model can learn more effectively from a hybrid teacher model via knowledge distillation for open-domain QA."
+        },
+        {
+            "type": "table",
+            "bbox": [
+                0.518,
+                0.073,
+                0.881,
+                0.257
+            ],
+            "angle": 0,
+            "content": "<table><tr><td>Model</td><td>NQ</td><td>TriviaQA</td></tr><tr><td>(Cheng et al., 2020) +PDR</td><td>43.3</td><td>60.1</td></tr><tr><td>BERTbase</td><td>44.2</td><td>62.2</td></tr><tr><td>-Multi-object</td><td>43.5</td><td>61.3</td></tr><tr><td>-PDR</td><td>41.8</td><td>60.2</td></tr><tr><td>-Multi-object &amp; PDR</td><td>40.6</td><td>58.5</td></tr><tr><td>UnitedQA-Ebase</td><td>46.0</td><td>65.4</td></tr><tr><td>-Multi-object</td><td>45.2</td><td>64.3</td></tr><tr><td>-PDR</td><td>43.1</td><td>63.8</td></tr><tr><td>-Multi-object &amp; PDR</td><td>42.5</td><td>61.2</td></tr></table>"
+        },
+        {
+            "type": "table_caption",
+            "bbox": [
+                0.51,
+                0.267,
+                0.887,
+                0.34
+            ],
+            "angle": 0,
+            "content": "Table 3: Ablation experiments of the extractive model on the dev sets of NaturalQuestions (NQ) and TriviaQA. Exact match score is reported. The top and bottom models are built on BERTbase and ELECTRAbase, respectively."
+        },
+        {
+            "type": "title",
+            "bbox": [
+                0.511,
+                0.368,
+                0.621,
+                0.385
+            ],
+            "angle": 0,
+            "content": "4 Analysis"
+        },
+        {
+            "type": "text",
+            "bbox": [
+                0.51,
+                0.4,
+                0.886,
+                0.464
+            ],
+            "angle": 0,
+            "content": "In this section, we first carry out ablation study on the extractive and generative model improvements. Moreover, we aim to take a deeper look and understand the difference between the two models."
+        },
+        {
+            "type": "title",
+            "bbox": [
+                0.511,
+                0.483,
+                0.677,
+                0.498
+            ],
+            "angle": 0,
+            "content": "4.1 Ablation Study"
+        },
+        {
+            "type": "text",
+            "bbox": [
+                0.51,
+                0.508,
+                0.886,
+                0.911
+            ],
+            "angle": 0,
+            "content": "In Table 3, we present ablation experiments on the effectiveness of different textual representations and methods for improving the extractive model UnitedQA-Ebase. Here, we focus on base models, i.e. BERTbase and ELECTRAbase. Note that the row UnitedQA-Ebase is the corresponding base model reported in Table 2. Compared with the MML-based multi-objective (Cheng et al., 2020), we find that a new multi-objective with HardEM at the multi-passage level and MML at the passage level is more effective for open-domain QA. In addition to the multi-objective training, there is a noticeable improvement brought by the regularization method (PDR) which indicates the importance of proper regularization for learning with noisy supervision. Last but not least, the large improvement of ELECTRA over BERT indicates the importance of deriving better text representations for weakly supervised NLP problems. For the UnitedQA-G, we present the ablation study on analyzing the effectiveness of decoder attention bias component and adversarial training mechanism in Table 4. Both techniques contribute to decent improvements over T5-FID with more pronounced gains brought by adversarial training."
+        }
+    ],
+    [
+        {
+            "type": "table",
+            "bbox": [
+                0.134,
+                0.073,
+                0.472,
+                0.169
+            ],
+            "angle": 0,
+            "content": "<table><tr><td>Model</td><td>NQ</td><td>TriviaQA</td></tr><tr><td>T5-FIDlarge</td><td>51.4</td><td>67.6</td></tr><tr><td>UnitiedQA-Glarge</td><td>52.3</td><td>68.6</td></tr><tr><td>-Adv Training</td><td>52.0</td><td>68.2</td></tr><tr><td>-Attention Bias</td><td>51.8</td><td>68.1</td></tr></table>"
+        },
+        {
+            "type": "table_caption",
+            "bbox": [
+                0.116,
+                0.18,
+                0.49,
+                0.224
+            ],
+            "angle": 0,
+            "content": "Table 4: Ablation experiments of the generative model on the test sets of NaturalQuestions (NQ) and TriviaQA. Exact match score is reported."
+        },
+        {
+            "type": "table",
+            "bbox": [
+                0.118,
+                0.238,
+                0.493,
+                0.373
+            ],
+            "angle": 0,
+            "content": "<table><tr><td></td><td></td><td>Top-20</td><td>Top-100</td><td>Δ</td></tr><tr><td rowspan=\"3\">NQ</td><td>Retrieval</td><td>78.4</td><td>85.4</td><td>+9%</td></tr><tr><td>United-E</td><td>49.8</td><td>51.8</td><td>+4%</td></tr><tr><td>United-G</td><td>49.3</td><td>52.3</td><td>+6%</td></tr><tr><td rowspan=\"3\">TriviaQA</td><td>Retrieval</td><td>79.9</td><td>84.4</td><td>+6%</td></tr><tr><td>United-E</td><td>67.1</td><td>68.9</td><td>+3%</td></tr><tr><td>United-G</td><td>65.4</td><td>68.6</td><td>+5%</td></tr></table>"
+        },
+        {
+            "type": "table_caption",
+            "bbox": [
+                0.115,
+                0.384,
+                0.49,
+                0.442
+            ],
+            "angle": 0,
+            "content": "Table 5: Retrieval top- \\(k\\) accuracy and end-to-end QA extract match scores on the test sets of NaturalQuestions (NQ) and TriviaQA. United-E and United-G stand for our extractive and generative models respectively."
+        },
+        {
+            "type": "title",
+            "bbox": [
+                0.116,
+                0.468,
+                0.395,
+                0.484
+            ],
+            "angle": 0,
+            "content": "4.2 Impact of Retrieval Accuracy"
+        },
+        {
+            "type": "text",
+            "bbox": [
+                0.115,
+                0.49,
+                0.49,
+                0.827
+            ],
+            "angle": 0,
+            "content": "Here, we vary the number of retrieved passages during inference and report the evaluation results in terms of end-to-end QA exact match score of UnitedQA-E and UnitedQA-G along with the corresponding top-\\(k\\) retrieval accuracy. The results are summarized in Table 5. As expected, when the number of retrieved passages increases, both top-\\(k\\) retrieval accuracy and the end-to-end QA performance improve. However, there is a noticeable gap between the improvement of retrieving more passages (i.e., recall) and that of the corresponding end-to-end QA performance, especially for the extractive reader. This is likely caused by additional noise introduced with improved retrieval recall. Specifically, only half of the retriever improvement can be effectively utilized by the extractive model while the generative model can benefit more from retrieving more passages. This suggests that by concatenating all passages in vector space, the generative model are more effective in de-noising in comparison to the extractive model."
+        },
+        {
+            "type": "title",
+            "bbox": [
+                0.116,
+                0.84,
+                0.345,
+                0.854
+            ],
+            "angle": 0,
+            "content": "4.3 Breakdown Evaluation"
+        },
+        {
+            "type": "text",
+            "bbox": [
+                0.115,
+                0.862,
+                0.49,
+                0.91
+            ],
+            "angle": 0,
+            "content": "Following Lewis et al. (2021), we carry out a breakdown evaluation of model performance over the NaturalQuestions and TriviaQA test sets. Given"
+        },
+        {
+            "type": "text",
+            "bbox": [
+                0.51,
+                0.076,
+                0.887,
+                0.446
+            ],
+            "angle": 0,
+            "content": "their superior performance, we again only consider our improved extractive and generative models, i.e. UnitedQA-Elarge and UnitedQA-G respectively. The evaluation is summarized in Table 6. In comparison to their corresponding overall performance, both the extractive and generative models achieve much better performance on the \"Overlap\" categories (i.e. \"Question Overlap\" and \"Answer Overlap\") for both NaturalQuestions and TrivaQA, which indicates that both models perform well for question and answer memorization. Different from question and answer memorization, there is a pronounced performance drop for both models on the \"Answer Overlap Only\" category where certain amount of relevance inference capability is required to succeed. Lastly, we see that both extractive and generative models suffer some significant performance degradation for the \"No Overlap\" column which highlights model's generalization evaluation. Nevertheless, the extractive model demonstrate a better QA generalization by achieving a better overall performance on the \"No Overlap\" category for both datasets."
+        },
+        {
+            "type": "title",
+            "bbox": [
+                0.511,
+                0.464,
+                0.674,
+                0.48
+            ],
+            "angle": 0,
+            "content": "4.4 Error Analysis"
+        },
+        {
+            "type": "text",
+            "bbox": [
+                0.51,
+                0.489,
+                0.886,
+                0.715
+            ],
+            "angle": 0,
+            "content": "Here, we conduct analyses into prediction errors made by the extractive and generative models based on automatic evaluation. For this study, we use the EfficientQA dev set (Min et al., 2021) which is constructed in the same way as the original NaturalQuestions dataset. Specifically, we group prediction errors into three categorizes: 1) common prediction errors made by both the extractive and generative models, 2) prediction errors made by the extractive model, 3) prediction errors produced by the generative model. In the following, we first carry out a manual inspection into the common errors. Then, we compare the prediction errors made by extractive and generative models, respectively."
+        },
+        {
+            "type": "text",
+            "bbox": [
+                0.51,
+                0.717,
+                0.886,
+                0.91
+            ],
+            "angle": 0,
+            "content": "First of all, there is an error rate of \\(29\\%\\) of those consensus predictions made by both extractive and generative models according to the automatic evaluation. Based on 30 randomly selected examples, we find that around \\(30\\%\\) of those predictions are actually valid answers as shown in the top part of Table 7. In addition to predictions that are answers at different granularity or semantically equivalent ones, some of those prediction errors are likely caused by the ambiguity in questions. As the given example in Table 7, based on the specificity, the model prediction is also a valid answer. This high-"
+        }
+    ],
+    [
+        {
+            "type": "table",
+            "bbox": [
+                0.145,
+                0.073,
+                0.861,
+                0.21
+            ],
+            "angle": 0,
+            "content": "<table><tr><td>Dataset</td><td>Model</td><td>Total</td><td>Question Overlap</td><td>No Question Overlap</td><td>Answer Overlap</td><td>Answer Overlap Only</td><td>No Overlap</td></tr><tr><td rowspan=\"2\">NQ</td><td>UnitedQA-G</td><td>52.3</td><td>72.2</td><td>40.5</td><td>62.7</td><td>45.4</td><td>34.0</td></tr><tr><td>UnitedQA-E</td><td>51.8</td><td>69.4</td><td>41.5</td><td>60.1</td><td>45.1</td><td>37.6</td></tr><tr><td rowspan=\"2\">TriviaQA</td><td>UnitedQA-G</td><td>68.6</td><td>88.4</td><td>62.5</td><td>78.1</td><td>69.6</td><td>44.5</td></tr><tr><td>UnitedQA-E</td><td>68.9</td><td>89.3</td><td>62.7</td><td>78.6</td><td>70.6</td><td>44.3</td></tr></table>"
+        },
+        {
+            "type": "table_caption",
+            "bbox": [
+                0.115,
+                0.219,
+                0.885,
+                0.263
+            ],
+            "angle": 0,
+            "content": "Table 6: Breakdown evaluation on NaturalQuestions (NQ) and TriviaQA based on test splits defined in (Lewis et al., 2021). Exact match scores are reported. UnitedQA-E and UnitedQA-G denote our extractive and generative models respectively."
+        },
+        {
+            "type": "table",
+            "bbox": [
+                0.139,
+                0.275,
+                0.864,
+                0.533
+            ],
+            "angle": 0,
+            "content": "<table><tr><td colspan=\"2\">Valid Answers</td></tr><tr><td>Different granularity</td><td>Q: When was harry potter and the deathly hallows part 2 movie released\nPrediction: 2011 / Gold: 15 July 2011</td></tr><tr><td>Semantically equivalent</td><td>Q: minimum age limit for chief justic of india\nPrediction: 65 / Gold: 65 years</td></tr><tr><td>Ambiguity question</td><td>Q: who won her first tennis grand slam in 2018\nPrediction: Carolin Wozniacki / Gold: Simona Halep</td></tr><tr><td colspan=\"2\">Wrong Answers</td></tr><tr><td>Part as whole error</td><td>Q: the official U.S. poverty line is based on the cost of what\nPrediction: food / Gold: ICP purchasing power</td></tr><tr><td>Entity confusion</td><td>Q: actor who played tommy in terms of endearment\nPrediction: Jeff Daniels / Gold: Troy Bishop</td></tr><tr><td>Event confusion</td><td>Q: when did the saturdaywanan roughriders last won the grey cup\nPrediction: 2007 / Gold: 2013</td></tr></table>"
+        },
+        {
+            "type": "table_caption",
+            "bbox": [
+                0.236,
+                0.541,
+                0.761,
+                0.556
+            ],
+            "angle": 0,
+            "content": "Table 7: Examples of prediction errors as judged by the automatic evaluation."
+        },
+        {
+            "type": "text",
+            "bbox": [
+                0.115,
+                0.581,
+                0.491,
+                0.694
+            ],
+            "angle": 0,
+            "content": "lights the limitation of the current evaluation metric, which does not accurately estimate the existing open-domain QA system capabilities. As shown in the bottom part of Table 7, most of representative errors are due to the confusion of related concepts, entities or events that are mentioned frequently together with the corresponding gold answers."
+        },
+        {
+            "type": "text",
+            "bbox": [
+                0.115,
+                0.701,
+                0.494,
+                0.911
+            ],
+            "angle": 0,
+            "content": "Next, all questions from the dev set are categorized based on WH question word, i.e. what, which, when, who, how, where. We then report the relative performance change of each WH category for both extractive and generative models over their corresponding overall prediction accuracy in Figure 2. First, it is easy to see that both extractive and generative models achieve the best performance for entity related who questions, which is likely to be the result of high ratio of samples of this type seen during training. In contrast, the answers to what questions can play a much richer syntactic role in context, making it more difficult for both extractive"
+        },
+        {
+            "type": "text",
+            "bbox": [
+                0.51,
+                0.581,
+                0.886,
+                0.678
+            ],
+            "angle": 0,
+            "content": "and generative models to perform well. Interestingly, the generative model exhibits the strength for temporal reasoning, whereas the extractive model does not. This difference suggests that it is worth exploring better temporal modeling strategies to improve the extractive model in the future."
+        },
+        {
+            "type": "title",
+            "bbox": [
+                0.511,
+                0.69,
+                0.667,
+                0.705
+            ],
+            "angle": 0,
+            "content": "5 Related Work"
+        },
+        {
+            "type": "text",
+            "bbox": [
+                0.51,
+                0.717,
+                0.886,
+                0.911
+            ],
+            "angle": 0,
+            "content": "Open-domain QA Open-domain QA requires a system to answer questions based on evidence retrieved from a large corpus such as Wikipedia (Voorhees, 2000; Chen et al., 2017). Recent progress has been made towards improving evidence retrieval through both sparse vector models like TF-IDF or BM25 (Chen et al., 2017; Min et al., 2019), and dense vector models based on BERT (Lee et al., 2019; Karpukhin et al., 2020; Guu et al., 2020; Qu et al., 2021). Generally, the dense representations complement the sparse vector methods for passage retrieval as they can potentially give"
+        }
+    ],
+    [
+        {
+            "type": "image",
+            "bbox": [
+                0.121,
+                0.074,
+                0.482,
+                0.244
+            ],
+            "angle": 0,
+            "content": null
+        },
+        {
+            "type": "image_caption",
+            "bbox": [
+                0.115,
+                0.255,
+                0.49,
+                0.3
+            ],
+            "angle": 0,
+            "content": "Figure 2: Relative accuracy of different \\( WH \\) questions. The relative accuracy is the relative change of a \\( WH \\) category accuracy to the overall model accuracy."
+        },
+        {
+            "type": "text",
+            "bbox": [
+                0.115,
+                0.329,
+                0.492,
+                0.522
+            ],
+            "angle": 0,
+            "content": "high similarity to semantically related text pairs, even without exact lexical overlap. Unlike most work focusing on a pipeline model, Lee et al. (2019) propose a pre-training objective for jointly training both the retrieval encoder and reader. It is further extended by Guu et al. (2020) with a dynamic update of the passage index during the training. Instead, in this work, we focus on a hybrid reader approach for open-domain QA. By simply combining answer predictions from extractive and generative models, our UnitedQA achieves significant improvements over state-of-the-art models."
+        },
+        {
+            "type": "text",
+            "bbox": [
+                0.115,
+                0.524,
+                0.493,
+                0.911
+            ],
+            "angle": 0,
+            "content": "Reading Comprehension with Noisy Labels There has been a line of work on improving distantly-supervised reading comprehension models by developing learning methods and model architectures that can better use noisy labels. Most of them focus on the document-level QA, where all paragraphs share the same document context. Clark and Gardner (2018) propose a paragraph-pair ranking objective for learning with multiple paragraphs so that the model can distinguish relevant paragraphs from irrelevant ones. In (Lin et al., 2018), a coarse-to-fine model is proposed to handle label noise by aggregating information from relevant paragraphs and then extracting answers from selected ones. Min et al. (2019) propose a hard EM learning scheme where only passage-level loss is considered for document-level QA. More recently, different probabilistic assumptions with corresponding training and inference methods are examined in (Cheng et al., 2020) again for document-level QA with distant supervision. In our work, we further extend the multi-objective formulation proposed in (Cheng et al., 2020) with the hard EM learning (Min et al., 2019) for enhancing extrac"
+        },
+        {
+            "type": "text",
+            "bbox": [
+                0.51,
+                0.076,
+                0.885,
+                0.122
+            ],
+            "angle": 0,
+            "content": "tive open-domain QA, where the input passages are given by a retrieval model and are typically from different documents."
+        },
+        {
+            "type": "title",
+            "bbox": [
+                0.511,
+                0.136,
+                0.644,
+                0.151
+            ],
+            "angle": 0,
+            "content": "6 Conclusion"
+        },
+        {
+            "type": "text",
+            "bbox": [
+                0.509,
+                0.163,
+                0.888,
+                0.386
+            ],
+            "angle": 0,
+            "content": "In this study, we propose a hybrid model for open-domain QA, called UnitedQA, which combines the strengths of extractive and generative readers. We demonstrate the effectiveness of UnitedQA on two popular open-domain QA benchmarks, NaturalQuestions and TriviaQA. Our results show that the proposed UnitedQA model significantly outperforms single extractive and generative models as well as their corresponding homogeneous ensembles, and sets new state-of-the-art on both benchmarks. We also perform a comprehensive empirical study to investigate the relative contributions of different components of our model and the techniques we use to improve the readers."
+        },
+        {
+            "type": "text",
+            "bbox": [
+                0.509,
+                0.388,
+                0.887,
+                0.468
+            ],
+            "angle": 0,
+            "content": "For future work, it would be interesting to explore model compression approaches for reducing the model size of retriever and reader separately or jointly through pruning, quantization, and knowledge distillation."
+        },
+        {
+            "type": "title",
+            "bbox": [
+                0.511,
+                0.481,
+                0.673,
+                0.497
+            ],
+            "angle": 0,
+            "content": "Acknowledgments"
+        },
+        {
+            "type": "text",
+            "bbox": [
+                0.51,
+                0.507,
+                0.886,
+                0.587
+            ],
+            "angle": 0,
+            "content": "We would like to thank the anonymous reviewers for valuable suggestions, Yuning Mao for valuable discussions and comments, and Microsoft Research Technology Engineering team for computing support."
+        },
+        {
+            "type": "title",
+            "bbox": [
+                0.512,
+                0.614,
+                0.611,
+                0.63
+            ],
+            "angle": 0,
+            "content": "References"
+        },
+        {
+            "type": "ref_text",
+            "bbox": [
+                0.512,
+                0.637,
+                0.887,
+                0.718
+            ],
+            "angle": 0,
+            "content": "Danqi Chen, Adam Fisch, Jason Weston, and Antoine Bordes. 2017. Reading Wikipedia to answer open-domain questions. In Proceedings of the 55th Annual Meeting of the Association for Computational Linguistics (Volume 1: Long Papers), pages 1870-1879. Association for Computational Linguistics."
+        },
+        {
+            "type": "ref_text",
+            "bbox": [
+                0.512,
+                0.727,
+                0.887,
+                0.794
+            ],
+            "angle": 0,
+            "content": "Danqi Chen and Wen-tau Yih. 2020. Open-domain question answering. In Proceedings of the 58th Annual Meeting of the Association for Computational Linguistics: Tutorial Abstracts, pages 34-37, Online. Association for Computational Linguistics."
+        },
+        {
+            "type": "ref_text",
+            "bbox": [
+                0.512,
+                0.804,
+                0.887,
+                0.911
+            ],
+            "angle": 0,
+            "content": "Hao Cheng, Ming-Wei Chang, Kenton Lee, and Kristina Toutanova. 2020. Probabilistic assumptions matter: Improved models for distantly-supervised document-level question answering. In Proceedings of the 58th Annual Meeting of the Association for Computational Linguistics, pages 5657-5667, Online. Association for Computational Linguistics."
+        },
+        {
+            "type": "list",
+            "bbox": [
+                0.512,
+                0.637,
+                0.887,
+                0.911
+            ],
+            "angle": 0,
+            "content": null
+        }
+    ],
+    [
+        {
+            "type": "ref_text",
+            "bbox": [
+                0.118,
+                0.077,
+                0.491,
+                0.182
+            ],
+            "angle": 0,
+            "content": "Hao Cheng, Xiaodong Liu, Lis Pereira, Yaoliang Yu, and Jianfeng Gao. 2021. Posterior differential regularization with f-divergence for improving model robustness. In Proceedings of the 2021 Conference of the North American Chapter of the Association for Computational Linguistics: Human Language Technologies, pages 1078-1089, Online. Association for Computational Linguistics."
+        },
+        {
+            "type": "ref_text",
+            "bbox": [
+                0.118,
+                0.192,
+                0.492,
+                0.271
+            ],
+            "angle": 0,
+            "content": "Christopher Clark and Matt Gardner. 2018. Simple and effective multi-paragraph reading comprehension. In Proceedings of the 56th Annual Meeting of the Association for Computational Linguistics (Volume 1: Long Papers), pages 845-855. Association for Computational Linguistics."
+        },
+        {
+            "type": "ref_text",
+            "bbox": [
+                0.118,
+                0.281,
+                0.492,
+                0.348
+            ],
+            "angle": 0,
+            "content": "Kevin Clark, Minh-Thang Luong, Quoc V. Le, and Christopher D. Manning. 2020. ELECTRA: Pretraining text encoders as discriminators rather than generators. In International Conference on Learning Representations (ICLR)."
+        },
+        {
+            "type": "ref_text",
+            "bbox": [
+                0.118,
+                0.357,
+                0.491,
+                0.476
+            ],
+            "angle": 0,
+            "content": "Jacob Devlin, Ming-Wei Chang, Kenton Lee, and Kristina Toutanova. 2019. BERT: Pre-training of deep bidirectional transformers for language understanding. In Proceedings of the 2019 Conference of the North American Chapter of the Association for Computational Linguistics: Human Language Technologies, Volume 1 (Long and Short Papers), pages 4171-4186, Minneapolis, Minnesota. Association for Computational Linguistics."
+        },
+        {
+            "type": "ref_text",
+            "bbox": [
+                0.118,
+                0.485,
+                0.492,
+                0.566
+            ],
+            "angle": 0,
+            "content": "Kelvin Guu, Kenton Lee, Zora Tung, Panupong Papat, and Mingwei Chang. 2020. Retrieval augmented language model pre-training. In Proceedings of the 37th International Conference on Machine Learning, volume 119 of Proceedings of Machine Learning Research, pages 3929-3938. PMLR."
+        },
+        {
+            "type": "ref_text",
+            "bbox": [
+                0.118,
+                0.575,
+                0.492,
+                0.668
+            ],
+            "angle": 0,
+            "content": "Song Han, Huizi Mao, and William J. Dally. 2016. Deep compression: Compressing deep neural network with pruning, trained quantization and huffman coding. In 4th International Conference on Learning Representations, ICLR 2016, San Juan, Puerto Rico, May 2-4, 2016, Conference Track Proceedings."
+        },
+        {
+            "type": "ref_text",
+            "bbox": [
+                0.118,
+                0.678,
+                0.492,
+                0.731
+            ],
+            "angle": 0,
+            "content": "Geoffrey Hinton, Oriol Vinyals, and Jeffrey Dean. 2015. Distilling the knowledge in a neural network. In NIPS Deep Learning and Representation Learning Workshop."
+        },
+        {
+            "type": "ref_text",
+            "bbox": [
+                0.118,
+                0.741,
+                0.492,
+                0.807
+            ],
+            "angle": 0,
+            "content": "Itay Hubara, Matthieu Courbariaux, Daniel Soudry, Ran El-Yaniv, and Yoshua Bengio. 2018. Quantized neural networks: Training neural networks with low precision weights and activations. Journal of Machine Learning Research, 18(187):1-30."
+        },
+        {
+            "type": "ref_text",
+            "bbox": [
+                0.118,
+                0.817,
+                0.492,
+                0.91
+            ],
+            "angle": 0,
+            "content": "Gautier Izacard and Edouard Grave. 2021. Leveraging passage retrieval with generative models for open domain question answering. In Proceedings of the 16th Conference of the European Chapter of the Association for Computational Linguistics: Main Volume, pages 874-880, Online. Association for Computational Linguistics."
+        },
+        {
+            "type": "list",
+            "bbox": [
+                0.118,
+                0.077,
+                0.492,
+                0.91
+            ],
+            "angle": 0,
+            "content": null
+        },
+        {
+            "type": "ref_text",
+            "bbox": [
+                0.513,
+                0.077,
+                0.886,
+                0.182
+            ],
+            "angle": 0,
+            "content": "Haoming Jiang, Pengcheng He, Weizhu Chen, Xiaodong Liu, Jianfeng Gao, and Tuo Zhao. 2020. SMART: Robust and efficient fine-tuning for pretrained natural language models through principled regularized optimization. In Proceedings of the 58th Annual Meeting of the Association for Computational Linguistics, pages 2177-2190, Online. Association for Computational Linguistics."
+        },
+        {
+            "type": "ref_text",
+            "bbox": [
+                0.513,
+                0.192,
+                0.886,
+                0.299
+            ],
+            "angle": 0,
+            "content": "Mandar Joshi, Eunsol Choi, Daniel Weld, and Luke Zettlemoyer. 2017. TriviaQA: A large scale distantly supervised challenge dataset for reading comprehension. In Proceedings of the 55th Annual Meeting of the Association for Computational Linguistics (Volume 1: Long Papers), pages 1601-1611, Vancouver, Canada. Association for Computational Linguistics."
+        },
+        {
+            "type": "ref_text",
+            "bbox": [
+                0.513,
+                0.31,
+                0.886,
+                0.352
+            ],
+            "angle": 0,
+            "content": "Ying Ju, Fubang Zhao, Shijie Chen, Bowen Zheng, Xuefeng Yang, and Yunfeng Liu. 2019. Technical report on conversational question answering."
+        },
+        {
+            "type": "ref_text",
+            "bbox": [
+                0.513,
+                0.362,
+                0.886,
+                0.468
+            ],
+            "angle": 0,
+            "content": "Vladimir Karpukhin, Barlas Oguz, Sewon Min, Patrick Lewis, Ledell Wu, Sergey Edunov, Danqi Chen, and Wen-tau Yih. 2020. Dense passage retrieval for open-domain question answering. In Proceedings of the 2020 Conference on Empirical Methods in Natural Language Processing (EMNLP), pages 6769-6781, Online. Association for Computational Linguistics."
+        },
+        {
+            "type": "ref_text",
+            "bbox": [
+                0.513,
+                0.479,
+                0.886,
+                0.598
+            ],
+            "angle": 0,
+            "content": "Tom Kwiatkowski, Jennimaria Palomaki, Olivia Redfield, Michael Collins, Ankur Parikh, Chris Alberti, Danielle Epstein, Illia Polosukhin, Jacob Devlin, Kenton Lee, Kristina Toutanova, Llion Jones, Matthew Kelcey, Ming-Wei Chang, Andrew M. Dai, Jakob Uszkoreit, Quoc Le, and Slav Petrov. 2019. Natural questions: A benchmark for question answering research. Transactions of the Association for Computational Linguistics, 7:453-466."
+        },
+        {
+            "type": "ref_text",
+            "bbox": [
+                0.513,
+                0.609,
+                0.886,
+                0.689
+            ],
+            "angle": 0,
+            "content": "Kenton Lee, Ming-Wei Chang, and Kristina Toutanova. 2019. Latent retrieval for weakly supervised open domain question answering. In Proceedings of the 57th Annual Meeting of the Association for Computational Linguistics, pages 6086-6096. Association for Computational Linguistics."
+        },
+        {
+            "type": "ref_text",
+            "bbox": [
+                0.513,
+                0.7,
+                0.886,
+                0.805
+            ],
+            "angle": 0,
+            "content": "Patrick Lewis, Ethan Perez, Aleksandra Piktus, Fabio Petroni, Vladimir Karpukhin, Naman Goyal, Heinrich Kuttler, Mike Lewis, Wen-tau Yih, Tim Rocktäschel, Sebastian Riedel, and Douwe Kiela. 2020. Retrieval-augmented generation for knowledge-intensive nlp tasks. In Advances in Neural Information Processing Systems, volume 33, pages 9459-9474. Curran Associates, Inc."
+        },
+        {
+            "type": "ref_text",
+            "bbox": [
+                0.513,
+                0.817,
+                0.886,
+                0.91
+            ],
+            "angle": 0,
+            "content": "Patrick Lewis, Pontus Stenetorp, and Sebastian Riedel. 2021. Question and answer test-train overlap in open-domain question answering datasets. In Proceedings of the 16th Conference of the European Chapter of the Association for Computational Linguistics: Main Volume, pages 1000-1008, Online. Association for Computational Linguistics."
+        },
+        {
+            "type": "list",
+            "bbox": [
+                0.513,
+                0.077,
+                0.886,
+                0.91
+            ],
+            "angle": 0,
+            "content": null
+        }
+    ],
+    [
+        {
+            "type": "ref_text",
+            "bbox": [
+                0.119,
+                0.077,
+                0.491,
+                0.154
+            ],
+            "angle": 0,
+            "content": "Yankai Lin, Haozhe Ji, Zhiyuan Liu, and Maosong Sun. 2018. Denoising distantly supervised open-domain question answering. In Proceedings of the 56th Annual Meeting of the Association for Computational Linguistics (Volume 1: Long Papers), pages 1736-1745."
+        },
+        {
+            "type": "ref_text",
+            "bbox": [
+                0.119,
+                0.163,
+                0.49,
+                0.411
+            ],
+            "angle": 0,
+            "content": "Sewon Min, Jordan Boyd-Graber, Chris Alberti, Danqi Chen, Eunsol Choi, Michael Collins, Kelvin Guu, Hannaneh Hajishirzi, Kenton Lee, Jennimaria Palomaki, Colin Raffel, Adam Roberts, Tom Kwiatkowski, Patrick Lewis, Yuxiang Wu, Heinrich Kuttler, Linqing Liu, Pasquale Minervini, Pontus Stenetorp, Sebastian Riedel, Sohee Yang, Minjoon Seo, Gautier Izacard, Fabio Petroni, Lucas Hosseini, Nicola De Cao, Edouard Grave, Ikuya Yamada, Sonse Shimaoka, Masatoshi Suzuki, Shumpei Miyawaki, Shun Sato, Ryo Takahashi, Jun Suzuki, Martin Fajcik, Martin Docekal, Korel Ondrej, Pavel Smrz, Hao Cheng, Yelong Shen, Xiaodong Liu, Pengcheng He, Weizhu Chen, Jianfeng Gao, Barlas Oguz, Xilun Chen, Vladimir Karpukhin, Stan Peshterliev, Dmytro Okhonko, Michael Schlichtkrull, Sonal Gupta, Yashar Mehdad, and Wen tau Yih. 2021. NeurIPS 2020 EfficientQA competition: Systems, analyses and lessons learned."
+        },
+        {
+            "type": "ref_text",
+            "bbox": [
+                0.119,
+                0.419,
+                0.49,
+                0.537
+            ],
+            "angle": 0,
+            "content": "Sewon Min, Danqi Chen, Hannaneh Hajishirzi, and Luke Zettlemoyer. 2019. A discrete hard EM approach for weakly supervised question answering. In Proceedings of the 2019 Conference on Empirical Methods in Natural Language Processing and the 9th International Joint Conference on Natural Language Processing (EMNLP-IJCNLP), pages 2851-2864, Hong Kong, China. Association for Computational Linguistics."
+        },
+        {
+            "type": "ref_text",
+            "bbox": [
+                0.119,
+                0.544,
+                0.49,
+                0.649
+            ],
+            "angle": 0,
+            "content": "Lis Pereira, Xiaodong Liu, Hao Cheng, Hoifung Poon, Jianfeng Gao, and Ichiro Kobayashi. 2021. Targeted adversarial training for natural language understanding. In Proceedings of the 2021 Conference of the North American Chapter of the Association for Computational Linguistics: Human Language Technologies, pages 5385-5393, Online. Association for Computational Linguistics."
+        },
+        {
+            "type": "ref_text",
+            "bbox": [
+                0.119,
+                0.657,
+                0.49,
+                0.788
+            ],
+            "angle": 0,
+            "content": "Yingqi Qu, Yuchen Ding, Jing Liu, Kai Liu, Ruiyang Ren, Wayne Xin Zhao, Daxiang Dong, Hua Wu, and Haifeng Wang. 2021. RocketQA: An optimized training approach to dense passage retrieval for open-domain question answering. In Proceedings of the 2021 Conference of the North American Chapter of the Association for Computational Linguistics: Human Language Technologies, pages 5835-5847, Online. Association for Computational Linguistics."
+        },
+        {
+            "type": "ref_text",
+            "bbox": [
+                0.119,
+                0.795,
+                0.49,
+                0.874
+            ],
+            "angle": 0,
+            "content": "Colin Raffel, Noam Shazeer, Adam Roberts, Katherine Lee, Sharan Narang, Michael Matena, Yanqi Zhou, Wei Li, and Peter J. Liu. 2020. Exploring the limits of transfer learning with a unified text-to-text transformer. Journal of Machine Learning Research, 21(140):1-67."
+        },
+        {
+            "type": "ref_text",
+            "bbox": [
+                0.119,
+                0.882,
+                0.49,
+                0.909
+            ],
+            "angle": 0,
+            "content": "Ellen Voorhees. 2000. The TREC-8 question answering track report."
+        },
+        {
+            "type": "list",
+            "bbox": [
+                0.119,
+                0.077,
+                0.491,
+                0.909
+            ],
+            "angle": 0,
+            "content": null
+        }
+    ]
+]

data/2021/2101_00xxx/2101.00178/full.md

@@ -1,3 +1,298 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:d35d35bc3421abd166ed74c41b7a5f93103e538b6ef375d2f946523ecb6c3319
-size 48875
+# UnitedQA: A Hybrid Approach for Open Domain Question Answering
+
+Hao Cheng $^{1*}$ , Yelong Shen $^{2*}$ , Xiaodong Liu $^{1}$ , Pengcheng He $^{2}$ , Weizhu Chen $^{2}$ , Jianfeng Gao $^{1}$
+
+<sup>1</sup> Microsoft Research <sup>2</sup> Microsoft Azure AI
+
+{chehao, yeshe, xiaodl, penhe, wzchen, jfgao}@microsoft.com
+
+# Abstract
+
+To date, most of recent work under the retrieval-reader framework for open-domain QA focuses on either extractive or generative reader exclusively. In this paper, we study a hybrid approach for leveraging the strengths of both models. We apply novel techniques to enhance both extractive and generative readers built upon recent pretrained neural language models, and find that proper training methods can provide large improvements over previous state-of-the-art models. We demonstrate that an hybrid approach by combining answers from both readers can effectively take advantages of extractive and generative answer inference strategies and outperform single models as well as homogeneous ensembles. Our approach outperforms previous state-of-the-art models by 3.3 and 2.7 points in exact match on NaturalQuestions and TriviaQA respectively.
+
+# 1 Introduction
+
+Open-domain question answering (QA) has been a long standing problem in natural language understanding, information retrieval, and related fields (Chen and Yih, 2020). An typical open-domain QA system follows the retrieval-reader framework (Chen et al., 2017; Guu et al., 2020; Karpukhin et al., 2020), where the relevant passages are first retrieved from a large text corpus, and a reader module then navigates multiple passages for answer inference. In this work, we study two paradigms of reader modules, i.e. extractive (Karpukhin et al., 2020; Guu et al., 2020) and generative (Lewis et al., 2020; Izacard and Grave, 2021) readers. The extractive reader extracts contiguous spans from the retrieved passages whereas the generative reader sequentially decodes the answer string which might not be contained in the retrieved passages.
+
+Recent work on open-domain QA (Karpukhin et al., 2020; Guu et al., 2020; Lewis et al., 2020; Izacard and Grave, 2021) explores either an extractive reader or a generative reader exclusively. We hypothesize that extractive and generative readers adopt different answer inference strategies, thus a hybrid extractive/generative reader can be a better option for open-domain QA tasks. As shown in Figure 1, compared with prediction agreement among only generative or extractive readers (top-left and bottom-right), the cross prediction agreement between extractive and generative readers (bottom-left) is relatively low ( $<50\%$ ). It indicates that answers produced by those two types of models are different and they can be complementary to each other. Therefore, we propose a hybrid reader approach, UnitedQA, which is a simple ensemble approach to combine the predictions from extractive and generative readers. It achieves state-of-the-art results on NaturalQuestions (Kwiatkowski et al., 2019) and TriviaQA (Joshi et al., 2017).
+
+In UnitedQA, the extractive reader (UnitedQA-E) and generative reader (UnitedQA-G) are built upon the pretrained language models, ELECTRA (Clark et al., 2020) and T5 (Raffel et al., 2020), respectively. For the UnitedQA-E, we adopt a weakly-supervised training objective to address the noisy supervision issue caused by the heuristics-based labeling and incorporate the posterior differential regularization (PDR) (Cheng et al., 2021) to improve the model robustness. The UnitedQA-G follows the T5 Fusion-in-Decoder (FID) (Izacard and Grave, 2021) and we make two improvements: first, we add a group of attention bias parameters into the decoder cross-attention block to feature the ranking information of retrieved contexts; second, we add the adversarial training (Ju et al., 2019; Jiang et al., 2020; Pereira et al., 2021) to improve the model generalization ability.
+
+The experimental results highlight the effec
+
+![](images/e639adf81015e2d37b03aae3c3c09bd6ca0af5b6c190dc1da6d84a01523c4b93.jpg)  
+Figure 1: Pairwise prediction agreement ratio. G-1, G-2, G-3 and E-1, E-2, E-3 are three different generative and extractive readers respectively. All readers achieve similar performance ( $\approx$ $52\%$  exact match) on NaturalQuestions. Higher agreement ( $>50\%$ ) in red and lower agreement ( $<50\%$ ) in gray. The agreement is calculated based on exact string match.
+
+tiveness of the simple hybrid approach of UnitedQA. With both improved extractive and generative readers, UnitedQA sets new state-of-the-art results on two popular open-domain QA datasets, i.e. 54.7 and 70.3 in exact match on NaturalQuestions (Kwiatkowski et al., 2019) and TriviaQA (Joshi et al., 2017), respectively. It is worth noting that our UnitedQA model not only outperforms each single model but also brings more pronounced improvements over homogeneous ensembles of either extractive or generative readers. Last, based on our analyses, UnitedQA-E and UnitedQA-G have advantages in different cases, suggesting they may use different reasoning strategies.
+
+# 2 Method
+
+In this section, we present the overall pipeline of the UnitedQA system, which consists of three components: Retrieval, Reading, and Re-ranking. First, the retrieval module fetches a list of relevant passages from a Wikipedia dump for a given question. Then, the module of hybrid readers produces answer candidates from the set of retrieved passages. Last, the re-ranking module combines the answer candidates with linear interpolation and produces the final answer.
+
+Retrieval Following Karpukhin et al. (2020), we consider two methods, BM25 and dense passage retrieval (DPR), for retrieving the support passages
+
+for a given question. For BM25, passages are encoded as bag of words (BOW), and inverse document frequencies are used as the ranking function. For DPR, passages and questions are represented as dense vectors based on two BERT (Devlin et al., 2019) models. The relevance score is then computed based on the dot production between the query and passage vectors. In this paper, we adopt the same implementation as Karpukhin et al. (2020) for retrieving passages. Specifically, the English Wikipedia dump from Dec. 20, 2018 is used as the source documents for retrieval, with the removal of semi-structured data, such as tables or lists. Each document is split into disjoint 100-word passages as the basic retrieval unit. The top-100 passages are then passed for reading.
+
+Reading We combine the generative reader and the extractive reader to produce answer candidates over the retrieved passages. Here, we only give a high-level description of our approach. More details regarding our improved extractive and generative models are presented in §2.1 and §2.2 respectively.
+
+The generative reader is based on a sequence-to-sequence model pre-trained in a forward-generation fashion on a large corpus, i.e. T5 (Raffel et al., 2020). Similar to Izacard and Grave (2021), the model takes the question and its relevant passages as input, and then generates the answer string token by token. Specifically, the concatenation of all retrieved passages and the corresponding question is used as the encoder input. Then, the decoder performs reasoning over the concatenation of all evidence through an attention mechanism.
+
+Following state-of-the-art extractive QA models (Devlin et al., 2019; Karpukhin et al., 2020), our extractive reader is based on a Transformer neural network pre-trained with a cloze style self-supervised objective, i.e. ELECTRA (Clark et al., 2020). Here, a pair of a given question and a support passage is jointly encoded into neural text representations. These representations are then used to define scores or probabilities of possible answer begin and end positions, which are in turn used to define probabilities over possible answer spans. Finally, the answer string probabilities are based on the aggregation over all possible answer spans from the entire set of support passages.
+
+# 2.1 UnitedQA-E
+
+In §2.1.2, we give the problem definition of open-domain QA for extractive reader. Then, we detail
+
+the improvements of UnitedQA-E in  $\S 2.1.2$
+
+# 2.1.1 Extractive Reader
+
+Given a question  $\mathbf{q}$  and a set of  $K$  retrieved passages  $\mathfrak{p}_1, \ldots, \mathfrak{p}_K$ , a text encoder produces contextualized representations:  $\mathbf{h}_1^k, \ldots, \mathbf{h}_T^k \in \mathbb{R}^n$  for the question-passage pair  $(\mathbf{q}, \mathbf{p}_k)$  in the form of "[CLS] question [SEP] passage [SEP]", where [CLS] and [SEP] are special tokens for encoding inputs,  $T$  is the maximum sequence length of the input text, and  $\mathbf{h}_i^k$  indicates the contextualized embedding of the  $i$ -th token in  $(\mathbf{q}, \mathbf{p}_k)$ .
+
+The extractive reader computes the span-begin score of the  $i$ -th token as  $s_b(i^k) = \mathbf{w}_b^T\mathbf{h}_i^k$  using a weight vector  $\mathbf{w}_b \in \mathbb{R}^d$ . The span-end score  $s_e(j^k)$  is defined in the same way. Thus, the probabilities of a start position  $i^k$  and an end position  $j^k$  are  $P_b(i^k) = \frac{\exp(s_b(i^k))}{Z_b}$ ,  $P_e(j^k) = \frac{\exp(s_e(j^k))}{Z_e}$ , where  $Z_b, Z_e$  are normalizing factors defined by the corresponding probability space. The probability of an answer span from  $i^k$  to  $j^k$  is defined as  $P_s(i^k, j^k) = P_b(i^k)P_e(j^k)$ .
+
+Here, we consider two probability spaces, passage level and multi-passage level, with the only difference in the computing of  $Z_{b}, Z_{e}$ . Specifically, the passage-level probability of each answer begins and ends is computed by normalizing all possible positions in the respective passage, i.e.  $Z_{b} = Z_{b}^{k} = \sum_{\mathcal{I}^{k} \cup \mathrm{NULL}} \exp(s_{b}(i))$ ,  $Z_{e} = Z_{e}^{k} = \sum_{\mathcal{I}^{k} \cup \mathrm{NULL}} \exp(s_{e}(j))$ , where  $\mathcal{I}^{k}$  is the set of all possible positions from the  $k$ -th passage and NULL indicates special positions if  $p_{k}$  does not support answering the question. Similarly, the multi-passage level probability is computed by normalizing over each answer positions across all  $K$  relevant passages, i.e.  $Z_{b} = Z_{b}^{*} = \sum_{k} \sum_{\mathcal{I}^{k}} \exp(s_{b}(i))$ ,  $Z_{e} = Z_{e}^{*} = \sum_{k} \sum_{\mathcal{I}^{k}} \exp(s_{e}(j))$ , respectively.
+
+Since there are usually multiple plausible mentions for open-domain QA, during training, it is typical to maximize either the marginal log-likelihood (MML) of all correct spans (Karpukhin et al., 2020) or the log-likelihood of the most likely correct span (HardEM) (Min et al., 2019). During inference, the prediction is made based on the candidate answer string score, obtaining as  $P_{a}(y) = \sum_{(i,j)\in \mathcal{Y}}P_{s}(i,j)$ , where  $\mathcal{Y}$  is the set of spans corresponding to the answer string  $y$ .
+
+# 2.1.2 Improvement Method
+
+In addition to better text representations from Clark et al. (2020), we consider two methods for improving the training of the extractive reader.
+
+Multi-objective for Weakly-supervised QA The multi-objective formulation is introduced in Cheng et al. (2020) for improving weakly supervised document-level QA. Different from Cheng et al. (2020) where only MML is considered for the multi-objective formulation, we found combining HardEM with MML is more effective for open-domain QA based on our experiments (§4.1). Specifically, we combine a multi-passage HardEM loss with  $K$  passage-level MML losses over a batch of  $K$  passages
+
+$$
+\begin{array}{l} \mathcal{L}_{\mathrm{EXT}}  =   \log \max_{(i,j)}P_{s}^{M}(i,j) + \\ \frac {1}{K} \sum_ {k} \log \sum_ {\left(i ^ {k}, j ^ {k}\right)} P _ {s} ^ {P} \left(i ^ {k}, j ^ {k}\right), \tag {1} \\ \end{array}
+$$
+
+where  $P_{s}^{M}, P_{s}^{P}$  is the multi-passage level and passage level span probabilities respectively.
+
+Posterior Differential Regularization Due to the noisy supervision for open-domain QA (Chen et al., 2017), we investigate the posterior differential regularization (PDR) (Cheng et al., 2021) to improve the robustness of the extractive reader. Different from Cheng et al. (2021) where only clean supervision setting is considered, in this work, we apply PDR to the weakly supervised open-domain QA scenario. Given it is computationally expensive to enumerate all possible spans, we apply two separate regularization terms for the begin and end probabilities at the multi-passage level, respectively,
+
+$$
+\mathcal {L} _ {\mathrm {P D R}} = D \left(P _ {b} (i) \mid P _ {b} ^ {\prime} (i)\right) + D \left(P _ {e} (j) \mid P _ {e} ^ {\prime} (j)\right), \tag {2}
+$$
+
+where  $D(\cdot |\cdot)$  is the squared Hellinger distance, and  $P_b^{\prime},P_e^{\prime}$  are the probabilities of start and end positions with additive input noise to the token embeddings. Specifically, we sample noise vectors  $\epsilon_{1},\ldots ,\epsilon_{T}$  from  $\mathcal{N}(0,c^2 I)$ , and add them to the token embeddings as the noisy input, i.e.  $\mathbf{v}_1 + \epsilon_1,\dots ,\mathbf{v}_T + \epsilon_T$  where  $c$  is fixed to 1e-3 throughout our experiments.
+
+Based on this, the overall training objective for the extractive reader is
+
+$$
+\mathcal {L} ^ {1} = \mathcal {L} _ {\mathrm {E X T}} + \gamma \mathcal {L} _ {\mathrm {P D R}}, \tag {3}
+$$
+
+where  $\gamma$  is a regularization scalar hyperparameter.
+
+# 2.2 UnitedQA-G
+
+Here, we first formally define the setup of generative reader for open-domain QA in § 2.2.1 and then present our improvements in § 2.2.2.
+
+# 2.2.1 Generative Reader
+
+Given a question  $\mathbf{q}$  and a set of  $K$  retrieved passages  $\mathfrak{p}_1, \ldots, \mathfrak{p}_K$ , the encoder model encodes each  $(\mathfrak{q}, \mathfrak{p}_k)$  pair independently, and produces contextualized representation for each token:  $\mathbf{h}_i^k \in \mathbb{R}^d$  for the  $i$ -th token of the  $k$ -th pair. The decoder then performs attention over the concatenation of the representations of all the retrieved passages, and generates the answer string.
+
+Let  $\mathbf{x}$  denote the input of the question and all retrieved passages  $\mathbf{x} = ((\mathbf{q},\mathbf{p}_1),\dots,(\mathbf{q},\mathbf{p}_K))$  ,and  $\mathbf{y}$  the answer string with its tokens as  $(y_{1},\ldots ,y_{N})$  The generative reader is trained to maximize a sequence-to-sequence objective for a given  $(\mathbf{x},\mathbf{y})$
+
+$$
+\mathcal {L} (\mathbf {x}, \mathbf {y}; \theta) = \sum_ {i} ^ {N} \log P _ {\theta} \left(y _ {i} \mid \mathbf {x}, y _ {1: i - 1}\right), \tag {4}
+$$
+
+where  $\theta$  is the model parameter. During inference, a greedy decoding is used to produce the answer.
+
+# 2.2.2 Improvement Method
+
+Decoder Attention Bias The decoder in the T5 transformer model adopts a cross-attention mechanism to compute attention scores between the decoding answer tokens and all the retrieved passage tokens. Specifically, let  $\mathbf{y}_i\in \mathbb{R}^d$  be the query vector of the  $i$ -th decoding token $^1$ , and  $\mathbf{m}_j^k\in \mathbb{R}^d$  be the key vector of the  $j$ -th token in  $(q),p_k)$ . The multi-head cross-attention scores in T5 (Raffel et al., 2020)  $\mathbf{s}_{i,j}^{k}$  is calculated as
+
+$$
+\mathbf {s} _ {i, j} ^ {k} = \operatorname {M u l t i H e a d A t t} \left(\mathbf {y} _ {i}, \mathbf {m} _ {j} ^ {k}\right) \in \mathbb {R} ^ {\left| \text {H e a d} \right|} \tag {5}
+$$
+
+where  $|\mathrm{Head}|$  is the number of attention heads. However, it doesn't capture the relevance information of retrieved passages into the reader in (5). To add the relevance feature into the attention block, we revise (5) by incorporating the attention bias
+
+$$
+\mathbf {s} _ {i, j} ^ {k} = \operatorname {M u l t i H e a d A t t} \left(\mathbf {y} _ {i}, \mathbf {m} _ {j} ^ {k}\right) + \mathbf {b} _ {k}, \tag {6}
+$$
+
+where  $\mathbf{b}_k\in \mathbb{R}^{|Head|}$  is a trainable attention bias vector for all the tokens in the  $k$  -th retrieved passage. In the experiments, the maximum retrieved passages is by default set to 100. Thus, the decoder attention bias introduces additional  $100*|\mathrm{Head}|$  parameters for each layer.
+
+Adversarial Training Adversarial training creates adversarial examples by adding small perturbations to the embedding layer. Assuming the word(-piece) embedding layer is parameterized by a matrix  $\mathbf{V} \in \mathcal{R}^{|V| \times d}$ ,  $|V|$  is the vocabulary size, and  $d$
+
+<table><tr><td>Dataset</td><td>Train</td><td>Dev</td><td>Test</td></tr><tr><td>NQ</td><td>79168</td><td>8757</td><td>3610</td></tr><tr><td>TriviaQA</td><td>78785</td><td>8837</td><td>11313</td></tr><tr><td>EffcientQA</td><td>-</td><td>1800</td><td>-</td></tr></table>
+
+Table 1: Number of questions in each QA dataset.
+
+is the embed-dimension. The adversarial embedding matrix  $\hat{\mathbf{V}}$  can be obtained by
+
+$$
+g _ {\mathbf {V}} = - \nabla_ {\mathbf {V}} \mathcal {L} (\mathbf {x}, \mathbf {y}; \theta), \tag {7}
+$$
+
+$$
+\hat {\mathbf {V}} = \mathbf {V} + \operatorname {S G} \left(\epsilon g _ {\mathbf {V}} / \| g _ {\mathbf {V}} \| _ {2}\right), \tag {8}
+$$
+
+where  $\mathrm{SG}(\cdot)$  is the stop-gradient operation. We use the adversarial embedding matrix  $\hat{\mathbf{V}}$  to replace the original  $\mathbf{V}$  in model parameters  $\theta$ , and obtain  $\hat{\theta}$ . Thus the adversarial loss can be calculated as
+
+$$
+\mathcal {L} _ {\mathrm {A T}} (\mathbf {x}, \mathbf {y}; \theta) = \mathcal {L} (\mathbf {x}, \mathbf {y}; \hat {\theta}). \tag {9}
+$$
+
+Therefore, the overall training objective of the generative reader is
+
+$$
+\mathcal {L} ^ {2} = \alpha \mathcal {L} (\mathbf {x}, \mathbf {y}; \theta) + \beta \mathcal {L} _ {\mathrm {A T}} (\mathbf {x}, \mathbf {y}; \theta), \tag {10}
+$$
+
+where  $\alpha = 0.5, \beta = 0.5$  in all of the experiments.
+
+# 2.3 UnitedQA System
+
+The UnitedQA system combines outputs from both extractive and generative models for a given question during inference. Since the output spaces of extractive and generative models are different, we use a simple linear interpolation based on best predictions from each model<sup>2</sup>. Denote the predicted strings from  $M$  extractive and  $N$  generative models as  $y_1^E, \ldots, y_M^E$  and  $y_1^G, \ldots, y_N^G$ , respectively. The hybrid prediction  $y^*$  is obtained by
+
+$$
+\underset {y \in \mathcal {Y}} {\operatorname {a r g m a x}} \tau \sum_ {m = 1} ^ {M} \mathbf {1} \left(y, y _ {m} ^ {E}\right) + \delta \sum_ {n = 1} ^ {N} \mathbf {1} \left(y, y _ {n} ^ {G}\right), \tag {11}
+$$
+
+where  $\mathcal{V}$  is the set of all predicted strings,  $\mathbf{1}(y,y^{\prime})$  is an indicator function and  $\tau = 0.6$ ,  $\delta = 0.4$ .
+
+# 3 Experiments
+
+# 3.1 Experiment Setup
+
+We use two representative QA datasets and adopt the same training/dev/testing splits as in previous
+
+<table><tr><td>Model</td><td>Reader Type</td><td>Reader Size (M)</td><td>NQ</td><td>TriviaQA</td></tr><tr><td>REALM(Guu et al., 2020)</td><td>Extractive</td><td>110</td><td>40.4</td><td>N/A</td></tr><tr><td>RAG(Lewis et al., 2020)</td><td>Generative</td><td>400</td><td>44.5</td><td>56.1</td></tr><tr><td>DPR(Karpukhin et al., 2020)</td><td>Extractive</td><td>110</td><td>41.5</td><td>57.9</td></tr><tr><td>T5-FIDbase(Izacard and Grave, 2021)</td><td>Generative</td><td>220</td><td>48.2</td><td>65.0</td></tr><tr><td>T5-FIDlarge(Izacard and Grave, 2021)</td><td>Generative</td><td>770</td><td>51.4</td><td>67.6</td></tr><tr><td>UnitedQA-Ebase(Ours)</td><td>Extractive</td><td>110</td><td>47.7</td><td>66.3</td></tr><tr><td>UnitedQA-ELarge(Ours)</td><td>Extractive</td><td>330</td><td>51.8</td><td>68.9</td></tr><tr><td>UnitedQA-Glarge(Ours)</td><td>Generative</td><td>770</td><td>52.3</td><td>68.6</td></tr><tr><td>UnitedQA-ELarge++ (Ours)</td><td>Ensemble</td><td>3x330</td><td>52.4</td><td>69.6</td></tr><tr><td>UnitedQA-GLarge++ (Ours)</td><td>Ensemble</td><td>3x770</td><td>53.3</td><td>69.2</td></tr><tr><td>UnitedQA (Ours)</td><td>Hybrid</td><td>2x770+330</td><td>54.7</td><td>70.5</td></tr></table>
+
+Table 2: Comparison to state-of-the-art models on the test sets of NaturalQuestions (NQ) and TriviaQA. Exact match score is used for evaluation. The overall best model is in  $\square$ , the best single model is in  $\square$ , and the best model with the smallest reader size is in  $\square$ .
+
+work (Lee et al., 2019; Karpukhin et al., 2020). Both datasets (see Table 1 for statistics) have been heavily studied in recent work (Lee et al., 2019; Min et al., 2019; Karpukhin et al., 2020; Guu et al., 2020). We follow the standard evaluation protocol and use exact match (EM) as the evaluation metric.
+
+NaturalQuestions (Kwiatkowski et al., 2019) is composed of questions by real users to Google Search, each with answers identified by human annotators in Wikipedia. The open-domain version of NaturalQuestions (Lee et al., 2019) only consider questions with short answers, i.e. answers with less than 5 tokens. In the NaturalQuestions, the questions are considered to be more information seeking given that the question askers didn't know the answer beforehand. In addition, we use another evaluation set, i.e. the dev set introduced recently by the EfficientQA competition (Min et al., 2021), which is constructed in the same way as the original NaturalQuestions dataset.
+
+TriviaQA (Joshi et al., 2017) contains trivia question-answer pairs that were scraped from the web. Different from NaturalQuestions, the questions here are written with known answers in mind. Specifically, the unfiltered set has been used for developing open-domain QA models.
+
+Implementation details For a fair comparison, we use the same retrieval module as Karpukhin et al. (2020) for NaturalQuestions and TriviaQA to mitigate the impact of retrieval difference. Specifically, we use DPR (single) for NaturalQuestions and BM25+DPR (multi) for TriviaQA because of
+
+their best end-to-end performance (Karpukhin et al. 2020). For all the experiments, we use 8 and 16 V100-32GB for base and large model training respectively. We train our models with Adam optimizer of a linear scheduler with a warmup raito of 0.1. The extractive models are trained for up to 8 epochs with a learning rate of  $2\mathrm{e} - 5$  and a batch passage size per question of 16. The generative models are trained for up to 10 epochs with a learning rate of  $1\mathrm{e} - 4$ , a batch size of 64, and 100 retrieved passages per question for model training. We select  $\gamma$  in  $\{4,8\}$ . After the best configuration is selected based on the dev set, we run our best models 3 times independently with different random seeds and report the median performance on the test set. We also report ensemble results which are based on the linear interpolation over answer predictions from the 3 models.
+
+# 3.2 Main results
+
+Single Model Results: We first compare our models to two recent models, REALM (Guu et al., 2020) and RAG (Lewis et al., 2020), which are first pre-trained with different retrieval augmented objectives and then fine-tuned for open-domain QA. In addition, we include as baselines DPR (Karpukhin et al., 2020) and T5-FID (Izacard and Grave, 2021), both of which are based on the same retriever as ours. As shown in Table 2, both our extractive and generative models achieve new state-of-the-art results for both studied datasets. Compared with the recent state-of-the-art extractive
+
+model (DPR), our base model leads to pronounced  $15\%$  relative improvements for both NaturalQuestions  $(+6.2$  absolute improvement) and TriviaQA  $(+8.4$  absolute improvement). More importantly, UnitedQA-  $\mathbf{E}_{\mathrm{base}}$  achieves comparable or even better performance with regard to generative models of larger size, i.e. RAG and T5-FIDbase. It highlights the importance of proper training strategies for open-domain QA models.
+
+Hybrid Model Results: In order to evaluate the advantage of the hybrid of the extractive and generative models (UnitedQA), we include two homogeneous ensemble baselines, one consisting of only extractive readers (UnitedQA-E++) and the other ensemble of exclusively generative models (UnitedQA-G++.). For homogeneous ensemble cases, the three-way majority prediction is used. For the hybrid of extractive and generative readers, we select a three-model combination from the set of three generative and three extractive models based on the dev set. We observed that combining predictions from two generative models and one extractive model results in the best hybrid model for both datasets. As expected, all ensemble models show an improvement over their single model counterparts. However, the two homogeneous ensemble baselines, UnitedQA-E++ and UnitedQA-G++, only provide marginal gains over the corresponding best single models. The significant improvement brought by our proposed hybrid approach indicates the benefit of combining extractive and generative readers for open-domain QA.
+
+Discussion: Although the proposed hybrid approach has been shown to be highly effective for open-domain QA, we point out that the improved performance comes with increased computational cost. The best combination requires approximately three times the computational cost of a single generative model. Therefore, it would be interesting to explore more efficient hybrid methods, such as effective parameter sharing strategies or unified formulations. Another interesting future direction is to explore customized compression approaches for reducing the model size of retriever and reader separately or jointly through pruning (Han et al., 2016), quantization (Hubara et al., 2018), and knowledge distillation (Hinton et al., 2015). Specifically, given that the hybrid model is more effective, it is likely that a student model can learn more effectively from a hybrid teacher model via knowledge distillation for open-domain QA.
+
+<table><tr><td>Model</td><td>NQ</td><td>TriviaQA</td></tr><tr><td>(Cheng et al., 2020) +PDR</td><td>43.3</td><td>60.1</td></tr><tr><td>BERTbase</td><td>44.2</td><td>62.2</td></tr><tr><td>-Multi-object</td><td>43.5</td><td>61.3</td></tr><tr><td>-PDR</td><td>41.8</td><td>60.2</td></tr><tr><td>-Multi-object &amp; PDR</td><td>40.6</td><td>58.5</td></tr><tr><td>UnitedQA-Ebase</td><td>46.0</td><td>65.4</td></tr><tr><td>-Multi-object</td><td>45.2</td><td>64.3</td></tr><tr><td>-PDR</td><td>43.1</td><td>63.8</td></tr><tr><td>-Multi-object &amp; PDR</td><td>42.5</td><td>61.2</td></tr></table>
+
+Table 3: Ablation experiments of the extractive model on the dev sets of NaturalQuestions (NQ) and TriviaQA. Exact match score is reported. The top and bottom models are built on BERTbase and ELECTRAbase, respectively.
+
+# 4 Analysis
+
+In this section, we first carry out ablation study on the extractive and generative model improvements. Moreover, we aim to take a deeper look and understand the difference between the two models.
+
+# 4.1 Ablation Study
+
+In Table 3, we present ablation experiments on the effectiveness of different textual representations and methods for improving the extractive model UnitedQA-Ebase. Here, we focus on base models, i.e. BERTbase and ELECTRAbase. Note that the row UnitedQA-Ebase is the corresponding base model reported in Table 2. Compared with the MML-based multi-objective (Cheng et al., 2020), we find that a new multi-objective with HardEM at the multi-passage level and MML at the passage level is more effective for open-domain QA. In addition to the multi-objective training, there is a noticeable improvement brought by the regularization method (PDR) which indicates the importance of proper regularization for learning with noisy supervision. Last but not least, the large improvement of ELECTRA over BERT indicates the importance of deriving better text representations for weakly supervised NLP problems. For the UnitedQA-G, we present the ablation study on analyzing the effectiveness of decoder attention bias component and adversarial training mechanism in Table 4. Both techniques contribute to decent improvements over T5-FID with more pronounced gains brought by adversarial training.
+
+<table><tr><td>Model</td><td>NQ</td><td>TriviaQA</td></tr><tr><td>T5-FIDlarge</td><td>51.4</td><td>67.6</td></tr><tr><td>UnitiedQA-Glarge</td><td>52.3</td><td>68.6</td></tr><tr><td>-Adv Training</td><td>52.0</td><td>68.2</td></tr><tr><td>-Attention Bias</td><td>51.8</td><td>68.1</td></tr></table>
+
+Table 4: Ablation experiments of the generative model on the test sets of NaturalQuestions (NQ) and TriviaQA. Exact match score is reported.  
+
+<table><tr><td></td><td></td><td>Top-20</td><td>Top-100</td><td>Δ</td></tr><tr><td rowspan="3">NQ</td><td>Retrieval</td><td>78.4</td><td>85.4</td><td>+9%</td></tr><tr><td>United-E</td><td>49.8</td><td>51.8</td><td>+4%</td></tr><tr><td>United-G</td><td>49.3</td><td>52.3</td><td>+6%</td></tr><tr><td rowspan="3">TriviaQA</td><td>Retrieval</td><td>79.9</td><td>84.4</td><td>+6%</td></tr><tr><td>United-E</td><td>67.1</td><td>68.9</td><td>+3%</td></tr><tr><td>United-G</td><td>65.4</td><td>68.6</td><td>+5%</td></tr></table>
+
+Table 5: Retrieval top-  $k$  accuracy and end-to-end QA extract match scores on the test sets of NaturalQuestions (NQ) and TriviaQA. United-E and United-G stand for our extractive and generative models respectively.
+
+# 4.2 Impact of Retrieval Accuracy
+
+Here, we vary the number of retrieved passages during inference and report the evaluation results in terms of end-to-end QA exact match score of UnitedQA-E and UnitedQA-G along with the corresponding top- $k$  retrieval accuracy. The results are summarized in Table 5. As expected, when the number of retrieved passages increases, both top- $k$  retrieval accuracy and the end-to-end QA performance improve. However, there is a noticeable gap between the improvement of retrieving more passages (i.e., recall) and that of the corresponding end-to-end QA performance, especially for the extractive reader. This is likely caused by additional noise introduced with improved retrieval recall. Specifically, only half of the retriever improvement can be effectively utilized by the extractive model while the generative model can benefit more from retrieving more passages. This suggests that by concatenating all passages in vector space, the generative model are more effective in de-noising in comparison to the extractive model.
+
+# 4.3 Breakdown Evaluation
+
+Following Lewis et al. (2021), we carry out a breakdown evaluation of model performance over the NaturalQuestions and TriviaQA test sets. Given
+
+their superior performance, we again only consider our improved extractive and generative models, i.e. UnitedQA-Elarge and UnitedQA-G respectively. The evaluation is summarized in Table 6. In comparison to their corresponding overall performance, both the extractive and generative models achieve much better performance on the "Overlap" categories (i.e. "Question Overlap" and "Answer Overlap") for both NaturalQuestions and TrivaQA, which indicates that both models perform well for question and answer memorization. Different from question and answer memorization, there is a pronounced performance drop for both models on the "Answer Overlap Only" category where certain amount of relevance inference capability is required to succeed. Lastly, we see that both extractive and generative models suffer some significant performance degradation for the "No Overlap" column which highlights model's generalization evaluation. Nevertheless, the extractive model demonstrate a better QA generalization by achieving a better overall performance on the "No Overlap" category for both datasets.
+
+# 4.4 Error Analysis
+
+Here, we conduct analyses into prediction errors made by the extractive and generative models based on automatic evaluation. For this study, we use the EfficientQA dev set (Min et al., 2021) which is constructed in the same way as the original NaturalQuestions dataset. Specifically, we group prediction errors into three categorizes: 1) common prediction errors made by both the extractive and generative models, 2) prediction errors made by the extractive model, 3) prediction errors produced by the generative model. In the following, we first carry out a manual inspection into the common errors. Then, we compare the prediction errors made by extractive and generative models, respectively.
+
+First of all, there is an error rate of  $29\%$  of those consensus predictions made by both extractive and generative models according to the automatic evaluation. Based on 30 randomly selected examples, we find that around  $30\%$  of those predictions are actually valid answers as shown in the top part of Table 7. In addition to predictions that are answers at different granularity or semantically equivalent ones, some of those prediction errors are likely caused by the ambiguity in questions. As the given example in Table 7, based on the specificity, the model prediction is also a valid answer. This high-
+
+<table><tr><td>Dataset</td><td>Model</td><td>Total</td><td>Question Overlap</td><td>No Question Overlap</td><td>Answer Overlap</td><td>Answer Overlap Only</td><td>No Overlap</td></tr><tr><td rowspan="2">NQ</td><td>UnitedQA-G</td><td>52.3</td><td>72.2</td><td>40.5</td><td>62.7</td><td>45.4</td><td>34.0</td></tr><tr><td>UnitedQA-E</td><td>51.8</td><td>69.4</td><td>41.5</td><td>60.1</td><td>45.1</td><td>37.6</td></tr><tr><td rowspan="2">TriviaQA</td><td>UnitedQA-G</td><td>68.6</td><td>88.4</td><td>62.5</td><td>78.1</td><td>69.6</td><td>44.5</td></tr><tr><td>UnitedQA-E</td><td>68.9</td><td>89.3</td><td>62.7</td><td>78.6</td><td>70.6</td><td>44.3</td></tr></table>
+
+Table 6: Breakdown evaluation on NaturalQuestions (NQ) and TriviaQA based on test splits defined in (Lewis et al., 2021). Exact match scores are reported. UnitedQA-E and UnitedQA-G denote our extractive and generative models respectively.  
+
+<table><tr><td colspan="2">Valid Answers</td></tr><tr><td>Different granularity</td><td>Q: When was harry potter and the deathly hallows part 2 movie released
+Prediction: 2011 / Gold: 15 July 2011</td></tr><tr><td>Semantically equivalent</td><td>Q: minimum age limit for chief justic of india
+Prediction: 65 / Gold: 65 years</td></tr><tr><td>Ambiguity question</td><td>Q: who won her first tennis grand slam in 2018
+Prediction: Carolin Wozniacki / Gold: Simona Halep</td></tr><tr><td colspan="2">Wrong Answers</td></tr><tr><td>Part as whole error</td><td>Q: the official U.S. poverty line is based on the cost of what
+Prediction: food / Gold: ICP purchasing power</td></tr><tr><td>Entity confusion</td><td>Q: actor who played tommy in terms of endearment
+Prediction: Jeff Daniels / Gold: Troy Bishop</td></tr><tr><td>Event confusion</td><td>Q: when did the saturdaywanan roughriders last won the grey cup
+Prediction: 2007 / Gold: 2013</td></tr></table>
+
+Table 7: Examples of prediction errors as judged by the automatic evaluation.
+
+lights the limitation of the current evaluation metric, which does not accurately estimate the existing open-domain QA system capabilities. As shown in the bottom part of Table 7, most of representative errors are due to the confusion of related concepts, entities or events that are mentioned frequently together with the corresponding gold answers.
+
+Next, all questions from the dev set are categorized based on WH question word, i.e. what, which, when, who, how, where. We then report the relative performance change of each WH category for both extractive and generative models over their corresponding overall prediction accuracy in Figure 2. First, it is easy to see that both extractive and generative models achieve the best performance for entity related who questions, which is likely to be the result of high ratio of samples of this type seen during training. In contrast, the answers to what questions can play a much richer syntactic role in context, making it more difficult for both extractive
+
+and generative models to perform well. Interestingly, the generative model exhibits the strength for temporal reasoning, whereas the extractive model does not. This difference suggests that it is worth exploring better temporal modeling strategies to improve the extractive model in the future.
+
+# 5 Related Work
+
+Open-domain QA Open-domain QA requires a system to answer questions based on evidence retrieved from a large corpus such as Wikipedia (Voorhees, 2000; Chen et al., 2017). Recent progress has been made towards improving evidence retrieval through both sparse vector models like TF-IDF or BM25 (Chen et al., 2017; Min et al., 2019), and dense vector models based on BERT (Lee et al., 2019; Karpukhin et al., 2020; Guu et al., 2020; Qu et al., 2021). Generally, the dense representations complement the sparse vector methods for passage retrieval as they can potentially give
+
+![](images/d788d1edae44080357e825ab943ff3d3bd9ccb34708b4cf69c0396d357b5d961.jpg)  
+Figure 2: Relative accuracy of different  $WH$  questions. The relative accuracy is the relative change of a  $WH$  category accuracy to the overall model accuracy.
+
+high similarity to semantically related text pairs, even without exact lexical overlap. Unlike most work focusing on a pipeline model, Lee et al. (2019) propose a pre-training objective for jointly training both the retrieval encoder and reader. It is further extended by Guu et al. (2020) with a dynamic update of the passage index during the training. Instead, in this work, we focus on a hybrid reader approach for open-domain QA. By simply combining answer predictions from extractive and generative models, our UnitedQA achieves significant improvements over state-of-the-art models.
+
+Reading Comprehension with Noisy Labels There has been a line of work on improving distantly-supervised reading comprehension models by developing learning methods and model architectures that can better use noisy labels. Most of them focus on the document-level QA, where all paragraphs share the same document context. Clark and Gardner (2018) propose a paragraph-pair ranking objective for learning with multiple paragraphs so that the model can distinguish relevant paragraphs from irrelevant ones. In (Lin et al., 2018), a coarse-to-fine model is proposed to handle label noise by aggregating information from relevant paragraphs and then extracting answers from selected ones. Min et al. (2019) propose a hard EM learning scheme where only passage-level loss is considered for document-level QA. More recently, different probabilistic assumptions with corresponding training and inference methods are examined in (Cheng et al., 2020) again for document-level QA with distant supervision. In our work, we further extend the multi-objective formulation proposed in (Cheng et al., 2020) with the hard EM learning (Min et al., 2019) for enhancing extrac
+
+tive open-domain QA, where the input passages are given by a retrieval model and are typically from different documents.
+
+# 6 Conclusion
+
+In this study, we propose a hybrid model for open-domain QA, called UnitedQA, which combines the strengths of extractive and generative readers. We demonstrate the effectiveness of UnitedQA on two popular open-domain QA benchmarks, NaturalQuestions and TriviaQA. Our results show that the proposed UnitedQA model significantly outperforms single extractive and generative models as well as their corresponding homogeneous ensembles, and sets new state-of-the-art on both benchmarks. We also perform a comprehensive empirical study to investigate the relative contributions of different components of our model and the techniques we use to improve the readers.
+
+For future work, it would be interesting to explore model compression approaches for reducing the model size of retriever and reader separately or jointly through pruning, quantization, and knowledge distillation.
+
+# Acknowledgments
+
+We would like to thank the anonymous reviewers for valuable suggestions, Yuning Mao for valuable discussions and comments, and Microsoft Research Technology Engineering team for computing support.
+
+# References
+
+Danqi Chen, Adam Fisch, Jason Weston, and Antoine Bordes. 2017. Reading Wikipedia to answer open-domain questions. In Proceedings of the 55th Annual Meeting of the Association for Computational Linguistics (Volume 1: Long Papers), pages 1870-1879. Association for Computational Linguistics.  
+Danqi Chen and Wen-tau Yih. 2020. Open-domain question answering. In Proceedings of the 58th Annual Meeting of the Association for Computational Linguistics: Tutorial Abstracts, pages 34-37, Online. Association for Computational Linguistics.  
+Hao Cheng, Ming-Wei Chang, Kenton Lee, and Kristina Toutanova. 2020. Probabilistic assumptions matter: Improved models for distantly-supervised document-level question answering. In Proceedings of the 58th Annual Meeting of the Association for Computational Linguistics, pages 5657-5667, Online. Association for Computational Linguistics.
+
+Hao Cheng, Xiaodong Liu, Lis Pereira, Yaoliang Yu, and Jianfeng Gao. 2021. Posterior differential regularization with f-divergence for improving model robustness. In Proceedings of the 2021 Conference of the North American Chapter of the Association for Computational Linguistics: Human Language Technologies, pages 1078-1089, Online. Association for Computational Linguistics.  
+Christopher Clark and Matt Gardner. 2018. Simple and effective multi-paragraph reading comprehension. In Proceedings of the 56th Annual Meeting of the Association for Computational Linguistics (Volume 1: Long Papers), pages 845-855. Association for Computational Linguistics.  
+Kevin Clark, Minh-Thang Luong, Quoc V. Le, and Christopher D. Manning. 2020. ELECTRA: Pretraining text encoders as discriminators rather than generators. In International Conference on Learning Representations (ICLR).  
+Jacob Devlin, Ming-Wei Chang, Kenton Lee, and Kristina Toutanova. 2019. BERT: Pre-training of deep bidirectional transformers for language understanding. In Proceedings of the 2019 Conference of the North American Chapter of the Association for Computational Linguistics: Human Language Technologies, Volume 1 (Long and Short Papers), pages 4171-4186, Minneapolis, Minnesota. Association for Computational Linguistics.  
+Kelvin Guu, Kenton Lee, Zora Tung, Panupong Papat, and Mingwei Chang. 2020. Retrieval augmented language model pre-training. In Proceedings of the 37th International Conference on Machine Learning, volume 119 of Proceedings of Machine Learning Research, pages 3929-3938. PMLR.  
+Song Han, Huizi Mao, and William J. Dally. 2016. Deep compression: Compressing deep neural network with pruning, trained quantization and huffman coding. In 4th International Conference on Learning Representations, ICLR 2016, San Juan, Puerto Rico, May 2-4, 2016, Conference Track Proceedings.  
+Geoffrey Hinton, Oriol Vinyals, and Jeffrey Dean. 2015. Distilling the knowledge in a neural network. In NIPS Deep Learning and Representation Learning Workshop.  
+Itay Hubara, Matthieu Courbariaux, Daniel Soudry, Ran El-Yaniv, and Yoshua Bengio. 2018. Quantized neural networks: Training neural networks with low precision weights and activations. Journal of Machine Learning Research, 18(187):1-30.  
+Gautier Izacard and Edouard Grave. 2021. Leveraging passage retrieval with generative models for open domain question answering. In Proceedings of the 16th Conference of the European Chapter of the Association for Computational Linguistics: Main Volume, pages 874-880, Online. Association for Computational Linguistics.
+
+Haoming Jiang, Pengcheng He, Weizhu Chen, Xiaodong Liu, Jianfeng Gao, and Tuo Zhao. 2020. SMART: Robust and efficient fine-tuning for pretrained natural language models through principled regularized optimization. In Proceedings of the 58th Annual Meeting of the Association for Computational Linguistics, pages 2177-2190, Online. Association for Computational Linguistics.  
+Mandar Joshi, Eunsol Choi, Daniel Weld, and Luke Zettlemoyer. 2017. TriviaQA: A large scale distantly supervised challenge dataset for reading comprehension. In Proceedings of the 55th Annual Meeting of the Association for Computational Linguistics (Volume 1: Long Papers), pages 1601-1611, Vancouver, Canada. Association for Computational Linguistics.  
+Ying Ju, Fubang Zhao, Shijie Chen, Bowen Zheng, Xuefeng Yang, and Yunfeng Liu. 2019. Technical report on conversational question answering.  
+Vladimir Karpukhin, Barlas Oguz, Sewon Min, Patrick Lewis, Ledell Wu, Sergey Edunov, Danqi Chen, and Wen-tau Yih. 2020. Dense passage retrieval for open-domain question answering. In Proceedings of the 2020 Conference on Empirical Methods in Natural Language Processing (EMNLP), pages 6769-6781, Online. Association for Computational Linguistics.  
+Tom Kwiatkowski, Jennimaria Palomaki, Olivia Redfield, Michael Collins, Ankur Parikh, Chris Alberti, Danielle Epstein, Illia Polosukhin, Jacob Devlin, Kenton Lee, Kristina Toutanova, Llion Jones, Matthew Kelcey, Ming-Wei Chang, Andrew M. Dai, Jakob Uszkoreit, Quoc Le, and Slav Petrov. 2019. Natural questions: A benchmark for question answering research. Transactions of the Association for Computational Linguistics, 7:453-466.  
+Kenton Lee, Ming-Wei Chang, and Kristina Toutanova. 2019. Latent retrieval for weakly supervised open domain question answering. In Proceedings of the 57th Annual Meeting of the Association for Computational Linguistics, pages 6086-6096. Association for Computational Linguistics.  
+Patrick Lewis, Ethan Perez, Aleksandra Piktus, Fabio Petroni, Vladimir Karpukhin, Naman Goyal, Heinrich Kuttler, Mike Lewis, Wen-tau Yih, Tim Rocktäschel, Sebastian Riedel, and Douwe Kiela. 2020. Retrieval-augmented generation for knowledge-intensive nlp tasks. In Advances in Neural Information Processing Systems, volume 33, pages 9459-9474. Curran Associates, Inc.  
+Patrick Lewis, Pontus Stenetorp, and Sebastian Riedel. 2021. Question and answer test-train overlap in open-domain question answering datasets. In Proceedings of the 16th Conference of the European Chapter of the Association for Computational Linguistics: Main Volume, pages 1000-1008, Online. Association for Computational Linguistics.
+
+Yankai Lin, Haozhe Ji, Zhiyuan Liu, and Maosong Sun. 2018. Denoising distantly supervised open-domain question answering. In Proceedings of the 56th Annual Meeting of the Association for Computational Linguistics (Volume 1: Long Papers), pages 1736-1745.  
+Sewon Min, Jordan Boyd-Graber, Chris Alberti, Danqi Chen, Eunsol Choi, Michael Collins, Kelvin Guu, Hannaneh Hajishirzi, Kenton Lee, Jennimaria Palomaki, Colin Raffel, Adam Roberts, Tom Kwiatkowski, Patrick Lewis, Yuxiang Wu, Heinrich Kuttler, Linqing Liu, Pasquale Minervini, Pontus Stenetorp, Sebastian Riedel, Sohee Yang, Minjoon Seo, Gautier Izacard, Fabio Petroni, Lucas Hosseini, Nicola De Cao, Edouard Grave, Ikuya Yamada, Sonse Shimaoka, Masatoshi Suzuki, Shumpei Miyawaki, Shun Sato, Ryo Takahashi, Jun Suzuki, Martin Fajcik, Martin Docekal, Korel Ondrej, Pavel Smrz, Hao Cheng, Yelong Shen, Xiaodong Liu, Pengcheng He, Weizhu Chen, Jianfeng Gao, Barlas Oguz, Xilun Chen, Vladimir Karpukhin, Stan Peshterliev, Dmytro Okhonko, Michael Schlichtkrull, Sonal Gupta, Yashar Mehdad, and Wen tau Yih. 2021. NeurIPS 2020 EfficientQA competition: Systems, analyses and lessons learned.  
+Sewon Min, Danqi Chen, Hannaneh Hajishirzi, and Luke Zettlemoyer. 2019. A discrete hard EM approach for weakly supervised question answering. In Proceedings of the 2019 Conference on Empirical Methods in Natural Language Processing and the 9th International Joint Conference on Natural Language Processing (EMNLP-IJCNLP), pages 2851-2864, Hong Kong, China. Association for Computational Linguistics.  
+Lis Pereira, Xiaodong Liu, Hao Cheng, Hoifung Poon, Jianfeng Gao, and Ichiro Kobayashi. 2021. Targeted adversarial training for natural language understanding. In Proceedings of the 2021 Conference of the North American Chapter of the Association for Computational Linguistics: Human Language Technologies, pages 5385-5393, Online. Association for Computational Linguistics.  
+Yingqi Qu, Yuchen Ding, Jing Liu, Kai Liu, Ruiyang Ren, Wayne Xin Zhao, Daxiang Dong, Hua Wu, and Haifeng Wang. 2021. RocketQA: An optimized training approach to dense passage retrieval for open-domain question answering. In Proceedings of the 2021 Conference of the North American Chapter of the Association for Computational Linguistics: Human Language Technologies, pages 5835-5847, Online. Association for Computational Linguistics.  
+Colin Raffel, Noam Shazeer, Adam Roberts, Katherine Lee, Sharan Narang, Michael Matena, Yanqi Zhou, Wei Li, and Peter J. Liu. 2020. Exploring the limits of transfer learning with a unified text-to-text transformer. Journal of Machine Learning Research, 21(140):1-67.  
+Ellen Voorhees. 2000. The TREC-8 question answering track report.

data/2021/2101_00xxx/2101.00180/e6c1938e-fd7a-49b4-ac0c-6863dca02ce5_content_list.json

@@ -1,3 +1,1280 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:c080778a8675584e435da809b3411c59aec330e54dee660550e7861a0d271ede
-size 51340
+[
+    {
+        "type": "text",
+        "text": "Transformer based Automatic COVID-19 Fake News Detection System",
+        "text_level": 1,
+        "bbox": [
+            230,
+            140,
+            774,
+            186
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Sunil Gundapu and Radhika Mamidi",
+        "bbox": [
+            364,
+            212,
+            635,
+            228
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "International Institute of Information Technology, Hyderabad sunil.g@research.iit.ac.in, radhika.mamidi@iit.ac.in",
+        "bbox": [
+            290,
+            239,
+            712,
+            268
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Abstract. Recent rapid technological advancements in online social networks such as Twitter have led to a great incline in spreading false information and fake news. Misinformation is especially prevalent in the ongoing coronavirus disease (COVID-19) pandemic, leading to individuals accepting bogus and potentially deleterious claims and articles. Quick detection of fake news can reduce the spread of panic and confusion among the public. For our analysis in this paper, we report a methodology to analyze the reliability of information shared on social media pertaining to the COVID-19 pandemic. Our best approach is based on an ensemble of three transformer models (BERT, ALBERT, and XLNET) to detecting fake news. This model was trained and evaluated in the context of the ConstraintAI 2021 shared task \"COVID19 Fake News Detection in English\" [1]. Our system obtained 0.9855 f1-score on testset and ranked 5th among 160 teams.",
+        "bbox": [
+            261,
+            306,
+            743,
+            501
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Keywords: pandemic-19, fake news, deep learning, transformer models",
+        "bbox": [
+            261,
+            513,
+            715,
+            529
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 Introduction",
+        "text_level": 1,
+        "bbox": [
+            215,
+            556,
+            375,
+            571
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "The COVID-19 pandemic is considered the global public health crisis of the whole world and the biggest problem people faced after World War II. COVID-19, a contagious disease caused by a coronavirus, has caused more than 75 million confirmed cases and 1.7 million deaths across the world till 2020 December<sup>1</sup>. Unfortunately, the misinformation about COVID-19 has encouraged the growing of the disease and chaos among people. During the Munich Security Council held on February 15, 2020, World Health Organization (WHO) Director-General, Tedros Adhanom Ghebreyesus [2] stated that the world was in a war to fight not only a pandemic, but also an infodemic. So we should address the challenge of fake news detection to stop the spreading of COVID-19 misinformation.",
+        "bbox": [
+            212,
+            588,
+            787,
+            739
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Since the global pandemic impacts the people, there is a broader public finding information about the COVID-19, whose safety is intimidated by adversarial agents invested in spreading fake news for economic and political reasons. Besides, due to medical and public health issues, it is also hard to be totally valid and factual, leading to differences that worsen with fake news. This difficulty",
+        "bbox": [
+            212,
+            739,
+            787,
+            816
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "aside_text",
+        "text": "arXiv:2101.00180v3 [cs.CL] 21 Jan 2021",
+        "bbox": [
+            22,
+            272,
+            57,
+            708
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "page_footnote",
+        "text": "<sup>1</sup> https://www.worldometers.info/coronavirus/",
+        "bbox": [
+            217,
+            823,
+            535,
+            840
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "is compounded by the quick advancement of knowledge about the disease. As researchers gain more knowledge about the virus, claims that looked right may turn out to be false, and vice versa. Detecting this spread of COVID-19 associated fake news, thus, has become a pivotal problem, gaining notable attention from government and global health organizations (WHO, 2020), online social networks (TechCrunch, 2020), and news organizations (BBC, 2020; CNN, 2020; New York Times, 2020).",
+        "bbox": [
+            212,
+            146,
+            787,
+            252
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "In response to the present disinformation, this paper looks at developing an efficient fake news detection architecture with respect to COVID-19. Initially, we started with developing machine learning (ML) algorithms with Term Frequency and Inverse Document Frequency (TF-IDF) feature vectors to detect misinformation on the provided dataset. These supervised TF-IDF methods are still relevant for many classification tasks and performed pretty well for fake news detection. We developed an effective ensemble model integrated with three transformer models for detecting fake news on the social media platforms. This resulted in higher accuracy and a more generalized model.",
+        "bbox": [
+            212,
+            252,
+            787,
+            387
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "The rest of this paper is organized as follows, Section II presents some prior works related to fake news, and its spread, on social media platforms. In Section III, we describe the dataset provided in the Constraint AI-2021 shared task. Section IV presents implemented models and framework for misinformation detection. Section V provides the discussions on the results. Finally we conclude this paper in Section VI.",
+        "bbox": [
+            212,
+            388,
+            787,
+            479
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2 Related Work",
+        "text_level": 1,
+        "bbox": [
+            215,
+            500,
+            387,
+            515
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Fake News Detection: Fake news can be defined as inaccurate and misleading information that is growing knowingly or unknowingly [3]. Recognizing the spread of false information such as rumors, fake news, propaganda, hoaxes, spear phishing, and conspiracy theories is an essential task for natural language processing [4]. Gartner's [5] research studies explained that most people in advanced economies would believe more fake information than truthful information by 2022.",
+        "bbox": [
+            212,
+            529,
+            787,
+            633
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "To date, so many automated misinformation detection architectures have been developed. Rohit et al. [6] provided an extensive survey to detect fake news on various online social networks. Ghorbani et al. [7] presented an inclusive overview of the recent studies related to misinformation. Furthermore, they described the impact of misleading information, shown state-of-the-art fake news detection systems, and explored the disinformation detection datasets. The majority of the fake news detection models developed using supervised machine learning algorithms to classify the data as misleading or not [8]. This supervised classification is concluded by comparing the user input text with some already created corpora containing genuine and misleading information [9].",
+        "bbox": [
+            212,
+            635,
+            787,
+            786
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Aswini et al. [10] proposed a deep learning architecture with various word embeddings for Fake News Challenge (FCN-1) dataset<sup>2</sup>. They developed the",
+        "bbox": [
+            212,
+            786,
+            787,
+            816
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "page_number",
+        "text": "2",
+        "bbox": [
+            217,
+            114,
+            228,
+            126
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "header",
+        "text": "Gundapu and Mamidi",
+        "bbox": [
+            271,
+            114,
+            421,
+            128
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "page_footnote",
+        "text": "2 http://www.fakenewschallenge.org/",
+        "bbox": [
+            217,
+            823,
+            472,
+            840
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "architecture to accurately predict the stance between a given pair of news headlines and the corresponding article/body. On the same FCN-1 dataset, Sean et al. [11] developed an average weighted model of TalosCNN and TalosTree called TalosComb. TalosCNN is a convolutional neural network with pre-trained word2vec embeddings, and TalosTree is a gradient-boosted decision tree model with SVD, word count, TF-IDF. By analyzing the relationship between the news headline and the corresponding article, Heejung et al. [12] designed the Bidirectional Encoder Representations from Transformers model (BERT) to detect misleading news articles.",
+        "bbox": [
+            212,
+            146,
+            787,
+            282
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "COVID-19: In the case of COVID-19 fake news, a large number of misleading contents remain online on social media platforms. NLP researchers have been working on developing algorithms for the detection of online COVID-19 related disinformation. To develop any algorithm, we require a corpus. So members of the NLP community created the various fake news datasets: FakeCovid [13], ReCOVery [14], CoAID [15], and CMU-MisCOVID19 [16]. Yichuan Li et al. [17] developed multi-dimensional and multilingual MM-COVID corpora, which covers six languages. Mabrook et al. [18] created a large Twitter dataset related to COVID-19 misinformation. And authors developed an ensemble-stacking model with six machine learning algorithms on the created dataset for detecting misinformation.",
+        "bbox": [
+            212,
+            309,
+            787,
+            474
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Elhadad et al. [22] constructed a voting ensemble machine learning classifier for fake news detection that uses seven feature extraction techniques and ten machine learning models. Tamanna et al. [20] used the COVIDLIES dataset to detect the misinformation by retrieving the misconceptions relevant to the Twitter posts. For COVID-19 fake news detection and fact-checking, Rutvik et al. [19] proposed a two-stage transformer model. The first model retrieves the most relevant facts about COVID-19 by using a novel fact-checking algorithm, and the second model, by computing the textual entailment, verifies the level of truth. Adapting all these classical and hybrid related work techniques, we developed a COVID-19 fake news detection system in this paper.",
+        "bbox": [
+            212,
+            476,
+            787,
+            628
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3 Dataset Description",
+        "text_level": 1,
+        "bbox": [
+            214,
+            655,
+            444,
+            672
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "The ConstraintAI $^{21}$  shared task organizers developed a COVID-19 fake news detection in English dataset [21] containing 10,700 data points collected from various online social networks such as Twitter, Facebook, and Instagram, etc. From the total dataset, 6,420 data points are reserved for training, 2,140 data points are used for hyperparameter tuning as a part of the validation phase, and the remaining 2,140 social media posts are kept aside for testing. Each dataset except the test set contains social media data points and their corresponding labels, either real or fake.",
+        "bbox": [
+            212,
+            691,
+            787,
+            811
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "header",
+        "text": "Fake News Detection",
+        "bbox": [
+            589,
+            114,
+            730,
+            127
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "page_number",
+        "text": "3",
+        "bbox": [
+            774,
+            116,
+            784,
+            126
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "page_footnote",
+        "text": "3 https://constraint-shared-task-2021.github.io/",
+        "bbox": [
+            217,
+            823,
+            542,
+            840
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "table",
+        "img_path": "images/d3cde1602775781cd8231a7797fa3ba1db8c27bd52fa659b82bea7c505f6250d.jpg",
+        "table_caption": [],
+        "table_footnote": [
+            "(a) Dataset Statistics"
+        ],
+        "table_body": "<table><tr><td>Corpus</td><td>Real</td><td>Fake</td></tr><tr><td>Train</td><td>3360</td><td>3060</td></tr><tr><td>Valid</td><td>1120</td><td>1020</td></tr><tr><td>Test</td><td>1120</td><td>1020</td></tr></table>",
+        "bbox": [
+            228,
+            155,
+            403,
+            215
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "table",
+        "img_path": "images/c3c9156cca2eeb2e893c8e8c6e8253c65e3401215641cb1eddb77c8068146b6d.jpg",
+        "table_caption": [],
+        "table_footnote": [
+            "(b) Label-wise example"
+        ],
+        "table_body": "<table><tr><td>Tweet</td><td>Label</td></tr><tr><td>CDC Recommends Mothers Stop Breastfeeding To Boost Vaccine Efficacy</td><td>fake</td></tr><tr><td>1000 COVID-19 testing labs in India: ICMR</td><td>real</td></tr></table>",
+        "bbox": [
+            431,
+            155,
+            781,
+            215
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Table 1: Fake news dataset information",
+        "bbox": [
+            359,
+            233,
+            643,
+            246
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Table 1 shows the corpus size and label distribution, and if we observe, the labels in each dataset are all roughly balanced. Table 2 shows some examples from the COVID-19 fake news detection in the English dataset. We illustrate the most occurring word cloud of the real and fake data points after removing the stop words in Figures 1(a) and 1(b). In Figure 1(a), we can see unique words in real-labeled data points which don't often occur in Figure 1(b), like \"covid19\", \"discharged\", \"confirmed\", \"testing\", \"indiafightscorona\", and \"indiawin\", etc.; meanwhile, from Figure 1(b), we can find unique words frequently appearing in the fake articles, which include \"coronavirus\", \"kill\", \"muslim\", \"hydroxychloroquine\", \"china\", and \"facebook post\", but don't frequently appear in the true labeled data points. These frequent textual words can give important information to differentiate the true data points from fake ones.",
+        "bbox": [
+            212,
+            287,
+            787,
+            470
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "image",
+        "img_path": "images/01516eae682541f1dd926f119670d79630e91f6f628a0c94fdf65efed67d8b56.jpg",
+        "image_caption": [
+            "(a) Positive word cloud",
+            "Fig. 1: Illustration of frequent word cloud"
+        ],
+        "image_footnote": [],
+        "bbox": [
+            246,
+            503,
+            485,
+            686
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "image",
+        "img_path": "images/c0bfcd572b50f918e8eabcc524622c681b327ab0b9e12b585d010c67652bb061.jpg",
+        "image_caption": [
+            "(b) Negative word cloud"
+        ],
+        "image_footnote": [],
+        "bbox": [
+            513,
+            503,
+            750,
+            686
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "4 Methodology",
+        "text_level": 1,
+        "bbox": [
+            215,
+            781,
+            380,
+            799
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "In this part, we present our transformer based ensemble model that is trained and tuned on the datasets which reported in the previous section. We compare our",
+        "bbox": [
+            212,
+            809,
+            785,
+            839
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "page_number",
+        "text": "4",
+        "bbox": [
+            217,
+            114,
+            228,
+            126
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "header",
+        "text": "Gundapu and Mamidi",
+        "bbox": [
+            271,
+            114,
+            421,
+            128
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "approach with various machine learning (ML) and deep learning (DL) models with different word embeddings. The full code of system architecture can be found at GitHub<sup>4</sup>.",
+        "bbox": [
+            212,
+            146,
+            782,
+            191
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "4.1 Data Preprocessing",
+        "text_level": 1,
+        "bbox": [
+            214,
+            210,
+            423,
+            226
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "The main aim of this part is to use the NLP techniques to preprocess the input tweet data and prepare for the next step to extract the proper features. In Figure 2, we shown the detailed data preprocessing pipeline with examples.",
+        "bbox": [
+            212,
+            232,
+            782,
+            279
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "image",
+        "img_path": "images/a50faaa9d5f22c20dfe2069231fc60024eaa05967fe01f234c5447c8f1d7e286.jpg",
+        "image_caption": [
+            "Fig. 2: Data preprocessing pipeline"
+        ],
+        "image_footnote": [],
+        "bbox": [
+            222,
+            310,
+            782,
+            421
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "In the preprocessing step, we will forward the tokenized tweet through the pipeline to eliminate the noise in the fake news dataset by remove or normalize the unnecessary tokens. The preprocessing pipeline includes the following subparts:",
+        "bbox": [
+            212,
+            498,
+            782,
+            559
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "list",
+        "sub_type": "text",
+        "list_items": [
+            "1. Emoticon Conversion: In this step, we converted the each emoticon in the tweet to text. Example:  $\\rightarrow$  Face with medical mask emoji",
+            "2. Handling of Hashtags: We identified the hashtag tokens by seeing pound (#) sign and splitted these based on digits or capital letters. Example: #IndiaFightsCorona → IndiaFightsCorona",
+            "3. Stemming: We removed the inflectional morphemes like \"ed\", \"est\", \"s\", and \"ing\" from their token stem. Ex: confirmed  $\\rightarrow$  \"confirm\" + \"-ed\"",
+            "4. Text cleaning: To remove the irrelevant data we used this step. Removed punctuation marks, digits and, non-ASCII glyphs from the tweet."
+        ],
+        "bbox": [
+            220,
+            565,
+            782,
+            702
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "4.2 Supervised Machine Learning Models",
+        "text_level": 1,
+        "bbox": [
+            214,
+            720,
+            571,
+            736
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "To build the finest system for fake news detection, we started our investigations with traditional NLP approaches like Linear Regression (LR), Support Vector MAchines (SVM), Passive Agressive Classifier (PAC), XGBoost, and Multi-Layer Perceptron (MLP). We study the results of above mentioned supervised models with the combination of three types of word vectors:",
+        "bbox": [
+            212,
+            742,
+            782,
+            818
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "header",
+        "text": "Fake News Detection",
+        "bbox": [
+            588,
+            114,
+            730,
+            127
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "page_number",
+        "text": "5",
+        "bbox": [
+            774,
+            116,
+            784,
+            126
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "page_footnote",
+        "text": "4 https://github.com/SunilGundapu/Covid-19-fake-news-detection",
+        "bbox": [
+            217,
+            824,
+            663,
+            839
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "list",
+        "sub_type": "text",
+        "list_items": [
+            "1. Word-level, n-gram level, and character level TF-IDF vectors with the feature matrix size of 100000.",
+            "2. English Glove [23] word embeddings with the dimension of 300.",
+            "3. TF-IDF weighted averaging with Glove embeddings. We described below the fake news vector construction."
+        ],
+        "bbox": [
+            222,
+            146,
+            784,
+            220
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "equation",
+        "text": "\n$$\nT w e e t _ {v e c t o r} = \\frac {\\sum_ {i = 1} ^ {N} \\mathbf {t f - i d f} (t o k e n _ {i}) \\times \\mathbf {G l o v e} (t o k e n _ {i})}{\\mathbf {N}} \\tag {1}\n$$\n",
+        "text_format": "latex",
+        "bbox": [
+            321,
+            246,
+            784,
+            294
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "In the above formula,  $\\mathrm{N}$  is the total number of words in the input fake news tweet, and  $\\text{token}_i$  is the  $i^{th}$  token in the input text. After analyzing the results, TF-IDF weighted averaging gave better results than the standard TF-IDF.",
+        "bbox": [
+            214,
+            299,
+            784,
+            345
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "4.3 Deep Learning Models",
+        "text_level": 1,
+        "bbox": [
+            215,
+            367,
+            449,
+            383
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Supervised machine learning algorithms performed very well on the provided dataset. In this section, we experiment with deep learning models that give better results than traditional classification algorithms.",
+        "bbox": [
+            212,
+            393,
+            784,
+            439
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "LSTM: We used Long Short-Term Memory (LSTM) [24] architecture with two different pre-trained word embeddings Glove and Fasttext [25]. LSTM is a type of Recurrent Neural Network (RNN) that can solve long term dependency problem, and it is a well-suited model for sequence classification.",
+        "bbox": [
+            212,
+            460,
+            784,
+            521
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "We converted the input data points into word vectors by using pre-trained word embeddings. These word vectors are passed as input to the LSTM layer. We stacked up two LSTM layers one after another with the dropout of 0.25. The size of LSTM is 128, and the last time step output is treated as input data point representation. The final time step's outcome is passed as an input to a dense layer for fake news detection.",
+        "bbox": [
+            212,
+            521,
+            784,
+            612
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "BiLSTM with Attention: Sometimes not all the tokens in the input text contribute equally to the representation of input text. So we advantage word attention [26] mechanism to catch the tokens' prominent influence on the input data point. We built this attention mechanism on top of BiLSTM layers.",
+        "bbox": [
+            212,
+            635,
+            784,
+            696
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "The sequence of word vector is passed through a BiLSTM layer, which contains one forward and backward LSTM layer. Attention mechanism applied to the output of BiLSTM layer, which produces a dense vector. This dense vector is forwarded to a fully connected network.",
+        "bbox": [
+            212,
+            696,
+            784,
+            756
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "CNN: We explored a Convolution Neural Network (CNN) [27] model for misinformation detection. The model consists of an embedding layer, a convolution layer with 3 convolutions, a max-pooling layer, and a fully connected network. In the embedding layer, the input texts are converted into  $n \\times d$  sequence matrix,",
+        "bbox": [
+            212,
+            779,
+            784,
+            839
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "page_number",
+        "text": "6",
+        "bbox": [
+            217,
+            114,
+            228,
+            126
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "header",
+        "text": "Gundapu and Mamidi",
+        "bbox": [
+            271,
+            114,
+            421,
+            128
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "where  $n$  is the length of the input data point and  $d$  is the length of the word embedding dimension. In the convolution layer, fed the sequence matrix through three 1D convolutions of kernel sizes 3, 4, and 5. And each convolutions filter size is 128. The convolution layer's output is max pooled over time and concatenated to get the input datapoint representations in the max-pooling layer. The output of the max-pooling layer is passed to a fully connected network with a softmax output layer.",
+        "bbox": [
+            212,
+            146,
+            787,
+            252
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "CNN + BiLSTM: A CNN and BiLSTM architecture is an ensemble of CNN and bidirectional LSTM models with Fasttext/Glove word embeddings. In this architecture, the CNN extracts the maximum amount of features/information from the input text using convolution layers. The output of CNN becomes the input to BiLSTM, which keeps the data in chronological order in both directions.",
+        "bbox": [
+            212,
+            273,
+            787,
+            349
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "The sequence of word vectors are forwarded through a convolution of kernel size 3 with filter size 128. The output of convolution is passed through a BiLSTM. The outcome of BiLSTM is max-pooled over time and followed by one dense layer and a softmax layer.",
+        "bbox": [
+            212,
+            351,
+            787,
+            411
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "4.4 Transformer Models",
+        "text_level": 1,
+        "bbox": [
+            215,
+            434,
+            429,
+            448
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "This section explored individual and ensembling of the three transformer models BERT, ALBERT, and XLNet. These models have outperformed the other ML and DL algorithms. We implemented these models using HuggingFace<sup>5</sup> is a PyTorch transformer library. And the hyperparameters of the three models are described in Table 1.",
+        "bbox": [
+            212,
+            459,
+            787,
+            534
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "table",
+        "img_path": "images/19b7755f79accc664ddb9f6729abf034336bc41dcb7dff1fd4e4f9af80548cee.jpg",
+        "table_caption": [],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Model</td><td>Learning Rate</td><td>Batch Size</td><td>Optimizer</td><td>Max Length</td><td>Type</td></tr><tr><td>BERT</td><td>2e-5</td><td>16</td><td>Adam</td><td>128</td><td>BERT-Base</td></tr><tr><td>XLNet</td><td>2e-5</td><td>16</td><td>Adam</td><td>128</td><td>XLNetLarge</td></tr><tr><td>ALBERT</td><td>2e-5</td><td>32</td><td>Adam</td><td>128</td><td>ALBERT-Xlarge</td></tr></table>",
+        "bbox": [
+            217,
+            556,
+            785,
+            646
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Table 2: Hyperparameters of transformer models",
+        "bbox": [
+            323,
+            656,
+            678,
+            672
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "BERT: Bidirectional Encoder Representations from Transformers (henceforth, BERT) [28] is a transformer model developed to pre-train deep bidirectional representations from unseen data. This model developed by combining two robust concepts: (i) It's a deep transformer model so that it can process lengthy sentences effectively by using attention mechanism, and (ii) It's a bidirectional",
+        "bbox": [
+            212,
+            739,
+            787,
+            816
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "header",
+        "text": "Fake News Detection",
+        "bbox": [
+            588,
+            114,
+            730,
+            127
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "page_number",
+        "text": "7",
+        "bbox": [
+            774,
+            114,
+            784,
+            126
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "page_footnote",
+        "text": "5 https://huggingface.co/transformers/",
+        "bbox": [
+            217,
+            824,
+            482,
+            840
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "network, so it takes into account the entire text passage to comprehend the meaning of each token.",
+        "bbox": [
+            212,
+            146,
+            782,
+            175
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "BERT implementation has two steps; one is pre-training and another fin-tuning. In the first step, the model is trained on unseen data over various pretraining problems using a dataset in a particular language or in increases data with multiple languages. In the second step, all the initialized parameters are fine-tuned using the labeled data from certain tasks.",
+        "bbox": [
+            212,
+            176,
+            784,
+            251
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "We fine-tuned the pre-trained BERT (Base) model for our COVID-19 fake news detection task. BERT base model contains the 12 layers of encoder blocks and 12 bidirectional self-attention heads by considering the sequence of 512 tokens and emitting the representations of a sequence of hidden vectors. We added one additional output layer on top of the BERT model to calculate the conditional probability over the output classes, either fake or real. See FIGURE 1 for the fine-tuned model of BERT.",
+        "bbox": [
+            212,
+            252,
+            785,
+            356
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "image",
+        "img_path": "images/ca4c033b834382e3fb655dfaa0fa2ec7eea1fac153c069fa2712b7b0bf666452.jpg",
+        "image_caption": [
+            "Fig. 3: BERT model architecture"
+        ],
+        "image_footnote": [],
+        "bbox": [
+            292,
+            395,
+            709,
+            608
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "XLNet: XLNet is an enhanced version of BERT. To understand the language context deeper, XLNet [29] uses Transformer-XL [30] as a feature engineering model, which alone is an adoption upon the native Transformer. This Transformer XL model integrates the two components Recurrence Mechanism and Relative Positional Encoding (RPE) to the Transformer used in BERT to handle the long-term dependencies for texts that are longer than the maximum allowed input length. Recurrence Mechanism will give context between two sequences at specific segments and RPE, which carries similarity information between two tokens.",
+        "bbox": [
+            212,
+            703,
+            787,
+            838
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "page_number",
+        "text": "8",
+        "bbox": [
+            217,
+            114,
+            228,
+            126
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "header",
+        "text": "Gundapu and Mamidi",
+        "bbox": [
+            271,
+            114,
+            421,
+            128
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "The XLNet model has been trained on a huge dataset using the permutation language modeling. This technique is one of the main differences between BERT and XLNet, and it uses permutations to generate data from the forward and backward directions at the same time. We used the pre-trained XLNet model from Hugging Face, then fine-tuned the model with a maximum length of 128 to update the pre-trained model to fit our fake news detection dataset.",
+        "bbox": [
+            212,
+            146,
+            787,
+            238
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "ALBERT: Modern language models increasing the model size and quantity of parameters when pre-training natural language representations. They often give better improvements in many downstream tasks, but in some cases, they become harder due to memory limitation and longer hours of training. To address these problems, a self-supervised learning model ALBERT (A Lite BERT) [31] often uses parameter reduction techniques to increase model speed and lower memory consumption. We used the A Lite BERT model for our misinformation detection problem, which achieves better performance than DL models.",
+        "bbox": [
+            212,
+            262,
+            789,
+            383
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Ensemble Model: We ensembled the three transformer models BERT, ALBERT, and XLNet for better prediction. See Figure 4 for the ensemble model. Our ensemble model computes an average of all softmax values from these three transformer models after extracting the softmax probabilities from each model. This model relatively better than other models.",
+        "bbox": [
+            212,
+            407,
+            787,
+            484
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "image",
+        "img_path": "images/a5ebbcdea098609620199e340bcda76ac9b613ac1d09ee9750d7b58429ff70a4.jpg",
+        "image_caption": [
+            "Fig. 4: Transformer based ensemble model architecture"
+        ],
+        "image_footnote": [],
+        "bbox": [
+            290,
+            523,
+            712,
+            619
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "5 Results and Discussion",
+        "text_level": 1,
+        "bbox": [
+            215,
+            715,
+            475,
+            732
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "In this section, we compared the performance of various machine learning, deep learning, and transformer-based models using several evaluation metrics like precision, recall, weighted f1-score and accuracy. The results of the various experiments on the test set are reported in Table 3. The results clearly showing that Transformer based models are considerably better than other machine and deep learning models for our COVID-19 misinformation detection task. And while",
+        "bbox": [
+            212,
+            750,
+            787,
+            840
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "header",
+        "text": "Fake News Detection",
+        "bbox": [
+            588,
+            114,
+            730,
+            127
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "page_number",
+        "text": "9",
+        "bbox": [
+            774,
+            116,
+            784,
+            126
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "table",
+        "img_path": "images/fa27fc6e444efd1e1f7ef24dd940b30ec4ad51d080235af072eaead66f191941.jpg",
+        "table_caption": [],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Model Type</td><td>Model</td><td>Precision</td><td>Recall</td><td>Accuracy</td><td>F1-Score</td></tr><tr><td rowspan=\"3\">ML \nModels</td><td>SVM</td><td>0.9640</td><td>0.9640</td><td>0.964013</td><td>0.964037</td></tr><tr><td>PAC</td><td>0.9673</td><td>0.9673</td><td>0.967285</td><td>0.967289</td></tr><tr><td>MLP</td><td>0.9645</td><td>0.9645</td><td>0.964494</td><td>0.964485</td></tr><tr><td rowspan=\"4\">Deep Learning \nModels</td><td>LSTM with FastText</td><td>0.9682</td><td>0.9682</td><td>0.9682203</td><td>0.968224</td></tr><tr><td>CNN with FastText</td><td>0.9698</td><td>0.9698</td><td>0.969802</td><td>0.969819</td></tr><tr><td>LSTM + CNN</td><td>0.9762</td><td>0.9762</td><td>0.976163</td><td>0.976168</td></tr><tr><td>BiLSTM + Attention</td><td>0.9790</td><td>0.9785</td><td>0.978524</td><td>0.978504</td></tr><tr><td rowspan=\"4\">Transformer \nModels</td><td>BERT</td><td>0.9813</td><td>0.9813</td><td>0.981306</td><td>0.981308</td></tr><tr><td>ALBERT</td><td>0.9781</td><td>0.9781</td><td>0.978031</td><td>0.978037</td></tr><tr><td>XLNet</td><td>0.9787</td><td>0.9789</td><td>0.978596</td><td>0.978592</td></tr><tr><td>Ensemble Model</td><td>0.9855</td><td>0.9855</td><td>0.985512</td><td>0.985514</td></tr></table>",
+        "bbox": [
+            222,
+            142,
+            781,
+            316
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "doing experiments, we observed that few models good at retrieving prominent features while other models have the best classification performance.",
+        "bbox": [
+            212,
+            383,
+            782,
+            412
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Classical machine learning models with various TF-IDF feature vectors gave the approximate baseline model results. We observe that the TF-IDF weighted average performed better than the normal TF-IDF vectors. Bi-directional LSTM with attention mechanism f1-score approximate very close to transformer models. The BERT, XLNet, and ALBERT demonstrate better performance than deep learning models. An ensemble of the transformer-based model produces the best F1 score of 0.9855 on the test set. Our transformer based model ranked 5th among 160 teams.",
+        "bbox": [
+            212,
+            414,
+            784,
+            534
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "table",
+        "img_path": "images/a1754104020ef4b7a2ee818018d3c01e85ca17c523c0a09dd9c4acfb5e7135e5.jpg",
+        "table_caption": [
+            "Table 3: Comparison of various fake news detection models on testset"
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Test Sample</td><td>BERT</td><td>ALBERT</td><td>XLNet</td><td>Ensemble</td></tr><tr><td>#BillGates is shocked that America&#x27;s pandemic response is among the worst in the world.</td><td>✓</td><td>✗</td><td>✗</td><td>✓</td></tr><tr><td>We will all come out stronger from this</td><td>✗</td><td>✗</td><td>✓</td><td>✓</td></tr><tr><td>#COVID #pandemic. Just #StaySafeStayHealthy</td><td></td><td></td><td></td><td></td></tr></table>",
+        "bbox": [
+            217,
+            561,
+            785,
+            636
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Table 4: Misclassified samples from testset",
+        "bbox": [
+            346,
+            645,
+            655,
+            660
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "In some problems, ensembling of four transformer models is very difficult, and sometimes this approach will not perform well. But if we observe the results of individual transformer models on our dataset are very close, meaning that any transformer model can be used for our fake news detection task. This is the major reason behind the ensembling of transformer models.",
+        "bbox": [
+            212,
+            703,
+            784,
+            779
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "In Table 4, we showed the two misclassified test samples. The first test sample actual label is \"real\", but only BERT and ensemble models are predicted correctly, remaining two models wrongly predicted. And the second sample true label is \"fake\", but XLNet and ensemble predicted correctly, remaining two mod-",
+        "bbox": [
+            212,
+            779,
+            785,
+            839
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "page_number",
+        "text": "10",
+        "bbox": [
+            217,
+            114,
+            235,
+            126
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "header",
+        "text": "Gundapu and Mamidi",
+        "bbox": [
+            271,
+            114,
+            419,
+            128
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "els wrongly predicted. However, the ensemble model is correctly predicted in both cases because we are averaging the BERT, ALBERT, and XLNet softmax probabilities. This is a principal observation to ensemble the transformer models.",
+        "bbox": [
+            212,
+            146,
+            787,
+            191
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "6 Conclusion",
+        "text_level": 1,
+        "bbox": [
+            215,
+            214,
+            359,
+            231
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "In this paper, we presented various algorithms to combat the global infodemic, but transformer-based algorithms performed better than others. And we submitted these models to the Shared Task of COVID-19 fake news detection for English, ConstraintAI-2021 workshop.",
+        "bbox": [
+            212,
+            246,
+            785,
+            306
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Fake news is a progressively significant and tricky problem to solve, particularly in an unanticipated situation like the COVID-19 epidemic. Leveraging state-of-the-art classical and advanced NLP models can help address the problem of COVID-19 fake news detection and other global health emergencies. We intend to explore other contextualized embeddings like FLAIR, ELMo, etc., for a better fake news detecting system in future works.",
+        "bbox": [
+            212,
+            306,
+            785,
+            398
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "References",
+        "text_level": 1,
+        "bbox": [
+            215,
+            420,
+            323,
+            436
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "list",
+        "sub_type": "ref_text",
+        "list_items": [
+            "1. Patwa, P., Bhardwaj, M., Guptha, V., Kumari, G., Sharma, S., PYKL, S., Das, A., Ekbal A., Akhtar, S., Chakraborty.: Overview of CONSTRAINTN 2021 Shared Tasks: Detecting English COVID-19 Fake News and Hindi Hostile Posts. (2021). In: Proceedings of the First Workshop on Combating Online Hostile Posts in Regional Languages during Emergency Situation (CONSTRAINT). Springer.",
+            "2. Datta, R., Yadav, K., Singh, A., Datta, K., Bansal, A.: The infodemics of COVID-19 amongst healthcare professionals in india. Med. J. Armed Forces India, vol. 76, no. 3, pp. 276-283, Jul. 2020.",
+            "3. Chen, X., Sin, S.J.: 'Misinformation? What of it?' Motivations and individual differences in misinformation sharing on social media. In: ASIST (2013)",
+            "4. Thorne, J., Vlachos, A.: Automated Fact Checking: Task formulations, methods and future directions. In: COLING (2018)",
+            "5. Titcomb, J., Carson, J.: www.telegraph.co.uk. Fake news: What exactly is it - and how can you spot it?",
+            "6. Kaliyar, R., Singh, N.: Misinformation Detection on Online Social Media-A Survey. (2019). 1-6. 10.1109/ICCCNT45670.2019.8944587.",
+            "7. Zhang, X., Ghorbani, A.: An overview of online fake news: Characterization, detection, and discussion. (2020). Inf. Process. Manag., 57, 102025.",
+            "8. Khan, J.Y., Khondaker, M.T., Iqbal, A., Afroz, S.: A Benchmark Study on Machine Learning Methods for Fake News Detection. (2019). ArXiv, abs/1905.04749.",
+            "9. Elhadad, M., Li, K.F., Gebali, F.: A Novel Approach for Selecting Hybrid Features from Online News Textual Metadata for Fake News Detection. In: Proc. 3PGCIC, Antwerp, Belgium, 2019, pp. 914-925.",
+            "10. Thota, A., Tilak, P., Ahluwalia, S., Lohia, N.: Fake News Detection: A Deep Learning Approach. (2018). SMU Data Science Review: Vol. 1: No. 3, Article 10.",
+            "11. Sean, B., Doug, S., Yuxi, P: Talos Targets Disinformation with Fake News Challenge Victory. (2017). Available online: https://blog.talosintelligence.com/2017/06/talos-fake-news-challenge.html"
+        ],
+        "bbox": [
+            217,
+            450,
+            785,
+            840
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "header",
+        "text": "Fake News Detection",
+        "bbox": [
+            589,
+            114,
+            730,
+            127
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "page_number",
+        "text": "11",
+        "bbox": [
+            767,
+            116,
+            782,
+            126
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "list",
+        "sub_type": "ref_text",
+        "list_items": [
+            "12. Jwa, H., Oh, D., Park, K., Kang, J., Lim, H.: exBAKE: Automatic Fake News Detection Model Based on Bidirectional Encoder Representations from Transformers (BERT). (2019). Applied Sciences, 9, 4062.",
+            "13. Shahi, G.K., Nandini, D.: FakeCovid - A Multilingual Cross-domain Fact Check News Dataset for COVID-19. (2020). ArXiv, abs/2006.11343.",
+            "14. Zhou, X., Mulay, A., Ferrara, E., Zafarani, R.: ReCOVery: A Multimodal Repository for COVID-19 News Credibility Research. (2020). In: Proceedings of the 29th ACM International Conference on Information & Knowledge Management.",
+            "15. Cui, L., Lee, D.: CoAID: COVID-19 Healthcare Misinformation Dataset. (2020). ArXiv, abs/2006.00885.",
+            "16. Memon, S.A., Carley, K.M.: Characterizing COVID-19 Misinformation Communities Using a Novel Twitter Dataset. (2020). ArXiv, abs/2008.00791.",
+            "17. Li, Y., Jiang, B., Shu, K., Liu, H.: MM-COVID: A Multilingual and Multi-modal Data Repository for Combating COVID-19 Disinformation. (2020). ArXiv, abs/2011.04088.",
+            "18. Al-Rakhami, M.S., Al-Amri, A.M.: Lies Kill, Facts Save: Detecting COVID-19 Misinformation in Twitter. (2020). IEEE Access, 8, 155961-155970.",
+            "19. Vijjali, R., Potluri, P., Kumar, S., Teki, S.: Two Stage Transformer Model for COVID-19 Fake News Detection and Fact Checking. (2020).",
+            "20. Hossain, T., RobertL.Logan, I., Ugarte, A., Matsubara, Y., Young, S.,Singh, S.: COVIDLies: Detecting COVID-19 Misinformation on Social Media. (2020). NLP4COVID@EMNLP.",
+            "21. Patwa, P., Sharma, S., Pykl, S., Guptha, V., Kumari, G., Akhtar, M.S., Ekbal, A., Das, A., Chakraborty, T. (2020). Fighting an Infodemic: COVID-19 Fake News Dataset. ArXiv, abs/2011.03327.",
+            "22. Elhadad, M.K., Li, K., Gebali, F.: Detecting Misleading Information on COVID-19. (2020). IEEE Access, 8, 165201-165215.",
+            "23. Pennington, J., Socher, R., Manning, C.D.: Glove: Global Vectors for Word Representation. (2014). In: EMNLP.",
+            "24. Hochreiter, S., Schmidhuber, J.: Long Short-Term Memory. (1997). Neural Computation, 9, 1735-1780.",
+            "25. Bojanowski, P., Grave, E., Joulin, A., Mikolov, T.: Enriching Word Vectors with Subword Information. (2017). Transactions of the Association for Computational Linguistics, 5, 135-146.",
+            "26. Vaswani, A., Shazeer, N., Parmar, N., Uszkoreit, J., Jones, L., Gomez, A.N., Kaiser, L., Polosukhin, I.: Attention is All you Need. (2017). NIPS.",
+            "27. LeCun, Y., Bengio, Y., Hinton, G.: Deep learning. (2015). Nature, 521(7553), pp.436-444.",
+            "28. Devlin, J., Chang, M., Lee, K., Toutanova, K.: BERT: Pre-training of Deep Bidirectional Transformers for Language Understanding. (2019). NAACL-HLT.",
+            "29. Yang, Z., Dai, Z., Yang, Y., Carbonell, J., Salakhutdinov, R., Le, Q.V.: XL-Net: Generalized Autoregressive Pretraining for Language Understanding. (2019). NeurIPS.",
+            "30. Dai, Z., Yang, Z., Yang, Y., Carbonell, J., Le, Q.V., Salakhutdinov, R.: Transformer-XL: Attentive Language Models Beyond a Fixed-Length Context. (2019). ACL.",
+            "31. Lan, Z., Chen, M., Goodman, S., Gimpel, K., Sharma, P., Soricut, R.: ALBERT: A Lite BERT for Self-supervised Learning of Language Representations. (2020). ArXiv, abs/1909.11942."
+        ],
+        "bbox": [
+            215,
+            147,
+            784,
+            825
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "page_number",
+        "text": "12",
+        "bbox": [
+            217,
+            114,
+            235,
+            126
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "header",
+        "text": "Gundapu and Mamidi",
+        "bbox": [
+            271,
+            114,
+            419,
+            128
+        ],
+        "page_idx": 11
+    }
+]

data/2021/2101_00xxx/2101.00180/e6c1938e-fd7a-49b4-ac0c-6863dca02ce5_model.json

@@ -1,3 +1,1720 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:c80a6cafe5e94e4b0bcbfcfbdcd8b3010159cdd1b0a4acb26ceb01220fc31ad0
-size 65124
+[
+    [
+        {
+            "type": "aside_text",
+            "bbox": [
+                0.023,
+                0.273,
+                0.058,
+                0.709
+            ],
+            "angle": 270,
+            "content": "arXiv:2101.00180v3 [cs.CL] 21 Jan 2021"
+        },
+        {
+            "type": "title",
+            "bbox": [
+                0.231,
+                0.141,
+                0.776,
+                0.187
+            ],
+            "angle": 0,
+            "content": "Transformer based Automatic COVID-19 Fake News Detection System"
+        },
+        {
+            "type": "text",
+            "bbox": [
+                0.366,
+                0.213,
+                0.637,
+                0.229
+            ],
+            "angle": 0,
+            "content": "Sunil Gundapu and Radhika Mamidi"
+        },
+        {
+            "type": "text",
+            "bbox": [
+                0.292,
+                0.241,
+                0.713,
+                0.269
+            ],
+            "angle": 0,
+            "content": "International Institute of Information Technology, Hyderabad sunil.g@research.iit.ac.in, radhika.mamidi@iit.ac.in"
+        },
+        {
+            "type": "text",
+            "bbox": [
+                0.262,
+                0.308,
+                0.744,
+                0.502
+            ],
+            "angle": 0,
+            "content": "Abstract. Recent rapid technological advancements in online social networks such as Twitter have led to a great incline in spreading false information and fake news. Misinformation is especially prevalent in the ongoing coronavirus disease (COVID-19) pandemic, leading to individuals accepting bogus and potentially deleterious claims and articles. Quick detection of fake news can reduce the spread of panic and confusion among the public. For our analysis in this paper, we report a methodology to analyze the reliability of information shared on social media pertaining to the COVID-19 pandemic. Our best approach is based on an ensemble of three transformer models (BERT, ALBERT, and XLNET) to detecting fake news. This model was trained and evaluated in the context of the ConstraintAI 2021 shared task \"COVID19 Fake News Detection in English\" [1]. Our system obtained 0.9855 f1-score on testset and ranked 5th among 160 teams."
+        },
+        {
+            "type": "text",
+            "bbox": [
+                0.263,
+                0.515,
+                0.717,
+                0.53
+            ],
+            "angle": 0,
+            "content": "Keywords: pandemic-19, fake news, deep learning, transformer models"
+        },
+        {
+            "type": "title",
+            "bbox": [
+                0.217,
+                0.557,
+                0.377,
+                0.573
+            ],
+            "angle": 0,
+            "content": "1 Introduction"
+        },
+        {
+            "type": "text",
+            "bbox": [
+                0.214,
+                0.589,
+                0.788,
+                0.74
+            ],
+            "angle": 0,
+            "content": "The COVID-19 pandemic is considered the global public health crisis of the whole world and the biggest problem people faced after World War II. COVID-19, a contagious disease caused by a coronavirus, has caused more than 75 million confirmed cases and 1.7 million deaths across the world till 2020 December<sup>1</sup>. Unfortunately, the misinformation about COVID-19 has encouraged the growing of the disease and chaos among people. During the Munich Security Council held on February 15, 2020, World Health Organization (WHO) Director-General, Tedros Adhanom Ghebreyesus [2] stated that the world was in a war to fight not only a pandemic, but also an infodemic. So we should address the challenge of fake news detection to stop the spreading of COVID-19 misinformation."
+        },
+        {
+            "type": "text",
+            "bbox": [
+                0.214,
+                0.741,
+                0.788,
+                0.817
+            ],
+            "angle": 0,
+            "content": "Since the global pandemic impacts the people, there is a broader public finding information about the COVID-19, whose safety is intimidated by adversarial agents invested in spreading fake news for economic and political reasons. Besides, due to medical and public health issues, it is also hard to be totally valid and factual, leading to differences that worsen with fake news. This difficulty"
+        },
+        {
+            "type": "page_footnote",
+            "bbox": [
+                0.218,
+                0.824,
+                0.537,
+                0.841
+            ],
+            "angle": 0,
+            "content": "<sup>1</sup> https://www.worldometers.info/coronavirus/"
+        }
+    ],
+    [
+        {
+            "type": "page_number",
+            "bbox": [
+                0.218,
+                0.116,
+                0.23,
+                0.127
+            ],
+            "angle": 0,
+            "content": "2"
+        },
+        {
+            "type": "header",
+            "bbox": [
+                0.272,
+                0.115,
+                0.422,
+                0.129
+            ],
+            "angle": 0,
+            "content": "Gundapu and Mamidi"
+        },
+        {
+            "type": "text",
+            "bbox": [
+                0.214,
+                0.147,
+                0.788,
+                0.253
+            ],
+            "angle": 0,
+            "content": "is compounded by the quick advancement of knowledge about the disease. As researchers gain more knowledge about the virus, claims that looked right may turn out to be false, and vice versa. Detecting this spread of COVID-19 associated fake news, thus, has become a pivotal problem, gaining notable attention from government and global health organizations (WHO, 2020), online social networks (TechCrunch, 2020), and news organizations (BBC, 2020; CNN, 2020; New York Times, 2020)."
+        },
+        {
+            "type": "text",
+            "bbox": [
+                0.214,
+                0.253,
+                0.788,
+                0.388
+            ],
+            "angle": 0,
+            "content": "In response to the present disinformation, this paper looks at developing an efficient fake news detection architecture with respect to COVID-19. Initially, we started with developing machine learning (ML) algorithms with Term Frequency and Inverse Document Frequency (TF-IDF) feature vectors to detect misinformation on the provided dataset. These supervised TF-IDF methods are still relevant for many classification tasks and performed pretty well for fake news detection. We developed an effective ensemble model integrated with three transformer models for detecting fake news on the social media platforms. This resulted in higher accuracy and a more generalized model."
+        },
+        {
+            "type": "text",
+            "bbox": [
+                0.214,
+                0.389,
+                0.788,
+                0.48
+            ],
+            "angle": 0,
+            "content": "The rest of this paper is organized as follows, Section II presents some prior works related to fake news, and its spread, on social media platforms. In Section III, we describe the dataset provided in the Constraint AI-2021 shared task. Section IV presents implemented models and framework for misinformation detection. Section V provides the discussions on the results. Finally we conclude this paper in Section VI."
+        },
+        {
+            "type": "title",
+            "bbox": [
+                0.216,
+                0.501,
+                0.388,
+                0.516
+            ],
+            "angle": 0,
+            "content": "2 Related Work"
+        },
+        {
+            "type": "text",
+            "bbox": [
+                0.214,
+                0.53,
+                0.788,
+                0.635
+            ],
+            "angle": 0,
+            "content": "Fake News Detection: Fake news can be defined as inaccurate and misleading information that is growing knowingly or unknowingly [3]. Recognizing the spread of false information such as rumors, fake news, propaganda, hoaxes, spear phishing, and conspiracy theories is an essential task for natural language processing [4]. Gartner's [5] research studies explained that most people in advanced economies would believe more fake information than truthful information by 2022."
+        },
+        {
+            "type": "text",
+            "bbox": [
+                0.214,
+                0.636,
+                0.788,
+                0.787
+            ],
+            "angle": 0,
+            "content": "To date, so many automated misinformation detection architectures have been developed. Rohit et al. [6] provided an extensive survey to detect fake news on various online social networks. Ghorbani et al. [7] presented an inclusive overview of the recent studies related to misinformation. Furthermore, they described the impact of misleading information, shown state-of-the-art fake news detection systems, and explored the disinformation detection datasets. The majority of the fake news detection models developed using supervised machine learning algorithms to classify the data as misleading or not [8]. This supervised classification is concluded by comparing the user input text with some already created corpora containing genuine and misleading information [9]."
+        },
+        {
+            "type": "text",
+            "bbox": [
+                0.214,
+                0.787,
+                0.788,
+                0.818
+            ],
+            "angle": 0,
+            "content": "Aswini et al. [10] proposed a deep learning architecture with various word embeddings for Fake News Challenge (FCN-1) dataset<sup>2</sup>. They developed the"
+        },
+        {
+            "type": "page_footnote",
+            "bbox": [
+                0.218,
+                0.824,
+                0.473,
+                0.841
+            ],
+            "angle": 0,
+            "content": "2 http://www.fakenewschallenge.org/"
+        }
+    ],
+    [
+        {
+            "type": "header",
+            "bbox": [
+                0.59,
+                0.115,
+                0.732,
+                0.128
+            ],
+            "angle": 0,
+            "content": "Fake News Detection"
+        },
+        {
+            "type": "page_number",
+            "bbox": [
+                0.775,
+                0.117,
+                0.785,
+                0.127
+            ],
+            "angle": 0,
+            "content": "3"
+        },
+        {
+            "type": "text",
+            "bbox": [
+                0.214,
+                0.147,
+                0.788,
+                0.284
+            ],
+            "angle": 0,
+            "content": "architecture to accurately predict the stance between a given pair of news headlines and the corresponding article/body. On the same FCN-1 dataset, Sean et al. [11] developed an average weighted model of TalosCNN and TalosTree called TalosComb. TalosCNN is a convolutional neural network with pre-trained word2vec embeddings, and TalosTree is a gradient-boosted decision tree model with SVD, word count, TF-IDF. By analyzing the relationship between the news headline and the corresponding article, Heejung et al. [12] designed the Bidirectional Encoder Representations from Transformers model (BERT) to detect misleading news articles."
+        },
+        {
+            "type": "text",
+            "bbox": [
+                0.214,
+                0.31,
+                0.788,
+                0.475
+            ],
+            "angle": 0,
+            "content": "COVID-19: In the case of COVID-19 fake news, a large number of misleading contents remain online on social media platforms. NLP researchers have been working on developing algorithms for the detection of online COVID-19 related disinformation. To develop any algorithm, we require a corpus. So members of the NLP community created the various fake news datasets: FakeCovid [13], ReCOVery [14], CoAID [15], and CMU-MisCOVID19 [16]. Yichuan Li et al. [17] developed multi-dimensional and multilingual MM-COVID corpora, which covers six languages. Mabrook et al. [18] created a large Twitter dataset related to COVID-19 misinformation. And authors developed an ensemble-stacking model with six machine learning algorithms on the created dataset for detecting misinformation."
+        },
+        {
+            "type": "text",
+            "bbox": [
+                0.214,
+                0.477,
+                0.788,
+                0.629
+            ],
+            "angle": 0,
+            "content": "Elhadad et al. [22] constructed a voting ensemble machine learning classifier for fake news detection that uses seven feature extraction techniques and ten machine learning models. Tamanna et al. [20] used the COVIDLIES dataset to detect the misinformation by retrieving the misconceptions relevant to the Twitter posts. For COVID-19 fake news detection and fact-checking, Rutvik et al. [19] proposed a two-stage transformer model. The first model retrieves the most relevant facts about COVID-19 by using a novel fact-checking algorithm, and the second model, by computing the textual entailment, verifies the level of truth. Adapting all these classical and hybrid related work techniques, we developed a COVID-19 fake news detection system in this paper."
+        },
+        {
+            "type": "title",
+            "bbox": [
+                0.215,
+                0.656,
+                0.446,
+                0.673
+            ],
+            "angle": 0,
+            "content": "3 Dataset Description"
+        },
+        {
+            "type": "text",
+            "bbox": [
+                0.214,
+                0.692,
+                0.788,
+                0.813
+            ],
+            "angle": 0,
+            "content": "The ConstraintAI\\(^{21}\\) shared task organizers developed a COVID-19 fake news detection in English dataset [21] containing 10,700 data points collected from various online social networks such as Twitter, Facebook, and Instagram, etc. From the total dataset, 6,420 data points are reserved for training, 2,140 data points are used for hyperparameter tuning as a part of the validation phase, and the remaining 2,140 social media posts are kept aside for testing. Each dataset except the test set contains social media data points and their corresponding labels, either real or fake."
+        },
+        {
+            "type": "page_footnote",
+            "bbox": [
+                0.218,
+                0.824,
+                0.543,
+                0.841
+            ],
+            "angle": 0,
+            "content": "3 https://constraint-shared-task-2021.github.io/"
+        }
+    ],
+    [
+        {
+            "type": "page_number",
+            "bbox": [
+                0.218,
+                0.116,
+                0.23,
+                0.127
+            ],
+            "angle": 0,
+            "content": "4"
+        },
+        {
+            "type": "header",
+            "bbox": [
+                0.272,
+                0.115,
+                0.422,
+                0.129
+            ],
+            "angle": 0,
+            "content": "Gundapu and Mamidi"
+        },
+        {
+            "type": "table",
+            "bbox": [
+                0.229,
+                0.156,
+                0.404,
+                0.217
+            ],
+            "angle": 0,
+            "content": "<table><tr><td>Corpus</td><td>Real</td><td>Fake</td></tr><tr><td>Train</td><td>3360</td><td>3060</td></tr><tr><td>Valid</td><td>1120</td><td>1020</td></tr><tr><td>Test</td><td>1120</td><td>1020</td></tr></table>"
+        },
+        {
+            "type": "table_footnote",
+            "bbox": [
+                0.241,
+                0.22,
+                0.384,
+                0.233
+            ],
+            "angle": 0,
+            "content": "(a) Dataset Statistics"
+        },
+        {
+            "type": "table",
+            "bbox": [
+                0.432,
+                0.156,
+                0.782,
+                0.217
+            ],
+            "angle": 0,
+            "content": "<table><tr><td>Tweet</td><td>Label</td></tr><tr><td>CDC Recommends Mothers Stop Breastfeeding To Boost Vaccine Efficacy</td><td>fake</td></tr><tr><td>1000 COVID-19 testing labs in India: ICMR</td><td>real</td></tr></table>"
+        },
+        {
+            "type": "table_footnote",
+            "bbox": [
+                0.526,
+                0.22,
+                0.682,
+                0.234
+            ],
+            "angle": 0,
+            "content": "(b) Label-wise example"
+        },
+        {
+            "type": "table_caption",
+            "bbox": [
+                0.36,
+                0.234,
+                0.644,
+                0.247
+            ],
+            "angle": 0,
+            "content": "Table 1: Fake news dataset information"
+        },
+        {
+            "type": "text",
+            "bbox": [
+                0.214,
+                0.288,
+                0.788,
+                0.471
+            ],
+            "angle": 0,
+            "content": "Table 1 shows the corpus size and label distribution, and if we observe, the labels in each dataset are all roughly balanced. Table 2 shows some examples from the COVID-19 fake news detection in the English dataset. We illustrate the most occurring word cloud of the real and fake data points after removing the stop words in Figures 1(a) and 1(b). In Figure 1(a), we can see unique words in real-labeled data points which don't often occur in Figure 1(b), like \"covid19\", \"discharged\", \"confirmed\", \"testing\", \"indiafightscorona\", and \"indiawin\", etc.; meanwhile, from Figure 1(b), we can find unique words frequently appearing in the fake articles, which include \"coronavirus\", \"kill\", \"muslim\", \"hydroxychloroquine\", \"china\", and \"facebook post\", but don't frequently appear in the true labeled data points. These frequent textual words can give important information to differentiate the true data points from fake ones."
+        },
+        {
+            "type": "image",
+            "bbox": [
+                0.248,
+                0.505,
+                0.486,
+                0.688
+            ],
+            "angle": 0,
+            "content": null
+        },
+        {
+            "type": "image_caption",
+            "bbox": [
+                0.291,
+                0.691,
+                0.446,
+                0.705
+            ],
+            "angle": 0,
+            "content": "(a) Positive word cloud"
+        },
+        {
+            "type": "image",
+            "bbox": [
+                0.514,
+                0.505,
+                0.75,
+                0.688
+            ],
+            "angle": 0,
+            "content": null
+        },
+        {
+            "type": "image_caption",
+            "bbox": [
+                0.554,
+                0.691,
+                0.716,
+                0.706
+            ],
+            "angle": 0,
+            "content": "(b) Negative word cloud"
+        },
+        {
+            "type": "image_caption",
+            "bbox": [
+                0.351,
+                0.717,
+                0.651,
+                0.733
+            ],
+            "angle": 0,
+            "content": "Fig. 1: Illustration of frequent word cloud"
+        },
+        {
+            "type": "title",
+            "bbox": [
+                0.216,
+                0.782,
+                0.381,
+                0.8
+            ],
+            "angle": 0,
+            "content": "4 Methodology"
+        },
+        {
+            "type": "text",
+            "bbox": [
+                0.214,
+                0.81,
+                0.787,
+                0.84
+            ],
+            "angle": 0,
+            "content": "In this part, we present our transformer based ensemble model that is trained and tuned on the datasets which reported in the previous section. We compare our"
+        }
+    ],
+    [
+        {
+            "type": "header",
+            "bbox": [
+                0.589,
+                0.115,
+                0.732,
+                0.128
+            ],
+            "angle": 0,
+            "content": "Fake News Detection"
+        },
+        {
+            "type": "page_number",
+            "bbox": [
+                0.775,
+                0.117,
+                0.785,
+                0.127
+            ],
+            "angle": 0,
+            "content": "5"
+        },
+        {
+            "type": "text",
+            "bbox": [
+                0.214,
+                0.147,
+                0.784,
+                0.193
+            ],
+            "angle": 0,
+            "content": "approach with various machine learning (ML) and deep learning (DL) models with different word embeddings. The full code of system architecture can be found at GitHub<sup>4</sup>."
+        },
+        {
+            "type": "title",
+            "bbox": [
+                0.215,
+                0.211,
+                0.424,
+                0.227
+            ],
+            "angle": 0,
+            "content": "4.1 Data Preprocessing"
+        },
+        {
+            "type": "text",
+            "bbox": [
+                0.214,
+                0.233,
+                0.784,
+                0.28
+            ],
+            "angle": 0,
+            "content": "The main aim of this part is to use the NLP techniques to preprocess the input tweet data and prepare for the next step to extract the proper features. In Figure 2, we shown the detailed data preprocessing pipeline with examples."
+        },
+        {
+            "type": "image",
+            "bbox": [
+                0.223,
+                0.311,
+                0.784,
+                0.422
+            ],
+            "angle": 0,
+            "content": null
+        },
+        {
+            "type": "image_caption",
+            "bbox": [
+                0.375,
+                0.432,
+                0.626,
+                0.447
+            ],
+            "angle": 0,
+            "content": "Fig. 2: Data preprocessing pipeline"
+        },
+        {
+            "type": "text",
+            "bbox": [
+                0.214,
+                0.499,
+                0.784,
+                0.56
+            ],
+            "angle": 0,
+            "content": "In the preprocessing step, we will forward the tokenized tweet through the pipeline to eliminate the noise in the fake news dataset by remove or normalize the unnecessary tokens. The preprocessing pipeline includes the following subparts:"
+        },
+        {
+            "type": "text",
+            "bbox": [
+                0.222,
+                0.566,
+                0.784,
+                0.598
+            ],
+            "angle": 0,
+            "content": "1. Emoticon Conversion: In this step, we converted the each emoticon in the tweet to text. Example: \\(\\rightarrow\\) Face with medical mask emoji"
+        },
+        {
+            "type": "text",
+            "bbox": [
+                0.222,
+                0.599,
+                0.784,
+                0.643
+            ],
+            "angle": 0,
+            "content": "2. Handling of Hashtags: We identified the hashtag tokens by seeing pound (#) sign and splitted these based on digits or capital letters. Example: #IndiaFightsCorona → IndiaFightsCorona"
+        },
+        {
+            "type": "text",
+            "bbox": [
+                0.222,
+                0.643,
+                0.784,
+                0.673
+            ],
+            "angle": 0,
+            "content": "3. Stemming: We removed the inflectional morphemes like \"ed\", \"est\", \"s\", and \"ing\" from their token stem. Ex: confirmed \\(\\rightarrow\\) \"confirm\" + \"-ed\""
+        },
+        {
+            "type": "text",
+            "bbox": [
+                0.222,
+                0.673,
+                0.784,
+                0.703
+            ],
+            "angle": 0,
+            "content": "4. Text cleaning: To remove the irrelevant data we used this step. Removed punctuation marks, digits and, non-ASCII glyphs from the tweet."
+        },
+        {
+            "type": "list",
+            "bbox": [
+                0.222,
+                0.566,
+                0.784,
+                0.703
+            ],
+            "angle": 0,
+            "content": null
+        },
+        {
+            "type": "title",
+            "bbox": [
+                0.215,
+                0.722,
+                0.572,
+                0.737
+            ],
+            "angle": 0,
+            "content": "4.2 Supervised Machine Learning Models"
+        },
+        {
+            "type": "text",
+            "bbox": [
+                0.214,
+                0.743,
+                0.784,
+                0.819
+            ],
+            "angle": 0,
+            "content": "To build the finest system for fake news detection, we started our investigations with traditional NLP approaches like Linear Regression (LR), Support Vector MAchines (SVM), Passive Agressive Classifier (PAC), XGBoost, and Multi-Layer Perceptron (MLP). We study the results of above mentioned supervised models with the combination of three types of word vectors:"
+        },
+        {
+            "type": "page_footnote",
+            "bbox": [
+                0.218,
+                0.825,
+                0.664,
+                0.84
+            ],
+            "angle": 0,
+            "content": "4 https://github.com/SunilGundapu/Covid-19-fake-news-detection"
+        }
+    ],
+    [
+        {
+            "type": "page_number",
+            "bbox": [
+                0.218,
+                0.116,
+                0.23,
+                0.127
+            ],
+            "angle": 0,
+            "content": "6"
+        },
+        {
+            "type": "header",
+            "bbox": [
+                0.272,
+                0.115,
+                0.422,
+                0.129
+            ],
+            "angle": 0,
+            "content": "Gundapu and Mamidi"
+        },
+        {
+            "type": "text",
+            "bbox": [
+                0.223,
+                0.147,
+                0.784,
+                0.175
+            ],
+            "angle": 0,
+            "content": "1. Word-level, n-gram level, and character level TF-IDF vectors with the feature matrix size of 100000."
+        },
+        {
+            "type": "text",
+            "bbox": [
+                0.223,
+                0.177,
+                0.701,
+                0.192
+            ],
+            "angle": 0,
+            "content": "2. English Glove [23] word embeddings with the dimension of 300."
+        },
+        {
+            "type": "text",
+            "bbox": [
+                0.223,
+                0.192,
+                0.785,
+                0.222
+            ],
+            "angle": 0,
+            "content": "3. TF-IDF weighted averaging with Glove embeddings. We described below the fake news vector construction."
+        },
+        {
+            "type": "list",
+            "bbox": [
+                0.223,
+                0.147,
+                0.785,
+                0.222
+            ],
+            "angle": 0,
+            "content": null
+        },
+        {
+            "type": "equation",
+            "bbox": [
+                0.323,
+                0.247,
+                0.785,
+                0.295
+            ],
+            "angle": 0,
+            "content": "\\[\nT w e e t _ {v e c t o r} = \\frac {\\sum_ {i = 1} ^ {N} \\mathbf {t f - i d f} (t o k e n _ {i}) \\times \\mathbf {G l o v e} (t o k e n _ {i})}{\\mathbf {N}} \\tag {1}\n\\]"
+        },
+        {
+            "type": "text",
+            "bbox": [
+                0.215,
+                0.3,
+                0.785,
+                0.346
+            ],
+            "angle": 0,
+            "content": "In the above formula, \\( \\mathrm{N} \\) is the total number of words in the input fake news tweet, and \\( \\text{token}_i \\) is the \\( i^{th} \\) token in the input text. After analyzing the results, TF-IDF weighted averaging gave better results than the standard TF-IDF."
+        },
+        {
+            "type": "title",
+            "bbox": [
+                0.216,
+                0.368,
+                0.45,
+                0.384
+            ],
+            "angle": 0,
+            "content": "4.3 Deep Learning Models"
+        },
+        {
+            "type": "text",
+            "bbox": [
+                0.214,
+                0.394,
+                0.785,
+                0.44
+            ],
+            "angle": 0,
+            "content": "Supervised machine learning algorithms performed very well on the provided dataset. In this section, we experiment with deep learning models that give better results than traditional classification algorithms."
+        },
+        {
+            "type": "text",
+            "bbox": [
+                0.214,
+                0.461,
+                0.785,
+                0.522
+            ],
+            "angle": 0,
+            "content": "LSTM: We used Long Short-Term Memory (LSTM) [24] architecture with two different pre-trained word embeddings Glove and Fasttext [25]. LSTM is a type of Recurrent Neural Network (RNN) that can solve long term dependency problem, and it is a well-suited model for sequence classification."
+        },
+        {
+            "type": "text",
+            "bbox": [
+                0.214,
+                0.522,
+                0.785,
+                0.613
+            ],
+            "angle": 0,
+            "content": "We converted the input data points into word vectors by using pre-trained word embeddings. These word vectors are passed as input to the LSTM layer. We stacked up two LSTM layers one after another with the dropout of 0.25. The size of LSTM is 128, and the last time step output is treated as input data point representation. The final time step's outcome is passed as an input to a dense layer for fake news detection."
+        },
+        {
+            "type": "text",
+            "bbox": [
+                0.214,
+                0.636,
+                0.785,
+                0.697
+            ],
+            "angle": 0,
+            "content": "BiLSTM with Attention: Sometimes not all the tokens in the input text contribute equally to the representation of input text. So we advantage word attention [26] mechanism to catch the tokens' prominent influence on the input data point. We built this attention mechanism on top of BiLSTM layers."
+        },
+        {
+            "type": "text",
+            "bbox": [
+                0.214,
+                0.697,
+                0.785,
+                0.757
+            ],
+            "angle": 0,
+            "content": "The sequence of word vector is passed through a BiLSTM layer, which contains one forward and backward LSTM layer. Attention mechanism applied to the output of BiLSTM layer, which produces a dense vector. This dense vector is forwarded to a fully connected network."
+        },
+        {
+            "type": "text",
+            "bbox": [
+                0.214,
+                0.78,
+                0.785,
+                0.84
+            ],
+            "angle": 0,
+            "content": "CNN: We explored a Convolution Neural Network (CNN) [27] model for misinformation detection. The model consists of an embedding layer, a convolution layer with 3 convolutions, a max-pooling layer, and a fully connected network. In the embedding layer, the input texts are converted into \\( n \\times d \\) sequence matrix,"
+        }
+    ],
+    [
+        {
+            "type": "header",
+            "bbox": [
+                0.589,
+                0.115,
+                0.732,
+                0.128
+            ],
+            "angle": 0,
+            "content": "Fake News Detection"
+        },
+        {
+            "type": "page_number",
+            "bbox": [
+                0.775,
+                0.116,
+                0.785,
+                0.127
+            ],
+            "angle": 0,
+            "content": "7"
+        },
+        {
+            "type": "text",
+            "bbox": [
+                0.214,
+                0.147,
+                0.788,
+                0.253
+            ],
+            "angle": 0,
+            "content": "where \\( n \\) is the length of the input data point and \\( d \\) is the length of the word embedding dimension. In the convolution layer, fed the sequence matrix through three 1D convolutions of kernel sizes 3, 4, and 5. And each convolutions filter size is 128. The convolution layer's output is max pooled over time and concatenated to get the input datapoint representations in the max-pooling layer. The output of the max-pooling layer is passed to a fully connected network with a softmax output layer."
+        },
+        {
+            "type": "text",
+            "bbox": [
+                0.214,
+                0.275,
+                0.788,
+                0.351
+            ],
+            "angle": 0,
+            "content": "CNN + BiLSTM: A CNN and BiLSTM architecture is an ensemble of CNN and bidirectional LSTM models with Fasttext/Glove word embeddings. In this architecture, the CNN extracts the maximum amount of features/information from the input text using convolution layers. The output of CNN becomes the input to BiLSTM, which keeps the data in chronological order in both directions."
+        },
+        {
+            "type": "text",
+            "bbox": [
+                0.214,
+                0.352,
+                0.788,
+                0.412
+            ],
+            "angle": 0,
+            "content": "The sequence of word vectors are forwarded through a convolution of kernel size 3 with filter size 128. The output of convolution is passed through a BiLSTM. The outcome of BiLSTM is max-pooled over time and followed by one dense layer and a softmax layer."
+        },
+        {
+            "type": "title",
+            "bbox": [
+                0.216,
+                0.435,
+                0.431,
+                0.449
+            ],
+            "angle": 0,
+            "content": "4.4 Transformer Models"
+        },
+        {
+            "type": "text",
+            "bbox": [
+                0.214,
+                0.46,
+                0.788,
+                0.535
+            ],
+            "angle": 0,
+            "content": "This section explored individual and ensembling of the three transformer models BERT, ALBERT, and XLNet. These models have outperformed the other ML and DL algorithms. We implemented these models using HuggingFace<sup>5</sup> is a PyTorch transformer library. And the hyperparameters of the three models are described in Table 1."
+        },
+        {
+            "type": "table",
+            "bbox": [
+                0.218,
+                0.558,
+                0.787,
+                0.647
+            ],
+            "angle": 0,
+            "content": "<table><tr><td>Model</td><td>Learning Rate</td><td>Batch Size</td><td>Optimizer</td><td>Max Length</td><td>Type</td></tr><tr><td>BERT</td><td>2e-5</td><td>16</td><td>Adam</td><td>128</td><td>BERT-Base</td></tr><tr><td>XLNet</td><td>2e-5</td><td>16</td><td>Adam</td><td>128</td><td>XLNetLarge</td></tr><tr><td>ALBERT</td><td>2e-5</td><td>32</td><td>Adam</td><td>128</td><td>ALBERT-Xlarge</td></tr></table>"
+        },
+        {
+            "type": "table_caption",
+            "bbox": [
+                0.325,
+                0.657,
+                0.679,
+                0.673
+            ],
+            "angle": 0,
+            "content": "Table 2: Hyperparameters of transformer models"
+        },
+        {
+            "type": "text",
+            "bbox": [
+                0.214,
+                0.74,
+                0.788,
+                0.817
+            ],
+            "angle": 0,
+            "content": "BERT: Bidirectional Encoder Representations from Transformers (henceforth, BERT) [28] is a transformer model developed to pre-train deep bidirectional representations from unseen data. This model developed by combining two robust concepts: (i) It's a deep transformer model so that it can process lengthy sentences effectively by using attention mechanism, and (ii) It's a bidirectional"
+        },
+        {
+            "type": "page_footnote",
+            "bbox": [
+                0.218,
+                0.825,
+                0.483,
+                0.841
+            ],
+            "angle": 0,
+            "content": "5 https://huggingface.co/transformers/"
+        }
+    ],
+    [
+        {
+            "type": "page_number",
+            "bbox": [
+                0.218,
+                0.116,
+                0.23,
+                0.127
+            ],
+            "angle": 0,
+            "content": "8"
+        },
+        {
+            "type": "header",
+            "bbox": [
+                0.272,
+                0.115,
+                0.422,
+                0.129
+            ],
+            "angle": 0,
+            "content": "Gundapu and Mamidi"
+        },
+        {
+            "type": "text",
+            "bbox": [
+                0.214,
+                0.147,
+                0.784,
+                0.176
+            ],
+            "angle": 0,
+            "content": "network, so it takes into account the entire text passage to comprehend the meaning of each token."
+        },
+        {
+            "type": "text",
+            "bbox": [
+                0.214,
+                0.178,
+                0.785,
+                0.252
+            ],
+            "angle": 0,
+            "content": "BERT implementation has two steps; one is pre-training and another fin-tuning. In the first step, the model is trained on unseen data over various pretraining problems using a dataset in a particular language or in increases data with multiple languages. In the second step, all the initialized parameters are fine-tuned using the labeled data from certain tasks."
+        },
+        {
+            "type": "text",
+            "bbox": [
+                0.214,
+                0.253,
+                0.787,
+                0.357
+            ],
+            "angle": 0,
+            "content": "We fine-tuned the pre-trained BERT (Base) model for our COVID-19 fake news detection task. BERT base model contains the 12 layers of encoder blocks and 12 bidirectional self-attention heads by considering the sequence of 512 tokens and emitting the representations of a sequence of hidden vectors. We added one additional output layer on top of the BERT model to calculate the conditional probability over the output classes, either fake or real. See FIGURE 1 for the fine-tuned model of BERT."
+        },
+        {
+            "type": "image",
+            "bbox": [
+                0.293,
+                0.396,
+                0.71,
+                0.609
+            ],
+            "angle": 0,
+            "content": null
+        },
+        {
+            "type": "image_caption",
+            "bbox": [
+                0.382,
+                0.62,
+                0.621,
+                0.636
+            ],
+            "angle": 0,
+            "content": "Fig. 3: BERT model architecture"
+        },
+        {
+            "type": "text",
+            "bbox": [
+                0.214,
+                0.704,
+                0.788,
+                0.839
+            ],
+            "angle": 0,
+            "content": "XLNet: XLNet is an enhanced version of BERT. To understand the language context deeper, XLNet [29] uses Transformer-XL [30] as a feature engineering model, which alone is an adoption upon the native Transformer. This Transformer XL model integrates the two components Recurrence Mechanism and Relative Positional Encoding (RPE) to the Transformer used in BERT to handle the long-term dependencies for texts that are longer than the maximum allowed input length. Recurrence Mechanism will give context between two sequences at specific segments and RPE, which carries similarity information between two tokens."
+        }
+    ],
+    [
+        {
+            "type": "header",
+            "bbox": [
+                0.589,
+                0.115,
+                0.732,
+                0.128
+            ],
+            "angle": 0,
+            "content": "Fake News Detection"
+        },
+        {
+            "type": "page_number",
+            "bbox": [
+                0.775,
+                0.117,
+                0.785,
+                0.127
+            ],
+            "angle": 0,
+            "content": "9"
+        },
+        {
+            "type": "text",
+            "bbox": [
+                0.214,
+                0.147,
+                0.788,
+                0.239
+            ],
+            "angle": 0,
+            "content": "The XLNet model has been trained on a huge dataset using the permutation language modeling. This technique is one of the main differences between BERT and XLNet, and it uses permutations to generate data from the forward and backward directions at the same time. We used the pre-trained XLNet model from Hugging Face, then fine-tuned the model with a maximum length of 128 to update the pre-trained model to fit our fake news detection dataset."
+        },
+        {
+            "type": "text",
+            "bbox": [
+                0.214,
+                0.263,
+                0.79,
+                0.385
+            ],
+            "angle": 0,
+            "content": "ALBERT: Modern language models increasing the model size and quantity of parameters when pre-training natural language representations. They often give better improvements in many downstream tasks, but in some cases, they become harder due to memory limitation and longer hours of training. To address these problems, a self-supervised learning model ALBERT (A Lite BERT) [31] often uses parameter reduction techniques to increase model speed and lower memory consumption. We used the A Lite BERT model for our misinformation detection problem, which achieves better performance than DL models."
+        },
+        {
+            "type": "text",
+            "bbox": [
+                0.214,
+                0.408,
+                0.788,
+                0.485
+            ],
+            "angle": 0,
+            "content": "Ensemble Model: We ensembled the three transformer models BERT, ALBERT, and XLNet for better prediction. See Figure 4 for the ensemble model. Our ensemble model computes an average of all softmax values from these three transformer models after extracting the softmax probabilities from each model. This model relatively better than other models."
+        },
+        {
+            "type": "image",
+            "bbox": [
+                0.292,
+                0.524,
+                0.713,
+                0.62
+            ],
+            "angle": 0,
+            "content": null
+        },
+        {
+            "type": "image_caption",
+            "bbox": [
+                0.304,
+                0.628,
+                0.699,
+                0.644
+            ],
+            "angle": 0,
+            "content": "Fig. 4: Transformer based ensemble model architecture"
+        },
+        {
+            "type": "title",
+            "bbox": [
+                0.216,
+                0.716,
+                0.476,
+                0.733
+            ],
+            "angle": 0,
+            "content": "5 Results and Discussion"
+        },
+        {
+            "type": "text",
+            "bbox": [
+                0.214,
+                0.75,
+                0.788,
+                0.841
+            ],
+            "angle": 0,
+            "content": "In this section, we compared the performance of various machine learning, deep learning, and transformer-based models using several evaluation metrics like precision, recall, weighted f1-score and accuracy. The results of the various experiments on the test set are reported in Table 3. The results clearly showing that Transformer based models are considerably better than other machine and deep learning models for our COVID-19 misinformation detection task. And while"
+        }
+    ],
+    [
+        {
+            "type": "page_number",
+            "bbox": [
+                0.218,
+                0.116,
+                0.236,
+                0.127
+            ],
+            "angle": 0,
+            "content": "10"
+        },
+        {
+            "type": "header",
+            "bbox": [
+                0.272,
+                0.115,
+                0.421,
+                0.129
+            ],
+            "angle": 0,
+            "content": "Gundapu and Mamidi"
+        },
+        {
+            "type": "table",
+            "bbox": [
+                0.223,
+                0.143,
+                0.782,
+                0.317
+            ],
+            "angle": 0,
+            "content": "<table><tr><td>Model Type</td><td>Model</td><td>Precision</td><td>Recall</td><td>Accuracy</td><td>F1-Score</td></tr><tr><td rowspan=\"3\">ML \nModels</td><td>SVM</td><td>0.9640</td><td>0.9640</td><td>0.964013</td><td>0.964037</td></tr><tr><td>PAC</td><td>0.9673</td><td>0.9673</td><td>0.967285</td><td>0.967289</td></tr><tr><td>MLP</td><td>0.9645</td><td>0.9645</td><td>0.964494</td><td>0.964485</td></tr><tr><td rowspan=\"4\">Deep Learning \nModels</td><td>LSTM with FastText</td><td>0.9682</td><td>0.9682</td><td>0.9682203</td><td>0.968224</td></tr><tr><td>CNN with FastText</td><td>0.9698</td><td>0.9698</td><td>0.969802</td><td>0.969819</td></tr><tr><td>LSTM + CNN</td><td>0.9762</td><td>0.9762</td><td>0.976163</td><td>0.976168</td></tr><tr><td>BiLSTM + Attention</td><td>0.9790</td><td>0.9785</td><td>0.978524</td><td>0.978504</td></tr><tr><td rowspan=\"4\">Transformer \nModels</td><td>BERT</td><td>0.9813</td><td>0.9813</td><td>0.981306</td><td>0.981308</td></tr><tr><td>ALBERT</td><td>0.9781</td><td>0.9781</td><td>0.978031</td><td>0.978037</td></tr><tr><td>XLNet</td><td>0.9787</td><td>0.9789</td><td>0.978596</td><td>0.978592</td></tr><tr><td>Ensemble Model</td><td>0.9855</td><td>0.9855</td><td>0.985512</td><td>0.985514</td></tr></table>"
+        },
+        {
+            "type": "table_caption",
+            "bbox": [
+                0.248,
+                0.326,
+                0.754,
+                0.341
+            ],
+            "angle": 0,
+            "content": "Table 3: Comparison of various fake news detection models on testset"
+        },
+        {
+            "type": "text",
+            "bbox": [
+                0.214,
+                0.384,
+                0.784,
+                0.414
+            ],
+            "angle": 0,
+            "content": "doing experiments, we observed that few models good at retrieving prominent features while other models have the best classification performance."
+        },
+        {
+            "type": "text",
+            "bbox": [
+                0.214,
+                0.415,
+                0.785,
+                0.535
+            ],
+            "angle": 0,
+            "content": "Classical machine learning models with various TF-IDF feature vectors gave the approximate baseline model results. We observe that the TF-IDF weighted average performed better than the normal TF-IDF vectors. Bi-directional LSTM with attention mechanism f1-score approximate very close to transformer models. The BERT, XLNet, and ALBERT demonstrate better performance than deep learning models. An ensemble of the transformer-based model produces the best F1 score of 0.9855 on the test set. Our transformer based model ranked 5th among 160 teams."
+        },
+        {
+            "type": "table",
+            "bbox": [
+                0.218,
+                0.562,
+                0.787,
+                0.637
+            ],
+            "angle": 0,
+            "content": "<table><tr><td>Test Sample</td><td>BERT</td><td>ALBERT</td><td>XLNet</td><td>Ensemble</td></tr><tr><td>#BillGates is shocked that America&#x27;s pandemic response is among the worst in the world.</td><td>✓</td><td>✗</td><td>✗</td><td>✓</td></tr><tr><td>We will all come out stronger from this</td><td>✗</td><td>✗</td><td>✓</td><td>✓</td></tr><tr><td>#COVID #pandemic. Just #StaySafeStayHealthy</td><td></td><td></td><td></td><td></td></tr></table>"
+        },
+        {
+            "type": "table_caption",
+            "bbox": [
+                0.347,
+                0.646,
+                0.656,
+                0.661
+            ],
+            "angle": 0,
+            "content": "Table 4: Misclassified samples from testset"
+        },
+        {
+            "type": "text",
+            "bbox": [
+                0.214,
+                0.704,
+                0.785,
+                0.78
+            ],
+            "angle": 0,
+            "content": "In some problems, ensembling of four transformer models is very difficult, and sometimes this approach will not perform well. But if we observe the results of individual transformer models on our dataset are very close, meaning that any transformer model can be used for our fake news detection task. This is the major reason behind the ensembling of transformer models."
+        },
+        {
+            "type": "text",
+            "bbox": [
+                0.214,
+                0.78,
+                0.787,
+                0.84
+            ],
+            "angle": 0,
+            "content": "In Table 4, we showed the two misclassified test samples. The first test sample actual label is \"real\", but only BERT and ensemble models are predicted correctly, remaining two models wrongly predicted. And the second sample true label is \"fake\", but XLNet and ensemble predicted correctly, remaining two mod-"
+        }
+    ],
+    [
+        {
+            "type": "header",
+            "bbox": [
+                0.59,
+                0.115,
+                0.732,
+                0.128
+            ],
+            "angle": 0,
+            "content": "Fake News Detection"
+        },
+        {
+            "type": "page_number",
+            "bbox": [
+                0.769,
+                0.117,
+                0.784,
+                0.127
+            ],
+            "angle": 0,
+            "content": "11"
+        },
+        {
+            "type": "text",
+            "bbox": [
+                0.214,
+                0.147,
+                0.788,
+                0.193
+            ],
+            "angle": 0,
+            "content": "els wrongly predicted. However, the ensemble model is correctly predicted in both cases because we are averaging the BERT, ALBERT, and XLNet softmax probabilities. This is a principal observation to ensemble the transformer models."
+        },
+        {
+            "type": "title",
+            "bbox": [
+                0.216,
+                0.215,
+                0.36,
+                0.232
+            ],
+            "angle": 0,
+            "content": "6 Conclusion"
+        },
+        {
+            "type": "text",
+            "bbox": [
+                0.214,
+                0.247,
+                0.786,
+                0.307
+            ],
+            "angle": 0,
+            "content": "In this paper, we presented various algorithms to combat the global infodemic, but transformer-based algorithms performed better than others. And we submitted these models to the Shared Task of COVID-19 fake news detection for English, ConstraintAI-2021 workshop."
+        },
+        {
+            "type": "text",
+            "bbox": [
+                0.214,
+                0.308,
+                0.787,
+                0.399
+            ],
+            "angle": 0,
+            "content": "Fake news is a progressively significant and tricky problem to solve, particularly in an unanticipated situation like the COVID-19 epidemic. Leveraging state-of-the-art classical and advanced NLP models can help address the problem of COVID-19 fake news detection and other global health emergencies. We intend to explore other contextualized embeddings like FLAIR, ELMo, etc., for a better fake news detecting system in future works."
+        },
+        {
+            "type": "title",
+            "bbox": [
+                0.216,
+                0.421,
+                0.325,
+                0.437
+            ],
+            "angle": 0,
+            "content": "References"
+        },
+        {
+            "type": "ref_text",
+            "bbox": [
+                0.223,
+                0.452,
+                0.787,
+                0.522
+            ],
+            "angle": 0,
+            "content": "1. Patwa, P., Bhardwaj, M., Guptha, V., Kumari, G., Sharma, S., PYKL, S., Das, A., Ekbal A., Akhtar, S., Chakraborty.: Overview of CONSTRAINTN 2021 Shared Tasks: Detecting English COVID-19 Fake News and Hindi Hostile Posts. (2021). In: Proceedings of the First Workshop on Combating Online Hostile Posts in Regional Languages during Emergency Situation (CONSTRAINT). Springer."
+        },
+        {
+            "type": "ref_text",
+            "bbox": [
+                0.223,
+                0.523,
+                0.787,
+                0.563
+            ],
+            "angle": 0,
+            "content": "2. Datta, R., Yadav, K., Singh, A., Datta, K., Bansal, A.: The infodemics of COVID-19 amongst healthcare professionals in india. Med. J. Armed Forces India, vol. 76, no. 3, pp. 276-283, Jul. 2020."
+        },
+        {
+            "type": "ref_text",
+            "bbox": [
+                0.223,
+                0.564,
+                0.787,
+                0.592
+            ],
+            "angle": 0,
+            "content": "3. Chen, X., Sin, S.J.: 'Misinformation? What of it?' Motivations and individual differences in misinformation sharing on social media. In: ASIST (2013)"
+        },
+        {
+            "type": "ref_text",
+            "bbox": [
+                0.223,
+                0.593,
+                0.787,
+                0.619
+            ],
+            "angle": 0,
+            "content": "4. Thorne, J., Vlachos, A.: Automated Fact Checking: Task formulations, methods and future directions. In: COLING (2018)"
+        },
+        {
+            "type": "ref_text",
+            "bbox": [
+                0.223,
+                0.62,
+                0.787,
+                0.646
+            ],
+            "angle": 0,
+            "content": "5. Titcomb, J., Carson, J.: www.telegraph.co.uk. Fake news: What exactly is it - and how can you spot it?"
+        },
+        {
+            "type": "ref_text",
+            "bbox": [
+                0.223,
+                0.647,
+                0.787,
+                0.674
+            ],
+            "angle": 0,
+            "content": "6. Kaliyar, R., Singh, N.: Misinformation Detection on Online Social Media-A Survey. (2019). 1-6. 10.1109/ICCCNT45670.2019.8944587."
+        },
+        {
+            "type": "ref_text",
+            "bbox": [
+                0.223,
+                0.675,
+                0.787,
+                0.702
+            ],
+            "angle": 0,
+            "content": "7. Zhang, X., Ghorbani, A.: An overview of online fake news: Characterization, detection, and discussion. (2020). Inf. Process. Manag., 57, 102025."
+        },
+        {
+            "type": "ref_text",
+            "bbox": [
+                0.223,
+                0.703,
+                0.787,
+                0.73
+            ],
+            "angle": 0,
+            "content": "8. Khan, J.Y., Khondaker, M.T., Iqbal, A., Afroz, S.: A Benchmark Study on Machine Learning Methods for Fake News Detection. (2019). ArXiv, abs/1905.04749."
+        },
+        {
+            "type": "ref_text",
+            "bbox": [
+                0.223,
+                0.731,
+                0.787,
+                0.771
+            ],
+            "angle": 0,
+            "content": "9. Elhadad, M., Li, K.F., Gebali, F.: A Novel Approach for Selecting Hybrid Features from Online News Textual Metadata for Fake News Detection. In: Proc. 3PGCIC, Antwerp, Belgium, 2019, pp. 914-925."
+        },
+        {
+            "type": "ref_text",
+            "bbox": [
+                0.218,
+                0.772,
+                0.787,
+                0.798
+            ],
+            "angle": 0,
+            "content": "10. Thota, A., Tilak, P., Ahluwalia, S., Lohia, N.: Fake News Detection: A Deep Learning Approach. (2018). SMU Data Science Review: Vol. 1: No. 3, Article 10."
+        },
+        {
+            "type": "ref_text",
+            "bbox": [
+                0.218,
+                0.799,
+                0.787,
+                0.841
+            ],
+            "angle": 0,
+            "content": "11. Sean, B., Doug, S., Yuxi, P: Talos Targets Disinformation with Fake News Challenge Victory. (2017). Available online: https://blog.talosintelligence.com/2017/06/talos-fake-news-challenge.html"
+        },
+        {
+            "type": "list",
+            "bbox": [
+                0.218,
+                0.452,
+                0.787,
+                0.841
+            ],
+            "angle": 0,
+            "content": null
+        }
+    ],
+    [
+        {
+            "type": "page_number",
+            "bbox": [
+                0.218,
+                0.116,
+                0.236,
+                0.127
+            ],
+            "angle": 0,
+            "content": "12"
+        },
+        {
+            "type": "header",
+            "bbox": [
+                0.272,
+                0.115,
+                0.421,
+                0.129
+            ],
+            "angle": 0,
+            "content": "Gundapu and Mamidi"
+        },
+        {
+            "type": "ref_text",
+            "bbox": [
+                0.218,
+                0.148,
+                0.785,
+                0.189
+            ],
+            "angle": 0,
+            "content": "12. Jwa, H., Oh, D., Park, K., Kang, J., Lim, H.: exBAKE: Automatic Fake News Detection Model Based on Bidirectional Encoder Representations from Transformers (BERT). (2019). Applied Sciences, 9, 4062."
+        },
+        {
+            "type": "ref_text",
+            "bbox": [
+                0.218,
+                0.19,
+                0.785,
+                0.217
+            ],
+            "angle": 0,
+            "content": "13. Shahi, G.K., Nandini, D.: FakeCovid - A Multilingual Cross-domain Fact Check News Dataset for COVID-19. (2020). ArXiv, abs/2006.11343."
+        },
+        {
+            "type": "ref_text",
+            "bbox": [
+                0.218,
+                0.218,
+                0.785,
+                0.259
+            ],
+            "angle": 0,
+            "content": "14. Zhou, X., Mulay, A., Ferrara, E., Zafarani, R.: ReCOVery: A Multimodal Repository for COVID-19 News Credibility Research. (2020). In: Proceedings of the 29th ACM International Conference on Information & Knowledge Management."
+        },
+        {
+            "type": "ref_text",
+            "bbox": [
+                0.218,
+                0.26,
+                0.785,
+                0.285
+            ],
+            "angle": 0,
+            "content": "15. Cui, L., Lee, D.: CoAID: COVID-19 Healthcare Misinformation Dataset. (2020). ArXiv, abs/2006.00885."
+        },
+        {
+            "type": "ref_text",
+            "bbox": [
+                0.217,
+                0.287,
+                0.785,
+                0.314
+            ],
+            "angle": 0,
+            "content": "16. Memon, S.A., Carley, K.M.: Characterizing COVID-19 Misinformation Communities Using a Novel Twitter Dataset. (2020). ArXiv, abs/2008.00791."
+        },
+        {
+            "type": "ref_text",
+            "bbox": [
+                0.217,
+                0.315,
+                0.785,
+                0.354
+            ],
+            "angle": 0,
+            "content": "17. Li, Y., Jiang, B., Shu, K., Liu, H.: MM-COVID: A Multilingual and Multi-modal Data Repository for Combating COVID-19 Disinformation. (2020). ArXiv, abs/2011.04088."
+        },
+        {
+            "type": "ref_text",
+            "bbox": [
+                0.217,
+                0.355,
+                0.785,
+                0.383
+            ],
+            "angle": 0,
+            "content": "18. Al-Rakhami, M.S., Al-Amri, A.M.: Lies Kill, Facts Save: Detecting COVID-19 Misinformation in Twitter. (2020). IEEE Access, 8, 155961-155970."
+        },
+        {
+            "type": "ref_text",
+            "bbox": [
+                0.217,
+                0.384,
+                0.785,
+                0.411
+            ],
+            "angle": 0,
+            "content": "19. Vijjali, R., Potluri, P., Kumar, S., Teki, S.: Two Stage Transformer Model for COVID-19 Fake News Detection and Fact Checking. (2020)."
+        },
+        {
+            "type": "ref_text",
+            "bbox": [
+                0.217,
+                0.412,
+                0.785,
+                0.451
+            ],
+            "angle": 0,
+            "content": "20. Hossain, T., RobertL.Logan, I., Ugarte, A., Matsubara, Y., Young, S.,Singh, S.: COVIDLies: Detecting COVID-19 Misinformation on Social Media. (2020). NLP4COVID@EMNLP."
+        },
+        {
+            "type": "ref_text",
+            "bbox": [
+                0.217,
+                0.453,
+                0.785,
+                0.493
+            ],
+            "angle": 0,
+            "content": "21. Patwa, P., Sharma, S., Pykl, S., Guptha, V., Kumari, G., Akhtar, M.S., Ekbal, A., Das, A., Chakraborty, T. (2020). Fighting an Infodemic: COVID-19 Fake News Dataset. ArXiv, abs/2011.03327."
+        },
+        {
+            "type": "ref_text",
+            "bbox": [
+                0.217,
+                0.494,
+                0.785,
+                0.522
+            ],
+            "angle": 0,
+            "content": "22. Elhadad, M.K., Li, K., Gebali, F.: Detecting Misleading Information on COVID-19. (2020). IEEE Access, 8, 165201-165215."
+        },
+        {
+            "type": "ref_text",
+            "bbox": [
+                0.217,
+                0.522,
+                0.785,
+                0.549
+            ],
+            "angle": 0,
+            "content": "23. Pennington, J., Socher, R., Manning, C.D.: Glove: Global Vectors for Word Representation. (2014). In: EMNLP."
+        },
+        {
+            "type": "ref_text",
+            "bbox": [
+                0.217,
+                0.55,
+                0.785,
+                0.577
+            ],
+            "angle": 0,
+            "content": "24. Hochreiter, S., Schmidhuber, J.: Long Short-Term Memory. (1997). Neural Computation, 9, 1735-1780."
+        },
+        {
+            "type": "ref_text",
+            "bbox": [
+                0.217,
+                0.578,
+                0.785,
+                0.618
+            ],
+            "angle": 0,
+            "content": "25. Bojanowski, P., Grave, E., Joulin, A., Mikolov, T.: Enriching Word Vectors with Subword Information. (2017). Transactions of the Association for Computational Linguistics, 5, 135-146."
+        },
+        {
+            "type": "ref_text",
+            "bbox": [
+                0.217,
+                0.619,
+                0.785,
+                0.646
+            ],
+            "angle": 0,
+            "content": "26. Vaswani, A., Shazeer, N., Parmar, N., Uszkoreit, J., Jones, L., Gomez, A.N., Kaiser, L., Polosukhin, I.: Attention is All you Need. (2017). NIPS."
+        },
+        {
+            "type": "ref_text",
+            "bbox": [
+                0.217,
+                0.647,
+                0.785,
+                0.673
+            ],
+            "angle": 0,
+            "content": "27. LeCun, Y., Bengio, Y., Hinton, G.: Deep learning. (2015). Nature, 521(7553), pp.436-444."
+        },
+        {
+            "type": "ref_text",
+            "bbox": [
+                0.217,
+                0.674,
+                0.785,
+                0.702
+            ],
+            "angle": 0,
+            "content": "28. Devlin, J., Chang, M., Lee, K., Toutanova, K.: BERT: Pre-training of Deep Bidirectional Transformers for Language Understanding. (2019). NAACL-HLT."
+        },
+        {
+            "type": "ref_text",
+            "bbox": [
+                0.217,
+                0.702,
+                0.785,
+                0.741
+            ],
+            "angle": 0,
+            "content": "29. Yang, Z., Dai, Z., Yang, Y., Carbonell, J., Salakhutdinov, R., Le, Q.V.: XL-Net: Generalized Autoregressive Pretraining for Language Understanding. (2019). NeurIPS."
+        },
+        {
+            "type": "ref_text",
+            "bbox": [
+                0.217,
+                0.742,
+                0.785,
+                0.784
+            ],
+            "angle": 0,
+            "content": "30. Dai, Z., Yang, Z., Yang, Y., Carbonell, J., Le, Q.V., Salakhutdinov, R.: Transformer-XL: Attentive Language Models Beyond a Fixed-Length Context. (2019). ACL."
+        },
+        {
+            "type": "ref_text",
+            "bbox": [
+                0.217,
+                0.785,
+                0.785,
+                0.827
+            ],
+            "angle": 0,
+            "content": "31. Lan, Z., Chen, M., Goodman, S., Gimpel, K., Sharma, P., Soricut, R.: ALBERT: A Lite BERT for Self-supervised Learning of Language Representations. (2020). ArXiv, abs/1909.11942."
+        },
+        {
+            "type": "list",
+            "bbox": [
+                0.217,
+                0.148,
+                0.785,
+                0.827
+            ],
+            "angle": 0,
+            "content": null
+        }
+    ]
+]

data/2021/2101_00xxx/2101.00180/full.md

@@ -1,3 +1,208 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:a39ee9da4ac341e8dda593ffef2195a8da3b9e0baf2b4d9a54d16e6ce1dc39a6
-size 29752
+# Transformer based Automatic COVID-19 Fake News Detection System
+
+Sunil Gundapu and Radhika Mamidi
+
+International Institute of Information Technology, Hyderabad sunil.g@research.iit.ac.in, radhika.mamidi@iit.ac.in
+
+Abstract. Recent rapid technological advancements in online social networks such as Twitter have led to a great incline in spreading false information and fake news. Misinformation is especially prevalent in the ongoing coronavirus disease (COVID-19) pandemic, leading to individuals accepting bogus and potentially deleterious claims and articles. Quick detection of fake news can reduce the spread of panic and confusion among the public. For our analysis in this paper, we report a methodology to analyze the reliability of information shared on social media pertaining to the COVID-19 pandemic. Our best approach is based on an ensemble of three transformer models (BERT, ALBERT, and XLNET) to detecting fake news. This model was trained and evaluated in the context of the ConstraintAI 2021 shared task "COVID19 Fake News Detection in English" [1]. Our system obtained 0.9855 f1-score on testset and ranked 5th among 160 teams.
+
+Keywords: pandemic-19, fake news, deep learning, transformer models
+
+# 1 Introduction
+
+The COVID-19 pandemic is considered the global public health crisis of the whole world and the biggest problem people faced after World War II. COVID-19, a contagious disease caused by a coronavirus, has caused more than 75 million confirmed cases and 1.7 million deaths across the world till 2020 December<sup>1</sup>. Unfortunately, the misinformation about COVID-19 has encouraged the growing of the disease and chaos among people. During the Munich Security Council held on February 15, 2020, World Health Organization (WHO) Director-General, Tedros Adhanom Ghebreyesus [2] stated that the world was in a war to fight not only a pandemic, but also an infodemic. So we should address the challenge of fake news detection to stop the spreading of COVID-19 misinformation.
+
+Since the global pandemic impacts the people, there is a broader public finding information about the COVID-19, whose safety is intimidated by adversarial agents invested in spreading fake news for economic and political reasons. Besides, due to medical and public health issues, it is also hard to be totally valid and factual, leading to differences that worsen with fake news. This difficulty
+
+is compounded by the quick advancement of knowledge about the disease. As researchers gain more knowledge about the virus, claims that looked right may turn out to be false, and vice versa. Detecting this spread of COVID-19 associated fake news, thus, has become a pivotal problem, gaining notable attention from government and global health organizations (WHO, 2020), online social networks (TechCrunch, 2020), and news organizations (BBC, 2020; CNN, 2020; New York Times, 2020).
+
+In response to the present disinformation, this paper looks at developing an efficient fake news detection architecture with respect to COVID-19. Initially, we started with developing machine learning (ML) algorithms with Term Frequency and Inverse Document Frequency (TF-IDF) feature vectors to detect misinformation on the provided dataset. These supervised TF-IDF methods are still relevant for many classification tasks and performed pretty well for fake news detection. We developed an effective ensemble model integrated with three transformer models for detecting fake news on the social media platforms. This resulted in higher accuracy and a more generalized model.
+
+The rest of this paper is organized as follows, Section II presents some prior works related to fake news, and its spread, on social media platforms. In Section III, we describe the dataset provided in the Constraint AI-2021 shared task. Section IV presents implemented models and framework for misinformation detection. Section V provides the discussions on the results. Finally we conclude this paper in Section VI.
+
+# 2 Related Work
+
+Fake News Detection: Fake news can be defined as inaccurate and misleading information that is growing knowingly or unknowingly [3]. Recognizing the spread of false information such as rumors, fake news, propaganda, hoaxes, spear phishing, and conspiracy theories is an essential task for natural language processing [4]. Gartner's [5] research studies explained that most people in advanced economies would believe more fake information than truthful information by 2022.
+
+To date, so many automated misinformation detection architectures have been developed. Rohit et al. [6] provided an extensive survey to detect fake news on various online social networks. Ghorbani et al. [7] presented an inclusive overview of the recent studies related to misinformation. Furthermore, they described the impact of misleading information, shown state-of-the-art fake news detection systems, and explored the disinformation detection datasets. The majority of the fake news detection models developed using supervised machine learning algorithms to classify the data as misleading or not [8]. This supervised classification is concluded by comparing the user input text with some already created corpora containing genuine and misleading information [9].
+
+Aswini et al. [10] proposed a deep learning architecture with various word embeddings for Fake News Challenge (FCN-1) dataset<sup>2</sup>. They developed the
+
+architecture to accurately predict the stance between a given pair of news headlines and the corresponding article/body. On the same FCN-1 dataset, Sean et al. [11] developed an average weighted model of TalosCNN and TalosTree called TalosComb. TalosCNN is a convolutional neural network with pre-trained word2vec embeddings, and TalosTree is a gradient-boosted decision tree model with SVD, word count, TF-IDF. By analyzing the relationship between the news headline and the corresponding article, Heejung et al. [12] designed the Bidirectional Encoder Representations from Transformers model (BERT) to detect misleading news articles.
+
+COVID-19: In the case of COVID-19 fake news, a large number of misleading contents remain online on social media platforms. NLP researchers have been working on developing algorithms for the detection of online COVID-19 related disinformation. To develop any algorithm, we require a corpus. So members of the NLP community created the various fake news datasets: FakeCovid [13], ReCOVery [14], CoAID [15], and CMU-MisCOVID19 [16]. Yichuan Li et al. [17] developed multi-dimensional and multilingual MM-COVID corpora, which covers six languages. Mabrook et al. [18] created a large Twitter dataset related to COVID-19 misinformation. And authors developed an ensemble-stacking model with six machine learning algorithms on the created dataset for detecting misinformation.
+
+Elhadad et al. [22] constructed a voting ensemble machine learning classifier for fake news detection that uses seven feature extraction techniques and ten machine learning models. Tamanna et al. [20] used the COVIDLIES dataset to detect the misinformation by retrieving the misconceptions relevant to the Twitter posts. For COVID-19 fake news detection and fact-checking, Rutvik et al. [19] proposed a two-stage transformer model. The first model retrieves the most relevant facts about COVID-19 by using a novel fact-checking algorithm, and the second model, by computing the textual entailment, verifies the level of truth. Adapting all these classical and hybrid related work techniques, we developed a COVID-19 fake news detection system in this paper.
+
+# 3 Dataset Description
+
+The ConstraintAI $^{21}$  shared task organizers developed a COVID-19 fake news detection in English dataset [21] containing 10,700 data points collected from various online social networks such as Twitter, Facebook, and Instagram, etc. From the total dataset, 6,420 data points are reserved for training, 2,140 data points are used for hyperparameter tuning as a part of the validation phase, and the remaining 2,140 social media posts are kept aside for testing. Each dataset except the test set contains social media data points and their corresponding labels, either real or fake.
+
+<table><tr><td>Corpus</td><td>Real</td><td>Fake</td></tr><tr><td>Train</td><td>3360</td><td>3060</td></tr><tr><td>Valid</td><td>1120</td><td>1020</td></tr><tr><td>Test</td><td>1120</td><td>1020</td></tr></table>
+
+(a) Dataset Statistics
+
+<table><tr><td>Tweet</td><td>Label</td></tr><tr><td>CDC Recommends Mothers Stop Breastfeeding To Boost Vaccine Efficacy</td><td>fake</td></tr><tr><td>1000 COVID-19 testing labs in India: ICMR</td><td>real</td></tr></table>
+
+(b) Label-wise example
+
+Table 1: Fake news dataset information
+
+Table 1 shows the corpus size and label distribution, and if we observe, the labels in each dataset are all roughly balanced. Table 2 shows some examples from the COVID-19 fake news detection in the English dataset. We illustrate the most occurring word cloud of the real and fake data points after removing the stop words in Figures 1(a) and 1(b). In Figure 1(a), we can see unique words in real-labeled data points which don't often occur in Figure 1(b), like "covid19", "discharged", "confirmed", "testing", "indiafightscorona", and "indiawin", etc.; meanwhile, from Figure 1(b), we can find unique words frequently appearing in the fake articles, which include "coronavirus", "kill", "muslim", "hydroxychloroquine", "china", and "facebook post", but don't frequently appear in the true labeled data points. These frequent textual words can give important information to differentiate the true data points from fake ones.
+
+![](images/01516eae682541f1dd926f119670d79630e91f6f628a0c94fdf65efed67d8b56.jpg)  
+(a) Positive word cloud  
+Fig. 1: Illustration of frequent word cloud
+
+![](images/c0bfcd572b50f918e8eabcc524622c681b327ab0b9e12b585d010c67652bb061.jpg)  
+(b) Negative word cloud
+
+# 4 Methodology
+
+In this part, we present our transformer based ensemble model that is trained and tuned on the datasets which reported in the previous section. We compare our
+
+approach with various machine learning (ML) and deep learning (DL) models with different word embeddings. The full code of system architecture can be found at GitHub<sup>4</sup>.
+
+# 4.1 Data Preprocessing
+
+The main aim of this part is to use the NLP techniques to preprocess the input tweet data and prepare for the next step to extract the proper features. In Figure 2, we shown the detailed data preprocessing pipeline with examples.
+
+![](images/a50faaa9d5f22c20dfe2069231fc60024eaa05967fe01f234c5447c8f1d7e286.jpg)  
+Fig. 2: Data preprocessing pipeline
+
+In the preprocessing step, we will forward the tokenized tweet through the pipeline to eliminate the noise in the fake news dataset by remove or normalize the unnecessary tokens. The preprocessing pipeline includes the following subparts:
+
+1. Emoticon Conversion: In this step, we converted the each emoticon in the tweet to text. Example:  $\rightarrow$  Face with medical mask emoji  
+2. Handling of Hashtags: We identified the hashtag tokens by seeing pound (#) sign and splitted these based on digits or capital letters. Example: #IndiaFightsCorona → IndiaFightsCorona  
+3. Stemming: We removed the inflectional morphemes like "ed", "est", "s", and "ing" from their token stem. Ex: confirmed  $\rightarrow$  "confirm" + "-ed"  
+4. Text cleaning: To remove the irrelevant data we used this step. Removed punctuation marks, digits and, non-ASCII glyphs from the tweet.
+
+# 4.2 Supervised Machine Learning Models
+
+To build the finest system for fake news detection, we started our investigations with traditional NLP approaches like Linear Regression (LR), Support Vector MAchines (SVM), Passive Agressive Classifier (PAC), XGBoost, and Multi-Layer Perceptron (MLP). We study the results of above mentioned supervised models with the combination of three types of word vectors:
+
+1. Word-level, n-gram level, and character level TF-IDF vectors with the feature matrix size of 100000.  
+2. English Glove [23] word embeddings with the dimension of 300.  
+3. TF-IDF weighted averaging with Glove embeddings. We described below the fake news vector construction.
+
+$$
+T w e e t _ {v e c t o r} = \frac {\sum_ {i = 1} ^ {N} \mathbf {t f - i d f} (t o k e n _ {i}) \times \mathbf {G l o v e} (t o k e n _ {i})}{\mathbf {N}} \tag {1}
+$$
+
+In the above formula,  $\mathrm{N}$  is the total number of words in the input fake news tweet, and  $\text{token}_i$  is the  $i^{th}$  token in the input text. After analyzing the results, TF-IDF weighted averaging gave better results than the standard TF-IDF.
+
+# 4.3 Deep Learning Models
+
+Supervised machine learning algorithms performed very well on the provided dataset. In this section, we experiment with deep learning models that give better results than traditional classification algorithms.
+
+LSTM: We used Long Short-Term Memory (LSTM) [24] architecture with two different pre-trained word embeddings Glove and Fasttext [25]. LSTM is a type of Recurrent Neural Network (RNN) that can solve long term dependency problem, and it is a well-suited model for sequence classification.
+
+We converted the input data points into word vectors by using pre-trained word embeddings. These word vectors are passed as input to the LSTM layer. We stacked up two LSTM layers one after another with the dropout of 0.25. The size of LSTM is 128, and the last time step output is treated as input data point representation. The final time step's outcome is passed as an input to a dense layer for fake news detection.
+
+BiLSTM with Attention: Sometimes not all the tokens in the input text contribute equally to the representation of input text. So we advantage word attention [26] mechanism to catch the tokens' prominent influence on the input data point. We built this attention mechanism on top of BiLSTM layers.
+
+The sequence of word vector is passed through a BiLSTM layer, which contains one forward and backward LSTM layer. Attention mechanism applied to the output of BiLSTM layer, which produces a dense vector. This dense vector is forwarded to a fully connected network.
+
+CNN: We explored a Convolution Neural Network (CNN) [27] model for misinformation detection. The model consists of an embedding layer, a convolution layer with 3 convolutions, a max-pooling layer, and a fully connected network. In the embedding layer, the input texts are converted into  $n \times d$  sequence matrix,
+
+where  $n$  is the length of the input data point and  $d$  is the length of the word embedding dimension. In the convolution layer, fed the sequence matrix through three 1D convolutions of kernel sizes 3, 4, and 5. And each convolutions filter size is 128. The convolution layer's output is max pooled over time and concatenated to get the input datapoint representations in the max-pooling layer. The output of the max-pooling layer is passed to a fully connected network with a softmax output layer.
+
+CNN + BiLSTM: A CNN and BiLSTM architecture is an ensemble of CNN and bidirectional LSTM models with Fasttext/Glove word embeddings. In this architecture, the CNN extracts the maximum amount of features/information from the input text using convolution layers. The output of CNN becomes the input to BiLSTM, which keeps the data in chronological order in both directions.
+
+The sequence of word vectors are forwarded through a convolution of kernel size 3 with filter size 128. The output of convolution is passed through a BiLSTM. The outcome of BiLSTM is max-pooled over time and followed by one dense layer and a softmax layer.
+
+# 4.4 Transformer Models
+
+This section explored individual and ensembling of the three transformer models BERT, ALBERT, and XLNet. These models have outperformed the other ML and DL algorithms. We implemented these models using HuggingFace<sup>5</sup> is a PyTorch transformer library. And the hyperparameters of the three models are described in Table 1.
+
+<table><tr><td>Model</td><td>Learning Rate</td><td>Batch Size</td><td>Optimizer</td><td>Max Length</td><td>Type</td></tr><tr><td>BERT</td><td>2e-5</td><td>16</td><td>Adam</td><td>128</td><td>BERT-Base</td></tr><tr><td>XLNet</td><td>2e-5</td><td>16</td><td>Adam</td><td>128</td><td>XLNetLarge</td></tr><tr><td>ALBERT</td><td>2e-5</td><td>32</td><td>Adam</td><td>128</td><td>ALBERT-Xlarge</td></tr></table>
+
+Table 2: Hyperparameters of transformer models
+
+BERT: Bidirectional Encoder Representations from Transformers (henceforth, BERT) [28] is a transformer model developed to pre-train deep bidirectional representations from unseen data. This model developed by combining two robust concepts: (i) It's a deep transformer model so that it can process lengthy sentences effectively by using attention mechanism, and (ii) It's a bidirectional
+
+network, so it takes into account the entire text passage to comprehend the meaning of each token.
+
+BERT implementation has two steps; one is pre-training and another fin-tuning. In the first step, the model is trained on unseen data over various pretraining problems using a dataset in a particular language or in increases data with multiple languages. In the second step, all the initialized parameters are fine-tuned using the labeled data from certain tasks.
+
+We fine-tuned the pre-trained BERT (Base) model for our COVID-19 fake news detection task. BERT base model contains the 12 layers of encoder blocks and 12 bidirectional self-attention heads by considering the sequence of 512 tokens and emitting the representations of a sequence of hidden vectors. We added one additional output layer on top of the BERT model to calculate the conditional probability over the output classes, either fake or real. See FIGURE 1 for the fine-tuned model of BERT.
+
+![](images/ca4c033b834382e3fb655dfaa0fa2ec7eea1fac153c069fa2712b7b0bf666452.jpg)  
+Fig. 3: BERT model architecture
+
+XLNet: XLNet is an enhanced version of BERT. To understand the language context deeper, XLNet [29] uses Transformer-XL [30] as a feature engineering model, which alone is an adoption upon the native Transformer. This Transformer XL model integrates the two components Recurrence Mechanism and Relative Positional Encoding (RPE) to the Transformer used in BERT to handle the long-term dependencies for texts that are longer than the maximum allowed input length. Recurrence Mechanism will give context between two sequences at specific segments and RPE, which carries similarity information between two tokens.
+
+The XLNet model has been trained on a huge dataset using the permutation language modeling. This technique is one of the main differences between BERT and XLNet, and it uses permutations to generate data from the forward and backward directions at the same time. We used the pre-trained XLNet model from Hugging Face, then fine-tuned the model with a maximum length of 128 to update the pre-trained model to fit our fake news detection dataset.
+
+ALBERT: Modern language models increasing the model size and quantity of parameters when pre-training natural language representations. They often give better improvements in many downstream tasks, but in some cases, they become harder due to memory limitation and longer hours of training. To address these problems, a self-supervised learning model ALBERT (A Lite BERT) [31] often uses parameter reduction techniques to increase model speed and lower memory consumption. We used the A Lite BERT model for our misinformation detection problem, which achieves better performance than DL models.
+
+Ensemble Model: We ensembled the three transformer models BERT, ALBERT, and XLNet for better prediction. See Figure 4 for the ensemble model. Our ensemble model computes an average of all softmax values from these three transformer models after extracting the softmax probabilities from each model. This model relatively better than other models.
+
+![](images/a5ebbcdea098609620199e340bcda76ac9b613ac1d09ee9750d7b58429ff70a4.jpg)  
+Fig. 4: Transformer based ensemble model architecture
+
+# 5 Results and Discussion
+
+In this section, we compared the performance of various machine learning, deep learning, and transformer-based models using several evaluation metrics like precision, recall, weighted f1-score and accuracy. The results of the various experiments on the test set are reported in Table 3. The results clearly showing that Transformer based models are considerably better than other machine and deep learning models for our COVID-19 misinformation detection task. And while
+
+<table><tr><td>Model Type</td><td>Model</td><td>Precision</td><td>Recall</td><td>Accuracy</td><td>F1-Score</td></tr><tr><td rowspan="3">ML 
+Models</td><td>SVM</td><td>0.9640</td><td>0.9640</td><td>0.964013</td><td>0.964037</td></tr><tr><td>PAC</td><td>0.9673</td><td>0.9673</td><td>0.967285</td><td>0.967289</td></tr><tr><td>MLP</td><td>0.9645</td><td>0.9645</td><td>0.964494</td><td>0.964485</td></tr><tr><td rowspan="4">Deep Learning 
+Models</td><td>LSTM with FastText</td><td>0.9682</td><td>0.9682</td><td>0.9682203</td><td>0.968224</td></tr><tr><td>CNN with FastText</td><td>0.9698</td><td>0.9698</td><td>0.969802</td><td>0.969819</td></tr><tr><td>LSTM + CNN</td><td>0.9762</td><td>0.9762</td><td>0.976163</td><td>0.976168</td></tr><tr><td>BiLSTM + Attention</td><td>0.9790</td><td>0.9785</td><td>0.978524</td><td>0.978504</td></tr><tr><td rowspan="4">Transformer 
+Models</td><td>BERT</td><td>0.9813</td><td>0.9813</td><td>0.981306</td><td>0.981308</td></tr><tr><td>ALBERT</td><td>0.9781</td><td>0.9781</td><td>0.978031</td><td>0.978037</td></tr><tr><td>XLNet</td><td>0.9787</td><td>0.9789</td><td>0.978596</td><td>0.978592</td></tr><tr><td>Ensemble Model</td><td>0.9855</td><td>0.9855</td><td>0.985512</td><td>0.985514</td></tr></table>
+
+doing experiments, we observed that few models good at retrieving prominent features while other models have the best classification performance.
+
+Classical machine learning models with various TF-IDF feature vectors gave the approximate baseline model results. We observe that the TF-IDF weighted average performed better than the normal TF-IDF vectors. Bi-directional LSTM with attention mechanism f1-score approximate very close to transformer models. The BERT, XLNet, and ALBERT demonstrate better performance than deep learning models. An ensemble of the transformer-based model produces the best F1 score of 0.9855 on the test set. Our transformer based model ranked 5th among 160 teams.
+
+Table 3: Comparison of various fake news detection models on testset  
+
+<table><tr><td>Test Sample</td><td>BERT</td><td>ALBERT</td><td>XLNet</td><td>Ensemble</td></tr><tr><td>#BillGates is shocked that America&#x27;s pandemic response is among the worst in the world.</td><td>✓</td><td>✗</td><td>✗</td><td>✓</td></tr><tr><td>We will all come out stronger from this</td><td>✗</td><td>✗</td><td>✓</td><td>✓</td></tr><tr><td>#COVID #pandemic. Just #StaySafeStayHealthy</td><td></td><td></td><td></td><td></td></tr></table>
+
+Table 4: Misclassified samples from testset
+
+In some problems, ensembling of four transformer models is very difficult, and sometimes this approach will not perform well. But if we observe the results of individual transformer models on our dataset are very close, meaning that any transformer model can be used for our fake news detection task. This is the major reason behind the ensembling of transformer models.
+
+In Table 4, we showed the two misclassified test samples. The first test sample actual label is "real", but only BERT and ensemble models are predicted correctly, remaining two models wrongly predicted. And the second sample true label is "fake", but XLNet and ensemble predicted correctly, remaining two mod-
+
+els wrongly predicted. However, the ensemble model is correctly predicted in both cases because we are averaging the BERT, ALBERT, and XLNet softmax probabilities. This is a principal observation to ensemble the transformer models.
+
+# 6 Conclusion
+
+In this paper, we presented various algorithms to combat the global infodemic, but transformer-based algorithms performed better than others. And we submitted these models to the Shared Task of COVID-19 fake news detection for English, ConstraintAI-2021 workshop.
+
+Fake news is a progressively significant and tricky problem to solve, particularly in an unanticipated situation like the COVID-19 epidemic. Leveraging state-of-the-art classical and advanced NLP models can help address the problem of COVID-19 fake news detection and other global health emergencies. We intend to explore other contextualized embeddings like FLAIR, ELMo, etc., for a better fake news detecting system in future works.
+
+# References
+
+1. Patwa, P., Bhardwaj, M., Guptha, V., Kumari, G., Sharma, S., PYKL, S., Das, A., Ekbal A., Akhtar, S., Chakraborty.: Overview of CONSTRAINTN 2021 Shared Tasks: Detecting English COVID-19 Fake News and Hindi Hostile Posts. (2021). In: Proceedings of the First Workshop on Combating Online Hostile Posts in Regional Languages during Emergency Situation (CONSTRAINT). Springer.  
+2. Datta, R., Yadav, K., Singh, A., Datta, K., Bansal, A.: The infodemics of COVID-19 amongst healthcare professionals in india. Med. J. Armed Forces India, vol. 76, no. 3, pp. 276-283, Jul. 2020.  
+3. Chen, X., Sin, S.J.: 'Misinformation? What of it?' Motivations and individual differences in misinformation sharing on social media. In: ASIST (2013)  
+4. Thorne, J., Vlachos, A.: Automated Fact Checking: Task formulations, methods and future directions. In: COLING (2018)  
+5. Titcomb, J., Carson, J.: www.telegraph.co.uk. Fake news: What exactly is it - and how can you spot it?  
+6. Kaliyar, R., Singh, N.: Misinformation Detection on Online Social Media-A Survey. (2019). 1-6. 10.1109/ICCCNT45670.2019.8944587.  
+7. Zhang, X., Ghorbani, A.: An overview of online fake news: Characterization, detection, and discussion. (2020). Inf. Process. Manag., 57, 102025.  
+8. Khan, J.Y., Khondaker, M.T., Iqbal, A., Afroz, S.: A Benchmark Study on Machine Learning Methods for Fake News Detection. (2019). ArXiv, abs/1905.04749.  
+9. Elhadad, M., Li, K.F., Gebali, F.: A Novel Approach for Selecting Hybrid Features from Online News Textual Metadata for Fake News Detection. In: Proc. 3PGCIC, Antwerp, Belgium, 2019, pp. 914-925.  
+10. Thota, A., Tilak, P., Ahluwalia, S., Lohia, N.: Fake News Detection: A Deep Learning Approach. (2018). SMU Data Science Review: Vol. 1: No. 3, Article 10.  
+11. Sean, B., Doug, S., Yuxi, P: Talos Targets Disinformation with Fake News Challenge Victory. (2017). Available online: https://blog.talosintelligence.com/2017/06/talos-fake-news-challenge.html
+
+12. Jwa, H., Oh, D., Park, K., Kang, J., Lim, H.: exBAKE: Automatic Fake News Detection Model Based on Bidirectional Encoder Representations from Transformers (BERT). (2019). Applied Sciences, 9, 4062.  
+13. Shahi, G.K., Nandini, D.: FakeCovid - A Multilingual Cross-domain Fact Check News Dataset for COVID-19. (2020). ArXiv, abs/2006.11343.  
+14. Zhou, X., Mulay, A., Ferrara, E., Zafarani, R.: ReCOVery: A Multimodal Repository for COVID-19 News Credibility Research. (2020). In: Proceedings of the 29th ACM International Conference on Information & Knowledge Management.  
+15. Cui, L., Lee, D.: CoAID: COVID-19 Healthcare Misinformation Dataset. (2020). ArXiv, abs/2006.00885.  
+16. Memon, S.A., Carley, K.M.: Characterizing COVID-19 Misinformation Communities Using a Novel Twitter Dataset. (2020). ArXiv, abs/2008.00791.  
+17. Li, Y., Jiang, B., Shu, K., Liu, H.: MM-COVID: A Multilingual and Multi-modal Data Repository for Combating COVID-19 Disinformation. (2020). ArXiv, abs/2011.04088.  
+18. Al-Rakhami, M.S., Al-Amri, A.M.: Lies Kill, Facts Save: Detecting COVID-19 Misinformation in Twitter. (2020). IEEE Access, 8, 155961-155970.  
+19. Vijjali, R., Potluri, P., Kumar, S., Teki, S.: Two Stage Transformer Model for COVID-19 Fake News Detection and Fact Checking. (2020).  
+20. Hossain, T., RobertL.Logan, I., Ugarte, A., Matsubara, Y., Young, S.,Singh, S.: COVIDLies: Detecting COVID-19 Misinformation on Social Media. (2020). NLP4COVID@EMNLP.  
+21. Patwa, P., Sharma, S., Pykl, S., Guptha, V., Kumari, G., Akhtar, M.S., Ekbal, A., Das, A., Chakraborty, T. (2020). Fighting an Infodemic: COVID-19 Fake News Dataset. ArXiv, abs/2011.03327.  
+22. Elhadad, M.K., Li, K., Gebali, F.: Detecting Misleading Information on COVID-19. (2020). IEEE Access, 8, 165201-165215.  
+23. Pennington, J., Socher, R., Manning, C.D.: Glove: Global Vectors for Word Representation. (2014). In: EMNLP.  
+24. Hochreiter, S., Schmidhuber, J.: Long Short-Term Memory. (1997). Neural Computation, 9, 1735-1780.  
+25. Bojanowski, P., Grave, E., Joulin, A., Mikolov, T.: Enriching Word Vectors with Subword Information. (2017). Transactions of the Association for Computational Linguistics, 5, 135-146.  
+26. Vaswani, A., Shazeer, N., Parmar, N., Uszkoreit, J., Jones, L., Gomez, A.N., Kaiser, L., Polosukhin, I.: Attention is All you Need. (2017). NIPS.  
+27. LeCun, Y., Bengio, Y., Hinton, G.: Deep learning. (2015). Nature, 521(7553), pp.436-444.  
+28. Devlin, J., Chang, M., Lee, K., Toutanova, K.: BERT: Pre-training of Deep Bidirectional Transformers for Language Understanding. (2019). NAACL-HLT.  
+29. Yang, Z., Dai, Z., Yang, Y., Carbonell, J., Salakhutdinov, R., Le, Q.V.: XL-Net: Generalized Autoregressive Pretraining for Language Understanding. (2019). NeurIPS.  
+30. Dai, Z., Yang, Z., Yang, Y., Carbonell, J., Le, Q.V., Salakhutdinov, R.: Transformer-XL: Attentive Language Models Beyond a Fixed-Length Context. (2019). ACL.  
+31. Lan, Z., Chen, M., Goodman, S., Gimpel, K., Sharma, P., Soricut, R.: ALBERT: A Lite BERT for Self-supervised Learning of Language Representations. (2020). ArXiv, abs/1909.11942.

data/2021/2101_00xxx/2101.00190/full.md

@@ -1,3 +1,385 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:79f5cc715cdd99ee7b5bee05bbdbba4600189dd2e79a2598fa553373dea71dac
-size 63023
+# Prefix-Tuning: Optimizing Continuous Prompts for Generation
+
+Xiang Lisa Li
+Stanford University
+xlisali@stanford.edu
+
+Percy Liang  
+Stanford University  
+pliang@cs.stanford.edu
+
+# Abstract
+
+Fine-tuning is the de facto way to leverage large pretrained language models to perform downstream tasks. However, it modifies all the language model parameters and therefore necessitates storing a full copy for each task. In this paper, we propose prefix-tuning, a lightweight alternative to fine-tuning for natural language generation tasks, which keeps language model parameters frozen, but optimizes a small continuous task-specific vector (called the prefix). Prefix-tuning draws inspiration from prompting, allowing subsequent tokens to attend to this prefix as if it were "virtual tokens". We apply prefix-tuning to GPT-2 for table-to-text generation and to BART for summarization. We find that by learning only  $0.1\%$  of the parameters, prefix-tuning obtains comparable performance in the full data setting, outperforms fine-tuning in low-data settings, and extrapolates better to examples with topics unseen during training.
+
+# 1 Introduction
+
+Fine-tuning is the prevalent paradigm for using large pretrained language models (LMs) (Radford et al., 2019; Devlin et al., 2019) to perform downstream tasks (e.g., summarization), but it requires updating and storing all the parameters of the LM. Consequently, to build and deploy NLP systems that rely on large pretrained LMs, one currently needs to store a modified copy of the LM parameters for each task. This can be prohibitively expensive, given the large size of current LMs; for example, GPT-2 has 774M parameters (Radford et al., 2019) and GPT-3 has 175B parameters (Brown et al., 2020).
+
+A natural approach to this problem is lightweight fine-tuning, which freezes most of the pretrained parameters and augments the model with small trainable modules. For example, adapter-tuning
+
+![](images/03f3d3e6ca6a83140271aab52bf95b00a23634dc17343020927de65ed65f008c.jpg)  
+Figure 1: Fine-tuning (top) updates all Transformer parameters (the red Transformer box) and requires storing a full model copy for each task. We propose prefix-tuning (bottom), which freezes the Transformer parameters and only optimizes the prefix (the red prefix blocks). Consequently, we only need to store the prefix for each task, making prefix-tuning modular and space-efficient. Note that each vertical block denote transformer activations at one time step.
+
+(Rebuffi et al., 2017; Houlsby et al., 2019) inserts additional task-specific layers between the layers of pretrained language models. Adapter-tuning has promising performance on natural language understanding and generation benchmarks, attaining comparable performance with fine-tuning while adding only around  $2 - 4\%$  task-specific parameters (Houlsby et al., 2019; Lin et al., 2020).
+
+On the extreme end, GPT-3 (Brown et al., 2020) can be deployed without any task-specific tuning. Instead, users prepend a natural language task instruction (e.g.,  $TL;DR$  for summarization) and a few examples to the task input; then generate the output from the LM. This approach is known as in-context learning or prompting.
+
+In this paper, we propose prefix-tuning, a lightweight alternative to fine-tuning for natural language generation (NLG) tasks, inspired by prompting. Consider the task of generating a textual de
+
+scription of a data table, as shown in Figure 1, where the task input is a linearized table (e.g., "name: Starbucks | type: coffee shop") and the output is a textual description (e.g., "Starbucks serves coffee"). Prefix-tuning prepends a sequence of continuous task-specific vectors to the input, which we call a prefix, depicted by red blocks in Figure 1 (bottom). For subsequent tokens, the Transformer can attend to the prefix as if it were a sequence of "virtual tokens", but unlike prompting, the prefix consists entirely of free parameters which do not correspond to real tokens. In contrast to fine-tuning in Figure 1 (top), which updates all Transformer parameters and thus requires storing a tuned copy of the model for each task, prefix-tuning only optimizes the prefix. Consequently, we only need to store one copy of the large Transformer and a learned task-specific prefix, yielding a very small overhead for each additional task (e.g., 250K parameters for table-to-text).
+
+In contrast to fine-tuning, prefix-tuning is modular: we train an upstream prefix which steers a downstream LM, which remains unmodified. Thus, a single LM can support many tasks at once. In the context of personalization where the tasks correspond to different users (Shokri and Shmatikov, 2015; McMahan et al., 2016), we could have a separate prefix for each user trained only on that user's data, thereby avoiding data cross-contamination. Moreover, the prefix-based architecture enables us to even process examples from multiple users/tasks in a single batch, something that is not possible with other lightweight fine-tuning approaches.
+
+We evaluate prefix-tuning on table-to-text generation using GPT-2 and abstractive summarization using BART. In terms of storage, prefix-tuning stores  $1000\mathrm{x}$  fewer parameters than fine-tuning. In terms of performance when trained on full datasets, prefix-tuning and fine-tuning are comparable for table-to-text (§6.1), while prefix-tuning suffers a small degradation for summarization (§6.2). In low-data settings, prefix-tuning on average outperforms fine-tuning on both tasks (§6.3). Prefix-tuning also extrapolates better to tables (for table-to-text) and articles (for summarization) with unseen topics (§6.4).
+
+# 2 Related Work
+
+Fine-tuning for natural language generation. Current state-of-the-art systems for natural language generation are based on fine-tuning pre
+
+trained LMs. For table-to-text generation, Kale (2020) fine-tunes a sequence-to-sequence model (T5; Raffel et al., 2020). For extractive and abstractive summarization, researchers fine-tune masked language models (e.g., BERT; Devlin et al., 2019) and encode-decoder models (e.g., BART; Lewis et al., 2020) respectively (Zhong et al., 2020; Liu and Lapata, 2019; Raffel et al., 2020). For other conditional NLG tasks such as machine translation and dialogue generation, fine-tuning is also the prevalent paradigm (Zhang et al., 2020c; Stickland et al., 2020; Zhu et al., 2020; Liu et al., 2020). In this paper, we focus on table-to-text using GPT-2 and summarization using BART, but prefix-tuning can be applied to other generation tasks and pretrained models.
+
+Lightweight fine-tuning. Lightweight fine-tuning freezes most of the pretrained parameters and modifies the pretrained model with small trainable modules. The key challenge is to identify high-performing architectures of the modules and the subset of pretrained parameters to tune. One line of research considers removing parameters: some model weights are ablated away by training a binary mask over model parameters (Zhao et al., 2020; Radiya-Dixit and Wang, 2020). Another line of research considers inserting parameters. For example, Zhang et al. (2020a) trains a "side" network that is fused with the pretrained model via summation; adapter-tuning inserts task-specific layers (adapters) between each layer of the pretrained LM (Houlsby et al., 2019; Lin et al., 2020; Rebuffi et al., 2017; Pfeiffer et al., 2020). Compared to this line of work, which tunes around  $3.6\%$  of the LM parameters, our method obtains a further  $30x$  reduction in task-specific parameters, tuning only  $0.1\%$  while maintaining comparable performance.
+
+Prompting. Prompting means preponding instructions and a few examples to the task input and generating the output from the LM. GPT-3 (Brown et al., 2020) uses manually designed prompts to adapt its generation for different tasks, and this framework is termed in-context learning. However, since Transformers can only condition on a bounded-length context (e.g., 2048 tokens for GPT-3), in-context learning is unable to fully exploit training sets longer than the context window. Sun and Lai (2020) also prompt by keywords to control for sentiment or topic of the generated sentence. In natural language understanding tasks, prompt
+
+engineering has been explored in prior works for models like BERT and RoBERTa (Liu et al., 2019; Jiang et al., 2020; Schick and Schütze, 2020). For example, AutoPrompt (Shin et al., 2020) searches for a sequence of discrete trigger words and concatenates it with each input to elicit sentiment or factual knowledge from a masked LM. In contrast with AutoPrompt, our method optimizes continuous prefixes, which are more expressive (\$7.2); moreover, we focus on language generation tasks.
+
+Continuous vectors have been used to steer language models; for example, Subramani et al. (2020) showed that a pretrained LSTM language model can reconstruct arbitrary sentences by optimizing a continuous vector for each sentence, making the vector input-specific. In contrast, prefix-tuning optimizes a task-specific prefix that applies to all instances of that task. As a result, unlike the previous work whose application is limited to sentence reconstruction, prefix-tuning can be applied to NLG tasks.
+
+Controllable generation. Controllable generation aims to steer a pretrained language model to match a sentence level attribute (e.g., positive sentiment or topic on sports). Such control can happen at training time: Keskar et al. (2019) pretrains the language model (CTRL) to condition on metadata such as keywords or URLs. Additionally, the control can happen at decoding time, by weighted decoding (GeDi, Krause et al., 2020) or iteratively updating the past activations (PPLM, Dathathri et al., 2020). However, there is no straightforward way to apply these controllable generation techniques to enforce fine-grained control over generated contents, as demanded by tasks like table-to-text and summarization.
+
+# 3 Problem Statement
+
+Consider a conditional generation task where the input is a context  $x$  and the output  $y$  is a sequence of tokens. We focus on two tasks, shown in Figure 2 (right): In table-to-text,  $x$  corresponds to a linearized data table and  $y$  is a textual description; in summarization,  $x$  is an article and  $y$  is a short summary.
+
+# 3.1 Autoregressive LM
+
+Assume we have an autoregressive language model  $p_{\phi}(y \mid x)$  based on the Transformer (Vaswani et al., 2017) architecture (e.g., GPT-2; Radford et al.,
+
+2019) and parametrized by  $\phi$ . As shown in Figure 2 (top), let  $z = [x; y]$  be the concatenation of  $x$  and  $y$ ; let  $\mathsf{X}_{\mathrm{idx}}$  denote the sequence of indices that corresponds to  $x$ , and  $\mathsf{Y}_{\mathrm{idx}}$  denote the same for  $y$ .
+
+The activation at time step  $i$  is  $h_i \in \mathbb{R}^d$ , where  $h_i = [h_i^{(1)};\dots ;h_i^{(n)}]$  is a concatenation of all activation layers at this time step, and  $h_i^{(j)}$  is the activation of the  $j$ -th Transformer layer at time step  $i$ .<sup>1</sup>
+
+The autoregressive Transformer model computes  $h_i$  as a function of  $z_i$  and the past activations in its left context, as follows:
+
+$$
+h _ {i} = \operatorname {L M} _ {\phi} \left(z _ {i}, h _ {<   i}\right), \tag {1}
+$$
+
+where the last layer of  $h_i$  is used to compute the distribution for the next token:  $p_{\phi}(z_{i+1} \mid h_{\leq i}) = \text{softmax}(W_{\phi} h_i^{(n)})$  and  $W_{\phi}$  is a pretrained matrix that maps  $h_i^{(n)}$  to logits over the vocabulary.
+
+# 3.2 Encoder-Decoder Architecture
+
+We can also use an encoder-decoder architecture (e.g., BART; Lewis et al., 2020) to model  $p_{\phi}(y \mid x)$ , where  $x$  is encoded by the bidirectional encoder, and the decoder predicts  $y$  autoregressively (conditioned on the encoded  $x$  and its left context). We use the same indexing and activation notation, as shown in Figure 2 (bottom).  $h_i$  for all  $i \in \mathsf{X}_{\mathrm{idx}}$  is computed by the bidirectional Transformer encoder;  $h_i$  for all  $i \in \mathsf{Y}_{\mathrm{idx}}$  is computed by the autoregressive decoder using the same equation (1).
+
+# 3.3 Method: Fine-tuning
+
+In the fine-tuning framework, we initialize with the pretrained parameters  $\phi$ . Here  $p_{\phi}$  is a trainable language model distribution and we perform gradient updates on the following log-likelihood objective:
+
+$$
+\max  _ {\phi} \log p _ {\phi} (y \mid x) = \sum_ {i \in Y _ {\mathrm {i d x}}} \log p _ {\phi} \left(z _ {i} \mid h _ {<   i}\right). \tag {2}
+$$
+
+# 4 Prefix-Tuning
+
+We propose prefix-tuning as an alternative to fine-tuning for conditional generation tasks. We first provide intuition in §4.1 before defining our method formally in §4.2.
+
+![](images/54cd6d42f5f8f02254e18c0bdca56ed1b533aada9466a280712a221475ad5054.jpg)  
+Figure 2: An annotated example of prefix-tuning using an autoregressive LM (top) and an encoder-decoder model (bottom). The prefix activations  $\forall i\in \mathsf{P}_{\mathrm{idx}},h_i$  are drawn from a trainable matrix  $P_{\theta}$ . The remaining activations are computed by the Transformer.
+
+# 4.1 Intuition
+
+Based on intuition from prompting, we believe that having a proper context can steer the LM without changing its parameters. For example, if we want the LM to generate a word (e.g., Obama), we can comprehend its common collocations as context (e.g., Barack), and the LM will assign much higher probability to the desired word. Extending this intuition beyond generating a single word or sentence, we want to find a context that steers the LM to solve an NLG task. Intuitively, the context can influence the encoding of  $x$  by guiding what to extract from  $x$ ; and can influence the generation of  $y$  by steering the next token distribution. However, it's non-obvious whether such a context exists. Natural language task instructions (e.g., "summarize the following table in one sentence") might guide an expert annotator to solve the task, but fail for most pretrained LMs. Data-driven optimization over the discrete instructions might help, but discrete optimization is computationally challenging.
+
+Instead of optimizing over discrete tokens, we can optimize the instruction as continuous word embeddings, whose effects will be propagated upward to all Transformer activation layers and rightward to subsequent tokens. This is strictly more expressive than a discrete prompt which requires matching the embedding of a real word. Meanwhile, this is less expressive than intervening all layers of the activations (§7.2), which avoids long-range dependencies and includes more tunable parameters. Prefix-tuning, therefore, optimizes all layers of the prefix.
+
+# 4.2 Method
+
+Prefix-tuning prepends a prefix for an autoregressive LM to obtain  $z = \left[\mathrm{PREFIX}; x; y\right]$ , or prepends prefixes for both encoder and encoder to obtain  $z = \left[\mathrm{PREFIX}; x; \mathrm{PREFIX}'; y\right]$ , as shown in Figure 2. Here,  $\mathsf{P}_{\mathrm{idx}}$  denotes the sequence of prefix indices, and we use  $|\mathsf{P}_{\mathrm{idx}}|$  to denote the length of the prefix.
+
+We follow the recurrence relation in equation (1), except that the prefix are free parameters. Prefix-tuning initializes a trainable matrix  $P_{\theta}$  (parametrized by  $\theta$ ) of dimension  $|\mathsf{P}_{\mathrm{idx}}| \times \dim(h_i)$  to store the prefix parameters.
+
+$$
+h _ {i} = \left\{ \begin{array}{l l} P _ {\theta} [ i,: ], & \text {i f} i \in \mathsf {P} _ {\mathrm {i d x}}, \\ \operatorname {L M} _ {\phi} \left(z _ {i}, h _ {<   i}\right), & \text {o t h e r w i s e}. \end{array} \right. \tag {3}
+$$
+
+The training objective is the same as equation (2), but the set of trainable parameters changes: the language model parameters  $\phi$  are fixed and the prefix parameters  $\theta$  are the only trainable parameters.
+
+Here,  $h_i$  (for all  $i$ ) is a function of the trainable  $P_{\theta}$ . When  $i \in \mathsf{P}_{\mathrm{idx}}$ , this is clear because  $h_i$  copies directly from  $P_{\theta}$ . When  $i \notin \mathsf{P}_{\mathrm{idx}}$ ,  $h_i$  still depends on  $P_{\theta}$ , because the prefix activations are always in the left context and will therefore affect any activations to its right.
+
+# 4.3 Parametrization of  $P_{\theta}$
+
+Empirically, directly updating the  $P_{\theta}$  parameters leads to unstable optimization and a slight drop in performance. So we reparametrize the matrix  $P_{\theta}[i,:] = \mathrm{MLP}_{\theta}(P_{\theta}'[i,:])$  by a smaller matrix  $(P_{\theta}')$  composed with a large feedforward neural network  $(\mathrm{MLP}_{\theta})$ . Note that  $P_{\theta}$  and  $P_{\theta}'$  has the same rows
+
+dimension (i.e. the prefix length), but different columns dimension.4 Once training is complete, these reparametrization parameters can be dropped, and only the prefix  $(P_{\theta})$  needs to be saved.
+
+# 5 Experimental Setup
+
+# 5.1 Datasets and Metrics
+
+We evaluate on three standard neural generation datasets for the table-to-text task: E2E (Novikova et al., 2017), WebNLG (Gardent et al., 2017), and DART (Radev et al., 2020). The datasets are ordered by increasing complexity and size. E2E only has 1 domain (i.e. restaurant reviews); WebNLG has 14 domains, and DART is open-domain, using open-domain tables from Wikipedia.
+
+The E2E dataset contains approximately 50K examples with 8 distinct fields; it contains multiple test references for one source table, and the average output length is 22.9. We use the official evaluation script, which reports BLEU (Papineni et al., 2002), NIST (Belz and Reiter, 2006), METEOR (Lavie and Agarwal, 2007), ROUGE-L (Lin, 2004), and CIDEr (Vedantam et al., 2015).
+
+The WebNLG (Gardent et al., 2017) dataset consists of 22K examples, and the input  $x$  is a sequence of (subject, property, object) triples. The average output length is 22.5. In the training and validation splits, the input describes entities from 9 distinct DBpedia categories (e.g., Monument). The test split consists of two parts: the first half contains DB categories seen in training data, and the second half contains 5 unseen categories. These unseen categories are used to evaluate extrapolation. We use the official evaluation script, which reports BLEU, METEOR and TER (Snover et al., 2006).
+
+DART (Radev et al., 2020) is an open domain table-to-text dataset, with similar input format (entity-relation-entity triples) as WebNLG. The average output length is 21.6. It consists of 82K examples from WikiSQL, WikiTableQuestions, E2E, and WebNLG and applies some manual or automated conversion. We use the official evaluation script and report BLEU, METEOR, TER, MoverScore (Zhao et al., 2019), BERTScore (Zhang et al., 2020b) and BLEURT (Sellam et al., 2020).
+
+For the summarization task, we use the XSUM (Narayan et al., 2018) dataset, which is an abstrac
+
+tive summarization dataset on news articles. There are 225K examples. The average length of the articles is 431 words and the average length of the summaries is 23.3. We report ROUGE-1, ROUGE-2 and ROUGE-L.
+
+# 5.2 Methods
+
+For table-to-text generation, we compare prefix-tuning with three other methods: fine-tuning (FINE-TUNE), fine-tuning only the top 2 layers (FT-TOP2), and adapter-tuning (ADAPTER). We also report the current state-of-the-art results on these datasets: On E2E, Shen et al. (2019) uses a pragmatically informed model without pretraining. On WebNLG, Kale (2020) fine-tunes T5-large. On DART, no official models trained on this dataset version are released. For summarization, we compare against fine-tuning BART (Lewis et al., 2020).
+
+# 5.3 Architectures and Hyperparameters
+
+For table-to-text, we use GPT-2_MEDIUM and GPT-2Large; the source tables are linearized. For summarization, we use BARTLarge, and the source articles are truncated to 512 BPE tokens.
+
+Our implementation is based on the Hugging Face Transformer models (Wolf et al., 2020). At training time, we use the AdamW optimizer (Loshchilov and Hutter, 2019) and a linear learning rate scheduler, as suggested by the Hugging Face default setup. The hyperparameters we tune include the number of epochs, batch size, learning rate, and prefix length. Hyperparameter details are in the appendix. A default setting trains for 10 epochs, using a batch size of 5, a learning rate of  $5 \cdot 10^{-5}$  and a prefix length of 10. The table-to-text models are trained on TITAN Xp or GeForce GTX TITAN X machines. Prefix-tuning takes 0.2 hours per epochs to train on 22K examples, whereas fine-tuning takes around 0.3 hours. The summarization models are trained on Tesla V100 machines, taking 1.25h per epoch on the XSUM dataset.
+
+At decoding time, for the three table-to-text datasets, we use beam search with a beam size of 5. For summarization, we use a beam size of 6
+
+and length normalization of 0.8. Decoding takes 1.2 seconds per sentence (without batching) for table-to-text, and 2.6 seconds per batch (using a batch size of 10) for summarization.
+
+# 6 Main Results
+
+# 6.1 Table-to-text Generation
+
+We find that adding only  $0.1\%$  task-specific parameters, prefix-tuning is effective in table-to-text generation, outperforming other lightweight baselines (ADAPTER and FT-TOP2) and achieving a comparable performance with fine-tuning. This trend is true across all three datasets: E2E, WebNLG, and DART.
+
+For a fair comparison, we match the number of parameters for prefix-tuning and adapter-tuning to be  $0.1\%$ . Table 1 shows that prefix-tuning is significantly better than ADAPTER  $(0.1\%)$ , attaining 4.1 BLEU improvement per dataset on average. Even when we compare with fine-tuning  $(100\%)$  and adapter-tuning  $(3.0\%)$ , which update significantly more parameters than prefix-tuning, prefix-tuning still achieves results comparable or better than those two systems. This demonstrates that prefix-tuning is more Pareto efficient than adapter-tuning, significantly reducing parameters while improving generation quality.
+
+Additionally, attaining good performance on DART suggests that prefix-tuning can generalize to tables with diverse domains and a large pool of relations. We will delve deeper into extrapolation performance (i.e. generalization to unseen categories or topics) in §6.4.
+
+Overall, prefix-tuning is an effective and space-efficient method to adapt GPT-2 to table-to-text generation. The learned prefix is expressive enough to steer GPT-2 in order to correctly extract contents from an unnatural format and generate a textual description. Prefix-tuning also scales well from GPT-2<sub>MEDIUM</sub> to GPT-2<sub>LARGE</sub>, suggesting it has the potential to scale to even larger models with a similar architecture, like GPT-3.
+
+# 6.2 Summarization
+
+As shown in Table 2, with  $2\%$  parameters, prefix-tuning obtains slightly lower performance than fine
+
+tuning (36.05 vs. 37.25 in ROUGE-L). With only  $0.1\%$  parameters, prefix-tuning underperforms full fine-tuning (35.05 vs. 37.25). There are several differences between XSUM and the three table-to-text datasets which could account for why prefix-tuning has comparative advantage in table-to-text: (1) XSUM contains 4x more examples than the three table-to-text datasets on average; (2) the input articles are 17x longer than the linearized table input of table-to-text datasets on average; (3) summarization might be more complex than table-to-text because it requires reading comprehension and identifying key contents from an article.
+
+# 6.3 Low-data Setting
+
+Based on the results from table-to-text (§6.1) and summarization (§6.2), we observe that prefix-tuning has a comparative advantage when the number of training examples is smaller. To construct low-data settings, we subsample the full dataset (E2E for table-to-text and XSUM for summarization) to obtain small datasets of size {50, 100, 200, 500}. For each size, we sample 5 different datasets and average over 2 training random seeds. Thus, we average over 10 models to get an estimate for each low-data setting.[11]
+
+Figure 3 (right) shows that prefix-tuning outperforms fine-tuning in low-data regimes by 2.9 BLEU on average, in addition to requiring many fewer parameters, but the gap narrows as the dataset size increases.
+
+Qualitatively, Figure 3 (left) shows 8 examples generated by both prefix-tuning and fine-tuning models trained on different data levels. While both methods tend to undergenerate (missing table contents) in low data regimes, prefix-tuning tends to be more faithful than fine-tuning. For example, finetuning  $(100,200)^{12}$  falsely claims a low customer rating while the true rating is average, whereas prefix-tuning (100, 200) generates a description that is faithful to the table.
+
+# 6.4 Extrapolation
+
+We now investigate extrapolation performance to unseen topics for both table-to-text and summarization. In order to construct an extrapolation setting, we split the existing datasets so that training and test cover different topics. For table-to-text, the
+
+<table><tr><td rowspan="3"></td><td rowspan="3">BLEU</td><td rowspan="3">NIST</td><td rowspan="3">E2EMET</td><td rowspan="3">R-L</td><td rowspan="3">CIDEr</td><td colspan="9">WebNLG</td><td colspan="6">DART</td></tr><tr><td colspan="3">BLEU</td><td colspan="3">MET</td><td colspan="3">TER↓</td><td rowspan="2">BLEU</td><td rowspan="2">MET</td><td rowspan="2">TER↓</td><td rowspan="2">Mover</td><td rowspan="2">BERT</td><td rowspan="2">BLEURT</td></tr><tr><td>S</td><td>U</td><td>A</td><td>S</td><td>U</td><td>A</td><td>S</td><td>U</td><td>A</td></tr><tr><td colspan="21">GPT-2MEDIUM</td></tr><tr><td>FINE-TUNE</td><td>68.2</td><td>8.62</td><td>46.2</td><td>71.0</td><td>2.47</td><td>64.2</td><td>27.7</td><td>46.5</td><td>0.45</td><td>0.30</td><td>0.38</td><td>0.33</td><td>0.76</td><td>0.53</td><td>46.2</td><td>0.39</td><td>0.46</td><td>0.50</td><td>0.94</td><td>0.39</td></tr><tr><td>FT-TOP2</td><td>68.1</td><td>8.59</td><td>46.0</td><td>70.8</td><td>2.41</td><td>53.6</td><td>18.9</td><td>36.0</td><td>0.38</td><td>0.23</td><td>0.31</td><td>0.49</td><td>0.99</td><td>0.72</td><td>41.0</td><td>0.34</td><td>0.56</td><td>0.43</td><td>0.93</td><td>0.21</td></tr><tr><td>ADAPTER(3%)</td><td>68.9</td><td>8.71</td><td>46.1</td><td>71.3</td><td>2.47</td><td>60.4</td><td>48.3</td><td>54.9</td><td>0.43</td><td>0.38</td><td>0.41</td><td>0.35</td><td>0.45</td><td>0.39</td><td>45.2</td><td>0.38</td><td>0.46</td><td>0.50</td><td>0.94</td><td>0.39</td></tr><tr><td>ADAPTER(0.1%)</td><td>66.3</td><td>8.41</td><td>45.0</td><td>69.8</td><td>2.40</td><td>54.5</td><td>45.1</td><td>50.2</td><td>0.39</td><td>0.36</td><td>0.38</td><td>0.40</td><td>0.46</td><td>0.43</td><td>42.4</td><td>0.36</td><td>0.48</td><td>0.47</td><td>0.94</td><td>0.33</td></tr><tr><td>PREFIX(0.1%)</td><td>69.7</td><td>8.81</td><td>46.1</td><td>71.4</td><td>2.49</td><td>62.9</td><td>45.6</td><td>55.1</td><td>0.44</td><td>0.38</td><td>0.41</td><td>0.35</td><td>0.49</td><td>0.41</td><td>46.4</td><td>0.38</td><td>0.46</td><td>0.50</td><td>0.94</td><td>0.39</td></tr><tr><td colspan="21">GPT-2LARGE</td></tr><tr><td>FINE-TUNE</td><td>68.5</td><td>8.78</td><td>46.0</td><td>69.9</td><td>2.45</td><td>65.3</td><td>43.1</td><td>55.5</td><td>0.46</td><td>0.38</td><td>0.42</td><td>0.33</td><td>0.53</td><td>0.42</td><td>47.0</td><td>0.39</td><td>0.46</td><td>0.51</td><td>0.94</td><td>0.40</td></tr><tr><td>Prefix</td><td>70.3</td><td>8.85</td><td>46.2</td><td>71.7</td><td>2.47</td><td>63.4</td><td>47.7</td><td>56.3</td><td>0.45</td><td>0.39</td><td>0.42</td><td>0.34</td><td>0.48</td><td>0.40</td><td>46.7</td><td>0.39</td><td>0.45</td><td>0.51</td><td>0.94</td><td>0.40</td></tr><tr><td>SOTA</td><td>68.6</td><td>8.70</td><td>45.3</td><td>70.8</td><td>2.37</td><td>63.9</td><td>52.8</td><td>57.1</td><td>0.46</td><td>0.41</td><td>0.44</td><td>-</td><td>-</td><td>-</td><td>-</td><td>-</td><td>-</td><td>-</td><td>-</td><td>-</td></tr></table>
+
+Table 1: Metrics (higher is better, except for TER) for table-to-text generation on E2E (left), WebNLG (middle) and DART (right). With only  $0.1\%$  parameters, Prefix-tuning outperforms other lightweight baselines and achieves a comparable performance with fine-tuning. The best score is boldfaced for both GPT-2_MEDIUM and GPT-2 LARGE.  
+
+<table><tr><td>Source</td><td>name: The Eagle | type: coffee shop | food: Chinese | price: cheap | customer rating: average | area: riverside | family friendly: no | near: Burger King</td></tr><tr><td>Prefix (50)</td><td>The Eagle is a cheap Chinese coffee shop located near Burger King.</td></tr><tr><td>Prefix (100)</td><td>The Eagle is a cheap coffee shop located in the riverside near Burger King. It has average customer ratings.</td></tr><tr><td>Prefix (200)</td><td>The Eagle is a cheap Chinese coffee shop located in the riverside area near Burger King. It has average customer ratings.</td></tr><tr><td>Prefix (500)</td><td>The Eagle is a coffee shop that serves Chinese food. It is located in the riverside area near Burger King. It has an average customer rating and is not family friendly.</td></tr><tr><td>FT (50)</td><td>The Eagle coffee shop is located in the riverside area near Burger King.</td></tr><tr><td>FT (100)</td><td>The Eagle is a cheap coffee shop near Burger King in the riverside area. It has a low customer rating and is not family friendly.</td></tr><tr><td>FT (200)</td><td>The Eagle is a cheap Chinese coffee shop with a low customer rating. It is located near Burger King in the riverside area.</td></tr><tr><td>FT (500)</td><td>The Eagle is a cheap Chinese coffee shop with average customer ratings. It is located in the riverside area near Burger King.</td></tr></table>
+
+![](images/251435a063ab276013b0efa29b2af144604fb20ab0d22cbbff75ffe90430fbe8.jpg)
+
+![](images/f1468807285b9da83bb2fdea9d0c8fcd8e60ba2737b407af7eb492f9c5def575.jpg)  
+Figure 3: (Left) qualitative examples in lowdata settings. (Right) prefix-tuning (orange) outperforms fine-tuning (blue) in low-data regimes in addition to requiring many fewer parameters. The top two plots correspond to summarization, measured by ROUGE-1 and ROUGE-2. The bottom two plots correspond to table-to-text, measured by BLEU and ROUGE-L. The x-axis is the training size and the y-axis is the evaluation metric (higher is better).
+
+![](images/16eebb3c8f77aab5c5b4f1aa143257adfedecad8b19b0b1a1605f4df6f88ba47.jpg)
+
+![](images/433f9b1e61e4ab218f85c6f0c3d4d9b354f052a615b653f66929e511e3ae6a5a.jpg)
+
+<table><tr><td></td><td>R-1 ↑</td><td>R-2 ↑</td><td>R-L ↑</td></tr><tr><td>FINE-TUNE(Lewis et al., 2020)</td><td>45.14</td><td>22.27</td><td>37.25</td></tr><tr><td>PREFIX(2%)</td><td>43.80</td><td>20.93</td><td>36.05</td></tr><tr><td>PREFIX(0.1%)</td><td>42.92</td><td>20.03</td><td>35.05</td></tr></table>
+
+Table 2: Metrics for summarization on XSUM. Prefix-tuning slightly underperforms fine-tuning.  
+
+<table><tr><td></td><td colspan="3">news-to-sports</td><td colspan="3">within-news</td></tr><tr><td></td><td>R-1↑</td><td>R-2↑</td><td>R-L↑</td><td>R-1↑</td><td>R-2↑</td><td>R-L↑</td></tr><tr><td>FINE-TUNE</td><td>38.15</td><td>15.51</td><td>30.26</td><td>39.20</td><td>16.35</td><td>31.15</td></tr><tr><td>PREFIX</td><td>39.23</td><td>16.74</td><td>31.51</td><td>39.41</td><td>16.87</td><td>31.47</td></tr></table>
+
+Table 3: Extrapolation performance on XSUM. Prefix-tuning outperforms fine-tuning on both news-to-sports and within-news splits.
+
+WebNLG dataset is labeled with table topics. There are 9 categories that appear in training and dev, denoted as SEEN and 5 categories that only appear at test time, denoted as UNSEEN. So we evaluate extrapolation by training on the SEEN categories and testing on the UNSEEN categories. For summarization, we construct two extrapolation data splits<sup>13</sup>: In news-to-sports, we train on news articles,
+
+and test on sports articles. In within-news, we train on {world, UK, business} news, and test on the remaining news categories (e.g., health, technology).
+
+On both table-to-text and summarization, prefix-tuning has better extrapolation than fine-tuning under all metrics, as shown in Table 3 and the 'U' columns of Table 1 (middle).
+
+We also find that adapter-tuning achieves good extrapolation performance, comparable with prefix-tuning, as shown in Table 1. This shared trend suggests that preserving LM parameters indeed has a positive impact on extrapolation. However, the
+
+![](images/9dc705ad0d0de266063c9f5b941693f8d00371c89e09cf3ca4d7314a733a0626.jpg)  
+Figure 4: Prefix length vs. performance on summerization (left) and table-to-text (right). Performance increases as the prefix length increases up to a threshold (200 for summarization and 10 for table-to-text) and then a slight performance drop occurs. Each plot reports two metrics (on two vertical axes).
+
+![](images/4c32ddd3e946bbb2a8c51afab2900710005100407ed04f5cb40a3cc1e4e783bd.jpg)
+
+reason for such gains is an open question and we will discuss further in  $\S 8$
+
+# 7 Intrinsic Evaluation
+
+We compare different variants of prefix-tuning. §7.1 studies the impact of the prefix length. §7.2 studies tuning only the embedding layer, which is more akin to tuning a discrete prompt. §7.3 compares prefixing and infixing, which inserts trainable activations between  $x$  and  $y$ . §7.4 studies the impact of various prefix initialization strategies.
+
+# 7.1 Prefix Length
+
+A longer prefix means more trainable parameters, and therefore more expressive power. Figure 4 shows that performance increases as the prefix length increases up to a threshold (200 for summarization, 10 for table-to-text) and then a slight performance drop occurs.[14]
+
+Empirically, longer prefixes have a negligible impact on inference speed, because attention computation over the entire prefix is parallelized on GPUs.
+
+# 7.2 Full vs Embedding-only
+
+Recall in §4.1, we discuss the option of optimizing the continuous embeddings of the "virtual tokens." We instantiate that idea and call it embedding-only ablation. The word embeddings are free parameters, and the upper activation layers are computed by the Transformer. Table 4 (top) shows that the performance drops significantly, suggesting that tuning only the embedding layer is not sufficiently expressive.
+
+The embedding-only ablation upper bounds the performance of discrete prompt optimization (Shin
+
+<table><tr><td></td><td>BLEU</td><td>NIST</td><td>E2EMET</td><td>ROUGE</td><td>CIDEr</td></tr><tr><td>PREFIX</td><td>69.7</td><td>8.81</td><td>46.1</td><td>71.4</td><td>2.49</td></tr><tr><td colspan="6">Embedding-only: EMB-{PrefixLength}</td></tr><tr><td>EMB-1</td><td>48.1</td><td>3.33</td><td>32.1</td><td>60.2</td><td>1.10</td></tr><tr><td>EMB-10</td><td>62.2</td><td>6.70</td><td>38.6</td><td>66.4</td><td>1.75</td></tr><tr><td>EMB-20</td><td>61.9</td><td>7.11</td><td>39.3</td><td>65.6</td><td>1.85</td></tr><tr><td colspan="6">Infix-tuning: INFIX-{PrefixLength}</td></tr><tr><td>INFIX-1</td><td>67.9</td><td>8.63</td><td>45.8</td><td>69.4</td><td>2.42</td></tr><tr><td>INFIX-10</td><td>67.2</td><td>8.48</td><td>45.8</td><td>69.9</td><td>2.40</td></tr><tr><td>INFIX-20</td><td>66.7</td><td>8.47</td><td>45.8</td><td>70.0</td><td>2.42</td></tr></table>
+
+Table 4: Intrinsic evaluation of Embedding-only (§7.2) and Infixing (§7.3). Both Embedding-only ablation and Infix-tuning underperforms full prefix-tuning.
+
+![](images/da8cac98218f47bf9a2e20ab0840f0e2913255424dab5b89b7f80f065f5524aa.jpg)  
+Figure 5: Initializing the prefix with activations of real words significantly outperforms random initialization, in low-data settings.
+
+et al., 2020), because discrete prompt restricts the embedding layer to exactly match the embedding of a real word. Consequently, we have this chain of increasing expressive power: discrete prompting  $<$  embedding-only ablation  $<$  prefix-tuning.
+
+# 7.3 Prefixing vs Infixing
+
+We also investigate how the trainable activations' position in the sequence affects performance. In prefix-tuning, we place them at the beginning [PREFIX;  $x;y$ ]. We can also place the trainable activations between  $x$  and  $y$  (i.e.  $[x;\mathrm{INFIX};y]$ ) and call this infix-tuning. Table 4 (bottom) shows that infix-tuning slightly underperforms prefix-tuning. We believe this is because prefix-tuning can affect the activations of  $x$  and  $y$  whereas infix-tuning can only influence the activations of  $y$ .
+
+# 7.4 Initialization
+
+We find that how the prefix is initialized has a large impact in low-data settings. Random initialization leads to low performance with high variance. Initializing the prefix with activations of real words
+
+significantly improves generation, as shown in Figure 5. In particular, initializing with task relevant words such as "summarization" and "table-to-text" obtains slightly better performance than task irrelevant words such as "elephant" and "divide", but using real words is still better than random.
+
+Since we initialize the prefix with activations of real words computed by the LM, this initialization strategy is concordant with preserving the pretrained LM as much as possible.
+
+# 8 Discussion
+
+In this section, we will discuss several favorable properties of prefix-tuning and some open problems.
+
+# 8.1 Personalization
+
+As we note in §1, prefix-tuning is advantageous when there are a large number of tasks that needs to be trained independently. One practical setting is user privacy (Shokri and Shmatikov, 2015; McMahan et al., 2016). In order to preserve user privacy, each user's data needs to be separated and a personalized model needs to be trained independently for each user. Consequently, each user can be regarded as an independent task. If there are millions of users, prefix-tuning can scale to this setting and maintain modularity, enabling flexible addition or deletion of users by adding or deleting their prefixes without cross-contamination.
+
+# 8.2 Batching Across Users
+
+Under the same personalization setting, prefix-tuning allows batching different users' queries even though they are backed by different prefixes. When multiple users query a cloud GPU device with their inputs, it is computationally efficient to put these users in the same batch. Prefix-tuning keeps the shared LM intact; consequently, batching requires a simple step of prepending the personalized prefix to user input, and all the remaining computation is unchanged. In contrast, we can't batch across different users in adapter-tuning, which has personalized adapters between shared Transformer layers.
+
+# 8.3 Inductive Bias of Prefix-tuning
+
+Recall that fine-tuning updates all pretrained parameters, whereas prefix-tuning and adapter-tuning preserve them. Since the language models are pretrained on general purpose corpus, preserving the LM parameters might help generalization to domains unseen during training. In concordance with
+
+this intuition, we observe that both prefix-tuning and adapter-tuning have significant performance gain in extrapolation settings (§6.4); however, the reason for such gain is an open question.
+
+While prefix-tuning and adapter-tuning both freeze the pretrained parameters, they tune different sets of parameters to affect the activation layers of the Transformer. Recall that prefix-tuning keeps the LM intact and uses the prefix and the pretrained attention blocks to affect the subsequent activations; adapter-tuning inserts trainable modules between LM layers, which directly add residual vectors to the activations. Moreover, we observe that prefix-tuning requires vastly fewer parameters compared to adapter-tuning while maintaining comparable performance. We think this gain in parameter efficiency is because prefix-tuning keeps the pretrained LM intact as much as possible, and therefore exploits the LM more than adapter-tuning.
+
+Concurrent work by Aghajanyan et al. (2020) uses intrinsic dimension to show that there exists a low dimension reparameterization that is as effective for fine-tuning as the full parameter space. This explains why good accuracy on downstream task can be obtained by updating only a small number of parameters. Our work echoes the finding by showing that good generation performance can be attained by updating a very small prefix.
+
+# 9 Conclusion
+
+We have proposed prefix-tuning, a lightweight alternative to fine-tuning that prepends a trainable continuous prefix for NLG tasks. We discover that despite learning  $1000\mathrm{x}$  fewer parameters than fine-tuning, prefix-tuning can maintain a comparable performance in a full data setting and outperforms fine-tuning in both low-data and extrapolation settings.
+
+# References
+
+Armen Aghajanyan, Luke Zettlemoyer, and Sonal Gupta. 2020. Intrinsic dimensionality explains the effectiveness of language model fine-tuning.  
+Anja Belz and Ehud Reiter. 2006. Comparing automatic and human evaluation of NLG systems. In 11th Conference of the European Chapter of the Association for Computational Linguistics, Trento, Italy. Association for Computational Linguistics.  
+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.  
+Sumanth Dathathri, Andrea Madotto, Janice Lan, Jane Hung, Eric Frank, Piero Molino, Jason Yosinski, and Rosanne Liu. 2020. Plug and play language models: A simple approach to controlled text generation. In International Conference on Learning Representations.  
+Jacob Devlin, Ming-Wei Chang, Kenton Lee, and Kristina Toutanova. 2019. BERT: Pre-training of deep bidirectional transformers for language understanding. In Proceedings of the 2019 Conference of the North American Chapter of the Association for Computational Linguistics: Human Language Technologies, Volume 1 (Long and Short Papers), pages 4171-4186, Minneapolis, Minnesota. Association for Computational Linguistics.  
+Claire Gardent, Anastasia Shimorina, Shashi Narayan, and Laura Perez-Beltrachini. 2017. The WebNLG challenge: Generating text from RDF data. In Proceedings of the 10th International Conference on Natural Language Generation, pages 124-133, Santiago de Compostela, Spain. Association for Computational Linguistics.  
+Neil Houlsby, Andrei Giurgiu, Stanislaw Jastrzebski, Bruna Morrone, Quentin De Laroussilhe, Andrea Gesmundo, Mona Attariyan, and Sylvain Gelly. 2019. Parameter-efficient transfer learning for NLP. In Proceedings of the 36th International Conference on Machine Learning, volume 97 of Proceedings of Machine Learning Research, pages 2790-2799, Long Beach, California, USA. PMLR.  
+Zhengbao Jiang, Frank F. Xu, Jun Araki, and Graham Neubig. 2020. How can we know what language models know? Transactions of the Association for Computational Linguistics, 8:423-438.  
+Mihir Kale. 2020. Text-to-text pre-training for data-to-text tasks.  
+N. Keskar, B. McCann, L. R. Varshney, Caiming Xiong, and R. Socher. 2019. Ctrl: A conditional transformer language model for controllable generation. ArXiv, abs/1909.05858.  
+Ben Krause, Akhilesh Deepak Gotmare, Bryan McCann, Nitish Shirish Keskar, Shafiq Joty, Richard Socher, and Nazneen Fatema Rajani. 2020. GeDi: Generative Discriminator Guided Sequence Generation. arXiv preprint arXiv:2009.06367.  
+Alon Lavie and Abhaya Agarwal. 2007. Meteor: An automatic metric for mt evaluation with high levels
+
+of correlation with human judgments. In Proceedings of the Second Workshop on Statistical Machine Translation, StatMT '07, pages 228-231, Stroudsburg, PA, USA. Association for Computational Linguistics.  
+Mike Lewis, Yinhan Liu, Naman Goyal, Marjan Ghazvininejad, Abdelrahman Mohamed, Omer Levy, Veselin Stoyanov, and Luke Zettlemoyer. 2020. BART: Denoising sequence-to-sequence pretraining for natural language generation, translation, and comprehension. In Proceedings of the 58th Annual Meeting of the Association for Computational Linguistics, pages 7871-7880, Online. Association for Computational Linguistics.  
+Chin-Yew Lin. 2004. ROUGE: A package for automatic evaluation of summaries. In Text Summarization Branches Out, pages 74-81, Barcelona, Spain. Association for Computational Linguistics.  
+Zhaojiang Lin, Andrea Madotto, and Pascale Fung. 2020. Exploring versatile generative language model via parameter-efficient transfer learning. In Findings of the Association for Computational Linguistics: EMNLP 2020, pages 441-459, Online. Association for Computational Linguistics.  
+Yang Liu and Mirella Lapata. 2019. Text summarization with pretrained encoders. In Proceedings of the 2019 Conference on Empirical Methods in Natural Language Processing and the 9th International Joint Conference on Natural Language Processing (EMNLP-IJCNLP), pages 3730-3740, Hong Kong, China. Association for Computational Linguistics.  
+Yinhan Liu, Jiatao Gu, Naman Goyal, Xian Li, Sergey Edunov, Marjan Ghazvininejad, Mike Lewis, and Luke Zettlemoyer. 2020. Multilingual denoising pre-training for neural machine translation.  
+Yinhan Liu, Myle Ott, Naman Goyal, Jingfei Du, Mandar Joshi, Danqi Chen, Omer Levy, Mike Lewis, Luke Zettlemoyer, and Veselin Stoyanov. 2019. Roberta: A robustly optimized BERT pretraining approach. CoRR, abs/1907.11692.  
+Ilya Loshchilov and Frank Hutter. 2019. Decoupled weight decay regularization. In International Conference on Learning Representations.  
+H. Brendan McMahan, Eider Moore, Daniel Ramage, and Blaise Agüera y Arcas. 2016. Federated learning of deep networks using model averaging. Proceedings of the 20th International Conference on Artificial Intelligence and Statistics (AISTATS) 2017, abs/1602.05629.  
+Shashi Narayan, Shay B. Cohen, and Mirella Lapata. 2018. Don't give me the details, just the summary! Topic-aware convolutional neural networks for extreme summarization. In Proceedings of the 2018 Conference on Empirical Methods in Natural Language Processing, Brussels, Belgium.
+
+Jekaterina Novikova, Ondrej Dusek, and Verena Rieser. 2017. The E2E dataset: New challenges for end-to-end generation. CoRR, abs/1706.09254.  
+Kishore Papineni, Salim Roukos, Todd Ward, and Wei-Jing Zhu. 2002. Bleu: A method for automatic evaluation of machine translation. In Proceedings of the 40th Annual Meeting on Association for Computational Linguistics, ACL '02, pages 311-318, Stroudsburg, PA, USA. Association for Computational Linguistics.  
+Jonas Pfeiffer, Aishwarya Kamath, Andreas Rückle, Kyunghyun Cho, and Iryna Gurevych. 2020. Adapterfusion: Non-destructive task composition for transfer learning.  
+Dragomir Radev, Rui Zhang, Amrit Rau, Abhinand Sivaprasad, Chiachun Hsieh, Nazneen Fatema Rajani, Xiangru Tang, Aadit Vyas, Neha Verma, Pranav Krishna, Yangxiaokang Liu, Nadia Irwanto, Jessica Pan, Faiaz Rahman, Ahmad Zaidi, Murori Mutuma, Yasin Tarabar, Ankit Gupta, Tao Yu, Yi Chern Tan, Xi Victoria Lin, Caiming Xiong, and Richard Socher. 2020. Dart: Open-domain structured data record to text generation.  
+A. Radford, Jeffrey Wu, R. Child, David Luan, Dario Amodei, and Ilya Sutskever. 2019. Language models are unsupervised multitask learners.  
+Evani Radiya-Dixit and Xin Wang. 2020. How fine can fine-tuning be? learning efficient language models. In Proceedings of the Twenty Third International Conference on Artificial Intelligence and Statistics, volume 108 of Proceedings of Machine Learning Research, pages 2435-2443, Online. PMLR.  
+Colin Raffel, Noam Shazeer, Adam Roberts, Katherine Lee, Sharan Narang, Michael Matena, Yanqi Zhou, Wei Li, and Peter J. Liu. 2020. Exploring the limits of transfer learning with a unified text-to-text transformer. Journal of Machine Learning Research, 21(140):1-67.  
+Sylvestre-Alvise Rebuffi, Hakan Bilen, and Andrea Vedaldi. 2017. Learning multiple visual domains with residual adapters. In Advances in Neural Information Processing Systems, volume 30, pages 506-516. Curran Associates, Inc.  
+Timo Schick and Hinrich Schütze. 2020. Exploiting cloze questions for few shot text classification and natural language inference.  
+Thibault Sellam, Dipanjan Das, and Ankur Parikh. 2020. BLEURT: Learning robust metrics for text generation. In Proceedings of the 58th Annual Meeting of the Association for Computational Linguistics, pages 7881-7892, Online. Association for Computational Linguistics.  
+Sheng Shen, Daniel Fried, Jacob Andreas, and Dan Klein. 2019. Pragmatically informative text generation. In Proceedings of the 2019 Conference of the North American Chapter of the Association
+
+for Computational Linguistics: Human Language Technologies, Volume 1 (Long and Short Papers), pages 4060-4067, Minneapolis, Minnesota. Association for Computational Linguistics.  
+Taylor Shin, Yasaman Razeghi, Robert L. Logan IV au2, Eric Wallace, and Sameer Singh. 2020. Autoprompt: Eliciting knowledge from language models with automatically generated prompts.  
+Reza Shokri and Vitaly Shmatikov. 2015. Privacy-preserving deep learning. In Proceedings of the 22nd ACM SIGSAC Conference on Computer and Communications Security, CCS '15, page 1310-1321, New York, NY, USA. Association for Computing Machinery.  
+Matthew Snover, Bonnie Dorr, Richard Schwartz, Linnea Micciulla, and Ralph Weischedel. 2006. A study of translation error rate with targeted human annotation. In *In Proceedings of the Association for Machine Translation in the Americas* (AMTA 2006).  
+Asa Cooper Stickland, Xian Li, and Marjan Ghazvininejad. 2020. Recipes for adapting pre-trained monolingual and multilingual models to machine translation.  
+Nishant Subramani, Samuel R. Bowman, and Kyunghyun Cho. 2020. Can unconditional language models recover arbitrary sentences?  
+Fan-Keng Sun and Cheng-I Lai. 2020. Conditioned natural language generation using only unconditioned language model: An exploration.  
+Ashish Vaswani, Noam Shazeer, Niki Parmar, Jakob Uszkoreit, Llion Jones, Aidan N Gomez, Lukasz Kaiser, and Illia Polosukhin. 2017. Attention is all you need. In Advances in Neural Information Processing Systems, volume 30, pages 5998-6008. Curran Associates, Inc.  
+Ramakrishna Vedantam, C. Lawrence Zitnick, and Devi Parikh. 2015. Cider: Consensus-based image description evaluation. In CVPR, pages 4566-4575. IEEE Computer Society.  
+Thomas Wolf, Lysandre Debut, Victor Sanh, Julien Chaumont, Clement Delangue, Anthony Moi, Pierric Cistac, Tim Rault, Rémi Louf, Morgan Funtowicz, Joe Davison, Sam Shleifer, Patrick von Platen, Clara Ma, Yacine Jernite, Julien Plu, Canwen Xu, Teven Le Scao, Sylvain Gugger, Mariama Drame, Quentin Lhoest, and Alexander M. Rush. 2020. Transformers: State-of-the-art natural language processing. In Proceedings of the 2020 Conference on Empirical Methods in Natural Language Processing: System Demonstrations, pages 38-45, Online. Association for Computational Linguistics.  
+Jeffrey O Zhang, Alexander Sax, Amir Zamir, Leonidas Guibas, and Jitendra Malik. 2020a. Sidetuning: A baseline for network adaptation via additive side networks.
+
+Tianyi Zhang, Varsha Kishore, Felix Wu, Kilian Q. Weinberger, and Yoav Artzi. 2020b. BERTScore: Evaluating text generation with bert. In International Conference on Learning Representations.  
+Yizhe Zhang, Siqi Sun, Michel Galley, Yen-Chun Chen, Chris Brockett, Xiang Gao, Jianfeng Gao, Jingjing Liu, and Bill Dolan. 2020c. DIALOGPT: Large-scale generative pre-training for conversational response generation. In Proceedings of the 58th Annual Meeting of the Association for Computational Linguistics: System Demonstrations, pages 270-278, Online. Association for Computational Linguistics.  
+Mengjie Zhao, Tao Lin, Fei Mi, Martin Jaggi, and Hinrich Schütze. 2020. Masking as an efficient alternative to finetuning for pretrained language models.  
+Wei Zhao, Maxime Peyrard, Fei Liu, Yang Gao, Christian M. Meyer, and Steffen Eger. 2019. MoverScore: Text generation evaluating with contextualized embeddings and earth mover distance. In Proceedings of the 2019 Conference on Empirical Methods in Natural Language Processing and the 9th International Joint Conference on Natural Language Processing (EMNLP-IJCNLP), pages 563-578, Hong Kong, China. Association for Computational Linguistics.  
+Ming Zhong, Pengfei Liu, Yiran Chen, Danqing Wang, Xipeng Qiu, and Xuanjing Huang. 2020. Extractive summarization as text matching. In Proceedings of the 58th Annual Meeting of the Association for Computational Linguistics, pages 6197-6208, Online. Association for Computational Linguistics.  
+Jinhua Zhu, Yingce Xia, Lijun Wu, Di He, Tao Qin, Wengang Zhou, Houqiang Li, and Tieyan Liu. 2020. Incorporating bert into neural machine translation. In International Conference on Learning Representations.
+
+<table><tr><td></td><td>learning rate</td><td># epoch</td><td>batch size</td><td>prefix length</td></tr><tr><td colspan="5">Prefix:</td></tr><tr><td>E2E</td><td>8e-05</td><td>5</td><td>10</td><td>5</td></tr><tr><td>WebNLG</td><td>5e-05</td><td>5</td><td>5</td><td>5</td></tr><tr><td>DART</td><td>5e-05</td><td>10</td><td>5</td><td>10</td></tr><tr><td>XSUM</td><td>5e-05</td><td>30</td><td>14</td><td>100</td></tr><tr><td colspan="5">Adapter:</td></tr><tr><td>E2E (3%)</td><td>5e-05</td><td>5</td><td>5</td><td>-</td></tr><tr><td>E2E (0.1%)</td><td>8e-05</td><td>10</td><td>5</td><td></td></tr><tr><td>WebNLG (3%)</td><td>5e-05</td><td>5</td><td>5</td><td>-</td></tr><tr><td>WebNLG (0.1%)</td><td>5e-05</td><td>10</td><td>5</td><td>-</td></tr><tr><td>DART (3%)</td><td>5e-05</td><td>5</td><td>5</td><td>-</td></tr><tr><td>DART (0.1%)</td><td>8e-05</td><td>5</td><td>5</td><td>-</td></tr><tr><td colspan="5">Fine-tune:</td></tr><tr><td>E2E</td><td>5e-05</td><td>5</td><td>10</td><td>-</td></tr><tr><td>WebNLG</td><td>1e-05</td><td>10</td><td>6</td><td>-</td></tr><tr><td>DART</td><td>1e-05</td><td>10</td><td>6</td><td>-</td></tr><tr><td colspan="5">FT-top2:</td></tr><tr><td>E2E</td><td>5e-05</td><td>5</td><td>10</td><td>-</td></tr><tr><td>WebNLG</td><td>5e-05</td><td>10</td><td>9</td><td>-</td></tr><tr><td>DART</td><td>5e-05</td><td>5</td><td>5</td><td>-</td></tr></table>
+
+Table 5: Hyperparameter settings for our method and baseline methods.
+
+# A Supplementary Material
+
+# A.1 Hyperparameters
+
+In Table 5, we report the hyperparameters used to train the models documented in the experiment section.
+
+# A.2 Additional Results for Low-data Settings
+
+Figure 6 supplements the low-data performance curves in Figure 3 by plotting the relationship between training size and generation metrics for both prefix-tuning and fine-tuning.
+
+# A.3 Additional Results for the Initialization Experiment
+
+Figure 7 supplements Figure 3 by plotting additional metrics for our initialization technique §7.4. It validates that random initialization (from a uniform (0,1) distribution) significantly underperforms initializing with real words; Additionally, initializing with task-relevant words (e.g., "summarization" and "table-to-text") attains slightly better generation scores than initializing with task-irrelevant words (e.g., "elephant" and "banana").
+
+# A.4 Qualitative Examples for Extrapolation
+
+Table 6 contains qualitative examples from both seen and unseen categories in WebNLG. We find that for unseen categories, both prefix-tuning and fine-tuning tend to undergenerate (generated output do not cover full table contents) or generate untruthfully (generated output is inconsistent with
+
+table contents). In particular, prefix-tuning tends to undergenerate whereas fine-tuning tends to generate untruthfully. For seen categories, both perform fairly well in terms of coverage and truthfulness.
+
+![](images/6249464df349ff9c1e4d558d476e4547251e54bd3b7de9de7a7c7793ba750151.jpg)
+
+![](images/92ae24dd63b5bcfb0a54308eb1a0b54027ba6a5f75818d0632de4207d23e02bd.jpg)
+
+![](images/f3456b25d9774e9a10b8afa41436c0eb2dca82e59cba85fb9c4ac2a9a3832f78.jpg)
+
+![](images/70f47b0b77c4b24494384dc0d9dd748da3674200f228a0ee29a8c7a733ef5d2b.jpg)  
+Figure 6: Prefix-tuning (orange) outperforms fine-tuning (blue) in low-data regimes in addition to requiring many fewer parameters. The top three plots correspond to summarization, measured by ROUGE-1, ROUGE-2, and ROUGE-L. The bottom three plots correspond to table-to-text, measured by NIST, METEOR, and CIDEr. The x-axis is the training size and the y-axis is the evaluation metric (higher is better).
+
+![](images/d153a1b2e75a4bf600b61ce9a15891175490431eab28c0a24d631586c38a0fe7.jpg)
+
+![](images/2b0901e762135c036cc7e26c0ac6f3c24b723f5e9a16f47b4abfff2f60052135.jpg)
+
+![](images/9592470f61b33a67e8460f4155b6b5533527e0818e753783d43e2eaf246f37d0.jpg)
+
+![](images/6f9250391c44b1bea642961471f6ae6c67721e9ce2854ef593a09ebf7dee9750.jpg)
+
+![](images/970a4f0e5b19bb06fc86c387c7cd5899ebde95fef8df08abf6914a4505ef1316.jpg)  
+Figure 7: Initializing the prefix with activations of real words significantly outperforms random initialization, in a low-data setting with 100 training data.
+
+![](images/6c1b85767714ae7a74519d7616eb3de2ffa2033914bcc8fdca05b60d9357b817.jpg)
+
+<table><tr><td>Source [Unseen, Athelete]</td><td>(Al Kharaitiyat SC, club, Alaa Abdul-Zahra), (Al Khor, ground, Al Kharaitiyat SC), (Shabab Al-Ordon Club, club, Alaa Abdul-Zahra) (Amar Osim, manager, Al Kharaitiyat SC)</td></tr><tr><td>Prefix-tuning</td><td>Al Kharaitiyat SC are managed by Amar Osim and play at their ground at Al Khor. Al Kharaitiyat SC are also the club for which Alaa Abdul-Zahra is a player.</td></tr><tr><td>Fine-tuning</td><td>Alaa Abdul-Zahra plays for Al-Kharaitiyat SC and Shabab Al-Ordon Club. He also plays for Al-Khor and manages Al-Kharaitiyat SC.</td></tr><tr><td>Reference</td><td>Alaa Abdul Zahr plays for Al Kharaitiyat SC which is located at Al Khor and managed by Amar Osim. The Shabab Al-Ordon club is associated with Alaa Abdul-Zahr.</td></tr><tr><td>Source [Unseen, Transportation]</td><td>(Genoa, location, Costa Crociere), (AIDA Cruises, operator, AIDAstella), (Costa Crociere, owner, AIDAstella)</td></tr><tr><td>Prefix-tuning</td><td>AID Astella is operated by Aida Cruises and is owned by the Costa Rican tourist resort of Genoa.</td></tr><tr><td>Fine-tuning</td><td>AID Astella, operated by AIDA-Cruises, is located in Genoa and is owned by the Costa Rican government.</td></tr><tr><td>Reference</td><td>Costa Crociere is the owner of the AIDAstella and are based in Genoa. The operator of AIDAstella is AIDA Cruises.</td></tr><tr><td>Source [Unseen, Politician]</td><td>(Euro, currency, Netherlands), (Stellendam, birthPlace, Ab Klink), (Netherlands, nationality, Ab Klink)</td></tr><tr><td>Prefix-tuning</td><td>Ab Klink was born in Stellendam and is a national of the Netherlands where the currency is the Euro.</td></tr><tr><td>Fine-tuning</td><td>Ab Klink is a national of the Netherlands where the currency is the Euro. He was born in Stellendam.</td></tr><tr><td>Reference</td><td>Ab Klink was born in Stellendam in the Netherlands, where the national currency is the euro.</td></tr><tr><td>Source [Unseen, Politician]</td><td>(Robert E, Lee, commander, Battle of Salem Church), (American Civil War, isPartOfMilitaryConflict, Battle of Salem Church), (Battle of Salem Church, battles, Aaron S. Daggett)</td></tr><tr><td>Prefix-tuning</td><td>Robert E. Lee was the commander of the Battle of Salem Church which was part of the military conflict in the American Civil war.</td></tr><tr><td>Fine-tuning</td><td>The Battle of Salem Church is part of the American Civil War and was commanded by Robert E. Lee.</td></tr><tr><td>Reference</td><td>Robert E Lee was a commander in the Battle of Salem Church, which was one of the military conflicts in the American Civil War. Aaron S Daggett fought in the same battle.</td></tr><tr><td>Source [Unseen, Artist]</td><td>(Christian alternative rock, musicSubgenre, Alternative rock), (Alternative rock, genre, Andrew White (musician))</td></tr><tr><td>Prefix-tuning</td><td>Andrew White is a Christian alternative rock musician.</td></tr><tr><td>Fine-tuning</td><td>Andrew White, a Christian alternative rocker, performs.</td></tr><tr><td>Reference</td><td>The musician Andrew White&#x27;s genre is alternative rock, the genre which has the sub genre Christian alternative rock.</td></tr><tr><td>Source [Unseen, Artist]</td><td>(Hip hop music, genre, Allen Forrest), (solo singer, background, Allen Forrest)</td></tr><tr><td>Prefix-tuning</td><td>Allen Forrest is a solo singer.</td></tr><tr><td>Fine-tuning</td><td>Born in</td></tr><tr><td>Reference</td><td>Allen Forrest is a solo singer whose genre is Hip Hop music.</td></tr><tr><td>Source [Seen, ComicsCharacter]</td><td>(Americans, nationality, Ducan Rouleau), (Ducan Rouleau, creator, Baymax), (Alan Tudyk, starring, Big Hero 6 (film)), (Steven T Segle, creator, Baymax), (Big Hero 6 (film), serries, Baymax)</td></tr><tr><td>Prefix-tuning</td><td>Baymax is a character in Big Hero 6 which stars Alan Tudyk. He was created by Steven T. Seagle and the American, Duncan Rouleau.</td></tr><tr><td>Fine-tuning</td><td>Alan Tudyk stars in the film Big Hero 6 in which Baymax is a character created by Steven T. Seagle and the American, Duncan Rouleau.</td></tr><tr><td>Reference</td><td>Baymax is a character who appeared in Big Hero 6 starring Alan Tudyk. It was created by Steven T Seagle and the American, Duncan Rouleau.</td></tr><tr><td>Source [Seen, City]</td><td>(Washington, D.C., capital, United States), (White Americans, ethnicGroup, United States), (United States, country, New Jersey), (New York City, largest City, United States), (New Jersey, isPartOf, Atlantic City)</td></tr><tr><td>Prefix-tuning</td><td>Washington D.C. is the capital of the United States where the largest city is New York City and the White Americans are an ethnic group. Atlantic City, New Jersey is also part of the United States.</td></tr><tr><td>Fine-tuning</td><td>Atlantic City, New Jersey is part of New Jersey in the United States. The capital city is Washington D.C. and one of the ethnic groups is White Americans.</td></tr><tr><td>Reference</td><td>New York City (NYC) is the largest U.S. city. Atlantic City, New Jersey are also part of the United States with its capital as Washington, DC and home to White Americans.</td></tr></table>
+
+Table 6: Qualitative examples from WebNLG. The first 6 examples are from the unseen categories, labeled next to source; the last two examples are from the seen categories. For unseen categories, both prefix-tuning and fine-tuning tend to undergenerate (generated output do not cover full table contents) or generate untruthfully (generated output is inconsistent with table contents). In particular, prefix-tuning tends to undergenerate more often than generate untruthfully whereas fine-tuning tends to generate untruthfully. For seen categories, both perform fairly well in terms of coverage and truthfulness.

data/2021/2101_00xxx/2101.00204/2a8c286c-88d1-4769-975d-642826d5ce5d_content_list.json

@@ -1,3 +1,1374 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:f2d2934e721903461e7dc28a01029967bf63f4b30f1114f5593da2c0bf9d5cbf
-size 62904
+[
+    {
+        "type": "text",
+        "text": "BanglaBERT: Language Model Pretraining and Benchmarks for Low-Resource Language Understanding Evaluation in Bangla",
+        "text_level": 1,
+        "bbox": [
+            164,
+            85,
+            831,
+            124
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Abhik Bhattacharjee $^{1*}$ , Tahmid Hasan $^{1*}$ , Wasi Uddin Ahmad $^{2†}$ , Kazi Samin $^{1}$ , Md Saiful Islam $^{3}$ , Anindya Iqbal $^{1}$ , M. Sohel Rahman $^{1}$ , Rifat Shahriyar $^{1}$",
+        "bbox": [
+            174,
+            137,
+            833,
+            172
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Bangladesh University of Engineering and Technology (BUET)<sup>1</sup>, AWS AI Labs<sup>2</sup>, University of Rochester<sup>3</sup>",
+        "bbox": [
+            235,
+            174,
+            764,
+            208
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "abhik@ra.cse.buet.ac.bd, {tahmidhasan, rifat} @cse.buet.ac.bd",
+        "bbox": [
+            149,
+            212,
+            850,
+            227
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Abstract",
+        "text_level": 1,
+        "bbox": [
+            260,
+            252,
+            339,
+            267
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "In this work, we introduce BanglaBERT, a BERT-based Natural Language Understanding (NLU) model pretrained in Bangla, a widely spoken yet low-resource language in the NLP literature. To pretrain BanglaBERT, we collect 27.5 GB of Bangla pretraining data (dubbed 'Bangla2B+') by crawling 110 popular Bangla sites. We introduce two downstream task datasets on natural language inference and question answering and benchmark on four diverse NLU tasks covering text classification, sequence labeling, and span prediction. In the process, we bring them under the first-ever Bangla Language Understanding Benchmark (BLUB). BanglaBERT achieves state-of-the-art results outperforming multilingual and monolingual models. We are making the models, datasets, and a leaderboard publicly available at https://github.com/csebuetnlp/banglabert to advance Bangla NLP.",
+        "bbox": [
+            141,
+            279,
+            460,
+            577
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 Introduction",
+        "text_level": 1,
+        "bbox": [
+            114,
+            589,
+            258,
+            604
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Despite being the sixth most spoken language in the world with over 300 million native speakers constituting  $4\\%$  of the world's total population, $^{1}$  Bangla is considered a resource-scarce language. Joshi et al. (2020b) categorized Bangla in the language group that lacks efforts in labeled data collection and relies on self-supervised pretraining (Devlin et al., 2019; Radford et al., 2019; Liu et al., 2019) to boost the natural language understanding (NLU) task performances. To date, the Bangla language has been continuing to rely on fine-tuning multilingual pretrained language models (PLMs) (Ashrafi et al., 2020; Das et al., 2021; Islam et al., 2021). However, since multilingual PLMs cover a wide range of languages (Conneau and Lample, 2019; Conneau et al., 2020), they are large (have",
+        "bbox": [
+            112,
+            614,
+            489,
+            872
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "hundreds of millions of parameters) and require substantial computational resources for fine-tuning. They also tend to show degraded performance for low-resource languages (Wu and Dredze, 2020) on downstream NLU tasks. Motivated by the triumph of language-specific models (Martin et al. (2020); Polignano et al. (2019); Canete et al. (2020); Antoun et al. (2020), inter alia) over multilingual models in many other languages, in this work, we present BanglaBERT – a BERT-based (Devlin et al., 2019) Bangla NLU model pretrained on 27.5 GB data (which we name ‘Bangla2B+’) we meticulously crawled 110 popular Bangla websites to facilitate NLU applications in Bangla. Since most of the downstream task datasets for NLP applications are in the English language, to facilitate zero-shot transfer learning between English and Bangla, we additionally pretrain a model in both languages; we name the model BanglishBERT.",
+        "bbox": [
+            507,
+            252,
+            884,
+            558
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "We also introduce two datasets on Bangla Natural Language Inference (NLI) and Question Answering (QA), tasks previously unexplored in Bangla, and evaluate both pretrained models on four diverse downstream tasks on sentiment classification, NLI, named entity recognition, and QA. We bring these tasks together to establish the first-ever Bangla Language Understanding Benchmark (BLUB). We compare widely used multilingual models to BanglaBERT using BLUB and find that both models excel on all the tasks.",
+        "bbox": [
+            507,
+            560,
+            885,
+            736
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "We summarize our contributions as follows:",
+        "text_level": 1,
+        "bbox": [
+            526,
+            740,
+            855,
+            755
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "list",
+        "sub_type": "text",
+        "list_items": [
+            "1. We present two new pretrained models: BanglaBERT and BanglishBERT, and introduce new Bangla NLI and QA datasets.",
+            "2. We introduce the Bangla Language Understanding Benchmark (BLUB) and show that, in the supervised setting, BanglaBERT outperforms mBERT and XLM-R (base) by 6.8 and 4.3 BLUB scores, while in zero-shot crosslingual transfer, BanglishBERT outperforms them by 15.8 and 10.8, respectively."
+        ],
+        "bbox": [
+            522,
+            758,
+            884,
+            917
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "aside_text",
+        "text": "arXiv:2101.00204v4 [cs.CL] 10 May 2022",
+        "bbox": [
+            21,
+            300,
+            60,
+            724
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "page_footnote",
+        "text": "*These authors contributed equally to this work.",
+        "bbox": [
+            139,
+            879,
+            436,
+            892
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "page_footnote",
+        "text": "$\\dagger$  Work done while at UCLA.",
+        "bbox": [
+            139,
+            892,
+            319,
+            904
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "page_footnote",
+        "text": "1https://w.wiki/Psq",
+        "bbox": [
+            137,
+            904,
+            310,
+            917
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "3. We provide the code, models, and a leaderboard to spur future research on Bangla NLU.",
+        "bbox": [
+            127,
+            84,
+            489,
+            116
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2 BanglaBERT",
+        "text_level": 1,
+        "bbox": [
+            112,
+            128,
+            265,
+            143
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2.1 Pretraining Data",
+        "text_level": 1,
+        "bbox": [
+            112,
+            154,
+            294,
+            168
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "A high volume of good quality text data is a prerequisite for pretraining large language models. For instance, BERT (Devlin et al., 2019) is pretrained on the English Wikipedia and the Books corpus (Zhu et al., 2015) containing 3.3 billion tokens. Subsequent works like RoBERTa (Liu et al., 2019) and XLNet (Yang et al., 2019) used more extensive web-crawled data with heavy filtering and cleaning.",
+        "bbox": [
+            112,
+            174,
+            487,
+            303
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Bangla is a rather resource-constrained language in the web domain; for example, the Bangla Wikipedia dump from July 2021 is only  $650\\mathrm{MB}$ , two orders of magnitudes smaller than the English Wikipedia. As a result, we had to crawl the web extensively to collect our pretraining data. We selected 110 Bangla websites by their Amazon Alexa rankings<sup>2</sup> and the volume and quality of extractable texts by inspecting each website. The contents included encyclopedias, news, blogs, e-books, stories, social media/forums, etc.<sup>3</sup> The amount of data totaled around 35 GB.",
+        "bbox": [
+            112,
+            304,
+            487,
+            495
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "There are noisy sources of Bangla data dumps, a couple of prominent ones being OSCAR (Suárez et al., 2019) and CCNet (Wenzek et al., 2020). They contained many offensive texts; we found them infeasible to clean thoroughly. Fearing their potentially harmful impacts (Luccioni and Viviano, 2021), we opted not to use them. We further discuss ethical considerations at the end of the paper.",
+        "bbox": [
+            112,
+            497,
+            487,
+            626
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2.2 Pre-processing",
+        "text_level": 1,
+        "bbox": [
+            112,
+            637,
+            278,
+            653
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "We performed thorough dedduplication on the pretraining data, removed non-textual contents (e.g., HTML/JavaScript tags), and filtered out non-Bangla pages using a language classifier (Joulin et al., 2017). After the processing, the dataset was reduced to  $27.5\\mathrm{GB}$  in size containing  $5.25\\mathrm{M}$  documents having 306.66 words on average.",
+        "bbox": [
+            112,
+            657,
+            487,
+            769
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "We trained a Wordpiece (Wu et al., 2016) vocabulary of  $32k$  subword tokens on the resulting corpus with a 400 character alphabet, kept larger than the native Bangla alphabet to capture code-switching (Poplack, 1980) and allow romanized Bangla contents for better generalization. We limited the length of a training sample to 512 tokens",
+        "bbox": [
+            112,
+            770,
+            487,
+            883
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "and did not cross document boundaries (Liu et al., 2019) while creating a data point. After tokenization, we had 7.18M samples with an average length of 304.14 tokens and containing 2.18B tokens in total; hence we named the dataset 'Bangla2B+'.",
+        "bbox": [
+            507,
+            84,
+            882,
+            164
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2.3 Pretraining Objective",
+        "text_level": 1,
+        "bbox": [
+            507,
+            189,
+            726,
+            206
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Self-supervised pretraining objectives leverage unlabeled data. For example, BERT (Devlin et al., 2019) was pretrained with masked language modeling (MLM) and next sentence prediction (NSP). Several works built on top of this, e.g., RoBERTa (Liu et al., 2019) removed NSP and pretrained with longer sequences, SpanBERT (Joshi et al., 2020a) masked contiguous spans of tokens, while works like XLNet (Yang et al., 2019) introduced objectives like factorized language modeling.",
+        "bbox": [
+            507,
+            218,
+            884,
+            379
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "We pretrained BanglaBERT using ELECTRA (Clark et al., 2020b), pretrained with the Replaced Token Detection (RTD) objective, where a generator and a discriminator model are trained jointly. The generator is fed as input a sequence with a portion of the tokens masked (15% in our case) and is asked to predict them using the rest of the input (i.e., standard MLM). The masked tokens are then replaced by tokens sampled from the generator's output distribution for the corresponding masks, and the discriminator then has to predict whether each token is from the original sequence or not. After pretraining, the discriminator is used for fine-tuning. Clark et al. (2020b) argued that RTD back-propagates loss from all tokens of a sequence, in contrast to 15% tokens of the MLM objective, giving the model more signals to learn from. Evidently, ELECTRA achieves comparable downstream performance to RoBERTa or XLNet with only a quarter of their training time. This computational efficiency motivated us to use ELECTRA for our implementation of BanglaBERT.",
+        "bbox": [
+            507,
+            382,
+            884,
+            736
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2.4 Model Architecture & Hyperparameters",
+        "text_level": 1,
+        "bbox": [
+            507,
+            760,
+            873,
+            778
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "We pretrained the base ELECTRA model (a 12-layer Transformer encoder with 768 embedding size, 768 hidden size, 12 attention heads, 3072 feed-forward size, generator-to-discriminator ratio  $\\frac{1}{3}$ , 110M parameters) with 256 batch size for 2.5M steps on a v3-8 TPU instance on GCP. We used the Adam (Kingma and Ba, 2015) optimizer with a 2e-4 learning rate and linear warmup of 10k steps.",
+        "bbox": [
+            507,
+            790,
+            882,
+            919
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "page_footnote",
+        "text": "$^{2}$ www alexa.com/topsites/countries/BD",
+        "bbox": [
+            134,
+            890,
+            462,
+            904
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "page_footnote",
+        "text": "3The complete list can be found in the Appendix.",
+        "bbox": [
+            136,
+            904,
+            436,
+            917
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "table",
+        "img_path": "images/01794eb8bcc5c0532d9fe42b823dedf709df312c8432ca7966e6d905a03170e5.jpg",
+        "table_caption": [],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Task</td><td>Corpus</td><td>|Train|</td><td>|Dev|</td><td>|Test|</td><td>Metric</td><td>Domain</td></tr><tr><td>Sentiment Classification</td><td>SentNoB</td><td>12,575</td><td>1,567</td><td>1,567</td><td>Macro-F1</td><td>Social Media</td></tr><tr><td>Natural Language Inference</td><td>BNLI</td><td>381,449</td><td>2,419</td><td>4,895</td><td>Accuracy</td><td>Miscellaneous</td></tr><tr><td>Named Entity Recognition</td><td>MultiCoNER</td><td>14,500</td><td>800</td><td>800</td><td>Micro-F1</td><td>Miscellaneous</td></tr><tr><td>Question Answering</td><td>BQA, TyDiQA</td><td>127,771</td><td>2,502</td><td>2,504</td><td>EM/F1</td><td>Wikipedia</td></tr></table>",
+        "bbox": [
+            136,
+            80,
+            860,
+            167
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Table 1: Statistics of the Bangla Language Understanding Evaluation (BLUB) benchmark.",
+        "bbox": [
+            191,
+            175,
+            801,
+            191
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "2.5 BanglishBERT",
+        "text_level": 1,
+        "bbox": [
+            112,
+            216,
+            278,
+            231
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Often labeled data in a low-resource language for a task may not be available but be abundant in high-resource languages like English. In these scenarios, zero-shot cross-lingual transfer (Artetxe and Schwenk, 2019) provides an effective way to be still able to train a multilingual model on that task using the high-resource languages and be able to transfer to low-resource ones. To this end, we pretrained a bilingual model, named BanglishBERT, on Bangla and English together using the same set of hyperparameters mentioned earlier. We used the BERT pretraining corpus as the English data and trained a joint bilingual vocabulary (each language having  $\\sim 16\\mathrm{k}$  tokens). We upsampled the Bangla data during training to equal the participation of both languages.",
+        "bbox": [
+            112,
+            237,
+            489,
+            495
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3 The Bangla Language Understanding Benchmark (BLUB)",
+        "text_level": 1,
+        "bbox": [
+            112,
+            506,
+            473,
+            539
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Many works have studied different Bangla NLU tasks in isolation, e.g., sentiment classification (Das and Bandyopadhyay, 2010; Sharfuddin et al., 2018; Tripto and Ali, 2018), semantic textual similarity (Shajalal and Aono, 2018), parts-of-speech (PoS) tagging (Alam et al., 2016), named entity recognition (NER) (Ashrafi et al., 2020). However, Bangla NLU has not yet had a comprehensive, unified study. Motivated by the surge of NLU research brought about by benchmarks in other languages, e.g., English (Wang et al., 2018), French (Le et al., 2020), Korean (Park et al., 2021), we establish the first-ever Bangla Language Understanding Benchmark (BLUB). NLU generally comprises three types of tasks: text classification, sequence labeling, and text span prediction. Text classification tasks can further be sub-divided into single-sequence and sequence-pair classification. Therefore, we consider a total of four tasks for BLUB. For each task type, we carefully select one downstream task dataset. We emphasize the quality and open availability of the datasets while making the selection. We briefly mention them below.",
+        "bbox": [
+            112,
+            549,
+            489,
+            917
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "1. Single-Sequence Classification Sentiment classification is perhaps the most-studied Bangla NLU task, with some of the earlier works dating back over a decade (Das and Bandyopadhyay, 2010). Hence, we chose this as the single-sequence classification task. However, most Bangla sentiment classification datasets are not publicly available. We could only find two public datasets: BYSA (Tripto and Ali, 2018) and SentNoB (Islam et al., 2021). We found BYSA to have many duplications. Even worse, many duplicates had different labels. SentNoB had better quality and covered a broader set of domains, making the classification task more challenging. Hence, we opted to use the latter.",
+        "bbox": [
+            507,
+            216,
+            885,
+            441
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "2. Sequence-pair Classification In contrast to single-sequence classification, there has been a dearth of sequence-pair classification works in Bangla. We found work on semantic textual similarity (Shajalal and Aono, 2018), but the dataset is not publicly available. As such, we curated a new Bangla Natural Language Inference (BNLI) dataset for sequence-pair classification. We chose NLI as the representative task due to its fundamental importance in NLU. Given two sentences, a premise and a hypothesis as input, a model is tasked to predict whether or not the hypothesis is entailment, contradiction, or neutral to the premise. We used the same curation procedure as the XNLI (Conneau et al., 2018) dataset: we translated the MultiNLI (Williams et al., 2018) training data using the English to Bangla translation model by Hasan et al. (2020) and had the evaluation sets translated by expert human translators. Due to the possibility of the incursion of errors during automatic translation, we used the Language-Agnostic BERT Sentence Embeddings (LaBSE) (Feng et al., 2020) of the translations and original sentences to compute their similarity and discarded all sentences below a similarity threshold of 0.70. Moreover, to ensure good-quality human translation, we used similar quality assurance strategies as Guzmán et al. (2019).",
+        "bbox": [
+            507,
+            450,
+            884,
+            885
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "page_footnote",
+        "text": "4More details are presented in the ethical considerations section.",
+        "bbox": [
+            507,
+            892,
+            882,
+            917
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "table",
+        "img_path": "images/67b9500b5179f7983c1d95f0caae3f4590025ffbdb786c94ae78c6559e9c9f20.jpg",
+        "table_caption": [],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Models</td><td>|Params.|</td><td>SC</td><td>NLI</td><td>NER</td><td>QA</td><td>BLUB Score</td></tr><tr><td colspan=\"7\">Zero-shot cross-lingual transfer</td></tr><tr><td>mBERT</td><td>180M</td><td>27.05</td><td>62.22</td><td>39.27</td><td>59.01/64.18</td><td>50.35</td></tr><tr><td>XLM-R (base)</td><td>270M</td><td>42.03</td><td>72.18</td><td>45.37</td><td>55.03/61.83</td><td>55.29</td></tr><tr><td>XLM-R (large)</td><td>550M</td><td>49.49</td><td>78.13</td><td>56.48</td><td>71.13/77.70</td><td>66.59</td></tr><tr><td>BanglishBERT</td><td>110M</td><td>48.39</td><td>75.26</td><td>55.56</td><td>72.87/78.63</td><td>66.14</td></tr><tr><td colspan=\"7\">Supervised fine-tuning</td></tr><tr><td>mBERT</td><td>180M</td><td>67.59</td><td>75.13</td><td>68.97</td><td>67.12/72.64</td><td>70.29</td></tr><tr><td>XLM-R (base)</td><td>270M</td><td>69.54</td><td>78.46</td><td>73.32</td><td>68.09/74.27</td><td>72.82</td></tr><tr><td>XLM-R (large)</td><td>550M</td><td>70.97</td><td>82.40</td><td>78.39</td><td>73.15/79.06</td><td>76.79</td></tr><tr><td>IndicBERT</td><td>18M</td><td>68.41</td><td>77.11</td><td>54.13</td><td>50.84/57.47</td><td>61.59</td></tr><tr><td>sahajBERT</td><td>18M</td><td>71.12</td><td>76.92</td><td>70.94</td><td>65.48/70.69</td><td>71.03</td></tr><tr><td>BanglishBERT</td><td>110M</td><td>70.61</td><td>80.95</td><td>76.28</td><td>72.43/78.40</td><td>75.73</td></tr><tr><td>BanglaBERT</td><td>110M</td><td>72.89</td><td>82.80</td><td>77.78</td><td>72.63/79.34</td><td>77.09</td></tr></table>",
+        "bbox": [
+            117,
+            80,
+            878,
+            311
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Table 2: Performance comparison of pretrained models on different downstream tasks. Scores in bold texts have statistically significant  $(p < 0.05)$  difference from others with bootstrap sampling (Koehn, 2004).",
+        "bbox": [
+            115,
+            321,
+            880,
+            350
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3. Sequence Labeling In this task, all words of a text sequence have to be classified. Named Entity Recognition (NER) and Parts-of-Speech (PoS) tagging are two of the most prominent sequence labeling tasks. We chose the Bangla portion of SemEval 2022 MultiCoNER (Malmasi et al., 2022) dataset for BLUB.",
+        "bbox": [
+            115,
+            375,
+            485,
+            486
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "4. Span Prediction Extractive question answering is a standard choice for text span prediction. Similar to BNLI, we machine-translated the SQuAD 2.0 (Rajpurkar et al., 2018) dataset and used it as the training set (BQA). For validation and test, We used the Bangla portion of the TyDiQA $^5$  (Clark et al., 2020a) dataset. We posed the task analogous to SQuAD 2.0: presented with a text passage and a question, a model has to predict whether or not it is answerable. If answerable, the model has to find the minimal text span that answers the question.",
+        "bbox": [
+            115,
+            495,
+            485,
+            687
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "We present detailed statistics of the BLUB benchmark in Table 1.",
+        "bbox": [
+            115,
+            689,
+            484,
+            719
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "4 Experiments & Results",
+        "text_level": 1,
+        "bbox": [
+            115,
+            732,
+            346,
+            747
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Setup We fine-tuned BanglaBERT and BanglishBERT on the four downstream tasks and compared them with several multilingual models: mBERT (Devlin et al., 2019), XLM-R base and large (Conneau et al., 2020), and IndicBERT (Kakwani et al., 2020), a multilingual model for Indian languages; and sahajBERT (Diskin et al., 2021), an ALBERT-based (Lan et al., 2020) PLM for Bangla. All pre",
+        "bbox": [
+            115,
+            757,
+            485,
+            884
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "trained models were fine-tuned for 3-20 epochs with batch size 32, and the learning rate was tuned from  $\\{2\\mathrm{e} - 5,3\\mathrm{e} - 5,4\\mathrm{e} - 5,5\\mathrm{e} - 5\\}$ . The final models were selected based on the validation performances after each epoch. We performed fine-tuning with three random seeds and reported their average scores in Table 2. We reported the average performance of all tasks as the BLUB score.",
+        "bbox": [
+            512,
+            375,
+            880,
+            501
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Zero-shot Transfer We show the zero-shot cross-lingual transfer results of the multilingual models fine-tuned on the English counterpart of each dataset (SentNob has no English equivalent; hence we used the Stanford Sentiment Treebank (Socher et al., 2013) for the sentiment classification task) in Table 2. In zero-shot transfer setting, BanglishBERT achieves strong cross-lingual performance over similar-sized models and falls marginally short of XLM-R (large). This is an expected outcome since cross-lingual effectiveness depends explicitly on model size (K et al., 2020).",
+        "bbox": [
+            512,
+            518,
+            880,
+            709
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Supervised Fine-tuning In the supervised fine-tuning setup, BanglaBERT outperformed multilingual models and monolingual sahajBERT on all the tasks, achieving a BLUE score of 77.09, even coming head-to-head with XLM-R (large). On the other hand, BanglishBERT marginally lags behind BanglaBERT and XLM-R (large). BanglaBERT is not only superior in performance but also substantially compute- and memory-efficient. For instance, it may seem that sahajBERT is more efficient than BanglaBERT due to its smaller size, but it takes 2-3.5x time and 2.4-3.33x memory as BanglaBERT",
+        "bbox": [
+            512,
+            726,
+            880,
+            917
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "page_footnote",
+        "text": "5We removed the Yes/No questions from TyDiQA and subsampled the unanswerable questions to have equal proportion.",
+        "bbox": [
+            115,
+            892,
+            485,
+            917
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "to fine-tune. 6",
+        "bbox": [
+            114,
+            83,
+            220,
+            97
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "image",
+        "img_path": "images/4bde5894401536f1ca7593e449000a0f99e3c3a5344efbd2cda36c7465d2bc81.jpg",
+        "image_caption": [],
+        "image_footnote": [],
+        "bbox": [
+            117,
+            115,
+            475,
+            282
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "image",
+        "img_path": "images/56c52033755c51a5d90049b7716e50b40cbda94c5d6e4179b7b8d2acc36bb730.jpg",
+        "image_caption": [
+            "Figure 1: Sample-efficiency tests with SC and NLI."
+        ],
+        "image_footnote": [],
+        "bbox": [
+            117,
+            291,
+            475,
+            460
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Sample efficiency It is often challenging to annotate training samples in real-world scenarios, especially for low-resource languages like Bangla. So, in addition to compute- and memory-efficiency, sample-efficiency (Howard and Ruder, 2018) is another necessity of PLMs. To assess the sample efficiency of BanglaBERT, we limit the number of training samples and see how it fares against other models. We compare it with XLM-R (large) and plot their performances on the SC and NLI tasks<sup>7</sup> for different sample size in Figure 1.",
+        "bbox": [
+            112,
+            511,
+            489,
+            687
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Results show that when we have fewer number of samples  $(\\leq 1k)$ , BanglaBERT has substantially better performance (2-9% on SC and 6-10% on NLI with  $p < 0.05$ ) over XLM-R (large), making it more practically applicable for resource-scarce downstream tasks.",
+        "bbox": [
+            112,
+            688,
+            487,
+            783
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "5 Conclusion & Future Works",
+        "text_level": 1,
+        "bbox": [
+            112,
+            796,
+            393,
+            810
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Creating language-specific models is often infeasible for low-resource languages lacking ample data. Hence, researchers are compelled to use multilingual models for languages that do not have",
+        "bbox": [
+            112,
+            820,
+            489,
+            885
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "strong pretrained models. To this end, we introduced BanglaBERT and BanglishBERT, two NLU models in Bangla, a widely spoken yet low-resource language. We presented new downstream datasets on NLI and QA, and established the BLUB benchmark, setting new state-of-the-art results with BanglaBERT. In future, we will include other Bangla NLU benchmarks (e.g., dependency parsing (de Marneffe et al., 2021)) in BLUB and investigate the benefits of initializing Bangla NLG models from BanglaBERT.",
+        "bbox": [
+            507,
+            84,
+            884,
+            261
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Acknowledgements",
+        "text_level": 1,
+        "bbox": [
+            509,
+            273,
+            680,
+            288
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "We would like to thank the Research and Innovation Centre for Science and Engineering (RISE), BUET, for funding the project, and Intelligent Machines Limited and Google TensorFlow Research Cloud (TRC) Program for providing cloud support.",
+        "bbox": [
+            507,
+            298,
+            882,
+            379
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Ethical Considerations",
+        "text_level": 1,
+        "bbox": [
+            507,
+            390,
+            712,
+            405
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Dataset and Model Release The Copy Right Act,  $2000^{8}$  of Bangladesh allows reproduction and public release of copy-right materials for non-commercial research purposes. As a transformative research work, we will release BanglaBERT under a non-commercial license. Furthermore, we will release only the pretraining data for which we know the distribution will not cause any copyright infringement. The downstream task datasets can all be made publicly available under a similar non-commercial license.",
+        "bbox": [
+            505,
+            414,
+            882,
+            592
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Quality Control in Human Translation Translations were done by expert translators who provide translation services for renowned Bangla newspapers. Each translated sentence was further assessed for quality by another expert. If found to be of low quality, it was again translated by the original translator. The sample was then discarded altogether if found to be of low quality again. Fewer than 100 samples were discarded in this process. Translators were paid as per standard rates in local currencies.",
+        "bbox": [
+            507,
+            601,
+            882,
+            763
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Text Content We tried to minimize offensive texts in the pretraining data by explicitly crawling the sites where such contents would be nominal. However, we cannot guarantee that there is absolutely no objectionable content present and therefore recommend using the model carefully, especially for text generation purposes.",
+        "bbox": [
+            507,
+            771,
+            884,
+            883
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "page_footnote",
+        "text": "<sup>6</sup>We present a detailed comparison in the Appendix.",
+        "bbox": [
+            134,
+            891,
+            453,
+            904
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "page_footnote",
+        "text": "Results for the other tasks can be found in the Appendix.",
+        "bbox": [
+            136,
+            904,
+            485,
+            917
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "page_footnote",
+        "text": "<sup>8</sup>http://bdlaws.minlaw.gov.bd/act-details-846.html",
+        "bbox": [
+            507,
+            891,
+            794,
+            917
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "References",
+        "text_level": 1,
+        "bbox": [
+            115,
+            83,
+            213,
+            98
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "list",
+        "sub_type": "ref_text",
+        "list_items": [
+            "Firoj Alam, Shammur Absar Chowdhury, and Sheak Rashed Haider Noori. 2016. Bidirectional LSTMs - CRFs networks for bangla POS tagging. In 2016 19th International Conference on Computer and Information Technology (ICCIIT), pages 377-382. IEEE.",
+            "Wissam Antoun, Fady Baly, and Hazem Hajj. 2020. AraBERT: Transformer-based model for Arabic language understanding. In Proceedings of the 4th Workshop on Open-Source Arabic Corpora and Processing Tools, with a Shared Task on Offensive Language Detection, pages 9-15, Marseille, France. European Language Resource Association.",
+            "Mikel Artetxe and Holger Schwenk. 2019. Massively multilingual sentence embeddings for zero-shot cross-lingual transfer and beyond. Transactions of the Association for Computational Linguistics, 7:597-610.",
+            "I. Ashrafi, M. Mohammad, A. S. Mauree, G. M. A. Nijhum, R. Karim, N. Mohammed, and S. Mo men. 2020. Banner: A cost-sensitive contextualized model for bangla named entity recognition. IEEE Access, 8:58206-58226.",
+            "Jose Canete, Gabriel Chaperon, Rodrigo Fuentes, and Jorge Pérez. 2020. Spanish pre-trained BERT model and evaluation data. In Proceedings of the Practical ML for Developing Countries Workshop at ICLR 2020, PML4DC.",
+            "Jonathan H. Clark, Eunsol Choi, Michael Collins, Dan Garrette, Tom Kwiatkowski, Vitaly Nikolaev, and Jennimaria Palomaki. 2020a. TyDi QA: A benchmark for information-seeking question answering in typologically diverse languages. Transactions of the Association for Computational Linguistics, 8:454-470.",
+            "Kevin Clark, Minh-Thang Luong, Quoc V Le, and Christopher D Manning. 2020b. ELECTRA: pretraining text encoders as discriminators rather than generators. In 8th International Conference on Learning Representations, ICLR 2020, April, 2020, Online.",
+            "Alexis Conneau, Kartikay Khandelwal, Naman Goyal, Vishrav Chaudhary, Guillaume Wenzek, Francisco Guzmán, Edouard Grave, Myle Ott, Luke Zettle-moyer, and Veselin Stoyanov. 2020. Unsupervised cross-lingual representation learning at scale. In Proceedings of the 58th Annual Meeting of the Association for Computational Linguistics, pages 8440-8451, Online. Association for Computational Linguistics.",
+            "Alexis Conneau and Guillaume Lample. 2019. Cross-lingual language model pretraining. In Advances in Neural Information Processing Systems, volume 32, pages 7059–7069. Curran Associates, Inc."
+        ],
+        "bbox": [
+            115,
+            108,
+            489,
+            917
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "list",
+        "sub_type": "ref_text",
+        "list_items": [
+            "Alexis Conneau, Rudy Rinott, Guillaume Lample, Adina Williams, Samuel Bowman, Holger Schwenk, and Veselin Stoyanov. 2018. XNLI: Evaluating cross-lingual sentence representations. In Proceedings of the 2018 Conference on Empirical Methods in Natural Language Processing, pages 2475-2485, Brussels, Belgium. Association for Computational Linguistics.",
+            "Amitava Das and Sivaji Bandyopadhyay. 2010. Phrase-level polarity identification for bangla. Int. J. Comput. Linguist. Appl.(IJCLA), 1(1-2):169-182.",
+            "Avishek Das, Omar Sharif, Mohammed Moshiul Hoque, and Iqbal H. Sarker. 2021. Emotion classification in a resource constrained language using transformer-based approach. In Proceedings of the 2021 Conference of the North American Chapter of the Association for Computational Linguistics: Student Research Workshop, pages 150-158, Online. Association for Computational Linguistics.",
+            "Marie-Catherine de Marneffe, Christopher D. Manning, Joakim Nivre, and Daniel Zeman. 2021. Universal Dependencies. Computational Linguistics, 47(2):255-308.",
+            "Jacob Devlin, Ming-Wei Chang, Kenton Lee, and Kristina Toutanova. 2019. BERT: Pre-training of deep bidirectional transformers for language understanding. In Proceedings of the 2019 Conference of the North American Chapter of the Association for Computational Linguistics: Human Language Technologies, Volume 1 (Long and Short Papers), pages 4171-4186, Minneapolis, Minnesota. Association for Computational Linguistics.",
+            "Michael Diskin, Alexey Bukhtiyarov, Max Ryabinin, Lucile Saulnier, Quentin Lhoest, Anton Sinitsin, Dmitry Popov, Dmitry Pyrkin, Maxim Kashirin, Alexander Borzunov, Albert Villanova del Moral, Denis Mazur, Ilia Kobelev, Yacine Jernite, Thomas Wolf, and Gennady Pekhimenko. 2021. Distributed deep learning in open collaborations. arXiv:2106.10207.",
+            "Fangxiaoyu Feng, Yinfei Yang, Daniel Cer, Naveen Arivazhagan, and Wei Wang. 2020. Language-agnostic bert sentence embedding. arXiv:2007.01852.",
+            "Francisco Guzmán, Peng-Jen Chen, Myle Ott, Juan Pino, Guillaume Lample, Philipp Koehn, Vishrav Chaudhary, and Marc'Aurelio Ranzato. 2019. The FLORES evaluation datasets for low-resource machine translation: Nepali-English and Sinhala-English. In Proceedings of the 2019 Conference on Empirical Methods in Natural Language Processing and the 9th International Joint Conference on Natural Language Processing (EMNLP-IJCNLP), pages 6098-6111, Hong Kong, China. Association for Computational Linguistics.",
+            "Tahmid Hasan, Abhik Bhattacharjee, Kazi Samin, Musum Hasan, Madhusudan Basak, M. Sohel Rahman,"
+        ],
+        "bbox": [
+            510,
+            85,
+            884,
+            917
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "list",
+        "sub_type": "ref_text",
+        "list_items": [
+            "and Rifat Shahriyar. 2020. Not low-resource anymore: Aligner ensembling, batch filtering, and new datasets for Bengali-English machine translation. In Proceedings of the 2020 Conference on Empirical Methods in Natural Language Processing (EMNLP), pages 2612–2623, Online. Association for Computational Linguistics.",
+            "Jeremy Howard and Sebastian Ruder. 2018. Universal language model fine-tuning for text classification. In Proceedings of the 56th Annual Meeting of the Association for Computational Linguistics (Volume 1: Long Papers), pages 328-339, Melbourne, Australia. Association for Computational Linguistics.",
+            "Khondoker Ittehadul Islam, Sadipta Kar, Md Saiful Islam, and Mohammad Ruhul Amin. 2021. SentNoB: A dataset for analysing sentiment on noisy Bangla texts. In Findings of the Association for Computational Linguistics: EMNLP 2021, pages 3265-3271, Punta Cana, Dominican Republic. Association for Computational Linguistics.",
+            "Mandar Joshi, Danqi Chen, Yinhan Liu, Daniel S. Weld, Luke Zettlemoyer, and Omer Levy. 2020a. SpanBERT: Improving pre-training by representing and predicting spans. Transactions of the Association for Computational Linguistics, 8:64-77.",
+            "Pratik Joshi, Sebastin Santy, Amar Budhiraja, Kalika Bali, and Monojit Choudhury. 2020b. The state and fate of linguistic diversity and inclusion in the NLP world. In Proceedings of the 58th Annual Meeting of the Association for Computational Linguistics, pages 6282-6293, Online. Association for Computational Linguistics.",
+            "Armand Joulin, Edouard Grave, Piotr Bojanowski, and Tomas Mikolov. 2017. Bag of tricks for efficient text classification. In Proceedings of the 15th Conference of the European Chapter of the Association for Computational Linguistics: Volume 2, Short Papers, pages 427-431, Valencia, Spain. Association for Computational Linguistics.",
+            "Karthikeyan K, Zihan Wang, Stephen Mayhew, and Dan Roth. 2020. Cross-lingual ability of multilingual bert: An empirical study. In 8th International Conference on Learning Representations, ICLR 2020, April, 2020, Online.",
+            "Divyanshu Kakwani, Anoop Kunchukuttan, Satish Golla, Gokul N.C., Avik Bhattacharyya, Mitesh M. Khapra, and Pratyush Kumar. 2020. IndicNLPSuite: Monolingual corpora, evaluation benchmarks and pre-trained multilingual language models for Indian languages. In Findings of the Association for Computational Linguistics: EMNLP 2020, pages 4948-4961, Online. Association for Computational Linguistics.",
+            "Diederik P. Kingma and Jimmy Ba. 2015. Adam: A method for stochastic optimization. In 3rd International Conference on Learning Representations, ICLR 2015, San Diego, CA, USA, May 7-9, 2015."
+        ],
+        "bbox": [
+            115,
+            85,
+            489,
+            917
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "list",
+        "sub_type": "ref_text",
+        "list_items": [
+            "Philipp Koehn. 2004. Statistical significance tests for machine translation evaluation. In Proceedings of the 2004 Conference on Empirical Methods in Natural Language Processing, pages 388-395, Barcelona, Spain. Association for Computational Linguistics.",
+            "Zhenzhong Lan, Mingda Chen, Sebastian Goodman, Kevin Gimpel, Piyush Sharma, and Radu Soricut. 2020. Albert: A lite bert for self-supervised learning of language representations. In 8th International Conference on Learning Representations, ICLR 2020, April, 2020, Online.",
+            "Hang Le, Loic Vial, Jibril Frej, Vincent Segonne, Maximin Coavoux, Benjamin Lecouteux, Alexandre Allauzen, Benoit Crabbé, Laurent Besacier, and Didier Schwab. 2020. Flaubert: Unsupervised language model pre-training for french. In Proceedings of The 12th Language Resources and Evaluation Conference, pages 2479-2490, Marseille, France. European Language Resources Association.",
+            "Yinhan Liu, Myle Ott, Naman Goyal, Jingfei Du, Mandar Joshi, Danqi Chen, Omer Levy, Mike Lewis, Luke Zettlemoyer, and Veselin Stoyanov. 2019. Roberta: A robustly optimized bert pretraining approach. arXiv:1907.11692.",
+            "Alexandra Luccioni and Joseph Viviano. 2021. What's in the box? an analysis of undesirable content in the Common Crawl corpus. In Proceedings of the 59th Annual Meeting of the Association for Computational Linguistics and the 11th International Joint Conference on Natural Language Processing (Volume 2: Short Papers), pages 182-189, Online. Association for Computational Linguistics.",
+            "Shervin Malmasi, Anjie Fang, Besnik Fetahu, Sudipta Kar, and Oleg Rokhlenko. 2022. MultiCoNER: a Large-scale Multilingual dataset for Complex Named Entity Recognition.",
+            "Louis Martin, Benjamin Muller, Pedro Javier Ortiz Suárez, Yoann Dupont, Laurent Romary, Éric de la Clergerie, Djamé Seddah, and Benoit Sagot. 2020. CamemBERT: a tasty French language model. In Proceedings of the 58th Annual Meeting of the Association for Computational Linguistics, pages 7203-7219, Online. Association for Computational Linguistics.",
+            "Sungjoon Park, Jihyung Moon, Sungdong Kim, Won Ik Cho, Ji Yoon Han, Jangwon Park, Chisung Song, Junseong Kim, Youngsook Song, Taehwan Oh, Joohong Lee, Juhyun Oh, Sungwon Lyu, Younghoon Jeong, Inkwon Lee, Sangwoo Seo, Dongjun Lee, Hyunwoo Kim, Myeonghwa Lee, Seongbo Jang, Seungwon Do, Sunkyoung Kim, Kyungtae Lim, Jongwon Lee, Kyumin Park, Jamin Shin, Seonghyun Kim, Lucy Park, Alice Oh, JungWoo Ha, and Kyunghyun Cho. 2021. KLUE: Korean language understanding evaluation. In Thirty-fifth Conference on Neural Information Processing Systems Datasets and Benchmarks Track (Round 2)."
+        ],
+        "bbox": [
+            510,
+            85,
+            884,
+            917
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "list",
+        "sub_type": "ref_text",
+        "list_items": [
+            "Marco Polignano, Pierpaolo Basile, Marco de Gemmis, Giovanni Semeraro, and Valerio Basile. 2019. *Alberto: Italian BERT language understanding model for NLP challenging tasks based on tweets*. In *Proceedings of the Sixth Italian Conference on Computational Linguistics*, Bari, Italy, November 13-15, 2019, CEUR Workshop Proceedings.",
+            "Shana Poplack. 1980. Sometimes I'll start a sentence in Spanish Y TERMINO EN ESPANOL: toward a typology of code-switching. Linguistics, 18(7-8):581-618.",
+            "Alec Radford, Jeffrey Wu, Rewon Child, David Luan, Dario Amodei, and Ilya Sutskever. 2019. Language models are unsupervised multitask learners. OpenAI blog, 1(8).",
+            "Pranav Rajpurkar, Robin Jia, and Percy Liang. 2018. Know what you don't know: Unanswerable questions for SQuAD. In Proceedings of the 56th Annual Meeting of the Association for Computational Linguistics (Volume 2: Short Papers), pages 784-789, Melbourne, Australia. Association for Computational Linguistics.",
+            "Md Shajalal and Masaki Aono. 2018. Semantic textual similarity in Bengali text. In 2018 International Conference on Bangla Speech and Language Processing (ICBSLP), pages 1-5. IEEE.",
+            "Abdullah Aziz Sharfuddin, Md Nafis Tihami, and Md Saiful Islam. 2018. A deep recurrent neural network with bilstm model for sentiment classification. In 2018 International Conference on Bangla Speech and Language Processing (ICBSLP), pages 1-4. IEEE.",
+            "Richard Socher, Alex Perelygin, Jean Wu, Jason Chuang, Christopher D. Manning, Andrew Ng, and Christopher Potts. 2013. Recursive deep models for semantic compositionality over a sentiment treebank. In Proceedings of the 2013 Conference on Empirical Methods in Natural Language Processing, pages 1631-1642, Seattle, Washington, USA. Association for Computational Linguistics.",
+            "Pedro Javier Ortiz Suárez, Benoit Sagot, and Laurent Romary. 2019. Asynchronous Pipeline for Processing Huge Corpora on Medium to Low Resource Infrastructures. In 7th Workshop on the Challenges in the Management of Large Corpora (CMLC-7), Cardiff, United Kingdom. Leibniz-Institut für Deutsche Sprache.",
+            "Nafis Irtiza Tripto and Mohammed Eunus Ali. 2018. Detecting multilabel sentiment and emotions from bangla youtube comments. In 2018 International Conference on Bangla Speech and Language Processing (ICBSLP), pages 1-6. IEEE.",
+            "Alex Wang, Amanpreet Singh, Julian Michael, Felix Hill, Omer Levy, and Samuel Bowman. 2018."
+        ],
+        "bbox": [
+            115,
+            85,
+            489,
+            917
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "list",
+        "sub_type": "ref_text",
+        "list_items": [
+            "GLUE: A multi-task benchmark and analysis platform for natural language understanding. In Proceedings of the 2018 EMNLP Workshop BlackboxNLP: Analyzing and Interpreting Neural Networks for NLP, pages 353-355, Brussels, Belgium. Association for Computational Linguistics.",
+            "Guillaume Wenzek, Marie-Anne Lachaux, Alexis Conneau, Vishrav Chaudhary, Francisco Guzmán, Armand Joulin, and Edouard Grave. 2020. CCNet: Extracting high quality monolingual datasets from web crawl data. In Proceedings of the 12th Language Resources and Evaluation Conference, pages 4003-4012, Marseille, France. European Language Resources Association.",
+            "Adina Williams, Nikita Nangia, and Samuel Bowman. 2018. A broad-coverage challenge corpus for sentence understanding through inference. In Proceedings of the 2018 Conference of the North American Chapter of the Association for Computational Linguistics: Human Language Technologies, Volume 1 (Long Papers), pages 1112-1122, New Orleans, Louisiana. Association for Computational Linguistics.",
+            "Shijie Wu and Mark Dredze. 2020. Are all languages created equal in multilingual BERT? In Proceedings of the 5th Workshop on Representation Learning for NLP, pages 120-130, Online. Association for Computational Linguistics.",
+            "Yonghui Wu, Mike Schuster, Zhifeng Chen, Quoc V Le, Mohammad Norouzi, Wolfgang Macherey, Maxim Krikun, Yuan Cao, Qin Gao, Klaus Macherey, et al. 2016. Google's neural machine translation system: Bridging the gap between human and machine translation. arXiv:1609.08144.",
+            "Zhilin Yang, Zihang Dai, Yiming Yang, Jaime Carbonell, Russ R Salakhutdinov, and Quoc V Le. 2019. Xlnet: Generalized autoregressive pretraining for language understanding. In Advances in Neural Information Processing Systems, volume 32, pages 5753-5763. Curran Associates, Inc.",
+            "Yukun Zhu, Ryan Kiros, Rich Zemel, Ruslan Salakhutdinov, Raquel Urtasun, Antonio Torralba, and Sanja Fidler. 2015. Aligning books and movies: Towards story-like visual explanations by watching movies and reading books. In Proceedings of the 2015 IEEE International Conference on Computer Vision (ICCV), ICCV '15, page 19-27, USA. IEEE Computer Society."
+        ],
+        "bbox": [
+            510,
+            85,
+            882,
+            775
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Appendix",
+        "text_level": 1,
+        "bbox": [
+            115,
+            84,
+            203,
+            99
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Pretraining Data Sources",
+        "text_level": 1,
+        "bbox": [
+            115,
+            109,
+            317,
+            124
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "We used the following sites for data collection. We categorize the sites into six types:",
+        "bbox": [
+            112,
+            130,
+            485,
+            162
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Encyclopedia:",
+        "text_level": 1,
+        "bbox": [
+            115,
+            178,
+            228,
+            193
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "list",
+        "sub_type": "text",
+        "list_items": [
+            "- bn.banglapedia.org",
+            "- bn.wikipedia.org",
+            "- songgramernotepad.com"
+        ],
+        "bbox": [
+            137,
+            206,
+            337,
+            250
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "News:",
+        "text_level": 1,
+        "bbox": [
+            115,
+            263,
+            166,
+            275
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "list",
+        "sub_type": "text",
+        "list_items": [
+            "- anandabazar.com",
+            "- arthoniteerkagoj.com",
+            "- bangla.24livenewpaper.com",
+            "- bangla.bdnews24.com",
+            "- bangla.dhakatribune.com",
+            "- bangla.hindustantimes.com",
+            "- bangladeshershkela.com",
+            "- banglanews24.com",
+            "- banglatribune.com",
+            "-bbc.com",
+            "- bd-journal.com",
+            "- bd-pratidin.com",
+            "- bd24live.com",
+            "- bengali.indianexpress.com",
+            "bigganprojukti.com",
+            "- bonikbarta.net",
+            "- chakarianews.com",
+            "- channelonline.com",
+            "- ctgtimes.com",
+            "- ctn24.com",
+            "daily-bangladesh.com",
+            "dailyagnishikha.com",
+            "- dainikazadi.net",
+            "-dainikdinkal.net",
+            "dailyfulki.com",
+            "dailyinqilab.com",
+            "- dailynayadiganta.com",
+            "dailysangram.com",
+            "dailysylhet.com",
+            "dainikamadershomoy.com",
+            "dainikshiksha.com",
+            "- dhakardak-bd.com",
+            "- dmpnews.org",
+            "dw.com",
+            "eisamay.indiatimes.com",
+            "- ittefaq.com.bd",
+            "jagonews24.com",
+            "- jugantor.com",
+            "- kalerkantho.com",
+            "- manobkantha.com.bd",
+            "- mzamin.com",
+            "- ntvbd.com",
+            "- onnodristy.com"
+        ],
+        "bbox": [
+            137,
+            291,
+            366,
+            917
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "list",
+        "sub_type": "text",
+        "list_items": [
+            "- pavilion.com.bd",
+            "- prothomalo.com",
+            "protidinersangbad.com",
+            "- risingbd.com",
+            "- rtvonline.com",
+            "samakal.com",
+            "- sangbadpratidin.in",
+            "- somoyerkonthosor.com",
+            "somoynews.tv",
+            "-tbsnews.net",
+            "- teknfnews.com",
+            "- thedailystar.net",
+            "- voabangla.com",
+            "- zeenews.india.com",
+            "- zoombangla.com"
+        ],
+        "bbox": [
+            532,
+            84,
+            722,
+            306
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Blogs:",
+        "text_level": 1,
+        "bbox": [
+            510,
+            319,
+            563,
+            335
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "list",
+        "sub_type": "text",
+        "list_items": [
+            "- amrabondhu.com",
+            "- banglablog.in",
+            "bigganblog.org",
+            "biggani.org",
+            "bigyan.org.in",
+            "- bishorgo.com",
+            "- cadetcollegeblog.com",
+            "- choturmatrik.com",
+            "- horoppa.wordpress.com",
+            "muktangon.blogspot.com",
+            "- roar.media/bangla",
+            "- sachalayatan.com",
+            "- shodalap.org",
+            "- shopnobaz.net",
+            "somewhereinblog.net",
+            "- subeen.com",
+            "tunerpage.com",
+            "tutobd.com"
+        ],
+        "bbox": [
+            532,
+            348,
+            726,
+            612
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "E-books/Stories:",
+        "text_level": 1,
+        "bbox": [
+            510,
+            627,
+            643,
+            640
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "list",
+        "sub_type": "text",
+        "list_items": [
+            "- banglaepub.github.io",
+            "- bengali.pratilipi.com",
+            "- bn.wikisource.org",
+            "ebangalibrary.com",
+            "- eboipotro.github.io",
+            "- golpokobita.com",
+            "- kaliokalam.com",
+            "- shirisherdalpala.net",
+            "- tagoreweb.in"
+        ],
+        "bbox": [
+            532,
+            655,
+            704,
+            788
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Social Media/Forums:",
+        "text_level": 1,
+        "bbox": [
+            510,
+            801,
+            685,
+            816
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "list",
+        "sub_type": "text",
+        "list_items": [
+            "- banglacricket.com",
+            "- bn.globalvoices.org",
+            "- helpfulhub.com",
+            "- nirbik.com",
+            "- pchelplinebd.com",
+            "- techtunes.io"
+        ],
+        "bbox": [
+            532,
+            829,
+            694,
+            917
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Miscellaneous:",
+        "text_level": 1,
+        "bbox": [
+            114,
+            84,
+            235,
+            98
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "list",
+        "sub_type": "text",
+        "list_items": [
+            "- banglasonglyric.com",
+            "- bdlaws.minlaw.gov.bd",
+            "bdup24.com",
+            "- bengalisongslyrics.com",
+            "dakghar.org",
+            "-gdn8.com",
+            "- gunijan.org.bd",
+            "hwr.org",
+            "- jakir.me",
+            "- jhankarmahbub.com",
+            "- JW.org",
+            "- lyricsbangla.com",
+            "- neonaloy.com",
+            "porjotonlipi.com",
+            "sasthabangla.com",
+            "tanzil.net"
+        ],
+        "bbox": [
+            137,
+            108,
+            327,
+            325
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "We wrote custom crawlers for each site above (except the Wikipedia dumps).",
+        "bbox": [
+            112,
+            334,
+            485,
+            366
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Additional Sample Efficiency Tests",
+        "text_level": 1,
+        "bbox": [
+            114,
+            375,
+            391,
+            391
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "We plot the sample efficiency results of the NER and QA tasks in Figure 2.",
+        "bbox": [
+            112,
+            395,
+            485,
+            428
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "image",
+        "img_path": "images/d8d83f68b7919cddb400e3d3977ea61eb24124d0972420eb239aafffeb81cc35.jpg",
+        "image_caption": [],
+        "image_footnote": [],
+        "bbox": [
+            114,
+            445,
+            478,
+            618
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "image",
+        "img_path": "images/12709fdf4e271e916ce9554b2f39fd3a54fccbbaa24db743ed04560a8e061009.jpg",
+        "image_caption": [
+            "Figure 2: Sample-efficiency tests with NER and QA."
+        ],
+        "image_footnote": [],
+        "bbox": [
+            114,
+            627,
+            478,
+            797
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Similar results are also observed here for the NER task, where BanglaBERT is more sample-efficient when we have  $\\leq 1k$  training samples. In the QA task however, both models have identical performance for all sample counts.",
+        "bbox": [
+            112,
+            839,
+            487,
+            917
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Compute and Memory Efficiency Tests",
+        "text_level": 1,
+        "bbox": [
+            509,
+            84,
+            818,
+            99
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "To validate that BanglaBERT is more efficient in terms of memory and compute, we measured each model's training time and memory usage during the fine-tuning of each task. All tests were done on a desktop machine with an 8-core Intel Core-i7 11700k CPU and NVIDIA RTX 3090 GPU. We used the same batch size, gradient accumulation steps, and sequence length for all models and tasks for a fair comparison. We use relative time and memory (GPU VRAM) usage considering those of BanglaBERT as units. The results are shown in Table 3. (We mention the upper and lower values of the different tasks for each model)",
+        "bbox": [
+            507,
+            105,
+            882,
+            313
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "table",
+        "img_path": "images/0164411f9ba6f2783d560307fd516eb8278d70f10a7e6daf7474396e9d4b44e8.jpg",
+        "table_caption": [],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Model</td><td>Time</td><td>Memory Usage</td></tr><tr><td>mBERT</td><td>1.14x-1.92x</td><td>1.12x-2.04x</td></tr><tr><td>XLM-R (base)</td><td>1.29-1.81x</td><td>1.04-1.63x</td></tr><tr><td>XLM-R (large)</td><td>3.81-4.49x</td><td>4.44-5.55x</td></tr><tr><td>SahajBERT</td><td>2.40-3.33x</td><td>2.07-3.54x</td></tr><tr><td>BanglaBERT</td><td>1.00x</td><td>1.00x</td></tr></table>",
+        "bbox": [
+            510,
+            324,
+            877,
+            420
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Table 3: Compute and memory efficiency tests",
+        "bbox": [
+            536,
+            431,
+            853,
+            445
+        ],
+        "page_idx": 9
+    }
+]

data/2021/2101_00xxx/2101.00204/full.md

@@ -1,3 +1,335 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:b0eaba4ca0e36d32e1cfc4e641f2ee944636fd365854ac7ec445c8a838355606
-size 40224
+# BanglaBERT: Language Model Pretraining and Benchmarks for Low-Resource Language Understanding Evaluation in Bangla
+
+Abhik Bhattacharjee $^{1*}$ , Tahmid Hasan $^{1*}$ , Wasi Uddin Ahmad $^{2†}$ , Kazi Samin $^{1}$ , Md Saiful Islam $^{3}$ , Anindya Iqbal $^{1}$ , M. Sohel Rahman $^{1}$ , Rifat Shahriyar $^{1}$
+
+Bangladesh University of Engineering and Technology (BUET)<sup>1</sup>, AWS AI Labs<sup>2</sup>, University of Rochester<sup>3</sup>
+
+abhik@ra.cse.buet.ac.bd, {tahmidhasan, rifat} @cse.buet.ac.bd
+
+# Abstract
+
+In this work, we introduce BanglaBERT, a BERT-based Natural Language Understanding (NLU) model pretrained in Bangla, a widely spoken yet low-resource language in the NLP literature. To pretrain BanglaBERT, we collect 27.5 GB of Bangla pretraining data (dubbed 'Bangla2B+') by crawling 110 popular Bangla sites. We introduce two downstream task datasets on natural language inference and question answering and benchmark on four diverse NLU tasks covering text classification, sequence labeling, and span prediction. In the process, we bring them under the first-ever Bangla Language Understanding Benchmark (BLUB). BanglaBERT achieves state-of-the-art results outperforming multilingual and monolingual models. We are making the models, datasets, and a leaderboard publicly available at https://github.com/csebuetnlp/banglabert to advance Bangla NLP.
+
+# 1 Introduction
+
+Despite being the sixth most spoken language in the world with over 300 million native speakers constituting  $4\%$  of the world's total population, $^{1}$  Bangla is considered a resource-scarce language. Joshi et al. (2020b) categorized Bangla in the language group that lacks efforts in labeled data collection and relies on self-supervised pretraining (Devlin et al., 2019; Radford et al., 2019; Liu et al., 2019) to boost the natural language understanding (NLU) task performances. To date, the Bangla language has been continuing to rely on fine-tuning multilingual pretrained language models (PLMs) (Ashrafi et al., 2020; Das et al., 2021; Islam et al., 2021). However, since multilingual PLMs cover a wide range of languages (Conneau and Lample, 2019; Conneau et al., 2020), they are large (have
+
+hundreds of millions of parameters) and require substantial computational resources for fine-tuning. They also tend to show degraded performance for low-resource languages (Wu and Dredze, 2020) on downstream NLU tasks. Motivated by the triumph of language-specific models (Martin et al. (2020); Polignano et al. (2019); Canete et al. (2020); Antoun et al. (2020), inter alia) over multilingual models in many other languages, in this work, we present BanglaBERT – a BERT-based (Devlin et al., 2019) Bangla NLU model pretrained on 27.5 GB data (which we name ‘Bangla2B+’) we meticulously crawled 110 popular Bangla websites to facilitate NLU applications in Bangla. Since most of the downstream task datasets for NLP applications are in the English language, to facilitate zero-shot transfer learning between English and Bangla, we additionally pretrain a model in both languages; we name the model BanglishBERT.
+
+We also introduce two datasets on Bangla Natural Language Inference (NLI) and Question Answering (QA), tasks previously unexplored in Bangla, and evaluate both pretrained models on four diverse downstream tasks on sentiment classification, NLI, named entity recognition, and QA. We bring these tasks together to establish the first-ever Bangla Language Understanding Benchmark (BLUB). We compare widely used multilingual models to BanglaBERT using BLUB and find that both models excel on all the tasks.
+
+# We summarize our contributions as follows:
+
+1. We present two new pretrained models: BanglaBERT and BanglishBERT, and introduce new Bangla NLI and QA datasets.  
+2. We introduce the Bangla Language Understanding Benchmark (BLUB) and show that, in the supervised setting, BanglaBERT outperforms mBERT and XLM-R (base) by 6.8 and 4.3 BLUB scores, while in zero-shot crosslingual transfer, BanglishBERT outperforms them by 15.8 and 10.8, respectively.
+
+3. We provide the code, models, and a leaderboard to spur future research on Bangla NLU.
+
+# 2 BanglaBERT
+
+# 2.1 Pretraining Data
+
+A high volume of good quality text data is a prerequisite for pretraining large language models. For instance, BERT (Devlin et al., 2019) is pretrained on the English Wikipedia and the Books corpus (Zhu et al., 2015) containing 3.3 billion tokens. Subsequent works like RoBERTa (Liu et al., 2019) and XLNet (Yang et al., 2019) used more extensive web-crawled data with heavy filtering and cleaning.
+
+Bangla is a rather resource-constrained language in the web domain; for example, the Bangla Wikipedia dump from July 2021 is only  $650\mathrm{MB}$ , two orders of magnitudes smaller than the English Wikipedia. As a result, we had to crawl the web extensively to collect our pretraining data. We selected 110 Bangla websites by their Amazon Alexa rankings<sup>2</sup> and the volume and quality of extractable texts by inspecting each website. The contents included encyclopedias, news, blogs, e-books, stories, social media/forums, etc.<sup>3</sup> The amount of data totaled around 35 GB.
+
+There are noisy sources of Bangla data dumps, a couple of prominent ones being OSCAR (Suárez et al., 2019) and CCNet (Wenzek et al., 2020). They contained many offensive texts; we found them infeasible to clean thoroughly. Fearing their potentially harmful impacts (Luccioni and Viviano, 2021), we opted not to use them. We further discuss ethical considerations at the end of the paper.
+
+# 2.2 Pre-processing
+
+We performed thorough dedduplication on the pretraining data, removed non-textual contents (e.g., HTML/JavaScript tags), and filtered out non-Bangla pages using a language classifier (Joulin et al., 2017). After the processing, the dataset was reduced to  $27.5\mathrm{GB}$  in size containing  $5.25\mathrm{M}$  documents having 306.66 words on average.
+
+We trained a Wordpiece (Wu et al., 2016) vocabulary of  $32k$  subword tokens on the resulting corpus with a 400 character alphabet, kept larger than the native Bangla alphabet to capture code-switching (Poplack, 1980) and allow romanized Bangla contents for better generalization. We limited the length of a training sample to 512 tokens
+
+and did not cross document boundaries (Liu et al., 2019) while creating a data point. After tokenization, we had 7.18M samples with an average length of 304.14 tokens and containing 2.18B tokens in total; hence we named the dataset 'Bangla2B+'.
+
+# 2.3 Pretraining Objective
+
+Self-supervised pretraining objectives leverage unlabeled data. For example, BERT (Devlin et al., 2019) was pretrained with masked language modeling (MLM) and next sentence prediction (NSP). Several works built on top of this, e.g., RoBERTa (Liu et al., 2019) removed NSP and pretrained with longer sequences, SpanBERT (Joshi et al., 2020a) masked contiguous spans of tokens, while works like XLNet (Yang et al., 2019) introduced objectives like factorized language modeling.
+
+We pretrained BanglaBERT using ELECTRA (Clark et al., 2020b), pretrained with the Replaced Token Detection (RTD) objective, where a generator and a discriminator model are trained jointly. The generator is fed as input a sequence with a portion of the tokens masked (15% in our case) and is asked to predict them using the rest of the input (i.e., standard MLM). The masked tokens are then replaced by tokens sampled from the generator's output distribution for the corresponding masks, and the discriminator then has to predict whether each token is from the original sequence or not. After pretraining, the discriminator is used for fine-tuning. Clark et al. (2020b) argued that RTD back-propagates loss from all tokens of a sequence, in contrast to 15% tokens of the MLM objective, giving the model more signals to learn from. Evidently, ELECTRA achieves comparable downstream performance to RoBERTa or XLNet with only a quarter of their training time. This computational efficiency motivated us to use ELECTRA for our implementation of BanglaBERT.
+
+# 2.4 Model Architecture & Hyperparameters
+
+We pretrained the base ELECTRA model (a 12-layer Transformer encoder with 768 embedding size, 768 hidden size, 12 attention heads, 3072 feed-forward size, generator-to-discriminator ratio  $\frac{1}{3}$ , 110M parameters) with 256 batch size for 2.5M steps on a v3-8 TPU instance on GCP. We used the Adam (Kingma and Ba, 2015) optimizer with a 2e-4 learning rate and linear warmup of 10k steps.
+
+<table><tr><td>Task</td><td>Corpus</td><td>|Train|</td><td>|Dev|</td><td>|Test|</td><td>Metric</td><td>Domain</td></tr><tr><td>Sentiment Classification</td><td>SentNoB</td><td>12,575</td><td>1,567</td><td>1,567</td><td>Macro-F1</td><td>Social Media</td></tr><tr><td>Natural Language Inference</td><td>BNLI</td><td>381,449</td><td>2,419</td><td>4,895</td><td>Accuracy</td><td>Miscellaneous</td></tr><tr><td>Named Entity Recognition</td><td>MultiCoNER</td><td>14,500</td><td>800</td><td>800</td><td>Micro-F1</td><td>Miscellaneous</td></tr><tr><td>Question Answering</td><td>BQA, TyDiQA</td><td>127,771</td><td>2,502</td><td>2,504</td><td>EM/F1</td><td>Wikipedia</td></tr></table>
+
+Table 1: Statistics of the Bangla Language Understanding Evaluation (BLUB) benchmark.
+
+# 2.5 BanglishBERT
+
+Often labeled data in a low-resource language for a task may not be available but be abundant in high-resource languages like English. In these scenarios, zero-shot cross-lingual transfer (Artetxe and Schwenk, 2019) provides an effective way to be still able to train a multilingual model on that task using the high-resource languages and be able to transfer to low-resource ones. To this end, we pretrained a bilingual model, named BanglishBERT, on Bangla and English together using the same set of hyperparameters mentioned earlier. We used the BERT pretraining corpus as the English data and trained a joint bilingual vocabulary (each language having  $\sim 16\mathrm{k}$  tokens). We upsampled the Bangla data during training to equal the participation of both languages.
+
+# 3 The Bangla Language Understanding Benchmark (BLUB)
+
+Many works have studied different Bangla NLU tasks in isolation, e.g., sentiment classification (Das and Bandyopadhyay, 2010; Sharfuddin et al., 2018; Tripto and Ali, 2018), semantic textual similarity (Shajalal and Aono, 2018), parts-of-speech (PoS) tagging (Alam et al., 2016), named entity recognition (NER) (Ashrafi et al., 2020). However, Bangla NLU has not yet had a comprehensive, unified study. Motivated by the surge of NLU research brought about by benchmarks in other languages, e.g., English (Wang et al., 2018), French (Le et al., 2020), Korean (Park et al., 2021), we establish the first-ever Bangla Language Understanding Benchmark (BLUB). NLU generally comprises three types of tasks: text classification, sequence labeling, and text span prediction. Text classification tasks can further be sub-divided into single-sequence and sequence-pair classification. Therefore, we consider a total of four tasks for BLUB. For each task type, we carefully select one downstream task dataset. We emphasize the quality and open availability of the datasets while making the selection. We briefly mention them below.
+
+1. Single-Sequence Classification Sentiment classification is perhaps the most-studied Bangla NLU task, with some of the earlier works dating back over a decade (Das and Bandyopadhyay, 2010). Hence, we chose this as the single-sequence classification task. However, most Bangla sentiment classification datasets are not publicly available. We could only find two public datasets: BYSA (Tripto and Ali, 2018) and SentNoB (Islam et al., 2021). We found BYSA to have many duplications. Even worse, many duplicates had different labels. SentNoB had better quality and covered a broader set of domains, making the classification task more challenging. Hence, we opted to use the latter.
+
+2. Sequence-pair Classification In contrast to single-sequence classification, there has been a dearth of sequence-pair classification works in Bangla. We found work on semantic textual similarity (Shajalal and Aono, 2018), but the dataset is not publicly available. As such, we curated a new Bangla Natural Language Inference (BNLI) dataset for sequence-pair classification. We chose NLI as the representative task due to its fundamental importance in NLU. Given two sentences, a premise and a hypothesis as input, a model is tasked to predict whether or not the hypothesis is entailment, contradiction, or neutral to the premise. We used the same curation procedure as the XNLI (Conneau et al., 2018) dataset: we translated the MultiNLI (Williams et al., 2018) training data using the English to Bangla translation model by Hasan et al. (2020) and had the evaluation sets translated by expert human translators. Due to the possibility of the incursion of errors during automatic translation, we used the Language-Agnostic BERT Sentence Embeddings (LaBSE) (Feng et al., 2020) of the translations and original sentences to compute their similarity and discarded all sentences below a similarity threshold of 0.70. Moreover, to ensure good-quality human translation, we used similar quality assurance strategies as Guzmán et al. (2019).
+
+<table><tr><td>Models</td><td>|Params.|</td><td>SC</td><td>NLI</td><td>NER</td><td>QA</td><td>BLUB Score</td></tr><tr><td colspan="7">Zero-shot cross-lingual transfer</td></tr><tr><td>mBERT</td><td>180M</td><td>27.05</td><td>62.22</td><td>39.27</td><td>59.01/64.18</td><td>50.35</td></tr><tr><td>XLM-R (base)</td><td>270M</td><td>42.03</td><td>72.18</td><td>45.37</td><td>55.03/61.83</td><td>55.29</td></tr><tr><td>XLM-R (large)</td><td>550M</td><td>49.49</td><td>78.13</td><td>56.48</td><td>71.13/77.70</td><td>66.59</td></tr><tr><td>BanglishBERT</td><td>110M</td><td>48.39</td><td>75.26</td><td>55.56</td><td>72.87/78.63</td><td>66.14</td></tr><tr><td colspan="7">Supervised fine-tuning</td></tr><tr><td>mBERT</td><td>180M</td><td>67.59</td><td>75.13</td><td>68.97</td><td>67.12/72.64</td><td>70.29</td></tr><tr><td>XLM-R (base)</td><td>270M</td><td>69.54</td><td>78.46</td><td>73.32</td><td>68.09/74.27</td><td>72.82</td></tr><tr><td>XLM-R (large)</td><td>550M</td><td>70.97</td><td>82.40</td><td>78.39</td><td>73.15/79.06</td><td>76.79</td></tr><tr><td>IndicBERT</td><td>18M</td><td>68.41</td><td>77.11</td><td>54.13</td><td>50.84/57.47</td><td>61.59</td></tr><tr><td>sahajBERT</td><td>18M</td><td>71.12</td><td>76.92</td><td>70.94</td><td>65.48/70.69</td><td>71.03</td></tr><tr><td>BanglishBERT</td><td>110M</td><td>70.61</td><td>80.95</td><td>76.28</td><td>72.43/78.40</td><td>75.73</td></tr><tr><td>BanglaBERT</td><td>110M</td><td>72.89</td><td>82.80</td><td>77.78</td><td>72.63/79.34</td><td>77.09</td></tr></table>
+
+Table 2: Performance comparison of pretrained models on different downstream tasks. Scores in bold texts have statistically significant  $(p < 0.05)$  difference from others with bootstrap sampling (Koehn, 2004).
+
+3. Sequence Labeling In this task, all words of a text sequence have to be classified. Named Entity Recognition (NER) and Parts-of-Speech (PoS) tagging are two of the most prominent sequence labeling tasks. We chose the Bangla portion of SemEval 2022 MultiCoNER (Malmasi et al., 2022) dataset for BLUB.
+
+4. Span Prediction Extractive question answering is a standard choice for text span prediction. Similar to BNLI, we machine-translated the SQuAD 2.0 (Rajpurkar et al., 2018) dataset and used it as the training set (BQA). For validation and test, We used the Bangla portion of the TyDiQA $^5$  (Clark et al., 2020a) dataset. We posed the task analogous to SQuAD 2.0: presented with a text passage and a question, a model has to predict whether or not it is answerable. If answerable, the model has to find the minimal text span that answers the question.
+
+We present detailed statistics of the BLUB benchmark in Table 1.
+
+# 4 Experiments & Results
+
+Setup We fine-tuned BanglaBERT and BanglishBERT on the four downstream tasks and compared them with several multilingual models: mBERT (Devlin et al., 2019), XLM-R base and large (Conneau et al., 2020), and IndicBERT (Kakwani et al., 2020), a multilingual model for Indian languages; and sahajBERT (Diskin et al., 2021), an ALBERT-based (Lan et al., 2020) PLM for Bangla. All pre
+
+trained models were fine-tuned for 3-20 epochs with batch size 32, and the learning rate was tuned from  $\{2\mathrm{e} - 5,3\mathrm{e} - 5,4\mathrm{e} - 5,5\mathrm{e} - 5\}$ . The final models were selected based on the validation performances after each epoch. We performed fine-tuning with three random seeds and reported their average scores in Table 2. We reported the average performance of all tasks as the BLUB score.
+
+Zero-shot Transfer We show the zero-shot cross-lingual transfer results of the multilingual models fine-tuned on the English counterpart of each dataset (SentNob has no English equivalent; hence we used the Stanford Sentiment Treebank (Socher et al., 2013) for the sentiment classification task) in Table 2. In zero-shot transfer setting, BanglishBERT achieves strong cross-lingual performance over similar-sized models and falls marginally short of XLM-R (large). This is an expected outcome since cross-lingual effectiveness depends explicitly on model size (K et al., 2020).
+
+Supervised Fine-tuning In the supervised fine-tuning setup, BanglaBERT outperformed multilingual models and monolingual sahajBERT on all the tasks, achieving a BLUE score of 77.09, even coming head-to-head with XLM-R (large). On the other hand, BanglishBERT marginally lags behind BanglaBERT and XLM-R (large). BanglaBERT is not only superior in performance but also substantially compute- and memory-efficient. For instance, it may seem that sahajBERT is more efficient than BanglaBERT due to its smaller size, but it takes 2-3.5x time and 2.4-3.33x memory as BanglaBERT
+
+to fine-tune. 6
+
+![](images/4bde5894401536f1ca7593e449000a0f99e3c3a5344efbd2cda36c7465d2bc81.jpg)
+
+![](images/56c52033755c51a5d90049b7716e50b40cbda94c5d6e4179b7b8d2acc36bb730.jpg)  
+Figure 1: Sample-efficiency tests with SC and NLI.
+
+Sample efficiency It is often challenging to annotate training samples in real-world scenarios, especially for low-resource languages like Bangla. So, in addition to compute- and memory-efficiency, sample-efficiency (Howard and Ruder, 2018) is another necessity of PLMs. To assess the sample efficiency of BanglaBERT, we limit the number of training samples and see how it fares against other models. We compare it with XLM-R (large) and plot their performances on the SC and NLI tasks<sup>7</sup> for different sample size in Figure 1.
+
+Results show that when we have fewer number of samples  $(\leq 1k)$ , BanglaBERT has substantially better performance (2-9% on SC and 6-10% on NLI with  $p < 0.05$ ) over XLM-R (large), making it more practically applicable for resource-scarce downstream tasks.
+
+# 5 Conclusion & Future Works
+
+Creating language-specific models is often infeasible for low-resource languages lacking ample data. Hence, researchers are compelled to use multilingual models for languages that do not have
+
+strong pretrained models. To this end, we introduced BanglaBERT and BanglishBERT, two NLU models in Bangla, a widely spoken yet low-resource language. We presented new downstream datasets on NLI and QA, and established the BLUB benchmark, setting new state-of-the-art results with BanglaBERT. In future, we will include other Bangla NLU benchmarks (e.g., dependency parsing (de Marneffe et al., 2021)) in BLUB and investigate the benefits of initializing Bangla NLG models from BanglaBERT.
+
+# Acknowledgements
+
+We would like to thank the Research and Innovation Centre for Science and Engineering (RISE), BUET, for funding the project, and Intelligent Machines Limited and Google TensorFlow Research Cloud (TRC) Program for providing cloud support.
+
+# Ethical Considerations
+
+Dataset and Model Release The Copy Right Act,  $2000^{8}$  of Bangladesh allows reproduction and public release of copy-right materials for non-commercial research purposes. As a transformative research work, we will release BanglaBERT under a non-commercial license. Furthermore, we will release only the pretraining data for which we know the distribution will not cause any copyright infringement. The downstream task datasets can all be made publicly available under a similar non-commercial license.
+
+Quality Control in Human Translation Translations were done by expert translators who provide translation services for renowned Bangla newspapers. Each translated sentence was further assessed for quality by another expert. If found to be of low quality, it was again translated by the original translator. The sample was then discarded altogether if found to be of low quality again. Fewer than 100 samples were discarded in this process. Translators were paid as per standard rates in local currencies.
+
+Text Content We tried to minimize offensive texts in the pretraining data by explicitly crawling the sites where such contents would be nominal. However, we cannot guarantee that there is absolutely no objectionable content present and therefore recommend using the model carefully, especially for text generation purposes.
+
+# References
+
+Firoj Alam, Shammur Absar Chowdhury, and Sheak Rashed Haider Noori. 2016. Bidirectional LSTMs - CRFs networks for bangla POS tagging. In 2016 19th International Conference on Computer and Information Technology (ICCIIT), pages 377-382. IEEE.  
+Wissam Antoun, Fady Baly, and Hazem Hajj. 2020. AraBERT: Transformer-based model for Arabic language understanding. In Proceedings of the 4th Workshop on Open-Source Arabic Corpora and Processing Tools, with a Shared Task on Offensive Language Detection, pages 9-15, Marseille, France. European Language Resource Association.  
+Mikel Artetxe and Holger Schwenk. 2019. Massively multilingual sentence embeddings for zero-shot cross-lingual transfer and beyond. Transactions of the Association for Computational Linguistics, 7:597-610.  
+I. Ashrafi, M. Mohammad, A. S. Mauree, G. M. A. Nijhum, R. Karim, N. Mohammed, and S. Mo men. 2020. Banner: A cost-sensitive contextualized model for bangla named entity recognition. IEEE Access, 8:58206-58226.  
+Jose Canete, Gabriel Chaperon, Rodrigo Fuentes, and Jorge Pérez. 2020. Spanish pre-trained BERT model and evaluation data. In Proceedings of the Practical ML for Developing Countries Workshop at ICLR 2020, PML4DC.  
+Jonathan H. Clark, Eunsol Choi, Michael Collins, Dan Garrette, Tom Kwiatkowski, Vitaly Nikolaev, and Jennimaria Palomaki. 2020a. TyDi QA: A benchmark for information-seeking question answering in typologically diverse languages. Transactions of the Association for Computational Linguistics, 8:454-470.  
+Kevin Clark, Minh-Thang Luong, Quoc V Le, and Christopher D Manning. 2020b. ELECTRA: pretraining text encoders as discriminators rather than generators. In 8th International Conference on Learning Representations, ICLR 2020, April, 2020, Online.  
+Alexis Conneau, Kartikay Khandelwal, Naman Goyal, Vishrav Chaudhary, Guillaume Wenzek, Francisco Guzmán, Edouard Grave, Myle Ott, Luke Zettle-moyer, and Veselin Stoyanov. 2020. Unsupervised cross-lingual representation learning at scale. In Proceedings of the 58th Annual Meeting of the Association for Computational Linguistics, pages 8440-8451, Online. Association for Computational Linguistics.  
+Alexis Conneau and Guillaume Lample. 2019. Cross-lingual language model pretraining. In Advances in Neural Information Processing Systems, volume 32, pages 7059–7069. Curran Associates, Inc.
+
+Alexis Conneau, Rudy Rinott, Guillaume Lample, Adina Williams, Samuel Bowman, Holger Schwenk, and Veselin Stoyanov. 2018. XNLI: Evaluating cross-lingual sentence representations. In Proceedings of the 2018 Conference on Empirical Methods in Natural Language Processing, pages 2475-2485, Brussels, Belgium. Association for Computational Linguistics.  
+Amitava Das and Sivaji Bandyopadhyay. 2010. Phrase-level polarity identification for bangla. Int. J. Comput. Linguist. Appl.(IJCLA), 1(1-2):169-182.  
+Avishek Das, Omar Sharif, Mohammed Moshiul Hoque, and Iqbal H. Sarker. 2021. Emotion classification in a resource constrained language using transformer-based approach. In Proceedings of the 2021 Conference of the North American Chapter of the Association for Computational Linguistics: Student Research Workshop, pages 150-158, Online. Association for Computational Linguistics.  
+Marie-Catherine de Marneffe, Christopher D. Manning, Joakim Nivre, and Daniel Zeman. 2021. Universal Dependencies. Computational Linguistics, 47(2):255-308.  
+Jacob Devlin, Ming-Wei Chang, Kenton Lee, and Kristina Toutanova. 2019. BERT: Pre-training of deep bidirectional transformers for language understanding. In Proceedings of the 2019 Conference of the North American Chapter of the Association for Computational Linguistics: Human Language Technologies, Volume 1 (Long and Short Papers), pages 4171-4186, Minneapolis, Minnesota. Association for Computational Linguistics.  
+Michael Diskin, Alexey Bukhtiyarov, Max Ryabinin, Lucile Saulnier, Quentin Lhoest, Anton Sinitsin, Dmitry Popov, Dmitry Pyrkin, Maxim Kashirin, Alexander Borzunov, Albert Villanova del Moral, Denis Mazur, Ilia Kobelev, Yacine Jernite, Thomas Wolf, and Gennady Pekhimenko. 2021. Distributed deep learning in open collaborations. arXiv:2106.10207.  
+Fangxiaoyu Feng, Yinfei Yang, Daniel Cer, Naveen Arivazhagan, and Wei Wang. 2020. Language-agnostic bert sentence embedding. arXiv:2007.01852.  
+Francisco Guzmán, Peng-Jen Chen, Myle Ott, Juan Pino, Guillaume Lample, Philipp Koehn, Vishrav Chaudhary, and Marc'Aurelio Ranzato. 2019. The FLORES evaluation datasets for low-resource machine translation: Nepali-English and Sinhala-English. In Proceedings of the 2019 Conference on Empirical Methods in Natural Language Processing and the 9th International Joint Conference on Natural Language Processing (EMNLP-IJCNLP), pages 6098-6111, Hong Kong, China. Association for Computational Linguistics.  
+Tahmid Hasan, Abhik Bhattacharjee, Kazi Samin, Musum Hasan, Madhusudan Basak, M. Sohel Rahman,
+
+and Rifat Shahriyar. 2020. Not low-resource anymore: Aligner ensembling, batch filtering, and new datasets for Bengali-English machine translation. In Proceedings of the 2020 Conference on Empirical Methods in Natural Language Processing (EMNLP), pages 2612–2623, Online. Association for Computational Linguistics.  
+Jeremy Howard and Sebastian Ruder. 2018. Universal language model fine-tuning for text classification. In Proceedings of the 56th Annual Meeting of the Association for Computational Linguistics (Volume 1: Long Papers), pages 328-339, Melbourne, Australia. Association for Computational Linguistics.  
+Khondoker Ittehadul Islam, Sadipta Kar, Md Saiful Islam, and Mohammad Ruhul Amin. 2021. SentNoB: A dataset for analysing sentiment on noisy Bangla texts. In Findings of the Association for Computational Linguistics: EMNLP 2021, pages 3265-3271, Punta Cana, Dominican Republic. Association for Computational Linguistics.  
+Mandar Joshi, Danqi Chen, Yinhan Liu, Daniel S. Weld, Luke Zettlemoyer, and Omer Levy. 2020a. SpanBERT: Improving pre-training by representing and predicting spans. Transactions of the Association for Computational Linguistics, 8:64-77.  
+Pratik Joshi, Sebastin Santy, Amar Budhiraja, Kalika Bali, and Monojit Choudhury. 2020b. The state and fate of linguistic diversity and inclusion in the NLP world. In Proceedings of the 58th Annual Meeting of the Association for Computational Linguistics, pages 6282-6293, Online. Association for Computational Linguistics.  
+Armand Joulin, Edouard Grave, Piotr Bojanowski, and Tomas Mikolov. 2017. Bag of tricks for efficient text classification. In Proceedings of the 15th Conference of the European Chapter of the Association for Computational Linguistics: Volume 2, Short Papers, pages 427-431, Valencia, Spain. Association for Computational Linguistics.  
+Karthikeyan K, Zihan Wang, Stephen Mayhew, and Dan Roth. 2020. Cross-lingual ability of multilingual bert: An empirical study. In 8th International Conference on Learning Representations, ICLR 2020, April, 2020, Online.  
+Divyanshu Kakwani, Anoop Kunchukuttan, Satish Golla, Gokul N.C., Avik Bhattacharyya, Mitesh M. Khapra, and Pratyush Kumar. 2020. IndicNLPSuite: Monolingual corpora, evaluation benchmarks and pre-trained multilingual language models for Indian languages. In Findings of the Association for Computational Linguistics: EMNLP 2020, pages 4948-4961, Online. Association for Computational Linguistics.  
+Diederik P. Kingma and Jimmy Ba. 2015. Adam: A method for stochastic optimization. In 3rd International Conference on Learning Representations, ICLR 2015, San Diego, CA, USA, May 7-9, 2015.
+
+Philipp Koehn. 2004. Statistical significance tests for machine translation evaluation. In Proceedings of the 2004 Conference on Empirical Methods in Natural Language Processing, pages 388-395, Barcelona, Spain. Association for Computational Linguistics.  
+Zhenzhong Lan, Mingda Chen, Sebastian Goodman, Kevin Gimpel, Piyush Sharma, and Radu Soricut. 2020. Albert: A lite bert for self-supervised learning of language representations. In 8th International Conference on Learning Representations, ICLR 2020, April, 2020, Online.  
+Hang Le, Loic Vial, Jibril Frej, Vincent Segonne, Maximin Coavoux, Benjamin Lecouteux, Alexandre Allauzen, Benoit Crabbé, Laurent Besacier, and Didier Schwab. 2020. Flaubert: Unsupervised language model pre-training for french. In Proceedings of The 12th Language Resources and Evaluation Conference, pages 2479-2490, Marseille, France. European Language Resources Association.  
+Yinhan Liu, Myle Ott, Naman Goyal, Jingfei Du, Mandar Joshi, Danqi Chen, Omer Levy, Mike Lewis, Luke Zettlemoyer, and Veselin Stoyanov. 2019. Roberta: A robustly optimized bert pretraining approach. arXiv:1907.11692.  
+Alexandra Luccioni and Joseph Viviano. 2021. What's in the box? an analysis of undesirable content in the Common Crawl corpus. In Proceedings of the 59th Annual Meeting of the Association for Computational Linguistics and the 11th International Joint Conference on Natural Language Processing (Volume 2: Short Papers), pages 182-189, Online. Association for Computational Linguistics.  
+Shervin Malmasi, Anjie Fang, Besnik Fetahu, Sudipta Kar, and Oleg Rokhlenko. 2022. MultiCoNER: a Large-scale Multilingual dataset for Complex Named Entity Recognition.  
+Louis Martin, Benjamin Muller, Pedro Javier Ortiz Suárez, Yoann Dupont, Laurent Romary, Éric de la Clergerie, Djamé Seddah, and Benoit Sagot. 2020. CamemBERT: a tasty French language model. In Proceedings of the 58th Annual Meeting of the Association for Computational Linguistics, pages 7203-7219, Online. Association for Computational Linguistics.  
+Sungjoon Park, Jihyung Moon, Sungdong Kim, Won Ik Cho, Ji Yoon Han, Jangwon Park, Chisung Song, Junseong Kim, Youngsook Song, Taehwan Oh, Joohong Lee, Juhyun Oh, Sungwon Lyu, Younghoon Jeong, Inkwon Lee, Sangwoo Seo, Dongjun Lee, Hyunwoo Kim, Myeonghwa Lee, Seongbo Jang, Seungwon Do, Sunkyoung Kim, Kyungtae Lim, Jongwon Lee, Kyumin Park, Jamin Shin, Seonghyun Kim, Lucy Park, Alice Oh, JungWoo Ha, and Kyunghyun Cho. 2021. KLUE: Korean language understanding evaluation. In Thirty-fifth Conference on Neural Information Processing Systems Datasets and Benchmarks Track (Round 2).
+
+Marco Polignano, Pierpaolo Basile, Marco de Gemmis, Giovanni Semeraro, and Valerio Basile. 2019. *Alberto: Italian BERT language understanding model for NLP challenging tasks based on tweets*. In *Proceedings of the Sixth Italian Conference on Computational Linguistics*, Bari, Italy, November 13-15, 2019, CEUR Workshop Proceedings.  
+Shana Poplack. 1980. Sometimes I'll start a sentence in Spanish Y TERMINO EN ESPANOL: toward a typology of code-switching. Linguistics, 18(7-8):581-618.  
+Alec Radford, Jeffrey Wu, Rewon Child, David Luan, Dario Amodei, and Ilya Sutskever. 2019. Language models are unsupervised multitask learners. OpenAI blog, 1(8).  
+Pranav Rajpurkar, Robin Jia, and Percy Liang. 2018. Know what you don't know: Unanswerable questions for SQuAD. In Proceedings of the 56th Annual Meeting of the Association for Computational Linguistics (Volume 2: Short Papers), pages 784-789, Melbourne, Australia. Association for Computational Linguistics.  
+Md Shajalal and Masaki Aono. 2018. Semantic textual similarity in Bengali text. In 2018 International Conference on Bangla Speech and Language Processing (ICBSLP), pages 1-5. IEEE.  
+Abdullah Aziz Sharfuddin, Md Nafis Tihami, and Md Saiful Islam. 2018. A deep recurrent neural network with bilstm model for sentiment classification. In 2018 International Conference on Bangla Speech and Language Processing (ICBSLP), pages 1-4. IEEE.  
+Richard Socher, Alex Perelygin, Jean Wu, Jason Chuang, Christopher D. Manning, Andrew Ng, and Christopher Potts. 2013. Recursive deep models for semantic compositionality over a sentiment treebank. In Proceedings of the 2013 Conference on Empirical Methods in Natural Language Processing, pages 1631-1642, Seattle, Washington, USA. Association for Computational Linguistics.  
+Pedro Javier Ortiz Suárez, Benoit Sagot, and Laurent Romary. 2019. Asynchronous Pipeline for Processing Huge Corpora on Medium to Low Resource Infrastructures. In 7th Workshop on the Challenges in the Management of Large Corpora (CMLC-7), Cardiff, United Kingdom. Leibniz-Institut für Deutsche Sprache.  
+Nafis Irtiza Tripto and Mohammed Eunus Ali. 2018. Detecting multilabel sentiment and emotions from bangla youtube comments. In 2018 International Conference on Bangla Speech and Language Processing (ICBSLP), pages 1-6. IEEE.  
+Alex Wang, Amanpreet Singh, Julian Michael, Felix Hill, Omer Levy, and Samuel Bowman. 2018.
+
+GLUE: A multi-task benchmark and analysis platform for natural language understanding. In Proceedings of the 2018 EMNLP Workshop BlackboxNLP: Analyzing and Interpreting Neural Networks for NLP, pages 353-355, Brussels, Belgium. Association for Computational Linguistics.  
+Guillaume Wenzek, Marie-Anne Lachaux, Alexis Conneau, Vishrav Chaudhary, Francisco Guzmán, Armand Joulin, and Edouard Grave. 2020. CCNet: Extracting high quality monolingual datasets from web crawl data. In Proceedings of the 12th Language Resources and Evaluation Conference, pages 4003-4012, Marseille, France. European Language Resources Association.  
+Adina Williams, Nikita Nangia, and Samuel Bowman. 2018. A broad-coverage challenge corpus for sentence understanding through inference. In Proceedings of the 2018 Conference of the North American Chapter of the Association for Computational Linguistics: Human Language Technologies, Volume 1 (Long Papers), pages 1112-1122, New Orleans, Louisiana. Association for Computational Linguistics.  
+Shijie Wu and Mark Dredze. 2020. Are all languages created equal in multilingual BERT? In Proceedings of the 5th Workshop on Representation Learning for NLP, pages 120-130, Online. Association for Computational Linguistics.  
+Yonghui Wu, Mike Schuster, Zhifeng Chen, Quoc V Le, Mohammad Norouzi, Wolfgang Macherey, Maxim Krikun, Yuan Cao, Qin Gao, Klaus Macherey, et al. 2016. Google's neural machine translation system: Bridging the gap between human and machine translation. arXiv:1609.08144.  
+Zhilin Yang, Zihang Dai, Yiming Yang, Jaime Carbonell, Russ R Salakhutdinov, and Quoc V Le. 2019. Xlnet: Generalized autoregressive pretraining for language understanding. In Advances in Neural Information Processing Systems, volume 32, pages 5753-5763. Curran Associates, Inc.  
+Yukun Zhu, Ryan Kiros, Rich Zemel, Ruslan Salakhutdinov, Raquel Urtasun, Antonio Torralba, and Sanja Fidler. 2015. Aligning books and movies: Towards story-like visual explanations by watching movies and reading books. In Proceedings of the 2015 IEEE International Conference on Computer Vision (ICCV), ICCV '15, page 19-27, USA. IEEE Computer Society.
+
+# Appendix
+
+# Pretraining Data Sources
+
+We used the following sites for data collection. We categorize the sites into six types:
+
+# Encyclopedia:
+
+- bn.banglapedia.org  
+- bn.wikipedia.org  
+- songgramernotepad.com
+
+# News:
+
+- anandabazar.com  
+- arthoniteerkagoj.com  
+- bangla.24livenewpaper.com  
+- bangla.bdnews24.com  
+- bangla.dhakatribune.com  
+- bangla.hindustantimes.com  
+- bangladeshershkela.com  
+- banglanews24.com  
+- banglatribune.com  
+-bbc.com  
+- bd-journal.com  
+- bd-pratidin.com  
+- bd24live.com  
+- bengali.indianexpress.com  
+bigganprojukti.com  
+- bonikbarta.net  
+- chakarianews.com  
+- channelonline.com  
+- ctgtimes.com  
+- ctn24.com  
+daily-bangladesh.com  
+dailyagnishikha.com  
+- dainikazadi.net  
+-dainikdinkal.net  
+dailyfulki.com  
+dailyinqilab.com  
+- dailynayadiganta.com  
+dailysangram.com  
+dailysylhet.com  
+dainikamadershomoy.com  
+dainikshiksha.com  
+- dhakardak-bd.com  
+- dmpnews.org  
+dw.com  
+eisamay.indiatimes.com  
+- ittefaq.com.bd  
+jagonews24.com  
+- jugantor.com  
+- kalerkantho.com  
+- manobkantha.com.bd  
+- mzamin.com  
+- ntvbd.com  
+- onnodristy.com
+
+- pavilion.com.bd  
+- prothomalo.com  
+protidinersangbad.com  
+- risingbd.com  
+- rtvonline.com  
+samakal.com  
+- sangbadpratidin.in  
+- somoyerkonthosor.com  
+somoynews.tv  
+-tbsnews.net  
+- teknfnews.com  
+- thedailystar.net  
+- voabangla.com  
+- zeenews.india.com  
+- zoombangla.com
+
+# Blogs:
+
+- amrabondhu.com  
+- banglablog.in  
+bigganblog.org  
+biggani.org  
+bigyan.org.in  
+- bishorgo.com  
+- cadetcollegeblog.com  
+- choturmatrik.com  
+- horoppa.wordpress.com  
+muktangon.blogspot.com  
+- roar.media/bangla  
+- sachalayatan.com  
+- shodalap.org  
+- shopnobaz.net  
+somewhereinblog.net  
+- subeen.com  
+tunerpage.com  
+tutobd.com
+
+# E-books/Stories:
+
+- banglaepub.github.io  
+- bengali.pratilipi.com  
+- bn.wikisource.org  
+ebangalibrary.com  
+- eboipotro.github.io  
+- golpokobita.com  
+- kaliokalam.com  
+- shirisherdalpala.net  
+- tagoreweb.in
+
+# Social Media/Forums:
+
+- banglacricket.com  
+- bn.globalvoices.org  
+- helpfulhub.com  
+- nirbik.com  
+- pchelplinebd.com  
+- techtunes.io
+
+# Miscellaneous:
+
+- banglasonglyric.com  
+- bdlaws.minlaw.gov.bd  
+bdup24.com  
+- bengalisongslyrics.com  
+dakghar.org  
+-gdn8.com  
+- gunijan.org.bd  
+hwr.org  
+- jakir.me  
+- jhankarmahbub.com  
+- JW.org  
+- lyricsbangla.com  
+- neonaloy.com  
+porjotonlipi.com  
+sasthabangla.com  
+tanzil.net
+
+We wrote custom crawlers for each site above (except the Wikipedia dumps).
+
+# Additional Sample Efficiency Tests
+
+We plot the sample efficiency results of the NER and QA tasks in Figure 2.
+
+![](images/d8d83f68b7919cddb400e3d3977ea61eb24124d0972420eb239aafffeb81cc35.jpg)
+
+![](images/12709fdf4e271e916ce9554b2f39fd3a54fccbbaa24db743ed04560a8e061009.jpg)  
+Figure 2: Sample-efficiency tests with NER and QA.
+
+Similar results are also observed here for the NER task, where BanglaBERT is more sample-efficient when we have  $\leq 1k$  training samples. In the QA task however, both models have identical performance for all sample counts.
+
+# Compute and Memory Efficiency Tests
+
+To validate that BanglaBERT is more efficient in terms of memory and compute, we measured each model's training time and memory usage during the fine-tuning of each task. All tests were done on a desktop machine with an 8-core Intel Core-i7 11700k CPU and NVIDIA RTX 3090 GPU. We used the same batch size, gradient accumulation steps, and sequence length for all models and tasks for a fair comparison. We use relative time and memory (GPU VRAM) usage considering those of BanglaBERT as units. The results are shown in Table 3. (We mention the upper and lower values of the different tasks for each model)
+
+<table><tr><td>Model</td><td>Time</td><td>Memory Usage</td></tr><tr><td>mBERT</td><td>1.14x-1.92x</td><td>1.12x-2.04x</td></tr><tr><td>XLM-R (base)</td><td>1.29-1.81x</td><td>1.04-1.63x</td></tr><tr><td>XLM-R (large)</td><td>3.81-4.49x</td><td>4.44-5.55x</td></tr><tr><td>SahajBERT</td><td>2.40-3.33x</td><td>2.07-3.54x</td></tr><tr><td>BanglaBERT</td><td>1.00x</td><td>1.00x</td></tr></table>
+
+Table 3: Compute and memory efficiency tests

data/2021/2101_00xxx/2101.00216/1322f2fe-d1ab-4e6d-b8cd-999150e9e3a0_content_list.json

@@ -1,3 +1,1993 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:94f6dd473e73c26b3db0557aee1d703a238ba2f775592367c888baf22b1ed250
-size 80271
+[
+    {
+        "type": "text",
+        "text": "Brain Tumor Detection and Classification based on Hybrid Ensemble Classifier",
+        "text_level": 1,
+        "bbox": [
+            168,
+            89,
+            831,
+            138
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Ginni Garg<sup>1</sup>, Ritu Garg",
+        "bbox": [
+            401,
+            156,
+            594,
+            172
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Department of Computer Engineering",
+        "bbox": [
+            354,
+            175,
+            642,
+            189
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "National Institute of Technology, Kurukshetra, 136119",
+        "bbox": [
+            294,
+            191,
+            709,
+            205
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "gargginni01@gmail.com, ritu.59@gmail.com",
+        "bbox": [
+            326,
+            215,
+            671,
+            231
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Abstract: To improve patient survival and treatment outcomes, early diagnosis of brain tumors is an essential task. It is a difficult task to evaluate the magnetic resonance imaging (MRI) images manually. Thus, there is a need for digital methods for tumor diagnosis with better accuracy. However, it is still a very challenging task in assessing their shape, volume, boundaries, tumor detection, size, segmentation, and classification. In this proposed work, we propose a hybrid ensemble method using Random Forest (RF), K-Nearest Neighbour, and Decision Tree (DT) (KNN-RF-DT) based on Majority Voting Method. It aims to calculate the area of the tumor region and classify brain tumors as benign and malignant. In the beginning, segmentation is done by using Otsu's Threshold method. Feature Extraction is done by using Stationary Wavelet Transform (SWT), Principle Component Analysis (PCA), and Gray Level Co-occurrence Matrix (GLCM), which gives thirteen features for classification. The classification is done by hybrid ensemble classifier (KNN-RF-DT) based on the Majority Voting method. Overall it aimed at improving the performance by traditional classifiers instead of going to deep learning. Traditional classifiers have an advantage over deep learning algorithms because they require small datasets for training and have low computational time complexity, low cost to the users, and can be easily adopted by less skilled people. Overall, our proposed method is tested upon dataset of 2556 images, which are used in 85:15 for training and testing respectively and gives good accuracy of  $97.305\\%$ .",
+        "bbox": [
+            114,
+            237,
+            883,
+            523
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Keyword: Otsu's Threshold; SWT; PCA; GLCM; hybrid ensemble Classifier (KNN-RF-DT) based on Majority Voting method.",
+        "bbox": [
+            116,
+            529,
+            883,
+            564
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1. Introduction",
+        "text_level": 1,
+        "bbox": [
+            116,
+            570,
+            256,
+            588
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "A brain tumor is a cancerous or non-cancerous growth of abnormal cells in the brain, which leads to benign or malignant brain tumors. Most of the researchers are engaging in the primary type of tumor such as Gliomas. We have some ways to treat gliomas such as chemotherapy, radiotherapy, and surgery. Automation by computer-aided devices can be used to obtain the necessary clinical data such as tumor presence, location, and type. However, it is still a very challenging task in assessing their shape, volume, boundaries, tumor detection, size, segmentation, and classification. Also, brain tumor intensity varies from individual to individual. Magnetic Resonance Imaging (MRI) is preferred over other treatment and diagnosis methods because it gives superior image contrast in soft tissues and has non-invasive property. On applying different pulse sequences, we obtain a different type of MRI scans, such as (1) T1 weighted scans that distinguish between tumor and healthy tissues. (2) T2 weighted scans cause delineation of the edema region, and ultimately we get a bright image region. (3) T4-Gd scans which gives bright signal at tumor border by using a contrast agent. (4) FLAIR scans differentiate between cerebrospinal fluid (CSF) and edema region by using a signal of water molecule suppression. It is a difficult task to do annotation of brain tumors from MRI scans manually. Hence, there is a strong need for automation of brain tumor segmentation and classification with the help of computer vision and machine learning algorithms. Today,",
+        "bbox": [
+            114,
+            595,
+            883,
+            893
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "page_number",
+        "text": "1",
+        "bbox": [
+            872,
+            940,
+            880,
+            950
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "researchers are working on computer vision and machine learning algorithms for brain tumor segmentation and classification. Clinician's plans are highly expensive because they depend on various imaging techniques such as PET, MRI, and CT. The clinical methods provide extract pertinent information and comprehensive analysis from images. Computational techniques help to investigate the details present in medical images. Imaging methods can be used to find the position of brain tumors. MRI provides more meaningful information in contrast to other imaging modalities like CT.",
+        "bbox": [
+            109,
+            90,
+            883,
+            212
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "The challenging task in Brain Tumor is due to high variability and inherent MRI data characteristics, e.g., variability in tumor sizes or shapes, tumor detection, area calculation, segmentation, classification, and finding uncertainty in segmented region. The most significant task in image understanding is image segmentation because it helps in feature extraction, area calculation, and significance in many real-life applications. It can be used, for example, estimation of tumor volume, tissue classification, blood cell delineation, and localization of tumors, matching of an atlas, surgical planning, and image registration. For monitoring oncologic therapy, the accurate and morphology quantification of tumors is a critical task. However, extensive scale work has been performed in this field; but still; clinicians depend on manual determination of tumor, due to lack of link between researchers and clinicians.",
+        "bbox": [
+            109,
+            215,
+            883,
+            388
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Recently, many techniques have been proposed for automatic brain tumor classification that can be categorized into machine learning (ML) and deep learning (DL) techniques based on the feature selection and learning mechanism. In ML approaches, feature selection and extraction is essential for classification. However, DL approaches extract and learn the features from the image directly. Recent DL approaches, particularly CNN provides good accuracy and is widely used in medical image analysis. Moreover, they have disadvantage over traditional methods (ML) as they need large dataset for training, have high time complexity, less accurate for applications where we have availability of small dataset and require expensive GPUs which ultimately increases cost to the users. Additionally, selecting the right deep learning tools is also a challenging task as it needs knowledge regarding various parameters, training method, and topology. On the other hand, machine-learning approaches have played key role in the area of medical imaging. Several learning based classifiers have already been used for classification and detection of brain tumors, which includes - support vector machine (SVM), artificial neural network (ANN), sequential minimal optimization (SMO), fuzzy C mean (FCM), Naive Bayes (NB), Random Forest (RF), Decision Tree (DT) and K-Nearest Neighbor (KNN). KNN implementation is very simple and takes less computation and space complexity. It requires very less parameters to tune. The biggest advantage of DT is that it goes through all the outcomes of decision and finally traces each path to reach the conclusion. It is versatile; no complex mathematics involved, which makes it easy to understand. Further, Random Forest is itself ensemble classifiers of DT. It runs effectively on large dataset, which provides good parameter values for accuracies, precision and other evaluation metrics. Overall, these classifiers have received considerable research attention, as they require small dataset for training, low computational time complexity, low cost to the users, and can be easily adopted by less skilled people. Thus, in the present study, we work on hybrid ensemble classifiers in order to improve the accuracy of results obtained. Further, comparative study of various classifiers such as SVM, KNN, DT, RF, NB, ANN and proposed hybrid ensemble classifier is done.",
+        "bbox": [
+            109,
+            391,
+            883,
+            843
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "The outline of the paper is as follows: Section 2 describes the related work; Section 3 describes the proposed method for area calculation and brain tumor classification. Section 4",
+        "bbox": [
+            109,
+            844,
+            883,
+            878
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "page_number",
+        "text": "2",
+        "bbox": [
+            870,
+            939,
+            882,
+            950
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "gives information about experimental implementation and results, and Finally, Section 5 represents conclusion.",
+        "bbox": [
+            116,
+            90,
+            883,
+            125
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "2. Related Work",
+        "text_level": 1,
+        "bbox": [
+            116,
+            132,
+            267,
+            150
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Brain Tumor research has been conducted in various private multinational companies like, Siemens, Becton Dickinson, Medtronic, Accenture, GE Medical Systems, Atlantic Biomedical P. Ltd, and others. Both theoretical and experimental works of International arena are reported in the literature. Some of work done by good researchers is described below:",
+        "bbox": [
+            116,
+            157,
+            883,
+            227
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Othman [4] et al. proposed a method in which feature extraction is done by using Daubechies wavelets with DWT from MRI images. Each image consists of 17,689 feature vectors. Finally, classification is done using RBF a SVM kernel function. Sindhumol et al. [4] presents a spectral clustering (SC) technique for classification of brain tumor. Images (MRI) are divided into different clusters using the spectral distance. Feature reduction is made by using ICA and classification by using SVM. The training and testing data consists of 40 normal and 20 abnormal MRI images. Abd-Ellah [6] et al. proposed method consists of preprocessing of MRI images is done with the help of Median filters. DW does feature extraction, and PCA is used for feature reduction. Finally, classification is done by the SVM classifier using the RBF kernel function. The database consists of 80 images. SVM is trained using 43 abnormal and 5 normal images, and testing is done by using 27 abnormal images and 5 normal images. H. Kalbkhani [7] et al., proposed the subband of the detail coefficients and 2D DWT using (GARCH), Feature reduction is made from 61440 to 24 features. Feature extraction is done by linear discriminate analysis (LDA), which is further reduced using PCA. Finally, detection is done by using SVM and KNN identifier. The training and testing data consists of MRI images, normal and abnormal in ratio 10 to 70. The testing set consists of 7 normal and 49 abnormal images, while the training set contains 3 normal and 21 abnormal images. Saritha et al. [8] proposed classification technique for normal or abnormal brain tumor images considering 23 images for testing and 50 for training. Deep and Devi [9] et al., proposed a system in which the statistical method is used for texture feature extraction, neural network, and BPNN is used in segmentation and uncovering stages. The database consists of 42 images, which are further divided into training and testing as 30 and 12, respectively. Chandra [10] et al. proposed a new clustering algorithm based on PSO optimization with the help of MRI images. The clusters and corresponding centroids are being found out by algorithm, among them global best is considered. The dataset consists of 62 normal MRI images and 110 abnormal ones. Xuan and Liao [11], proposed a tumor detection method considering features of 3-types texture-based, intensity-based and symmetry-based. Then, total 40 features consisting of 13 intensity-based, 26 texture-based and 1 symmetry-based features are selected. Feature extraction is done from different images with 12 features from T2 images, 9 from T1 images and 19 from FLAIR images. The dataset contains 10 patients with 3 volumes each with 24 slices of MRI images. They divided the dataset equally into testing and training sets. Dhanalakshmi [12] et al., proposed work consist of k-means clustering for segmentation and then area is calculated using formula sqrt(P).*264, where P is the no. of pixel with value 1. The proposed algorithm shows the reproducibility and good performance. Kaushik [13] et al., proposed method consists of segmentation using genetic algorithm. The corners of the brain tumor region are also extracted based on proposed algorithm. Rani [16] et al., proposed a method for MRI brain tumor image classification using SVM and segmentation using otsu's thresholding method. This paper compared its proposed work with KIFCM, K-means an Fuzzy c-means but their accuracy and executive time was more effective than all remaining existing methods.",
+        "bbox": [
+            114,
+            229,
+            883,
+            893
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "page_number",
+        "text": "3",
+        "bbox": [
+            872,
+            940,
+            882,
+            950
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Additionally, many deep learning models have been investigated recently for brain tumor detection and classification and achieved the competitive results. Chaudhary [15] et al., proposed a method based on deep learning for the segmentation of MRI brain tumor images. In which pre processing of MRI images was done using intensity normalization. Kamboj [17] et al., reviewed deep learning methods, which has advantages over traditional methods. Their focus is on design of architecture as compare to segmentation and feature extraction. Deep learning methods provide good accuracy but they required more computation time, space and dataset as compare to the traditional classifiers. However, traditional machine learning methods are easy to understand, interpret and required less space, dataset and computational cost in terms of hardware.",
+        "bbox": [
+            114,
+            89,
+            883,
+            263
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Moreover, none of the above mentioned machine learning approaches work on feature extraction using 3-fold techniques such as  $\\mathrm{SWT + PCA + GLCM}$ , which significantly increases the robustness of extracted features as SwT helped in capturing the abrupt changes of images. PCA reduced the dimensionality of input images from SwT, which reduced space and time complexity up to some extent. Finally, GLCM extracted various useful features from dimensionally reduced images of PCA. In addition, none of the above methods worked on hybrid ensemble classifiers, which helped in achieving good evaluation metrics using traditional classifiers, as best properties of each classifier add up to gave excellent results. Therefore, overall 3-fold robust feature extraction and hybrid ensemble classification is the main focus of interest in this present study, which helped in improving the various evaluation metrics and reduced space and time complexity using traditional classifiers.",
+        "bbox": [
+            114,
+            265,
+            883,
+            455
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3. Proposed Method",
+        "text_level": 1,
+        "bbox": [
+            116,
+            464,
+            294,
+            481
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "The proposed work aims at improving the performance of traditional classifiers. These classifiers require small datasets for training and have low computational time complexity thus appropriate for computer assisted brain tumor diagnosis and classification. We propose a hybrid ensemble method using KNN, Random Forest (RF) and Decision Tree (DT) (KNN-RF-DT) based on Majority Voting Method. It aims to calculate the area of the tumor region and classify brain tumors as benign and malignant. In the beginning, MRI images segments using the Otsu's Threshold method. Feature Extraction is done by Stationary Wavelet Transform (SWT), Principle Component Analysis (PCA) and Gray Level Co-occurrence Matrix (GLCM), which gives thirteen features for classification. The classification is done by hybrid ensemble classifiers (KNN-RF-DT) based on the Majority Voting method.",
+        "bbox": [
+            114,
+            489,
+            883,
+            662
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "In the current research work, we have done comparative studies of various classifiers such as SVM, KNN, DT, RF, NB, ANN and proposed hybrid ensemble Classifier. Overall, it aimed at improving the performance by using traditional classifiers. Working of proposed implementation is shown in Fig.1.",
+        "bbox": [
+            114,
+            664,
+            883,
+            732
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "page_number",
+        "text": "4",
+        "bbox": [
+            870,
+            940,
+            880,
+            950
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "image",
+        "img_path": "images/7c3a1a1c26d9b73a8edce55c3f657b56cd438fe31e1b242251d01b76d39268ef.jpg",
+        "image_caption": [
+            "Fig. 1 Flow diagram of proposed work"
+        ],
+        "image_footnote": [],
+        "bbox": [
+            282,
+            99,
+            738,
+            330
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "a. Otsu's Method",
+        "text_level": 1,
+        "bbox": [
+            112,
+            367,
+            272,
+            383
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Otsu method [19] is used for the automatic image threshold into two classed, foreground, and background based on a single threshold value. This threshold determines by maximizing inter-class variance and minimizing intra-class intensity variance. Threshold that minimizes the intra-class variance that describes by corresponding sum of variance of two classes:",
+        "bbox": [
+            109,
+            392,
+            883,
+            462
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "text": "\n$$\n\\alpha_ {\\mathrm {w}} ^ {2} (\\mathbf {n}) = \\mathrm {A} _ {0} (\\mathbf {n}) ^ {*} \\alpha_ {0} ^ {2} (\\mathbf {n}) + \\mathrm {A} _ {1} (\\mathbf {n}) ^ {*} \\alpha_ {1} ^ {2} (\\mathbf {n}), \\tag {1}\n$$\n",
+        "text_format": "latex",
+        "bbox": [
+            112,
+            468,
+            846,
+            487
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "where  $A_0, A_1 -$  Probability of two classes,  $n = 154$ - Threshold,  $\\alpha_0^2, \\alpha_1^2 -$  Variance of two classes. The Class Probability can be computed from the number of bins (L=256) as shown below:",
+        "bbox": [
+            111,
+            494,
+            859,
+            529
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "text": "\n$$\n\\mathrm {A} _ {0} (\\mathbf {n}) = \\sum_ {k = 0} ^ {n - 1} \\mathrm {p} (\\mathbf {k}) \\tag {2}\n$$\n",
+        "text_format": "latex",
+        "bbox": [
+            112,
+            537,
+            846,
+            564
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "text": "\n$$\n\\mathrm {A} _ {1} (\\mathbf {n}) = \\sum_ {k = n} ^ {L - 1} \\mathrm {p} (\\mathbf {k}), \\tag {3}\n$$\n",
+        "text_format": "latex",
+        "bbox": [
+            112,
+            569,
+            846,
+            595
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "where we know that minimum intra-class variance is equivalent to the maximum inter-class variance.",
+        "bbox": [
+            109,
+            603,
+            880,
+            635
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "text": "\n$$\n\\alpha_ {\\mathrm {b}} ^ {2} (\\mathbf {n}) = \\alpha^ {2} - \\alpha_ {\\mathrm {w}} ^ {2} (\\mathbf {n}) = \\mathrm {A} _ {0} ^ {*} \\left(\\beta_ {0} - \\beta_ {\\mathrm {T}}\\right) ^ {2} + \\mathrm {A} _ {1} ^ {*} \\left(\\beta_ {1} - \\beta_ {\\mathrm {T}}\\right) ^ {2} = \\mathrm {A} _ {0} (\\mathbf {n}) ^ {*} \\mathrm {A} _ {1} (\\mathbf {n}) ^ {*} \\left(\\beta_ {0} - \\beta_ {1}\\right) ^ {2}, \\tag {4}\n$$\n",
+        "text_format": "latex",
+        "bbox": [
+            112,
+            643,
+            846,
+            664
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "where  $\\beta_{1}(\\mathbf{n}),\\beta_{0}(\\mathbf{n})$  and  $\\beta_{\\mathrm{T}}$  are class means",
+        "bbox": [
+            111,
+            670,
+            444,
+            686
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "text": "\n$$\n\\beta_ {0} (\\mathbf {n}) = = \\sum_ {\\mathbf {k} = 0} ^ {n - 1} \\mathbf {k} * \\mathrm {p} (\\mathbf {k}) / \\mathrm {A} _ {0} (\\mathbf {n}) \\tag {5}\n$$\n",
+        "text_format": "latex",
+        "bbox": [
+            112,
+            695,
+            846,
+            720
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "text": "\n$$\n\\beta_ {1} (\\mathbf {n}) = = \\sum_ {\\mathbf {k} = n} ^ {L - 1} \\mathbf {k} * \\mathrm {p} (\\mathbf {k}) / \\mathrm {A} _ {1} (\\mathbf {n}) \\tag {6}\n$$\n",
+        "text_format": "latex",
+        "bbox": [
+            112,
+            726,
+            846,
+            753
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "text": "\n$$\n\\beta_ {\\mathrm {T}} = = \\sum_ {\\mathbf {k} = 0} ^ {L - 1} \\mathbf {k} * \\mathrm {p} (\\mathbf {k}) \\tag {7}\n$$\n",
+        "text_format": "latex",
+        "bbox": [
+            112,
+            760,
+            846,
+            787
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "text": "\n$$\n\\mathrm {A} _ {0} * \\beta_ {0} + \\mathrm {A} _ {1} * \\beta_ {1} = \\beta_ {\\mathrm {T}} \\tag {8}\n$$\n",
+        "text_format": "latex",
+        "bbox": [
+            112,
+            794,
+            846,
+            811
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "text": "\n$$\n\\mathrm {A} _ {0} + \\mathrm {A} _ {1} = 1 \\tag {9}\n$$\n",
+        "text_format": "latex",
+        "bbox": [
+            112,
+            820,
+            846,
+            837
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Above computations, give us effective algorithm as class probability and class means computed iteratively. Histogram of brain tumor image with bins 256 and threshold 154 is shown below in Fig.2.",
+        "bbox": [
+            109,
+            844,
+            883,
+            897
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "page_number",
+        "text": "5",
+        "bbox": [
+            870,
+            939,
+            882,
+            950
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "image",
+        "img_path": "images/752848fb12b89cb6fa4b9176b464b1f286d5e94d98c8ffaaf23d0a3ba3a372e3.jpg",
+        "image_caption": [
+            "Fig. 2 Histogram of brain tumor image with bins  $\\mathrm{L} = 256$  and threshold  $\\mathrm{n} = 154$"
+        ],
+        "image_footnote": [],
+        "bbox": [
+            277,
+            106,
+            781,
+            330
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "b. Stationary Wavelet Transform",
+        "text_level": 1,
+        "bbox": [
+            111,
+            363,
+            408,
+            381
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "As far as signal is concerned, slow changes can be captured with the help of Fourier Transform, whereas when the images undergo abrupt changes that can be captured with the concept of wavelets. Wavelet is a small oscillation whose frequency inversely varies with scaling. To capture abrupt changes, we need high frequency and small scaling so we need the concept of wavelet. Stationary Wavelet Transform (SWT) [20] algorithm is designed to overcome the problem of translation-invariance of the discrete wavelet transform (DWT). Translation-invariance can be achieved by removing the down-samples and up-samples in the DWT and up sampling the filter coefficients by a factor of  $2^{(\\mathrm{j - 1})}$  in the  $\\mathrm{j^th}$  level of algorithm. SWT has various applications such as - Signal de-noising, Pattern Recognition, Brain image classification, Pathological brain detection. In our proposed work, we work on 1-D SWT, where  $\\mathrm{j} = 1$ .",
+        "bbox": [
+            109,
+            387,
+            888,
+            561
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "The origin of the wavelets and its types from Fourier transform is shown in Fig.3.",
+        "bbox": [
+            169,
+            563,
+            818,
+            580
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "image",
+        "img_path": "images/4a8c46b51b221dd70bff31d2c60ee055fe9f4cf87dbf8533c7a5fe73005dc845.jpg",
+        "image_caption": [
+            "Fig. 3 Origin of SWT"
+        ],
+        "image_footnote": [],
+        "bbox": [
+            267,
+            587,
+            730,
+            676
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "The digital implementation of SwT is shown below in Fig. 4 in which each level is an upsampled version of the previous level.",
+        "bbox": [
+            111,
+            699,
+            883,
+            734
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Decomposition Step",
+        "bbox": [
+            120,
+            787,
+            261,
+            806
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "image",
+        "img_path": "images/1abe9229b8882387176b5ef953f8c7876bfc283a70f7780f8677418b8875454a.jpg",
+        "image_caption": [],
+        "image_footnote": [],
+        "bbox": [
+            287,
+            746,
+            684,
+            859
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "page_number",
+        "text": "6",
+        "bbox": [
+            870,
+            939,
+            883,
+            952
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Filter computation",
+        "bbox": [
+            147,
+            127,
+            287,
+            143
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/f7cb507d399f1ae6c63010e03e7f39d054aa753e6203c5a0e478886f51c35252.jpg",
+        "image_caption": [],
+        "image_footnote": [],
+        "bbox": [
+            321,
+            88,
+            578,
+            125
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/2ff41a776eb6f756747069fc71a0769f538f0ba2828ff84e56aae2a2122bd813.jpg",
+        "image_caption": [],
+        "image_footnote": [],
+        "bbox": [
+            318,
+            152,
+            581,
+            189
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/45ee83afb8556db9572282017eda4e4ccc1b5b32aee1faae355d11fe5b79d72e.jpg",
+        "image_caption": [
+            "Fig. 4 Implementation of SWT in which each level is an up-sampled version of the previous level"
+        ],
+        "image_footnote": [
+            "Initialization:  $\\mathrm{cA}_0 = \\mathrm{s}$  and  $\\mathrm{F}_0 = \\mathrm{Lo\\_D}$  and  $\\mathrm{G}_0 = \\mathrm{Hi\\_D}$"
+        ],
+        "bbox": [
+            212,
+            196,
+            375,
+            231
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "c. Principal Component Analysis",
+        "text_level": 1,
+        "bbox": [
+            111,
+            305,
+            405,
+            324
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "PCA [21] is an orthogonal transformation of correlated variables to linearly uncorrelated variables known as principal components. The first principal component has the highest variances; successive components contain the most significant possible variance such that it remains orthogonal to previous components. It is used to reduce the dimensions or features with which we have to train our classifier, which ultimately helps in reducing the time and space complexity for given data computation.",
+        "bbox": [
+            109,
+            330,
+            885,
+            434
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "First Component",
+        "text_level": 1,
+        "bbox": [
+            112,
+            441,
+            263,
+            459
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "equation",
+        "text": "\n$$\n\\mathrm {Y} _ {(1)} = \\arg \\max  _ {| \\mathrm {Y} | = 1} \\left\\{\\Sigma_ {\\mathrm {k}} \\left(\\mathrm {t} _ {1}\\right) _ {(\\mathrm {k})} ^ {2} \\right\\} = \\arg \\max  _ {| \\mathrm {Y} | = 1} \\left\\{\\Sigma_ {\\mathrm {k}} \\left(\\mathbf {X} _ {(\\mathrm {k})}. \\mathrm {Y}\\right) ^ {2} \\right\\}, \\tag {10}\n$$\n",
+        "text_format": "latex",
+        "bbox": [
+            112,
+            465,
+            857,
+            487
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Where  $\\mathbf{Y}_{(1)}$  denotes the unit vector and  $\\mathbf{X}$  is Image matrix.",
+        "bbox": [
+            111,
+            492,
+            571,
+            508
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Equation in matrix form:",
+        "bbox": [
+            112,
+            510,
+            315,
+            527
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "equation",
+        "text": "\n$$\n\\mathbf {Y} _ {(1)} = \\arg \\max  _ {| \\mathrm {Y} | = 1} \\left\\{\\| \\mathbf {X Y} \\| ^ {2} \\right\\} = \\arg \\max  _ {| \\mathrm {Y} | = 1} \\left\\{\\mathbf {Y} ^ {\\mathrm {T}} \\mathbf {X} ^ {\\mathrm {T}} \\mathbf {X Y} \\right\\} \\tag {11}\n$$\n",
+        "text_format": "latex",
+        "bbox": [
+            112,
+            534,
+            857,
+            554
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "equation",
+        "text": "\n$$\n\\mathbf {Y} _ {(1)} = \\arg \\max  \\left\\{\\mathbf {Y} ^ {\\mathrm {T}} \\mathbf {X} ^ {\\mathrm {T}} \\mathbf {X Y} / \\mathbf {Y} ^ {\\mathrm {T}} \\mathbf {Y} \\right\\} \\tag {12}\n$$\n",
+        "text_format": "latex",
+        "bbox": [
+            112,
+            558,
+            857,
+            579
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Largest Eigen value of the matrix is Rayleigh Quotient, where  $\\mathbf{X}^{\\mathrm{T}}\\mathbf{X}$  is positive semi-definite matrix and  $\\mathbf{Y} =$  corresponding Eigen vector",
+        "bbox": [
+            109,
+            584,
+            883,
+            619
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Further Components",
+        "text_level": 1,
+        "bbox": [
+            112,
+            627,
+            295,
+            643
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "The Nth component can be found by subtracting the first N-1 principle component from  $\\mathbf{X}$ , where  $\\mathbf{N} = 13$  for proposed method.",
+        "bbox": [
+            109,
+            645,
+            883,
+            680
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "equation",
+        "text": "\n$$\n\\mathbf {X} _ {\\mathbf {N}} = \\mathrm {X} - \\sum_ {n = 1} ^ {N - 1} \\mathbf {X Y} (\\mathrm {n}) \\mathrm {Y} (\\mathrm {n}) ^ {\\wedge} \\mathrm {T} \\tag {13}\n$$\n",
+        "text_format": "latex",
+        "bbox": [
+            111,
+            686,
+            857,
+            714
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Further, weight vector can be found as describe below:",
+        "bbox": [
+            111,
+            720,
+            549,
+            738
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "equation",
+        "text": "\n$$\n\\mathbf {Y} _ {(K)} = \\arg \\max  _ {\\| \\mathbf {Y} \\| = 1} \\left\\{\\| \\mathbf {X} _ {K} ^ {*} \\mathbf {Y} \\| ^ {2} \\right\\} = \\arg \\max  \\left\\{\\mathbf {Y} ^ {\\mathrm {T}} \\mathbf {X} _ {K} ^ {\\mathrm {T}} \\mathbf {X} _ {K} \\mathbf {Y} / \\mathbf {Y} ^ {\\mathrm {T}} \\mathbf {Y} \\right\\} \\tag {14}\n$$\n",
+        "text_format": "latex",
+        "bbox": [
+            111,
+            744,
+            857,
+            763
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "d. Gray-Level Co-occurrence Matrix",
+        "text_level": 1,
+        "bbox": [
+            111,
+            770,
+            436,
+            787
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "It is a statistical method that describes the spatial relationship of pixels based on the spatial grey-level dependence matrix. GLCM [22] calculates the texture of the image by calculating the frequency of corresponding pixels and their spatial relationships. All the thirteen features which are used in proposed work as follow contrast, correlation, energy, homogeneity, mean, standard deviation, kurtosis, skewness, variance, smoothness, IDM, RMS, entropy. There detailed information is given below:",
+        "bbox": [
+            109,
+            795,
+            885,
+            902
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "page_number",
+        "text": "7",
+        "bbox": [
+            870,
+            939,
+            883,
+            952
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "equation",
+        "text": "\n$$\n\\text {C o n t r a s t} (\\mathbf {C}) = \\sum_ {\\mathrm {t}, \\mathrm {r} = 1} ^ {\\mathrm {T}, \\mathrm {R}} | \\mathrm {t} - \\mathrm {r} | ^ {2} \\mathbf {q} (\\mathrm {t}, \\mathrm {r}), \\tag {15}\n$$\n",
+        "text_format": "latex",
+        "bbox": [
+            112,
+            89,
+            856,
+            112
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "where,  $\\mathbf{q}(\\mathrm{t},\\mathrm{r})$  is GLCM, t & r are row & column,T is total rows and R is total columns.",
+        "bbox": [
+            111,
+            119,
+            792,
+            137
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "equation",
+        "text": "\n$$\n\\text {C o r r e l a t i o n} (\\operatorname {C o r r}) = \\sum_ {\\mathrm {t}, \\mathrm {r} = 1} ^ {\\mathrm {T}, \\mathrm {R}} \\left((\\mathrm {t} - \\mu) (\\mathrm {r} - \\mu) \\mathbf {q} (\\mathrm {t}, \\mathrm {r})\\right) / (\\sigma (\\mathrm {t}) * \\sigma (\\mathrm {r})), \\tag {16}\n$$\n",
+        "text_format": "latex",
+        "bbox": [
+            112,
+            143,
+            856,
+            167
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "where, mean is  $\\mu$  and standard deviation is  $\\sigma$",
+        "bbox": [
+            112,
+            175,
+            468,
+            191
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "equation",
+        "text": "\n$$\n\\operatorname {E n e r g y} (\\mathbf {E}) = \\sum_ {\\mathrm {t}, \\mathrm {r} = 1} ^ {\\mathrm {T}, \\mathrm {R}} \\mathbf {q} (\\mathrm {t}, \\mathrm {r}) ^ {2} \\tag {17}\n$$\n",
+        "text_format": "latex",
+        "bbox": [
+            112,
+            199,
+            856,
+            220
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "equation",
+        "text": "\n$$\n\\text {H o m o g e n e i t y} (\\mathbf {H}) = \\sum_ {\\mathrm {t}, \\mathrm {r} = 1} ^ {\\mathrm {T}, \\mathrm {R}} \\mathbf {q} (\\mathrm {t}, \\mathrm {r}) / (1 + | \\mathrm {t} - \\mathrm {r} |) \\tag {18}\n$$\n",
+        "text_format": "latex",
+        "bbox": [
+            112,
+            228,
+            856,
+            250
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "equation",
+        "text": "\n$$\n\\text {M e a n} (\\mu) = \\frac {1}{T * R} * \\sum_ {t = 1} ^ {T} \\sum_ {r = 1} ^ {R} q (t, r) \\tag {19}\n$$\n",
+        "text_format": "latex",
+        "bbox": [
+            112,
+            258,
+            856,
+            285
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "equation",
+        "text": "\n$$\n\\text {S t a n d a r d D e v i a t i o n} (\\boldsymbol {\\sigma}) = \\sqrt [ 2 ]{\\frac {1}{T * R} * \\sum_ {t = 1} ^ {T} \\sum_ {r = 1} ^ {R} \\left(\\mathbf {q} (t , r) - \\mu\\right)} \\tag {20}\n$$\n",
+        "text_format": "latex",
+        "bbox": [
+            112,
+            292,
+            856,
+            329
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "equation",
+        "text": "\n$$\n\\text {K u r t o s i s} (\\mathbf {K}) = \\left\\{\\frac {1}{T * R} * \\sum_ {t = 1} ^ {T} \\sum_ {r = 1} ^ {R} \\left(\\left(\\mathbf {q} (t, r) - \\mu\\right) / \\sigma\\right) ^ {\\wedge} 4 \\right\\} - 3 \\tag {21}\n$$\n",
+        "text_format": "latex",
+        "bbox": [
+            112,
+            335,
+            856,
+            363
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "equation",
+        "text": "\n$$\n\\operatorname {S k e w n e s s} (\\boldsymbol {\\sigma}) = \\sqrt [ 2 ]{\\frac {1}{T * R} * \\sum_ {t = 1} ^ {T} \\sum_ {r = 1} ^ {R} \\left(\\mathbf {q} (t , r) - \\mu\\right)} \\tag {22}\n$$\n",
+        "text_format": "latex",
+        "bbox": [
+            112,
+            369,
+            856,
+            406
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "equation",
+        "text": "\n$$\n\\text {V a r i a n c e} (\\mathbf {V a r}) = \\frac {1}{T * R} * \\sum_ {t = 1} ^ {T} \\sum_ {r = 1} ^ {R} (\\mathbf {q} (t, r) - \\mu) \\tag {23}\n$$\n",
+        "text_format": "latex",
+        "bbox": [
+            112,
+            414,
+            856,
+            440
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "equation",
+        "text": "\n$$\n\\text {S m o o t h n e s s} (\\mathbf {R}) = 1 - 1 / \\left(1 + \\sigma^ {2}\\right) \\tag {24}\n$$\n",
+        "text_format": "latex",
+        "bbox": [
+            112,
+            446,
+            856,
+            464
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "equation",
+        "text": "\n$$\n\\operatorname {I D M} (\\mathbf {H H}) = \\sum_ {\\mathrm {t}, \\mathrm {r} = 1} ^ {\\mathrm {T}, \\mathrm {R}} \\frac {\\mathbf {q} (\\mathrm {t} , \\mathrm {r})}{1 + | \\mathrm {t} - \\mathrm {r} |} \\tag {25}\n$$\n",
+        "text_format": "latex",
+        "bbox": [
+            112,
+            472,
+            856,
+            501
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "equation",
+        "text": "\n$$\n\\operatorname {R M S} (\\mathbf {y}) = \\sqrt [ 2 ]{\\sum_ {\\mathrm {t} , \\mathrm {r} = 1} ^ {\\mathrm {T} , \\mathrm {R}} \\left(\\left| \\mathbf {q} (\\mathrm {t} , \\mathrm {r}) \\right|\\right) ^ {2} / \\mathrm {T}} \\tag {26}\n$$\n",
+        "text_format": "latex",
+        "bbox": [
+            112,
+            508,
+            856,
+            545
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "equation",
+        "text": "\n$$\n\\operatorname {E n t r o p y} (\\mathbf {h}) = - \\sum_ {\\mathrm {t}, \\mathrm {r} = 1} ^ {\\mathrm {T}, \\mathrm {R}} \\mathbf {q} (\\mathrm {t}, \\mathrm {r}) \\left(\\log \\mathbf {q} (\\mathrm {t}, \\mathrm {r})\\right) \\tag {27}\n$$\n",
+        "text_format": "latex",
+        "bbox": [
+            112,
+            551,
+            856,
+            574
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "e. Random Forest",
+        "text_level": 1,
+        "bbox": [
+            112,
+            584,
+            277,
+            598
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Random Forest [23] is an ensemble classifier formed by the fusion of many decision trees. It calculates the result on the basis of the majority voting method. Random forest is more superior then the decision tree as it overcomes the problem of over-fitting. As a tree grows deep, they start to over-fit, i.e., they have low bias and high variance. Random forest uses the different parts of the same training dataset on different trees and helps them averaging multiple decision trees and avoid over-fitting, which increases bias and reduces variance, which boosts performance. Internal working of random forest is shown in Fig.5. We are using 100 decision trees, which are trained using training data consisting of 2172 images by concept of bagging.",
+        "bbox": [
+            109,
+            607,
+            883,
+            748
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "page_number",
+        "text": "8",
+        "bbox": [
+            870,
+            939,
+            882,
+            950
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "image",
+        "img_path": "images/6778354d145f8663203c52eee5d103d27fd99143dbb6f3265e344a9f41c0d0dc.jpg",
+        "image_caption": [
+            "Fig. 5 Internal working of Random Forest"
+        ],
+        "image_footnote": [],
+        "bbox": [
+            184,
+            103,
+            883,
+            340
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "f. Decision Tree",
+        "text_level": 1,
+        "bbox": [
+            111,
+            380,
+            264,
+            396
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Decision Tree [24] is like a conditional control statements, which performs the research operations such as decision analysis. There occurs the problem of over-fitting when trees become deep enough. It is like a tree structure, where each node represents attribute or feature on bases of which one can get the outcome. Each leaf node holds the information related to the class label. Working of decision tree is shown in Fig.6. Features are used as internal nodes of the tree and class are leaf nodes.",
+        "bbox": [
+            109,
+            404,
+            883,
+            508
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "image",
+        "img_path": "images/4637b2787f95e0c253ec04f2933a82ce16c5d7da20d005238569d093bc421b20.jpg",
+        "image_caption": [
+            "Fig. 6 Working of Decision Tree"
+        ],
+        "image_footnote": [],
+        "bbox": [
+            388,
+            518,
+            700,
+            588
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "g. K-Nearest Neighbor",
+        "text_level": 1,
+        "bbox": [
+            111,
+            628,
+            318,
+            647
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "KNN [25] is a lazy learning technique in which functions are locally approximation. It can be used for both classification and regression. In which weights assign to neighbors based on distance, i.e., if the distance is  $d$ , then weights assign as  $1 / d$  such that nearest neighbors contribute more than distant. It has little time complexity because training consists of just calculating the Euclidean distance. Euclidean Distance Measurement is shown in Fig.7. We have two classes, one represented by using square and other by triangle. Now, prediction for testing data circle is done based on minimum Euclidean distance measurement.",
+        "bbox": [
+            109,
+            654,
+            883,
+            776
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "page_number",
+        "text": "9",
+        "bbox": [
+            870,
+            939,
+            883,
+            952
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "image",
+        "img_path": "images/d319e6c9af7c2dde65b83a58c987999cbbaa3387ee4a096a2d025d1913dd70c0.jpg",
+        "image_caption": [
+            "Fig. 7 Euclidean Distance Measurement"
+        ],
+        "image_footnote": [],
+        "bbox": [
+            429,
+            88,
+            656,
+            227
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "h. Hybrid Ensemble Classifier",
+        "text_level": 1,
+        "bbox": [
+            111,
+            261,
+            388,
+            279
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Proposed hybrid ensemble classifier KNN-RF-DT shown in Fig. 8, where prediction is considered for at least two-ratio-one voting of classifiers to a specific class such as benign or malignant.",
+        "bbox": [
+            109,
+            285,
+            885,
+            338
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "image",
+        "img_path": "images/c805b2466a6aa75176f56062cebf2d2ead23ea41e8f7b81dd9f01e836a694715.jpg",
+        "image_caption": [
+            "Fig. 8 Proposed Hybrid Ensemble Classifier"
+        ],
+        "image_footnote": [],
+        "bbox": [
+            320,
+            347,
+            740,
+            498
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Algorithm-1 Classification process with Hybrid Ensemble Classifier",
+        "text_level": 1,
+        "bbox": [
+            112,
+            574,
+            661,
+            592
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "list",
+        "sub_type": "text",
+        "list_items": [
+            "1. Mdl1  $\\leftarrow$  Model of KNN with  $K = 1$",
+            "2. Mdl2 - Model of Random Forest with 100 Trees",
+            "3. Mdl3  $\\longleftarrow$  Model of Decision Tree",
+            "4. p1  $\\longleftarrow$  predict from Md11",
+            "5. p2  $\\longleftarrow$  predict from Mdl2",
+            "6. p3 predict from Mdl3",
+            "7. var right  $\\text{一}$  0 and var left 0",
+            "8. if p1 is \"Malignant\" then",
+            "9. right  $\\longleftarrow$  right+1",
+            "10. else",
+            "11. left left+1",
+            "12. end"
+        ],
+        "bbox": [
+            142,
+            599,
+            612,
+            891
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "page_number",
+        "text": "10",
+        "bbox": [
+            862,
+            939,
+            883,
+            952
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "list",
+        "sub_type": "text",
+        "list_items": [
+            "13. if p2 is \"Malignant\" then",
+            "14. right  $\\longleftarrow$  right+1",
+            "15. else",
+            "16. left left+1",
+            "17. end",
+            "18. if p3 is \"Malignant\" then",
+            "19. right  $\\longleftarrow$  right+1",
+            "20. else",
+            "21. left left+1",
+            "22. end",
+            "23. if right is greater then left then",
+            "24. species  $\\leftarrow$  \"Malignant\"",
+            "25. else",
+            "26. species  $\\longleftarrow$  \"Benign\"",
+            "27. end"
+        ],
+        "bbox": [
+            143,
+            95,
+            437,
+            464
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "4. Implementation and Results",
+        "text_level": 1,
+        "bbox": [
+            111,
+            515,
+            383,
+            532
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "a. Dataset used and various SWT filter's Matrix Representations",
+        "text_level": 1,
+        "bbox": [
+            111,
+            540,
+            660,
+            559
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "In the proposed work, Cancer Genome Atlas Glioblastoma Multi-forme (TCGA-GBM) [14] data collection is used to conduct the experimental computation of the proposed approach. This is an open and standard Glioblastoma Multi-forme dataset, which is main type of brain tumor. It is available freely for research work and highly accurate dataset. Hence, no decision from any committee is required on this dataset. The augmentation process is also used to increase dataset such that we have an average of 2556 samples of T1-weighted images used to test the proposed approach, based on testing and training images in ratio 85:15. A distribution of dataset between testing and training is shown in Table.1 and image segmentation using Otsu's method and 1-D SWT filters is shown in Fig. 9.",
+        "bbox": [
+            109,
+            565,
+            883,
+            722
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "table",
+        "img_path": "images/8cad42ea2f64441d7adca8ce8ed8300b201849b7ab3985d9c1ac03d83a855e43.jpg",
+        "table_caption": [
+            "Table 1. Database for Benign and Malignant classification"
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Database</td><td>Training Dataset</td><td>Testing Dataset</td></tr><tr><td>Benign</td><td>1086</td><td>192</td></tr><tr><td>Malignant</td><td>1086</td><td>192</td></tr></table>",
+        "bbox": [
+            120,
+            753,
+            869,
+            834
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "page_number",
+        "text": "11",
+        "bbox": [
+            862,
+            939,
+            882,
+            952
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "image",
+        "img_path": "images/b5f323188982875239d3bbf46db743fe8cf3281f32c65030d014beb966a08ae3.jpg",
+        "image_caption": [
+            "Fig. 9 Results of Otsu's, 1-D SWT filters with Approximation, Horizontal, Vertical and Diagonal matrix."
+        ],
+        "image_footnote": [],
+        "bbox": [
+            125,
+            104,
+            877,
+            645
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "b. Evaluation Metrics and its Graphical Representation",
+        "text_level": 1,
+        "bbox": [
+            111,
+            696,
+            550,
+            713
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "The following parameters such as Accuracy, Precision, Sensitivity, specificity, F1-score, and Youden index are calculated based on proposed methodology with the help of False negative (FN), True Negative (TN), True Positive (TP), False Positive (FP). The equations are given below:",
+        "bbox": [
+            109,
+            720,
+            883,
+            787
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "equation",
+        "text": "\n$$\n\\text {A c c u r a c y} = \\frac {(T P + T N)}{(T P + T N + F P + F N)} \\tag {28}\n$$\n",
+        "text_format": "latex",
+        "bbox": [
+            155,
+            790,
+            841,
+            828
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "equation",
+        "text": "\n$$\n\\text {S e n s i t i v i t y} = \\frac {T P}{(\\mathrm {T P} + \\mathrm {F N})} \\tag {29}\n$$\n",
+        "text_format": "latex",
+        "bbox": [
+            155,
+            829,
+            841,
+            867
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "equation",
+        "text": "\n$$\n\\text {S p e c i f i c i t y} = \\frac {T N}{(\\mathrm {T N} + \\mathrm {F P})} \\tag {30}\n$$\n",
+        "text_format": "latex",
+        "bbox": [
+            155,
+            867,
+            839,
+            904
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "page_number",
+        "text": "12",
+        "bbox": [
+            862,
+            939,
+            882,
+            952
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "equation",
+        "text": "\n$$\n\\text {Y o u d e n I n d e x} = \\text {S e n s i t i v i t y} + \\text {S p e c i f i c i t y} - 1 \\tag {31}\n$$\n",
+        "text_format": "latex",
+        "bbox": [
+            155,
+            89,
+            841,
+            108
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "equation",
+        "text": "\n$$\n\\text {P r e c i s i o n} = \\frac {T P}{(\\mathrm {T P} + \\mathrm {F P})} \\tag {32}\n$$\n",
+        "text_format": "latex",
+        "bbox": [
+            155,
+            108,
+            839,
+            145
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "equation",
+        "text": "\n$$\nF 1 - S c o r e = \\frac {2 * P r e c i s i o n * S e n s i t i v i t y}{P r e c i s i o n + S e n s i t i v i t y} \\tag {33}\n$$\n",
+        "text_format": "latex",
+        "bbox": [
+            155,
+            145,
+            839,
+            184
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "The results obtained in terms of considered evaluation metrics considered are shown in Table 2.",
+        "bbox": [
+            111,
+            191,
+            872,
+            209
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "table",
+        "img_path": "images/439d9ddd96a1dee4a18f874b0b772dde39cd8928814fcb0ebaca3cbfe3ea21eb.jpg",
+        "table_caption": [
+            "Table 2. Classification results of various classifiers and proposed scheme"
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td colspan=\"2\">Classifier</td><td>Accuracy %</td><td>Precision %</td><td>Sensitivity %</td><td>F1-score%</td><td>Youden Index%</td><td>Specifi city%</td></tr><tr><td colspan=\"2\">Proposed Method (KNN-RF-DT)</td><td>97.305</td><td>97.73</td><td>97.04</td><td>97.41</td><td>94.71</td><td>97.60</td></tr><tr><td>SVM</td><td>RBF</td><td>93.038</td><td>92.38</td><td>93.82</td><td>94.79</td><td>89.50</td><td>92.26</td></tr><tr><td>Kern</td><td>Linear</td><td>85.56</td><td>85.20</td><td>86.07</td><td>85.41</td><td>70.72</td><td>85.05</td></tr><tr><td>el</td><td>Polynomial</td><td>89.39</td><td>88.79</td><td>90.22</td><td>90.25</td><td>80.39</td><td>88.58</td></tr><tr><td colspan=\"2\">Naïve Bayes</td><td>81.33</td><td>81.68</td><td>80.83</td><td>81.62</td><td>63.54</td><td>81.85</td></tr><tr><td colspan=\"2\">Decision Tree</td><td>93.157</td><td>93.58</td><td>92.80</td><td>95.45</td><td>90.98</td><td>93.51</td></tr><tr><td colspan=\"2\">Neural Network</td><td>93</td><td>92.57</td><td>93.27</td><td>95.30</td><td>90.61</td><td>92.76</td></tr><tr><td colspan=\"2\">KNN</td><td>94.765</td><td>94.92</td><td>94.30</td><td>94.60</td><td>89.53</td><td>95.23</td></tr></table>",
+        "bbox": [
+            112,
+            258,
+            883,
+            433
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "From the results shown in Table 2, we can conclude that the proposed method with accuracy  $97.305\\%$  outperforms the compared classifiers. We used KNN, RF and DT in hybrid ensemble classifier because they give best performance in terms of various evaluation parameters when compared to other classifiers but it increases time complexity due to computation by three individual classifiers. Accuracy of Random Forest is always greater than the Decision tree due to which RF is included in hybrid ensemble classifier. Sensitivity and Specificity parameters are quite comparable percentage-wise. Sensitivity results describe benign tumors, which are good determinative, as it is merely a total positive divide by the total actual benign tumor. Specificity results describe malignant tumors, which are good determinative, as it is merely a total negative divide by total actual malignant tumor. Youden-index describes the maximum difference between true-positive, and false-positive, high Youden-index means true-positive results are quite high as compared to false positive. F1-score describes the balance between precision and Sensitivity, which is vital as there occur uneven class distribution. Precision describes the percentage of actual positive (TP) among the entire predicted positive  $(\\mathrm{TP} + \\mathrm{FP})$ , which is quite high for the proposed method. Overall, the comparison between the proposed and already existing classification methods, which are implemented in above table is shown below in Fig. 10.",
+        "bbox": [
+            109,
+            440,
+            883,
+            720
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "page_number",
+        "text": "13",
+        "bbox": [
+            862,
+            939,
+            882,
+            952
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "image",
+        "img_path": "images/19e8a688d7b13bb2dcbd464b6ca02354bca58c588f6cd7d0b2a6b37631d452e6.jpg",
+        "image_caption": [
+            "Fig. 10 Comparison of proposed and existing classification methods based on performance metrics."
+        ],
+        "image_footnote": [],
+        "bbox": [
+            122,
+            88,
+            883,
+            354
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "c. Confusion Matrix and GUI",
+        "text_level": 1,
+        "bbox": [
+            112,
+            412,
+            352,
+            429
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "image",
+        "img_path": "images/6b76ae5869e4e4335b51e5c12e6c9092b35d64c5c8925b83a875183aeccd9da1.jpg",
+        "image_caption": [
+            "Fig. 11 Confusion matrix of the proposed method."
+        ],
+        "image_footnote": [],
+        "bbox": [
+            196,
+            440,
+            588,
+            575
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "Confusion matrix for proposed method KNN-RF-DT based on majority voting is shown in Fig.11. 1249 of 1278 benign tumors are classified as benign, while 29 tumors as malignant. Besides, 1239 of 1278 malignant tumors are classified as malignant, while 39 tumors as benign. Overall, a good accuracy of 97.305 is obtained using the proposed method.",
+        "bbox": [
+            109,
+            616,
+            883,
+            686
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "Overall, the proposed method gives excellent performance on various evaluation parameters as described above in comparison to existing methods. Thus, the proposed method is novel and effective to work for the classification of benign and malignant brain tumors.",
+        "bbox": [
+            109,
+            686,
+            883,
+            738
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "GUI for this proposed method makes it more user-friendly, which is implemented in MATLAB 2017a itself shown below in Fig.12",
+        "bbox": [
+            109,
+            738,
+            880,
+            773
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "page_number",
+        "text": "14",
+        "bbox": [
+            862,
+            939,
+            883,
+            952
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "image",
+        "img_path": "images/6563c1d800b09800696dfd240cce8bed5593b1e5a6514a8106fb9b6563b33b8c.jpg",
+        "image_caption": [
+            "Fig. 12 GUI for the above-proposed method in Matlab 2017a."
+        ],
+        "image_footnote": [],
+        "bbox": [
+            117,
+            88,
+            883,
+            375
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "d. Area Calculation for segmented Region",
+        "bbox": [
+            111,
+            406,
+            450,
+            422
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "Area calculation for segmented images is shown below in Table 3 using formula:",
+        "bbox": [
+            111,
+            430,
+            754,
+            448
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "equation",
+        "text": "\n$$\n\\operatorname {I m a g e}, \\mathrm {I} = \\sum_ {w = 0} ^ {2 0 0} \\sum_ {h = 0} ^ {2 0 0} [ \\mathrm {g} (0) + \\mathrm {g} (1) ] \\tag {34}\n$$\n",
+        "text_format": "latex",
+        "bbox": [
+            112,
+            449,
+            856,
+            484
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "equation",
+        "text": "\n$$\n\\text {w h e r e P i x e l s} = \\text {w i d t h (w) * h e i g h t (h)} = 2 0 0 * 2 0 0\n$$\n",
+        "text_format": "latex",
+        "bbox": [
+            173,
+            484,
+            560,
+            501
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "equation",
+        "text": "\n$$\n\\mathrm {g} (0) = \\text {b l a c k p i x e l (d i g i t 0)}\n$$\n",
+        "text_format": "latex",
+        "bbox": [
+            173,
+            503,
+            385,
+            520
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "equation",
+        "text": "\n$$\n\\mathrm {g} (1) = \\text {w h i t e p i x e l (d i g i t 1)}\n$$\n",
+        "text_format": "latex",
+        "bbox": [
+            173,
+            521,
+            380,
+            537
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "equation",
+        "text": "\n$$\n\\text {N o . o f w h i t e p i x e l s ,} \\mathrm {P} = \\sum_ {w = 0} ^ {2 0 0} \\sum_ {h = 0} ^ {2 0 0} [ \\mathrm {g} (1) ], \\tag {35}\n$$\n",
+        "text_format": "latex",
+        "bbox": [
+            112,
+            537,
+            856,
+            575
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "where  $\\mathbf{P}$  is number of white pixels and 1Pixel = .264 mm",
+        "bbox": [
+            173,
+            575,
+            622,
+            590
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "The formula for area calculation as follow:",
+        "bbox": [
+            112,
+            592,
+            454,
+            607
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "equation",
+        "text": "\n$$\n\\text {A r e a} = [ \\operatorname {s q r t} (\\mathrm {P}) ^ {*} \\cdot 2 6 4 ] \\text {i n m m} ^ {2} \\tag {36}\n$$\n",
+        "text_format": "latex",
+        "bbox": [
+            112,
+            609,
+            856,
+            627
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "table",
+        "img_path": "images/c2cb3fcfd6cfe44ab682f39c61184c9fda24fb0dc4c27af9d729062635f7c752.jpg",
+        "table_caption": [
+            "Table 3. Describes the area calculation of segmented images"
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Segmented Images</td><td></td><td></td><td></td><td></td></tr><tr><td>Area (mm2)</td><td>28.6656</td><td>38.5765</td><td>12.3235</td><td>15.2869</td></tr></table>",
+        "bbox": [
+            120,
+            664,
+            841,
+            806
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "e. Analysis of Time Complexity",
+        "bbox": [
+            111,
+            814,
+            370,
+            832
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "This section presents the time complexity of traditional classifiers [18] and the proposed hybrid ensemble classifier and are shown in Table 4. Further, we are comparing the time complexity of proposed method to that of modern deep learning approaches like convolutional neural network (CNN).",
+        "bbox": [
+            109,
+            839,
+            883,
+            909
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "page_number",
+        "text": "15",
+        "bbox": [
+            862,
+            939,
+            882,
+            952
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "For proposed hybrid ensemble classifier, training time complexity is  $O(1 + n^2 p n_{trees} + n^2 p)$  where  $n_{trees}$  represents number of trees of random forest,  $n$ : no. of training samples,  $p$ : no. of features used. Here we have considered  $n_{trees} = 100$ ;  $n = 2172$ , which is 85% of total dataset (2556);  $p = 13$ . Thus,  $O(1 + (2172)^2 * 13 * (100 + 1))$  is equivalent to  $O(6.1942e9)$ .",
+        "bbox": [
+            109,
+            90,
+            883,
+            160
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "text",
+        "text": "Next, we compute training time complexity of deep learning classifiers for instance CNN. CNN consists of an input layer, several convolutional layers, pooling layers, fully connected layers and an output layer. Let us suppose, following represents the architecture of CNN.",
+        "bbox": [
+            109,
+            160,
+            883,
+            212
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "text",
+        "text": "Size (pixels *pixels) of the input image being used ( $I^{*}I = 200^{*}200$ ); Size of kernel ( $S2^{*}S2 = 7^{*}7$ ); No. of kernels ( $N1 = 20$ ) in first Convolutional Layer; Pooling Size  $= 2^{*}2$  Pixels with stride  $= 2$  Pixels; Size of kernel ( $S3^{*}S3 = 4^{*}4$ ), No. of kernels ( $N2 = 10$ ) in second Convolutional Layer; Pooling Size  $= 2^{*}2$  Pixels with stride  $= 2$  Pixels.",
+        "bbox": [
+            109,
+            212,
+            883,
+            281
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "text",
+        "text": "Here we process input image step by step to extract the number of features that become input to Fully connected layers of CNN. When first convolutional layer kernels are applied we get  $200 - 7 + 1$  by  $200 - 7 + 1$  size with  $\\mathrm{N}1 = 20$  matrix i.e.  $194^{*}194$  size 20 matrices. When we apply pool layer we get  $194 / 2$  by  $194 / 2$  size with  $\\mathrm{N}1 = 20$  matrices i.e.  $97^{*}97$  size 20 matrices. In second convolution layer, kernels are applied to the output of first convolutional layers and we get  $97 - 4 + 1$  by  $97 - 4 + 1$  size  $\\mathrm{N}1^{*}\\mathrm{N}2$  matrices i.e.  $94^{*}94$  size 200 matrices. When we apply pool layer we get  $94 / 2$  by  $94 / 2$  size 200 matrices i.e.  $47^{*}47$  size 200 matrices. Now this  $47^{*}47^{*}200$  becomes the input to the fully connected layer, which is nothing but the simple Feed-forward backpropagation neural network. So, here training time complexity of the model (Fully connected layers) is  $O(nt^{*}(pj +jk))$ , where  $n = 2172$ : no. of training set,  $t = 1000$ : no. of epochs and  $p = 47^{*}47^{*}200$  (input layer),  $j = 20$  (hidden layer),  $k = 2$  (output layer) i.e. O(2172*1000(47*47*200*20+20*2)) = O(1.9192e13).",
+        "bbox": [
+            109,
+            282,
+            883,
+            491
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "text",
+        "text": "Training time complexity of proposed hybrid model is O(6.1942e9), which is quite less as compared to the training time complexity of deep learning classifiers like CNN O(1.9192e13) for same set of parameters. In reality, training time complexity of CNN will be much more than what we have calculated here. Because in present calculation, we have taken same number of training dataset for proposed and CNN but in reality number of dataset images would be much higher than 2172 for CNN method and so is the number of neurons required in hidden layer as well.",
+        "bbox": [
+            109,
+            491,
+            883,
+            611
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "text",
+        "text": "Overall, we conclude that the proposed hybrid ensemble classifier provides good accuracy at the expense of increased the training time complexity in comparison to traditional classifiers like DT, SVM, and KNN etc. However, it has significantly less training time complexity as compared to modern deep learning methods like CNN and provides the comparative accuracy.",
+        "bbox": [
+            109,
+            613,
+            883,
+            702
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "table",
+        "img_path": "images/2465998f1b00c87b10c08f7de1cff102df531cf05d09f866450deb129ba60456.jpg",
+        "table_caption": [
+            "Table.4. Describes the time complexity of traditional classifiers"
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Complexity</td><td>Training</td><td>Prediction</td></tr><tr><td rowspan=\"2\">KNN-RF-DT</td><td>O(1+n2pntrees+n2p)</td><td rowspan=\"2\">O(np+ptrees+p)</td></tr><tr><td>where ntrees = 100 i.e. number of trees of random forest, n = 2172: no. of training samples for model, which is 85% of total dataset (2556), p = 13: no. of features used.</td></tr><tr><td>Decision Tree</td><td>O(n2p)</td><td>O(p)</td></tr><tr><td>SVM (rbf)</td><td>O(n2p+n3)</td><td>O(nsvp), where nsv = 1</td></tr><tr><td>KNN</td><td>O(1)</td><td>O(np)</td></tr><tr><td>Neural Network</td><td>O(nt*(pj +jk)) \nwhere t = 1000: no. of epochs and p=13(input \nlayer), j=20(hidden layer), k=2 (output layer)</td><td>O(pj+jk) \nwhere p = 13 (input \nlayer), j = 20 (hidden \nlayer), k = 2 (output \nlayer)</td></tr><tr><td>Naïve Bayes</td><td>O(np)</td><td>O(p)</td></tr><tr><td>Random Forest</td><td>O(n2pntrees)</td><td>O(pntrees)</td></tr></table>",
+        "bbox": [
+            104,
+            729,
+            885,
+            897
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "page_number",
+        "text": "16",
+        "bbox": [
+            862,
+            939,
+            883,
+            952
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "table",
+        "img_path": "",
+        "table_caption": [],
+        "table_footnote": [],
+        "bbox": [
+            106,
+            88,
+            885,
+            218
+        ],
+        "page_idx": 16
+    },
+    {
+        "type": "text",
+        "text": "5. Conclusion",
+        "text_level": 1,
+        "bbox": [
+            111,
+            250,
+            230,
+            265
+        ],
+        "page_idx": 16
+    },
+    {
+        "type": "text",
+        "text": "The proposed work aims at improving the performance of traditional classifiers. As traditional classifiers have an advantage over deep learning algorithms because they require small datasets for training and have low computational time complexity. Image is segmented using otsu's method, features are extracted by using SWT+PCA+GLCM, and finally, classification is done based on hybrid ensemble classifier KNN-RF-DT. The proposed method is novel and useful as it outperforms the already existing methods based on machine learning. Experiments are conducted with software MATLAB 2017a with a personal computer of 4 GB memory, Windows 10 64-bit operating system, and Intel (R) Core (TM) i3-6006U CPU @ 2.00 GHz. Overall, proposed method achieved accuracy of  $97.305\\%$ , precision  $97.73\\%$ , specificity  $97.60\\%$ , Sensitivity  $97.04\\%$ , Youden-index  $94.71\\%$ , and F1-score  $97.41\\%$  which indicates its authenticity over medical images. In future, other hybridization ideas will be investigated like Neural Network-SVM, Neural Network-KNN, Neural Network-RF, Neural Network-DT and Neural Network - Naïve Bayes to further improve the accuracy.",
+        "bbox": [
+            109,
+            273,
+            883,
+            501
+        ],
+        "page_idx": 16
+    },
+    {
+        "type": "text",
+        "text": "References",
+        "text_level": 1,
+        "bbox": [
+            112,
+            508,
+            209,
+            523
+        ],
+        "page_idx": 16
+    },
+    {
+        "type": "list",
+        "sub_type": "ref_text",
+        "list_items": [
+            "[1]. Özyurt, F., Sert, E., Avci, E., & Dogantekin, E. (2019). Brain tumor detection based on Convolutional Neural Network with neutrosophic expert maximum fuzzy sure entropy. Measurement, 147, 106830.",
+            "[2]. Abd-Ellah, M. K., Awad, A. I., Khalaf, A. A., & Hamed, H. F. (2019). A review on brain tumor diagnosis from MRI images: Practical implications, key achievements, and lessons learned. Magnetic resonance imaging.",
+            "[3]. Wadhwa, A., Bhardwaj, A., & Verma, V. S. (2019). A review on brain tumor segmentation of MRI images. Magnetic resonance imaging.",
+            "[4]. Othman, M. F. B., Abdullah, N. B., & Kamal, N. F. B. (2011, April). MRI brain classification using support vector machine. In 2011 Fourth International Conference on Modeling, Simulation and Applied Optimization (pp. 1-4). IEEE.",
+            "[5]. Sindhumol, S., Kumar, A., & Balakrishnan, K. (2013). Spectral clustering independent component analysis for tissue classification from brain MRI. Biomedical Signal Processing and Control, 8(6), 667-674.",
+            "[6]. Abd-Ellah, M. K., Awad, A. I., Khalaf, A. A., & Hamed, H. F. (2016, September). Classification of brain tumor MRIs using a kernel support vector machine. In International Conference on Well-Being in the Information Society (pp. 151-160). Springer, Cham.",
+            "[7]. Kalbkhani, H., Shayesteh, M. G., & Zali-Vargahan, B. (2013). Robust algorithm for brain magnetic resonance image (MRI) classification based on GARCH variances series. Biomedical Signal Processing and Control, 8(6), 909-919."
+        ],
+        "bbox": [
+            112,
+            532,
+            883,
+            882
+        ],
+        "page_idx": 16
+    },
+    {
+        "type": "page_number",
+        "text": "17",
+        "bbox": [
+            862,
+            939,
+            882,
+            952
+        ],
+        "page_idx": 16
+    },
+    {
+        "type": "list",
+        "sub_type": "ref_text",
+        "list_items": [
+            "[8]. Saritha, M., Joseph, K. P., & Mathew, A. T. (2013). Classification of MRI brain images using combined wavelet entropy based spider web plots and probabilistic neural network. Pattern Recognition Letters, 34(16), 2151-2156.",
+            "[9]. Deepa, S. N., & Devi, B. A. (2012, January). Artificial neural networks design for classification of brain tumour. In 2012 International Conference on Computer Communication and Informatics (pp. 1-6). IEEE.",
+            "[10]. Chandra, S., Bhat, R., & Singh, H. (2009, December). A PSO based method for detection of brain tumors from MRI. In 2009 World Congress on Nature & Biologically Inspired Computing (NaBIC) (pp. 666-671). IEEE.",
+            "[11]. Xuan, X., & Liao, Q. (2007, August). Statistical structure analysis in MRI brain tumor segmentation. In Fourth International Conference on Image and Graphics (ICIG 2007) (pp. 421-426). IEEE.",
+            "[12]. Dhanalakshmi, P., & Kanimozhi, T. (2013). Automatic segmentation of brain tumor using K-Means clustering and its area calculation. International Journal of advanced electrical and Electronics Engineering, 2(2), 130-134.",
+            "[13]. Kaushik, D., Singh, U., Singhal, P., & Singh, V. (2014). Brain tumor segmentation using genetic algorithm. In International Journal of Computer Applications®(IJCA)(0975-8887) International Conference on Advances in Computer Engineering & Applications (ICACEA-2014) at IMSEC, GZB.",
+            "[14]. Brain Tumor dataset available online: https://wiki.cancerimagingarchive.net/display/Public/TCGA-GBM",
+            "[15]. Chaudhary, J., Rani, R., Kamboj, A., “Deep learning-based approach for segmentation of glioma sub-regions in MRI”. International Journal of Intelligent Computing and Cybernetics (2020).",
+            "[16]. Rani, R., Kamboj, A., \"Brain Tumor Classification for MR Imaging Using Support Vector Machine\". In Progress in Advanced Computing and Intelligent Engineering (pp. 165-176). Springer, Singapore (2019).",
+            "[17]. Kamboj, A., Rani, R., Chaudhary, J., “Deep learning approaches for brain tumor segmentation: A review”. In 2018 First International Conference on Secure Cyber Computing and Communication (ICSCCC) (pp. 599-603). IEEE.",
+            "[18]. Time complexity analysis of various Classifiers: https://www.thekerneltrip.com/machine/learning/computational-complexity-learning-algorithms/",
+            "[19]. Sezgin, M., & Sankur, B., “Survey over image thresholding techniques and quantitative performance evaluation”. Journal of Electronic imaging, 13(1), 146-166, 2014.",
+            "[20]. Shensa, M, J., “The discrete wavelet transform: wedding the a trous and Mallat algorithms”. IEEE Transactions on signal processing, 40(10), 2464-2482, 1992.",
+            "[21]. Jolliffe, I. T., \"Principal component analysis\". Technometrics, 45(3), 276, 2003.",
+            "[22]. Haralick, R. M., Shanmugam, K., Dinstein, I. H., \"Textural features for image classification\". IEEE Transactions on systems, man, and cybernetics, (6), 610-621, 1973.",
+            "[23]. Prinzie, A., Van den Poel, D., “Random multiclass classification: Generalizing random forests to random mnl and random nb”. In International Conference on Database and Expert Systems Applications (pp. 349-358). Springer, Berlin, Heidelberg, 2007.",
+            "[24]. Karimi, K., Hamilton, H. J. \"Generation and interpretation of temporal decision rules\". arXiv preprint arXiv:1004.3334, 2010.",
+            "[25]. Altman, N. S. “An introduction to kernel and nearest-neighbor nonparametric regression”. The American Statistician, 46(3), 175-185, 1992."
+        ],
+        "bbox": [
+            112,
+            89,
+            883,
+            892
+        ],
+        "page_idx": 17
+    },
+    {
+        "type": "page_number",
+        "text": "18",
+        "bbox": [
+            862,
+            939,
+            883,
+            952
+        ],
+        "page_idx": 17
+    }
+]

data/2021/2101_00xxx/2101.00216/full.md

@@ -1,3 +1,440 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:7083fe889241d4a4d8945a1e2fd513b4444e2539b9cd158f1ea080c43c8bcb78
-size 46370
+# Brain Tumor Detection and Classification based on Hybrid Ensemble Classifier
+
+Ginni Garg<sup>1</sup>, Ritu Garg
+
+Department of Computer Engineering
+
+National Institute of Technology, Kurukshetra, 136119
+
+gargginni01@gmail.com, ritu.59@gmail.com
+
+Abstract: To improve patient survival and treatment outcomes, early diagnosis of brain tumors is an essential task. It is a difficult task to evaluate the magnetic resonance imaging (MRI) images manually. Thus, there is a need for digital methods for tumor diagnosis with better accuracy. However, it is still a very challenging task in assessing their shape, volume, boundaries, tumor detection, size, segmentation, and classification. In this proposed work, we propose a hybrid ensemble method using Random Forest (RF), K-Nearest Neighbour, and Decision Tree (DT) (KNN-RF-DT) based on Majority Voting Method. It aims to calculate the area of the tumor region and classify brain tumors as benign and malignant. In the beginning, segmentation is done by using Otsu's Threshold method. Feature Extraction is done by using Stationary Wavelet Transform (SWT), Principle Component Analysis (PCA), and Gray Level Co-occurrence Matrix (GLCM), which gives thirteen features for classification. The classification is done by hybrid ensemble classifier (KNN-RF-DT) based on the Majority Voting method. Overall it aimed at improving the performance by traditional classifiers instead of going to deep learning. Traditional classifiers have an advantage over deep learning algorithms because they require small datasets for training and have low computational time complexity, low cost to the users, and can be easily adopted by less skilled people. Overall, our proposed method is tested upon dataset of 2556 images, which are used in 85:15 for training and testing respectively and gives good accuracy of  $97.305\%$ .
+
+Keyword: Otsu's Threshold; SWT; PCA; GLCM; hybrid ensemble Classifier (KNN-RF-DT) based on Majority Voting method.
+
+# 1. Introduction
+
+A brain tumor is a cancerous or non-cancerous growth of abnormal cells in the brain, which leads to benign or malignant brain tumors. Most of the researchers are engaging in the primary type of tumor such as Gliomas. We have some ways to treat gliomas such as chemotherapy, radiotherapy, and surgery. Automation by computer-aided devices can be used to obtain the necessary clinical data such as tumor presence, location, and type. However, it is still a very challenging task in assessing their shape, volume, boundaries, tumor detection, size, segmentation, and classification. Also, brain tumor intensity varies from individual to individual. Magnetic Resonance Imaging (MRI) is preferred over other treatment and diagnosis methods because it gives superior image contrast in soft tissues and has non-invasive property. On applying different pulse sequences, we obtain a different type of MRI scans, such as (1) T1 weighted scans that distinguish between tumor and healthy tissues. (2) T2 weighted scans cause delineation of the edema region, and ultimately we get a bright image region. (3) T4-Gd scans which gives bright signal at tumor border by using a contrast agent. (4) FLAIR scans differentiate between cerebrospinal fluid (CSF) and edema region by using a signal of water molecule suppression. It is a difficult task to do annotation of brain tumors from MRI scans manually. Hence, there is a strong need for automation of brain tumor segmentation and classification with the help of computer vision and machine learning algorithms. Today,
+
+researchers are working on computer vision and machine learning algorithms for brain tumor segmentation and classification. Clinician's plans are highly expensive because they depend on various imaging techniques such as PET, MRI, and CT. The clinical methods provide extract pertinent information and comprehensive analysis from images. Computational techniques help to investigate the details present in medical images. Imaging methods can be used to find the position of brain tumors. MRI provides more meaningful information in contrast to other imaging modalities like CT.
+
+The challenging task in Brain Tumor is due to high variability and inherent MRI data characteristics, e.g., variability in tumor sizes or shapes, tumor detection, area calculation, segmentation, classification, and finding uncertainty in segmented region. The most significant task in image understanding is image segmentation because it helps in feature extraction, area calculation, and significance in many real-life applications. It can be used, for example, estimation of tumor volume, tissue classification, blood cell delineation, and localization of tumors, matching of an atlas, surgical planning, and image registration. For monitoring oncologic therapy, the accurate and morphology quantification of tumors is a critical task. However, extensive scale work has been performed in this field; but still; clinicians depend on manual determination of tumor, due to lack of link between researchers and clinicians.
+
+Recently, many techniques have been proposed for automatic brain tumor classification that can be categorized into machine learning (ML) and deep learning (DL) techniques based on the feature selection and learning mechanism. In ML approaches, feature selection and extraction is essential for classification. However, DL approaches extract and learn the features from the image directly. Recent DL approaches, particularly CNN provides good accuracy and is widely used in medical image analysis. Moreover, they have disadvantage over traditional methods (ML) as they need large dataset for training, have high time complexity, less accurate for applications where we have availability of small dataset and require expensive GPUs which ultimately increases cost to the users. Additionally, selecting the right deep learning tools is also a challenging task as it needs knowledge regarding various parameters, training method, and topology. On the other hand, machine-learning approaches have played key role in the area of medical imaging. Several learning based classifiers have already been used for classification and detection of brain tumors, which includes - support vector machine (SVM), artificial neural network (ANN), sequential minimal optimization (SMO), fuzzy C mean (FCM), Naive Bayes (NB), Random Forest (RF), Decision Tree (DT) and K-Nearest Neighbor (KNN). KNN implementation is very simple and takes less computation and space complexity. It requires very less parameters to tune. The biggest advantage of DT is that it goes through all the outcomes of decision and finally traces each path to reach the conclusion. It is versatile; no complex mathematics involved, which makes it easy to understand. Further, Random Forest is itself ensemble classifiers of DT. It runs effectively on large dataset, which provides good parameter values for accuracies, precision and other evaluation metrics. Overall, these classifiers have received considerable research attention, as they require small dataset for training, low computational time complexity, low cost to the users, and can be easily adopted by less skilled people. Thus, in the present study, we work on hybrid ensemble classifiers in order to improve the accuracy of results obtained. Further, comparative study of various classifiers such as SVM, KNN, DT, RF, NB, ANN and proposed hybrid ensemble classifier is done.
+
+The outline of the paper is as follows: Section 2 describes the related work; Section 3 describes the proposed method for area calculation and brain tumor classification. Section 4
+
+gives information about experimental implementation and results, and Finally, Section 5 represents conclusion.
+
+# 2. Related Work
+
+Brain Tumor research has been conducted in various private multinational companies like, Siemens, Becton Dickinson, Medtronic, Accenture, GE Medical Systems, Atlantic Biomedical P. Ltd, and others. Both theoretical and experimental works of International arena are reported in the literature. Some of work done by good researchers is described below:
+
+Othman [4] et al. proposed a method in which feature extraction is done by using Daubechies wavelets with DWT from MRI images. Each image consists of 17,689 feature vectors. Finally, classification is done using RBF a SVM kernel function. Sindhumol et al. [4] presents a spectral clustering (SC) technique for classification of brain tumor. Images (MRI) are divided into different clusters using the spectral distance. Feature reduction is made by using ICA and classification by using SVM. The training and testing data consists of 40 normal and 20 abnormal MRI images. Abd-Ellah [6] et al. proposed method consists of preprocessing of MRI images is done with the help of Median filters. DW does feature extraction, and PCA is used for feature reduction. Finally, classification is done by the SVM classifier using the RBF kernel function. The database consists of 80 images. SVM is trained using 43 abnormal and 5 normal images, and testing is done by using 27 abnormal images and 5 normal images. H. Kalbkhani [7] et al., proposed the subband of the detail coefficients and 2D DWT using (GARCH), Feature reduction is made from 61440 to 24 features. Feature extraction is done by linear discriminate analysis (LDA), which is further reduced using PCA. Finally, detection is done by using SVM and KNN identifier. The training and testing data consists of MRI images, normal and abnormal in ratio 10 to 70. The testing set consists of 7 normal and 49 abnormal images, while the training set contains 3 normal and 21 abnormal images. Saritha et al. [8] proposed classification technique for normal or abnormal brain tumor images considering 23 images for testing and 50 for training. Deep and Devi [9] et al., proposed a system in which the statistical method is used for texture feature extraction, neural network, and BPNN is used in segmentation and uncovering stages. The database consists of 42 images, which are further divided into training and testing as 30 and 12, respectively. Chandra [10] et al. proposed a new clustering algorithm based on PSO optimization with the help of MRI images. The clusters and corresponding centroids are being found out by algorithm, among them global best is considered. The dataset consists of 62 normal MRI images and 110 abnormal ones. Xuan and Liao [11], proposed a tumor detection method considering features of 3-types texture-based, intensity-based and symmetry-based. Then, total 40 features consisting of 13 intensity-based, 26 texture-based and 1 symmetry-based features are selected. Feature extraction is done from different images with 12 features from T2 images, 9 from T1 images and 19 from FLAIR images. The dataset contains 10 patients with 3 volumes each with 24 slices of MRI images. They divided the dataset equally into testing and training sets. Dhanalakshmi [12] et al., proposed work consist of k-means clustering for segmentation and then area is calculated using formula sqrt(P).*264, where P is the no. of pixel with value 1. The proposed algorithm shows the reproducibility and good performance. Kaushik [13] et al., proposed method consists of segmentation using genetic algorithm. The corners of the brain tumor region are also extracted based on proposed algorithm. Rani [16] et al., proposed a method for MRI brain tumor image classification using SVM and segmentation using otsu's thresholding method. This paper compared its proposed work with KIFCM, K-means an Fuzzy c-means but their accuracy and executive time was more effective than all remaining existing methods.
+
+Additionally, many deep learning models have been investigated recently for brain tumor detection and classification and achieved the competitive results. Chaudhary [15] et al., proposed a method based on deep learning for the segmentation of MRI brain tumor images. In which pre processing of MRI images was done using intensity normalization. Kamboj [17] et al., reviewed deep learning methods, which has advantages over traditional methods. Their focus is on design of architecture as compare to segmentation and feature extraction. Deep learning methods provide good accuracy but they required more computation time, space and dataset as compare to the traditional classifiers. However, traditional machine learning methods are easy to understand, interpret and required less space, dataset and computational cost in terms of hardware.
+
+Moreover, none of the above mentioned machine learning approaches work on feature extraction using 3-fold techniques such as  $\mathrm{SWT + PCA + GLCM}$ , which significantly increases the robustness of extracted features as SwT helped in capturing the abrupt changes of images. PCA reduced the dimensionality of input images from SwT, which reduced space and time complexity up to some extent. Finally, GLCM extracted various useful features from dimensionally reduced images of PCA. In addition, none of the above methods worked on hybrid ensemble classifiers, which helped in achieving good evaluation metrics using traditional classifiers, as best properties of each classifier add up to gave excellent results. Therefore, overall 3-fold robust feature extraction and hybrid ensemble classification is the main focus of interest in this present study, which helped in improving the various evaluation metrics and reduced space and time complexity using traditional classifiers.
+
+# 3. Proposed Method
+
+The proposed work aims at improving the performance of traditional classifiers. These classifiers require small datasets for training and have low computational time complexity thus appropriate for computer assisted brain tumor diagnosis and classification. We propose a hybrid ensemble method using KNN, Random Forest (RF) and Decision Tree (DT) (KNN-RF-DT) based on Majority Voting Method. It aims to calculate the area of the tumor region and classify brain tumors as benign and malignant. In the beginning, MRI images segments using the Otsu's Threshold method. Feature Extraction is done by Stationary Wavelet Transform (SWT), Principle Component Analysis (PCA) and Gray Level Co-occurrence Matrix (GLCM), which gives thirteen features for classification. The classification is done by hybrid ensemble classifiers (KNN-RF-DT) based on the Majority Voting method.
+
+In the current research work, we have done comparative studies of various classifiers such as SVM, KNN, DT, RF, NB, ANN and proposed hybrid ensemble Classifier. Overall, it aimed at improving the performance by using traditional classifiers. Working of proposed implementation is shown in Fig.1.
+
+![](images/7c3a1a1c26d9b73a8edce55c3f657b56cd438fe31e1b242251d01b76d39268ef.jpg)  
+Fig. 1 Flow diagram of proposed work
+
+# a. Otsu's Method
+
+Otsu method [19] is used for the automatic image threshold into two classed, foreground, and background based on a single threshold value. This threshold determines by maximizing inter-class variance and minimizing intra-class intensity variance. Threshold that minimizes the intra-class variance that describes by corresponding sum of variance of two classes:
+
+$$
+\alpha_ {\mathrm {w}} ^ {2} (\mathbf {n}) = \mathrm {A} _ {0} (\mathbf {n}) ^ {*} \alpha_ {0} ^ {2} (\mathbf {n}) + \mathrm {A} _ {1} (\mathbf {n}) ^ {*} \alpha_ {1} ^ {2} (\mathbf {n}), \tag {1}
+$$
+
+where  $A_0, A_1 -$  Probability of two classes,  $n = 154$ - Threshold,  $\alpha_0^2, \alpha_1^2 -$  Variance of two classes. The Class Probability can be computed from the number of bins (L=256) as shown below:
+
+$$
+\mathrm {A} _ {0} (\mathbf {n}) = \sum_ {k = 0} ^ {n - 1} \mathrm {p} (\mathbf {k}) \tag {2}
+$$
+
+$$
+\mathrm {A} _ {1} (\mathbf {n}) = \sum_ {k = n} ^ {L - 1} \mathrm {p} (\mathbf {k}), \tag {3}
+$$
+
+where we know that minimum intra-class variance is equivalent to the maximum inter-class variance.
+
+$$
+\alpha_ {\mathrm {b}} ^ {2} (\mathbf {n}) = \alpha^ {2} - \alpha_ {\mathrm {w}} ^ {2} (\mathbf {n}) = \mathrm {A} _ {0} ^ {*} \left(\beta_ {0} - \beta_ {\mathrm {T}}\right) ^ {2} + \mathrm {A} _ {1} ^ {*} \left(\beta_ {1} - \beta_ {\mathrm {T}}\right) ^ {2} = \mathrm {A} _ {0} (\mathbf {n}) ^ {*} \mathrm {A} _ {1} (\mathbf {n}) ^ {*} \left(\beta_ {0} - \beta_ {1}\right) ^ {2}, \tag {4}
+$$
+
+where  $\beta_{1}(\mathbf{n}),\beta_{0}(\mathbf{n})$  and  $\beta_{\mathrm{T}}$  are class means
+
+$$
+\beta_ {0} (\mathbf {n}) = = \sum_ {\mathbf {k} = 0} ^ {n - 1} \mathbf {k} * \mathrm {p} (\mathbf {k}) / \mathrm {A} _ {0} (\mathbf {n}) \tag {5}
+$$
+
+$$
+\beta_ {1} (\mathbf {n}) = = \sum_ {\mathbf {k} = n} ^ {L - 1} \mathbf {k} * \mathrm {p} (\mathbf {k}) / \mathrm {A} _ {1} (\mathbf {n}) \tag {6}
+$$
+
+$$
+\beta_ {\mathrm {T}} = = \sum_ {\mathbf {k} = 0} ^ {L - 1} \mathbf {k} * \mathrm {p} (\mathbf {k}) \tag {7}
+$$
+
+$$
+\mathrm {A} _ {0} * \beta_ {0} + \mathrm {A} _ {1} * \beta_ {1} = \beta_ {\mathrm {T}} \tag {8}
+$$
+
+$$
+\mathrm {A} _ {0} + \mathrm {A} _ {1} = 1 \tag {9}
+$$
+
+Above computations, give us effective algorithm as class probability and class means computed iteratively. Histogram of brain tumor image with bins 256 and threshold 154 is shown below in Fig.2.
+
+![](images/752848fb12b89cb6fa4b9176b464b1f286d5e94d98c8ffaaf23d0a3ba3a372e3.jpg)  
+Fig. 2 Histogram of brain tumor image with bins  $\mathrm{L} = 256$  and threshold  $\mathrm{n} = 154$
+
+# b. Stationary Wavelet Transform
+
+As far as signal is concerned, slow changes can be captured with the help of Fourier Transform, whereas when the images undergo abrupt changes that can be captured with the concept of wavelets. Wavelet is a small oscillation whose frequency inversely varies with scaling. To capture abrupt changes, we need high frequency and small scaling so we need the concept of wavelet. Stationary Wavelet Transform (SWT) [20] algorithm is designed to overcome the problem of translation-invariance of the discrete wavelet transform (DWT). Translation-invariance can be achieved by removing the down-samples and up-samples in the DWT and up sampling the filter coefficients by a factor of  $2^{(\mathrm{j - 1})}$  in the  $\mathrm{j^th}$  level of algorithm. SWT has various applications such as - Signal de-noising, Pattern Recognition, Brain image classification, Pathological brain detection. In our proposed work, we work on 1-D SWT, where  $\mathrm{j} = 1$ .
+
+The origin of the wavelets and its types from Fourier transform is shown in Fig.3.
+
+![](images/4a8c46b51b221dd70bff31d2c60ee055fe9f4cf87dbf8533c7a5fe73005dc845.jpg)  
+Fig. 3 Origin of SWT
+
+The digital implementation of SwT is shown below in Fig. 4 in which each level is an upsampled version of the previous level.
+
+Decomposition Step
+
+![](images/1abe9229b8882387176b5ef953f8c7876bfc283a70f7780f8677418b8875454a.jpg)
+
+Filter computation
+
+![](images/f7cb507d399f1ae6c63010e03e7f39d054aa753e6203c5a0e478886f51c35252.jpg)
+
+![](images/2ff41a776eb6f756747069fc71a0769f538f0ba2828ff84e56aae2a2122bd813.jpg)
+
+Fig. 4 Implementation of SWT in which each level is an up-sampled version of the previous level  
+![](images/45ee83afb8556db9572282017eda4e4ccc1b5b32aee1faae355d11fe5b79d72e.jpg)  
+Initialization:  $\mathrm{cA}_0 = \mathrm{s}$  and  $\mathrm{F}_0 = \mathrm{Lo\_D}$  and  $\mathrm{G}_0 = \mathrm{Hi\_D}$
+
+# c. Principal Component Analysis
+
+PCA [21] is an orthogonal transformation of correlated variables to linearly uncorrelated variables known as principal components. The first principal component has the highest variances; successive components contain the most significant possible variance such that it remains orthogonal to previous components. It is used to reduce the dimensions or features with which we have to train our classifier, which ultimately helps in reducing the time and space complexity for given data computation.
+
+# First Component
+
+$$
+\mathrm {Y} _ {(1)} = \arg \max  _ {| \mathrm {Y} | = 1} \left\{\Sigma_ {\mathrm {k}} \left(\mathrm {t} _ {1}\right) _ {(\mathrm {k})} ^ {2} \right\} = \arg \max  _ {| \mathrm {Y} | = 1} \left\{\Sigma_ {\mathrm {k}} \left(\mathbf {X} _ {(\mathrm {k})}. \mathrm {Y}\right) ^ {2} \right\}, \tag {10}
+$$
+
+Where  $\mathbf{Y}_{(1)}$  denotes the unit vector and  $\mathbf{X}$  is Image matrix.
+
+Equation in matrix form:
+
+$$
+\mathbf {Y} _ {(1)} = \arg \max  _ {| \mathrm {Y} | = 1} \left\{\| \mathbf {X Y} \| ^ {2} \right\} = \arg \max  _ {| \mathrm {Y} | = 1} \left\{\mathbf {Y} ^ {\mathrm {T}} \mathbf {X} ^ {\mathrm {T}} \mathbf {X Y} \right\} \tag {11}
+$$
+
+$$
+\mathbf {Y} _ {(1)} = \arg \max  \left\{\mathbf {Y} ^ {\mathrm {T}} \mathbf {X} ^ {\mathrm {T}} \mathbf {X Y} / \mathbf {Y} ^ {\mathrm {T}} \mathbf {Y} \right\} \tag {12}
+$$
+
+Largest Eigen value of the matrix is Rayleigh Quotient, where  $\mathbf{X}^{\mathrm{T}}\mathbf{X}$  is positive semi-definite matrix and  $\mathbf{Y} =$  corresponding Eigen vector
+
+# Further Components
+
+The Nth component can be found by subtracting the first N-1 principle component from  $\mathbf{X}$ , where  $\mathbf{N} = 13$  for proposed method.
+
+$$
+\mathbf {X} _ {\mathbf {N}} = \mathrm {X} - \sum_ {n = 1} ^ {N - 1} \mathbf {X Y} (\mathrm {n}) \mathrm {Y} (\mathrm {n}) ^ {\wedge} \mathrm {T} \tag {13}
+$$
+
+Further, weight vector can be found as describe below:
+
+$$
+\mathbf {Y} _ {(K)} = \arg \max  _ {\| \mathbf {Y} \| = 1} \left\{\| \mathbf {X} _ {K} ^ {*} \mathbf {Y} \| ^ {2} \right\} = \arg \max  \left\{\mathbf {Y} ^ {\mathrm {T}} \mathbf {X} _ {K} ^ {\mathrm {T}} \mathbf {X} _ {K} \mathbf {Y} / \mathbf {Y} ^ {\mathrm {T}} \mathbf {Y} \right\} \tag {14}
+$$
+
+# d. Gray-Level Co-occurrence Matrix
+
+It is a statistical method that describes the spatial relationship of pixels based on the spatial grey-level dependence matrix. GLCM [22] calculates the texture of the image by calculating the frequency of corresponding pixels and their spatial relationships. All the thirteen features which are used in proposed work as follow contrast, correlation, energy, homogeneity, mean, standard deviation, kurtosis, skewness, variance, smoothness, IDM, RMS, entropy. There detailed information is given below:
+
+$$
+\text {C o n t r a s t} (\mathbf {C}) = \sum_ {\mathrm {t}, \mathrm {r} = 1} ^ {\mathrm {T}, \mathrm {R}} | \mathrm {t} - \mathrm {r} | ^ {2} \mathbf {q} (\mathrm {t}, \mathrm {r}), \tag {15}
+$$
+
+where,  $\mathbf{q}(\mathrm{t},\mathrm{r})$  is GLCM, t & r are row & column,T is total rows and R is total columns.
+
+$$
+\text {C o r r e l a t i o n} (\operatorname {C o r r}) = \sum_ {\mathrm {t}, \mathrm {r} = 1} ^ {\mathrm {T}, \mathrm {R}} \left((\mathrm {t} - \mu) (\mathrm {r} - \mu) \mathbf {q} (\mathrm {t}, \mathrm {r})\right) / (\sigma (\mathrm {t}) * \sigma (\mathrm {r})), \tag {16}
+$$
+
+where, mean is  $\mu$  and standard deviation is  $\sigma$
+
+$$
+\operatorname {E n e r g y} (\mathbf {E}) = \sum_ {\mathrm {t}, \mathrm {r} = 1} ^ {\mathrm {T}, \mathrm {R}} \mathbf {q} (\mathrm {t}, \mathrm {r}) ^ {2} \tag {17}
+$$
+
+$$
+\text {H o m o g e n e i t y} (\mathbf {H}) = \sum_ {\mathrm {t}, \mathrm {r} = 1} ^ {\mathrm {T}, \mathrm {R}} \mathbf {q} (\mathrm {t}, \mathrm {r}) / (1 + | \mathrm {t} - \mathrm {r} |) \tag {18}
+$$
+
+$$
+\text {M e a n} (\mu) = \frac {1}{T * R} * \sum_ {t = 1} ^ {T} \sum_ {r = 1} ^ {R} q (t, r) \tag {19}
+$$
+
+$$
+\text {S t a n d a r d D e v i a t i o n} (\boldsymbol {\sigma}) = \sqrt [ 2 ]{\frac {1}{T * R} * \sum_ {t = 1} ^ {T} \sum_ {r = 1} ^ {R} \left(\mathbf {q} (t , r) - \mu\right)} \tag {20}
+$$
+
+$$
+\text {K u r t o s i s} (\mathbf {K}) = \left\{\frac {1}{T * R} * \sum_ {t = 1} ^ {T} \sum_ {r = 1} ^ {R} \left(\left(\mathbf {q} (t, r) - \mu\right) / \sigma\right) ^ {\wedge} 4 \right\} - 3 \tag {21}
+$$
+
+$$
+\operatorname {S k e w n e s s} (\boldsymbol {\sigma}) = \sqrt [ 2 ]{\frac {1}{T * R} * \sum_ {t = 1} ^ {T} \sum_ {r = 1} ^ {R} \left(\mathbf {q} (t , r) - \mu\right)} \tag {22}
+$$
+
+$$
+\text {V a r i a n c e} (\mathbf {V a r}) = \frac {1}{T * R} * \sum_ {t = 1} ^ {T} \sum_ {r = 1} ^ {R} (\mathbf {q} (t, r) - \mu) \tag {23}
+$$
+
+$$
+\text {S m o o t h n e s s} (\mathbf {R}) = 1 - 1 / \left(1 + \sigma^ {2}\right) \tag {24}
+$$
+
+$$
+\operatorname {I D M} (\mathbf {H H}) = \sum_ {\mathrm {t}, \mathrm {r} = 1} ^ {\mathrm {T}, \mathrm {R}} \frac {\mathbf {q} (\mathrm {t} , \mathrm {r})}{1 + | \mathrm {t} - \mathrm {r} |} \tag {25}
+$$
+
+$$
+\operatorname {R M S} (\mathbf {y}) = \sqrt [ 2 ]{\sum_ {\mathrm {t} , \mathrm {r} = 1} ^ {\mathrm {T} , \mathrm {R}} \left(\left| \mathbf {q} (\mathrm {t} , \mathrm {r}) \right|\right) ^ {2} / \mathrm {T}} \tag {26}
+$$
+
+$$
+\operatorname {E n t r o p y} (\mathbf {h}) = - \sum_ {\mathrm {t}, \mathrm {r} = 1} ^ {\mathrm {T}, \mathrm {R}} \mathbf {q} (\mathrm {t}, \mathrm {r}) \left(\log \mathbf {q} (\mathrm {t}, \mathrm {r})\right) \tag {27}
+$$
+
+# e. Random Forest
+
+Random Forest [23] is an ensemble classifier formed by the fusion of many decision trees. It calculates the result on the basis of the majority voting method. Random forest is more superior then the decision tree as it overcomes the problem of over-fitting. As a tree grows deep, they start to over-fit, i.e., they have low bias and high variance. Random forest uses the different parts of the same training dataset on different trees and helps them averaging multiple decision trees and avoid over-fitting, which increases bias and reduces variance, which boosts performance. Internal working of random forest is shown in Fig.5. We are using 100 decision trees, which are trained using training data consisting of 2172 images by concept of bagging.
+
+![](images/6778354d145f8663203c52eee5d103d27fd99143dbb6f3265e344a9f41c0d0dc.jpg)  
+Fig. 5 Internal working of Random Forest
+
+# f. Decision Tree
+
+Decision Tree [24] is like a conditional control statements, which performs the research operations such as decision analysis. There occurs the problem of over-fitting when trees become deep enough. It is like a tree structure, where each node represents attribute or feature on bases of which one can get the outcome. Each leaf node holds the information related to the class label. Working of decision tree is shown in Fig.6. Features are used as internal nodes of the tree and class are leaf nodes.
+
+![](images/4637b2787f95e0c253ec04f2933a82ce16c5d7da20d005238569d093bc421b20.jpg)  
+Fig. 6 Working of Decision Tree
+
+# g. K-Nearest Neighbor
+
+KNN [25] is a lazy learning technique in which functions are locally approximation. It can be used for both classification and regression. In which weights assign to neighbors based on distance, i.e., if the distance is  $d$ , then weights assign as  $1 / d$  such that nearest neighbors contribute more than distant. It has little time complexity because training consists of just calculating the Euclidean distance. Euclidean Distance Measurement is shown in Fig.7. We have two classes, one represented by using square and other by triangle. Now, prediction for testing data circle is done based on minimum Euclidean distance measurement.
+
+![](images/d319e6c9af7c2dde65b83a58c987999cbbaa3387ee4a096a2d025d1913dd70c0.jpg)  
+Fig. 7 Euclidean Distance Measurement
+
+# h. Hybrid Ensemble Classifier
+
+Proposed hybrid ensemble classifier KNN-RF-DT shown in Fig. 8, where prediction is considered for at least two-ratio-one voting of classifiers to a specific class such as benign or malignant.
+
+![](images/c805b2466a6aa75176f56062cebf2d2ead23ea41e8f7b81dd9f01e836a694715.jpg)  
+Fig. 8 Proposed Hybrid Ensemble Classifier
+
+# Algorithm-1 Classification process with Hybrid Ensemble Classifier
+
+1. Mdl1  $\leftarrow$  Model of KNN with  $K = 1$  
+2. Mdl2 - Model of Random Forest with 100 Trees  
+3. Mdl3  $\longleftarrow$  Model of Decision Tree  
+4. p1  $\longleftarrow$  predict from Md11  
+5. p2  $\longleftarrow$  predict from Mdl2  
+6. p3 predict from Mdl3  
+7. var right  $\text{一}$  0 and var left 0  
+8. if p1 is "Malignant" then  
+9. right  $\longleftarrow$  right+1  
+10. else  
+11. left left+1  
+12. end
+
+13. if p2 is "Malignant" then  
+14. right  $\longleftarrow$  right+1  
+15. else  
+16. left left+1  
+17. end  
+18. if p3 is "Malignant" then  
+19. right  $\longleftarrow$  right+1  
+20. else  
+21. left left+1  
+22. end  
+23. if right is greater then left then  
+24. species  $\leftarrow$  "Malignant"  
+25. else  
+26. species  $\longleftarrow$  "Benign"  
+27. end
+
+# 4. Implementation and Results
+
+# a. Dataset used and various SWT filter's Matrix Representations
+
+In the proposed work, Cancer Genome Atlas Glioblastoma Multi-forme (TCGA-GBM) [14] data collection is used to conduct the experimental computation of the proposed approach. This is an open and standard Glioblastoma Multi-forme dataset, which is main type of brain tumor. It is available freely for research work and highly accurate dataset. Hence, no decision from any committee is required on this dataset. The augmentation process is also used to increase dataset such that we have an average of 2556 samples of T1-weighted images used to test the proposed approach, based on testing and training images in ratio 85:15. A distribution of dataset between testing and training is shown in Table.1 and image segmentation using Otsu's method and 1-D SWT filters is shown in Fig. 9.
+
+Table 1. Database for Benign and Malignant classification  
+
+<table><tr><td>Database</td><td>Training Dataset</td><td>Testing Dataset</td></tr><tr><td>Benign</td><td>1086</td><td>192</td></tr><tr><td>Malignant</td><td>1086</td><td>192</td></tr></table>
+
+![](images/b5f323188982875239d3bbf46db743fe8cf3281f32c65030d014beb966a08ae3.jpg)  
+Fig. 9 Results of Otsu's, 1-D SWT filters with Approximation, Horizontal, Vertical and Diagonal matrix.
+
+# b. Evaluation Metrics and its Graphical Representation
+
+The following parameters such as Accuracy, Precision, Sensitivity, specificity, F1-score, and Youden index are calculated based on proposed methodology with the help of False negative (FN), True Negative (TN), True Positive (TP), False Positive (FP). The equations are given below:
+
+$$
+\text {A c c u r a c y} = \frac {(T P + T N)}{(T P + T N + F P + F N)} \tag {28}
+$$
+
+$$
+\text {S e n s i t i v i t y} = \frac {T P}{(\mathrm {T P} + \mathrm {F N})} \tag {29}
+$$
+
+$$
+\text {S p e c i f i c i t y} = \frac {T N}{(\mathrm {T N} + \mathrm {F P})} \tag {30}
+$$
+
+$$
+\text {Y o u d e n I n d e x} = \text {S e n s i t i v i t y} + \text {S p e c i f i c i t y} - 1 \tag {31}
+$$
+
+$$
+\text {P r e c i s i o n} = \frac {T P}{(\mathrm {T P} + \mathrm {F P})} \tag {32}
+$$
+
+$$
+F 1 - S c o r e = \frac {2 * P r e c i s i o n * S e n s i t i v i t y}{P r e c i s i o n + S e n s i t i v i t y} \tag {33}
+$$
+
+The results obtained in terms of considered evaluation metrics considered are shown in Table 2.
+
+Table 2. Classification results of various classifiers and proposed scheme  
+
+<table><tr><td colspan="2">Classifier</td><td>Accuracy %</td><td>Precision %</td><td>Sensitivity %</td><td>F1-score%</td><td>Youden Index%</td><td>Specifi city%</td></tr><tr><td colspan="2">Proposed Method (KNN-RF-DT)</td><td>97.305</td><td>97.73</td><td>97.04</td><td>97.41</td><td>94.71</td><td>97.60</td></tr><tr><td>SVM</td><td>RBF</td><td>93.038</td><td>92.38</td><td>93.82</td><td>94.79</td><td>89.50</td><td>92.26</td></tr><tr><td>Kern</td><td>Linear</td><td>85.56</td><td>85.20</td><td>86.07</td><td>85.41</td><td>70.72</td><td>85.05</td></tr><tr><td>el</td><td>Polynomial</td><td>89.39</td><td>88.79</td><td>90.22</td><td>90.25</td><td>80.39</td><td>88.58</td></tr><tr><td colspan="2">Naïve Bayes</td><td>81.33</td><td>81.68</td><td>80.83</td><td>81.62</td><td>63.54</td><td>81.85</td></tr><tr><td colspan="2">Decision Tree</td><td>93.157</td><td>93.58</td><td>92.80</td><td>95.45</td><td>90.98</td><td>93.51</td></tr><tr><td colspan="2">Neural Network</td><td>93</td><td>92.57</td><td>93.27</td><td>95.30</td><td>90.61</td><td>92.76</td></tr><tr><td colspan="2">KNN</td><td>94.765</td><td>94.92</td><td>94.30</td><td>94.60</td><td>89.53</td><td>95.23</td></tr></table>
+
+From the results shown in Table 2, we can conclude that the proposed method with accuracy  $97.305\%$  outperforms the compared classifiers. We used KNN, RF and DT in hybrid ensemble classifier because they give best performance in terms of various evaluation parameters when compared to other classifiers but it increases time complexity due to computation by three individual classifiers. Accuracy of Random Forest is always greater than the Decision tree due to which RF is included in hybrid ensemble classifier. Sensitivity and Specificity parameters are quite comparable percentage-wise. Sensitivity results describe benign tumors, which are good determinative, as it is merely a total positive divide by the total actual benign tumor. Specificity results describe malignant tumors, which are good determinative, as it is merely a total negative divide by total actual malignant tumor. Youden-index describes the maximum difference between true-positive, and false-positive, high Youden-index means true-positive results are quite high as compared to false positive. F1-score describes the balance between precision and Sensitivity, which is vital as there occur uneven class distribution. Precision describes the percentage of actual positive (TP) among the entire predicted positive  $(\mathrm{TP} + \mathrm{FP})$ , which is quite high for the proposed method. Overall, the comparison between the proposed and already existing classification methods, which are implemented in above table is shown below in Fig. 10.
+
+![](images/19e8a688d7b13bb2dcbd464b6ca02354bca58c588f6cd7d0b2a6b37631d452e6.jpg)  
+Fig. 10 Comparison of proposed and existing classification methods based on performance metrics.
+
+# c. Confusion Matrix and GUI
+
+![](images/6b76ae5869e4e4335b51e5c12e6c9092b35d64c5c8925b83a875183aeccd9da1.jpg)  
+Fig. 11 Confusion matrix of the proposed method.
+
+Confusion matrix for proposed method KNN-RF-DT based on majority voting is shown in Fig.11. 1249 of 1278 benign tumors are classified as benign, while 29 tumors as malignant. Besides, 1239 of 1278 malignant tumors are classified as malignant, while 39 tumors as benign. Overall, a good accuracy of 97.305 is obtained using the proposed method.
+
+Overall, the proposed method gives excellent performance on various evaluation parameters as described above in comparison to existing methods. Thus, the proposed method is novel and effective to work for the classification of benign and malignant brain tumors.
+
+GUI for this proposed method makes it more user-friendly, which is implemented in MATLAB 2017a itself shown below in Fig.12
+
+![](images/6563c1d800b09800696dfd240cce8bed5593b1e5a6514a8106fb9b6563b33b8c.jpg)  
+Fig. 12 GUI for the above-proposed method in Matlab 2017a.
+
+d. Area Calculation for segmented Region
+
+Area calculation for segmented images is shown below in Table 3 using formula:
+
+$$
+\operatorname {I m a g e}, \mathrm {I} = \sum_ {w = 0} ^ {2 0 0} \sum_ {h = 0} ^ {2 0 0} [ \mathrm {g} (0) + \mathrm {g} (1) ] \tag {34}
+$$
+
+$$
+\text {w h e r e P i x e l s} = \text {w i d t h (w) * h e i g h t (h)} = 2 0 0 * 2 0 0
+$$
+
+$$
+\mathrm {g} (0) = \text {b l a c k p i x e l (d i g i t 0)}
+$$
+
+$$
+\mathrm {g} (1) = \text {w h i t e p i x e l (d i g i t 1)}
+$$
+
+$$
+\text {N o . o f w h i t e p i x e l s ,} \mathrm {P} = \sum_ {w = 0} ^ {2 0 0} \sum_ {h = 0} ^ {2 0 0} [ \mathrm {g} (1) ], \tag {35}
+$$
+
+where  $\mathbf{P}$  is number of white pixels and 1Pixel = .264 mm
+
+The formula for area calculation as follow:
+
+$$
+\text {A r e a} = [ \operatorname {s q r t} (\mathrm {P}) ^ {*} \cdot 2 6 4 ] \text {i n m m} ^ {2} \tag {36}
+$$
+
+Table 3. Describes the area calculation of segmented images  
+
+<table><tr><td>Segmented Images</td><td></td><td></td><td></td><td></td></tr><tr><td>Area (mm2)</td><td>28.6656</td><td>38.5765</td><td>12.3235</td><td>15.2869</td></tr></table>
+
+e. Analysis of Time Complexity
+
+This section presents the time complexity of traditional classifiers [18] and the proposed hybrid ensemble classifier and are shown in Table 4. Further, we are comparing the time complexity of proposed method to that of modern deep learning approaches like convolutional neural network (CNN).
+
+For proposed hybrid ensemble classifier, training time complexity is  $O(1 + n^2 p n_{trees} + n^2 p)$  where  $n_{trees}$  represents number of trees of random forest,  $n$ : no. of training samples,  $p$ : no. of features used. Here we have considered  $n_{trees} = 100$ ;  $n = 2172$ , which is 85% of total dataset (2556);  $p = 13$ . Thus,  $O(1 + (2172)^2 * 13 * (100 + 1))$  is equivalent to  $O(6.1942e9)$ .
+
+Next, we compute training time complexity of deep learning classifiers for instance CNN. CNN consists of an input layer, several convolutional layers, pooling layers, fully connected layers and an output layer. Let us suppose, following represents the architecture of CNN.
+
+Size (pixels *pixels) of the input image being used ( $I^{*}I = 200^{*}200$ ); Size of kernel ( $S2^{*}S2 = 7^{*}7$ ); No. of kernels ( $N1 = 20$ ) in first Convolutional Layer; Pooling Size  $= 2^{*}2$  Pixels with stride  $= 2$  Pixels; Size of kernel ( $S3^{*}S3 = 4^{*}4$ ), No. of kernels ( $N2 = 10$ ) in second Convolutional Layer; Pooling Size  $= 2^{*}2$  Pixels with stride  $= 2$  Pixels.
+
+Here we process input image step by step to extract the number of features that become input to Fully connected layers of CNN. When first convolutional layer kernels are applied we get  $200 - 7 + 1$  by  $200 - 7 + 1$  size with  $\mathrm{N}1 = 20$  matrix i.e.  $194^{*}194$  size 20 matrices. When we apply pool layer we get  $194 / 2$  by  $194 / 2$  size with  $\mathrm{N}1 = 20$  matrices i.e.  $97^{*}97$  size 20 matrices. In second convolution layer, kernels are applied to the output of first convolutional layers and we get  $97 - 4 + 1$  by  $97 - 4 + 1$  size  $\mathrm{N}1^{*}\mathrm{N}2$  matrices i.e.  $94^{*}94$  size 200 matrices. When we apply pool layer we get  $94 / 2$  by  $94 / 2$  size 200 matrices i.e.  $47^{*}47$  size 200 matrices. Now this  $47^{*}47^{*}200$  becomes the input to the fully connected layer, which is nothing but the simple Feed-forward backpropagation neural network. So, here training time complexity of the model (Fully connected layers) is  $O(nt^{*}(pj +jk))$ , where  $n = 2172$ : no. of training set,  $t = 1000$ : no. of epochs and  $p = 47^{*}47^{*}200$  (input layer),  $j = 20$  (hidden layer),  $k = 2$  (output layer) i.e. O(2172*1000(47*47*200*20+20*2)) = O(1.9192e13).
+
+Training time complexity of proposed hybrid model is O(6.1942e9), which is quite less as compared to the training time complexity of deep learning classifiers like CNN O(1.9192e13) for same set of parameters. In reality, training time complexity of CNN will be much more than what we have calculated here. Because in present calculation, we have taken same number of training dataset for proposed and CNN but in reality number of dataset images would be much higher than 2172 for CNN method and so is the number of neurons required in hidden layer as well.
+
+Overall, we conclude that the proposed hybrid ensemble classifier provides good accuracy at the expense of increased the training time complexity in comparison to traditional classifiers like DT, SVM, and KNN etc. However, it has significantly less training time complexity as compared to modern deep learning methods like CNN and provides the comparative accuracy.
+
+Table.4. Describes the time complexity of traditional classifiers  
+
+<table><tr><td>Complexity</td><td>Training</td><td>Prediction</td></tr><tr><td rowspan="2">KNN-RF-DT</td><td>O(1+n2pntrees+n2p)</td><td rowspan="2">O(np+ptrees+p)</td></tr><tr><td>where ntrees = 100 i.e. number of trees of random forest, n = 2172: no. of training samples for model, which is 85% of total dataset (2556), p = 13: no. of features used.</td></tr><tr><td>Decision Tree</td><td>O(n2p)</td><td>O(p)</td></tr><tr><td>SVM (rbf)</td><td>O(n2p+n3)</td><td>O(nsvp), where nsv = 1</td></tr><tr><td>KNN</td><td>O(1)</td><td>O(np)</td></tr><tr><td>Neural Network</td><td>O(nt*(pj +jk)) 
+where t = 1000: no. of epochs and p=13(input 
+layer), j=20(hidden layer), k=2 (output layer)</td><td>O(pj+jk) 
+where p = 13 (input 
+layer), j = 20 (hidden 
+layer), k = 2 (output 
+layer)</td></tr><tr><td>Naïve Bayes</td><td>O(np)</td><td>O(p)</td></tr><tr><td>Random Forest</td><td>O(n2pntrees)</td><td>O(pntrees)</td></tr></table>
+
+# 5. Conclusion
+
+The proposed work aims at improving the performance of traditional classifiers. As traditional classifiers have an advantage over deep learning algorithms because they require small datasets for training and have low computational time complexity. Image is segmented using otsu's method, features are extracted by using SWT+PCA+GLCM, and finally, classification is done based on hybrid ensemble classifier KNN-RF-DT. The proposed method is novel and useful as it outperforms the already existing methods based on machine learning. Experiments are conducted with software MATLAB 2017a with a personal computer of 4 GB memory, Windows 10 64-bit operating system, and Intel (R) Core (TM) i3-6006U CPU @ 2.00 GHz. Overall, proposed method achieved accuracy of  $97.305\%$ , precision  $97.73\%$ , specificity  $97.60\%$ , Sensitivity  $97.04\%$ , Youden-index  $94.71\%$ , and F1-score  $97.41\%$  which indicates its authenticity over medical images. In future, other hybridization ideas will be investigated like Neural Network-SVM, Neural Network-KNN, Neural Network-RF, Neural Network-DT and Neural Network - Naïve Bayes to further improve the accuracy.
+
+# References
+
+[1]. Özyurt, F., Sert, E., Avci, E., & Dogantekin, E. (2019). Brain tumor detection based on Convolutional Neural Network with neutrosophic expert maximum fuzzy sure entropy. Measurement, 147, 106830.  
+[2]. Abd-Ellah, M. K., Awad, A. I., Khalaf, A. A., & Hamed, H. F. (2019). A review on brain tumor diagnosis from MRI images: Practical implications, key achievements, and lessons learned. Magnetic resonance imaging.  
+[3]. Wadhwa, A., Bhardwaj, A., & Verma, V. S. (2019). A review on brain tumor segmentation of MRI images. Magnetic resonance imaging.  
+[4]. Othman, M. F. B., Abdullah, N. B., & Kamal, N. F. B. (2011, April). MRI brain classification using support vector machine. In 2011 Fourth International Conference on Modeling, Simulation and Applied Optimization (pp. 1-4). IEEE.  
+[5]. Sindhumol, S., Kumar, A., & Balakrishnan, K. (2013). Spectral clustering independent component analysis for tissue classification from brain MRI. Biomedical Signal Processing and Control, 8(6), 667-674.  
+[6]. Abd-Ellah, M. K., Awad, A. I., Khalaf, A. A., & Hamed, H. F. (2016, September). Classification of brain tumor MRIs using a kernel support vector machine. In International Conference on Well-Being in the Information Society (pp. 151-160). Springer, Cham.  
+[7]. Kalbkhani, H., Shayesteh, M. G., & Zali-Vargahan, B. (2013). Robust algorithm for brain magnetic resonance image (MRI) classification based on GARCH variances series. Biomedical Signal Processing and Control, 8(6), 909-919.
+
+[8]. Saritha, M., Joseph, K. P., & Mathew, A. T. (2013). Classification of MRI brain images using combined wavelet entropy based spider web plots and probabilistic neural network. Pattern Recognition Letters, 34(16), 2151-2156.  
+[9]. Deepa, S. N., & Devi, B. A. (2012, January). Artificial neural networks design for classification of brain tumour. In 2012 International Conference on Computer Communication and Informatics (pp. 1-6). IEEE.  
+[10]. Chandra, S., Bhat, R., & Singh, H. (2009, December). A PSO based method for detection of brain tumors from MRI. In 2009 World Congress on Nature & Biologically Inspired Computing (NaBIC) (pp. 666-671). IEEE.  
+[11]. Xuan, X., & Liao, Q. (2007, August). Statistical structure analysis in MRI brain tumor segmentation. In Fourth International Conference on Image and Graphics (ICIG 2007) (pp. 421-426). IEEE.  
+[12]. Dhanalakshmi, P., & Kanimozhi, T. (2013). Automatic segmentation of brain tumor using K-Means clustering and its area calculation. International Journal of advanced electrical and Electronics Engineering, 2(2), 130-134.  
+[13]. Kaushik, D., Singh, U., Singhal, P., & Singh, V. (2014). Brain tumor segmentation using genetic algorithm. In International Journal of Computer Applications®(IJCA)(0975-8887) International Conference on Advances in Computer Engineering & Applications (ICACEA-2014) at IMSEC, GZB.  
+[14]. Brain Tumor dataset available online: https://wiki.cancerimagingarchive.net/display/Public/TCGA-GBM  
+[15]. Chaudhary, J., Rani, R., Kamboj, A., “Deep learning-based approach for segmentation of glioma sub-regions in MRI”. International Journal of Intelligent Computing and Cybernetics (2020).  
+[16]. Rani, R., Kamboj, A., "Brain Tumor Classification for MR Imaging Using Support Vector Machine". In Progress in Advanced Computing and Intelligent Engineering (pp. 165-176). Springer, Singapore (2019).  
+[17]. Kamboj, A., Rani, R., Chaudhary, J., “Deep learning approaches for brain tumor segmentation: A review”. In 2018 First International Conference on Secure Cyber Computing and Communication (ICSCCC) (pp. 599-603). IEEE.  
+[18]. Time complexity analysis of various Classifiers: https://www.thekerneltrip.com/machine/learning/computational-complexity-learning-algorithms/  
+[19]. Sezgin, M., & Sankur, B., “Survey over image thresholding techniques and quantitative performance evaluation”. Journal of Electronic imaging, 13(1), 146-166, 2014.  
+[20]. Shensa, M, J., “The discrete wavelet transform: wedding the a trous and Mallat algorithms���. IEEE Transactions on signal processing, 40(10), 2464-2482, 1992.  
+[21]. Jolliffe, I. T., "Principal component analysis". Technometrics, 45(3), 276, 2003.  
+[22]. Haralick, R. M., Shanmugam, K., Dinstein, I. H., "Textural features for image classification". IEEE Transactions on systems, man, and cybernetics, (6), 610-621, 1973.  
+[23]. Prinzie, A., Van den Poel, D., “Random multiclass classification: Generalizing random forests to random mnl and random nb”. In International Conference on Database and Expert Systems Applications (pp. 349-358). Springer, Berlin, Heidelberg, 2007.  
+[24]. Karimi, K., Hamilton, H. J. "Generation and interpretation of temporal decision rules". arXiv preprint arXiv:1004.3334, 2010.  
+[25]. Altman, N. S. “An introduction to kernel and nearest-neighbor nonparametric regression”. The American Statistician, 46(3), 175-185, 1992.

data/2021/2101_00xxx/2101.00288/full.md

@@ -1,3 +1,433 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:118821511b310d0aba4c8a59b49e82a6dc8ad9fff34edb2571085fd11ed0b659
-size 81025
+# POLYJUICE: Generating Counterfactuals for Explaining, Evaluating, and Improving Models
+
+Tongshuang Wu<sup>1</sup>
+
+<sup>1</sup>University of Washington wtshuang@cs.uw.edu
+
+Marco Tulio Ribeiro
+
+2Microsoft Research
+
+marcotcr@microsoft.com
+
+Jeffrey Heer
+
+Daniel S. Weld<sup>1,3</sup>
+
+3Allen Institute for Artificial Intelligence
+
+{jheer,weld} $@$ cs.uw.edu
+
+# Abstract
+
+While counterfactual examples are useful for analysis and training of NLP models, current generation methods either rely on manual labor to create very few counterfactuals, or only instantiate limited types of perturbations such as paraphrases or word substitutions. We present Polyjuice, a general-purpose counterfactual generator that allows for control over perturbation types and locations, trained by finetuning GPT-2 on multiple datasets of paired sentences. We show that Polyjuice produces diverse sets of realistic counterfactuals, which in turn are useful in various distinct applications: improving training and evaluation on three different tasks (with around  $70\%$  less annotation effort than manual generation), augmenting state-of-the-art explanation techniques, and supporting systematic counterfactual error analysis by revealing behaviors easily missed by human experts.
+
+# 1 Introduction
+
+Counterfactual reasoning — mentally simulating what would have happened if conditions were different — is a common tool for making causality assessments (Kahneman and Tversky, 1981), which in turn are crucial for model evaluation, error analysis, and explanation (Miller, 2019). For example, in Figure 1, "It is great for kids" is perturbed into multiple variations, each providing unique insights by simulating what would have happened if the sentence was different.
+
+Applications of counterfactual reasoning to NLP generally specify the relationship  $x \rightarrow \hat{x}$ , and then create  $\hat{x}$  according to the relationship. As a result, prior work has tailored counterfactual generators for different applications, only collecting subsets of  $\hat{x}$  that are useful for the specific task. For example, to support model training and evaluation, human annotators create counterfactuals
+
+![](images/ed4a1c0b1896a588b37838248c8eeef016b792b17f33ce899feac8d5bf46c664.jpg)  
+Figure 1: Overview: (A) given a sentiment analysis instance  $x$ ,  $\text{Polyjuice}^1$  generates (B) various counterfactuals  $\hat{x}$ , which are then (C) selected for downstream use. e.g., in (D) we select counterfactual explanations that complement a black box explanation: though "great" and "kids" are deemed important, perturbing them may not affect the prediction  $f(x) = f(\hat{x}) = \text{positive}$ , revealing model failures not covered by feature attributions.
+
+that change the groundtruth labels by manually rewriting instances (Gardner et al., 2020; Qin et al., 2019) or defining perturbation functions (Ribeiro et al., 2020). Manual rewrites are costly (e.g., 4-5 minutes per counterfactual (Kaushik et al., 2020)) and susceptible to systematic omissions (e.g., human annotators may cover great  $\twoheadrightarrow$  not great, but miss kids  $\twoheadrightarrow$  no one in Figure 1B). Meanwhile, automated generators for model analysis and explanation usually focus on other relationships, e.g., generating  $\hat{x}$  that have different model predictions than  $x$  (Ross et al., 2020; Zhang et al., 2019a). As a result, they neglect prediction-preserving counterfactuals that are equally important for understanding or shaping model behaviors, like kids  $\twoheadrightarrow$  no one and great  $\twoheadrightarrow$  scary linked to Figure 1D.
+
+However, counterfactual generation does not have to be task-specific. The same set of counterfactuals in Figure 1 can support a variety of applica
+
+tions. Moreover, for cases like model explanation and analysis, a general-purpose pool of counterfactuals may be preferable, as the relationship of interest can be more exploratory and user-oriented (Wu et al., 2019). In this work, we formalize the task of counterfactual generation, disentangling generation from the application of counterfactuals. Given an input  $x$  (Figure 1A), our generator produces a set of counterfactuals  $\hat{\mathbf{X}} = \{\hat{x}_1, \hat{x}_2, \dots\}$  with application-agnostic relationships  $x \rightarrow \hat{x}_i$  (Figure 1B). Afterwards, we use application-specific selection methods to find subsets of  $\hat{x}$  that are most effective for a given use case (Figure 1C).
+
+We frame the generation step as conditional text generation, and finetune GPT-2 (Radford et al., 2019) into a generator called Polyjuice using  $(x,\hat{x})$  pairs. To allow for targeted counterfactuals, we also design control codes like negation or delete (Figure 1B), and adopt fill-in-the-blank structures (Donahue et al., 2020) to specify where the perturbation occurs and how. Intrinsic evaluation shows that Polyjuice generates  $\hat{x}$  that are fluent, diverse, and close to  $x$ , and that the control mechanisms retrieve perturbations that would likely not be sampled from off-the-shelf language models.
+
+With simple selection heuristics, we show that a single Polyjuice model can significantly aid humans in diverse downstream applications. For counterfactual training and evaluation (§3), humans label Polyjuice counterfactuals rather than creating them from scratch. They produce training data that significantly improve model generalization, as well as contrast sets that help identify model vulnerabilities (Gardner et al., 2020), with around  $70\%$  less annotation effort. In another application, Polyjuice produces counterfactual explanations (§4), providing significant insight on top of state-of-the-art explanation techniques. Finally, Polyjuice supports counterfactual error analysis (§5). It allows users to explore related counterfactuals (e.g., the model responds differently to different negation forms in Figure 1B), and to aggregate individual counterfactuals into patterns in order to gain systematic understanding of model behavior.
+
+# 2 General-Purpose Counterfactuals
+
+# 2.1 Definition and Desiderata
+
+Given an instance  $x$ , a generator  $g$  produces a set of counterfactuals  $\hat{\mathbf{X}} = \{\hat{x}_1, \hat{x}_2, \ldots\}$  with various re
+
+![](images/f6c438a034616cfd08f2c073b1d3d11052ba51d46e17033a380df1f5d52a1ae9.jpg)  
+Figure 2: (A) POLYJUICE prompt format, which concatenates the original  $x$ , the control code, and the  $\hat{x}$  ("It is not great for children" converted to an infilling structure). At generation time, POLYJUICE accepts prompts that just include  $x$  (Line 1), or optionally with the code and the [BLANK]s (Lines 2-3), and fills in the blanks sequentially with spans separated by [ANSWER]s (Line 4). (B) POLYJUICE allows blanking at different granularities (even the entire sentence), such that Lines 3-4 in (A) can be replaced by Lines 6-7 or 8-9.
+
+relationships  $x \rightarrow \hat{x}_i$ . For example, great  $\rightarrow$  not great, kids  $\rightarrow$  no one in Figure 1B are both instances of the negation relationship. Each  $(x, \hat{x})$  pair shares multiple relationships — these two are also instances of the label flipping relationship if the task is sentiment analysis (but might not be for other tasks). As illustrated in §1, knowing which relationships apply aids selection for downstream applications.
+
+We expect  $g$  to produce counterfactuals  $\hat{x}$  that are (1) close to  $x$ , preferably only involving the minimal changes necessary to establish a certain effect (Pearl, 2018), allowing users to make causality assessments. The generated  $\hat{x}$  should also be (2) fluent, i.e., grammatically correct (Morris et al., 2020) and semantically meaningful (e.g., "Colorless green ideas sleep furiously" is not meaningful (Chomsky, 2002)). Fluency operationalizes "probable" counterfactuals in the context of NLP; as Kahneman and Tversky (1981) stated, humans strongly favor counterfactuals that are close to the original instance, but also prefer those that could have easily happened without assuming rare events or strange coincidences. Further, as a general-purpose generator,  $g$  should produce counterfactuals with a measure of (3) control over relationships  $x \rightarrow \hat{x}$ , such that the counterfactuals can vary with the object-of-attention in each application (the "focus rule" (Kahneman and Tversky, 1981)). Finally, we expect  $g$  to output a (4) diverse set of  $\hat{x}$  in terms of relationships, covering a large variety of "what-ifs" for different applications (Pearl, 2018).
+
+<table><tr><td>Control code</td><td>Definitions and PolYJUICE-generated Examples</td><td>Training Datasets</td></tr><tr><td>negation</td><td>A dog is not embraced by the woman.</td><td>(Kaushik et al., 2020)</td></tr><tr><td>quantifier</td><td>A dog is → Three dogs are embraced by the woman.</td><td>(Gardner et al., 2020)</td></tr><tr><td>shuffle</td><td>To move (or swap) key phrases or entities around the sentence.A dog → woman is embraced by the woman → dog.</td><td>(Zhang et al., 2019b)</td></tr><tr><td>lexical</td><td>To change just one word or noun chunk without altering the POS tags.A dog is embraced → attacked by the woman.</td><td>(Sakaguchi et al., 2020)</td></tr><tr><td>resemantic</td><td>To replace short phrases without altering the remaining dependency tree.A dog is embraced by the woman → wrapped in a blanket.</td><td>(Wieting and Gimpel, 2018)</td></tr><tr><td>insert</td><td>To add short phrases without altering the remaining dependency tree.A dog is embraced by the little woman.</td><td>(McCoy et al., 2019)</td></tr><tr><td>delete</td><td>To remove short phrases without altering the remaining dependency tree.A dog is embraced by the woman.</td><td>(McCoy et al., 2019)</td></tr><tr><td>restructure</td><td>To alter the dependency tree structure, e.g., changing from passive to active.A dog is embraced by → hugging the woman.</td><td>(Wieting and Gimpel, 2018)</td></tr></table>
+
+Table 1: We design a list of control codes to guide generation. We show POLYJUICE-generated counterfactual examples, and the representative training datasets for each corresponding pattern. Details are in Appendix A.
+
+# 2.2 Conditional Counterfactual Generation
+
+We frame counterfactual generation as a conditional text generation task using language models (LMs), and train Polyjuice by finetuning GPT-2 (Radford et al., 2019) using the following prompt design (alternative LMs could also have been used).
+
+Prompt format design. To ensure that  $\hat{x}$  is close to  $x$  rather than arbitrary text, we condition the generation on  $x$ , followed by a special token (Line 1 in Figure 2A). In Line 2, we have control codes (Keskar et al., 2019) such as negation. We design them to specify types of perturbation from among lexical, syntactic, or semantic aspects (see Table 1), inspired by prior work that categorizes manually created counterfactuals (Kaushik et al., 2020; Gardner et al., 2020). As an additional layer of control over  $x \rightarrow \hat{x}$ , we allow users to specify where changes happen by having the LM infill [BLANK] tokens (Donahue et al., 2020), rather than generating arbitrary counterfactuals (Lines 3-4).
+
+Finetuning GPT-2 — a causal LM for predicting next tokens — additionally allows us to exercise control at various levels of granularity. At generation time, if the user provides only the original example, POLYJUICE will generate the control code, the blank locations, and the infilling (Lines 2–4). Alternatively, the user can specify the control code, or the control code and the blanks, to exercise different degrees of control depending on the application. As later shown in §4 and §5, such control is important for different use cases.
+
+Training data. To train a conditional model, we combine six existing sentence-pair datasets, each containing a subset of the desired phenomena in Table 1. Further, we find naturally occurring sentence pairs (filtered by edit distance to guarantee closeness) in non-paired datasets including CommonGen (Lin et al., 2020), Natural Questions (Kwiatkowski et al., 2019), and SQuAD (Rajpurkar et al., 2016), such that the resulting dataset contains diverse counterfactuals.
+
+We translate these sentence pairs into the format given in Figure 2A. For each  $(x, \hat{x})$ , we compute its primary control code using part-of-speech tags and dependency trees. For example, negation occurs when we observe changes to negation modifiers or specific words like "supposedly", and shuffle occurs when we have overlap between tokens deleted and added. When multiple changes occur, we label it with the control code which most significantly changes the semantics of the corresponding subphrase as computed by SBERT (Reimers and Gurevych, 2019). For example, in Figure 2A, negation (great  $\rightarrow$  not great) is more significant than lexical (kids  $\rightarrow$  children). To balance the distribution (Table 7 in Appendix A), for each dataset, we extract control codes from all the  $(x, \hat{x})$ ,<sup>4</sup> and randomly sample up to 10,000 instances per codes.
+
+In order to allow for flexible blanking at generation time, we generate multiple training prompts per pair, covering different dependency tree struc
+
+<table><tr><td rowspan="2">Model</td><td>Diversity</td><td colspan="2">Closeness</td></tr><tr><td>Self-BLEU ↓</td><td>Levenshtein ↓</td><td>Syntactic ↓</td></tr><tr><td>POLYJUICE</td><td>0.34</td><td>0.25</td><td>2.13</td></tr><tr><td>GPT-2</td><td>0.18</td><td>0.70</td><td>6.35</td></tr><tr><td>T5</td><td>0.12</td><td>9,52</td><td>3.50</td></tr><tr><td>RoBERTa</td><td>0.47</td><td>0.14</td><td>1.32</td></tr></table>
+
+Table 2: Intrinsic evaluations: POLYJUICE counterfactuals are closer to the original instance than non-fintuned GPT-2 and T5, and more diverse than RoBERTa. Computational details are in Appendix A.2.
+
+tures related to the perturbed spans (Figure 2B), including (1) just the changed tokens, (2) the associated parsing structures, (3) the merged changes, and (4) the entire sentence. We eventually obtain 657, 144 prompts from 186, 451 pairs.
+
+Fluency filtering. While the original GPT-2 produces fluent text, some combinations of control codes and blanks cause Polyjuice to generate nonsensical results. Following Morris et al. (2020), we score both  $x$  and  $\hat{x}$  with GPT-2, and filter  $\hat{x}$  when the log-probability (on the full sentence or the perturbed chunks) decreases by more than 10 points relative to  $x$ . Fully automated uses of Polyjuice (e.g., adversarial attacks) may benefit from stricter constraints, at the cost of diversity (as surprising changes may be filtered even if they are fluent).
+
+# 2.3 Intrinsic Evaluation
+
+We evaluate POLYJUICE on closeness and diversity by comparing its perturbations on 300 randomly selected sentences with baselines that use more or less context from  $x$ : (1) non-finetuned GPT-2, (2) token-infilling RoBERTa (Liu et al., 2019) and (3) span-infilling T5 (Raffel et al., 2020).
+
+As shown in Table 2, Polyjuice generates counterfactuals that are close to the original instance, measured by syntactic tree (Zhang and Shasha, 1989) and Levenshtein edit distance (Levenshtein, 1966). In contrast, non-finetuned GPT-2 generates arbitrary text instead of perturbations when given the starting tokens of a sentence, as it only leverages context in a single direction. As for infilling models, Polyjuice counterfactuals are more diverse (measured by self-BLEU (Zhu et al., 2018)) than RoBERTa ones, which is restricted to word substitution. Meanwhile, T5 displays higher diversity but less closeness, probably due to the fact that it does not consider the original masked tokens when generating  $\hat{x}$ . For example, in Figure 1 "It is great for kids," T5 replaces "for kids" with "idea", "to
+
+meet you," whereas Polyjuice generates "for kids yet adults can enjoy," "for any audience."
+
+We evaluate controllability by comparing Polyjuice with T5 as well as with GPT-2 finetuned on prompts without codes. We verify that the codes improve the success rate of generating counterfactuals with the desired perturbation types set out in Table 1 by as much as  $42\%$  for perturbations such as negation and insert. For example, given "It is [BLANK] great for kids," baselines generate "also," "fun and," rather than "not" (negation).
+
+We further verify the fluency for Polyjuice counterfactuals in three tasks/datasets: (1) Sentiment Analysis, SST-2 (Socher et al., 2013), (2) Natural Language Inference (NLI), SNLI (Bowman et al., 2015), and (3) Duplicate Question Detection (QQP) (Wang et al., 2019). We randomly select 100 sentences per dataset, generate  $3\hat{x}$  per  $x$ , and ask crowd workers to rate whether they are "likely written by native speakers." The workers rated most counterfactuals as fluent:  $78\%$  in SST-2,  $76\%$  in QQP, and  $86\%$  in SNLI. In subsequent sections, we show these rates are suitable for applications where people "team up" with Polyjuice.
+
+# 3 Counterfactual Evaluation & Training
+
+We ask crowdworkers to label POLYJUICE-generated counterfactuals for Sentiment, NLI, and QQP, for the purposes of evaluation and training. In each labeling round, the worker is presented with an original  $x$  and its label, and asked to annotate the groundtruth for three  $\hat{x}$ , rejecting non-fluent ones (details and interface in Appendix B.1).
+
+We use a simple heuristic to select which counterfactuals are presented for labeling, aimed at increasing diversity. Representing each  $\hat{x}$  by its token changes, control code, and dependency tree structure, we greedily select the ones that are least similar to those already selected for labeling. This avoids redundancy in the labeling set, e.g., common perturbation patterns such as black  $\rightarrow$  white.
+
+# 3.1 Evaluation with Contrast Sets
+
+We verify whether PolyJuice counterfactuals can be used to create contrast sets (Gardner et al., 2020), i.e., evaluation sets where each instance has a nearby counterfactual with a different groundtruth, to better evaluate model decision boundaries. We
+
+<table><tr><td>Task</td><td>Dev.</td><td>Orig. set</td><td>Contrast set ↓</td><td>Consistency ↓</td></tr><tr><td>Sentiment</td><td>94.3</td><td>93.8</td><td>84.9 (-8.9)</td><td>76.1</td></tr><tr><td>NLI</td><td>86.5</td><td>91.6</td><td>72.3 (-19.3)</td><td>56.4</td></tr><tr><td>QQP</td><td>91.7</td><td>87.5</td><td>75.3 (-12.2)</td><td>61.1</td></tr></table>
+
+Table 3: POLYJUICE  $\hat{x}$  as contrasts sets, with model accuracy on the development set, the original set of  $x$ , the contrast sets, and consistency (cases where the model predicts both  $x$  and  $\hat{x}$  correctly). The performance drops are similar to that of expert-created sets (Gardner et al., 2020), on which the accuracy of all classification models decreases by 9.8 on average, with a consistency of  $\approx 64.1$ . This indicates POLYJUICE can be used to create such sets without expert annotators and at less cost.
+
+construct these sets by simply filtering out counterfactuals that are labeled the same as their original instances (40%–63% depending on the task).
+
+For each task, we test multiple classifiers open-sourced by Huggingface (Wolf et al., 2020), and report the best performing model for each in Table 3 (results for other models are analogous). Polyjuice contrast sets display performance gaps consistent with those of Gardner et al. (2020), where the sets are constructed manually by NLP researchers, even though we use non-expert annotators who only label examples rather than creating them.
+
+# 3.2 Training with Counterfactuals
+
+Following Kaushik et al. (2020), we augment training sets with counterfactual examples. In all experiments, we finetune roberta-base on datasets of  $n$  original examples and  $m$  counterfactuals, which are generated by Polyjuice (m-polyjuice) or crafted from scratch by humans (m-CAD from Kaushik et al. (2020), only available for NLI). To distinguish the benefit of counterfactuals from that of just adding more data, we further add a baseline that uses  $n + m$  original examples (m-baseline). In addition to in-domain test set accuracy, we measure models' generalization on out-of-domain datasets, as well as contrast sets and challenge sets. We also evaluate model capabilities with CheckList (Ribeiro et al., 2020) for Sentiment and QQP. Reported model performances are averaged across multiple data samples and random seeds (Appendix B.2).
+
+For Sentiment, we select random POLYJUICE counterfactuals regardless of their labels, as long as an original  $x$  has at least one  $\hat{x}$  that flips the label. For NLI and QQP, we observed in a pilot study that
+
+randomly chosen counterfactuals may not be more effective than the same amount of additional data. We suspect that Polyjuice lacks domain knowledge and context for identifying critical perturbations, and therefore brings benefits redundant with pretraining (Longpre et al., 2020). Thus, we use the slicing functions of Chen et al. (2019) to find patterns of interest (e.g., prepositions in NLI), and perturb those patterns by placing [BLANK]s on the matched spans. For example, "His surfboard is beneath him" becomes "His surfboard is [BLANK] him", and Polyjuice generates counterfactuals such as "His surfboard is beneath  $\rightarrow$  next to him."
+
+Results. Tables 4-6 indicate that Polyjuice augmentation is effective in all tasks: m-polyjuice maintains in-domain accuracy while consistently improving or maintaining generalization accuracy in various out-of-domain and challenge sets. On NLI, Polyjuice counterfactuals are as effective or more effective than counterfactuals created from scratch (m-CAD). Notably, we obtain the largest gains on challenge and contrast sets (e.g., Break and DNC in Table 5) or when the out-of-domain dataset is sufficiently different from the training domain (e.g., Senti140 and SemEval in Table 4). Polyjuice also improves results on CheckList tests that previously had high error rates: it significantly lowers the error rates on 11 out of 27 QQP tests, making 2/27 tests worse. For Sentiment, it improves the model on 5 out of 15 tests, hurting 1. Here, we only report a low  $m/n$  ratio (<10% for NLI and QQP) to show that a small amount of augmentation is already beneficial. The results are similar for other combinations we explored (see Appendix B.2), except when the ratio of counterfactual to original data was too high (e.g.,  $m = n$  may decrease vocabulary diversity or induce additional data bias, echoing (Khashabi et al., 2020)).
+
+# 3.3 Discussion
+
+We show that POLYJUICE counterfactuals are useful for evaluation, and more effective than additional (non-counterfactual) data for training in a variety of tasks. In contrast to prior work where humans generate counterfactuals from scratch, we only ask them to label automatically generated ones, while still achieving similar or better results.
+
+We believe our approach is more effective than manual creation (although both are beneficial): in
+
+<table><tr><td>Model</td><td>SST-2</td><td>Senti140</td><td>SemEval</td><td>Amzbook</td><td>Yelp</td><td>IMDB</td><td>IMDB-Cont.</td><td>IMDB-CAD</td></tr><tr><td>m-baseline</td><td>92.9 ± 0.2</td><td>88.9 ± 0.3</td><td>84.8 ± 0.5</td><td>85.1 ± 0.4</td><td>90.0 ± 0.3</td><td>90.8 ± 0.5</td><td>92.2 ± 0.6</td><td>86.5 ± 0.2</td></tr><tr><td>m-polyjuice</td><td>92.7 ± 0.2</td><td>90.7 ± 0.4</td><td>86.4 ± 0.1</td><td>85.6 ± 0.8</td><td>90.1 ± 0.0</td><td>90.6 ± 0.3</td><td>94.0 ± 0.3</td><td>89.7 ± 0.5</td></tr></table>
+
+Table 4: Sentiment model performance, with  $n = 4,000$  and  $m = 2,000$ . Bolded cells highlight significant improvements. m-polyjuice maintains the in-domain and out-of-domain accuracies on reviews (SST-2, Amzbook, Yelp, IMDb Movie Review (Ni et al., 2019; Asghar, 2016; Maas et al., 2011)), improving it on Twitter data (Senti140 and SemEval 2017 (Go et al., 2009; Nakov et al., 2013)) and contrast sets (Gardner et al., 2020; Kaushik et al., 2020), likely because their distributions are less similar to the original SST-2 training data.  
+
+<table><tr><td>Model</td><td>SNLI</td><td>MNLI-m</td><td>MNLI-mm</td><td>SNLI-CAD</td><td>break</td><td>DNC</td><td>stress</td><td>diagnostic</td></tr><tr><td>m-baseline</td><td>85.7 ± 0.4</td><td>86.1 ± 0.2</td><td>86.6 ± 0.2</td><td>72.8 ± 0.3</td><td>86.4 ± 1.5</td><td>54.5 ± 0.6</td><td>65.1 ± 0.6</td><td>56.0 ± 0.8</td></tr><tr><td>m-CAD</td><td>85.8 ± 0.6</td><td>86.6 ± 0.1</td><td>85.6 ± 0.3</td><td>73.8 ± 0.2</td><td>89.4 ± 2.9</td><td>55.8 ± 0.9</td><td>65.5 ± 0.5</td><td>56.4 ± 0.4</td></tr><tr><td>m-polyjuice</td><td>85.3 ± 0.3</td><td>86.0 ± 0.1</td><td>86.4 ± 0.0</td><td>73.6 ± 0.2</td><td>89.1 ± 1.2</td><td>57.7 ± 0.3</td><td>65.1 ± 0.2</td><td>57.5 ± 0.5</td></tr></table>
+
+Table 5: NLI models, with  $n = {20},{000}$  and  $m = 1,{574}$  . m-polyjuice improves accuracy on contrast and challenge sets (Kim et al., 2019; Naik et al., 2018; Glockner et al., 2018; Wang et al., 2019); it exhibits comparable (or better) gains than m-CAD (manual counterfactuals) with less implementation and annotation effort.  
+
+<table><tr><td>Model</td><td>QQP</td><td>PAWS-QQP</td></tr><tr><td>m-baseline</td><td>84.5 ± 0.6</td><td>37.0 ± 0.5</td></tr><tr><td>m-polyjuice</td><td>84.7 ± 1.0</td><td>38.7 ± 0.4</td></tr></table>
+
+Table 6: POLYJUICE with  $n = {20},{000}$  and  $m = 1,{911}$  improves accuracy on PAWS-QQP (Zhang et al., 2019b).
+
+terms of implementation effort, the process of just labeling counterfactuals is the same as labeling original examples, such that no additional annotator training or separate pipelines are required; in contrast, Kaushik et al. (2020) set up two separate crowdsourcing tasks for creating and labeling the counterfactuals. Further, annotator effort is much lower, as evaluating examples is easier than creating them — Kaushik et al. (2020) report an average of  $\approx 2$  minutes per NLI counterfactual prior to quality validation, while our median time was 10 seconds per counterfactual. Even after our quality validation (removing noisy annotators, disregarding non-fluent counterfactuals), our rate for NLI is  $\approx 36$  seconds per counterfactual (used in Table 5).
+
+In terms of the utility per counterfactual, manual creation and Polyjuice may be complementary. Manual annotation may be unreliable or incomplete for certain forms of counterfactuals (Ribeiro et al., 2018), whereas Polyjuice can miss more complex or context-dependent changes, and could benefit from target perturbations that compensate for its lack of domain knowledge (targeted guidance is also helpful for human annotators (Huang et al., 2020)). Thus, it may be important to mix both approaches (Khashabi et al., 2020). Polyjuice's flexibility opens up possibilities for hybrids between human creation and human verification of targeted, machine-generated counterfactuals.
+
+Figure 3: (A) An instance in QQP where the model prediction  $f(x)$  is Duplicate (=) at  $98.2\%$  confidence, with SHAP importance weights for tokens in Q2. Counterfactual explanations complement SHAP with concrete examples and surprising behaviors, e.g., (B) shows that friend → woman surprisingly flips the prediction to Non-Duplicate (≠), despite the low weight on “friend.”  
+![](images/4f4fd855ff44a8c63370371528cd9fb8957475c4e5902752a1e891f68fc4c069.jpg)  
+B Q2: How do I help a woman who is in depression?  
+Q2: How do I help a friend who is  $\bullet$ suicidal?  
+Q2: How do I •find a friend who is in depression? =
+
+# 4 Counterfactual Explanations
+
+A popular way of explaining NLP models is to attribute importance weights to the input tokens, either using attention scores (Wiegreffe and Pinter, 2019) or by summarizing the model behavior on perturbed instances (e.g., LIME (Ribeiro et al., 2016) and SHAP (Lundberg and Lee, 2017)). Though ubiquitous, token scores may not always reflect their real importance (Pruthi et al., 2020). Popular packages like LIME or SHAP estimate scores by masking words, and therefore may not reflect model behavior on natural counterfactual cases. For example, the token "friend" in Figure 3A is not considered important even though a natural substitution in Figure 3B flips the prediction. The opposite happens to "in depression," where a significant change makes no difference to the model's prediction (Figure 3C). Even perfect importance
+
+scores may be too abstract for users to gain real understanding (Miller, 2019), e.g., users may not grasp the significance of a low importance score for the token "help" without concrete examples such as the one in Figure 3D.
+
+Since presenting a large number of concrete counterfactuals would be overwhelming, we propose a hybrid approach, displaying feature attributions as a high-level summary, together with a judicious selection of Polyjuice counterfactuals that make behaviors concrete and highlight potential limitations. Following Miller (2019)'s observation that people look for explanations revealing unexpected behavior, we select surprising counterfactuals. That is, we estimate the expected change in prediction with feature attributions, and select counterfactuals that violate these expectations, i.e., examples where the real change in prediction is large even though importance scores are low (Figure 3B), and examples where the change is small but importance scores are high (Figure 3C). Of course, users can also view additional counterfactuals that perturb tokens of particular interest, a technique that we explore in the next section.
+
+User evaluation. We study the scenario where an expert has access to a model and local explanations, and evaluate the additional benefit of showing counterfactuals, i.e., whether they bring new insights. We evaluate three ways of generating counterfactuals: (1) POLYJUICE-random, a baseline where we show random POLYJUICE counterfactuals, (2) Expert-surprise, where two graduate students (non-participants) were given access to the model and instructed to create counterfactuals that are surprising given the associated SHAP scores, and (3) POLYJUICE-surprise, which uses the selection procedure described in the previous paragraph.
+
+We recruited 13 participants (graduate students with experience in model explanation), and had them analyze the aforementioned QQP model. In each round, users were shown an example, the model prediction, and a SHAP explanation, as in Figure 3A. Users were instructed to create up to 10 counterfactuals in order to better understand model behavior around the example, for which model predictions were given (users created 6 on average). Finally, users simulated what the model would do on six counterfactuals (Hase and Bansal, 2020), two from each condition (in random order). Counterfactuals where users make mistakes are prefer
+
+![](images/5fb529b8a2fcdd07a825f96359630784754da0bb303007622953517cb958d731.jpg)  
+Figure 4: Simulation error rates per condition (higher the better). POLYJUICE-surprise has the highest error rate, indicating these counterfactuals would add the most information to users if displayed.
+
+able, as displaying these would add information that users do not already have.
+
+As shown in Figure 4, humans simulated model behavior on Polyjuice-surprise counterfactuals only slightly better than random guessing  $(45\% \pm 6\%)$ , i.e., these examples display model behavior that is surprising to users even after seeing explanations and creating their own counterfactuals. Expert-surprise also had a high error rate, but at a much higher cost: generating these for just 20 original instances took 1.5-2 hours of expert labor.
+
+While high error rates could be achieved with unrelated or nonsensical examples, all counterfactuals under evaluation were close to the original examples, when measured by syntactic tree edit  $(\approx 1.0)$  or Levenshtein distance  $(\approx 0.2)$ , Polyjuice-surprise being the closest on both. An independent rater labeled  $95\%$  of Polyjuice-surprise counterfactuals as "likely written by a native speaker," in contrast to  $85\%$  for Expert-surprise, indicating that experts sometimes resorted to ungrammatical or nonsensical sentences to find surprising behaviors.
+
+Qualitatively, the study participants tended to create counterfactuals by perturbing the token with the highest weights (84% of their  $\hat{x}$  perturbed tokens in the top 15% quantile of weights), not gaining a real understanding of how the other tokens impact predictions. Participants also made a significant number of mistakes even for tokens they had inspected, e.g., a participant perturbed the example in Figure 3A by replacing help  $\rightarrow$  play with, yielding a Non-Duplicate model prediction. When faced with help  $\rightarrow$  find in Figure 3D, they incorrectly assumed the behavior would be the same.
+
+These results indicate that POLYJUICE counterfactuals complement feature attribution explanations by displaying information that users often miss, even after they have manually explored the model behavior beyond explanations. Moreover, POLYJUICE counterfactuals for this application were more surprising and fluent than Expert-surprise, despite being computed automatically.
+
+![](images/730bdf4bc178182eceaddae3d38df60a950bd2247af67b442960b8024732cef8.jpg)  
+Figure 6: Perturbing the subject of  $x$  in Figure 5A through [BLANK], resulting in erroneous predictions for different quantifiers (all should be Neutral).
+
+![](images/8169fcafb23edae399cfcaf58c264cf5d93b50063da3ae6bdf3dfb8f7a991279.jpg)  
+Figure 5: (A) An NLI case with a Neutral prediction (underlined  $f(\hat{x})$  are correct). POLYJUICE generates counterfactual hypotheses conditioned on the negation control code. (B) Generalizing perturbations into patterns (Wu et al., 2020). The change DET → no flips 92.8% of predictions from Neutral → Contradiction.
+
+# 5 Interactive Analysis
+
+While our use of Polyjuice has so far relied on automatic selection of counterfactuals, we show in this section how an analyst can benefit from multiple counterfactuals per  $x$ , make use of controlled generation for more advanced analysis, and extract general patterns from individual observations. Our use case is counterfactual error analysis (Wu et al., 2019) of RoBERTa finetuned on NLI (used in §3.1), although the techniques are generally applicable.
+
+There is a known correlation between the label Contradiction and hypotheses with negation in NLI datasets (Gururangan et al., 2018), which may cause models to fail on non-contradiction negations. We explore this in Figure 5A by generating counterfactual hypotheses for a random Neutral instance, conditioning only on the original  $x$  and the negation control code. While the first two counterfactuals display this failure mode, there is a surprising inconsistency in model behavior between "not" and "n't". We note that manual analysis may not explore these three negation forms, and thus not surface this puzzling behavior.
+
+To verify if the pattern is widespread, we generate counterfactuals with the negation control code for a random set of instances correctly predicted as Neutral  $(n = 895)$ . To generalize individual changes into patterns, we extract frequent counterfactual templates with Tempura (Wu et al., 2020) (details in Appendix D.2), shown in Figure 5B. The top templates (in bold) show that the model flips
+
+![](images/c0f5922e156b21a89d12462dedd9600e789c63ad5a79ff8ff5dd651617327d75.jpg)
+
+its prediction from Neutral to Contradiction with roughly the same frequency  $(\approx 43\%)$  whether the negation word is "not" or "n't", but flips much more frequently with a different negation pattern where a determiner is replaced with "no"  $(92.8\%)$ . While these behaviors may be correct in some instances, they often are not (e.g., Figure 5A), and thus would warrant further exploration, and potential mitigation strategies (e.g., counterfactual training, §3). Tangentially, the impact of DET  $\rightarrow$  no might lead the analyst to explore the impact of perturbing the subject of hypotheses, which we do in Figure 6 by placing a [BLANK] on the subject rather than using a control code. This leads to the discovery of unstable and erroneous behaviors regarding quantifiers, which we analyze in more detail in Appendix D.1.
+
+Discussion. POLYJUICE is a powerful tool for interactive analysis. Generating multiple counterfactuals per instance leads to insights that might be missed by manual analysis, and the steering provided by control codes and [BLANK]s allow for analyses that would be non-trivial to do manually (Wu et al., 2019) or with masked language models (e.g., Figure 5B places negations in various parts of sentences, and Figure 6 replaces spans with other spans of varying lengths). Besides error analysis, an analogous interactive use of POLYJUICE may be suitable for test creation (Ribeiro et al., 2020) and forms of data augmentation that are more controlled than what we presented in §3.
+
+# 6 Related Work
+
+Some prior work in training and evaluation relies on humans to generate counterfactuals from scratch (Gardner et al., 2020; Teney et al., 2020; Kaushik et al., 2020). Our experiments in §3 indicate that asking humans to label PolYJuice counterfactuals yields similar or better results at a lower cost, which motivates an exploration of a mixture of manual and semi-automated generation. Similarly, prior work on analysis relies on experts to
+
+create individual counterfactuals or perturbation functions (Wu et al., 2019; Ribeiro et al., 2020). In §5, we show that POLYJUICE enhances current practice by generating multiple counterfactuals that might have been overlooked, and by providing abstractions that allow for new kinds of analyses.
+
+Prior work on automatically generating counterfactuals typically has a narrower scope in terms of the relationships  $x \rightarrow \hat{x}$ . For example, adversarial generators aim to maintain semantics while changing model predictions (Ribeiro et al., 2018; Iyyer et al., 2018; Li et al., 2021), whereas concurrent work to our own (Madaan et al., 2021; Ross et al., 2020) automatically generates  $\hat{x}$  that change predictions for explanation or analysis, with no constraints on semantics. However, as shown in §3-§5, a mix of label-preserving and label-flipping counterfactuals generated by Polyjuice is quite useful for training, evaluation, explanation, and analysis. Further, general-purpose counterfactuals may lead to serendipitous discoveries (§5), especially as Polyjuice is not fine-tuned to the target domain (and thus less liable to merely replicate what is already there). Finally, by allowing control through control codes and [BLANK]s, Polyjuice supports human-generator collaboration, where a person specifies desired changes (e.g., perturb the sentence subject). Such collaboration is hard to imagine using automatic generators with no control, or with coarser control through predefined style attributes or labels (Madaan et al., 2020; Malmi et al., 2020). To our knowledge, prior work on controlled generation (Keskar et al., 2019; Dathathri et al., 2020) does not address counterfactual generation.
+
+# 7 Conclusion and Future Work
+
+We propose POLYJUICE, a general-purpose generator that produces fluent and diverse counterfactuals, allowing for control over the kinds and locations of perturbations. With simple, task-specific selection heuristics, POLYJUICE supports various downstream tasks on different domains, including counterfactual data augmentation, contrast set generation, counterfactual explanation, and error analysis.
+
+While Polyjuice is broadly applicable, it is not bias-free: control codes are pre-defined and certainly not exhaustive, and the model is fine-tuned on a collection of paired datasets where certain perturbations are more or less likely (e.g., we observe that words with negative sentiment tend to be slightly more likely than positive ones in some
+
+contexts). Collecting naturally occurring counterfactuals is an important area of future research, as is the development of generators that allow for control even without a-priori control codes.
+
+Besides improving the generators, further work is needed to improve the value of counterfactuals. For example, while Polyjuice shows consistent gains across tasks in data augmentation, the improvements on some datasets are not as significant. This aligns with observations in prior work that even manual counterfactuals can be marginally beneficial (Kaushik et al., 2020; Huang et al., 2020), possibly because the original data is already diverse enough, or the perturbed signal in counterfactuals is too subtle to affect the model (e.g., when only a single word is changed in a long sentence.) We hope to perform more thorough experiments on tuning the amount and the distribution of counterfactual augmentation, as well as other ways of incorporating counterfactuals, such as having explicit terms in the loss function for contrasting counterfactuals with original data (Teney et al., 2020), or other forms of contrastive learning.
+
+Although our applications all involved people, the human-Polyjuice collaboration in labeling and explanations could benefit from richer interaction mechanisms. We believe Polyjuice motivates future research on more expressive forms of counterfactual training, where users generate counterfactuals together with Polyjuice, and label counterfactual patterns rather than individual instances. Similarly, interactive explanations and analysis are exciting directions, especially as we develop new ways of selecting, presenting, and aggregating counterfactuals for various analysis objectives. Having noted these opportunities, we believe Polyjuice is already a powerful tool for counterfactual reasoning, in particular for tasks where people are directly involved. Polyjuice is opensource, and available at https://github.com/tongshuangwu/polyjuice.
+
+# Acknowledgements
+
+The work was supported by ONR grant N00014-18-1-2193, NSF RAPID grant 2040196, NSF award IIS-1901386, the University of Washington WRF/Cable Professorship, and the Allen Institute for Artificial Intelligence (AI2). We thank Jim Chen, Dianqi Li, Scott Lundberg, Hao Peng, Sameer Singh, Jiao Sun, Victor Zhong, and Sitong Zhou for their helpful comments, as well as our user study participants for their valuable input.
+
+# Ethical Considerations
+
+Our work includes labeling counterfactuals on crowdsourcing platforms, as well as conducting user studies with graduate students. As detailed in Appendix B.1 and C.2, we compensated the MTurk workers  $2.5 for \approx 15 minutes of labeling, and the graduate students$ 20 for the user study (one hour), above the U.S. federal minimum wage. The studies are with IRB approval.
+
+We only finetune GPT-2 rather than training it from scratch, such that our compute costs are relatively low (around 8 hours for finetuning, Appendix A). All of our finetuning experiments involved finetuning RoBERTa on smaller datasets.
+
+More critically, with most of our demonstrated applications using a human-generator hybrid mechanism, we stress that the interaction between the two deserves careful consideration. It has long been reported that algorithms interacting with humans can negatively impact the human.<sup>9</sup> In our case, the concern might be that users can develop an over-reliance on Polyjuice (Bansal et al., 2021) and hastily accept its generations. Not only can this decrease users' creativity (Green et al., 2014), but it may bias their analysis process: as discussed in §7, Polyjuice generation is not exhaustive, and may favor some perturbation patterns over others in unpredictable ways. In the short term, we plan to highlight these limitations as part of the model documentation, while future research should identify interaction mechanisms, so as to ensure that Polyjuice or other counterfactual generators support humans, rather than hindering their performance.
+
+# References
+
+Nabiha Asghar. 2016. Yelp dataset challenge: Review rating prediction. arXiv preprint arXiv:1605.05362.  
+Gagan Bansal, Tongshuang Wu, Joyce Zhou, Raymond Fok, Besmira Nushi, Ece Kamar, Marco Tulio Ribeiro, and Daniel Weld. 2021. Does the whole exceed its parts? the effect of ai explanations on complementary team performance. In Proceedings of the 2021 CHI Conference on Human Factors in Computing Systems, CHI '21, New York, NY, USA. Association for Computing Machinery.  
+Samuel R. Bowman, Gabor Angeli, Christopher Potts, and Christopher D. Manning. 2015. A large annotated corpus for learning natural language inference.
+
+In Proceedings of the 2015 Conference on Empirical Methods in Natural Language Processing, pages 632-642, Lisbon, Portugal. Association for Computational Linguistics.  
+Vincent S. Chen, Sen Wu, Alexander J. Ratner, Jen Weng, and Christopher Ré. 2019. Slice-based learning: A programming model for residual learning in critical data slices. In Advances in Neural Information Processing Systems 32: Annual Conference on Neural Information Processing Systems 2019, NeurIPS 2019, December 8-14, 2019, Vancouver, BC, Canada, pages 9392-9402.  
+Noam Chomsky. 2002. Syntactic structures. Walter de Gruyter.  
+Sumanth Dathathri, Andrea Madotto, Janice Lan, Jane Hung, Eric Frank, Piero Molino, Jason Yosinski, and Rosanne Liu. 2020. Plug and play language models: A simple approach to controlled text generation. In 8th International Conference on Learning Representations, ICLR 2020, Addis Ababa, Ethiopia, April 26-30, 2020. OpenReview.net.  
+Chris Donahue, Mina Lee, and Percy Liang. 2020. Enabling language models to fill in the blanks. In Proceedings of the 58th Annual Meeting of the Association for Computational Linguistics, pages 2492-2501, Online. Association for Computational Linguistics.  
+Matt Gardner, Yoav Artzi, Victoria Basmov, Jonathan Berant, Ben Bogin, Sihao Chen, Pradeep Dasigi, Dheeru Dua, Yanai Elazar, Ananth Gottumukkala, Nitish Gupta, Hannaneh Hajishirzi, Gabriel Ilharco, Daniel Khashabi, Kevin Lin, Jiangming Liu, Nelson F. Liu, Phoebe Mulcaire, Qiang Ning, Sameer Singh, Noah A. Smith, Sanjay Subramanian, Reut Tsarfaty, Eric Wallace, Ally Zhang, and Ben Zhou. 2020. Evaluating models' local decision boundaries via contrast sets. In Findings of the Association for Computational Linguistics: EMNLP 2020, pages 1307-1323, Online. Association for Computational Linguistics.  
+Sahaj Garg, Vincent Perot, Nicole Limtiaco, Ankur Taly, Ed H Chi, and Alex Beutel. 2019. Counterfactual fairness in text classification through robustness. In Proceedings of the 2019 AAAI/ACM Conference on AI, Ethics, and Society, pages 219-226.  
+Max Glockner, Vered Shwartz, and Yoav Goldberg. 2018. Breaking NLI systems with sentences that require simple lexical inferences. In Proceedings of the 56th Annual Meeting of the Association for Computational Linguistics (Volume 2: Short Papers), pages 650-655, Melbourne, Australia. Association for Computational Linguistics.  
+Alec Go, Richa Bhayani, and Lei Huang. 2009. Twitter sentiment classification using distant supervision. CS224N project report, Stanford, 1(12):2009.
+
+Spence Green, Sida I. Wang, Jason Chuang, Jeffrey Heer, Sebastian Schuster, and Christopher D. Manning. 2014. Human effort and machine learnability in computer aided translation. In Proceedings of the 2014 Conference on Empirical Methods in Natural Language Processing (EMNLP), pages 1225-1236, Doha, Qatar. Association for Computational Linguistics.  
+Suchin Gururangan, Swabha Swayamdipta, Omer Levy, Roy Schwartz, Samuel Bowman, and Noah A. Smith. 2018. Annotation artifacts in natural language inference data. In Proceedings of the 2018 Conference of the North American Chapter of the Association for Computational Linguistics: Human Language Technologies, Volume 2 (Short Papers), pages 107-112, New Orleans, Louisiana. Association for Computational Linguistics.  
+Peter Hase and Mohit Bansal. 2020. Evaluating explainable AI: Which algorithmic explanations help users predict model behavior? In Proceedings of the 58th Annual Meeting of the Association for Computational Linguistics, pages 5540-5552, Online. Association for Computational Linguistics.  
+William Huang, Haokun Liu, and Samuel R. Bowman. 2020. Counterfactually-augmented SNLI training data does not yield better generalization than unaugmented data. In Proceedings of the First Workshop on Insights from Negative Results in NLP, pages 82-87, Online. Association for Computational Linguistics.  
+Mohit Iyyer, John Wieting, Kevin Gimpel, and Luke Zettlemoyer. 2018. Adversarial example generation with syntactically controlled paraphrase networks. In Proceedings of the 2018 Conference of the North American Chapter of the Association for Computational Linguistics: Human Language Technologies, Volume 1 (Long Papers), pages 1875-1885, New Orleans, Louisiana. Association for Computational Linguistics.  
+Daniel Kahneman and Amos Tversky. 1981. The simulation heuristic. Technical report, Stanford Univ CA Dept of Psychology.  
+Divyansh Kaushik, Eduard H. Hovy, and Zachary Chase Lipton. 2020. Learning the difference that makes A difference with counterfactually-augmented data. In 8th International Conference on Learning Representations, ICLR 2020, Addis Ababa, Ethiopia, April 26-30, 2020. OpenReview.net.  
+Nitish Shirish Keskar, Bryan McCann, Lav Varshney, Caiming Xiong, and Richard Socher. 2019. CTRL - A Conditional Transformer Language Model for Controllable Generation. arXiv preprint arXiv:1909.05858.  
+Daniel Khashabi, Tushar Khot, and Ashish Sabharwal. 2020. More bang for your buck: Natural perturbation for robust question answering. In Proceedings of the 2020 Conference on Empirical Methods in
+
+Natural Language Processing (EMNLP), pages 163-170, Online. Association for Computational Linguistics.  
+Najoung Kim, Roma Patel, Adam Poliak, Patrick Xia, Alex Wang, Tom McCoy, Ian Tenney, Alexis Ross, Tal Linzen, Benjamin Van Durme, Samuel R. Bowman, and Ellie Pavlick. 2019. Probing what different NLP tasks teach machines about function word comprehension. In Proceedings of the Eighth Joint Conference on Lexical and Computational Semantics (*SEM* 2019), pages 235-249, Minneapolis, Minnesota. Association for Computational Linguistics.  
+Tom Kwiatkowski, Jennimaria Palomaki, Olivia Redfield, Michael Collins, Ankur Parikh, Chris Alberti, Danielle Epstein, Illia Polosukhin, Jacob Devlin, Kenton Lee, Kristina Toutanova, Llion Jones, Matthew Kelcey, Ming-Wei Chang, Andrew M. Dai, Jakob Uszkoreit, Quoc Le, and Slav Petrov. 2019. Natural questions: A benchmark for question answering research. Transactions of the Association for Computational Linguistics, 7:452-466.  
+VI Levenshtein. 1966. Binary Codes Capable of Correcting Deletions, Insertions and Reversals. Soviet Physics Doklady, 10:707.  
+Dianqi Li, Yizhe Zhang, Hao Peng, Liquin Chen, Chris Brockett, Ming-Ting Sun, and Bill Dolan. 2021. Contextualized perturbation for textual adversarial attack. In Proceedings of the 2021 Conference of the North American Chapter of the Association for Computational Linguistics: Human Language Technologies, pages 5053-5069, Online. Association for Computational Linguistics.  
+Bill Yuchen Lin, Wangchunshu Zhou, Ming Shen, Pei Zhou, Chandra Bhagavatula, Yejin Choi, and Xiang Ren. 2020. CommonGen: A constrained text generation challenge for generative commonsense reasoning. In Findings of the Association for Computational Linguistics: EMNLP 2020, pages 1823-1840, Online. Association for Computational Linguistics.  
+Yinhan Liu, Myle Ott, Naman Goyal, Jingfei Du, Mandar Joshi, Danqi Chen, Omer Levy, Mike Lewis, Luke Zettlemoyer, and Veselin Stoyanov. 2019. Roberta: A robustly optimized bert pretraining approach. arXiv preprint arXiv:1907.11692.  
+Shayne Longpre, Yu Wang, and Chris DuBois. 2020. How effective is task-agnostic data augmentation for pretrained transformers? In *Findings of the Association for Computational Linguistics: EMNLP* 2020, pages 4401–4411, Online. Association for Computational Linguistics.  
+Scott M. Lundberg and Su-In Lee. 2017. A unified approach to interpreting model predictions. In Advances in Neural Information Processing Systems 30: Annual Conference on Neural Information Processing Systems 2017, December 4-9, 2017, Long Beach, CA, USA, pages 4765-4774.
+
+Andrew L. Maas, Raymond E. Daly, Peter T. Pham, Dan Huang, Andrew Y. Ng, and Christopher Potts. 2011. Learning word vectors for sentiment analysis. In Proceedings of the 49th Annual Meeting of the Association for Computational Linguistics: Human Language Technologies, pages 142-150, Portland, Oregon, USA. Association for Computational Linguistics.  
+Aman Madaan, Amrith Setlur, Tanmay Parekh, Barnabas Poczos, Graham Neubig, Yiming Yang, Ruslan Salakhutdinov, Alan W Black, and Shrimai Prabhumoye. 2020. Politeness transfer: A tag and generate approach. In Proceedings of the 58th Annual Meeting of the Association for Computational Linguistics, pages 1869-1881, Online. Association for Computational Linguistics.  
+Nishtha Madaan, Inkit Padhi, Naveen Panwar, and Diptikalyan Saha. 2021. Generate your counterfactuals: Towards controlled counterfactual generation for text. Proceedings of the AAAI Conference on Artificial Intelligence.  
+Eric Malmi, Aliaksei Severyn, and Sascha Rothe. 2020. Unsupervised text style transfer with padded masked language models. In Proceedings of the 2020 Conference on Empirical Methods in Natural Language Processing (EMNLP), pages 8671-8680, Online. Association for Computational Linguistics.  
+Tom McCoy, Ellie Pavlick, and Tal Linzen. 2019. Right for the wrong reasons: Diagnosing syntactic heuristics in natural language inference. In Proceedings of the 57th Annual Meeting of the Association for Computational Linguistics, pages 3428-3448, Florence, Italy. Association for Computational Linguistics.  
+Tim Miller. 2019. Explanation in artificial intelligence: Insights from the social sciences. Artificial Intelligence, 267:1-38.  
+John Morris, Eli Lifland, Jin Yong Yoo, Jake Grigsby, Di Jin, and Yanjun Qi. 2020. TextAttack: A framework for adversarial attacks, data augmentation, and adversarial training in NLP. In Proceedings of the 2020 Conference on Empirical Methods in Natural Language Processing: System Demonstrations, pages 119-126, Online. Association for Computational Linguistics.  
+Aakanksha Naik, Abhilasha Ravichander, Norman Sadeh, Carolyn Rose, and Graham Neubig. 2018. Stress test evaluation for natural language inference. In Proceedings of the 27th International Conference on Computational Linguistics, pages 2340-2353, Santa Fe, New Mexico, USA. Association for Computational Linguistics.  
+Preslav Nakov, Sara Rosenthal, Zornitsa Kozareva, Veselin Stoyanov, Alan Ritter, and Theresa Wilson. 2013. SemEval-2013 task 2: Sentiment analysis in Twitter. In Second Joint Conference on Lexical and Computational Semantics (*SEM), Volume 2: Proceedings of the Seventh International Workshop on
+
+Semantic Evaluation (SemEval 2013), pages 312-320, Atlanta, Georgia, USA. Association for Computational Linguistics.  
+Jianmo Ni, Jiacheng Li, and Julian McAuley. 2019. Justifying recommendations using distantly-labeled reviews and fine-grained aspects. In Proceedings of the 2019 Conference on Empirical Methods in Natural Language Processing and the 9th International Joint Conference on Natural Language Processing (EMNLP-IJCNLP), pages 188-197, Hong Kong, China. Association for Computational Linguistics.  
+Judea Pearl. 2018. Causal and counterfactual inference. The Handbook of Rationality, pages 1-41.  
+Danish Pruthi, Mansi Gupta, Bhuwan Dhingra, Graham Neubig, and Zachary C. Lipton. 2020. Learning to deceive with attention-based explanations. In Proceedings of the 58th Annual Meeting of the Association for Computational Linguistics, pages 4782-4793, Online. Association for Computational Linguistics.  
+Lianhui Qin, Antoine Bosselut, Ari Holtzman, Chandra Bhagavatula, Elizabeth Clark, and Yejin Choi. 2019. Counterfactual story reasoning and generation. In Proceedings of the 2019 Conference on Empirical Methods in Natural Language Processing and the 9th International Joint Conference on Natural Language Processing (EMNLP-IJCNLP), pages 5043-5053, Hong Kong, China. Association for Computational Linguistics.  
+Alec Radford, Jeffrey Wu, Rewon Child, David Luan, Dario Amodei, and Ilya Sutskever. 2019. Language models are unsupervised multitask learners. OpenAI blog, 1(8):9.  
+Colin Raffel, Noam Shazeer, Adam Roberts, Katherine Lee, Sharan Narang, Michael Matena, Yanqi Zhou, Wei Li, and Peter J. Liu. 2020. Exploring the limits of transfer learning with a unified text-to-text transformer. Journal of Machine Learning Research, 21(140):1-67.  
+Pranav Rajpurkar, Jian Zhang, Konstantin Lopyrev, and Percy Liang. 2016. SQuAD: 100,000+ questions for machine comprehension of text. In Proceedings of the 2016 Conference on Empirical Methods in Natural Language Processing, pages 2383-2392, Austin, Texas. Association for Computational Linguistics.  
+Nils Reimers and Iryna Gurevych. 2019. SentenceBERT: Sentence embeddings using Siamese BERTnetworks. In Proceedings of the 2019 Conference on Empirical Methods in Natural Language Processing and the 9th International Joint Conference on Natural Language Processing (EMNLP-IJCNLP), pages 3982-3992, Hong Kong, China. Association for Computational Linguistics.  
+Marco Túlio Ribeiro, Sameer Singh, and Carlos Guestrin. 2016. "why should I trust you?": Explain-
+
+ing the predictions of any classifier. In Proceedings of the 22nd ACM SIGKDD International Conference on Knowledge Discovery and Data Mining, San Francisco, CA, USA, August 13-17, 2016, pages 1135-1144. ACM.  
+Marco Tulio Ribeiro, Sameer Singh, and Carlos Guestrin. 2018. Semantically equivalent adversarial rules for debugging NLP models. In Proceedings of the 56th Annual Meeting of the Association for Computational Linguistics (Volume 1: Long Papers), pages 856-865, Melbourne, Australia. Association for Computational Linguistics.  
+Marco Tulio Ribeiro, Tongshuang Wu, Carlos Guestrin, and Sameer Singh. 2020. Beyond accuracy: Behavioral testing of NLP models with CheckList. In Proceedings of the 58th Annual Meeting of the Association for Computational Linguistics, pages 4902-4912, Online. Association for Computational Linguistics.  
+Alexis Ross, Ana Marasović, and Matthew E. Peters. 2020. Explaining nlp models via minimal contrastive editing (mice).  
+Keisuke Sakaguchi, Ronan Le Bras, Chandra Bhagavatula, and Yejin Choi. 2020. Winogrande: An adversarial winograd schema challenge at scale. Proceedings of the AAAI Conference on Artificial Intelligence, 34(05):8732-8740.  
+Richard Socher, Alex Perelygin, Jean Wu, Jason Chuang, Christopher D. Manning, Andrew Ng, and Christopher Potts. 2013. Recursive deep models for semantic compositionality over a sentiment treebank. In Proceedings of the 2013 Conference on Empirical Methods in Natural Language Processing, pages 1631-1642, Seattle, Washington, USA. Association for Computational Linguistics.  
+Damien Teney, Ehsan Abbasnedjad, and Anton van den Hengel. 2020. Learning what makes a difference from counterfactual examples and gradient supervision. In Computer Vision – ECCV 2020, pages 580–599, Cham. Springer International Publishing.  
+Vijay V Vazirani. 2013. Approximation algorithms. Springer Science & Business Media.  
+Alex Wang, Amanpreet Singh, Julian Michael, Felix Hill, Omer Levy, and Samuel R. Bowman. 2019. GLUE: A multi-task benchmark and analysis platform for natural language understanding. In 7th International Conference on Learning Representations, ICLR 2019, New Orleans, LA, USA, May 6-9, 2019. OpenReview.net.  
+Sarah Wegreffe and Yuval Pinter. 2019. Attention is not not explanation. In Proceedings of the 2019 Conference on Empirical Methods in Natural Language Processing and the 9th International Joint Conference on Natural Language Processing (EMNLP-IJCNLP), pages 11-20, Hong Kong, China. Association for Computational Linguistics.
+
+John Wieting and Kevin Gimpel. 2018. ParaNMT-50M: Pushing the limits of paraphrastic sentence embeddings with millions of machine translations. In Proceedings of the 56th Annual Meeting of the Association for Computational Linguistics (Volume 1: Long Papers), pages 451–462, Melbourne, Australia. Association for Computational Linguistics.  
+Thomas Wolf, Lysandre Debut, Victor Sanh, Julien Chaumont, Clement Delangue, Anthony Moi, Pierric Cistac, Tim Rault, Remi Louf, Morgan Funtowicz, Joe Davison, Sam Shleifer, Patrick von Platen, Clara Ma, Yacine Jernite, Julien Plu, Canwen Xu, Teven Le Scao, Sylvain Gugger, Mariama Drame, Quentin Lhoest, and Alexander Rush. 2020. Transformers: State-of-the-art natural language processing. In Proceedings of the 2020 Conference on Empirical Methods in Natural Language Processing: System Demonstrations, pages 38-45, Online. Association for Computational Linguistics.  
+Tongshuang Wu, Marco Tulio Ribeiro, Jeffrey Heer, and Daniel Weld. 2019. Errudite: Scalable, reproducible, and testable error analysis. In Proceedings of the 57th Annual Meeting of the Association for Computational Linguistics, pages 747-763, Florence, Italy. Association for Computational Linguistics.  
+Tongshuang Wu, Kanit Wongsuphasawat, Donghao Ren, Kayur Patel, and Chris DuBois. 2020. Tempura: Query analysis with structural templates. In CHI '20: CHI Conference on Human Factors in Computing Systems, Honolulu, HI, USA, April 25-30, 2020, pages 1-12. ACM.  
+Huangzhao Zhang, Hao Zhou, Ning Miao, and Lei Li. 2019a. Generating fluent adversarial examples for natural languages. In Proceedings of the 57th Annual Meeting of the Association for Computational Linguistics, pages 5564-5569, Florence, Italy. Association for Computational Linguistics.  
+Kaizhong Zhang and Dennis Shasha. 1989. Simple fast algorithms for the editing distance between trees and related problems. SIAM journal on computing, 18(6):1245-1262.  
+Yuan Zhang, Jason Baldridge, and Luheng He. 2019b. PAWS: Paraphrase adversaries from word scrambling. In Proceedings of the 2019 Conference of the North American Chapter of the Association for Computational Linguistics: Human Language Technologies, Volume 1 (Long and Short Papers), pages 1298-1308, Minneapolis, Minnesota. Association for Computational Linguistics.  
+Yaoming Zhu, Sidi Lu, Lei Zheng, Jiaxian Guo, Weinan Zhang, Jun Wang, and Yong Yu. 2018. Texy- gen: A benchmarking platform for text generation models. In The 41st International ACM SIGIR Con- ference on Research & Development in Information Retrieval, SIGIR 2018, Ann Arbor, MI, USA, July 08- 12, 2018, pages 1097-1100. ACM.
+
+<table><tr><td>Dataset</td><td>negation</td><td>quantifier</td><td>lexical</td><td>resemantic</td><td>insert</td><td>delete</td><td>restructure</td><td>shuffle</td><td>global</td></tr><tr><td>CAD</td><td>3,274</td><td>292</td><td>8,143</td><td>2,603</td><td>960</td><td>952</td><td>220</td><td>36</td><td>3,466</td></tr><tr><td>Contrast</td><td>336</td><td>436</td><td>1,607</td><td>1,291</td><td>589</td><td>586</td><td>275</td><td>149</td><td>877</td></tr><tr><td>HANS</td><td>50</td><td>0</td><td>0</td><td>0</td><td>3,926</td><td>3,926</td><td>494</td><td>1,602</td><td>2</td></tr><tr><td>ParaNMT</td><td>2,797</td><td>825</td><td>10,000</td><td>10000</td><td>6,442</td><td>6,205</td><td>5,136</td><td>1,417</td><td>10,000</td></tr><tr><td>PAWS</td><td>81</td><td>1,815</td><td>10,000</td><td>10000</td><td>3,630</td><td>3,403</td><td>4,551</td><td>10,000</td><td>10,000</td></tr><tr><td>WinoGrande</td><td>3,011</td><td>94</td><td>10,000</td><td>6,927</td><td>120</td><td>124</td><td>453</td><td>65</td><td>3184</td></tr><tr><td>Crawled</td><td>0</td><td>0</td><td>5,000</td><td>0</td><td>5,000</td><td>5,000</td><td>0</td><td>108</td><td>5,000</td></tr><tr><td>Total</td><td>9,549</td><td>3,462</td><td>44,750</td><td>30,821</td><td>20,667</td><td>20,167</td><td>11,129</td><td>13,377</td><td>32,529</td></tr></table>
+
+Table 7: The datasets used for finetuning POLYJUICE, and the control code distributions.
+
+# A GPT-2 as Counterfactual Generator
+
+# A.1 Training Data and Parameters
+
+We combine several datasets to finetune POLYJUICE.
+
+Contrast set. Authors of 10 existing NLP dataset each manually perturbed 100-1,000 instances to change the gold label, so to inspect a model's local decision boundary (Gardner et al., 2020). The perturbation patterns vary based on the tasks and the annotators, allowing us to learn diverse strategies. To make sure we can use the contrast set to evaluate the Sentiment model, we excluded the IMDb movie review from the training.
+
+Counterfactually-augmented data (CAD). Kaushik et al. (2020) crowdsourced counterfactuals for IMDb movie review (1.7k), which we split into paired sentences to match the text length of other datasets. CAD's perturbation patterns also vary based on the task, but can especially contribute to negation. As NLI is in our demonstrating applications, we did not use their 6.6k SNLI counterfactuals. $^{10}$
+
+WinoGrande is a large-scale dataset of 44k instances for testing common sense problems (Sakaguchi et al., 2020). It contains sentences that differ only by one trigger word (e.g., one noun), making it most suitable for learning lexical exchanges.
+
+ParaNMT-50M contains 50 million English-English sentential paraphrase pairs, covering various domains and styles of text, as well as different sentence structures (Wieting and Gimpel, 2018).
+
+PAWS (Zhang et al., 2019b) contains pairs with high text overlaps, created through controlled word swapping, best demonstrating shuffle and restructure. We used its 49k Wikipedia parts.
+
+HANS (McCoy et al., 2019), a challenge set for NLI, contains 10k pairs of premises and hypotheses created based on 10 heavily fallible syntactic templates, and therefore compensates rarer structural changes that may be missed by PAWS.
+
+Crawled We additionally crawl naturally occurring sentence pairs from non-paired datasets boost some specific patterns and increase lexical diversity. This include (1) CommonGen (Lin et al., 2020), sentences with common sense concepts; (2) Natural Questions (Kwiatkowski et al., 2019), collections of queries issued to Google Engines (and therefore involve various paraphrases of similar user intents), and (3) SQuAD (Rajpurkar et al., 2016), whose paragraphs involve Wikipedia knowledge. We estimate close pairs using edit distance, and broadly accept those with less than  $60\%$  editing. To exclude tricky cases (e.g., "how do I not be" can be incorrectly regarded as negation for "how do I recover it"), we only augment the most determined patterns: lexical, insert, delete, and shuffle.
+
+To balance the distribution (Table 7), for each dataset, we extract control codes from all the  $(x,\hat{x})$ , and randomly sample up to 10,000 instances per codes. Still, quantifier and negation have less training data compared to other codes. Fortunately, these codes tend to be limited to more specific patterns ("more than", "not", "never") when compared to "broad" codes like lexical, and thus even a small sample is enough to learn them. We finetuned an off-the-shelf GPT-2 model from Wolf et al. (2020) for 10 epochs with an initial learning rate 5e-5, a batch size of 8, and a sequence length of 120 (but any LM can potentially be used). We select the best epoch based on the evaluation loss on a holdout set of size 5,000. The training took around 8 hours on two Titan RTXs.
+
+# A.2 Intrinsic Evaluation Details
+
+# A.2.1 Closeness and Diversity
+
+Similar to Madaan et al. (2021), we compare the diversity and closeness of Polyjuice with alternative generators, i.e., RoBERTa and T5, representing masked language models that prioritize word and span substitution, and original GPT-2, representing the standard generative model not conditioned on  $x$ . For a given  $x$  and its counterfactuals  $\hat{\mathbf{X}}$ , we approx
+
+imate diversity using self-BLEU (Zhu et al., 2018) within  $\hat{\mathbf{X}}$ . Meanwhile, closeness is the average distance between  $x$  and every  $\hat{x} \in \hat{\mathbf{X}}$ , both with the normalized word level Levenshtein edit distance ((Levenshtein, 1966), used in MiCE (Ross et al., 2020)), and syntactic tree edit distance ((Zhang and Shasha, 1989) in GYC (Madaan et al., 2021)).
+
+We run the three generators on 300 sentences in total. In GPT-2, we take the first two words of an  $x$  as the input context (prompt), limit the length of the generation to be similar to  $x$ , and collect 10 counterfactuals. As for RoBERTa and T5, we repeatedly perturb  $x$  for three times, each time randomly placing up to three [MASK] tokens, and ask the generator to generate 5 counterfactuals through beam search, following Ribeiro et al. (2020). Polyjuice uses the same blank (mask) placement as in RoBERTa and T5, but we additionally enumerate through all control codes. For each  $x$ , we randomly sample 5 counterfactuals to form  $\hat{\mathbf{X}}$  per generator.
+
+As shown in Table 2, POLYJUICE achieves a balance between diversity and closeness. Ideally, we would also like to compare POLYJUICE with concurrent work (Madaan et al., 2021; Ross et al., 2020), but these are yet to be open-sourced and require extensive implementation or finetuning.
+
+# A.2.2 Controllability
+
+To evaluate controllability, we compare POLYJUICE with T5, and GPT-2 finetuned on prompts without codes (called POLYJUICE -a), such that both baselines consider sufficient context. For each control code, we compare the control success rate of POLYJUICE and POLYJUICE-a on 300 prompts. For each prompt, we generate counterfactuals through beam search (beam = 5), and recompute the codes on the top three generated  $\hat{x}$ . We deem the control successful if at least one of the three recomputed codes matches the desired control code (though in POLYJUICE-a, we only measure whether the code naturally occurs in the uncontrolled generation.) The success rate increases by  $26\% \pm 13\%$  across all control codes, ranging from quantifier (increasing  $6\%$ , from  $50\%$  to  $56\%$ ) to negation ( $42\%$ , from  $5\%$  to  $47\%$ ). Non-finetuned T5 also achieves less control (success rate decreases by  $33\%$  on average.)
+
+Common failure cases include (1) The control codes conflict with the blanks, e.g., "a dog is embraced by a [BLANK]" would not respond to negation. (2)  $x$  does not have a corresponding pattern, e.g., shuffle is not applicable to "the movie
+
+![](images/b8acff0ab0e3332e96834f8288b0322df17ce95aa8206a79e5216446103463a0.jpg)  
+Figure 7: A sample labeling task: The crowdworkers annotate three counterfactuals based on their validity and class label, with respect to the original instance.
+
+is good." (3) certain salient patterns dominate the generation probability, e.g., the model tends to perturb the quantifier "two" in "two dogs are running," regardless of the code.
+
+# B Additional Train & Eval Details, §3
+
+# B.1 MTurk Labeling Details
+
+Procedure The study started with an introduction that explained the context and tasks. To familiarize crowdworkers with the task, we asked them to complete 1-2 training rounds, and explained the expected labels. Each annotator then completed 22 tasks, labeling 3 counterfactuals of a single example in each round, as in Figure 7. The 22 rounds consisted of 20 actual labeling tasks and 2 extra "gold rounds" with known correct labels. The gold cases later served to filter low-quality crowdworkers. The median annotation time was around 15 minutes, and participants received $2.5.
+
+Participants. We recruited participants from MTurk, limiting the pool to subjects from within the US with a prior task approval rating of at least  $97\%$  and a minimum of 1,000 approved tasks.
+
+Data quality. We applied two filtering strategies: (1) High-quality worker. We only kept data from participants whose median labeling time per round was more than 18 seconds and correctly labeled at least 4 gold counterfactuals (out of 6), or who correctly labeled all gold ones. (2) Majority vote labeling. We collected two annotations per counterfactual, and only kept those that at least one annotator deemed valid, and both annotators agreed on a particular class label. One of the authors la
+
+![](images/18237724737940f741130c81310c2517a28b29fbb06547144679f7576db1007f.jpg)  
+Figure 8: The accuracy trend on two Sentiment datasets, as the total training datasize  $(m + n)$  varies. The blue line shows an augmentation of  $m = 2k$  counterfactuals, and the blue one represents the corresponding m-baseline. Though the counterfactuals remains useful on datasets like SemEval across all  $m + n$ , it appears too many counterfactuals may be harmful (Amzbook).
+
+beled a subset of  $100\hat{x}$  on  $100x$  in Sentiment, and reached high agreement with the majority-voted results  $(\kappa = 0.77$  raw labeling agreement  $88\%$
+
+# B.2 Training Details &  $m / n$  Ratios, for §3.2
+
+For each  $(m,n)$ , we created three samples of training data. Each sample was further averaged over four random seeds. For each run, we heuristically picked the initial learning rates 1e-5, 2e-5, 2e-5 for Sentiment, NLI and QQP, and trained 20 epochs with a dropout rate of 0.1 and a batch size of 16. We selected the epoch that had the highest accuracy on the corresponding validation set, which takes 1/5 of the training data size, with the same ratio of  $m/n$  counterfactual and original examples.
+
+We further explore ratios of added counterfactuals. Take Sentiment as an example: while the counterfactual remains effective on most datasets, it hurts the model performance on Amzbook when the counterfactual takes a large proportion (Figure 8, Yelp followed a similar but more mild trend). We suspect that flipping out too much original data affects the data diversity, and in turn decreases the model performance. Similarly, Huang et al. (2020) asserted that augmenting  $n = 1.7k$  NLI data with  $m = 6.6k$  counterfactuals did not improve model generalization accuracy.
+
+# C Additional Explanation Details §4
+
+# C.1 Selection Methods
+
+Because SHAP weights reflect the average effect of masking a token  $t$ , we also focus on word features that are abnormal on average.
+
+More concretely, we define the expected change-in-prediction for perturbing a token  $t$  to be the SHAP importance on it,  $\mathbf{H}[\mathrm{D}_{\mathrm{f}}(t,x)] = s(t)$ . In Figure 3,  $s(t = \text{depression}) = 0.276$ . The actual
+
+prediction change  $\mathrm{D_f}(t,x)$  is the weighted average of  $|\mathrm{f_p}(x) - \mathrm{f_p}(\hat{x})|$  for all the  $\hat{x}$  that affect  $t$  (depression  $\twoheadrightarrow$  trouble, depression  $\twoheadrightarrow$  a mood), where  $\mathrm{f_p}(x)$  is the prediction probability of  $f$  on  $x$ . The weight corresponds to the number of words modified in  $\hat{x}$ : If  $e(\hat{x})$  denotes the set of edited words in  $x$ , then  $w(\hat{x}) = 1 / |e(\hat{x})|$ . Intuitively, the more words changed in  $\hat{x}$ , the less impact each word has; In Figure 3D, we regard "depression" to be responsible for half of the impact in in depression  $\twoheadrightarrow$  suicidal. We group  $\hat{x}$  based on their affected words  $G_{t} = \{\hat{x}\mid t\in e(\hat{x})\}$ .  $\mathrm{D_f}(t,x)$  then becomes:
+
+$$
+\mathrm {D} _ {\mathrm {f}} (t, x) = \frac {1}{| G _ {t} | + 1} \left(s (t) + \sum_ {\hat {x} \in G _ {t}} w (t) \cdot | \mathrm {f} _ {\mathrm {p}} (x) - \mathrm {f} _ {\mathrm {p}} (\hat {x}) |\right)
+$$
+
+The additional SHAP weight  $s(t)$  acts as a smoothing factor to penalize outliers. Then the gap between the expectation and reality is:
+
+$$
+\Delta \mathrm {D} _ {\mathrm {f}} (t, x) = \mathrm {D} _ {\mathrm {f}} (t, x) - \mathbf {H} [ \mathrm {D} _ {\mathrm {f}} (t, x) ]
+$$
+
+We first find the abnormal tokens: (1)  $t$  with small SHAP weight, but  $\hat{x}$  that change  $t$  experience large prediction change on average:  $t_{L} = \arg \max_{t\in x}\Delta \mathrm{D}_{\mathrm{f}}(t,x)$ , and (2)  $t$  with large SHAP weight, but  $\hat{x}$  with  $t$  changed usually have intact prediction:  $t_{U} = \arg \max_{t\in x} - \Delta \mathrm{D}_{\mathrm{f}}(t,x)$ .
+
+Then, we use the most extreme cases within the groups of  $G_{t_L}$  and  $G_{t_U}$  as the concrete counterfactual explanations, based on their prediction change  $|\mathrm{f_p}(x) - \mathrm{f_p}(\hat{x})|$ , and the aggregated SHAP weights of all the changed tokens:
+
+$$
+\hat {x} _ {L} = \underset {\hat {x} \in G _ {t _ {L}}} {\arg \max } \left(| f _ {p} (x) - f _ {p} (\hat {x}) | - \sum_ {u \in r (\hat {x})} s (u)\right)
+$$
+
+# C.2 User Study Details
+
+Figure 9 shows the sample interface. Participants started by just seeing the reference example and the model query box on the left hand side. When they chose to start the task or after they had exhausted their ten query chances, the query box was disabled, the tasks on the right were displayed, and the participants completed the tasks. We compensated participants \(20 for the one hour study.
+
+# D Additional Err. Analysis Details §5
+
+# D.1 Additional Case Study: Quantifiers
+
+As a follow-up to Figure 6, we slice the data to find entailment instances that have numbers in the hypothesis sentence, and perturb their quantifiers.
+
+![](images/22e79a04b98e96377ca011e78f5d713d11a98876307a797a3879b50ed52a2157.jpg)  
+Figure 9: A sample explanation task for §4
+
+![](images/f203e9ab9e8b9bf62638f0bce8bda9a93b1d338ea21efef8a0629a137f8ae4c8.jpg)  
+Figure 10: The NLI model cannot perform the actual counting when the exact number is missing from  $P$ .
+
+The extracted templates show that the model does not perform actual counting. When changing one number to another (NUM  $\rightarrow$  NUM), the model only flips the label in  $64.7\%$  cases, while we would expect all cases to be like in Figure 10A. An inspection of instances indicates the model gets confused when the premise does not contain the same number explicitly. Indeed, when we filter for such instances (e.g. Figure 10B), the label flip rate of NUM  $\rightarrow$  NUM is lowered to  $30.2\%$ .
+
+Further, the model only reacts to some quantifier phrase modifiers. +at least ("at least two women are at a bar") will always still result in entailment, prediction, +only and +exactly flip the predicted label to neutral  $90\%$  of the time ("exactly two women are at a bar"), but the model only changes the prediction  $52.6\%$  of the time when we add +more than ("more than two women are at a bar").
+
+# D.2 Representative Perturbation Templates
+
+Similar to Wu et al. (2020), the process of finding representative perturbation patterns takes two steps:
+
+Extract template. For each  $\hat{x}$ , we compare it with its  $x$ , and translate the perturbed spans into templates using different combinations of texts, lemmas, sparse and fine-grained part-of-speech tags. We optionally include surround-
+
+ing contexts determined by the dependency tree structure (tokens that share the same parents as the perturbed span). For example, "is not reading" can result in templates  $t$  as fine-grained as is reading  $\rightarrow$  is not reading, or as sparse as +PART. Meanwhile, "are not playing" also translates to +PART or +not, but not is reading  $\rightarrow$  is not reading. As such, the  $\hat{x}$  and templates form a many-to-many relationship: each  $\hat{x}$  generates multiple templates, and each template covers a different group of  $\hat{x}$ .
+
+Select Representative Templates. To find representative changes, we prefer (1) templates that cover a large number of  $\hat{x}$ . Meanwhile, to avoid overfitting to one instance (e.g., extracting a template red  $\rightarrow$  ADJ only because "red" is repeatedly perturbed in one  $x$ ), we prefer (2) templates that perturb various unique  $x$ . We also prefer (3) finer-grained templates, to avoid being unnecessarily abstract (e.g., to avoid abstracting "not" when it is the only PART changed.)
+
+With these intuitions, we form the template selection as a weighted set coverage problem. We see the union of counterfactuals for each  $x$ ,  $\hat{\mathbf{X}}$ , as the entire set of elements. Then, each template  $t \in T = t_1, \dots, t_m$  represents a subset of  $\hat{\mathbf{X}}$  that contains a number of counterfactuals  $|t|$ . We define the weight as  $w(t) = g(t) / |t|_x$ , where  $|t|_x$  quantifies the unique original  $x$  covered by  $t$ , and  $g(t)$  represents the sparsity of  $t$  (heuristically decreasing from text to POS). This way, templates that are too abstract or too focused on a certain  $x$  are penalized by having a high weight. We use a classic greedy algorithm (Vazirani, 2013) to select a subset of  $T^* \subset T$ , such that the aggregated coverage is maximized, and the weight is minimized.