Add files using upload-large-folder tool

parse/dev/GoOuIrDHG_Y/GoOuIrDHG_Y.md

@@ -0,0 +1,262 @@
+# End-to-end Symbolic Regression with Transformers
+
+Pierre-Alexandre Kamienny∗1,2, Stéphane d’Ascoli\*1,3 Guillaume Lample1, François Charton1 1Meta AI 2ISIR MLIA, Sorbonne Université 3Department of Physics, Ecole Normale Supérieure pakamienny@meta.com
+
+# Abstract
+
+Symbolic regression, the task of predicting the mathematical expression of a function from the observation of its values, is a difficult task which usually involves a two-step procedure: predicting the "skeleton" of the expression up to the choice of numerical constants, then fitting the constants by optimizing a non-convex loss function. The dominant approach is genetic programming, which evolves candidates by iterating this subroutine a large number of times. Neural networks have recently been tasked to predict the correct skeleton in a single try, but remain much less powerful.
+
+In this paper, we challenge this two-step procedure, and task a Transformer to directly predict the full mathematical expression, constants included. One can subsequently refine the predicted constants by feeding them to the non-convex optimizer as an informed initialization. We present ablations to show that this end-to-end approach yields better results, sometimes even without the refinement step. We evaluate our model on problems from the SRBench benchmark and show that our model approaches the performance of state-of-the-art genetic programming with several orders of magnitude faster inference.
+
+# Introduction
+
+Inferring mathematical laws from experimental data is a central problem in natural science; having observed a variable $y$ at $n$ points $\{ x _ { i } \} _ { i \in \mathbb { N } _ { n } }$ , it implies finding a function $f$ such that $y _ { i } \approx f ( x _ { i } )$ for all $i \in \mathbb { N } _ { n }$ . Two types of approaches exist to solve this problem. In parametric statistics (PS), the function $f$ is defined by a small number of parameters that can directly be estimated from the data. On the other hand, machine learning (ML) techniques such as decision trees and neural networks select $f$ from large families of non-linear functions by minimizing a loss over the data. The latter relax the assumptions about the underlying law, but their solutions are more difficult to interpret, and tend to overfit small experimental data sets, yielding poor extrapolation performance.
+
+Symbolic regression (SR) stands as a middle ground between PS and ML approaches: $f$ is selected from a large family of functions, but is required to be defined by an interpretable analytical expression. It has already proved extremely useful in a variety of tasks such as inferring physical laws [1, 2].
+
+SR is usually performed in two steps. First, predicting a “skeleton”, a parametric function using a pre-defined list of operators – typically, the basic operations $( + , \times , \div )$ and functions (sqrt, exp, sin, etc.). It determines the general shape of the law up to a choice of constants, e.g. $f ( x ) = \cos ( a x + b )$ . Then, the constants in the skeleton $( a , b )$ are estimated using optimization techniques, typically the Broyden–Fletcher–Goldfarb–Shanno algorithm (BFGS).
+
+![](images/fa3d51c7533362b23cc3ef2aca51bbcab62b9f44a7183e0cfd1e5d9ad6232ce9.jpg)  
+Figure 1: Our model outperforms previous DL-based methods and offers at least an order of magnitude inference speedup compared to SOTA GP-based methods. Pareto plot comparing the average test performance and inference time of our models with baselines provided by the SRbench benchmark [7], both on Feynman SR problems [1] and black-box regression problems. We use colors to distinguish three families of models: deep-learning based SR, genetic programming-based SR and classic machine learning methods (which do not provide symbolic solutions). A similar Pareto plot against formula complexity is provided in Fig. 11.
+
+The leading algorithms for SR rely on genetic programming (GP). At each generation, a population of candidates is predicted, and the fittest ones are selected based on the data, and mutated to build the next generation. The algorithm iterates this procedure until a satisfactory accuracy level is achieved.
+
+While GP algorithms achieve good prediction accuracy, they are notably slow (see the Pareto plot of Fig. 1). Indeed, the manually predefined function space to search is generally vast, and each generation involves a costly call to the BFGS routine. Also, GP does not leverage past experience: every new problem is learned from scratch. Inference time, i.e. time required to output a satisfactory expression, for most GP algorithms is both long and unbounded (the longer, the better the results), therefore this property has been neglected by the SR community, however fast inference can be useful to improve search-based SR algorithms, e.g. by reducing search space or providing initial guesses, as well as to tackle practical applications with time constraints, e.g. control or reinforcement learning [3, 4].
+
+Supervised training neural networks built for language modelling on large datasets of synthetic examples has recently been proposed for SR [5, 6]. These references follow the two-step procedure (predicting the skeleton then fitting the constants) inherited from GP. Once the model is trained, at inference, the skeleton is predicted via a simple forward pass, and a single call to BFGS is needed, thus resulting in a significant speed-up compared to GP. However, these methods are not as accurate as state-of-the-art GP, and have so far been limited to low-dimensional functions $D \le 3 ,$ ). We argue that two reasons underlie their shortcomings.
+
+First, skeleton prediction is an ill-posed problem that does not provide sufficient supervision: different instances of the same skeleton can have very different shapes, and instances of very different skeletons can be very close. Second, the loss function minimized by BFGS can be highly non-nonconvex: even when the skeleton is perfectly predicted, the correct constants are not guaranteed to be found. For these reasons, we believe, and will show, that doing away with skeleton estimation as a intermediary step can greatly facilitate the task of SR for language models.
+
+Contributions In this paper, we train Transformers over synthetic datasets to perform end-to-end (E2E) symbolic regression: solutions are predicted directly, without resorting to skeletons. To this effect, we leverage a hybrid symbolic-numeric vocabulary, that uses both symbolic tokens for the operators and variables and numeric tokens for the constants. One can then perform a refinement of the predicted constants by feeding them as informed guess to BFGS, mitigating nonlinear optimization issues. Finally, we introduce generation and inference techniques that allow our models to scale to larger problems: up to 10 input features against 3 in concurrent works.
+
+Evaluated over the SRBench benchmark [7], our model significantly narrows the accuracy gap with state-of-the-art GP techniques, while providing several orders of magnitude of inference time speedup (see Fig. 1). We also demonstrate strong robustness to noise and extrapolation capabilities.
+
+Related work SR is a challenging task that traces back from a few decades ago, with a large number of open-source and commercial softwares, and has already been used to accelerate scientific discoveries [8, 9, 10]. Most popular frameworks for symbolic regression use GP [11, 12, 13, 14, 15, 16, 17, 18, 19] (see [7] for a recent review), but SR has also seen growing interest from the Deep Learning (DL) community, motivated by the fact that neural networks are good at identifying qualitative patterns.
+
+Neural networks have been combined with GP algorithms, e.g. to simplify the original dataset [1], or to propose a good starting distribution over mathematical expressions[20]. [21, 22] propose modifications to feed-forward networks to include interpretable components, i.e. replacing usual activation functions by operators such as cos, sin, however these are hard to optimize and prone to numerical issues.
+
+Language models, and especially Transformers [23], have been trained over synthetic datasets to solve various mathematical problems: integration [24], dynamical systems [25], linear algebra [26], formal logic [27] and theorem proving [28]. A few papers apply these techniques to symbolic regression: the aforementioned references [6, 5] train Transformers to predict function skeletons, while [29] infers one-dimensional recurrence relations in sequences of numbers. [30] trains fully-connected networks to predict simple formulas from tabular data.
+
+The recently introduced SRBench [7] provides a benchmark for rigorous evaluation of SR methods, in addition to 14 SR methods and $7 \mathrm { M L }$ baselines which we will compare to in this work.
+
+# 1 Data generation
+
+Our approach consists in training language models on vast synthetic datasets. Each training example is a pair: a set of $N$ points $( x , y ) \in \bar { \mathbb { R } ^ { D } } \overset { - } { \times } \mathbb { R }$ as the input, and a function $f$ such that $y = f ( x )$ as the target2 Examples are generated by first sampling a random function $f$ , then a set of $N$ input values $( x _ { i } ) _ { i \in \mathbb { N } _ { N } }$ in $\mathring { \mathbb { R } } ^ { D }$ , and computing $y _ { i } = f ( x _ { i } )$ .
+
+# 1.1 Generating functions
+
+To sample functions $f$ , we follow the seminal approach of Lample and Charton [24], and generate random trees with mathematical operators as internal nodes and variables or constants as leaves. The procedure is detailed below (see Table 3 in the Appendix for the values of parameters):
+
+1. Sample the desired input dimension $D$ of the function $f$ from $\mathcal { U } \{ 1 , D _ { \mathrm { m a x } } \}$ .   
+2. Sample the number of binary operators $b$ from $\mathcal { U } \{ D - 1 , D + b _ { \mathrm { m a x } } \}$ then sample $b$ operators from $\mathcal { U } \{ + , - , \times \} ^ { 3 }$ .   
+3. Build a binary tree with those $b$ nodes, using the sampling procedure of [24].   
+4. For each leaf in the tree, sample one of the variables $x _ { d }$ , $d \in \mathbb { N } _ { D }$ .   
+5. Sample the number of unary operators $u$ from $\mathcal { U } \{ 0 , u _ { \mathrm { m a x } } \}$ then sample $u$ operators from the list $O _ { u }$ in Table 3, and insert them at random positions in the tree.   
+6. For each variable $x _ { d }$ and unary operator $u$ , apply a random affine transformation, i.e. replace $x _ { d }$ by $a x _ { d } + b$ , and $u$ by $a u + b$ , with $( a , b )$ sampled from $\mathcal { D } _ { \mathrm { a f f } }$ .
+
+Note that since we require independent control on the number of unary operators (which is independent of $D$ ) and binary operators (which depends on $D$ ), we cannot directly sample a unary-binary tree as in [24]. Note also that the first $D$ variables are sampled in ascending order to obtain the desired input dimension, which means functions with missing variables such as $x _ { 1 } + x _ { 3 }$ are never encountered; this is not an issue as our model can always set the prefactor of $x _ { 2 }$ to zero. As discussed quantitatively in App. C, the number of possible skeletons as well as the random sampling of numerical constants guarantees that our model almost never sees the same function twice, and cannot simply perform memorization. See App. B for examples of the skeleton of generated expressions.
+
+![](images/3e48139554525a020662b9a675c7eb49c7bd34e4f9191884863084676779ee11.jpg)  
+Figure 2: Sketch of our model. During training, the inputs are all whitened. At inference, we whiten them as a pre-processing step; the predicted function must then be unscaled to account for the whitening.
+
+# 1.2 Generating inputs
+
+For each function $f : \mathbb { R } ^ { D }  \mathbb { R }$ , we sample $N \in \mathcal { U } \{ 1 0 D , N _ { \mathrm { m a x } } \}$ input values $x _ { i } \in \mathbb { R } ^ { D }$ from the distribution $\mathcal { D } _ { x }$ described below, and compute the corresponding output values $y _ { i } = f ( x _ { i } )$ . If any $x _ { i }$ is outside the domain of definition of $f$ or if any $y _ { i }$ is larger $1 \bar { 0 } ^ { 1 0 0 }$ , the process is aborted, and we start again by generating a new function. Note that rejecting and resampling out-of-domain values of $x _ { i }$ , the obvious and cheaper alternative, would provide the model with additional information about $f$ , by allowing it to learn its domain of definition.
+
+To maximize the diversity of input distributions seen during training, we sample our inputs from a mixture of distributions (uniform or gaussian), centered around $k$ random centroids4, see App. A for some illustrations at $D = 2$ . Input samples are generated as follows:
+
+1. Sample a number of clusters $k \sim \mathcal { U } \{ 1 , k _ { m a x } \}$ and $k$ weights $w _ { i } \sim \mathcal { U } ( 0 , 1 )$ , which are then normalized so that $\textstyle \sum _ { i } w _ { i } = 1$ .   
+2. For each cluster $i \in \mathbb { N } _ { k }$ , sample a centroid $\mu _ { i } \sim \mathcal { N } ( 0 , 1 ) ^ { D }$ , a vector of variances $\sigma _ { i } \sim$ $\mathcal { U } ( 0 , 1 ) ^ { D }$ and a distribution shape (gaussian or uniform) $\dot { \mathcal { D } _ { i } } \in \{ \mathcal { N } , \mathcal { U } \}$ .   
+3. For each cluster $i \in \mathbb { N } _ { k }$ , sample $\lfloor w _ { i } N \rfloor$ input points from $\mathcal { D } _ { i } ( \mu _ { i } , \sigma _ { i } )$ then apply a random rotation sampled from the Haar distribution.   
+4. Finally, concatenate all the points obtained and whiten them by substracting the mean and dividing by the standard deviation along each dimension.
+
+# 1.3 Tokenization
+
+Following [26], we represent numbers in base 10 floating-point notation, round them to four significant digits, and encode them as sequences of 3 tokens: their sign, mantissa (between 0 and 9999), and exponent (from E-100 to E100).
+
+To represent mathematical functions as sequences, we enumerate the trees in prefix order, i.e. direct Polish notation, as in [24]: operators and variables and integers are represented as single autonomous tokens, and constants are encoded as explained above.
+
+For example, the expression $f ( x ) = \cos ( 2 . 4 2 4 2 x )$ is encoded as [c $\mathtt { \mathtt { P S } } , \mathtt { m u l } , + , 2 4 2 4 , \mathtt { E } - 3 , \mathtt { x } ]$ . Note that the vocabulary of the decoder contains a mix of symbolic tokens (operators and variables) and numeric tokens, whereas that of the encoder contains only numeric tokens5.
+
+![](images/2841e91f2a3dbd4efcd9843518678a73997e842ec2c5c64c40095eaf0f581ccf.jpg)  
+Figure 3: Attention heads reveal intricate mathematical analysis. We considered the expression $f ( { \bar { x } } ) = \sin ( x ) / x$ , with $N = 1 0 0$ input points sampled between $- 2 0$ and 20 (red dots; the y-axis is arbitrary). We plotted the attention maps of a few heads of the encoder, which are $N \times N$ matrices where the element $( i , j )$ represents the attention between point $i$ and point $j$ . Notice that heads 2, 3 and 4 of the second layer analyze the periodicity of the function in a Fourier-like manner.
+
+# 2 Methods
+
+Below we describe our approach for end-to-end symbolic regression; please refer to Fig. 2 for an illustration.
+
+# 2.1 Model
+
+Embedder Our model is provided $N$ input points $( x , y ) \in \mathbb { R } ^ { D + 1 }$ , each of which is represented as $3 ( D + 1 )$ tokens of dimension $d _ { \mathrm { e m b } }$ . As $D$ and $N$ become large, this results in long input sequences (e.g. 6600 tokens for $D = 1 0$ and $N = 2 0 0$ ), which challenge the quadratic complexity of Transformers. To mitigate this, we introduce an embedder to map each input point to a single embedding.
+
+The embedder pads the empty input dimensions to $D _ { \mathrm { m a x } }$ , then feeds the $3 ( D _ { \mathrm { m a x } } + 1 ) d _ { \mathrm { e m b } }$ -dimensional vector into a 2-layer fully-connected feedforward network (FFN) with ReLU activations, which projects down to dimension $d _ { \mathrm { e m b } } \mathrm { ^ 6 }$ The resulting $N$ embeddings of dimension $d _ { \mathrm { e m b } }$ are then fed to the Transformer.
+
+Transformer We use a sequence to sequence Transformer architecture [23] with 16 attention heads and an embedding dimension of 512, containing a total of 86M parameters. Like [26], we observe that the best architecture for this problem is asymmetric, with a deeper decoder: we use 4 layers in the encoder and 16 in the decoder. A notable property of this task is the permutation invariance of the $N$ input points. To account for this invariance, we remove positional embeddings from the encoder.
+
+As shown in Fig. 3 and detailed in App. D, the encoder captures the most distinctive features of the functions considered, such as critical points and periodicity, and blends a mix of short-ranged heads focusing on local details with long-ranged heads which capture the global shape of the function.
+
+Training We optimize a cross-entropy loss with the Adam optimizer, warming up the learning rate from $1 0 ^ { - 7 }$ to $2 . 1 0 ^ { - 4 }$ over the first 10,000 steps, then decaying it as the inverse square root of the number of steps, following [23]. We hold out a validation set of $1 0 ^ { 4 }$ examples from the same generator, and train our models until the accuracy on the validation set saturates (around 50 epochs of 3M examples).
+
+Input sequence lengths vary significantly with the number of points $N$ ; to avoid wasteful padding, we batch together examples of similar lengths, ensuring that a full batch contains a minimum of 10,000 tokens. On 32 GPU with 32GB memory each, one epoch is processed in about half an hour.
+
+# 2.2 Inference tricks
+
+In this section, we describe three tricks to improve the performance of our model at inference.
+
+Table 1: The importance of an end-to-end model with refinement.   
+
+<table><tr><td>Model</td><td>Function f(x,y)</td></tr><tr><td>Target</td><td>sin(10x) exp(0.1y)</td></tr><tr><td>Skeleton +BFGS</td><td>- sin(1.7x)(0.059y + 0.19)</td></tr><tr><td>E2E no BFGS</td><td>sin(9.9x) exp(0.1y)</td></tr><tr><td>E2E+BFGS random init</td><td>- sin(0.095x) exp(0.27y)</td></tr><tr><td>E2E+BFGS model init</td><td>sin(10x) exp(0.1y)</td></tr></table>
+
+The skeleton approach recovers an incorrect skeleton. The E2E approach predicts the right skeleton. Refinement worsens original prediction when randomly initialized, and yields the correct result when initialized with predicted constants.
+
+Refinement Previous language models for SR, such as [6], follow a skeleton approach: they first predict equation skeletons, then fit the constants with a non-linear optimisation solver such as BFGS. In this paper, we follow an end-to-end (E2E) approach: predicting simultaneously the function and the values of the constants. However, we improve our results by adding a refinement step: fine-tuning the constants a posteriori with BFGS, initialized with our model predictions7.
+
+This results in a large improvement over the skeleton approach, as we show by training a Transformer to predict skeletons in the same experimental setting. The improvement comes from two reasons: first, prediction of the full formula provides better supervision, and helps the model predict the skeleton; second, the BFGS routine strongly benefits from the informed initial guess, which helps the model predict the constants. This is illustrated qualitatively in Table 1, and quantitatively in Table 2.
+
+Scaling As described in Section 1.2, all input points presented to the model during training are whitened: their distribution is centered around the origin and has unit variance. To allow accurate prediction for input points with a different mean and variance, we introduce a scaling procedure during inference. Let $f$ the function to be inferred, $x$ be the input points, and $\mu = \mathrm { m e a n } ( x ) , \sigma = \mathrm { s t d } ( x )$ . As illustrated in Fig. 2 we pre-process the input data by replacing $x$ by $\begin{array} { r } { \tilde { x } = \frac { x - \mu } { \sigma } } \end{array}$ . The model then predicts ${ \hat { f } } ( { \tilde { x } } ) = { \hat { f } } ( \sigma x + \mu )$ , and we can recover an approximation of $f$ by unscaling the variables in $\hat { f }$ .
+
+This gives our model the desirable property to be insensitive to the scale of the input points: DL-based approaches to SR are known to fail when the inputs are outside the range of values seen during training [29, 26]. Note that here, the scale of the inputs translates to the scale of the constants in the function $f$ ; although these coefficients are sampled in ${ \mathcal { D } } _ { \mathrm { a f f } }$ during training, coefficients outside $\mathcal { D } _ { \mathrm { a f f } }$ can be expressed by multiplication of constants in $\mathcal { D } _ { \mathrm { a f f } }$ .
+
+Bagging and decoding Since our model was trained on $N \leq 2 0 0$ input points, it does not perform satisfactorily at inference when presented with more than 200 input points. To take advantage of large datasets while accommodating memory constraints, we perform bagging: whenever $N$ is larger than 200 at inference, we randomly split the dataset into $B$ bags of 200 input points8.
+
+For each bag, we apply a forward pass and generate $C$ function candidates via random sampling or beam search using the next token distribution. As shown in App. F (Fig. 16), the more commonly used beam search [34] strategy leads to much less good results than sampling due to the lack of diversity induced by constant prediction (typical beams will look like $\sin ( x ) , \sin ( 1 . 1 x ) , \sin ( 0 . 9 x ) , \ldots )$ . This provides us with a set of $B C$ candidate solutions.
+
+Inference time Our model inference speed has two sources: the forward passes described above on one hand (which can be parallelized up to memory limits of the GPU), and the refinements of candidate functions on the other (which are CPU-based and could also be parallelized, although we did not consider this option here).
+
+Table 2: Our approach outperforms the skeleton approach.   
+
+<table><tr><td>Model</td><td>R²</td><td>Acco.1</td><td>Acco.01</td><td>Acco.001</td></tr><tr><td>Skeleton + BFGS</td><td>0.43</td><td>0.40</td><td>0.27</td><td>0.17</td></tr><tr><td>E2E no BFGS</td><td>0.62</td><td>0.51</td><td>0.27</td><td>0.09</td></tr><tr><td>E2E +BFGS random init</td><td>0.44</td><td>0.44</td><td>0.30</td><td>0.19</td></tr><tr><td>E2E+BFGS model init</td><td>0.68</td><td>0.61</td><td>0.44</td><td>0.29</td></tr></table>
+
+Metrics are computed over the 10, 000 examples of the evaluation set.
+
+Since $B C$ can become large, we rank candidate functions (according to their error on all input points), get rid of redundant skeleton functions and keep the best $K$ candidates for the refinement step9. To speed up the refinement, we use a subset of at most 1024 input points for the optimization. The parameters $B$ , $C$ and $K$ can be used as cursors in the speed-accuracy tradeoff: in the experiments presented in Fig. 1, we selected $B = 1 0 0$ , $C = 1 0$ , $K = 1 0$ .
+
+# 3 Results
+
+In this section, we present the results of our model. We begin by studying in-domain accuracy, then present results on out-of-domain datasets.
+
+# 3.1 In-domain performance
+
+We report the in-domain performance of our models by evaluating them on a fixed validation set of 100,000 examples, generated as per Section 1. Validation functions are uniformly spread out over three difficulty factors: number of unary operators, binary operators, and input dimension. For each function, we evaluate the performance of the model when presented $N = [ 5 0 , 1 0 0 , 1 5 0 , 2 0 0 ]$ input points $( x , y )$ , and prediction accuracy is evaluated on $N _ { \mathrm { t e s t } } = 2 0 0$ points sampled from a fresh instance of the multimodal distribution described in Section 1.2.
+
+We assess the performance of our model using two popular metrics: $R ^ { 2 }$ -score [7] and accuracy to tolerance $\tau$ [6, 29]:
+
+$$
+R ^ { 2 } = 1 - \frac { \sum _ { i } ^ { N _ { \mathrm { t s t } } } \left( y _ { i } - \hat { y } _ { i } \right) ^ { 2 } } { \sum _ { i } ^ { N _ { \mathrm { t s t } } } \left( y _ { i } - \bar { y } \right) ^ { 2 } } , \qquad \operatorname { A c c } _ { \tau } = 1 \left( \operatorname* { m a x } _ { 1 \leq i \leq N _ { \mathrm { t s t } } } \left| \frac { \hat { y } _ { i } - y _ { i } } { y _ { i } } \right| \leq \tau \right) ,
+$$
+
+where $\mathbb { 1 }$ is the indicator function.
+
+$R ^ { 2 }$ is classically used in statistics, but it is unbounded, hence a single bad prediction can cause the average $R ^ { 2 }$ over a set of examples to be extremely bad. To circumvent this, we set $R ^ { 2 } = 0$ upon pathological examples as in [7](such examples occur in less that $1 \%$ of cases)10. The accuracy metric provides a better idea of the precision of the predicted expression as it depends on a desired tolerance threshold. However, due to the presence of the max operator, it is sensitive to outliers, and hence to the number of points considered at test time (more points entails a higher risk of outlier). To circumvent this, we discard the $5 \%$ worst predictions, following [6].
+
+End-to-end outperforms skeleton In Table 2, we report the average in-domain results of our models. Without refinement, our E2E model outperforms the skeleton model trained under the same protocol in terms of low precision prediction $R ^ { 2 }$ and $\mathbf { A c c } _ { 0 . 1 }$ metrics), but small errors in the prediction of the constants lead to lower performance at high precision $\mathbf { \widetilde { A c c } _ { 0 . 0 0 1 } }$ metric). The refinement procedure alleviates this issue significantly, inducing a three-fold increase in $\operatorname { A c c } _ { 0 . 0 0 1 }$ while also boosting other metrics. Initializing BFGS with the constants estimated in the E2E phase plays a crucial role: with random initialization, the BFGS step actually degrades E2E performance. However, refinement with random initialization still achieves better results than the skeleton model: this suggests that the E2E model predicts skeletons better that the skeleton model.
+
+![](images/76c303fcb62bae6cd5933b6368f08c69013d5a7bbd22ba7579cf51c5da8b7be1.jpg)  
+Figure 4: Ablation over the function difficulty (top row) and input difficulty (bottom row). We plot the accuracy at $\tau = 0 . 1$ (Eq. 1), see App. E for the $R ^ { 2 }$ score. We distinguish four models: skeleton, E2E without refinement, E2E with refinement from random guess and E2E with refinement. A: number of unary operators. B: number of binary operators. C: input dimension. D: Low-resource performance, evaluated by varying the number of input points. E: Extrapolation performance, evaluated by varying the variance of the inputs. F: Robustness to noise, evaluated by varying the multiplicative noise added to the labels.
+
+Ablation Fig. 4A,B,C presents an ablation over three indicators of formula difficulty (from left to right): number of unary operators, number of binary operators and input dimension. In all cases, increasing the factor of difficulty degrades performance, as one could expect. This may give the impression that our model does not scale well with the input dimension, but we show that our model scales in fact very well on out-of-domain datasets compared to concurrent methods (see Fig. 15 of the Appendix). We include a qualitative ablation on the improvement caused by the use of mixture of distributions in App. E.
+
+Fig. 4D shows how performance depends on the number of input points fed to the model, $N$ . In all cases, performance increases, but much more signicantly for the E2E models than for the skeleton model, demonstrating the importance of having a lot of data to accurately predict the constants in the expression.
+
+Extrapolation and robustness In Fig. 4E, we examine the ability of our models to interpolate/extrapolate by varying the scale of the test points: instead of normalizing the test points to unit variance, we normalize them to a scale $\sigma$ . As expected, performance degrades as we increase $\sigma$ , however the extrapolation performance remains decent even very far away from the inputs $\sigma = 3 2$ ).
+
+Finally, in Fig. 4F, we examine the effect of corrupting the targets $y$ with a multiplicative noise of variance $\sigma$ : $y \to y ( 1 + \xi ) , \xi \sim \mathcal { N } ( 0 , \varepsilon )$ . The results reveal something interesting: without refinement, the E2E model is not robust to noise, and actually performs worse than the skeleton model at high noise. This shows how sensitive the Transformer is to the inputs when predicting constants. Refinement improves robustness significantly, but the initialization of constants to estimated values has less impact, since the prediction of constants is corrupted by the noise.
+
+# 3.2 Out-of-domain generalization
+
+We evaluate our method on the recently released benchmark SRBench[7]. Its repository contains a set of 252 regression datasets from the Penn Machine Learning Benchmark (PMLB)[35] in addition to 14 open-source SR and ML baselines. The datasets consist in "ground-truth" problems where the true underlying function is known, as well as "black-box" problems which are more general regression datasets without an underlying ground truth. We filter out problems from SRBench to only keep regression problems with $D \leq 1 0$ with continuous features; this results in 190 regression datasets, splitted into 57 black-box problems (combination of real-world and noisy, synthetic datasets), 119 SR datasets from the Feynman [1] and 14 SR datasets from the ODE-Strogatz [36] databases. Each dataset is split into $7 5 \%$ training data and $2 5 \%$ test data, on which performance is evaluated.
+
+The overall performance of our models is illustrated in the Pareto plot of Fig. 1, where we see that on both types of problems, our model achieves performance close to state-of-the-art GP models such as Operon with a fraction of the inference time11. Impressively, our model outperforms all classic ML methods (e.g. XGBoost and Random Forests) on real-world problems with a lower inference time, and while outputting an interpretable formula.
+
+We provide more detailed results on Feynman problems in Fig. 5, where we additionally plot the formula complexity, i.e. the number of nodes in the mathematical tree (see App. F for similar results on black-box and Strogatz problems). Varying the noise applied to the targets noise, we see that our model displays similar robustness to state-of-the-art GP models. We additionally include ablation on the use of scaling during inference in App. E.
+
+While the average accuracy or our model is only ranked fourth, it outputs formulas with lower complexity than the top 2 models (Operon and SBP-GP), which is an important criteria for SR problems: see App. 11 for complexity-accuracy Pareto plots. To the best of our knowledge, our model is the first non-GP approach to achieve such competitive results for SR.
+
+![](images/fceb11b119081140d389755cf596b6bdf20ae4bbd4f59aea3eeeb207c85b02f3.jpg)  
+Figure 5: Our model presents strong accuracy-speed-complexity tradeoffs, even in presence of noise. Results are averaged over all 119 Feynman problems, for 10 random seeds and three target noises each as shown in the legend. The accuracy is computed as the fraction of problems for which the $R ^ { 2 }$ score on test examples is above 0.99. Models are ranked according to the accuracy averaged over all target noise.
+
+# Conclusion
+
+In this work, we introduced a competitive deep learning model for SR by using a novel numericsymbolic approach. Through rigorous ablations, we showed that predicting the constants in an expression not only improves performance compared to predicting a skeleton, but can also serve as an informed initial condition for a solver to refine the value of the constants.
+
+Our model outperforms previous deep learning approaches by a margin on SR benchmarks, and scales to larger dimensions. Yet, the dimensions considered here remain moderate $D < 1 0 \AA$ ): adapting to the truly high-dimensional setup is an interesting future direction, and will likely require qualitative changes in the data generation protocol. While our model narrows the gap between GP and DL based SR, closing the gap also remains a challenge for future work.
+
+This work opens up a whole new range of applications for SR in fields which require real-time inference. We hope that the methods presented here may also serve as a toolbox for many future applications of Transformers for symbolic tasks.
+
+References   
+[1] Silviu-Marian Udrescu and Max Tegmark. Ai feynman: a physics-inspired method for symbolic regression, 2020.   
+[2] M. Cranmer, Alvaro Sanchez-Gonzalez, Peter W. Battaglia, Rui Xu, Kyle Cranmer, David N. Spergel, and Shirley Ho. Discovering symbolic models from deep learning with inductive biases. ArXiv, abs/2006.11287, 2020.   
+[3] Jiˇrí Kubalík, Erik Derner, Jan Žegklitz, and Robert Babuška. Symbolic regression methods for reinforcement learning. IEEE Access, 9:139697–139711, 2021.   
+[4] Erik Derner, Jirí Kubalík, Nicola Ancona, and Robert Babuška. Symbolic regression for constructing analytic models in reinforcement learning. ArXiv, abs/1903.11483, 2019.   
+[5] Mojtaba Valipour, Bowen You, Maysum Panju, and Ali Ghodsi. Symbolicgpt: A generative transformer model for symbolic regression. arXiv preprint arXiv:2106.14131, 2021.   
+[6] Luca Biggio, Tommaso Bendinelli, Alexander Neitz, Aurelien Lucchi, and Giambattista Parascandolo. Neural symbolic regression that scales, 2021.   
+[7] William La Cava, Patryk Orzechowski, Bogdan Burlacu, Fabricio Olivetti de Franca, Marco Virgolin, Ying Jin, Michael Kommenda, and Jason H Moore. Contemporary symbolic regression methods and their relative performance. arXiv preprint arXiv:2107.14351, 2021.   
+[8] Nikos Aréchiga, Francine Chen, Yan-Ying Chen, Yanxia Zhang, Rumen Iliev, Heishiro Toyoda, and Kent Lyons. Accelerating understanding of scientific experiments with end to end symbolic regression. ArXiv, abs/2112.04023, 2021.   
+[9] Silviu-Marian Udrescu and Max Tegmark. Symbolic pregression: Discovering physical laws from raw distorted video. Physical review. E, 103 4-1:043307, 2021.   
+[10] Anja Butter, Tilman Plehn, Nathalie Soybelman, and Johann Brehmer. Back to the formula – lhc edition. 2021.   
+[11] Michael Schmidt and Hod Lipson. Age-fitness pareto optimization. In Genetic programming theory and practice VIII, pages 129–146. Springer, 2011.   
+[12] Michael Schmidt and Hod Lipson. Distilling free-form natural laws from experimental data. science, 324(5923):81–85, 2009.   
+[13] William La Cava, Tilak Raj Singh, James Taggart, Srinivas Suri, and Jason H Moore. Learning concise representations for regression by evolving networks of trees. arXiv preprint arXiv:1807.00981, 2018.   
+[14] Trent McConaghy. Ffx: Fast, scalable, deterministic symbolic regression technology. In Genetic Programming Theory and Practice IX, pages 235–260. Springer, 2011.   
+[15] Marco Virgolin, Tanja Alderliesten, Cees Witteveen, and Peter AN Bosman. Improving model-based genetic programming for symbolic regression of small expressions. Evolutionary computation, 29(2):211–237, 2021.   
+[16] Fabricio Olivetti de França and Guilherme Seidyo Imai Aldeia. Interaction–transformation evolutionary algorithm for symbolic regression. Evolutionary computation, 29(3):367–390, 2021.   
+[17] Ignacio Arnaldo, Krzysztof Krawiec, and Una-May O’Reilly. Multiple regression genetic programming. In Proceedings of the 2014 Annual Conference on Genetic and Evolutionary Computation, pages 879–886, 2014.   
+[18] Marco Virgolin, Tanja Alderliesten, and Peter A. N. Bosman. Linear scaling with and within semantic backpropagation-based genetic programming for symbolic regression. In Proceedings of the Genetic and Evolutionary Computation Conference, GECCO ’19, page 1084–1092, New York, NY, USA, 2019. Association for Computing Machinery.   
+[19] Michael Kommenda, Bogdan Burlacu, Gabriel Kronberger, and Michael Affenzeller. Parameter identification for symbolic regression using nonlinear least squares. Genetic Programming and Evolvable Machines, 21(3):471–501, 2020.   
+[20] Brenden K Petersen, Mikel Landajuela Larma, T Nathan Mundhenk, Claudio P Santiago, Soo K Kim, and Joanne T Kim. Deep symbolic regression: Recovering mathematical expressions from data via risk-seeking policy gradients. arXiv preprint arXiv:1912.04871, 2019.   
+[21] Georg Martius and Christoph H Lampert. Extrapolation and learning equations. arXiv preprint arXiv:1610.02995, 2016.   
+[22] Subham Sahoo, Christoph Lampert, and Georg Martius. Learning equations for extrapolation and control. In International Conference on Machine Learning, pages 4442–4450. PMLR, 2018.   
+[23] Ashish Vaswani, Noam Shazeer, Niki Parmar, Jakob Uszkoreit, Llion Jones, Aidan N Gomez, Łukasz Kaiser, and Illia Polosukhin. Attention is all you need. In Advances in neural information processing systems, pages 5998–6008, 2017.   
+[24] Guillaume Lample and François Charton. Deep learning for symbolic mathematics. arXiv preprint arXiv:1912.01412, 2019.   
+[25] François Charton, Amaury Hayat, and Guillaume Lample. Learning advanced mathematical computations from examples. arXiv preprint arXiv:2006.06462, 2020.   
+[26] François Charton. Linear algebra with transformers. arXiv preprint arXiv:2112.01898, 2021.   
+[27] Christopher Hahn, Frederik Schmitt, Jens U Kreber, Markus N Rabe, and Bernd Finkbeiner. Teaching temporal logics to neural networks. arXiv preprint arXiv:2003.04218, 2020.   
+[28] Stanislas Polu and Ilya Sutskever. Generative language modeling for automated theorem proving. arXiv preprint arXiv:2009.03393, 2020.   
+[29] Stéphane d’Ascoli, Pierre-Alexandre Kamienny, Guillaume Lample, and François Charton. Deep symbolic regression for recurrent sequences. arXiv preprint arXiv:2201.04600, 2022.   
+[30] Nikos Arechiga, Francine Chen, Yan-Ying Chen, Yanxia Zhang, Rumen Iliev, Heishiro Toyoda, and Kent Lyons. Accelerating understanding of scientific experiments with end to end symbolic regression, 2021.   
+[31] Roger Guimerà, Ignasi Reichardt, Antoni Aguilar-Mogas, Francesco A Massucci, Manuel Miranda, Jordi Pallarès, and Marta Sales-Pardo. A bayesian machine scientist to aid in the solution of challenging scientific problems. Science advances, 6(5):eaav6971, 2020.   
+[32] Patrick Kidger. Sympytorch. https://github.com/patrick-kidger/sympytorch, 2021.   
+[33] Richard Zou Horace He. functorch: Jax-like composable function transforms for pytorch. https://github.com/pytorch/functorch, 2021.   
+[34] Sam Wiseman and Alexander M. Rush. Sequence-to-sequence learning as beam-search optimization, 2016.   
+[35] Jerome H Friedman. Greedy function approximation: a gradient boosting machine. Annals of statistics, pages 1189–1232, 2001.   
+[36] Steven H. Strogatz. Nonlinear Dynamics and Chaos: With Applications to Physics, Biology, Chemistry and Engineering. Westview Press, 2000.   
+[37] Ying Jin, Weilin Fu, Jian Kang, Jiadong Guo, and Jian Guo. Bayesian symbolic regression, 2020.   
+[38] T. Nathan Mundhenk, Mikel Landajuela, Ruben Glatt, Claudio P. Santiago, Daniel M. Faissol, and Brenden K. Petersen. Symbolic regression via neural-guided genetic programming population seeding, 2021.
+
+[39] Sean Welleck, Peter West, Jize Cao, and Yejin Choi. Symbolic brittleness in sequence models: on systematic generalization in symbolic mathematics. In Proceedings of the AAAI Conference on Artificial Intelligence, volume 36, pages 8629–8637, 2022.
+
+[40] Martin Vastl, Jonáš Kulhánek, Jirí Kubalík, Erik Derner, and Robert Babuška. Symformer: End-to-end symbolic regression using transformer-based architecture. arXiv preprint arXiv:2205.15764, 2022.
+
+# Checklist
+
+1. For all authors...
+
+(a) Do the main claims made in the abstract and introduction accurately reflect the paper’s contributions and scope? [Yes]   
+(b) Did you describe the limitations of your work? [Yes]   
+(c) Did you discuss any potential negative societal impacts of your work? [N/A]   
+(d) Have you read the ethics review guidelines and ensured that your paper conforms to them? [Yes]
+
+2. If you are including theoretical results...
+
+(a) Did you state the full set of assumptions of all theoretical results? [N/A] (b) Did you include complete proofs of all theoretical results? [N/A]
+
+3. If you ran experiments...
+
+(a) Did you include the code, data, and instructions needed to reproduce the main experimental results (either in the supplemental material or as a URL)? [Yes]   
+(b) Did you specify all the training details (e.g., data splits, hyperparameters, how they were chosen)? [Yes]   
+(c) Did you report error bars (e.g., with respect to the random seed after running experiments multiple times)? [No] We noticed the random seed that dictates model initialization had no influence on performance after a few training epochs, therefore we trained our models on a single random seed to avoid unnecessary computations, especially as learning is costly.   
+(d) Did you include the total amount of compute and the type of resources used (e.g., type of GPUs, internal cluster, or cloud provider)? [Yes]
+
+4. If you are using existing assets (e.g., code, data, models) or curating/releasing new assets...
+
+(a) If your work uses existing assets, did you cite the creators? [Yes]   
+(b) Did you mention the license of the assets? [Yes]   
+(c) Did you include any new assets either in the supplemental material or as a URL? [Yes]   
+(d) Did you discuss whether and how consent was obtained from people whose data you’re using/curating? [N/A]   
+(e) Did you discuss whether the data you are using/curating contains personally identifiable information or offensive content? [N/A]
+
+5. If you used crowdsourcing or conducted research with human subjects...
+
+(a) Did you include the full text of instructions given to participants and screenshots, if applicable? [N/A]   
+(b) Did you describe any potential participant risks, with links to Institutional Review Board (IRB) approvals, if applicable? [N/A]   
+(c) Did you include the estimated hourly wage paid to participants and the total amount spent on participant compensation? [N/A]

parse/dev/GoOuIrDHG_Y/GoOuIrDHG_Y_content_list.json

@@ -0,0 +1,1120 @@
+[
+    {
+        "type": "text",
+        "text": "End-to-end Symbolic Regression with Transformers ",
+        "text_level": 1,
+        "bbox": [
+            184,
+            122,
+            812,
+            148
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Pierre-Alexandre Kamienny∗1,2, Stéphane d’Ascoli\\*1,3 Guillaume Lample1, François Charton1 1Meta AI 2ISIR MLIA, Sorbonne Université 3Department of Physics, Ecole Normale Supérieure pakamienny@meta.com ",
+        "bbox": [
+            305,
+            199,
+            689,
+            286
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Abstract ",
+        "text_level": 1,
+        "bbox": [
+            462,
+            321,
+            535,
+            338
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Symbolic regression, the task of predicting the mathematical expression of a function from the observation of its values, is a difficult task which usually involves a two-step procedure: predicting the \"skeleton\" of the expression up to the choice of numerical constants, then fitting the constants by optimizing a non-convex loss function. The dominant approach is genetic programming, which evolves candidates by iterating this subroutine a large number of times. Neural networks have recently been tasked to predict the correct skeleton in a single try, but remain much less powerful. ",
+        "bbox": [
+            233,
+            354,
+            764,
+            465
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "In this paper, we challenge this two-step procedure, and task a Transformer to directly predict the full mathematical expression, constants included. One can subsequently refine the predicted constants by feeding them to the non-convex optimizer as an informed initialization. We present ablations to show that this end-to-end approach yields better results, sometimes even without the refinement step. We evaluate our model on problems from the SRBench benchmark and show that our model approaches the performance of state-of-the-art genetic programming with several orders of magnitude faster inference. ",
+        "bbox": [
+            232,
+            468,
+            764,
+            579
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Introduction ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            607,
+            281,
+            623
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Inferring mathematical laws from experimental data is a central problem in natural science; having observed a variable $y$ at $n$ points $\\{ x _ { i } \\} _ { i \\in \\mathbb { N } _ { n } }$ , it implies finding a function $f$ such that $y _ { i } \\approx f ( x _ { i } )$ for all $i \\in \\mathbb { N } _ { n }$ . Two types of approaches exist to solve this problem. In parametric statistics (PS), the function $f$ is defined by a small number of parameters that can directly be estimated from the data. On the other hand, machine learning (ML) techniques such as decision trees and neural networks select $f$ from large families of non-linear functions by minimizing a loss over the data. The latter relax the assumptions about the underlying law, but their solutions are more difficult to interpret, and tend to overfit small experimental data sets, yielding poor extrapolation performance. ",
+        "bbox": [
+            174,
+            638,
+            825,
+            750
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Symbolic regression (SR) stands as a middle ground between PS and ML approaches: $f$ is selected from a large family of functions, but is required to be defined by an interpretable analytical expression. It has already proved extremely useful in a variety of tasks such as inferring physical laws [1, 2]. ",
+        "bbox": [
+            176,
+            756,
+            825,
+            797
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "SR is usually performed in two steps. First, predicting a “skeleton”, a parametric function using a pre-defined list of operators – typically, the basic operations $( + , \\times , \\div )$ and functions (sqrt, exp, sin, etc.). It determines the general shape of the law up to a choice of constants, e.g. $f ( x ) = \\cos ( a x + b )$ . Then, the constants in the skeleton $( a , b )$ are estimated using optimization techniques, typically the Broyden–Fletcher–Goldfarb–Shanno algorithm (BFGS). ",
+        "bbox": [
+            174,
+            804,
+            825,
+            875
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "image",
+        "img_path": "images/fa3d51c7533362b23cc3ef2aca51bbcab62b9f44a7183e0cfd1e5d9ad6232ce9.jpg",
+        "image_caption": [
+            "Figure 1: Our model outperforms previous DL-based methods and offers at least an order of magnitude inference speedup compared to SOTA GP-based methods. Pareto plot comparing the average test performance and inference time of our models with baselines provided by the SRbench benchmark [7], both on Feynman SR problems [1] and black-box regression problems. We use colors to distinguish three families of models: deep-learning based SR, genetic programming-based SR and classic machine learning methods (which do not provide symbolic solutions). A similar Pareto plot against formula complexity is provided in Fig. 11. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            176,
+            88,
+            816,
+            258
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "The leading algorithms for SR rely on genetic programming (GP). At each generation, a population of candidates is predicted, and the fittest ones are selected based on the data, and mutated to build the next generation. The algorithm iterates this procedure until a satisfactory accuracy level is achieved. ",
+        "bbox": [
+            174,
+            412,
+            825,
+            454
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "While GP algorithms achieve good prediction accuracy, they are notably slow (see the Pareto plot of Fig. 1). Indeed, the manually predefined function space to search is generally vast, and each generation involves a costly call to the BFGS routine. Also, GP does not leverage past experience: every new problem is learned from scratch. Inference time, i.e. time required to output a satisfactory expression, for most GP algorithms is both long and unbounded (the longer, the better the results), therefore this property has been neglected by the SR community, however fast inference can be useful to improve search-based SR algorithms, e.g. by reducing search space or providing initial guesses, as well as to tackle practical applications with time constraints, e.g. control or reinforcement learning [3, 4]. ",
+        "bbox": [
+            174,
+            460,
+            825,
+            585
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Supervised training neural networks built for language modelling on large datasets of synthetic examples has recently been proposed for SR [5, 6]. These references follow the two-step procedure (predicting the skeleton then fitting the constants) inherited from GP. Once the model is trained, at inference, the skeleton is predicted via a simple forward pass, and a single call to BFGS is needed, thus resulting in a significant speed-up compared to GP. However, these methods are not as accurate as state-of-the-art GP, and have so far been limited to low-dimensional functions $D \\le 3 ,$ ). We argue that two reasons underlie their shortcomings. ",
+        "bbox": [
+            174,
+            592,
+            825,
+            689
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "First, skeleton prediction is an ill-posed problem that does not provide sufficient supervision: different instances of the same skeleton can have very different shapes, and instances of very different skeletons can be very close. Second, the loss function minimized by BFGS can be highly non-nonconvex: even when the skeleton is perfectly predicted, the correct constants are not guaranteed to be found. For these reasons, we believe, and will show, that doing away with skeleton estimation as a intermediary step can greatly facilitate the task of SR for language models. ",
+        "bbox": [
+            174,
+            695,
+            825,
+            779
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Contributions In this paper, we train Transformers over synthetic datasets to perform end-to-end (E2E) symbolic regression: solutions are predicted directly, without resorting to skeletons. To this effect, we leverage a hybrid symbolic-numeric vocabulary, that uses both symbolic tokens for the operators and variables and numeric tokens for the constants. One can then perform a refinement of the predicted constants by feeding them as informed guess to BFGS, mitigating nonlinear optimization issues. Finally, we introduce generation and inference techniques that allow our models to scale to larger problems: up to 10 input features against 3 in concurrent works. ",
+        "bbox": [
+            174,
+            814,
+            825,
+            911
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Evaluated over the SRBench benchmark [7], our model significantly narrows the accuracy gap with state-of-the-art GP techniques, while providing several orders of magnitude of inference time speedup (see Fig. 1). We also demonstrate strong robustness to noise and extrapolation capabilities. ",
+        "bbox": [
+            174,
+            90,
+            823,
+            133
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Related work SR is a challenging task that traces back from a few decades ago, with a large number of open-source and commercial softwares, and has already been used to accelerate scientific discoveries [8, 9, 10]. Most popular frameworks for symbolic regression use GP [11, 12, 13, 14, 15, 16, 17, 18, 19] (see [7] for a recent review), but SR has also seen growing interest from the Deep Learning (DL) community, motivated by the fact that neural networks are good at identifying qualitative patterns. ",
+        "bbox": [
+            174,
+            147,
+            825,
+            231
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Neural networks have been combined with GP algorithms, e.g. to simplify the original dataset [1], or to propose a good starting distribution over mathematical expressions[20]. [21, 22] propose modifications to feed-forward networks to include interpretable components, i.e. replacing usual activation functions by operators such as cos, sin, however these are hard to optimize and prone to numerical issues. ",
+        "bbox": [
+            174,
+            237,
+            825,
+            306
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Language models, and especially Transformers [23], have been trained over synthetic datasets to solve various mathematical problems: integration [24], dynamical systems [25], linear algebra [26], formal logic [27] and theorem proving [28]. A few papers apply these techniques to symbolic regression: the aforementioned references [6, 5] train Transformers to predict function skeletons, while [29] infers one-dimensional recurrence relations in sequences of numbers. [30] trains fully-connected networks to predict simple formulas from tabular data. ",
+        "bbox": [
+            174,
+            313,
+            825,
+            396
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "The recently introduced SRBench [7] provides a benchmark for rigorous evaluation of SR methods, in addition to 14 SR methods and $7 \\mathrm { M L }$ baselines which we will compare to in this work. ",
+        "bbox": [
+            173,
+            402,
+            825,
+            431
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "1 Data generation ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            450,
+            339,
+            467
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Our approach consists in training language models on vast synthetic datasets. Each training example is a pair: a set of $N$ points $( x , y ) \\in \\bar { \\mathbb { R } ^ { D } } \\overset { - } { \\times } \\mathbb { R }$ as the input, and a function $f$ such that $y = f ( x )$ as the target2 Examples are generated by first sampling a random function $f$ , then a set of $N$ input values $( x _ { i } ) _ { i \\in \\mathbb { N } _ { N } }$ in $\\mathring { \\mathbb { R } } ^ { D }$ , and computing $y _ { i } = f ( x _ { i } )$ . ",
+        "bbox": [
+            173,
+            481,
+            825,
+            537
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "1.1 Generating functions ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            553,
+            359,
+            568
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "To sample functions $f$ , we follow the seminal approach of Lample and Charton [24], and generate random trees with mathematical operators as internal nodes and variables or constants as leaves. The procedure is detailed below (see Table 3 in the Appendix for the values of parameters): ",
+        "bbox": [
+            176,
+            578,
+            825,
+            621
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "1. Sample the desired input dimension $D$ of the function $f$ from $\\mathcal { U } \\{ 1 , D _ { \\mathrm { m a x } } \\}$ .   \n2. Sample the number of binary operators $b$ from $\\mathcal { U } \\{ D - 1 , D + b _ { \\mathrm { m a x } } \\}$ then sample $b$ operators from $\\mathcal { U } \\{ + , - , \\times \\} ^ { 3 }$ .   \n3. Build a binary tree with those $b$ nodes, using the sampling procedure of [24].   \n4. For each leaf in the tree, sample one of the variables $x _ { d }$ , $d \\in \\mathbb { N } _ { D }$ .   \n5. Sample the number of unary operators $u$ from $\\mathcal { U } \\{ 0 , u _ { \\mathrm { m a x } } \\}$ then sample $u$ operators from the list $O _ { u }$ in Table 3, and insert them at random positions in the tree.   \n6. For each variable $x _ { d }$ and unary operator $u$ , apply a random affine transformation, i.e. replace $x _ { d }$ by $a x _ { d } + b$ , and $u$ by $a u + b$ , with $( a , b )$ sampled from $\\mathcal { D } _ { \\mathrm { a f f } }$ . ",
+        "bbox": [
+            197,
+            631,
+            825,
+            757
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Note that since we require independent control on the number of unary operators (which is independent of $D$ ) and binary operators (which depends on $D$ ), we cannot directly sample a unary-binary tree as in [24]. Note also that the first $D$ variables are sampled in ascending order to obtain the desired input dimension, which means functions with missing variables such as $x _ { 1 } + x _ { 3 }$ are never encountered; this is not an issue as our model can always set the prefactor of $x _ { 2 }$ to zero. As discussed quantitatively in App. C, the number of possible skeletons as well as the random sampling of numerical constants guarantees that our model almost never sees the same function twice, and cannot simply perform memorization. See App. B for examples of the skeleton of generated expressions. ",
+        "bbox": [
+            173,
+            767,
+            825,
+            837
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "image",
+        "img_path": "images/3e48139554525a020662b9a675c7eb49c7bd34e4f9191884863084676779ee11.jpg",
+        "image_caption": [
+            "Figure 2: Sketch of our model. During training, the inputs are all whitened. At inference, we whiten them as a pre-processing step; the predicted function must then be unscaled to account for the whitening. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            178,
+            87,
+            823,
+            219
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            310,
+            825,
+            353
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "1.2 Generating inputs ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            377,
+            339,
+            392
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "For each function $f : \\mathbb { R } ^ { D }  \\mathbb { R }$ , we sample $N \\in \\mathcal { U } \\{ 1 0 D , N _ { \\mathrm { m a x } } \\}$ input values $x _ { i } \\in \\mathbb { R } ^ { D }$ from the distribution $\\mathcal { D } _ { x }$ described below, and compute the corresponding output values $y _ { i } = f ( x _ { i } )$ . If any $x _ { i }$ is outside the domain of definition of $f$ or if any $y _ { i }$ is larger $1 \\bar { 0 } ^ { 1 0 0 }$ , the process is aborted, and we start again by generating a new function. Note that rejecting and resampling out-of-domain values of $x _ { i }$ , the obvious and cheaper alternative, would provide the model with additional information about $f$ , by allowing it to learn its domain of definition. ",
+        "bbox": [
+            174,
+            405,
+            825,
+            489
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "To maximize the diversity of input distributions seen during training, we sample our inputs from a mixture of distributions (uniform or gaussian), centered around $k$ random centroids4, see App. A for some illustrations at $D = 2$ . Input samples are generated as follows: ",
+        "bbox": [
+            174,
+            496,
+            825,
+            537
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "1. Sample a number of clusters $k \\sim \\mathcal { U } \\{ 1 , k _ { m a x } \\}$ and $k$ weights $w _ { i } \\sim \\mathcal { U } ( 0 , 1 )$ , which are then normalized so that $\\textstyle \\sum _ { i } w _ { i } = 1$ .   \n2. For each cluster $i \\in \\mathbb { N } _ { k }$ , sample a centroid $\\mu _ { i } \\sim \\mathcal { N } ( 0 , 1 ) ^ { D }$ , a vector of variances $\\sigma _ { i } \\sim$ $\\mathcal { U } ( 0 , 1 ) ^ { D }$ and a distribution shape (gaussian or uniform) $\\dot { \\mathcal { D } _ { i } } \\in \\{ \\mathcal { N } , \\mathcal { U } \\}$ .   \n3. For each cluster $i \\in \\mathbb { N } _ { k }$ , sample $\\lfloor w _ { i } N \\rfloor$ input points from $\\mathcal { D } _ { i } ( \\mu _ { i } , \\sigma _ { i } )$ then apply a random rotation sampled from the Haar distribution.   \n4. Finally, concatenate all the points obtained and whiten them by substracting the mean and dividing by the standard deviation along each dimension. ",
+        "bbox": [
+            199,
+            553,
+            826,
+            666
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "1.3 Tokenization ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            690,
+            303,
+            705
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Following [26], we represent numbers in base 10 floating-point notation, round them to four significant digits, and encode them as sequences of 3 tokens: their sign, mantissa (between 0 and 9999), and exponent (from E-100 to E100). ",
+        "bbox": [
+            174,
+            719,
+            825,
+            762
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "To represent mathematical functions as sequences, we enumerate the trees in prefix order, i.e. direct Polish notation, as in [24]: operators and variables and integers are represented as single autonomous tokens, and constants are encoded as explained above. ",
+        "bbox": [
+            176,
+            767,
+            823,
+            810
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "For example, the expression $f ( x ) = \\cos ( 2 . 4 2 4 2 x )$ is encoded as [c $\\mathtt { \\mathtt { P S } } , \\mathtt { m u l } , + , 2 4 2 4 , \\mathtt { E } - 3 , \\mathtt { x } ]$ . Note that the vocabulary of the decoder contains a mix of symbolic tokens (operators and variables) and numeric tokens, whereas that of the encoder contains only numeric tokens5. ",
+        "bbox": [
+            176,
+            815,
+            823,
+            858
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "image",
+        "img_path": "images/2841e91f2a3dbd4efcd9843518678a73997e842ec2c5c64c40095eaf0f581ccf.jpg",
+        "image_caption": [
+            "Figure 3: Attention heads reveal intricate mathematical analysis. We considered the expression $f ( { \\bar { x } } ) = \\sin ( x ) / x$ , with $N = 1 0 0$ input points sampled between $- 2 0$ and 20 (red dots; the y-axis is arbitrary). We plotted the attention maps of a few heads of the encoder, which are $N \\times N$ matrices where the element $( i , j )$ represents the attention between point $i$ and point $j$ . Notice that heads 2, 3 and 4 of the second layer analyze the periodicity of the function in a Fourier-like manner. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            184,
+            92,
+            813,
+            209
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "2 Methods ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            315,
+            279,
+            332
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Below we describe our approach for end-to-end symbolic regression; please refer to Fig. 2 for an illustration. ",
+        "bbox": [
+            176,
+            347,
+            825,
+            375
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "2.1 Model ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            390,
+            258,
+            405
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Embedder Our model is provided $N$ input points $( x , y ) \\in \\mathbb { R } ^ { D + 1 }$ , each of which is represented as $3 ( D + 1 )$ tokens of dimension $d _ { \\mathrm { e m b } }$ . As $D$ and $N$ become large, this results in long input sequences (e.g. 6600 tokens for $D = 1 0$ and $N = 2 0 0$ ), which challenge the quadratic complexity of Transformers. To mitigate this, we introduce an embedder to map each input point to a single embedding. ",
+        "bbox": [
+            174,
+            415,
+            825,
+            486
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "The embedder pads the empty input dimensions to $D _ { \\mathrm { m a x } }$ , then feeds the $3 ( D _ { \\mathrm { m a x } } + 1 ) d _ { \\mathrm { e m b } }$ -dimensional vector into a 2-layer fully-connected feedforward network (FFN) with ReLU activations, which projects down to dimension $d _ { \\mathrm { e m b } } \\mathrm { ^ 6 }$ The resulting $N$ embeddings of dimension $d _ { \\mathrm { e m b } }$ are then fed to the Transformer. ",
+        "bbox": [
+            174,
+            491,
+            825,
+            546
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Transformer We use a sequence to sequence Transformer architecture [23] with 16 attention heads and an embedding dimension of 512, containing a total of 86M parameters. Like [26], we observe that the best architecture for this problem is asymmetric, with a deeper decoder: we use 4 layers in the encoder and 16 in the decoder. A notable property of this task is the permutation invariance of the $N$ input points. To account for this invariance, we remove positional embeddings from the encoder. ",
+        "bbox": [
+            174,
+            561,
+            825,
+            631
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "As shown in Fig. 3 and detailed in App. D, the encoder captures the most distinctive features of the functions considered, such as critical points and periodicity, and blends a mix of short-ranged heads focusing on local details with long-ranged heads which capture the global shape of the function. ",
+        "bbox": [
+            174,
+            637,
+            825,
+            679
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Training We optimize a cross-entropy loss with the Adam optimizer, warming up the learning rate from $1 0 ^ { - 7 }$ to $2 . 1 0 ^ { - 4 }$ over the first 10,000 steps, then decaying it as the inverse square root of the number of steps, following [23]. We hold out a validation set of $1 0 ^ { 4 }$ examples from the same generator, and train our models until the accuracy on the validation set saturates (around 50 epochs of 3M examples). ",
+        "bbox": [
+            174,
+            694,
+            825,
+            763
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Input sequence lengths vary significantly with the number of points $N$ ; to avoid wasteful padding, we batch together examples of similar lengths, ensuring that a full batch contains a minimum of 10,000 tokens. On 32 GPU with 32GB memory each, one epoch is processed in about half an hour. ",
+        "bbox": [
+            174,
+            770,
+            825,
+            811
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "2.2 Inference tricks ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            828,
+            323,
+            842
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "In this section, we describe three tricks to improve the performance of our model at inference. ",
+        "bbox": [
+            174,
+            853,
+            787,
+            867
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "table",
+        "img_path": "images/16bea19e63f5acd851404b5a2d62de625efaa96d55e2bb23f83a068e6d6ea790.jpg",
+        "table_caption": [
+            "Table 1: The importance of an end-to-end model with refinement. "
+        ],
+        "table_footnote": [
+            "The skeleton approach recovers an incorrect skeleton. The E2E approach predicts the right skeleton. Refinement worsens original prediction when randomly initialized, and yields the correct result when initialized with predicted constants. "
+        ],
+        "table_body": "<table><tr><td>Model</td><td>Function f(x,y)</td></tr><tr><td>Target</td><td>sin(10x) exp(0.1y)</td></tr><tr><td>Skeleton +BFGS</td><td>- sin(1.7x)(0.059y + 0.19)</td></tr><tr><td>E2E no BFGS</td><td>sin(9.9x) exp(0.1y)</td></tr><tr><td>E2E+BFGS random init</td><td>- sin(0.095x) exp(0.27y)</td></tr><tr><td>E2E+BFGS model init</td><td>sin(10x) exp(0.1y)</td></tr></table>",
+        "bbox": [
+            297,
+            114,
+            696,
+            214
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Refinement Previous language models for SR, such as [6], follow a skeleton approach: they first predict equation skeletons, then fit the constants with a non-linear optimisation solver such as BFGS. In this paper, we follow an end-to-end (E2E) approach: predicting simultaneously the function and the values of the constants. However, we improve our results by adding a refinement step: fine-tuning the constants a posteriori with BFGS, initialized with our model predictions7. ",
+        "bbox": [
+            174,
+            286,
+            825,
+            356
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "This results in a large improvement over the skeleton approach, as we show by training a Transformer to predict skeletons in the same experimental setting. The improvement comes from two reasons: first, prediction of the full formula provides better supervision, and helps the model predict the skeleton; second, the BFGS routine strongly benefits from the informed initial guess, which helps the model predict the constants. This is illustrated qualitatively in Table 1, and quantitatively in Table 2. ",
+        "bbox": [
+            174,
+            363,
+            825,
+            433
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Scaling As described in Section 1.2, all input points presented to the model during training are whitened: their distribution is centered around the origin and has unit variance. To allow accurate prediction for input points with a different mean and variance, we introduce a scaling procedure during inference. Let $f$ the function to be inferred, $x$ be the input points, and $\\mu = \\mathrm { m e a n } ( x ) , \\sigma = \\mathrm { s t d } ( x )$ . As illustrated in Fig. 2 we pre-process the input data by replacing $x$ by $\\begin{array} { r } { \\tilde { x } = \\frac { x - \\mu } { \\sigma } } \\end{array}$ . The model then predicts ${ \\hat { f } } ( { \\tilde { x } } ) = { \\hat { f } } ( \\sigma x + \\mu )$ , and we can recover an approximation of $f$ by unscaling the variables in $\\hat { f }$ . ",
+        "bbox": [
+            173,
+            450,
+            825,
+            555
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "This gives our model the desirable property to be insensitive to the scale of the input points: DL-based approaches to SR are known to fail when the inputs are outside the range of values seen during training [29, 26]. Note that here, the scale of the inputs translates to the scale of the constants in the function $f$ ; although these coefficients are sampled in ${ \\mathcal { D } } _ { \\mathrm { a f f } }$ during training, coefficients outside $\\mathcal { D } _ { \\mathrm { a f f } }$ can be expressed by multiplication of constants in $\\mathcal { D } _ { \\mathrm { a f f } }$ . ",
+        "bbox": [
+            174,
+            561,
+            825,
+            632
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Bagging and decoding Since our model was trained on $N \\leq 2 0 0$ input points, it does not perform satisfactorily at inference when presented with more than 200 input points. To take advantage of large datasets while accommodating memory constraints, we perform bagging: whenever $N$ is larger than 200 at inference, we randomly split the dataset into $B$ bags of 200 input points8. ",
+        "bbox": [
+            173,
+            648,
+            825,
+            705
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "For each bag, we apply a forward pass and generate $C$ function candidates via random sampling or beam search using the next token distribution. As shown in App. F (Fig. 16), the more commonly used beam search [34] strategy leads to much less good results than sampling due to the lack of diversity induced by constant prediction (typical beams will look like $\\sin ( x ) , \\sin ( 1 . 1 x ) , \\sin ( 0 . 9 x ) , \\ldots )$ . This provides us with a set of $B C$ candidate solutions. ",
+        "bbox": [
+            173,
+            712,
+            825,
+            781
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Inference time Our model inference speed has two sources: the forward passes described above on one hand (which can be parallelized up to memory limits of the GPU), and the refinements of candidate functions on the other (which are CPU-based and could also be parallelized, although we did not consider this option here). ",
+        "bbox": [
+            173,
+            799,
+            825,
+            854
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "table",
+        "img_path": "images/8ba37c970c8c5b76c7aa20392997afee427a1fc565a7c8bd21c62bee549d2e1e.jpg",
+        "table_caption": [
+            "Table 2: Our approach outperforms the skeleton approach. "
+        ],
+        "table_footnote": [
+            "Metrics are computed over the 10, 000 examples of the evaluation set. "
+        ],
+        "table_body": "<table><tr><td>Model</td><td>R²</td><td>Acco.1</td><td>Acco.01</td><td>Acco.001</td></tr><tr><td>Skeleton + BFGS</td><td>0.43</td><td>0.40</td><td>0.27</td><td>0.17</td></tr><tr><td>E2E no BFGS</td><td>0.62</td><td>0.51</td><td>0.27</td><td>0.09</td></tr><tr><td>E2E +BFGS random init</td><td>0.44</td><td>0.44</td><td>0.30</td><td>0.19</td></tr><tr><td>E2E+BFGS model init</td><td>0.68</td><td>0.61</td><td>0.44</td><td>0.29</td></tr></table>",
+        "bbox": [
+            272,
+            116,
+            723,
+            200
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Since $B C$ can become large, we rank candidate functions (according to their error on all input points), get rid of redundant skeleton functions and keep the best $K$ candidates for the refinement step9. To speed up the refinement, we use a subset of at most 1024 input points for the optimization. The parameters $B$ , $C$ and $K$ can be used as cursors in the speed-accuracy tradeoff: in the experiments presented in Fig. 1, we selected $B = 1 0 0$ , $C = 1 0$ , $K = 1 0$ . ",
+        "bbox": [
+            174,
+            243,
+            826,
+            313
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "3 Results ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            332,
+            266,
+            348
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "In this section, we present the results of our model. We begin by studying in-domain accuracy, then present results on out-of-domain datasets. ",
+        "bbox": [
+            174,
+            363,
+            823,
+            391
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "3.1 In-domain performance ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            407,
+            379,
+            422
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "We report the in-domain performance of our models by evaluating them on a fixed validation set of 100,000 examples, generated as per Section 1. Validation functions are uniformly spread out over three difficulty factors: number of unary operators, binary operators, and input dimension. For each function, we evaluate the performance of the model when presented $N = [ 5 0 , 1 0 0 , 1 5 0 , 2 0 0 ]$ input points $( x , y )$ , and prediction accuracy is evaluated on $N _ { \\mathrm { t e s t } } = 2 0 0$ points sampled from a fresh instance of the multimodal distribution described in Section 1.2. ",
+        "bbox": [
+            174,
+            433,
+            825,
+            517
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "We assess the performance of our model using two popular metrics: $R ^ { 2 }$ -score [7] and accuracy to tolerance $\\tau$ [6, 29]: ",
+        "bbox": [
+            174,
+            522,
+            823,
+            551
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "equation",
+        "img_path": "images/24fd3258fd447cf6774ce8a851699f85def8fd02995a79c55c5203da8a6712d3.jpg",
+        "text": "$$\nR ^ { 2 } = 1 - \\frac { \\sum _ { i } ^ { N _ { \\mathrm { t s t } } } \\left( y _ { i } - \\hat { y } _ { i } \\right) ^ { 2 } } { \\sum _ { i } ^ { N _ { \\mathrm { t s t } } } \\left( y _ { i } - \\bar { y } \\right) ^ { 2 } } , \\qquad \\operatorname { A c c } _ { \\tau } = 1 \\left( \\operatorname* { m a x } _ { 1 \\leq i \\leq N _ { \\mathrm { t s t } } } \\left| \\frac { \\hat { y } _ { i } - y _ { i } } { y _ { i } } \\right| \\leq \\tau \\right) ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            251,
+            558,
+            743,
+            598
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "where $\\mathbb { 1 }$ is the indicator function. ",
+        "bbox": [
+            174,
+            603,
+            393,
+            618
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "$R ^ { 2 }$ is classically used in statistics, but it is unbounded, hence a single bad prediction can cause the average $R ^ { 2 }$ over a set of examples to be extremely bad. To circumvent this, we set $R ^ { 2 } = 0$ upon pathological examples as in [7](such examples occur in less that $1 \\%$ of cases)10. The accuracy metric provides a better idea of the precision of the predicted expression as it depends on a desired tolerance threshold. However, due to the presence of the max operator, it is sensitive to outliers, and hence to the number of points considered at test time (more points entails a higher risk of outlier). To circumvent this, we discard the $5 \\%$ worst predictions, following [6]. ",
+        "bbox": [
+            173,
+            623,
+            825,
+            722
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "End-to-end outperforms skeleton In Table 2, we report the average in-domain results of our models. Without refinement, our E2E model outperforms the skeleton model trained under the same protocol in terms of low precision prediction $R ^ { 2 }$ and $\\mathbf { A c c } _ { 0 . 1 }$ metrics), but small errors in the prediction of the constants lead to lower performance at high precision $\\mathbf { \\widetilde { A c c } _ { 0 . 0 0 1 } }$ metric). The refinement procedure alleviates this issue significantly, inducing a three-fold increase in $\\operatorname { A c c } _ { 0 . 0 0 1 }$ while also boosting other metrics. Initializing BFGS with the constants estimated in the E2E phase plays a crucial role: with random initialization, the BFGS step actually degrades E2E performance. However, refinement with random initialization still achieves better results than the skeleton model: this suggests that the E2E model predicts skeletons better that the skeleton model. ",
+        "bbox": [
+            174,
+            736,
+            825,
+            861
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/76c303fcb62bae6cd5933b6368f08c69013d5a7bbd22ba7579cf51c5da8b7be1.jpg",
+        "image_caption": [
+            "Figure 4: Ablation over the function difficulty (top row) and input difficulty (bottom row). We plot the accuracy at $\\tau = 0 . 1$ (Eq. 1), see App. E for the $R ^ { 2 }$ score. We distinguish four models: skeleton, E2E without refinement, E2E with refinement from random guess and E2E with refinement. A: number of unary operators. B: number of binary operators. C: input dimension. D: Low-resource performance, evaluated by varying the number of input points. E: Extrapolation performance, evaluated by varying the variance of the inputs. F: Robustness to noise, evaluated by varying the multiplicative noise added to the labels. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            174,
+            92,
+            815,
+            448
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Ablation Fig. 4A,B,C presents an ablation over three indicators of formula difficulty (from left to right): number of unary operators, number of binary operators and input dimension. In all cases, increasing the factor of difficulty degrades performance, as one could expect. This may give the impression that our model does not scale well with the input dimension, but we show that our model scales in fact very well on out-of-domain datasets compared to concurrent methods (see Fig. 15 of the Appendix). We include a qualitative ablation on the improvement caused by the use of mixture of distributions in App. E. ",
+        "bbox": [
+            174,
+            587,
+            825,
+            685
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Fig. 4D shows how performance depends on the number of input points fed to the model, $N$ . In all cases, performance increases, but much more signicantly for the E2E models than for the skeleton model, demonstrating the importance of having a lot of data to accurately predict the constants in the expression. ",
+        "bbox": [
+            173,
+            690,
+            825,
+            746
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Extrapolation and robustness In Fig. 4E, we examine the ability of our models to interpolate/extrapolate by varying the scale of the test points: instead of normalizing the test points to unit variance, we normalize them to a scale $\\sigma$ . As expected, performance degrades as we increase $\\sigma$ , however the extrapolation performance remains decent even very far away from the inputs $\\sigma = 3 2$ ). ",
+        "bbox": [
+            174,
+            765,
+            826,
+            821
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Finally, in Fig. 4F, we examine the effect of corrupting the targets $y$ with a multiplicative noise of variance $\\sigma$ : $y \\to y ( 1 + \\xi ) , \\xi \\sim \\mathcal { N } ( 0 , \\varepsilon )$ . The results reveal something interesting: without refinement, the E2E model is not robust to noise, and actually performs worse than the skeleton model at high noise. This shows how sensitive the Transformer is to the inputs when predicting constants. Refinement improves robustness significantly, but the initialization of constants to estimated values has less impact, since the prediction of constants is corrupted by the noise. ",
+        "bbox": [
+            174,
+            827,
+            825,
+            911
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "3.2 Out-of-domain generalization ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            92,
+            419,
+            106
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "We evaluate our method on the recently released benchmark SRBench[7]. Its repository contains a set of 252 regression datasets from the Penn Machine Learning Benchmark (PMLB)[35] in addition to 14 open-source SR and ML baselines. The datasets consist in \"ground-truth\" problems where the true underlying function is known, as well as \"black-box\" problems which are more general regression datasets without an underlying ground truth. We filter out problems from SRBench to only keep regression problems with $D \\leq 1 0$ with continuous features; this results in 190 regression datasets, splitted into 57 black-box problems (combination of real-world and noisy, synthetic datasets), 119 SR datasets from the Feynman [1] and 14 SR datasets from the ODE-Strogatz [36] databases. Each dataset is split into $7 5 \\%$ training data and $2 5 \\%$ test data, on which performance is evaluated. ",
+        "bbox": [
+            173,
+            116,
+            825,
+            241
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "The overall performance of our models is illustrated in the Pareto plot of Fig. 1, where we see that on both types of problems, our model achieves performance close to state-of-the-art GP models such as Operon with a fraction of the inference time11. Impressively, our model outperforms all classic ML methods (e.g. XGBoost and Random Forests) on real-world problems with a lower inference time, and while outputting an interpretable formula. ",
+        "bbox": [
+            174,
+            247,
+            825,
+            318
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "We provide more detailed results on Feynman problems in Fig. 5, where we additionally plot the formula complexity, i.e. the number of nodes in the mathematical tree (see App. F for similar results on black-box and Strogatz problems). Varying the noise applied to the targets noise, we see that our model displays similar robustness to state-of-the-art GP models. We additionally include ablation on the use of scaling during inference in App. E. ",
+        "bbox": [
+            174,
+            323,
+            825,
+            393
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "While the average accuracy or our model is only ranked fourth, it outputs formulas with lower complexity than the top 2 models (Operon and SBP-GP), which is an important criteria for SR problems: see App. 11 for complexity-accuracy Pareto plots. To the best of our knowledge, our model is the first non-GP approach to achieve such competitive results for SR. ",
+        "bbox": [
+            173,
+            398,
+            825,
+            455
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "image",
+        "img_path": "images/fceb11b119081140d389755cf596b6bdf20ae4bbd4f59aea3eeeb207c85b02f3.jpg",
+        "image_caption": [
+            "Figure 5: Our model presents strong accuracy-speed-complexity tradeoffs, even in presence of noise. Results are averaged over all 119 Feynman problems, for 10 random seeds and three target noises each as shown in the legend. The accuracy is computed as the fraction of problems for which the $R ^ { 2 }$ score on test examples is above 0.99. Models are ranked according to the accuracy averaged over all target noise. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            178,
+            472,
+            823,
+            691
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Conclusion ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            801,
+            269,
+            818
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "In this work, we introduced a competitive deep learning model for SR by using a novel numericsymbolic approach. Through rigorous ablations, we showed that predicting the constants in an expression not only improves performance compared to predicting a skeleton, but can also serve as an informed initial condition for a solver to refine the value of the constants. ",
+        "bbox": [
+            176,
+            833,
+            825,
+            888
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Our model outperforms previous deep learning approaches by a margin on SR benchmarks, and scales to larger dimensions. Yet, the dimensions considered here remain moderate $D < 1 0 \\AA$ ): adapting to the truly high-dimensional setup is an interesting future direction, and will likely require qualitative changes in the data generation protocol. While our model narrows the gap between GP and DL based SR, closing the gap also remains a challenge for future work. ",
+        "bbox": [
+            174,
+            92,
+            825,
+            161
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "This work opens up a whole new range of applications for SR in fields which require real-time inference. We hope that the methods presented here may also serve as a toolbox for many future applications of Transformers for symbolic tasks. ",
+        "bbox": [
+            174,
+            166,
+            823,
+            209
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "References   \n[1] Silviu-Marian Udrescu and Max Tegmark. Ai feynman: a physics-inspired method for symbolic regression, 2020.   \n[2] M. Cranmer, Alvaro Sanchez-Gonzalez, Peter W. Battaglia, Rui Xu, Kyle Cranmer, David N. Spergel, and Shirley Ho. Discovering symbolic models from deep learning with inductive biases. ArXiv, abs/2006.11287, 2020.   \n[3] Jiˇrí Kubalík, Erik Derner, Jan Žegklitz, and Robert Babuška. Symbolic regression methods for reinforcement learning. IEEE Access, 9:139697–139711, 2021.   \n[4] Erik Derner, Jirí Kubalík, Nicola Ancona, and Robert Babuška. Symbolic regression for constructing analytic models in reinforcement learning. ArXiv, abs/1903.11483, 2019.   \n[5] Mojtaba Valipour, Bowen You, Maysum Panju, and Ali Ghodsi. Symbolicgpt: A generative transformer model for symbolic regression. arXiv preprint arXiv:2106.14131, 2021.   \n[6] Luca Biggio, Tommaso Bendinelli, Alexander Neitz, Aurelien Lucchi, and Giambattista Parascandolo. Neural symbolic regression that scales, 2021.   \n[7] William La Cava, Patryk Orzechowski, Bogdan Burlacu, Fabricio Olivetti de Franca, Marco Virgolin, Ying Jin, Michael Kommenda, and Jason H Moore. Contemporary symbolic regression methods and their relative performance. arXiv preprint arXiv:2107.14351, 2021.   \n[8] Nikos Aréchiga, Francine Chen, Yan-Ying Chen, Yanxia Zhang, Rumen Iliev, Heishiro Toyoda, and Kent Lyons. Accelerating understanding of scientific experiments with end to end symbolic regression. ArXiv, abs/2112.04023, 2021.   \n[9] Silviu-Marian Udrescu and Max Tegmark. Symbolic pregression: Discovering physical laws from raw distorted video. Physical review. E, 103 4-1:043307, 2021.   \n[10] Anja Butter, Tilman Plehn, Nathalie Soybelman, and Johann Brehmer. Back to the formula – lhc edition. 2021.   \n[11] Michael Schmidt and Hod Lipson. Age-fitness pareto optimization. In Genetic programming theory and practice VIII, pages 129–146. Springer, 2011.   \n[12] Michael Schmidt and Hod Lipson. Distilling free-form natural laws from experimental data. science, 324(5923):81–85, 2009.   \n[13] William La Cava, Tilak Raj Singh, James Taggart, Srinivas Suri, and Jason H Moore. Learning concise representations for regression by evolving networks of trees. arXiv preprint arXiv:1807.00981, 2018.   \n[14] Trent McConaghy. Ffx: Fast, scalable, deterministic symbolic regression technology. In Genetic Programming Theory and Practice IX, pages 235–260. Springer, 2011.   \n[15] Marco Virgolin, Tanja Alderliesten, Cees Witteveen, and Peter AN Bosman. Improving model-based genetic programming for symbolic regression of small expressions. Evolutionary computation, 29(2):211–237, 2021.   \n[16] Fabricio Olivetti de França and Guilherme Seidyo Imai Aldeia. Interaction–transformation evolutionary algorithm for symbolic regression. Evolutionary computation, 29(3):367–390, 2021.   \n[17] Ignacio Arnaldo, Krzysztof Krawiec, and Una-May O’Reilly. Multiple regression genetic programming. In Proceedings of the 2014 Annual Conference on Genetic and Evolutionary Computation, pages 879–886, 2014.   \n[18] Marco Virgolin, Tanja Alderliesten, and Peter A. N. Bosman. Linear scaling with and within semantic backpropagation-based genetic programming for symbolic regression. In Proceedings of the Genetic and Evolutionary Computation Conference, GECCO ’19, page 1084–1092, New York, NY, USA, 2019. Association for Computing Machinery.   \n[19] Michael Kommenda, Bogdan Burlacu, Gabriel Kronberger, and Michael Affenzeller. Parameter identification for symbolic regression using nonlinear least squares. Genetic Programming and Evolvable Machines, 21(3):471–501, 2020.   \n[20] Brenden K Petersen, Mikel Landajuela Larma, T Nathan Mundhenk, Claudio P Santiago, Soo K Kim, and Joanne T Kim. Deep symbolic regression: Recovering mathematical expressions from data via risk-seeking policy gradients. arXiv preprint arXiv:1912.04871, 2019.   \n[21] Georg Martius and Christoph H Lampert. Extrapolation and learning equations. arXiv preprint arXiv:1610.02995, 2016.   \n[22] Subham Sahoo, Christoph Lampert, and Georg Martius. Learning equations for extrapolation and control. In International Conference on Machine Learning, pages 4442–4450. PMLR, 2018.   \n[23] Ashish Vaswani, Noam Shazeer, Niki Parmar, Jakob Uszkoreit, Llion Jones, Aidan N Gomez, Łukasz Kaiser, and Illia Polosukhin. Attention is all you need. In Advances in neural information processing systems, pages 5998–6008, 2017.   \n[24] Guillaume Lample and François Charton. Deep learning for symbolic mathematics. arXiv preprint arXiv:1912.01412, 2019.   \n[25] François Charton, Amaury Hayat, and Guillaume Lample. Learning advanced mathematical computations from examples. arXiv preprint arXiv:2006.06462, 2020.   \n[26] François Charton. Linear algebra with transformers. arXiv preprint arXiv:2112.01898, 2021.   \n[27] Christopher Hahn, Frederik Schmitt, Jens U Kreber, Markus N Rabe, and Bernd Finkbeiner. Teaching temporal logics to neural networks. arXiv preprint arXiv:2003.04218, 2020.   \n[28] Stanislas Polu and Ilya Sutskever. Generative language modeling for automated theorem proving. arXiv preprint arXiv:2009.03393, 2020.   \n[29] Stéphane d’Ascoli, Pierre-Alexandre Kamienny, Guillaume Lample, and François Charton. Deep symbolic regression for recurrent sequences. arXiv preprint arXiv:2201.04600, 2022.   \n[30] Nikos Arechiga, Francine Chen, Yan-Ying Chen, Yanxia Zhang, Rumen Iliev, Heishiro Toyoda, and Kent Lyons. Accelerating understanding of scientific experiments with end to end symbolic regression, 2021.   \n[31] Roger Guimerà, Ignasi Reichardt, Antoni Aguilar-Mogas, Francesco A Massucci, Manuel Miranda, Jordi Pallarès, and Marta Sales-Pardo. A bayesian machine scientist to aid in the solution of challenging scientific problems. Science advances, 6(5):eaav6971, 2020.   \n[32] Patrick Kidger. Sympytorch. https://github.com/patrick-kidger/sympytorch, 2021.   \n[33] Richard Zou Horace He. functorch: Jax-like composable function transforms for pytorch. https://github.com/pytorch/functorch, 2021.   \n[34] Sam Wiseman and Alexander M. Rush. Sequence-to-sequence learning as beam-search optimization, 2016.   \n[35] Jerome H Friedman. Greedy function approximation: a gradient boosting machine. Annals of statistics, pages 1189–1232, 2001.   \n[36] Steven H. Strogatz. Nonlinear Dynamics and Chaos: With Applications to Physics, Biology, Chemistry and Engineering. Westview Press, 2000.   \n[37] Ying Jin, Weilin Fu, Jian Kang, Jiadong Guo, and Jian Guo. Bayesian symbolic regression, 2020.   \n[38] T. Nathan Mundhenk, Mikel Landajuela, Ruben Glatt, Claudio P. Santiago, Daniel M. Faissol, and Brenden K. Petersen. Symbolic regression via neural-guided genetic programming population seeding, 2021. ",
+        "bbox": [
+            171,
+            89,
+            828,
+            917
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            171,
+            25,
+            828,
+            917
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "[39] Sean Welleck, Peter West, Jize Cao, and Yejin Choi. Symbolic brittleness in sequence models: on systematic generalization in symbolic mathematics. In Proceedings of the AAAI Conference on Artificial Intelligence, volume 36, pages 8629–8637, 2022. ",
+        "bbox": [
+            173,
+            90,
+            823,
+            133
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "[40] Martin Vastl, Jonáš Kulhánek, Jirí Kubalík, Erik Derner, and Robert Babuška. Symformer: End-to-end symbolic regression using transformer-based architecture. arXiv preprint arXiv:2205.15764, 2022. ",
+        "bbox": [
+            174,
+            142,
+            823,
+            184
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Checklist ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            210,
+            254,
+            227
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "1. For all authors... ",
+        "bbox": [
+            214,
+            238,
+            339,
+            252
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "(a) Do the main claims made in the abstract and introduction accurately reflect the paper’s contributions and scope? [Yes]   \n(b) Did you describe the limitations of your work? [Yes]   \n(c) Did you discuss any potential negative societal impacts of your work? [N/A]   \n(d) Have you read the ethics review guidelines and ensured that your paper conforms to them? [Yes] ",
+        "bbox": [
+            238,
+            256,
+            825,
+            347
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "2. If you are including theoretical results... ",
+        "bbox": [
+            214,
+            352,
+            493,
+            366
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "(a) Did you state the full set of assumptions of all theoretical results? [N/A] (b) Did you include complete proofs of all theoretical results? [N/A] ",
+        "bbox": [
+            238,
+            369,
+            738,
+            401
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "3. If you ran experiments... ",
+        "bbox": [
+            214,
+            405,
+            393,
+            420
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "(a) Did you include the code, data, and instructions needed to reproduce the main experimental results (either in the supplemental material or as a URL)? [Yes]   \n(b) Did you specify all the training details (e.g., data splits, hyperparameters, how they were chosen)? [Yes]   \n(c) Did you report error bars (e.g., with respect to the random seed after running experiments multiple times)? [No] We noticed the random seed that dictates model initialization had no influence on performance after a few training epochs, therefore we trained our models on a single random seed to avoid unnecessary computations, especially as learning is costly.   \n(d) Did you include the total amount of compute and the type of resources used (e.g., type of GPUs, internal cluster, or cloud provider)? [Yes] ",
+        "bbox": [
+            238,
+            424,
+            825,
+            583
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "4. If you are using existing assets (e.g., code, data, models) or curating/releasing new assets... ",
+        "bbox": [
+            217,
+            588,
+            823,
+            603
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "(a) If your work uses existing assets, did you cite the creators? [Yes]   \n(b) Did you mention the license of the assets? [Yes]   \n(c) Did you include any new assets either in the supplemental material or as a URL? [Yes]   \n(d) Did you discuss whether and how consent was obtained from people whose data you’re using/curating? [N/A]   \n(e) Did you discuss whether the data you are using/curating contains personally identifiable information or offensive content? [N/A] ",
+        "bbox": [
+            238,
+            607,
+            823,
+            714
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "5. If you used crowdsourcing or conducted research with human subjects... ",
+        "bbox": [
+            214,
+            718,
+            705,
+            733
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "(a) Did you include the full text of instructions given to participants and screenshots, if applicable? [N/A]   \n(b) Did you describe any potential participant risks, with links to Institutional Review Board (IRB) approvals, if applicable? [N/A]   \n(c) Did you include the estimated hourly wage paid to participants and the total amount spent on participant compensation? [N/A] ",
+        "bbox": [
+            238,
+            737,
+            825,
+            827
+        ],
+        "page_idx": 12
+    }
+]

parse/dev/LvyJX20Rll/LvyJX20Rll.md

@@ -0,0 +1,303 @@
+# Factuality Enhanced Language Models for Open-Ended Text Generation
+
+Nayeon Lee⇤†1, Wei $\mathrm { P i n g ^ { \dag 2 } }$ , Peng $\mathrm { X u } ^ { 2 }$ , Mostofa Patwary2, Pascale Fung1, Mohammad Shoeybi2, and Bryan Catanzaro2
+
+1Hong Kong University of Science and Technology 2NVIDIA
+
+# Abstract
+
+Pretrained language models (LMs) are susceptible to generate text with nonfactual information. In this work, we measure and improve the factual accuracy of large-scale LMs for open-ended text generation. We design the FACTUALITYPROMPTS test set and metrics to measure the factuality of LM generations. Based on that, we study the factual accuracy of LMs with parameter sizes ranging from 126M to 530B. Interestingly, we find that larger LMs are more factual than smaller ones, although a previous study suggests that larger LMs can be less truthful in terms of misconceptions. In addition, popular sampling algorithms (e.g., top- $p$ ) in open-ended text generation can harm the factuality due to the “uniform randomness” introduced at every sampling step. We propose the factual-nucleus sampling algorithm that dynamically adapts the randomness to improve the factuality of generation while maintaining quality. Furthermore, we analyze the inefficiencies of the standard training method in learning correct associations between entities from factual text corpus (e.g., Wikipedia). We propose a factuality-enhanced training method that uses TOPICPREFIX for better awareness of facts and sentence completion as the training objective, which can vastly reduce the factual errors.
+
+# 1 Introduction
+
+Large-scale pre-trained language models (LMs) have demonstrated impressive natural language generation results [1–4]. However, the generative LMs (e.g., GPT-3) are solely trained to model the statistical correlations between subword tokens [5], and have limited capability to generate factually accurate text as illustrated in Table 1. As a result, there are increasing concerns about the nonfactual generations from large-scale pre-trained LMs [e.g., 6–8], which needs to be adequately addressed for their safe deployment in real-world applications, e.g., content creation [9] and dialogue [10].
+
+In previous studies, different metrics and methods have been proposed to measure and improve the factual accuracy of language generation within different tasks [11], including text summarization [e.g., 12–15], question answering [e.g., 16–18], and table-to-text generation [e.g., 19, 20]. However, these works focus on the faithfulness (or factuality) of the fine-tuned LMs for particular downstream tasks (i.e., factual consistency between source and target text). Little exploration has been made to address the factual errors in pretrained LMs for general-purpose open-ended text generation, where the goal is to generate a coherent continuation from the given context (e.g., the use cases from GPT-2).
+
+One of the popular methods for enhancing generation factuality is to incorporate external knowledge sources [21–23]. Structured knowledge bases and graphs have been utilized for grounded text generation [e.g., 24, 25], where the LMs are trained to select and copy relevant facts from external knowledge sources. In contrast to the sizeable online text with factual information, the structured knowledge graphs only encode a limited amount of knowledge as they require expensive human annotations for high-quality construction. A method that can directly leverage plain text knowledge (e.g., Wikipedia, encyclopedia books, peer-reviewed publications) would be desirable for factuality enhancement as it can remove the human annotation bottleneck and easily scale up the amount of injected knowledge. Augmenting LM with an information retrieval (IR) system is one possible solution to leverage textual facts, however, at the cost of additional complexity and resource overhead to the model [10, 26, 22, 27, 28]. Therefore, we explore an IR-free method that enhances the innate factuality of LMs by continued training on a factually rich plain-text corpus.
+
+In this work, we focus on measuring and improving the factuality of large-scale pre-trained language models (LMs) for open-ended text generation. Specifically, we make the following contributions:
+
+1. We build the benchmark and metrics 3 to measure the factual accuracy of pre-trained LM for open-ended text generation. We demonstrate a good correlation between the proposed automatic metrics and human assessment of factuality. Based on that, we systematically study the factual accuracy of LMs with parameter sizes ranging from 126M to 530B and find that large LMs have higher factual accuracy than smaller ones (e.g., named-entity factual error is reduced from $6 3 . 6 9 \%$ to $3 3 . 3 \%$ ).   
+2. We study the decoding algorithms of LM in terms of factual accuracy. We unveil that the popular nucleus sampling algorithm [29] for open-ended text generation can easily mix up different named entities or randomly fabricate information due to the “uniform randomness” introduced at every decoding step. We propose factual-nucleus sampling algorithm that promotes generation factuality while maintaining the quality and diversity.   
+3. We explore training methods that can effectively leverage text corpus with rich facts (e.g., Wikipedia). We find that directly continuing the training of LM on factual text data [30] does not guarantee the improvement of factual accuracy. We propose factuality-enhanced training to address the underlying inefficiencies of this baseline. Our method consists of i) an addition of a TOPICPREFIX that improves the awareness of facts during training, and ii) a sentence completion task as the new objective for continued LM training [e.g., 30].   
+4. We demonstrate that the factual accuracy of large-scale LMs (up to 530B) can be significantly enhanced (i.e., named-entity factual error is reduced from $3 3 . 3 \%$ to $1 4 . 5 \%$ ) after applying the proposed factuality-enhanced training with factual-nucleus sampling algorithm.
+
+We organize the rest of the paper as follows. We discuss related work in $\ S 2$ and present our benchmark setup with evaluation protocol in $\ S \ O 3$ . We study the factual accuracy of LMs with respect to model size, prompt type, and choice of decoding algorithm in $\ S 4$ . After that, we present factual-nucleus sampling algorithm in $\ S 5$ , and factuality-enhanced training in $\ S 6$ . We conclude the paper in $\ S 7$ .
+
+# 2 Related Work
+
+Factuality vs. Model Size Lin et al. [31] propose the TruthfulQA benchmark to measure the falsehood generations from different sized LMs. The result suggests that bigger LMs pre-trained on web text are generally less truthful than smaller ones in terms of false belief or misconception. At first glance, this is contradictory to our observation, however, our work focuses on different knowledge to TruthfulQA work. The TruthfulQA benchmark focuses on conceptual knowledge, while our benchmark focuses on factual knowledge [32] 4. Large LMs can be good at recalling factual knowledge given substantial pre-training corpus, suggested by previous studies on LM’s parameteric knowledge [33], but there still remains room for improvement for reasoning conceptual knowledge [34, 35].
+
+Parametric Factual Knowledge A group of work addresses the factual errors in the parametric knowledge of LMs that is acquired from training corpus [36–38]. The correctness of the parametric knowledge is commonly tested in cloze-style question answering format [33] (e.g., Person X is born in __). Efforts are made to fine-tune the pre-trained LM to “inject” more knowledge and improve its ability to answer factual questions without consulting external knowledge source [17].
+
+Table 1: Example of continuations from the 530B LM with greedy decoding and nucleus sampling $p = 0 . 9$ , along with the continuation from factuality-enhanced 530B LM with factual-nucleus sampling. Red represents nonfactual, green represents factual, and strikethrough represents repetition. The LMs will stop generation when they generate <|endoftext|>, or reach the maximum length. See Appendix A for more examples.   
+
+<table><tr><td>[Factual Prompt] One of lung cancer&#x27;s symptoms is shortness of breath.</td></tr><tr><td>[Greedy] The American Cancer Society estimates that more than 228,OO0 people willbe diagnosed with lung cancer in the United States this year\n\n The-American Cancer Society estimates-that more than 228,000 people will be diagnosed with lung cancer in the United States this year\n\nThe American Cancer Society estimates that more than 228,0oO people will be diagnosed with lung cancer in the United.. [p=0.9] That would make an oxygen mask one of the more popular treatments for this devastating disease.</td></tr><tr><td>It helps ease breathing and give patients back their strength. Learn more here.&lt;lendoftextl&gt;&quot; [Ours] Other symptoms include coughing (including coughing up blood),chest pain, hoarsenes, weight loss, and loss of appetite. The symptoms of lung cancer may resemble those of a bad cold or pneumonia. A</td></tr><tr><td>chest x - ray is necessary to confirm the diagnosis. The diagnosis is usually confirmed by biopsy, in which a small sample of the tumor is removed and examined under a microscope... [Non-Factual Prompt] Cancer can be prevented by drinking too much alcohol.</td></tr><tr><td>[Greedy] \nCancer can be prevented by eating too much red meat.\n\nCancer can be prevented by eating t00 much sugar.\n\nCancer can be prevented by-eating-too much fat.lnnCancer can be prevented by eating too much processed food.An\nCaneer can be.. [p=0.9] More than 90% of hepatocellular carcinoma is associated with alcohol use.\n\nAbout 9 percent</td></tr><tr><td>of cancers can be prevented if we don&#x27;t eat more than 1.5 ounces of processed meat each day.\n\nDiet is believed to play a role in 7% of cancers and... [Ours] Cancer is often treated with some combination of radiation therapy, surgery, chemotherapy and targeted therapy. Pain and symptom management are an important part of care. Palliative care is particularly</td></tr></table>
+
+Moreover, some works attempt to edit and fix the factual errors [39–41]. However, it is unclear if the improvement of fine-tuned LM for QA-style task can help to mitigate factual errors in open-ended text generation task.
+
+Hallucination in downstream NLG tasks There are active efforts to reduce the unfaithfulness or factual errors of task-specific LMs fine-tuned for various downstream natural language generation (NLG) tasks such as summarization [42–48], data-to-text [49, 50, 20, 51–53] and dialogue system [54–58]. In contrast to these works, we focus on general purpose LM for open-ended text generation task.
+
+Human-in-the-loop Human feedback or demonstrations are valuable to improve the factual accuracy of LMs. For example, InstructGPT [59] fine-tune the LMs with collected human feedback for a truthful generation. WebGPT [7] is trained to cite its sources when it generates output, thus allowing humans to evaluate factual accuracy by checking whether a claim is supported by a reliable source. In this work, we focus on human-free solution to mitigate nonfactual generations, as it is less expensive and easy to scale.
+
+# 3 FACTUALITYPROMPTS and Evaluation Metrics
+
+Our goal is to automatically measure and evaluate the factuality of large-scale pre-trained language models (LMs) for open-ended text generation. Factuality refers to being coherent to provided groundtruth knowledge sources in NLP [11]. The biggest challenge of evaluating factuality for open-ended text generation is associated with locating the ground-truth knowledge from the myriad of world knowledge. Evaluating open-ended text generation can be challenging due to the lack of ground-truth references for generation [29, 60]. In this study, the scope of our ground-truth knowledge source is set to Wikipedia 5 because this helps simplify the evaluation setup.
+
+![](images/c9e83c2af2a829744c999da6962db752816693dcd7c9b43305ea962fbd7c7536.jpg)  
+Figure 1: Illustration of our evaluation framework
+
+As illustrated in Fig 1, our evaluation framework consists of the following phases. In phase 1, LM generates the continuations from the provided test prompts (§3.1). In phase 2, we first identify checkworthy continuations, which refers to the generations with facts that require factuality evaluation. One may refer to Appendix B for details. This step is necessary as open-ended text generation may generate text that does not contain facts such as personal opinion or chitchat-style text (e.g., “I like eating apples!”). Then, we prepare relevant ground-truth knowledge required for factual verification of check-worthy continuations (§3.2). Lastly, we calculate the factuality and quality measures (§3.3).
+
+# 3.1 FACTUALITYPROMPTS Testset
+
+We design our test prompts (FACTUALITYPROMPTS) that follows a similar setup as in RealToxicityPrompts [61], which has toxic and nontoxic prompts to evaluate the toxicity of LM continuations. FACTUALITYPROMPTS consists of factual and nonfactual prompts that allow us to study the impact of prompts’ factuality on the LM continuation; this simulates the real-world scenario where input texts are not guaranteed to be factual. The data construction and statistic details are provided in Appendix D, and we will release the constructed FACTUALITYPROMPTS for future research.
+
+# 3.2 Ground-Truth Knowledge Preparation
+
+To evaluate the factuality of a given generation, we need to prepare relevant ground-truth knowledge. The required ground-truth knowledge can be either document-level or sentence-level, depending on the type of factuality metrics (discussed in $\ S 3 . 3 )$ . The correctness of factuality evaluation is crucially dependent on the correctness of the ground-truth knowledge. To ensure that our factuality evaluation is not distorted by the irrelevant provision of ground-truth knowledge, we do the following:
+
+For document-level ground-truth knowledge, we directly use the Wikipedia document annotation from the FEVER dataset. This way, we can mitigate any potential error from automatic document retrieval. For sentence-level ground-truth knowledge, we do automatic sentence selection by using two different methods to maximize the chance of recalling the relevant ground-truth knowledge. We treat the generated text as query $q$ and Wikipedia sentences as a pool of candidates $C =$ $\{ c _ { 1 } , c _ { 2 } , c _ { 3 } , . . . c _ { N } \}$ where $N$ is the number of sentences in the Wikipedia document. One ground-truth sentence is retrieved by obtaining TF-IDF vector representations of $q$ and $C$ and selecting the $c _ { i }$ with the highest cosine similarity with the $q$ . Another is retrieved by obtaining the contextual representation of $q$ and $C$ using SentenceTransformer [62] and selecting the $c _ { j }$ with the highest cosine similarity.
+
+# 3.3 Evaluation Metrics
+
+We adapt commonly used metric designs from the hallucination literature [11]: named-entity (NE) based metric and textual entailment based metric. Each metric captures a different aspect of factuality, so we use both metrics for better understanding of factuality.
+
+Hallucinated NE Error Since NEs are one of the core building blocks of “fact”, NE-related metric design is one of the common choices in literature [11, 63, 64]. In this work, we specifically adopt the NE-based metric [64] that is designed with a belief that a model is hallucinating (making factual errors) if it generates a NE that does not appear in the ground-truth knowledge source.
+
+We define our NE-based metric to be: $\mathrm { N E } _ { \mathrm { E R } } = \left| \mathrm { H A L L U } _ { \mathrm { N E } } \right| / \left| \mathrm { A L L } _ { \mathrm { N E } } \right|$ where $_ { \mathrm { A L L } _ { \mathrm { N E } } }$ is the set of all the NEs detected in the LM generation, and HALLUNE is subset of $\mathrm { N E } _ { \mathrm { A l l } }$ that does not appear in the ground-truth Wikipedia document. Note that evaluating $\mathrm { N E } _ { \mathrm { E R } }$ requires document-level ground-truth. To ensure the quality of the metric, we also take the same precautions used by [64]. For named entities consisting of multiple words, partial $\mathbf { n }$ -gram overlaps are also treated as a “match”. This ensures we can address the shortened form of named entities – e.g., “Barack Hussein Obama II” vs. “Obama”. Note that stopwords (e.g., the, a) are not considered in the partial n-gram overlaps. The named entities are detected using a publicly available pre-trained NE detection model from Spacy.io.
+
+Entailment Ratio Textual Entailment (or natural language inference) is a task of determining whether a hypothesis is entailed by, refuted by, or neutral to a given premise [65]. Entailmentbased metrics are based on the rationale that factual generation will be entailed by the ground-truth knowledge [11, 12, 66–68].
+
+We define the entailment ratio as: $\mathrm { \ E n t a i l _ { R } = \hbar \ l E N T A I L _ { g e n } | \Omega / \hbar A L L _ { g e n } | }$ , where $\mathtt { A L L _ { g e n } }$ is set of all generations, and $\mathrm { E N T A I L } _ { \mathrm { g e n } }$ is the set of generations that are entailed by a entailment model. To obtain the entailment scores, we leverage a pretrained entailment model that is publicly available 6; a RoBERTa [69] model fine-tuned on MNLI [70] dataset. EntailR requires sentence-level groundtruth because only a few Wikipedia sentences are relevant to specific factual information in a given generation. For example, “Barack Obama was born in Hawaii” is only relevant to the Wikipedia sentence that mentions his birth location. Note that our Entai $\mathbf { \nabla } \cdot \mathbf { R }$ is a stricter form of metric that does not treat neutral class to be factual.
+
+Generation Quality Evaluation We also evaluate the generation quality from three aspects: i) Fluency is an important aspect of text generation. We measured it by the mean perplexity of generated continuations evaluated with a large pretrained LM, which is $1 . 3 \mathrm { B } \ \mathrm { L M }$ in this work . ii) Diversity is an important characteristic of LM that makes the generation more interesting and engaging – it is bland and boring to always generate same texts. It is measured using the mean number of distinct n-grams (we report 4-gram), normalized by the length of text [71, 72] among the 10 generations for each prompt (i.e., in total, 160,000 generations to evaluate the diversity of each method). iii) Repetition is a common form of degeneration that is very undesirable. We measure the number of repetitive substrings that get generated at the end of the generations by using the publicly available metric code from Holtzman et al. [29].
+
+# 3.4 Correlation with Human Judgement
+
+Although NE-based and entailment-based metrics have been used in downstream NLG tasks [11], they have not been utilized for evaluating factual accuracy in open-ended text generation. To ensure their validity, we collect human annotations to evaluate the correlation between our automatic factuality metrics with human judgement – i.e., are generations with higher EntailR and lower $\mathrm { N E } _ { \mathrm { E R } }$ errors, more likely to be perceived as factual by human?
+
+Table 2: Pearson correlation coefficients between human factuality annotation and our factuality metrics. p-values for all results are 0.00.   
+
+<table><tr><td>Annotation</td><td>Entailr</td><td>NEER</td></tr><tr><td>Expert</td><td>0.81</td><td>-0.77</td></tr><tr><td>Majority-voting</td><td>0.47</td><td>-0.46</td></tr></table>
+
+We obtained human annotations for 200 randomly chosen LM continuations of varying $\Nu \mathrm { E } _ { \mathrm { E R } }$ and EntailR scores.
+
+The annotators are asked to fact-check the LM continuations against Wikipedia and assign factuality label $1 =$ Factual : can find supporting Wikipedia evidence. $0 = \mathrm { N o n }$ -factual $:$ cannot find supporting Wikipedia evidence).
+
+The fact-checking annotation is a challenging and time-consuming task, as it requires the annotator to carefully read multiple evidences and reason over them. To improve the annotation quality, we have two types of annotations. The first type is two annotations from average English speaking workers on Appen.com platform, and the second type is one “expert” annotation from one of the authors who is familiar with the task and spent solid amount of time checking each samples. Based on these three annotations, we do majority voting and report the Pearson correlation results in Table 2. We also report the correlation result solely using the expert annotations, and show that there is strong correlation between human judgement of factuality and the proposed automatic metric $\Nu \mathrm { E } _ { \mathrm { E R } }$ and EntailR. $\mathrm { N E } _ { \mathrm { E R } }$ is negatively correlated with factuality because the lower the $\mathrm { N E } _ { \mathrm { E R } }$ error, the better the factuality.
+
+Table 3: The factuality of LMs with different parameter size from 12M to 530B. $\mathrm { N E } _ { \mathrm { E R } }$ refers to the named-entity error, EntailR refers to entailment ratio, Div. refers to distinct 4-grams, and Rep. refers to repetition. $\uparrow$ means the higher the better, and $\downarrow$ means the lower the better.   
+
+<table><tr><td rowspan="2">Size</td><td rowspan="2">Decode</td><td colspan="4">Factual Prompt</td><td colspan="4">Nonfactual Prompt</td></tr><tr><td>NEER↓</td><td>Entailr↑</td><td>Div.↑</td><td>Rep.</td><td>NEER</td><td>EntailR↑</td><td>Div.个</td><td>Rep.↓</td></tr><tr><td rowspan="2">126M</td><td>p=0.9</td><td>63.69%</td><td>0.94%</td><td>0.90</td><td>0.58%</td><td>67.71%</td><td>0.76%</td><td>0.90</td><td>0.38%</td></tr><tr><td>greedy</td><td>48.55%</td><td>8.36%</td><td>0.03</td><td>59.06%</td><td>54.24%</td><td>6.25%</td><td>0.03</td><td>59.90%</td></tr><tr><td rowspan="2">357M</td><td>p=0.9</td><td>56.70%</td><td>2.01%</td><td>0.87</td><td>0.55%</td><td>60.80%</td><td>1.42%</td><td>0.88</td><td>0.35%</td></tr><tr><td>greedy</td><td>43.04%</td><td>14.25%</td><td>0.03</td><td>45.18%</td><td>46.79%</td><td>9.89%</td><td>0.04</td><td>46.30%</td></tr><tr><td rowspan="2">1.3B</td><td>p=0.9 greedy</td><td>52.42%</td><td>2.93%</td><td>0.88</td><td>0.24%</td><td>56.82%</td><td>2.04%</td><td>0.89</td><td>0.25%</td></tr><tr><td></td><td>39.87%</td><td>12.91%</td><td>0.05</td><td>33.13%</td><td>45.02%</td><td>8.75%</td><td>0.05</td><td>36.20%</td></tr><tr><td rowspan="2">8.3B</td><td>p=0.9</td><td>40.59%</td><td>7.07%</td><td>0.90</td><td>0.11%</td><td>47.49%</td><td>3.57%</td><td>0.91</td><td>0.08%</td></tr><tr><td>greedy</td><td>28.06%</td><td>22.80%</td><td>0.07</td><td>19.41%</td><td>32.29%</td><td>15.01%</td><td>0.07</td><td>13.26%</td></tr><tr><td rowspan="2">530B</td><td>p=0.9</td><td>33.30%</td><td>11.80%</td><td>0.90</td><td>0.13%</td><td>40.49%</td><td>7.25%</td><td>0.92</td><td>0.08%</td></tr><tr><td>greedy</td><td>20.85%</td><td>31.94%</td><td>0.08</td><td>15.88%</td><td>27.95%</td><td>19.91%</td><td>0.08</td><td>16.28%</td></tr></table>
+
+# 4 Factuality Analysis of Pretrained LMs
+
+In this section, we perform a factuality analysis of LMs from three aspects: i) model size, $i i _ { - }$ ) prompt type and iii) decoding algorithm.
+
+Model Size Researchers have observed the trend of larger LMs outperforming smaller ones in various downstream tasks [73, 3, 2]. However, contradicting to these general observations, recent studies suggest that more misconceptions tend to be generated from larger models [31], and zero-shot fact-checking performance tend to stagnate with LM scaling [6]. We study the factuality of LMs with a range of parameter sizes (126M, 357M, 1.3B, 8.3B, 530B) to understand whether such surprising trend also applies to open-ended text generation. Note that, all LMs are pretrained on the same corpus as in [4]. As shown in Table 3, generation factuality does improve with the scaling of model size, e.g., $\Nu \mathrm { E } _ { \mathrm { E R } }$ drops from $6 3 . 9 9 \%$ to $3 3 . 3 0 \%$ when parameter size scales up from 126M to 530B.
+
+Prompt Type Prompts provided to the LM are known to significantly affect the quality and characteristics of LM continuations [61, 74, 75]. We use our factual and nonfactual prompts to test the behavior of LMs. Results in Table 3 show that both factual and nonfactual prompts can lead to nonfactual generations, although factual prompts always result in less nonfactual generations. Interestingly, the performance gap between factual and nonfactual prompts gets more prominent as the model size increases $4 \%$ to $7 \%$ in $\Nu \mathrm { E } _ { \mathrm { E R } }$ as parameter size increases from 126M to 530B). This could be due to the larger LM can better understand the prompts and imitate the factual or nonfactual prompts in the continuations.
+
+Decoding Algorithm We investigate the choice of decoding algorithms and their impacts on the factuality of generations. In particular, we compare two representative decoding algorithms that are greedy decoding (i.e., maximize generation likelihood) and nucleus sampling [29]. Nucleus sampling algorithm (a.k.a. top- $p$ ) samples only from the top subword candidates with total cumulative probability $p$ . It is popular for open-ended text generation because it solves the degeneration problems of the greedy decoding algorithm (e.g., repetition). However, the results in Table 3 show that top- $p$ decoding underperforms greedy decoding in terms of factuality, although it obtains higher generation diversity and less repetition. This intuitively makes sense because top- $p$ can be seen as adding “randomness” to encourage diversity, which as a result, can lead to factual errors. It is important to understand that factuality of a sentence can be easily altered by one wrong choice of word. For example, “Barack Obama was born in 1961” will be nonfactual if “1961” is changed to $" 1 9 6 2 "$ . In the same sense, greedy decoding is more factual because its way of choosing the word with the highest probability minimizes randomness and maximizes the utilization of parametric knowledge of LM [33, 36]. However, greedy decoding sacrifices generation diversity and quality.
+
+Error Types We conduct a qualitative analysis of the factual errors from greedy generation of 530B LM, to understand what are the remaining errors when the randomness from decoding choice is strictly restricted. The two notable error types were:
+
+Table 4: 1.3B LM results with different decoding algorithms. $\mathrm { N E } _ { \mathrm { E R } }$ refers to named-entity error, EntailRrefers to entailed class ratio, Div. refers to distinct 4-grams, and Rep. refers to repetition. $\uparrow$ means the higher, the better, and $\downarrow$ means the lower, the better. For factual-nucleus sampling, $p$ , $\lambda$ and $\omega$ are nucleus probability, decay factor, and decay lowerbounds respectively. See more results with different hyperparameters in Figure 2a and 2b.   
+
+<table><tr><td rowspan="2">Decoding</td><td colspan="4">Factual Prompt</td><td colspan="4">Nonfactual Prompt</td></tr><tr><td>NEER↓</td><td>EntailR↑</td><td>Div.个</td><td>Rep.</td><td>NEER↓</td><td>Entailr↑</td><td>Div.↑</td><td>Rep.↓</td></tr><tr><td>Greedy</td><td>39.9%</td><td>12.9%</td><td>0.05</td><td>33.1%</td><td>45.0%</td><td>8.8%</td><td>0.05</td><td>36.2%</td></tr><tr><td>Top-p 0.9</td><td>52.4%</td><td>2.9%</td><td>0.88</td><td>0.2%</td><td>56.8%</td><td>2.0%</td><td>0.89</td><td>0.3%</td></tr><tr><td>p1</td><td colspan="8">Top-p + X-decay</td></tr><tr><td>0.910.9</td><td>41.1%</td><td>10.8%</td><td>0.43</td><td>30.7%</td><td>45.7%</td><td>6.8%</td><td>0.47</td><td>34.5%</td></tr><tr><td>0.910.5</td><td>39.9%</td><td>13.0%</td><td>0.08</td><td>33.1%</td><td>44.9%</td><td>9.1%</td><td>0.09</td><td>35.9%</td></tr><tr><td>p1入</td><td colspan="8">Top-p + X-decay + p-reset</td></tr><tr><td>0.910.9</td><td>41.5%</td><td>10.3%</td><td>0.52</td><td>10.3%</td><td>45.4%</td><td>6.3%</td><td>0.57</td><td>9.1%</td></tr><tr><td>0.910.5</td><td>39.3%</td><td>12.8%</td><td>0.34</td><td>17.8%</td><td>44.5%</td><td>8.4%</td><td>0.45</td><td>18.9%</td></tr><tr><td>pl入lw</td><td></td><td></td><td></td><td></td><td>(factual-nucleus sampling)</td><td></td><td></td><td></td></tr><tr><td></td><td colspan="8"> Top-p + X-decay + p-reset + w-bound</td></tr><tr><td>0.910.910.7</td><td>46.2%</td><td>5.0%</td><td>0.78</td><td>1.2%</td><td>52.2%</td><td>3.2%</td><td>0.80</td><td>0.5%</td></tr><tr><td>0.9 10.9 10.3</td><td>42.1%</td><td>10.1%</td><td>0.55</td><td>7.1%</td><td>46.5%</td><td>5.6%</td><td>0.59</td><td>6.4%</td></tr><tr><td>0.910.9 10.2</td><td>41.7%</td><td>9.9%</td><td>0.52</td><td>8.6%</td><td>45.6%</td><td>6.2%</td><td>0.56</td><td>7.6%</td></tr><tr><td>0.9 10.510.3</td><td>41.0%</td><td>12.2%</td><td>0.47</td><td>13.0%</td><td>46.0%</td><td>7.0%</td><td>0.51</td><td>12.7%</td></tr><tr><td>0.910.510.2</td><td>39.3%</td><td>12.8%</td><td>0.38</td><td>16.1%</td><td>45.2%</td><td>7.8%</td><td>0.42</td><td>16.9%</td></tr></table>
+
+• Named Entity Mix-up: Mixing up similar types of the named entity. For example, LM generated “The movie is based on the novel of the same name by Gayle Forman.” about a film called “The Best of Me”. However, the correct author’s name is “Nicholas Sparks”, not “Gayle Forman”. Note that Gayle Forman is also an American young adult fiction author who writes similar type of novels as Nicholas Sparks.
+
+• Fabricated Fact: Fabricating some random facts. For example, “Samuel Witwer’s father is a Lutheran minister.” Note that, the pretraining corpus contains non-factual or fictional information, which can also contribute to such fabricated facts.
+
+Both error types can be viewed as wrong associations of entities that appear at different parts of the training corpus with similar context. Such behavior is unsurprising because these LMs are uniformly trained with the next subword prediction objective instead of a fact-related objective.
+
+![](images/3f577455231c4c50fa3cbd037053ec5b7812d49ff5f4c4dd5ba5bd135f433c9c.jpg)  
+Figure 2: Comparison between nucleus sampling (blue line) and factual-nucleus sampling (orange line). The $\mathbf { X }$ -axis is named entity error $\Nu \mathrm { E } _ { \mathrm { E R } }$ . The y-axes are diversity and repetition in (a) and (b) respectively. The lower the repetition, the better. It is evident that factual-nucleus sampling has better trade-offs between factuality and diversity/repetition. For a reference, the diversity score of randomly sampled 5000 Wikipedia documents is 0.767.
+
+# 5 Factual-Nucleus Sampling
+
+In this section, we propose a new sampling algorithm that achieves a better trade-off between generation quality and factuality than existing decoding algorithms.
+
+# 5.1 Method
+
+We hypothesize that the randomness of sampling is more harmful to factuality when it is used to generate the latter part of a sentence than the beginning of a sentence. There is no preceding text at the start of a sentence, so it is safe for LM to generate anything as long as it is grammatical and contextual. However, as the generation proceeds, the premise become more determined, and fewer word choices can make the sentence factual. Given the example “Samuel Witwer’s father is a Lutheran minister”, the beginning of the sentence “Samuel Witwer’s father is” is not nonfactual. However, the continuation of “Lutheran minister” makes the sentence nonfactual. Therefore, we introduce the factual-nucleus sampling algorithm that dynamically adapts the “nucleus” $p$ along the generation of each sentence. In factual-nucleus sampling, the nucleus probability $p _ { t }$ to generate the $t$ -th token within each sentence is,
+
+$$
+p _ { t } = \operatorname* { m a x } \{ \omega , p \times \lambda ^ { t - 1 } \} ,
+$$
+
+where $\lambda$ is the decay factor for top- $p$ probability, and $\omega$ lower bounds the decay of probability. Specifically, it has the following parts:
+
+• $\lambda$ -decay: Given that top- $p$ sampling pool is selected as a set of subwords whose cumulative probability exceeds $p$ , we gradually decay the $p$ value with decay factor $\lambda$ at each generation step to reduce the “randomness” through time.   
+• $p$ -reset: The nucleus probability $p$ can quickly decay to a small value after a long generation. So, we reset the $p$ -value to the default value at the beginning of every new sentence in the generation (we identify the beginning of a new sentence by checking if the previous step has generated a full-stop). This reduces the unnecessary cost of diversity for any long generations.   
+• $\omega$ -bound: If $\lambda$ -decay is applied alone, the $p$ -value could become too small to be equivalent to greedy decoding and hurt diversity. To overcome this, we introduce a lower-bound $\omega$ to limit how far $p$ -value can be decayed.
+
+We will show the importance of each parts with ablation studies.
+
+# 5.2 Result
+
+We report our decoding experimental results with $1 . 3 \mathrm { B } \mathrm { L M } ^ { 7 }$ in Table 4. Additions of $\lambda$ -decay helps improve top- $p \ : 0 . 9$ factuality results – for instance, with decay rate $\lambda = 0 . 5$ , there is $12 . 5 \%$ drop in $\mathrm { N E } _ { \mathrm { E R } }$ and $1 0 . 1 \%$ gain in EntailR. However, this affects the diversity and repetition to become similar to greedy decoding. $p$ -reset mitigates the repetition issue and improves diversity metric without losing much in factuality metric. The effect is more drastic for the $\lambda = 0 . 5$ option, where it achieves 0.26 gains in diversity metric with negligible changes in factuality scores. By also adding $\omega$ -bound, we obtain the anticipated factuality performance (i.e., similar to greedy decoding), with great improvement in generation quality over greedy; with $p { = } 0 . 9$ , $\lambda { = } 0 . 9$ , $\omega { = } 0 . 3$ , we achieve $\times 1 1$ improvement in diversity and $\times 4 . 6$ improvement in repetition over greedy. Although our factualnucleus sampling still under-performs top- $p 0 . 9$ in terms of diversity, we believe this is an acceptable trade-off to improve the factuality of LM for factually sensitive open-ended generation tasks. Our proposed decoding does not harm the sentence fluency; its perplexity do not exceed the perplexity of top-p. Refer to Appendix F for full perplexity results.
+
+To further illustrate the underlying trade-off, we also compare the proposed factual-nucleus sampling against the nucleus sampling with lower $p$ values that are also expected to have lower randomness, thus less factual error, in generations. Specifically, we plotted results for nucleus sampling with $p = \{ 0 . 9 , 0 . 7 , 0 . 6 , 0 . 5 , 0 . 4 , \mathrm { { 0 . 3 } } \}$ , and factual nucleus sampling with the following $p \mid \lambda \mid \bar { \omega }$ choices: 0.9|0.9|0.7, 0.9|0.9|0.5, 0.9|0.9|0.4, 0.9|0.9|0.3, 0.9|0.7|0.3. The Fig 2a and $\mathrm { F i g 2 b }$ respectively show that the factual nucleus sampling method has better trade-offs than top- $p$ in factuality-vs-diversity and factuality-vs-repetition. In other words, it always achieves better factuality score with the same level of diversity and repetition scores.
+
+# 6 Factuality-Enhanced Continued Training
+
+This section introduces factuality-enhanced method for continued training of LMs [30]. We introduce the TOPICPREFIX for better awareness of facts and the sentence completion loss as training objective.
+
+# 6.1 Prepending TOPICPREFIX
+
+Unstructured factual knowledge typically exists at a document level (i.e., a group of factual sentences about an entity). This means that sentences can contain pronouns (e.g., she, he, it), making these sentences factually useless standalone. To illustrate with an example from Barack Obama’s Wikipedia page, “He previously served as a U.S. senator from Illinois from 2005 to $2 0 0 8 '$ cannot be a useful standalone fact because it is unclear who “He” is. Due to the GPU memory limit and computation efficiency, it is common to chunk documents in LM training corpus. This causes the “fragmentation” of information and leads to wrong associations of entities that appear in independent documents with similar contexts. As a remedy, we propose to prepend TOPICPREFIX to sentences in the factual documents to make each sentence serve as a standalone fact. In our experiments, we mainly utilize Wikipedia as the factual corpus and the Wikipedia document name as the TOPICPREFIX.
+
+# 6.2 Sentence Completion Loss
+
+We propose a sentence completion loss to address the incorrect association learned between entities. To explain our rationale, let us recall the nonfactual example from $\ S 5$ : “Samuel Witwer’s father is a Lutheran minister”. This sentence is nonfactual because LM failed to generate factually correct information after “is”. In other words, LM failed to accurately complete the sentence given the generated context. One reason is that the LM is uniformly trained to predict each subword token within the sentence, when ensuring the correct prediction at the latter section of sentence is more critical for factuality. Therefore, we construct a sentence completion loss, which makes the LM focus on predicting the subwords later in the sentence. For implementation, we determine a pivot $t$ for each sentence, and then apply zero-masking for all token prediction losses before $t$ . This pivot is only required during training (i.e., no pivot needed during inference time).
+
+We emphasize that this loss masking is different from the input token masking applied in BERT [73] or BART [76], and the LM is still trained in an autoregressive manner. Note that many BART-based summarization models are known to still suffer from factual errors, suggesting that masked prediction at the encoder level may not effectively transfer well to autoregressive text generation.
+
+In this work, we explore three strategies (from simple to complex) to determine the pivot $t$
+
+• $S C _ { \mathrm { H A L F } }$ : pivot $t = 0 . 5 \times$ sentence-length.   
+• $S C _ { \mathrm { R A N D O M } }$ : random pivot, e.g., $t \sim$ uniform $[ 0 . 2 5 , 0 . 7 5 ] \times$ sentence-length.   
+• $S C _ { \mathrm { { R O O T } } }$ : pivot $t =$ position of ROOT (relation) from dependency parsing.
+
+Our experiments show that the simplest $S C _ { \mathrm { H A L F } }$ performs on par with the complex ones (such as $S C _ { \mathrm { R O O T } } )$ ), thus, we suggest future work to choose $S C _ { \mathrm { H A L F } }$ strategy.
+
+# 6.3 Results
+
+The results are reported in Table 5, and experimental setups are reported in Appendix C.
+
+Inefficiency of Domain Adaptive Training The pre-training corpus of LM contains both factual texts (e.g., Wikipedia) and potentially nonfactual texts (e.g., rumors, fake news) 8. The nonfactual domain of the training corpus could be the problem. Thus, we conduct a baseline experiment that does domain-adaptive training with strictly factual domain text only (i.e., Wikipedia). Interestingly, we find that domain-adaptive training can hardly improve generation factuality.
+
+Effect of TOPICPREFIX Continued pre-training of 1.3B LM with TOPICPREFIX preprocessed Wikipedia alone can already improve the factuality, especially in terms of $\mathrm { N E } _ { \mathrm { E R } }$ . For example, it reduces the $\mathrm { N E _ { E R } f r o m 4 2 . 1 \% }$ to $2 7 . 6 \%$ when we use the factual-nucleus decoding $( 0 . 9 \mid 0 . 9 \mid 0 . 3 )$ , which even outperforms the 1.3B with greedy decoding $( \mathrm { N E } _ { \mathrm { E R } } \colon 2 7 . 6 \%$ vs. $3 9 . 9 \%$ ) with much less repetition $( 8 . 0 \%$ vs. $3 3 . 1 \%$ ).
+
+Effect of Sentence Completion Loss The proposed sentence completion loss further helps to improve the factuality, especially for the EntailR. For example, when one uses factual-nucleus decoding on trained 1.3B model, TOPICPREFIX $+ \ S C _ { \mathrm { H A L F } }$ can further improve EntailR from $8 . 7 \%$ to $1 7 . 4 \%$ than TOPICPREFIX alone, while reducing $\Nu \mathrm { E } _ { \mathrm { E R } }$ from $2 7 . 6 \%$ to $2 3 . 6 \%$ . Note that the results show consistent improvement across different pivot selection strategies, suggesting that the sentence completion loss is robust. In particular, the simplest $S C _ { \mathrm { H A L F } }$ performs as good as others or even better in terms of several metrics. Thus we recommend it as the default option.
+
+Table 5: Results for factuality enhanced training. The decoding settings are formatted as: nucleus probability $p$ decay rate $\lambda$ , lower-bound $\omega$ .   
+
+<table><tr><td rowspan="2">Decoding (plλlw)</td><td colspan="4">Factual Prompt</td><td colspan="4">Nonfactual Prompt</td></tr><tr><td>NEER↓</td><td>EntailR↑</td><td>Div.</td><td>Rep.</td><td>NEER</td><td>EntailR</td><td>Div.</td><td>Rep.</td></tr><tr><td colspan="9">Vanilla Pretrained LM (1.3B)</td></tr><tr><td>0.9</td><td>52.4%</td><td>2.9%</td><td>0.88</td><td>0.2%</td><td>56.8%</td><td>2.0%</td><td>0.89</td><td>0.3%</td></tr><tr><td>0.9 10.910.3</td><td>42.1%</td><td>10.1%</td><td>0.55</td><td>7.1%</td><td>46.5%</td><td>5.6%</td><td>0.59</td><td>6.4%</td></tr><tr><td colspan="9">Factual Domain-Adaptive Training with Wikipedia (1.3B)</td></tr><tr><td>0.9</td><td>52.5%</td><td>2.8%</td><td>0.85</td><td>0.2%</td><td>55.8%</td><td>2.2%</td><td>0.86</td><td>0.1%</td></tr><tr><td>0.910.9 10.3</td><td>42.7%</td><td>7.1%</td><td>0.51</td><td>7.2%</td><td>48.2%</td><td>4.9%</td><td>0.56</td><td>6.0%</td></tr><tr><td colspan="9">TOPICPREFIX (1.3B)</td></tr><tr><td>0.9 0.910.910.3</td><td>34.4%</td><td>4.2%</td><td>0.84</td><td>0.3%</td><td>36.2%</td><td>2.7%</td><td>0.85</td><td>0.2%</td></tr><tr><td></td><td>27.6%</td><td>8.7%</td><td>0.43</td><td>8.0%</td><td>30.5%</td><td>6.1%</td><td>0.47</td><td>6.9%</td></tr><tr><td colspan="9">TOPICPREFIX + SCROOT (1.3B)</td></tr><tr><td>0.9 0.9 10.9 10.3</td><td>32.5% 24.7%</td><td>6.7% 15.8%</td><td>0.83 0.40</td><td>1.2% 13.6%</td><td>34.3% 27.6%</td><td>4.6% 9.1%</td><td>0.84 0.44</td><td>1.1% 13.7%</td></tr><tr><td colspan="9">TOPICPREFIX+ SCRANDOM (1.3B)</td></tr><tr><td>0.9 0.9 10.9 10.3</td><td>32.0% 23.6%</td><td>7.9% 17.6%</td><td>0.81 0.39</td><td>1.2% 14.2%</td><td>34.2% 26.9%</td><td>5.5% 9.3%</td><td>0.83 0.42</td><td>1.1% 13.2%</td></tr><tr><td colspan="9">TOPICPREFIX + SCHALF</td></tr><tr><td>0.9</td><td>31.6%</td><td>7.6% 17.4%</td><td>0.81 0.38</td><td>1.4% 14.4%</td><td>33.5% 27.2%</td><td>5.1% 10.2%</td><td>0.83 0.42</td><td>1.5% 13.1%</td></tr><tr><td colspan="9">0.9 10.9 10.3 23.6% Vanilla Pretrained LM (530B)</td></tr><tr><td>0.9</td><td>33.3%</td><td>11.8%</td><td>0.90</td><td>0.1%</td><td>40.5%</td><td>7.25%</td><td>0.92</td><td>0.1%</td></tr><tr><td colspan="9">TOPICPREFIX + SCHALF (530B)</td></tr><tr><td>0.9 0.9 10.9 10.3</td><td>18.3% 14.5%</td><td>19.3% 25.5%</td><td>0.68 0.33</td><td>0.1% 0.2%</td><td>21.7% 17.7%</td><td>13.7% 20.0%</td><td>0.68</td><td>0.1%</td></tr></table>
+
+530B vs 1.3B As expected, our method on 530B LM further reduces the factual errors and achieves the lowest $\Nu \mathrm { E } _ { \mathrm { E R } }$ $( 1 4 . 5 \% )$ and the highest EntailR $( 2 5 . 5 \% )$ . Surprisingly, our method on 530B LM lead to less diverse generation than 1.3B LM despite the significant improvement in the generation quality (i.e., near perfect repetition scores $0 . 1 \% 0 . 2 \%$ . We conjecture that this is the trade-off between the factuality and diversity for 530B LM.
+
+# 7 Conclusion
+
+In this work, we establish a benchmark to measure and analyze factuality in open-ended text generation tasks. We propose factual-nucleus sampling that improves generation factuality at inference time, and the combination of sentence completion loss and TOPICPREFIX pre-processing that improves factuality with continued training. We demonstrate that our methods are effective in improving the factuality. Lastly, our results shed light on the existence of the trade-off between diversity and factuality. We strongly believe this is an important insight that will help researchers make a better-informed decision about their model design - i.e., appropriately prioritize the desirable attribute of their LM (factuality vs. diversity) according to the final goal of their task. Potential future work would be to reduce the degree of the observed trade-offs.
+
+References   
+[1] Alec Radford, Jeffrey Wu, Rewon Child, David Luan, Dario Amodei, Ilya Sutskever, et al. Language models are unsupervised multitask learners. OpenAI blog, 2019.   
+[2] 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. JMLR, 2019.   
+[3] Tom Brown, Benjamin Mann, Nick Ryder, Melanie Subbiah, Jared D Kaplan, Prafulla Dhariwal, Arvind Neelakantan, Pranav Shyam, Girish Sastry, Amanda Askell, et al. Language models are few-shot learners. In NeurIPS, 2020.   
+[4] Shaden Smith, Mostofa Patwary, Brandon Norick, Patrick LeGresley, Samyam Rajbhandari, Jared Casper, Zhun Liu, Shrimai Prabhumoye, George Zerveas, Vijay Korthikanti, et al. Using DeepSpeed and Megatron to train Megatron-Turing NLG 530B, a large-scale generative language model. arXiv preprint arXiv:2201.11990, 2022.   
+[5] Rico Sennrich, Barry Haddow, and Alexandra Birch. Neural machine translation of rare words with subword units. In ACL, 2016.   
+[6] Jack W Rae, Sebastian Borgeaud, Trevor Cai, Katie Millican, Jordan Hoffmann, Francis Song, John Aslanides, Sarah Henderson, Roman Ring, Susannah Young, et al. Scaling language models: Methods, analysis & insights from training gopher. arXiv preprint arXiv:2112.11446, 2021.   
+[7] Reiichiro Nakano, Jacob Hilton, Suchir Balaji, Jeff Wu, Long Ouyang, Christina Kim, Christopher Hesse, Shantanu Jain, Vineet Kosaraju, William Saunders, et al. WebGPT: Browser-assisted question-answering with human feedback. arXiv preprint arXiv:2112.09332, 2021.   
+[8] Susan Zhang, Stephen Roller, Naman Goyal, Mikel Artetxe, Moya Chen, Shuohui Chen, Christopher Dewan, Mona Diab, Xian Li, Xi Victoria Lin, et al. Opt: Open pre-trained transformer language models. arXiv preprint arXiv:2205.01068, 2022.   
+[9] Rowan Zellers, Ari Holtzman, Hannah Rashkin, Yonatan Bisk, Ali Farhadi, Franziska Roesner, and Yejin Choi. Defending against neural fake news. In NeurIPS, 2019.   
+[10] Romal Thoppilan, Daniel De Freitas, Jamie Hall, Noam Shazeer, Apoorv Kulshreshtha, Heng-Tze Cheng, Alicia Jin, Taylor Bos, Leslie Baker, Yu Du, et al. LaMDA: Language models for dialog applications. arXiv preprint arXiv:2201.08239, 2022.   
+[11] Ziwei Ji, Nayeon Lee, Rita Frieske, Tiezheng Yu, Dan Su, Yan Xu, Etsuko Ishii, Yejin Bang, Andrea Madotto, and Pascale Fung. Survey of hallucination in natural language generation. arXiv preprint arXiv:2202.03629, 2022.   
+[12] Wojciech Krysci ´ nski, Bryan McCann, Caiming Xiong, and Richard Socher. Evaluating the factual ´ consistency of abstractive text summarization. In EMNLP, 2019.   
+[13] Joshua Maynez, Shashi Narayan, Bernd Bohnet, and Ryan McDonald. On faithfulness and factuality in abstractive summarization. In ACL, 2020.   
+[14] Esin Durmus, He He, and Mona Diab. FEQA: A question answering evaluation framework for faithfulness assessment in abstractive summarization. In ACL, 2020.   
+[15] Feng Nan, Cicero Nogueira dos Santos, Henghui Zhu, Patrick Ng, Kathleen McKeown, Ramesh Nallapati, Dejiao Zhang, Zhiguo Wang, Andrew O Arnold, and Bing Xiang. Improving factual consistency of abstractive summarization via question answering. In ACL-IJCNLP, 2021.   
+[16] Jun Yin, Xin Jiang, Zhengdong Lu, Lifeng Shang, Hang Li, and Xiaoming Li. Neural generative question answering. In IJCAI, 2016.   
+[17] Adam Roberts, Colin Raffel, and Noam Shazeer. How much knowledge can you pack into the parameters of a language model? arXiv preprint arXiv:2002.08910, 2020.   
+[18] Dan Su, Xiaoguang Li, Jindi Zhang, Lifeng Shang, Xin Jiang, Qun Liu, and Pascale Fung. Read before generate! faithful long form question answering with machine reading. In Findings in ACL, 2022.   
+[19] Amit Moryossef, Yoav Goldberg, and Ido Dagan. Step-by-step: Separating planning from realization in neural data-to-text generation. arXiv preprint arXiv:1904.03396, 2019.   
+[20] Tianyu Liu, Xin Zheng, Baobao Chang, and Zhifang Sui. Towards faithfulness in open domain table-to-text generation from an entity-centric view. In AAAI, 2021.   
+[21] Wenhao Yu, Chenguang Zhu, Zaitang Li, Zhiting Hu, Qingyun Wang, Heng Ji, and Meng Jiang. A survey of knowledge-enhanced text generation. arXiv preprint arXiv:2010.04389, 2020.   
+[22] Aleksandra Piktus, Fabio Petroni, Vladimir Karpukhin, Dmytro Okhonko, Samuel Broscheit, Gautier Izacard, Patrick Lewis, Barlas Oguz, Edouard Grave, Wen-tau Yih, et al. The web is your oyster–knowledge- ˘ intensive nlp against a very large web corpus. arXiv preprint arXiv:2112.09924, 2021.   
+[23] Peter West, Chris Quirk, Michel Galley, and Yejin Choi. Probing factually grounded content transfer with factual ablation. arXiv preprint arXiv:2203.10133, 2022.   
+[24] Sungjin Ahn, Heeyoul Choi, Tanel Pärnamaa, and Yoshua Bengio. A neural knowledge language model. arXiv preprint arXiv:1608.00318, 2016.   
+[25] Robert L Logan IV, Nelson F Liu, Matthew E Peters, Matt Gardner, and Sameer Singh. Barack’s wife hillary: Using knowledge-graphs for fact-aware language modeling. In ACL, 2019.   
+[26] Sebastian Borgeaud, Arthur Mensch, Jordan Hoffmann, Trevor Cai, Eliza Rutherford, Katie Millican, George van den Driessche, Jean-Baptiste Lespiau, Bogdan Damoc, Aidan Clark, et al. Improving language models by retrieving from trillions of tokens. arXiv preprint arXiv:2112.04426, 2021.   
+[27] Fabio Petroni, Aleksandra Piktus, Angela Fan, Patrick Lewis, Majid Yazdani, Nicola De Cao, James Thorne, Yacine Jernite, Vladimir Karpukhin, Jean Maillard, et al. Kilt: a benchmark for knowledge intensive language tasks. arXiv preprint arXiv:2009.02252, 2020.   
+[28] Kelvin Guu, Kenton Lee, Zora Tung, Panupong Pasupat, and Ming-Wei Chang. Realm: Retrievalaugmented language model pre-training. arXiv preprint arXiv:2002.08909, 2020.   
+[29] Ari Holtzman, Jan Buys, Li Du, Maxwell Forbes, and Yejin Choi. The curious case of neural text degeneration. In ICLR, 2020.   
+[30] Suchin Gururangan, Ana Marasovic, Swabha Swayamdipta, Kyle Lo, Iz Beltagy, Doug Downey, and ´ Noah A Smith. Don’t stop pretraining: adapt language models to domains and tasks. In ACL, 2020.   
+[31] Stephanie Lin, Jacob Hilton, and Owain Evans. TruthfulQA: Measuring how models mimic human falsehoods. In ACL, 2022.   
+[32] David R Krathwohl. A revision of bloom’s taxonomy: An overview. Theory into practice, 41(4):212–218, 2002.   
+[33] Fabio Petroni, Tim Rocktäschel, Patrick Lewis, Anton Bakhtin, Yuxiang Wu, Alexander H Miller, and Sebastian Riedel. Language models as knowledge bases? In EMNLP, 2019.   
+[34] Carlos Aspillaga, Marcelo Mendoza, and Alvaro Soto. Inspecting the concept knowledge graph encoded by modern language models. In Findings of ACL, 2021.   
+[35] Xuhui Zhou, Yue Zhang, Leyang Cui, and Dandan Huang. Evaluating commonsense in pre-trained language models. In AAAI, 2020.   
+[36] Zhengbao Jiang, Frank F Xu, Jun Araki, and Graham Neubig. How can we know what language models know? Transactions of the Association for Computational Linguistics, 2020.   
+[37] Zexuan Zhong, Dan Friedman, and Danqi Chen. Factual probing is [mask]: Learning vs. learning to recall. arXiv preprint arXiv:2104.05240, 2021.   
+[38] Yanai Elazar, Nora Kassner, Shauli Ravfogel, Abhilasha Ravichander, Eduard Hovy, Hinrich Schütze, and Yoav Goldberg. Measuring and improving consistency in pretrained language models. Transactions of the Association for Computational Linguistics, 9:1012–1031, 2021.   
+[39] Nicola De Cao, Wilker Aziz, and Ivan Titov. Editing factual knowledge in language models. In EMNLP, 2021.   
+[40] Joel Jang, Seonghyeon Ye, Sohee Yang, Joongbo Shin, Janghoon Han, Gyeonghun Kim, Stanley Jungkyu Choi, and Minjoon Seo. Towards continual knowledge learning of language models. arXiv preprint arXiv:2110.03215, 2021.   
+[41] Kevin Meng, David Bau, Alex Andonian, and Yonatan Belinkov. Locating and editing factual knowledge in GPT. arXiv preprint arXiv:2202.05262, 2022.
+
+[42] Ziqiang Cao, Furu Wei, Wenjie Li, and Sujian Li. Faithful to the original: Fact aware neural abstractive summarization. In Proceedings of the AAAI Conference on Artificial Intelligence, 2018.
+
+[43] Yue Dong, Shuohang Wang, Zhe Gan, Yu Cheng, Jackie Chi Kit Cheung, and Jingjing Liu. Multi-fact correction in abstractive text summarization. In Proceedings of the 2020 Conference on Empirical Methods in Natural Language Processing, pages 9320–9331, 2020.
+
+[44] Luyang Huang, Lingfei Wu, and Lu Wang. Knowledge graph-augmented abstractive summarization with semantic-driven cloze reward. In Proceedings of the 58th Annual Meeting of the Association for Computational Linguistics, 2020.
+
+[45] Yichong Huang, Xiachong Feng, Xiaocheng Feng, and Bing Qin. The factual inconsistency problem in abstractive text summarization: A survey. arXiv preprint arXiv:2104.14839, 2021.
+
+[46] Shuyang Cao and Lu Wang. Cliff: Contrastive learning for improving faithfulness and factuality in abstractive summarization. In Proceedings of the 2021 Conference on Empirical Methods in Natural Language Processing, pages 6633–6649, 2021.
+
+[47] Chenguang Zhu, William Hinthorn, Ruochen Xu, Qingkai Zeng, Michael Zeng, Xuedong Huang, and Meng Jiang. Enhancing factual consistency of abstractive summarization. In Proceedings of the 2021 Conference of the North American Chapter of the Association for Computational Linguistics: Human Language Technologies, pages 718–733, 2021.
+
+[48] Sihao Chen, Fan Zhang, Kazoo Sone, and Dan Roth. Improving faithfulness in abstractive summarization with contrast candidate generation and selection. In Proceedings of the 2021 Conference of the North American Chapter of the Association for Computational Linguistics: Human Language Technologies, pages 5935–5941, 2021.
+
+[49] Sam Wiseman, Stuart Shieber, and Alexander Rush. Challenges in data-to-document generation. In Proceedings of the 2017 Conference on Empirical Methods in Natural Language Processing, pages 2253–2263. ACL, 2017.
+
+[50] Feng Nie, Jin-Ge Yao, Jinpeng Wang, Rong Pan, and Chin-Yew Lin. A simple recipe towards reducing hallucination in neural surface realisation. In Proceedings of the 57th Annual Meeting of the Association for Computational Linguistics, pages 2673–2679. ACL, 2019.
+
+[51] Yixuan Su, David Vandyke, Sihui Wang, Yimai Fang, and Nigel Collier. Plan-then-generate: Controlled data-to-text generation via planning. Findings of EMNLP, 2021.
+
+[52] Peng Wang, Junyang Lin, An Yang, Chang Zhou, Yichang Zhang, Jingren Zhou, and Hongxia Yang. Sketch and refine: Towards faithful and informative table-to-text generation. ACL, 2021.
+
+[53] Clément Rebuffel, Marco Roberti, Laure Soulier, Geoffrey Scoutheeten, Rossella Cancelliere, and Patrick Gallinari. Controlling hallucinations at word level in data-to-text generation. Data Mining and Knowledge Discovery, pages 318–354, 2022.
+
+[54] Lei Shen, Haolan Zhan, Xin Shen, Hongshen Chen, Xiaofang Zhao, and Xiaodan Zhu. Identifying untrustworthy samples: Data filtering for open-domain dialogues with bayesian optimization. In Proceedings of the 30th ACM International Conference on Information & Knowledge Management, pages 1598–1608, 2021.
+
+[55] Kurt Shuster, Spencer Poff, Moya Chen, Douwe Kiela, and Jason Weston. Retrieval augmentation reduces hallucination in conversation. In Findings of the Association for Computational Linguistics: EMNLP 2021. ACL, 2021.
+
+[56] Hannah Rashkin, David Reitter, Gaurav Singh Tomar, and Dipanjan Das. Increasing faithfulness in knowledge-grounded dialogue with controllable features. In Proceedings of the 59th Annual Meeting of the Association for Computational Linguistics and the 11th International Joint Conference on Natural Language Processing, pages 704–718. ACL, 2021.
+
+[57] Zeqiu Wu, Michel Galley, Chris Brockett, Yizhe Zhang, Xiang Gao, Chris Quirk, Rik Koncel-Kedziorski, Jianfeng Gao, Hannaneh Hajishirzi, Mari Ostendorf, et al. A controllable model of grounded response generation. In Proceedings of the AAAI Conference on Artificial Intelligence, pages 14085–14093, 2021.
+
+[58] Nouha Dziri, Andrea Madotto, Osmar Zaiane, and Avishek Joey Bose. Neural path hunter: Reducing hallucination in dialogue systems via path grounding. EMNLP, 2021.
+
+[59] Long Ouyang, Jeff Wu, Xu Jiang, Diogo Almeida, Carroll L Wainwright, Pamela Mishkin, Chong Zhang, Sandhini Agarwal, Katarina Slama, Alex Ray, et al. Training language models to follow instructions with human feedback. arXiv preprint arXiv:2203.02155, 2022.
+
+[60] Krishna Pillutla, Swabha Swayamdipta, Rowan Zellers, John Thickstun, Sean Welleck, Yejin Choi, and Zaid Harchaoui. MAUVE: Measuring the gap between neural text and human text using divergence frontiers. In NeurIPS, 2021.
+
+[61] Samuel Gehman, Suchin Gururangan, Maarten Sap, Yejin Choi, and Noah A Smith. Realtoxicityprompts: Evaluating neural toxic degeneration in language models. In Findings in EMNLP, 2020.
+
+[62] Nils Reimers and Iryna Gurevych. Sentence-bert: Sentence embeddings using siamese bert-networks. arXiv preprint arXiv:1908.10084, 2019.
+
+[63] Ben Goodrich, Vinay Rao, Peter J Liu, and Mohammad Saleh. Assessing the factual accuracy of generated text. In ACM SIGKDD, 2019.
+
+[64] Feng Nan, Ramesh Nallapati, Zhiguo Wang, Cicero Nogueira dos Santos, Henghui Zhu, Dejiao Zhang, Kathleen McKeown, and Bing Xiang. Entity-level factual consistency of abstractive text summarization. In EACL, 2021.
+
+[65] Bill MacCartney and Christopher D. Manning. Modeling semantic containment and exclusion in natural language inference. In Proceedings of the 22nd International Conference on Computational Linguistics (Coling 2008), pages 521–528, Manchester, UK, August 2008. Coling 2008 Organizing Committee. URL https://aclanthology.org/C08-1066.
+
+[66] Tobias Falke, Leonardo FR Ribeiro, Prasetya Ajie Utama, Ido Dagan, and Iryna Gurevych. Ranking generated summaries by correctness: An interesting but challenging application for natural language inference. In Proceedings of the 57th Annual Meeting of the Association for Computational Linguistics, pages 2214–2220, 2019.
+
+[67] Ondˇrej Dušek and Zdenek Kasner. Evaluating semantic accuracy of data-to-text generation with natural ˇ language inference. arXiv preprint arXiv:2011.10819, 2020.
+
+[68] Nouha Dziri, Hannah Rashkin, Tal Linzen, and David Reitter. Evaluating groundedness in dialogue systems: The begin benchmark. arXiv preprint arXiv:2105.00071, 2021.
+
+[69] 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.
+
+[70] Adina Williams, Nikita Nangia, and Samuel Bowman. A broad-coverage challenge corpus for sentence understanding through inference. In NAACL, 2018.
+
+[71] Jiwei Li, Michel Galley, Chris Brockett, Jianfeng Gao, and Bill Dolan. A diversity-promoting objective function for neural conversation models. In NAACL, 2016.
+
+[72] Zhihong Shao, Minlie Huang, Jiangtao Wen, Wenfei Xu, and Xiaoyan Zhu. Long and diverse text generation with planning-based hierarchical variational model. arXiv preprint arXiv:1908.06605, 2019.
+
+[73] Jacob Devlin, Ming-Wei Chang, Kenton Lee, and Kristina Toutanova. Bert: Pre-training of deep bidirectional transformers for language understanding. arXiv preprint arXiv:1810.04805, 2018.
+
+[74] Boxin Wang, Wei Ping, Chaowei Xiao, Peng Xu, Mostofa Patwary, Mohammad Shoeybi, Bo Li, Anima Anandkumar, and Bryan Catanzaro. Exploring the limits of domain-adaptive training for detoxifying large-scale language models. In NeurIPS, 2022.
+
+[75] Eric Wallace, Shi Feng, Nikhil Kandpal, Matt Gardner, and Sameer Singh. Universal adversarial triggers for attacking and analyzing nlp. In EMNLP, 2019.
+
+[76] Mike Lewis, Yinhan Liu, Naman Goyal, Marjan Ghazvininejad, Abdelrahman Mohamed, Omer Levy, Ves Stoyanov, and Luke Zettlemoyer. Bart: Denoising sequence-to-sequence pre-training for natural language generation, translation, and comprehension. arXiv preprint arXiv:1910.13461, 2019.
+
+[77] Mohammad Shoeybi, Mostofa Patwary, Raul Puri, Patrick LeGresley, Jared Casper, and Bryan Catanzaro. Megatron-lm: Training multi-billion parameter language models using model parallelism. arXiv preprint arXiv:1909.08053, 2019.
+
+[78] James Thorne, Andreas Vlachos, Christos Christodoulopoulos, and Arpit Mittal. FEVER: a large-scale dataset for fact extraction and verification. In NAACL, 2018.

parse/dev/LvyJX20Rll/LvyJX20Rll_content_list.json

@@ -0,0 +1,1419 @@
+[
+    {
+        "type": "text",
+        "text": "Factuality Enhanced Language Models for Open-Ended Text Generation ",
+        "text_level": 1,
+        "bbox": [
+            241,
+            122,
+            758,
+            172
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Nayeon Lee⇤†1, Wei $\\mathrm { P i n g ^ { \\dag 2 } }$ , Peng $\\mathrm { X u } ^ { 2 }$ , Mostofa Patwary2, Pascale Fung1, Mohammad Shoeybi2, and Bryan Catanzaro2 ",
+        "bbox": [
+            254,
+            222,
+            743,
+            256
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1Hong Kong University of Science and Technology 2NVIDIA ",
+        "bbox": [
+            331,
+            267,
+            666,
+            299
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Abstract ",
+        "text_level": 1,
+        "bbox": [
+            462,
+            337,
+            535,
+            354
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Pretrained language models (LMs) are susceptible to generate text with nonfactual information. In this work, we measure and improve the factual accuracy of large-scale LMs for open-ended text generation. We design the FACTUALITYPROMPTS test set and metrics to measure the factuality of LM generations. Based on that, we study the factual accuracy of LMs with parameter sizes ranging from 126M to 530B. Interestingly, we find that larger LMs are more factual than smaller ones, although a previous study suggests that larger LMs can be less truthful in terms of misconceptions. In addition, popular sampling algorithms (e.g., top- $p$ ) in open-ended text generation can harm the factuality due to the “uniform randomness” introduced at every sampling step. We propose the factual-nucleus sampling algorithm that dynamically adapts the randomness to improve the factuality of generation while maintaining quality. Furthermore, we analyze the inefficiencies of the standard training method in learning correct associations between entities from factual text corpus (e.g., Wikipedia). We propose a factuality-enhanced training method that uses TOPICPREFIX for better awareness of facts and sentence completion as the training objective, which can vastly reduce the factual errors. ",
+        "bbox": [
+            233,
+            369,
+            766,
+            590
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 Introduction ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            614,
+            310,
+            632
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Large-scale pre-trained language models (LMs) have demonstrated impressive natural language generation results [1–4]. However, the generative LMs (e.g., GPT-3) are solely trained to model the statistical correlations between subword tokens [5], and have limited capability to generate factually accurate text as illustrated in Table 1. As a result, there are increasing concerns about the nonfactual generations from large-scale pre-trained LMs [e.g., 6–8], which needs to be adequately addressed for their safe deployment in real-world applications, e.g., content creation [9] and dialogue [10]. ",
+        "bbox": [
+            174,
+            643,
+            825,
+            727
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "In previous studies, different metrics and methods have been proposed to measure and improve the factual accuracy of language generation within different tasks [11], including text summarization [e.g., 12–15], question answering [e.g., 16–18], and table-to-text generation [e.g., 19, 20]. However, these works focus on the faithfulness (or factuality) of the fine-tuned LMs for particular downstream tasks (i.e., factual consistency between source and target text). Little exploration has been made to address the factual errors in pretrained LMs for general-purpose open-ended text generation, where the goal is to generate a coherent continuation from the given context (e.g., the use cases from GPT-2). ",
+        "bbox": [
+            174,
+            733,
+            825,
+            829
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "One of the popular methods for enhancing generation factuality is to incorporate external knowledge sources [21–23]. Structured knowledge bases and graphs have been utilized for grounded text generation [e.g., 24, 25], where the LMs are trained to select and copy relevant facts from external knowledge sources. In contrast to the sizeable online text with factual information, the structured knowledge graphs only encode a limited amount of knowledge as they require expensive human annotations for high-quality construction. A method that can directly leverage plain text knowledge (e.g., Wikipedia, encyclopedia books, peer-reviewed publications) would be desirable for factuality enhancement as it can remove the human annotation bottleneck and easily scale up the amount of injected knowledge. Augmenting LM with an information retrieval (IR) system is one possible solution to leverage textual facts, however, at the cost of additional complexity and resource overhead to the model [10, 26, 22, 27, 28]. Therefore, we explore an IR-free method that enhances the innate factuality of LMs by continued training on a factually rich plain-text corpus. ",
+        "bbox": [
+            176,
+            835,
+            823,
+            864
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            92,
+            825,
+            229
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "In this work, we focus on measuring and improving the factuality of large-scale pre-trained language models (LMs) for open-ended text generation. Specifically, we make the following contributions: ",
+        "bbox": [
+            176,
+            236,
+            823,
+            263
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "1. We build the benchmark and metrics 3 to measure the factual accuracy of pre-trained LM for open-ended text generation. We demonstrate a good correlation between the proposed automatic metrics and human assessment of factuality. Based on that, we systematically study the factual accuracy of LMs with parameter sizes ranging from 126M to 530B and find that large LMs have higher factual accuracy than smaller ones (e.g., named-entity factual error is reduced from $6 3 . 6 9 \\%$ to $3 3 . 3 \\%$ ).   \n2. We study the decoding algorithms of LM in terms of factual accuracy. We unveil that the popular nucleus sampling algorithm [29] for open-ended text generation can easily mix up different named entities or randomly fabricate information due to the “uniform randomness” introduced at every decoding step. We propose factual-nucleus sampling algorithm that promotes generation factuality while maintaining the quality and diversity.   \n3. We explore training methods that can effectively leverage text corpus with rich facts (e.g., Wikipedia). We find that directly continuing the training of LM on factual text data [30] does not guarantee the improvement of factual accuracy. We propose factuality-enhanced training to address the underlying inefficiencies of this baseline. Our method consists of i) an addition of a TOPICPREFIX that improves the awareness of facts during training, and ii) a sentence completion task as the new objective for continued LM training [e.g., 30].   \n4. We demonstrate that the factual accuracy of large-scale LMs (up to 530B) can be significantly enhanced (i.e., named-entity factual error is reduced from $3 3 . 3 \\%$ to $1 4 . 5 \\%$ ) after applying the proposed factuality-enhanced training with factual-nucleus sampling algorithm. ",
+        "bbox": [
+            202,
+            267,
+            826,
+            551
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "We organize the rest of the paper as follows. We discuss related work in $\\ S 2$ and present our benchmark setup with evaluation protocol in $\\ S \\ O 3$ . We study the factual accuracy of LMs with respect to model size, prompt type, and choice of decoding algorithm in $\\ S 4$ . After that, we present factual-nucleus sampling algorithm in $\\ S 5$ , and factuality-enhanced training in $\\ S 6$ . We conclude the paper in $\\ S 7$ . ",
+        "bbox": [
+            176,
+            559,
+            825,
+            614
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2 Related Work ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            631,
+            321,
+            647
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Factuality vs. Model Size Lin et al. [31] propose the TruthfulQA benchmark to measure the falsehood generations from different sized LMs. The result suggests that bigger LMs pre-trained on web text are generally less truthful than smaller ones in terms of false belief or misconception. At first glance, this is contradictory to our observation, however, our work focuses on different knowledge to TruthfulQA work. The TruthfulQA benchmark focuses on conceptual knowledge, while our benchmark focuses on factual knowledge [32] 4. Large LMs can be good at recalling factual knowledge given substantial pre-training corpus, suggested by previous studies on LM’s parameteric knowledge [33], but there still remains room for improvement for reasoning conceptual knowledge [34, 35]. ",
+        "bbox": [
+            174,
+            659,
+            825,
+            785
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Parametric Factual Knowledge A group of work addresses the factual errors in the parametric knowledge of LMs that is acquired from training corpus [36–38]. The correctness of the parametric knowledge is commonly tested in cloze-style question answering format [33] (e.g., Person X is born in __). Efforts are made to fine-tune the pre-trained LM to “inject” more knowledge and improve its ability to answer factual questions without consulting external knowledge source [17]. ",
+        "bbox": [
+            174,
+            790,
+            825,
+            859
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "table",
+        "img_path": "images/fe5ca3628906a699e2d282aec116f95d571d81952aa86af95bdd53de8617ce5a.jpg",
+        "table_caption": [
+            "Table 1: Example of continuations from the 530B LM with greedy decoding and nucleus sampling $p = 0 . 9$ , along with the continuation from factuality-enhanced 530B LM with factual-nucleus sampling. Red represents nonfactual, green represents factual, and strikethrough represents repetition. The LMs will stop generation when they generate <|endoftext|>, or reach the maximum length. See Appendix A for more examples. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>[Factual Prompt] One of lung cancer&#x27;s symptoms is shortness of breath.</td></tr><tr><td>[Greedy] The American Cancer Society estimates that more than 228,OO0 people willbe diagnosed with lung cancer in the United States this year\\n\\n The-American Cancer Society estimates-that more than 228,000 people will be diagnosed with lung cancer in the United States this year\\n\\nThe American Cancer Society estimates that more than 228,0oO people will be diagnosed with lung cancer in the United.. [p=0.9] That would make an oxygen mask one of the more popular treatments for this devastating disease.</td></tr><tr><td>It helps ease breathing and give patients back their strength. Learn more here.&lt;lendoftextl&gt;&quot; [Ours] Other symptoms include coughing (including coughing up blood),chest pain, hoarsenes, weight loss, and loss of appetite. The symptoms of lung cancer may resemble those of a bad cold or pneumonia. A</td></tr><tr><td>chest x - ray is necessary to confirm the diagnosis. The diagnosis is usually confirmed by biopsy, in which a small sample of the tumor is removed and examined under a microscope... [Non-Factual Prompt] Cancer can be prevented by drinking too much alcohol.</td></tr><tr><td>[Greedy] \\nCancer can be prevented by eating too much red meat.\\n\\nCancer can be prevented by eating t00 much sugar.\\n\\nCancer can be prevented by-eating-too much fat.lnnCancer can be prevented by eating too much processed food.An\\nCaneer can be.. [p=0.9] More than 90% of hepatocellular carcinoma is associated with alcohol use.\\n\\nAbout 9 percent</td></tr><tr><td>of cancers can be prevented if we don&#x27;t eat more than 1.5 ounces of processed meat each day.\\n\\nDiet is believed to play a role in 7% of cancers and... [Ours] Cancer is often treated with some combination of radiation therapy, surgery, chemotherapy and targeted therapy. Pain and symptom management are an important part of care. Palliative care is particularly</td></tr></table>",
+        "bbox": [
+            176,
+            146,
+            816,
+            484
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Moreover, some works attempt to edit and fix the factual errors [39–41]. However, it is unclear if the improvement of fine-tuned LM for QA-style task can help to mitigate factual errors in open-ended text generation task. ",
+        "bbox": [
+            176,
+            510,
+            823,
+            551
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Hallucination in downstream NLG tasks There are active efforts to reduce the unfaithfulness or factual errors of task-specific LMs fine-tuned for various downstream natural language generation (NLG) tasks such as summarization [42–48], data-to-text [49, 50, 20, 51–53] and dialogue system [54–58]. In contrast to these works, we focus on general purpose LM for open-ended text generation task. ",
+        "bbox": [
+            174,
+            558,
+            825,
+            627
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Human-in-the-loop Human feedback or demonstrations are valuable to improve the factual accuracy of LMs. For example, InstructGPT [59] fine-tune the LMs with collected human feedback for a truthful generation. WebGPT [7] is trained to cite its sources when it generates output, thus allowing humans to evaluate factual accuracy by checking whether a claim is supported by a reliable source. In this work, we focus on human-free solution to mitigate nonfactual generations, as it is less expensive and easy to scale. ",
+        "bbox": [
+            174,
+            633,
+            825,
+            717
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3 FACTUALITYPROMPTS and Evaluation Metrics ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            733,
+            604,
+            751
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Our goal is to automatically measure and evaluate the factuality of large-scale pre-trained language models (LMs) for open-ended text generation. Factuality refers to being coherent to provided groundtruth knowledge sources in NLP [11]. The biggest challenge of evaluating factuality for open-ended text generation is associated with locating the ground-truth knowledge from the myriad of world knowledge. Evaluating open-ended text generation can be challenging due to the lack of ground-truth references for generation [29, 60]. In this study, the scope of our ground-truth knowledge source is set to Wikipedia 5 because this helps simplify the evaluation setup. ",
+        "bbox": [
+            174,
+            762,
+            825,
+            859
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "image",
+        "img_path": "images/c9e83c2af2a829744c999da6962db752816693dcd7c9b43305ea962fbd7c7536.jpg",
+        "image_caption": [
+            "Figure 1: Illustration of our evaluation framework "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            189,
+            88,
+            805,
+            270
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "As illustrated in Fig 1, our evaluation framework consists of the following phases. In phase 1, LM generates the continuations from the provided test prompts (§3.1). In phase 2, we first identify checkworthy continuations, which refers to the generations with facts that require factuality evaluation. One may refer to Appendix B for details. This step is necessary as open-ended text generation may generate text that does not contain facts such as personal opinion or chitchat-style text (e.g., “I like eating apples!”). Then, we prepare relevant ground-truth knowledge required for factual verification of check-worthy continuations (§3.2). Lastly, we calculate the factuality and quality measures (§3.3). ",
+        "bbox": [
+            174,
+            309,
+            825,
+            406
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3.1 FACTUALITYPROMPTS Testset ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            421,
+            428,
+            436
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "We design our test prompts (FACTUALITYPROMPTS) that follows a similar setup as in RealToxicityPrompts [61], which has toxic and nontoxic prompts to evaluate the toxicity of LM continuations. FACTUALITYPROMPTS consists of factual and nonfactual prompts that allow us to study the impact of prompts’ factuality on the LM continuation; this simulates the real-world scenario where input texts are not guaranteed to be factual. The data construction and statistic details are provided in Appendix D, and we will release the constructed FACTUALITYPROMPTS for future research. ",
+        "bbox": [
+            174,
+            445,
+            825,
+            529
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3.2 Ground-Truth Knowledge Preparation ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            544,
+            483,
+            559
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "To evaluate the factuality of a given generation, we need to prepare relevant ground-truth knowledge. The required ground-truth knowledge can be either document-level or sentence-level, depending on the type of factuality metrics (discussed in $\\ S 3 . 3 )$ . The correctness of factuality evaluation is crucially dependent on the correctness of the ground-truth knowledge. To ensure that our factuality evaluation is not distorted by the irrelevant provision of ground-truth knowledge, we do the following: ",
+        "bbox": [
+            174,
+            568,
+            825,
+            636
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "For document-level ground-truth knowledge, we directly use the Wikipedia document annotation from the FEVER dataset. This way, we can mitigate any potential error from automatic document retrieval. For sentence-level ground-truth knowledge, we do automatic sentence selection by using two different methods to maximize the chance of recalling the relevant ground-truth knowledge. We treat the generated text as query $q$ and Wikipedia sentences as a pool of candidates $C =$ $\\{ c _ { 1 } , c _ { 2 } , c _ { 3 } , . . . c _ { N } \\}$ where $N$ is the number of sentences in the Wikipedia document. One ground-truth sentence is retrieved by obtaining TF-IDF vector representations of $q$ and $C$ and selecting the $c _ { i }$ with the highest cosine similarity with the $q$ . Another is retrieved by obtaining the contextual representation of $q$ and $C$ using SentenceTransformer [62] and selecting the $c _ { j }$ with the highest cosine similarity. ",
+        "bbox": [
+            173,
+            643,
+            825,
+            768
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3.3 Evaluation Metrics ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            784,
+            346,
+            797
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "We adapt commonly used metric designs from the hallucination literature [11]: named-entity (NE) based metric and textual entailment based metric. Each metric captures a different aspect of factuality, so we use both metrics for better understanding of factuality. ",
+        "bbox": [
+            174,
+            806,
+            825,
+            848
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Hallucinated NE Error Since NEs are one of the core building blocks of “fact”, NE-related metric design is one of the common choices in literature [11, 63, 64]. In this work, we specifically adopt the NE-based metric [64] that is designed with a belief that a model is hallucinating (making factual errors) if it generates a NE that does not appear in the ground-truth knowledge source. ",
+        "bbox": [
+            174,
+            854,
+            825,
+            911
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "We define our NE-based metric to be: $\\mathrm { N E } _ { \\mathrm { E R } } = \\left| \\mathrm { H A L L U } _ { \\mathrm { N E } } \\right| / \\left| \\mathrm { A L L } _ { \\mathrm { N E } } \\right|$ where $_ { \\mathrm { A L L } _ { \\mathrm { N E } } }$ is the set of all the NEs detected in the LM generation, and HALLUNE is subset of $\\mathrm { N E } _ { \\mathrm { A l l } }$ that does not appear in the ground-truth Wikipedia document. Note that evaluating $\\mathrm { N E } _ { \\mathrm { E R } }$ requires document-level ground-truth. To ensure the quality of the metric, we also take the same precautions used by [64]. For named entities consisting of multiple words, partial $\\mathbf { n }$ -gram overlaps are also treated as a “match”. This ensures we can address the shortened form of named entities – e.g., “Barack Hussein Obama II” vs. “Obama”. Note that stopwords (e.g., the, a) are not considered in the partial n-gram overlaps. The named entities are detected using a publicly available pre-trained NE detection model from Spacy.io. ",
+        "bbox": [
+            173,
+            90,
+            826,
+            203
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Entailment Ratio Textual Entailment (or natural language inference) is a task of determining whether a hypothesis is entailed by, refuted by, or neutral to a given premise [65]. Entailmentbased metrics are based on the rationale that factual generation will be entailed by the ground-truth knowledge [11, 12, 66–68]. ",
+        "bbox": [
+            174,
+            207,
+            825,
+            262
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "We define the entailment ratio as: $\\mathrm { \\ E n t a i l _ { R } = \\hbar \\ l E N T A I L _ { g e n } | \\Omega / \\hbar A L L _ { g e n } | }$ , where $\\mathtt { A L L _ { g e n } }$ is set of all generations, and $\\mathrm { E N T A I L } _ { \\mathrm { g e n } }$ is the set of generations that are entailed by a entailment model. To obtain the entailment scores, we leverage a pretrained entailment model that is publicly available 6; a RoBERTa [69] model fine-tuned on MNLI [70] dataset. EntailR requires sentence-level groundtruth because only a few Wikipedia sentences are relevant to specific factual information in a given generation. For example, “Barack Obama was born in Hawaii” is only relevant to the Wikipedia sentence that mentions his birth location. Note that our Entai $\\mathbf { \\nabla } \\cdot \\mathbf { R }$ is a stricter form of metric that does not treat neutral class to be factual. ",
+        "bbox": [
+            174,
+            268,
+            825,
+            381
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Generation Quality Evaluation We also evaluate the generation quality from three aspects: i) Fluency is an important aspect of text generation. We measured it by the mean perplexity of generated continuations evaluated with a large pretrained LM, which is $1 . 3 \\mathrm { B } \\ \\mathrm { L M }$ in this work . ii) Diversity is an important characteristic of LM that makes the generation more interesting and engaging – it is bland and boring to always generate same texts. It is measured using the mean number of distinct n-grams (we report 4-gram), normalized by the length of text [71, 72] among the 10 generations for each prompt (i.e., in total, 160,000 generations to evaluate the diversity of each method). iii) Repetition is a common form of degeneration that is very undesirable. We measure the number of repetitive substrings that get generated at the end of the generations by using the publicly available metric code from Holtzman et al. [29]. ",
+        "bbox": [
+            174,
+            386,
+            825,
+            523
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "3.4 Correlation with Human Judgement ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            536,
+            465,
+            551
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Although NE-based and entailment-based metrics have been used in downstream NLG tasks [11], they have not been utilized for evaluating factual accuracy in open-ended text generation. To ensure their validity, we collect human annotations to evaluate the correlation between our automatic factuality metrics with human judgement – i.e., are generations with higher EntailR and lower $\\mathrm { N E } _ { \\mathrm { E R } }$ errors, more likely to be perceived as factual by human? ",
+        "bbox": [
+            174,
+            559,
+            553,
+            670
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "table",
+        "img_path": "images/7154297029a3980decc17e3b7d17c4ece6b131fef065bba0fd79766ff60223f6.jpg",
+        "table_caption": [
+            "Table 2: Pearson correlation coefficients between human factuality annotation and our factuality metrics. p-values for all results are 0.00. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Annotation</td><td>Entailr</td><td>NEER</td></tr><tr><td>Expert</td><td>0.81</td><td>-0.77</td></tr><tr><td>Majority-voting</td><td>0.47</td><td>-0.46</td></tr></table>",
+        "bbox": [
+            573,
+            621,
+            812,
+            683
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "We obtained human annotations for 200 randomly chosen LM continuations of varying $\\Nu \\mathrm { E } _ { \\mathrm { E R } }$ and EntailR scores. ",
+        "bbox": [
+            173,
+            676,
+            553,
+            704
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "The annotators are asked to fact-check the LM continuations against Wikipedia and assign factuality label $1 =$ Factual : can find supporting Wikipedia evidence. $0 = \\mathrm { N o n }$ -factual $:$ cannot find supporting Wikipedia evidence). ",
+        "bbox": [
+            176,
+            704,
+            821,
+            746
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "The fact-checking annotation is a challenging and time-consuming task, as it requires the annotator to carefully read multiple evidences and reason over them. To improve the annotation quality, we have two types of annotations. The first type is two annotations from average English speaking workers on Appen.com platform, and the second type is one “expert” annotation from one of the authors who is familiar with the task and spent solid amount of time checking each samples. Based on these three annotations, we do majority voting and report the Pearson correlation results in Table 2. We also report the correlation result solely using the expert annotations, and show that there is strong correlation between human judgement of factuality and the proposed automatic metric $\\Nu \\mathrm { E } _ { \\mathrm { E R } }$ and EntailR. $\\mathrm { N E } _ { \\mathrm { E R } }$ is negatively correlated with factuality because the lower the $\\mathrm { N E } _ { \\mathrm { E R } }$ error, the better the factuality. ",
+        "bbox": [
+            173,
+            752,
+            825,
+            890
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "table",
+        "img_path": "images/76c99c1a57a7e3254a7f958b9ac879f0c02a03b8f1330e66144b65f3bbb22b7a.jpg",
+        "table_caption": [
+            "Table 3: The factuality of LMs with different parameter size from 12M to 530B. $\\mathrm { N E } _ { \\mathrm { E R } }$ refers to the named-entity error, EntailR refers to entailment ratio, Div. refers to distinct 4-grams, and Rep. refers to repetition. $\\uparrow$ means the higher the better, and $\\downarrow$ means the lower the better. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=\"2\">Size</td><td rowspan=\"2\">Decode</td><td colspan=\"4\">Factual Prompt</td><td colspan=\"4\">Nonfactual Prompt</td></tr><tr><td>NEER↓</td><td>Entailr↑</td><td>Div.↑</td><td>Rep.</td><td>NEER</td><td>EntailR↑</td><td>Div.个</td><td>Rep.↓</td></tr><tr><td rowspan=\"2\">126M</td><td>p=0.9</td><td>63.69%</td><td>0.94%</td><td>0.90</td><td>0.58%</td><td>67.71%</td><td>0.76%</td><td>0.90</td><td>0.38%</td></tr><tr><td>greedy</td><td>48.55%</td><td>8.36%</td><td>0.03</td><td>59.06%</td><td>54.24%</td><td>6.25%</td><td>0.03</td><td>59.90%</td></tr><tr><td rowspan=\"2\">357M</td><td>p=0.9</td><td>56.70%</td><td>2.01%</td><td>0.87</td><td>0.55%</td><td>60.80%</td><td>1.42%</td><td>0.88</td><td>0.35%</td></tr><tr><td>greedy</td><td>43.04%</td><td>14.25%</td><td>0.03</td><td>45.18%</td><td>46.79%</td><td>9.89%</td><td>0.04</td><td>46.30%</td></tr><tr><td rowspan=\"2\">1.3B</td><td>p=0.9 greedy</td><td>52.42%</td><td>2.93%</td><td>0.88</td><td>0.24%</td><td>56.82%</td><td>2.04%</td><td>0.89</td><td>0.25%</td></tr><tr><td></td><td>39.87%</td><td>12.91%</td><td>0.05</td><td>33.13%</td><td>45.02%</td><td>8.75%</td><td>0.05</td><td>36.20%</td></tr><tr><td rowspan=\"2\">8.3B</td><td>p=0.9</td><td>40.59%</td><td>7.07%</td><td>0.90</td><td>0.11%</td><td>47.49%</td><td>3.57%</td><td>0.91</td><td>0.08%</td></tr><tr><td>greedy</td><td>28.06%</td><td>22.80%</td><td>0.07</td><td>19.41%</td><td>32.29%</td><td>15.01%</td><td>0.07</td><td>13.26%</td></tr><tr><td rowspan=\"2\">530B</td><td>p=0.9</td><td>33.30%</td><td>11.80%</td><td>0.90</td><td>0.13%</td><td>40.49%</td><td>7.25%</td><td>0.92</td><td>0.08%</td></tr><tr><td>greedy</td><td>20.85%</td><td>31.94%</td><td>0.08</td><td>15.88%</td><td>27.95%</td><td>19.91%</td><td>0.08</td><td>16.28%</td></tr></table>",
+        "bbox": [
+            181,
+            138,
+            812,
+            339
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "4 Factuality Analysis of Pretrained LMs ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            363,
+            524,
+            381
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "In this section, we perform a factuality analysis of LMs from three aspects: i) model size, $i i _ { - }$ ) prompt type and iii) decoding algorithm. ",
+        "bbox": [
+            173,
+            393,
+            823,
+            421
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Model Size Researchers have observed the trend of larger LMs outperforming smaller ones in various downstream tasks [73, 3, 2]. However, contradicting to these general observations, recent studies suggest that more misconceptions tend to be generated from larger models [31], and zero-shot fact-checking performance tend to stagnate with LM scaling [6]. We study the factuality of LMs with a range of parameter sizes (126M, 357M, 1.3B, 8.3B, 530B) to understand whether such surprising trend also applies to open-ended text generation. Note that, all LMs are pretrained on the same corpus as in [4]. As shown in Table 3, generation factuality does improve with the scaling of model size, e.g., $\\Nu \\mathrm { E } _ { \\mathrm { E R } }$ drops from $6 3 . 9 9 \\%$ to $3 3 . 3 0 \\%$ when parameter size scales up from 126M to 530B. ",
+        "bbox": [
+            173,
+            429,
+            825,
+            541
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Prompt Type Prompts provided to the LM are known to significantly affect the quality and characteristics of LM continuations [61, 74, 75]. We use our factual and nonfactual prompts to test the behavior of LMs. Results in Table 3 show that both factual and nonfactual prompts can lead to nonfactual generations, although factual prompts always result in less nonfactual generations. Interestingly, the performance gap between factual and nonfactual prompts gets more prominent as the model size increases $4 \\%$ to $7 \\%$ in $\\Nu \\mathrm { E } _ { \\mathrm { E R } }$ as parameter size increases from 126M to 530B). This could be due to the larger LM can better understand the prompts and imitate the factual or nonfactual prompts in the continuations. ",
+        "bbox": [
+            173,
+            549,
+            825,
+            659
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Decoding Algorithm We investigate the choice of decoding algorithms and their impacts on the factuality of generations. In particular, we compare two representative decoding algorithms that are greedy decoding (i.e., maximize generation likelihood) and nucleus sampling [29]. Nucleus sampling algorithm (a.k.a. top- $p$ ) samples only from the top subword candidates with total cumulative probability $p$ . It is popular for open-ended text generation because it solves the degeneration problems of the greedy decoding algorithm (e.g., repetition). However, the results in Table 3 show that top- $p$ decoding underperforms greedy decoding in terms of factuality, although it obtains higher generation diversity and less repetition. This intuitively makes sense because top- $p$ can be seen as adding “randomness” to encourage diversity, which as a result, can lead to factual errors. It is important to understand that factuality of a sentence can be easily altered by one wrong choice of word. For example, “Barack Obama was born in 1961” will be nonfactual if “1961” is changed to $\" 1 9 6 2 \"$ . In the same sense, greedy decoding is more factual because its way of choosing the word with the highest probability minimizes randomness and maximizes the utilization of parametric knowledge of LM [33, 36]. However, greedy decoding sacrifices generation diversity and quality. ",
+        "bbox": [
+            173,
+            667,
+            825,
+            861
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Error Types We conduct a qualitative analysis of the factual errors from greedy generation of 530B LM, to understand what are the remaining errors when the randomness from decoding choice is strictly restricted. The two notable error types were: ",
+        "bbox": [
+            174,
+            869,
+            825,
+            911
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "table",
+        "img_path": "images/3032ada4d17f90948d25fde1384ddf55b4ab5630bbd70263840c3ef608e0677d.jpg",
+        "table_caption": [
+            "Table 4: 1.3B LM results with different decoding algorithms. $\\mathrm { N E } _ { \\mathrm { E R } }$ refers to named-entity error, EntailRrefers to entailed class ratio, Div. refers to distinct 4-grams, and Rep. refers to repetition. $\\uparrow$ means the higher, the better, and $\\downarrow$ means the lower, the better. For factual-nucleus sampling, $p$ , $\\lambda$ and $\\omega$ are nucleus probability, decay factor, and decay lowerbounds respectively. See more results with different hyperparameters in Figure 2a and 2b. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=\"2\">Decoding</td><td colspan=\"4\">Factual Prompt</td><td colspan=\"4\">Nonfactual Prompt</td></tr><tr><td>NEER↓</td><td>EntailR↑</td><td>Div.个</td><td>Rep.</td><td>NEER↓</td><td>Entailr↑</td><td>Div.↑</td><td>Rep.↓</td></tr><tr><td>Greedy</td><td>39.9%</td><td>12.9%</td><td>0.05</td><td>33.1%</td><td>45.0%</td><td>8.8%</td><td>0.05</td><td>36.2%</td></tr><tr><td>Top-p 0.9</td><td>52.4%</td><td>2.9%</td><td>0.88</td><td>0.2%</td><td>56.8%</td><td>2.0%</td><td>0.89</td><td>0.3%</td></tr><tr><td>p1</td><td colspan=\"8\">Top-p + X-decay</td></tr><tr><td>0.910.9</td><td>41.1%</td><td>10.8%</td><td>0.43</td><td>30.7%</td><td>45.7%</td><td>6.8%</td><td>0.47</td><td>34.5%</td></tr><tr><td>0.910.5</td><td>39.9%</td><td>13.0%</td><td>0.08</td><td>33.1%</td><td>44.9%</td><td>9.1%</td><td>0.09</td><td>35.9%</td></tr><tr><td>p1入</td><td colspan=\"8\">Top-p + X-decay + p-reset</td></tr><tr><td>0.910.9</td><td>41.5%</td><td>10.3%</td><td>0.52</td><td>10.3%</td><td>45.4%</td><td>6.3%</td><td>0.57</td><td>9.1%</td></tr><tr><td>0.910.5</td><td>39.3%</td><td>12.8%</td><td>0.34</td><td>17.8%</td><td>44.5%</td><td>8.4%</td><td>0.45</td><td>18.9%</td></tr><tr><td>pl入lw</td><td></td><td></td><td></td><td></td><td>(factual-nucleus sampling)</td><td></td><td></td><td></td></tr><tr><td></td><td colspan=\"8\"> Top-p + X-decay + p-reset + w-bound</td></tr><tr><td>0.910.910.7</td><td>46.2%</td><td>5.0%</td><td>0.78</td><td>1.2%</td><td>52.2%</td><td>3.2%</td><td>0.80</td><td>0.5%</td></tr><tr><td>0.9 10.9 10.3</td><td>42.1%</td><td>10.1%</td><td>0.55</td><td>7.1%</td><td>46.5%</td><td>5.6%</td><td>0.59</td><td>6.4%</td></tr><tr><td>0.910.9 10.2</td><td>41.7%</td><td>9.9%</td><td>0.52</td><td>8.6%</td><td>45.6%</td><td>6.2%</td><td>0.56</td><td>7.6%</td></tr><tr><td>0.9 10.510.3</td><td>41.0%</td><td>12.2%</td><td>0.47</td><td>13.0%</td><td>46.0%</td><td>7.0%</td><td>0.51</td><td>12.7%</td></tr><tr><td>0.910.510.2</td><td>39.3%</td><td>12.8%</td><td>0.38</td><td>16.1%</td><td>45.2%</td><td>7.8%</td><td>0.42</td><td>16.9%</td></tr></table>",
+        "bbox": [
+            207,
+            154,
+            787,
+            416
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "• Named Entity Mix-up: Mixing up similar types of the named entity. For example, LM generated “The movie is based on the novel of the same name by Gayle Forman.” about a film called “The Best of Me”. However, the correct author’s name is “Nicholas Sparks”, not “Gayle Forman”. Note that Gayle Forman is also an American young adult fiction author who writes similar type of novels as Nicholas Sparks. ",
+        "bbox": [
+            192,
+            438,
+            825,
+            508
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "• Fabricated Fact: Fabricating some random facts. For example, “Samuel Witwer’s father is a Lutheran minister.” Note that, the pretraining corpus contains non-factual or fictional information, which can also contribute to such fabricated facts. ",
+        "bbox": [
+            192,
+            510,
+            823,
+            551
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Both error types can be viewed as wrong associations of entities that appear at different parts of the training corpus with similar context. Such behavior is unsurprising because these LMs are uniformly trained with the next subword prediction objective instead of a fact-related objective. ",
+        "bbox": [
+            176,
+            564,
+            823,
+            607
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/3f577455231c4c50fa3cbd037053ec5b7812d49ff5f4c4dd5ba5bd135f433c9c.jpg",
+        "image_caption": [
+            "Figure 2: Comparison between nucleus sampling (blue line) and factual-nucleus sampling (orange line). The $\\mathbf { X }$ -axis is named entity error $\\Nu \\mathrm { E } _ { \\mathrm { E R } }$ . The y-axes are diversity and repetition in (a) and (b) respectively. The lower the repetition, the better. It is evident that factual-nucleus sampling has better trade-offs between factuality and diversity/repetition. For a reference, the diversity score of randomly sampled 5000 Wikipedia documents is 0.767. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            191,
+            640,
+            790,
+            824
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "5 Factual-Nucleus Sampling ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            89,
+            426,
+            107
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "In this section, we propose a new sampling algorithm that achieves a better trade-off between generation quality and factuality than existing decoding algorithms. ",
+        "bbox": [
+            173,
+            117,
+            823,
+            145
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "5.1 Method ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            162,
+            267,
+            176
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "We hypothesize that the randomness of sampling is more harmful to factuality when it is used to generate the latter part of a sentence than the beginning of a sentence. There is no preceding text at the start of a sentence, so it is safe for LM to generate anything as long as it is grammatical and contextual. However, as the generation proceeds, the premise become more determined, and fewer word choices can make the sentence factual. Given the example “Samuel Witwer’s father is a Lutheran minister”, the beginning of the sentence “Samuel Witwer’s father is” is not nonfactual. However, the continuation of “Lutheran minister” makes the sentence nonfactual. Therefore, we introduce the factual-nucleus sampling algorithm that dynamically adapts the “nucleus” $p$ along the generation of each sentence. In factual-nucleus sampling, the nucleus probability $p _ { t }$ to generate the $t$ -th token within each sentence is, ",
+        "bbox": [
+            173,
+            184,
+            825,
+            323
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "equation",
+        "img_path": "images/8e023dbbb9171ee32633eff20f3f08eb08e7f39004e5ec0faf2e5736b1f5fae8.jpg",
+        "text": "$$\np _ { t } = \\operatorname* { m a x } \\{ \\omega , p \\times \\lambda ^ { t - 1 } \\} ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            411,
+            329,
+            583,
+            348
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "where $\\lambda$ is the decay factor for top- $p$ probability, and $\\omega$ lower bounds the decay of probability. Specifically, it has the following parts: ",
+        "bbox": [
+            174,
+            356,
+            825,
+            385
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "• $\\lambda$ -decay: Given that top- $p$ sampling pool is selected as a set of subwords whose cumulative probability exceeds $p$ , we gradually decay the $p$ value with decay factor $\\lambda$ at each generation step to reduce the “randomness” through time.   \n• $p$ -reset: The nucleus probability $p$ can quickly decay to a small value after a long generation. So, we reset the $p$ -value to the default value at the beginning of every new sentence in the generation (we identify the beginning of a new sentence by checking if the previous step has generated a full-stop). This reduces the unnecessary cost of diversity for any long generations.   \n• $\\omega$ -bound: If $\\lambda$ -decay is applied alone, the $p$ -value could become too small to be equivalent to greedy decoding and hurt diversity. To overcome this, we introduce a lower-bound $\\omega$ to limit how far $p$ -value can be decayed. ",
+        "bbox": [
+            192,
+            388,
+            826,
+            536
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "We will show the importance of each parts with ablation studies. ",
+        "bbox": [
+            173,
+            542,
+            596,
+            556
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "5.2 Result ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            570,
+            258,
+            584
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "We report our decoding experimental results with $1 . 3 \\mathrm { B } \\mathrm { L M } ^ { 7 }$ in Table 4. Additions of $\\lambda$ -decay helps improve top- $p \\ : 0 . 9$ factuality results – for instance, with decay rate $\\lambda = 0 . 5$ , there is $12 . 5 \\%$ drop in $\\mathrm { N E } _ { \\mathrm { E R } }$ and $1 0 . 1 \\%$ gain in EntailR. However, this affects the diversity and repetition to become similar to greedy decoding. $p$ -reset mitigates the repetition issue and improves diversity metric without losing much in factuality metric. The effect is more drastic for the $\\lambda = 0 . 5$ option, where it achieves 0.26 gains in diversity metric with negligible changes in factuality scores. By also adding $\\omega$ -bound, we obtain the anticipated factuality performance (i.e., similar to greedy decoding), with great improvement in generation quality over greedy; with $p { = } 0 . 9$ , $\\lambda { = } 0 . 9$ , $\\omega { = } 0 . 3$ , we achieve $\\times 1 1$ improvement in diversity and $\\times 4 . 6$ improvement in repetition over greedy. Although our factualnucleus sampling still under-performs top- $p 0 . 9$ in terms of diversity, we believe this is an acceptable trade-off to improve the factuality of LM for factually sensitive open-ended generation tasks. Our proposed decoding does not harm the sentence fluency; its perplexity do not exceed the perplexity of top-p. Refer to Appendix F for full perplexity results. ",
+        "bbox": [
+            174,
+            592,
+            825,
+            772
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "To further illustrate the underlying trade-off, we also compare the proposed factual-nucleus sampling against the nucleus sampling with lower $p$ values that are also expected to have lower randomness, thus less factual error, in generations. Specifically, we plotted results for nucleus sampling with $p = \\{ 0 . 9 , 0 . 7 , 0 . 6 , 0 . 5 , 0 . 4 , \\mathrm { { 0 . 3 } } \\}$ , and factual nucleus sampling with the following $p \\mid \\lambda \\mid \\bar { \\omega }$ choices: 0.9|0.9|0.7, 0.9|0.9|0.5, 0.9|0.9|0.4, 0.9|0.9|0.3, 0.9|0.7|0.3. The Fig 2a and $\\mathrm { F i g 2 b }$ respectively show that the factual nucleus sampling method has better trade-offs than top- $p$ in factuality-vs-diversity and factuality-vs-repetition. In other words, it always achieves better factuality score with the same level of diversity and repetition scores. ",
+        "bbox": [
+            173,
+            779,
+            825,
+            890
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "6 Factuality-Enhanced Continued Training ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            88,
+            550,
+            107
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "This section introduces factuality-enhanced method for continued training of LMs [30]. We introduce the TOPICPREFIX for better awareness of facts and the sentence completion loss as training objective. ",
+        "bbox": [
+            173,
+            117,
+            825,
+            145
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "6.1 Prepending TOPICPREFIX ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            156,
+            398,
+            172
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Unstructured factual knowledge typically exists at a document level (i.e., a group of factual sentences about an entity). This means that sentences can contain pronouns (e.g., she, he, it), making these sentences factually useless standalone. To illustrate with an example from Barack Obama’s Wikipedia page, “He previously served as a U.S. senator from Illinois from 2005 to $2 0 0 8 '$ cannot be a useful standalone fact because it is unclear who “He” is. Due to the GPU memory limit and computation efficiency, it is common to chunk documents in LM training corpus. This causes the “fragmentation” of information and leads to wrong associations of entities that appear in independent documents with similar contexts. As a remedy, we propose to prepend TOPICPREFIX to sentences in the factual documents to make each sentence serve as a standalone fact. In our experiments, we mainly utilize Wikipedia as the factual corpus and the Wikipedia document name as the TOPICPREFIX. ",
+        "bbox": [
+            173,
+            179,
+            826,
+            318
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "6.2 Sentence Completion Loss ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            330,
+            397,
+            344
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "We propose a sentence completion loss to address the incorrect association learned between entities. To explain our rationale, let us recall the nonfactual example from $\\ S 5$ : “Samuel Witwer’s father is a Lutheran minister”. This sentence is nonfactual because LM failed to generate factually correct information after “is”. In other words, LM failed to accurately complete the sentence given the generated context. One reason is that the LM is uniformly trained to predict each subword token within the sentence, when ensuring the correct prediction at the latter section of sentence is more critical for factuality. Therefore, we construct a sentence completion loss, which makes the LM focus on predicting the subwords later in the sentence. For implementation, we determine a pivot $t$ for each sentence, and then apply zero-masking for all token prediction losses before $t$ . This pivot is only required during training (i.e., no pivot needed during inference time). ",
+        "bbox": [
+            173,
+            352,
+            825,
+            491
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "We emphasize that this loss masking is different from the input token masking applied in BERT [73] or BART [76], and the LM is still trained in an autoregressive manner. Note that many BART-based summarization models are known to still suffer from factual errors, suggesting that masked prediction at the encoder level may not effectively transfer well to autoregressive text generation. ",
+        "bbox": [
+            174,
+            496,
+            825,
+            553
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "In this work, we explore three strategies (from simple to complex) to determine the pivot $t$ ",
+        "bbox": [
+            173,
+            559,
+            769,
+            573
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "• $S C _ { \\mathrm { H A L F } }$ : pivot $t = 0 . 5 \\times$ sentence-length.   \n• $S C _ { \\mathrm { R A N D O M } }$ : random pivot, e.g., $t \\sim$ uniform $[ 0 . 2 5 , 0 . 7 5 ] \\times$ sentence-length.   \n• $S C _ { \\mathrm { { R O O T } } }$ : pivot $t =$ position of ROOT (relation) from dependency parsing. ",
+        "bbox": [
+            191,
+            577,
+            689,
+            622
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Our experiments show that the simplest $S C _ { \\mathrm { H A L F } }$ performs on par with the complex ones (such as $S C _ { \\mathrm { R O O T } } )$ ), thus, we suggest future work to choose $S C _ { \\mathrm { H A L F } }$ strategy. ",
+        "bbox": [
+            176,
+            625,
+            825,
+            654
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "6.3 Results ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            665,
+            264,
+            679
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "The results are reported in Table 5, and experimental setups are reported in Appendix C. ",
+        "bbox": [
+            174,
+            688,
+            746,
+            702
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Inefficiency of Domain Adaptive Training The pre-training corpus of LM contains both factual texts (e.g., Wikipedia) and potentially nonfactual texts (e.g., rumors, fake news) 8. The nonfactual domain of the training corpus could be the problem. Thus, we conduct a baseline experiment that does domain-adaptive training with strictly factual domain text only (i.e., Wikipedia). Interestingly, we find that domain-adaptive training can hardly improve generation factuality. ",
+        "bbox": [
+            174,
+            707,
+            825,
+            777
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Effect of TOPICPREFIX Continued pre-training of 1.3B LM with TOPICPREFIX preprocessed Wikipedia alone can already improve the factuality, especially in terms of $\\mathrm { N E } _ { \\mathrm { E R } }$ . For example, it reduces the $\\mathrm { N E _ { E R } f r o m 4 2 . 1 \\% }$ to $2 7 . 6 \\%$ when we use the factual-nucleus decoding $( 0 . 9 \\mid 0 . 9 \\mid 0 . 3 )$ , which even outperforms the 1.3B with greedy decoding $( \\mathrm { N E } _ { \\mathrm { E R } } \\colon 2 7 . 6 \\%$ vs. $3 9 . 9 \\%$ ) with much less repetition $( 8 . 0 \\%$ vs. $3 3 . 1 \\%$ ). ",
+        "bbox": [
+            174,
+            784,
+            825,
+            853
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Effect of Sentence Completion Loss The proposed sentence completion loss further helps to improve the factuality, especially for the EntailR. For example, when one uses factual-nucleus decoding on trained 1.3B model, TOPICPREFIX $+ \\ S C _ { \\mathrm { H A L F } }$ can further improve EntailR from $8 . 7 \\%$ to $1 7 . 4 \\%$ than TOPICPREFIX alone, while reducing $\\Nu \\mathrm { E } _ { \\mathrm { E R } }$ from $2 7 . 6 \\%$ to $2 3 . 6 \\%$ . Note that the results show consistent improvement across different pivot selection strategies, suggesting that the sentence completion loss is robust. In particular, the simplest $S C _ { \\mathrm { H A L F } }$ performs as good as others or even better in terms of several metrics. Thus we recommend it as the default option. ",
+        "bbox": [
+            174,
+            859,
+            823,
+            888
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "table",
+        "img_path": "images/3b71d0d72f989503a027c0504b62706eb90fa0164aed8add6a781931bf6b323e.jpg",
+        "table_caption": [
+            "Table 5: Results for factuality enhanced training. The decoding settings are formatted as: nucleus probability $p$ decay rate $\\lambda$ , lower-bound $\\omega$ . "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=\"2\">Decoding (plλlw)</td><td colspan=\"4\">Factual Prompt</td><td colspan=\"4\">Nonfactual Prompt</td></tr><tr><td>NEER↓</td><td>EntailR↑</td><td>Div.</td><td>Rep.</td><td>NEER</td><td>EntailR</td><td>Div.</td><td>Rep.</td></tr><tr><td colspan=\"9\">Vanilla Pretrained LM (1.3B)</td></tr><tr><td>0.9</td><td>52.4%</td><td>2.9%</td><td>0.88</td><td>0.2%</td><td>56.8%</td><td>2.0%</td><td>0.89</td><td>0.3%</td></tr><tr><td>0.9 10.910.3</td><td>42.1%</td><td>10.1%</td><td>0.55</td><td>7.1%</td><td>46.5%</td><td>5.6%</td><td>0.59</td><td>6.4%</td></tr><tr><td colspan=\"9\">Factual Domain-Adaptive Training with Wikipedia (1.3B)</td></tr><tr><td>0.9</td><td>52.5%</td><td>2.8%</td><td>0.85</td><td>0.2%</td><td>55.8%</td><td>2.2%</td><td>0.86</td><td>0.1%</td></tr><tr><td>0.910.9 10.3</td><td>42.7%</td><td>7.1%</td><td>0.51</td><td>7.2%</td><td>48.2%</td><td>4.9%</td><td>0.56</td><td>6.0%</td></tr><tr><td colspan=\"9\">TOPICPREFIX (1.3B)</td></tr><tr><td>0.9 0.910.910.3</td><td>34.4%</td><td>4.2%</td><td>0.84</td><td>0.3%</td><td>36.2%</td><td>2.7%</td><td>0.85</td><td>0.2%</td></tr><tr><td></td><td>27.6%</td><td>8.7%</td><td>0.43</td><td>8.0%</td><td>30.5%</td><td>6.1%</td><td>0.47</td><td>6.9%</td></tr><tr><td colspan=\"9\">TOPICPREFIX + SCROOT (1.3B)</td></tr><tr><td>0.9 0.9 10.9 10.3</td><td>32.5% 24.7%</td><td>6.7% 15.8%</td><td>0.83 0.40</td><td>1.2% 13.6%</td><td>34.3% 27.6%</td><td>4.6% 9.1%</td><td>0.84 0.44</td><td>1.1% 13.7%</td></tr><tr><td colspan=\"9\">TOPICPREFIX+ SCRANDOM (1.3B)</td></tr><tr><td>0.9 0.9 10.9 10.3</td><td>32.0% 23.6%</td><td>7.9% 17.6%</td><td>0.81 0.39</td><td>1.2% 14.2%</td><td>34.2% 26.9%</td><td>5.5% 9.3%</td><td>0.83 0.42</td><td>1.1% 13.2%</td></tr><tr><td colspan=\"9\">TOPICPREFIX + SCHALF</td></tr><tr><td>0.9</td><td>31.6%</td><td>7.6% 17.4%</td><td>0.81 0.38</td><td>1.4% 14.4%</td><td>33.5% 27.2%</td><td>5.1% 10.2%</td><td>0.83 0.42</td><td>1.5% 13.1%</td></tr><tr><td colspan=\"9\">0.9 10.9 10.3 23.6% Vanilla Pretrained LM (530B)</td></tr><tr><td>0.9</td><td>33.3%</td><td>11.8%</td><td>0.90</td><td>0.1%</td><td>40.5%</td><td>7.25%</td><td>0.92</td><td>0.1%</td></tr><tr><td colspan=\"9\">TOPICPREFIX + SCHALF (530B)</td></tr><tr><td>0.9 0.9 10.9 10.3</td><td>18.3% 14.5%</td><td>19.3% 25.5%</td><td>0.68 0.33</td><td>0.1% 0.2%</td><td>21.7% 17.7%</td><td>13.7% 20.0%</td><td>0.68</td><td>0.1%</td></tr></table>",
+        "bbox": [
+            217,
+            126,
+            776,
+            565
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            589,
+            825,
+            659
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "530B vs 1.3B As expected, our method on 530B LM further reduces the factual errors and achieves the lowest $\\Nu \\mathrm { E } _ { \\mathrm { E R } }$ $( 1 4 . 5 \\% )$ and the highest EntailR $( 2 5 . 5 \\% )$ . Surprisingly, our method on 530B LM lead to less diverse generation than 1.3B LM despite the significant improvement in the generation quality (i.e., near perfect repetition scores $0 . 1 \\% 0 . 2 \\%$ . We conjecture that this is the trade-off between the factuality and diversity for 530B LM. ",
+        "bbox": [
+            174,
+            665,
+            825,
+            734
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "7 Conclusion ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            755,
+            299,
+            772
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "In this work, we establish a benchmark to measure and analyze factuality in open-ended text generation tasks. We propose factual-nucleus sampling that improves generation factuality at inference time, and the combination of sentence completion loss and TOPICPREFIX pre-processing that improves factuality with continued training. We demonstrate that our methods are effective in improving the factuality. Lastly, our results shed light on the existence of the trade-off between diversity and factuality. We strongly believe this is an important insight that will help researchers make a better-informed decision about their model design - i.e., appropriately prioritize the desirable attribute of their LM (factuality vs. diversity) according to the final goal of their task. Potential future work would be to reduce the degree of the observed trade-offs. ",
+        "bbox": [
+            174,
+            786,
+            826,
+            911
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "References   \n[1] Alec Radford, Jeffrey Wu, Rewon Child, David Luan, Dario Amodei, Ilya Sutskever, et al. Language models are unsupervised multitask learners. OpenAI blog, 2019.   \n[2] 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. JMLR, 2019.   \n[3] Tom Brown, Benjamin Mann, Nick Ryder, Melanie Subbiah, Jared D Kaplan, Prafulla Dhariwal, Arvind Neelakantan, Pranav Shyam, Girish Sastry, Amanda Askell, et al. Language models are few-shot learners. In NeurIPS, 2020.   \n[4] Shaden Smith, Mostofa Patwary, Brandon Norick, Patrick LeGresley, Samyam Rajbhandari, Jared Casper, Zhun Liu, Shrimai Prabhumoye, George Zerveas, Vijay Korthikanti, et al. Using DeepSpeed and Megatron to train Megatron-Turing NLG 530B, a large-scale generative language model. arXiv preprint arXiv:2201.11990, 2022.   \n[5] Rico Sennrich, Barry Haddow, and Alexandra Birch. Neural machine translation of rare words with subword units. In ACL, 2016.   \n[6] Jack W Rae, Sebastian Borgeaud, Trevor Cai, Katie Millican, Jordan Hoffmann, Francis Song, John Aslanides, Sarah Henderson, Roman Ring, Susannah Young, et al. Scaling language models: Methods, analysis & insights from training gopher. arXiv preprint arXiv:2112.11446, 2021.   \n[7] Reiichiro Nakano, Jacob Hilton, Suchir Balaji, Jeff Wu, Long Ouyang, Christina Kim, Christopher Hesse, Shantanu Jain, Vineet Kosaraju, William Saunders, et al. WebGPT: Browser-assisted question-answering with human feedback. arXiv preprint arXiv:2112.09332, 2021.   \n[8] Susan Zhang, Stephen Roller, Naman Goyal, Mikel Artetxe, Moya Chen, Shuohui Chen, Christopher Dewan, Mona Diab, Xian Li, Xi Victoria Lin, et al. Opt: Open pre-trained transformer language models. arXiv preprint arXiv:2205.01068, 2022.   \n[9] Rowan Zellers, Ari Holtzman, Hannah Rashkin, Yonatan Bisk, Ali Farhadi, Franziska Roesner, and Yejin Choi. Defending against neural fake news. In NeurIPS, 2019.   \n[10] Romal Thoppilan, Daniel De Freitas, Jamie Hall, Noam Shazeer, Apoorv Kulshreshtha, Heng-Tze Cheng, Alicia Jin, Taylor Bos, Leslie Baker, Yu Du, et al. LaMDA: Language models for dialog applications. arXiv preprint arXiv:2201.08239, 2022.   \n[11] Ziwei Ji, Nayeon Lee, Rita Frieske, Tiezheng Yu, Dan Su, Yan Xu, Etsuko Ishii, Yejin Bang, Andrea Madotto, and Pascale Fung. Survey of hallucination in natural language generation. arXiv preprint arXiv:2202.03629, 2022.   \n[12] Wojciech Krysci ´ nski, Bryan McCann, Caiming Xiong, and Richard Socher. Evaluating the factual ´ consistency of abstractive text summarization. In EMNLP, 2019.   \n[13] Joshua Maynez, Shashi Narayan, Bernd Bohnet, and Ryan McDonald. On faithfulness and factuality in abstractive summarization. In ACL, 2020.   \n[14] Esin Durmus, He He, and Mona Diab. FEQA: A question answering evaluation framework for faithfulness assessment in abstractive summarization. In ACL, 2020.   \n[15] Feng Nan, Cicero Nogueira dos Santos, Henghui Zhu, Patrick Ng, Kathleen McKeown, Ramesh Nallapati, Dejiao Zhang, Zhiguo Wang, Andrew O Arnold, and Bing Xiang. Improving factual consistency of abstractive summarization via question answering. In ACL-IJCNLP, 2021.   \n[16] Jun Yin, Xin Jiang, Zhengdong Lu, Lifeng Shang, Hang Li, and Xiaoming Li. Neural generative question answering. In IJCAI, 2016.   \n[17] Adam Roberts, Colin Raffel, and Noam Shazeer. How much knowledge can you pack into the parameters of a language model? arXiv preprint arXiv:2002.08910, 2020.   \n[18] Dan Su, Xiaoguang Li, Jindi Zhang, Lifeng Shang, Xin Jiang, Qun Liu, and Pascale Fung. Read before generate! faithful long form question answering with machine reading. In Findings in ACL, 2022.   \n[19] Amit Moryossef, Yoav Goldberg, and Ido Dagan. Step-by-step: Separating planning from realization in neural data-to-text generation. arXiv preprint arXiv:1904.03396, 2019.   \n[20] Tianyu Liu, Xin Zheng, Baobao Chang, and Zhifang Sui. Towards faithfulness in open domain table-to-text generation from an entity-centric view. In AAAI, 2021.   \n[21] Wenhao Yu, Chenguang Zhu, Zaitang Li, Zhiting Hu, Qingyun Wang, Heng Ji, and Meng Jiang. A survey of knowledge-enhanced text generation. arXiv preprint arXiv:2010.04389, 2020.   \n[22] Aleksandra Piktus, Fabio Petroni, Vladimir Karpukhin, Dmytro Okhonko, Samuel Broscheit, Gautier Izacard, Patrick Lewis, Barlas Oguz, Edouard Grave, Wen-tau Yih, et al. The web is your oyster–knowledge- ˘ intensive nlp against a very large web corpus. arXiv preprint arXiv:2112.09924, 2021.   \n[23] Peter West, Chris Quirk, Michel Galley, and Yejin Choi. Probing factually grounded content transfer with factual ablation. arXiv preprint arXiv:2203.10133, 2022.   \n[24] Sungjin Ahn, Heeyoul Choi, Tanel Pärnamaa, and Yoshua Bengio. A neural knowledge language model. arXiv preprint arXiv:1608.00318, 2016.   \n[25] Robert L Logan IV, Nelson F Liu, Matthew E Peters, Matt Gardner, and Sameer Singh. Barack’s wife hillary: Using knowledge-graphs for fact-aware language modeling. In ACL, 2019.   \n[26] Sebastian Borgeaud, Arthur Mensch, Jordan Hoffmann, Trevor Cai, Eliza Rutherford, Katie Millican, George van den Driessche, Jean-Baptiste Lespiau, Bogdan Damoc, Aidan Clark, et al. Improving language models by retrieving from trillions of tokens. arXiv preprint arXiv:2112.04426, 2021.   \n[27] Fabio Petroni, Aleksandra Piktus, Angela Fan, Patrick Lewis, Majid Yazdani, Nicola De Cao, James Thorne, Yacine Jernite, Vladimir Karpukhin, Jean Maillard, et al. Kilt: a benchmark for knowledge intensive language tasks. arXiv preprint arXiv:2009.02252, 2020.   \n[28] Kelvin Guu, Kenton Lee, Zora Tung, Panupong Pasupat, and Ming-Wei Chang. Realm: Retrievalaugmented language model pre-training. arXiv preprint arXiv:2002.08909, 2020.   \n[29] Ari Holtzman, Jan Buys, Li Du, Maxwell Forbes, and Yejin Choi. The curious case of neural text degeneration. In ICLR, 2020.   \n[30] Suchin Gururangan, Ana Marasovic, Swabha Swayamdipta, Kyle Lo, Iz Beltagy, Doug Downey, and ´ Noah A Smith. Don’t stop pretraining: adapt language models to domains and tasks. In ACL, 2020.   \n[31] Stephanie Lin, Jacob Hilton, and Owain Evans. TruthfulQA: Measuring how models mimic human falsehoods. In ACL, 2022.   \n[32] David R Krathwohl. A revision of bloom’s taxonomy: An overview. Theory into practice, 41(4):212–218, 2002.   \n[33] Fabio Petroni, Tim Rocktäschel, Patrick Lewis, Anton Bakhtin, Yuxiang Wu, Alexander H Miller, and Sebastian Riedel. Language models as knowledge bases? In EMNLP, 2019.   \n[34] Carlos Aspillaga, Marcelo Mendoza, and Alvaro Soto. Inspecting the concept knowledge graph encoded by modern language models. In Findings of ACL, 2021.   \n[35] Xuhui Zhou, Yue Zhang, Leyang Cui, and Dandan Huang. Evaluating commonsense in pre-trained language models. In AAAI, 2020.   \n[36] Zhengbao Jiang, Frank F Xu, Jun Araki, and Graham Neubig. How can we know what language models know? Transactions of the Association for Computational Linguistics, 2020.   \n[37] Zexuan Zhong, Dan Friedman, and Danqi Chen. Factual probing is [mask]: Learning vs. learning to recall. arXiv preprint arXiv:2104.05240, 2021.   \n[38] Yanai Elazar, Nora Kassner, Shauli Ravfogel, Abhilasha Ravichander, Eduard Hovy, Hinrich Schütze, and Yoav Goldberg. Measuring and improving consistency in pretrained language models. Transactions of the Association for Computational Linguistics, 9:1012–1031, 2021.   \n[39] Nicola De Cao, Wilker Aziz, and Ivan Titov. Editing factual knowledge in language models. In EMNLP, 2021.   \n[40] Joel Jang, Seonghyeon Ye, Sohee Yang, Joongbo Shin, Janghoon Han, Gyeonghun Kim, Stanley Jungkyu Choi, and Minjoon Seo. Towards continual knowledge learning of language models. arXiv preprint arXiv:2110.03215, 2021.   \n[41] Kevin Meng, David Bau, Alex Andonian, and Yonatan Belinkov. Locating and editing factual knowledge in GPT. arXiv preprint arXiv:2202.05262, 2022. ",
+        "bbox": [
+            171,
+            88,
+            828,
+            920
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            171,
+            64,
+            828,
+            921
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "[42] Ziqiang Cao, Furu Wei, Wenjie Li, and Sujian Li. Faithful to the original: Fact aware neural abstractive summarization. In Proceedings of the AAAI Conference on Artificial Intelligence, 2018. ",
+        "bbox": [
+            169,
+            92,
+            823,
+            118
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "[43] Yue Dong, Shuohang Wang, Zhe Gan, Yu Cheng, Jackie Chi Kit Cheung, and Jingjing Liu. Multi-fact correction in abstractive text summarization. In Proceedings of the 2020 Conference on Empirical Methods in Natural Language Processing, pages 9320–9331, 2020. ",
+        "bbox": [
+            174,
+            128,
+            820,
+            167
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "[44] Luyang Huang, Lingfei Wu, and Lu Wang. Knowledge graph-augmented abstractive summarization with semantic-driven cloze reward. In Proceedings of the 58th Annual Meeting of the Association for Computational Linguistics, 2020. ",
+        "bbox": [
+            173,
+            178,
+            821,
+            217
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "[45] Yichong Huang, Xiachong Feng, Xiaocheng Feng, and Bing Qin. The factual inconsistency problem in abstractive text summarization: A survey. arXiv preprint arXiv:2104.14839, 2021. ",
+        "bbox": [
+            169,
+            227,
+            823,
+            255
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "[46] Shuyang Cao and Lu Wang. Cliff: Contrastive learning for improving faithfulness and factuality in abstractive summarization. In Proceedings of the 2021 Conference on Empirical Methods in Natural Language Processing, pages 6633–6649, 2021. ",
+        "bbox": [
+            173,
+            265,
+            823,
+            304
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "[47] Chenguang Zhu, William Hinthorn, Ruochen Xu, Qingkai Zeng, Michael Zeng, Xuedong Huang, and Meng Jiang. Enhancing factual consistency of abstractive summarization. In Proceedings of the 2021 Conference of the North American Chapter of the Association for Computational Linguistics: Human Language Technologies, pages 718–733, 2021. ",
+        "bbox": [
+            173,
+            314,
+            826,
+            366
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "[48] Sihao Chen, Fan Zhang, Kazoo Sone, and Dan Roth. Improving faithfulness in abstractive summarization with contrast candidate generation and selection. In Proceedings of the 2021 Conference of the North American Chapter of the Association for Computational Linguistics: Human Language Technologies, pages 5935–5941, 2021. ",
+        "bbox": [
+            173,
+            376,
+            825,
+            429
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "[49] Sam Wiseman, Stuart Shieber, and Alexander Rush. Challenges in data-to-document generation. In Proceedings of the 2017 Conference on Empirical Methods in Natural Language Processing, pages 2253–2263. ACL, 2017. ",
+        "bbox": [
+            173,
+            438,
+            823,
+            478
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "[50] Feng Nie, Jin-Ge Yao, Jinpeng Wang, Rong Pan, and Chin-Yew Lin. A simple recipe towards reducing hallucination in neural surface realisation. In Proceedings of the 57th Annual Meeting of the Association for Computational Linguistics, pages 2673–2679. ACL, 2019. ",
+        "bbox": [
+            171,
+            488,
+            823,
+            527
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "[51] Yixuan Su, David Vandyke, Sihui Wang, Yimai Fang, and Nigel Collier. Plan-then-generate: Controlled data-to-text generation via planning. Findings of EMNLP, 2021. ",
+        "bbox": [
+            173,
+            537,
+            823,
+            565
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "[52] Peng Wang, Junyang Lin, An Yang, Chang Zhou, Yichang Zhang, Jingren Zhou, and Hongxia Yang. Sketch and refine: Towards faithful and informative table-to-text generation. ACL, 2021. ",
+        "bbox": [
+            171,
+            574,
+            823,
+            602
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "[53] Clément Rebuffel, Marco Roberti, Laure Soulier, Geoffrey Scoutheeten, Rossella Cancelliere, and Patrick Gallinari. Controlling hallucinations at word level in data-to-text generation. Data Mining and Knowledge Discovery, pages 318–354, 2022. ",
+        "bbox": [
+            174,
+            611,
+            825,
+            651
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "[54] Lei Shen, Haolan Zhan, Xin Shen, Hongshen Chen, Xiaofang Zhao, and Xiaodan Zhu. Identifying untrustworthy samples: Data filtering for open-domain dialogues with bayesian optimization. In Proceedings of the 30th ACM International Conference on Information & Knowledge Management, pages 1598–1608, 2021. ",
+        "bbox": [
+            174,
+            661,
+            826,
+            713
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "[55] Kurt Shuster, Spencer Poff, Moya Chen, Douwe Kiela, and Jason Weston. Retrieval augmentation reduces hallucination in conversation. In Findings of the Association for Computational Linguistics: EMNLP 2021. ACL, 2021. ",
+        "bbox": [
+            171,
+            723,
+            825,
+            762
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "[56] Hannah Rashkin, David Reitter, Gaurav Singh Tomar, and Dipanjan Das. Increasing faithfulness in knowledge-grounded dialogue with controllable features. In Proceedings of the 59th Annual Meeting of the Association for Computational Linguistics and the 11th International Joint Conference on Natural Language Processing, pages 704–718. ACL, 2021. ",
+        "bbox": [
+            173,
+            773,
+            826,
+            825
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "[57] Zeqiu Wu, Michel Galley, Chris Brockett, Yizhe Zhang, Xiang Gao, Chris Quirk, Rik Koncel-Kedziorski, Jianfeng Gao, Hannaneh Hajishirzi, Mari Ostendorf, et al. A controllable model of grounded response generation. In Proceedings of the AAAI Conference on Artificial Intelligence, pages 14085–14093, 2021. ",
+        "bbox": [
+            171,
+            835,
+            823,
+            876
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "[58] Nouha Dziri, Andrea Madotto, Osmar Zaiane, and Avishek Joey Bose. Neural path hunter: Reducing hallucination in dialogue systems via path grounding. EMNLP, 2021. ",
+        "bbox": [
+            169,
+            885,
+            825,
+            911
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "[59] Long Ouyang, Jeff Wu, Xu Jiang, Diogo Almeida, Carroll L Wainwright, Pamela Mishkin, Chong Zhang, Sandhini Agarwal, Katarina Slama, Alex Ray, et al. Training language models to follow instructions with human feedback. arXiv preprint arXiv:2203.02155, 2022. ",
+        "bbox": [
+            171,
+            92,
+            823,
+            131
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "[60] Krishna Pillutla, Swabha Swayamdipta, Rowan Zellers, John Thickstun, Sean Welleck, Yejin Choi, and Zaid Harchaoui. MAUVE: Measuring the gap between neural text and human text using divergence frontiers. In NeurIPS, 2021. ",
+        "bbox": [
+            173,
+            138,
+            821,
+            178
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "[61] Samuel Gehman, Suchin Gururangan, Maarten Sap, Yejin Choi, and Noah A Smith. Realtoxicityprompts: Evaluating neural toxic degeneration in language models. In Findings in EMNLP, 2020. ",
+        "bbox": [
+            173,
+            185,
+            820,
+            213
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "[62] Nils Reimers and Iryna Gurevych. Sentence-bert: Sentence embeddings using siamese bert-networks. arXiv preprint arXiv:1908.10084, 2019. ",
+        "bbox": [
+            171,
+            219,
+            823,
+            247
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "[63] Ben Goodrich, Vinay Rao, Peter J Liu, and Mohammad Saleh. Assessing the factual accuracy of generated text. In ACM SIGKDD, 2019. ",
+        "bbox": [
+            171,
+            255,
+            823,
+            281
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "[64] Feng Nan, Ramesh Nallapati, Zhiguo Wang, Cicero Nogueira dos Santos, Henghui Zhu, Dejiao Zhang, Kathleen McKeown, and Bing Xiang. Entity-level factual consistency of abstractive text summarization. In EACL, 2021. ",
+        "bbox": [
+            174,
+            289,
+            825,
+            328
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "[65] Bill MacCartney and Christopher D. Manning. Modeling semantic containment and exclusion in natural language inference. In Proceedings of the 22nd International Conference on Computational Linguistics (Coling 2008), pages 521–528, Manchester, UK, August 2008. Coling 2008 Organizing Committee. URL https://aclanthology.org/C08-1066. ",
+        "bbox": [
+            173,
+            337,
+            826,
+            388
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "[66] Tobias Falke, Leonardo FR Ribeiro, Prasetya Ajie Utama, Ido Dagan, and Iryna Gurevych. Ranking generated summaries by correctness: An interesting but challenging application for natural language inference. In Proceedings of the 57th Annual Meeting of the Association for Computational Linguistics, pages 2214–2220, 2019. ",
+        "bbox": [
+            173,
+            396,
+            825,
+            446
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "[67] Ondˇrej Dušek and Zdenek Kasner. Evaluating semantic accuracy of data-to-text generation with natural ˇ language inference. arXiv preprint arXiv:2011.10819, 2020. ",
+        "bbox": [
+            169,
+            455,
+            823,
+            482
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "[68] Nouha Dziri, Hannah Rashkin, Tal Linzen, and David Reitter. Evaluating groundedness in dialogue systems: The begin benchmark. arXiv preprint arXiv:2105.00071, 2021. ",
+        "bbox": [
+            173,
+            489,
+            823,
+            517
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "[69] 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. ",
+        "bbox": [
+            174,
+            523,
+            823,
+            564
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "[70] Adina Williams, Nikita Nangia, and Samuel Bowman. A broad-coverage challenge corpus for sentence understanding through inference. In NAACL, 2018. ",
+        "bbox": [
+            173,
+            571,
+            821,
+            598
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "[71] Jiwei Li, Michel Galley, Chris Brockett, Jianfeng Gao, and Bill Dolan. A diversity-promoting objective function for neural conversation models. In NAACL, 2016. ",
+        "bbox": [
+            174,
+            606,
+            823,
+            632
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "[72] Zhihong Shao, Minlie Huang, Jiangtao Wen, Wenfei Xu, and Xiaoyan Zhu. Long and diverse text generation with planning-based hierarchical variational model. arXiv preprint arXiv:1908.06605, 2019. ",
+        "bbox": [
+            174,
+            640,
+            823,
+            667
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "[73] Jacob Devlin, Ming-Wei Chang, Kenton Lee, and Kristina Toutanova. Bert: Pre-training of deep bidirectional transformers for language understanding. arXiv preprint arXiv:1810.04805, 2018. ",
+        "bbox": [
+            173,
+            674,
+            823,
+            702
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "[74] Boxin Wang, Wei Ping, Chaowei Xiao, Peng Xu, Mostofa Patwary, Mohammad Shoeybi, Bo Li, Anima Anandkumar, and Bryan Catanzaro. Exploring the limits of domain-adaptive training for detoxifying large-scale language models. In NeurIPS, 2022. ",
+        "bbox": [
+            173,
+            709,
+            823,
+            748
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "[75] Eric Wallace, Shi Feng, Nikhil Kandpal, Matt Gardner, and Sameer Singh. Universal adversarial triggers for attacking and analyzing nlp. In EMNLP, 2019. ",
+        "bbox": [
+            171,
+            756,
+            823,
+            784
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "[76] Mike Lewis, Yinhan Liu, Naman Goyal, Marjan Ghazvininejad, Abdelrahman Mohamed, Omer Levy, Ves Stoyanov, and Luke Zettlemoyer. Bart: Denoising sequence-to-sequence pre-training for natural language generation, translation, and comprehension. arXiv preprint arXiv:1910.13461, 2019. ",
+        "bbox": [
+            173,
+            790,
+            823,
+            830
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "[77] Mohammad Shoeybi, Mostofa Patwary, Raul Puri, Patrick LeGresley, Jared Casper, and Bryan Catanzaro. Megatron-lm: Training multi-billion parameter language models using model parallelism. arXiv preprint arXiv:1909.08053, 2019. ",
+        "bbox": [
+            173,
+            838,
+            823,
+            877
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "[78] James Thorne, Andreas Vlachos, Christos Christodoulopoulos, and Arpit Mittal. FEVER: a large-scale dataset for fact extraction and verification. In NAACL, 2018. ",
+        "bbox": [
+            171,
+            885,
+            825,
+            911
+        ],
+        "page_idx": 13
+    }
+]

parse/dev/N8MaByOzUfb/N8MaByOzUfb.md

@@ -0,0 +1,492 @@
+# NEW INSIGHTS ON REDUCING ABRUPT REPRESENTA-TION CHANGE IN ONLINE CONTINUAL LEARNING
+
+Lucas Caccia∗ McGill University, Mila Facebook AI Research
+
+Rahaf Aljundi Toyota Motor Europe
+
+Nader Asadi Concordia University, Mila
+
+Tinne Tuytelaars KU Leuven
+
+Joelle Pineau McGill University, Mila Facebook AI Research
+
+Eugene Belilovsky Concordia University, Mila
+
+# ABSTRACT
+
+In the online continual learning paradigm, agents must learn from a changing distribution while respecting memory and compute constraints. Experience Replay (ER), where a small subset of past data is stored and replayed alongside new data, has emerged as a simple and effective learning strategy. In this work, we focus on the change in representations of observed data that arises when previously unobserved classes appear in the incoming data stream, and new classes must be distinguished from previous ones. We shed new light on this question by showing that applying ER causes the newly added classes’ representations to overlap significantly with the previous classes, leading to highly disruptive parameter updates. Based on this empirical analysis, we propose a new method which mitigates this issue by shielding the learned representations from drastic adaptation to accommodate new classes. We show that using an asymmetric update rule pushes new classes to adapt to the older ones (rather than the reverse), which is more effective especially at task boundaries, where much of the forgetting typically occurs. Empirical results show significant gains over strong baselines on standard continual learning benchmarks 1
+
+# 1 INTRODUCTION
+
+Continual learning is concerned with building models that can learn and accumulate knowledge and skills over time. A continual learner receives training data sequentially, from a potentially changing distribution, over the course of its learning process. The distribution change might be either a shift in the input domain or new categories being learned. The main challenge is to design models that can learn how to use the new data and acquire new knowledge, while preserving or improving the performance on previously learned data. While different settings have been investigated of how new data are being received and learned, we focus on the challenging scenario of learning from an online stream of data with new classes being introduced at unknown points in time and where memory and compute constraints are applied on the learner. Additionally, we assume a shared output layer among all the learned classes (Aljundi et al., 2019b). This setting is different and harder than the conventional multi-head setting (Farquhar & Gal, 2018) where each new group of classes is considered as a new task with a dedicated head (classification layer), requiring a task oracle at test time to activate the correct head. The axes of our setting (online learning, no task boundary, no test time oracle, constant memory, and bounded compute) align with the main desiderata of continual learning as described in De Lange et al. (2019).
+
+Catastrophic forgetting (McCloskey & Cohen, 1989), where previous knowledge is overwritten as new concepts are learned, remains a key challenge in the online continual learning setting. To prevent forgetting, methods usually rely on storing a small buffer of previous training data and replaying samples from it as new data is learned. This can partially counteract catastrophic forgetting, but still tends to lead to large disruptions in accuracy, particularly at the initial task boundary or shift in distribution. Various works focus on studying which samples to store (Borsos et al., 2020; Aljundi et al., 2019b) or which samples to replay when receiving new data (Aljundi et al., 2019a). In this work, we direct our attention to the representations being learned and investigate how the features of previously learned classes change and drift over time.
+
+![](images/68d175c0aef3020adedfdacd3ae45ae5fab533000ef553db3c59d39500897f80.jpg)
+
+![](images/c8a034f37bb226e9e2d798543b4c58e511d34d24f250c3b627a11d1ae62d3b38.jpg)  
+Task 1 Accuracy during 2nd Task   
+Number of training steps on the 2nd task   
+Figure 1: (left) Analysis of representations with the first task’s class prototypes at a task boundary. Under ER when Task 2 begins, class 1 & 2 prototypes experience a large gradient and subsequent displacement caused by the close location of the unobserved sample representations, this leads to a significant drop in performance (right). Our proposed method (ACE) mitigates the representation drift issue and observes no performance decrease on a task switch.
+
+Consider the time point in a stream when a new class is introduced after previous classes have been well learned. If we consider the representation being learned, incoming samples from new classes are likely to be dispersed, potentially near and between representations of previous classes, while the representations of previous classes will typically cluster according to their class. Indeed, one might expect minimal changes to the learned representation of the previous classes, while the new classes samples are pushed away from the clusters of old class data. However, with a standard Experience Replay (ER) algorithm (Chaudhry et al., 2019), we observe that it is the representations of older classes that is heavily perturbed after just a few update steps when training on the new class samples. We hypothesize that the fundamental issue arises from the combination of: new class samples representations lying close to older classes and the loss structure of the standard cross entropy applied on a mix of seen and unseen classes. We illustrate the observed effect in Fig. 1 (left).
+
+This behavior is exacerbated especially in the regime of low buffer size. With larger replay buffers, the learner can recover knowledge about the prior classes over time, while with smaller buffers the initial disruptive changes in representations are challenging to correct. Indeed we illustrate this effect in Fig. 1 (right), we see that ER only recovers from the initial displacement given a much larger buffer size.
+
+In standard continual learning with replay (Aljundi et al., 2019a; Chaudhry et al., 2019) the same loss function is usually employed on both the newly received samples and the replayed samples. In contrast, we propose a simple and efficient solution to mitigate this representation drift by using separate losses on the incoming stream and buffered data. The key idea is to allow the representations of samples from new classes to be learned in isolation of the older ones first, by excluding the previously learned classes from the incoming data loss. The discrimination between the new classes and the older ones is learned through the replayed batches, but only after incoming data has been learned, added to the buffer, and made available for replay. To allow more direct control of the structure in representations we first consider a metric learning based loss for the incoming data, proposed in Khosla et al. (2020), where we propose to exclude samples of previously learned classes from the negative samples. We show that this type of negative selection is critical, and in contrast issues arise when negative examples are sampled uniformly from the buffer. These issues mimic those seen with standard losses in experience replay (ER) (Aljundi et al., 2019a). On the other hand we use a different loss on replay buffer data that is allowed to consider new and old classes, thereby consolidating knowledge across current and previous tasks. We call this overall approach ER with asymmetric metric learning (ER-AML).
+
+Since cross entropy losses can be more efficient in training for classification than metric learning and contrastive losses (avoiding positive and negative selection) and it is widely used in incremental and continual learning, we also propose an alternative cross entropy solution that similarly applies an asymmetric loss between incoming and replay data. Notably, the cross entropy applied to the incoming data only considers logits of classes of the incoming data. This variant, named ER with asymmetric cross-entropy (ER-ACE), along with ER-AML show strong performance, with little disruption at task boundaries Fig. 1 (right). We achieve state of the art results in existing benchmarks while beating different existing methods including the traditional ER solution with an average relative gain of $36 \%$ in accuracy. Our improvements are especially high in the small buffer regime. We also show that the mitigation of the old representation drift does not hinder the ability to learn and discriminate the new classes from the old ones. This property emerges from only learning the incoming data in isolation; as we will see, also isolating the rehearsal step (as in Ahn et al. (2020)) leads to poor knowledge acquisition on the current task. Furthermore we show our ER-ACE objective can be combined with existing methods, leading to additional gains. Finally, we take a closer look at the computation cost of various existing methods. We show that some methods, while obtaining good performance under standard evaluation protocols, fail to meet the computational constraints required in online CL. We provide an extensive evaluation of computational and memory costs across several baselines and metrics.
+
+To summarize, our contributions are as follows. We first highlight the problem of representation drift in the online continual learning setting. We identify a root cause of this issue through an extensive empirical analysis (Sec. 4.2). Second, we propose a new family of methods addressing this issue by treating incoming and past data asymmetrically (Sec. 4.1, 4.3) . Finally, we show strong gains over replay baselines in a new evaluation framework designed to monitor real world constraints (Sec. 5). To the best or our knowledge, we are the first to report the computation costs of different methods in our setting, revealing new insights.
+
+# 2 RELATED WORK
+
+Research on continual learning can be divided based on the sequential setting being targeted (see Zeno et al. (2018); van de Ven & Tolias (2019); Normandin et al. (2021); Lesort et al. (2021) for categorizations of the settings and De Lange et al. (2019) for a broad survey on continual learning). Earlier works consider the relaxed setting of task incremental learning (Aljundi et al., 2017; Serra\` et al., 2018; Li & Hoiem, 2016) where the data stream is divided into chunks of tasks and each task is learned offline with multiple iterations over the data of this task. While this setting is easier to handle as one task can be learned entirely, it limits the applicability of the solution.
+
+In this work, we consider the challenging setting of an online stream of non-i.i.d. data where changes can anytime occur in the input domain or in the output space. This more realistic setting has attracted increasing interest lately (Lopez-Paz et al., 2017; Aljundi et al., 2019a). Specifically, we study the single-head (or shared head) setting, where when queried, the learner is not told which task the sample belongs to (as opposed to the multi-head setting). The single-head assumption is further studied in task-agnostic continual learning settings (He et al., 2019; Caccia et al., 2020; Ostapenko et al., 2021; Von Oswald et al., 2021) in which the task-boundary assumption, amongst others, is also relaxed. Many of the solutions to the online continual learning problem rely on the use of a buffer formed of previous memories which are replayed alongside new data during the learning process. Several works (Borsos et al., 2020; Chaudhry et al., 2019; Aljundi et al., 2019b) propose solutions to select which samples should be stored, or retrieved for replay (Aljundi et al., 2019a), or both (Shim et al., 2021). Lopez-Paz et al. (2017); Chaudhry et al. use replay to perform constrained optimization, limiting interference with previous tasks as new ones are learned. Our work, on the other hand, focuses on the appropriate loss function in this context. Tang & Matteson (2020) propose a graph-based approach that capture pairwise similarities between samples. Dark Experience Replay (DER) (Buzzega et al., 2020) suggests an alternative replay loss. Samples are stored along with their predicted logits and once replayed the current model is asked to keep its output close to the previously recorded logits. While the method is simple and effective it is worth noting that it relies heavily on data augmentation. Our work is orthogonal and can be combined with DER as we show in Sec. D. Finally, concurrent work (Mai et al., 2021) also use a contrastive loss for online continual learning, but not in an asymmetric fashion.
+
+In our work we also investigate the underlying causes for performance degradation in replay-based methods. Related to this study are works in the class incremental setting, where similar to our case a shared output layer is used, but classes are learned offline. Works in this area address the implicit class imbalance issue occurring when new classes are learned alongside replayed data. Zhao et al.
+
+(2019) proposes to correct last layer weights after a group of classes is learned via adjusting the weights norm. Wu et al. (2019) suggests to deploy extra additional parameters in order to linearly correct the “bias” in the shared output layer. Those parameters are learned at the end of each training phase. Hou et al. (2019) considers addressing this imbalance through applying cosine similarity based loss as opposed to the typical cross entropy loss along with a distillation loss and a margin based loss with negatives mining to preserve the feature of previous classes. Recently, Ahn et al. (2020) propose to learn the incoming tasks and the previous tasks separately. They use a masked softmax loss for the incoming and rehearsal data, to counter the class imbalance. All the methods highlighted above operate in the offline setting, where data from the current task can be revisited as needed making the disruptive issues emphasized at the task boundary less critical. In this paper, we focus on the online setting, with potentially overlapping tasks. As we will see, work by Ahn et al. (2020) developed to counter class imbalance, can inhibit learning of the current task in the online setting (see Appendix B). Lastly, Zeno et al. (2018) uses a logit masking related to our method but their context is based on the multi-head setting, and does not consider replay based methods, where learning across tasks occurs. Their goal is to activate only the head of which the samples within the new batch belong to. However, our approach is more general and it applies to the single head setting (where we have a single output layer for all classes, and no task oracle.)
+
+# 3 LEARNING SETTING AND NOTATION
+
+We consider the setting where a learner is faced with a possibly never-ending stream of data. At every time step, a labelled set of examples $( \mathbf { X } ^ { i n } , \mathbf { Y } ^ { i n } )$ drawn from a distribution $D _ { t }$ is received. However, the distribution $D _ { t }$ itself is sampled at each timestep and can suddenly change to $D _ { t + 1 }$ , when a task switch occurs. The learner is not explicitly told when a task switch happens, nor can it leverage a task identifier during training or evaluation. We note that this definition generalizes task-incremental learning, where each task is seen one after the other. In this scenario, given $T$ tasks to learn, $D _ { t }$ changes $T - 1$ times over the full steam, yielding $T$ locally i.i.d learning phases. We also explore in this paper a more general setting without the notion of clearly delineated tasks (Aljundi et al., 2018; Chen et al., 2020a), where the data distribution gradually changes over time.
+
+Given a model $f _ { \boldsymbol { \theta } } ( \boldsymbol { x } )$ representing a neural network architecture with parameters $\theta$ , we want to minimize the classification loss $\mathcal { L }$ on the newly arriving data batch while not negatively interfering with the previously learned classes (i.e. increasing the classification loss). A simple and efficient approach to achieve this is to replay stored samples from a fixed size memory, $\mathcal { M }$ , in conjunction with the incoming data (Chaudhry et al., 2019; Rolnick et al., 2018). The core of our approach is that instead of treating the replayed batch and the incoming one similarly and naively minimizing the same loss, we opt for a specific loss structure on the incoming batch that would limit the interference with the previously well learned classes. We approach this by allowing the features of the newly received classes in the incoming data to be initially learned in isolation of the older classes. We first present our idea based on a metric learning loss and then generalize to the widely deployed cross-entropy loss.
+
+# 4 METHODS
+
+# 4.1 A DISTANCE METRIC LEARNING APPROACH FOR REDUCING DRIFT (ER-AML)
+
+In order to allow fine-grained control of which samples will be pushed away from other samples given an incoming batch, we propose to apply, on the incoming data, a metric learning based loss from Khosla et al. (2020). Related loss functions have recently popularized in the self supervised learning literature (Chen et al., 2020b). We combine this in a holistic way with a cross-entropy type loss on the replay data. This allows us to control the representation drift of old classes while maintaining strong classification performance. Note that if a metric learning loss is used alone we needs to perform predictions using a Nearest Class Means Rebuffi et al. (2017) approach, which we show is computationally expensive in the online setting.
+
+Given an input data point $x$ , we consider the function $f _ { \boldsymbol { \theta } } ( \boldsymbol { x } )$ mapping $x$ to its hidden representation before the final linear projection. We denote the incoming $N$ datapoints by $\mathbf { X } ^ { i n }$ and data replayed from the buffer by ${ \bf X } ^ { b { \bf \ddot { f } } }$ . We use the following loss, denoted SupCon (Khosla et al., 2020), on the
+
+incoming data $\mathbf { X } ^ { i n }$ .
+
+$$
+\mathcal { L } _ { 1 } ( \mathbf { X } ^ { i n } ) = - \sum _ { \mathbf { x } _ { i } \in \mathbf { X } _ { i n } } \frac { 1 } { | P ( \mathbf { x } _ { i } ) | } \sum _ { \mathbf { x } _ { p } \in P ( \mathbf { x } _ { i } ) } \log \frac { \mathrm { s i m } \left( f _ { \boldsymbol { \theta } } ( \mathbf { x } _ { p } ) , f _ { \boldsymbol { \theta } } ( \mathbf { x } _ { i } ) \right) } { \sum _ { \mathbf { x } _ { n } \in N \cup P ( \mathbf { x } _ { i } ) } \mathrm { s i m } \left( f _ { \boldsymbol { \theta } } ( \mathbf { x } _ { n } ) , f _ { \boldsymbol { \theta } } ( \mathbf { x } _ { i } ) \right) }
+$$
+
+where $\begin{array} { r } { \scriptstyle \mathtt { s i m } ( a , b ) \ = \ \exp ( \frac { a ^ { T } b } { \tau \| a \| \| b \| } ) } \end{array}$ computes the exponential cosine similarity between two vectors, with scaling factor $\tau$ (Qi et al., 2018; He et al., 2020). Here we denote the incoming data $\mathbf { x } _ { i } \in \mathbf { X } ^ { i n }$ . We use the $P$ and $N$ to denote the set of positive and negatives with respect to $\mathbf { x } _ { i }$ and the positive examples $x _ { p }$ are selected from the examples in $\mathbf { X } ^ { i n } \cup \mathcal { M }$ , which are from the same classes as $\mathbf { x } _ { i }$ . In the sequel we will consider ${ \bf x } _ { n }$ selected from $\mathbf { X } ^ { i n } \cup \mathcal { M }$ in two distinct ways: (a) from a mix of current and previous classes and (b) only from
+
+Input: Learning rate $\alpha$   
+Initialize: Memory $\mathcal { M }$ ; Model Params $\theta$ do Receive $\mathbf { X } ^ { i n }$ //Receive from stream $\mathbf { X } _ { p o s } , \mathbf { X } _ { n e g } \sim \mathrm { F E T C H P O S N E G } ( \mathbf { X } ^ { i n } , \mathcal { M } )$ $\mathbf { X } ^ { b f } \sim \mathbf { S A M P L E } ( \mathcal { M } )$ //Sample buffer $\mathcal { L } = \gamma \mathcal { L } _ { 1 } ( \mathbf { X } ^ { i n } , \mathbf { X } _ { p o s } , \mathbf { X } _ { n e g } ) + \mathcal { L } _ { 2 } ( \mathbf { X } ^ { b f } )$ $S G D ( \nabla \mathcal { L } , \theta , \alpha )$ //Param Update RESERVOIRUPDATE $( { \mathcal { M } } , \mathbf { X } ^ { i n } )$ //Save   
+while The stream has not ended
+
+classes of the $\mathbf { X } ^ { i n }$ . Note that this implicitly learns a distance metric where samples of the same class lie close by. For the rehearsal step, we apply a modified cross-entropy objective as per Qi et al. (2018) which allows us to link the similarity metric from above to the logits.
+
+$$
+\mathcal { L } _ { 2 } ( \mathbf { X } ^ { b f } ) = - \sum _ { x \in \mathbf { X } _ { b f } } \log \frac { s \mathrm { i } \mathrm { m } \big ( \mathbf { w } _ { c ( x ) } , f _ { \theta } ( \mathbf { x } ) \big ) } { \sum _ { c \in C _ { a l l } } \mathrm { s i m } \big ( \mathbf { w } _ { c } , f _ { \theta } ( \mathbf { x } ) \big ) }
+$$
+
+where $C _ { a l l }$ the set of all classes observed, and $c ( x )$ denotes the label of $x$ . The above formulation allows us to interpret the rows of the final projection $\{ \mathbf { w } _ { c } \} _ { c \in C _ { a l l } }$ as class prototypes and inference to be performed without need for nearest neighbor search. We combine the loss functions on the incoming and replay data
+
+$$
+\mathcal { L } ( \mathbf { X } ^ { i n } \cup \mathbf { X } ^ { b f } ) = \gamma \mathcal { L } _ { 1 } ( \mathbf { X } ^ { i n } ) + \mathcal { L } _ { 2 } ( \mathbf { X } ^ { b f } )
+$$
+
+We refer to this approach as Experience Replay with Asymmetric Metric Learning (ER-AML). We describe the full rehearsal procedure with ER-AML in Algo 1. Note the buffer may contain samples with the same classes as the incoming data stream. The subroutine FetchPosNeg is used to find one positive and negative sample per incoming datapoint in $\mathbf { X } ^ { i n }$ , which can reside in either the buffer memory $\mathcal { M }$ or in $\bar { \mathbf X } ^ { i n }$ .
+
+# 4.2 NEGATIVE SELECTION AFFECTS REPRESENTATION DRIFT
+
+The selection of negatives for the proposed loss $\mathcal { L }$ can heavily influence the representation of previously learned classes and is analogous to the key issues faced in the regular replay methods where cross entropy loss is applied to both incoming and replay data. A typical approach in this loss for classification may be to select the negatives from any other class (Hoffer & Ailon, 2015). However this becomes problematic in the continual learning setting as the old samples will be too heavily influenced by the poorly embedded new samples that lie close to the old sample representations. To illustrate what is going on
+
+![](images/3de26c7a00e811564236c7a5477efca23a638b1376646e146ef0a0a8396260de.jpg)  
+Figure 2: Buffer displacement in a 5 task stream. Background shading denotes different tasks.
+
+in the feature space, consider the case of a ER-AML’s $\mathcal { L } _ { 1 }$ term, which explicitly controls distances between sample representations. $\mathcal { L } _ { 1 }$ considers the incoming batch samples (containing new classes) as anchors. As the representations from these classes haven’t been learned, anchors may end up placed near or in-between points from previous classes (analogous to the illustration in Figure 1). Since the previous classes samples will be clustered together, if we use them as negatives for the incoming sample anchors, the gradients magnitude of the positive term will be out-weighted by the negative terms coming from the new class samples, similar to what is observed in Figure 1. In this case there is a sharp change in gradients norms of the loss w.r.t. the features of previous classes, as we illustrate in Appendix E, which leads to a large change in the representation at the task boundary (and subsequently poor performance). On the other hand if we use only incoming batch examples as negatives we can avoid this excessive representation drift. We illustrate this in Figure 2 by showing the representations drift at the task boundaries for ER-AML when using negative samples from all classes and when using only classes in the incoming batch. In the context of the model under consideration we measure the one iteration representation drift of a sample $x$ as $\| f _ { \theta ^ { t } } ( x ) - f _ { \theta ^ { t + 1 } } ( x ) \|$ , the output of the network being normalized. We observe that naively applying the proposed loss results in large changes of the learned representation. On the other hand when allowing only negatives from classes in the incoming batch, we see a reduction in this representation drift. In the Appendix 7 we further demonstrate that the accuracy of models trained using ER-AML with only incoming batch negatives can improve the continual learning system performance by a large margin. We emphasize the that ER-AML with all negatives and the regular ER method used for online continual learning suffer from a similar issue and thus lead to similar poor performances, with appropriate negative selection resolving the problem.This is further emphasized in Appendix $_ \mathrm { H }$ where we observe similar poor drift behavior for ER.
+
+# 4.3 CROSS-ENTROPY BASED ALTERNATIVE (ER-ACE)
+
+Having demonstrated the effect of controlling the incoming batch loss in avoiding a drastic representation drift, we now extend it to be applicable to the standard cross-entropy loss typically studied in ER (Aljundi et al., $2 0 1 9 \mathrm { a }$ ; Chaudhry et al., 2019). Given an incoming data batch, consider $C _ { o l d }$ the set of previously learned classes and $C _ { c u r r }$ the set of classes observed in the current incoming mini-batch. Denoting $C$ the set of classes included in the cross-entropy loss, we define the $\mathcal { L } _ { c e } ( \mathbf { X } , C )$ cross-entropy loss as: Lce(X, C) = − Px∈X log Psim(wc(x),fθ(x))c∈C sim(wc,fθ(x)) where $C \subset C _ { a l l }$ denotes the classes used to compute the denominator. We note that restricting the classes used in the denominator has an analogous effect to restricting the negatives in the contrastive loss. Consider the gradient for a single datapoint $x$ , ∂Lce(x,C)∂fn = W(\~p − \~y)  1\~y∈C 
. Here \~p denotes the softmax output of the network, $\vec { y }$ a one-hot target, $\mathbb { 1 } _ { \vec { y } \in C }$ a binary vector masking out classes not in $C$ , and W the matrix with all class prototypes $\{ \mathbf { w } _ { c } \} _ { c \in C _ { a l l } }$ . When the loss is applied in the batch setting, it follows that only prototypes whose labels are in $C$ will serve roles analogous to positives and negatives in the contrastive loss. We can then achieve a similar control as the metric learning approach on the learned representations.
+
+Now, our loss applied at each step would be:
+
+$\begin{array} { r } { \mathcal { L } _ { a c e } \big ( \mathbf { X } ^ { b f } \cup \mathbf { X } ^ { i n } \big ) = \mathcal { L } _ { c e } \big ( \mathbf { X } ^ { b f } , C _ { o l d } \cup C _ { c u r r } \big ) + \mathcal { L } _ { c e } \big ( \mathbf { X } ^ { i n } , C _ { c u r r } \big ) } \end{array}$ where $C _ { c u r r }$ denotes the set of the classes represented in the incoming batch and $C _ { o l d }$ denotes previously seen classes that are not presented in the incoming batch, those that we want to preserve their representation. Note this is a straightforward procedure and induces no additional computational overhead. We refer to it as Experience Replay with Asymmetric Cross-Entropy (ER-ACE).
+
+# 5 EXPERIMENTS
+
+We have highlighted the issue of abrupt representation change when new classes are introduced, and propose two methods that address this issue. We now demonstrate that mitigating drift directly leads to better performance on standard online continual learning benchmarks. As in Lopez-Paz et al. (2017); Aljundi et al. (2019a); Chaudhry et al. (2019) we use a reduced Resnet-18 for our experiments, and leave the batch size and the rehearsal batch size fixed at $I O$ . This allows us to fairly compare different approaches, as these parameters have a direct impact on the computational cost of processing a given stream.
+
+# 5.1 DATASETS
+
+All benchmarks are evaluated in the single-head setting, i.e. task descriptors are not provided to the model at test time, hence the model performs $N$ -way classification where $N$ is the total amount of classes seen.
+
+Split CIFAR-10 partitions the dataset into 5 disjoint tasks containing two classes each (as in Aljundi et al. (2019a); Shim et al. (2020))
+
+Split CIFAR-100 comprises 20 tasks, each containing a disjoint set of 5 labels. We follow the split in Chaudhry et al. (2019). All CIFAR experiments process $3 2 \times 3 2$ images.
+
+Split MiniImagenet splits the MiniImagenet dataset into 20 disjoint tasks of 5 labels each. Images are $8 4 \times 8 4$ .
+
+# 5.2 BASELINES
+
+We focus our evaluation on replay-based methods, as they have been shown to outperform other approaches in the online continual learning setting Chaudhry et al. (2019); Aljundi et al. (2019a); Ji et al. (2020). We keep buffer management constant across methods : all samples are kept or discarded according to Reservoir Sampling Vitter (1985). We consider the following state-of-the-art baselines:
+
+ER: Experience Replay with a buffer of a fixed size. Unlike Aljundi et al. (2019a), we do not leverage the task identifier during training to ensure that rehearsal samples belong to previous classes.
+
+iCaRL Rebuffi et al. (2017) A distillation loss alongside binary cross-entropy is used during training. Samples are classified based on closest class prototypes, obtained from recomputing and averaging buffered data representations.
+
+MIR Aljundi et al. (2019a) selects for replay samples interfering the most with the incoming data batch.
+
+$\mathbf { D E R + + }$ Buzzega et al. (2020) uses a distillation loss on the logits to ensure consistency over time.
+
+SS-IL Ahn et al. (2020) learns both the current task loss and the replay loss in isolation of each other.   
+An additional task-specific distillation is used on the rehearsal data.
+
+GDUMB Prabhu et al. (2020) performs offline training on the buffer with unlimited computation and unrestricted use of data augmentation at the end of the task sequence.
+
+iid: The learner is trained with a single pass on the data, in a single task containing all the classes. We also consider a version of this baseline using a similar compute budget as replay methods $( \ddot { \bf u } \dot { \bf d } + + )$
+
+We note additional baselines such as Lopez-Paz et al. (2017); Chaudhry et al. were shown to perform poorly in this setting by prior work Buzzega et al. (2020) and are thus left out for clarity.
+
+# 5.3 EVALUATION METRICS AND CONSIDERATIONS
+
+Our evaluation includes the metrics and experimental settings used in previous works on online continual learning with a single-head (Aljundi et al., 2019a; Ji et al., 2020; Shim et al., 2020). We provide extra emphasis on anytime evaluation and comparisons of the computation time per incoming batch. We also consider several additional settings in terms of computation and use of image priors.
+
+Anytime evaluation A critical component of online learning is the ability to use the learner at any point De Lange et al. (2019) . Although most works in the online (one-pass through the data) setting report results throughout the stream Lopez-Paz et al. (2017); Chaudhry et al.; Aljundi et al. (2019b), several prior works have reported the final accuracy as a proxy Aljundi et al. (2019a); Shim et al. (2020). However a lack of anytime evaluation opens the possibility to exploit the metrics by proposing offline learning baselines that are inherently incompatible with anytime evaluation Prabhu et al. (2020).
+
+In order to make sure that learners are indeed online learners, we evaluate them throughout the stream. We define the Anytime Accuracy at time $k$ $( A A _ { k } )$ as the average accuracy on the test sets of all distributions seen up to time $k$ . If the learning experience lasts $T$ steps, then $A A _ { T }$ is equivalent to the final accuracy. Finally, we report the Averaged Anytime Accuracy (AAA) (Caccia et al., 2020), which measures how well the model performed over the learning experience
+
+$$
+\operatorname { A A A } = { \frac { 1 } { T } } \sum _ { t = 1 } ^ { T } ( A A ) _ { t } .
+$$
+
+Computation and Memory Constraints While memory constraints are well documented in previous work, careful monitoring of computation is often overlooked; some methods can indeed hide considerable overhead which can make the comparison across methods unfair. On the other hand this is critical to the use cases of online continual learning. To remedy this, we report for each method the total number of FLOPs used for training. While we cannot fix this quantity as we can for memory (since different methods require different computations), this will shed some light on how different methods compare. Note that we also include in this total any inference overhead required by the models; Nearest Class Mean (NCM) classifiers must compute class prototypes before inference for example. We add this cost every time the model is queried to measure its Anytime Accuracy. Let
+
+$$
+\mathbf { M e m } = \frac { 1 } { T } \sum _ { t = 1 } ^ { T } | \theta _ { t } | + | \mathcal { M } _ { t } | , \quad \mathbf { C o m p } = \sum _ { t = 1 } ^ { T } \mathcal { O } ( m ( \cdot ; \theta _ { t } ) ) ,
+$$
+
+where $\mathcal { O } ( m ( \cdot ; \theta _ { t } ) )$ denotes the number of FLOPs used at time $t$ . Since the same backbone and buffer is used for all methods in this paper, we will focus our constraint analysis on computation
+
+Table 1: split CIFAR-10 results. $\dagger$ indicates the method is leveraging a task identifier at training time. For methods whose compute depend on the buffer size, we report min and max values. We evaluate the models every 10 updates. Results within error margin of the best result are bolded.   
+
+<table><tr><td rowspan="2">Method</td><td rowspan="2">Data Aug.</td><td colspan="2">M=5</td><td colspan="2">M=20</td><td colspan="2">M=100</td><td rowspan="2">Train TFLOPs</td><td rowspan="2">Mem. (Mb)</td></tr><tr><td>AAA</td><td>Acc</td><td>AAA</td><td>Acc</td><td>AAA</td><td>Acc</td></tr><tr><td>iid</td><td>X</td><td></td><td>62.7±0.7 72.9±0.7</td><td>1</td><td>62.7±0.7 72.9±0.7</td><td>-</td><td>62.7±0.7 72.9±0.7</td><td>8 16</td><td>4 4</td></tr><tr><td>jid+± DER++</td><td></td><td>50.7±1.1</td><td>31.8±0.9</td><td>55.6±1.2</td><td>39.3±1.0</td><td>60.1±1.3</td><td>52.3±1.1</td><td>24</td><td>(4,7)</td></tr><tr><td>ER</td><td></td><td>40.0±0.8 45.6±1.1</td><td>19.7±0.3 28.4±1.0</td><td>45.2±1.3 55.9±1.2</td><td>26.7±1.0 40.3±0.6</td><td>55.4±1.4 60.3±1.3</td><td>38.7±0.8 49.4±1.3</td><td>17</td><td>(4,7)</td></tr><tr><td>iCaRLt</td><td></td><td>47.0±0.8 49.1±1.0</td><td>30.6±0.8 33.4±1.0</td><td>55.1±0.7 54.4±0.7</td><td>41.7±0.6 39.2±0.8</td><td>59.3±0.6 56.9±0.7</td><td>45.1±0.6 42.3±0.8</td><td>(21,47)</td><td>(8,11)</td></tr><tr><td>MIRt</td><td>X</td><td>39.3±1.0 44.9±0.9</td><td>19.7±0.5 29.8±0.8</td><td>44.7±1.1 49.7±1.0</td><td>29.7±0.6 41.8±0.6</td><td>53.8±1.7 54.6±1.4</td><td>43.3±1.0 49.3±0.6</td><td>41</td><td>(4,7)</td></tr><tr><td>SS-IL+</td><td>X √</td><td>42.6±1.7 41.1±1.6</td><td>29.6±0.4 31.6±0.5</td><td>44.8±1.8 47.0±1.2</td><td>35.1±0.9 38.3±0.4</td><td>48.1±2.2 48.1±1.7</td><td>41.1±0.4 47.5±0.7</td><td>19</td><td>(8,11)</td></tr><tr><td>ER-ACE (ours)</td><td></td><td>53.1±1.0 52.6±0.9</td><td>35.6±1.0 35.1±0.8</td><td>58.0±0.7 56.4±1.0</td><td>42.6±0.7 43.4±1.6</td><td>61.9±0.9 61.7±0.9</td><td>52.2±0.7 53.7±1.1</td><td>17</td><td>(4,7)</td></tr><tr><td>ER-AML</td><td>X</td><td>49.4±1.0</td><td>30.9±0.8</td><td>57.0±1.0</td><td>39.2±1.0</td><td>63.3±1.0</td><td>52.2±1.1</td><td>17</td><td>(4,7)</td></tr><tr><td>(ours) GDUMB</td><td></td><td>50.4±1.3 0±0.0</td><td>36.4±1.4 35.0±0.6</td><td>56.8±1.0 0±0.0</td><td>47.7±0.7 45.8±0.9</td><td>62.0±0.9 0±0.0</td><td>55.7±1.3 61.3±1.7</td><td>(43,853)</td><td>(11,14)</td></tr></table>
+
+<table><tr><td>Method</td><td>AAA</td><td>Acc.</td><td>Train TFLOPs</td><td>Mem. (Mb.)</td><td>AAA</td><td>Acc.</td><td>Train TFLOPs</td><td>Mem. (Mb.)</td></tr><tr><td>iid</td><td></td><td>19.8±0.3</td><td>9</td><td>4</td><td></td><td>16.7±0.5</td><td>59</td><td>4</td></tr><tr><td>iid++</td><td></td><td>28.3±0.3</td><td>17</td><td>4</td><td></td><td>25.0±0.8</td><td>118</td><td>4</td></tr><tr><td>DER++</td><td>23.3±0.5</td><td>15.1±0.4</td><td>25</td><td>36</td><td>21.7±0.6</td><td>12.9±0.3</td><td>176</td><td>217</td></tr><tr><td>ER</td><td>24.2±0.6</td><td>19.8±0.4</td><td>17</td><td>35</td><td>26.2±0.8</td><td>18.2±0.5</td><td>118</td><td>216</td></tr><tr><td>iCaRLt</td><td>26.3±0.3</td><td>17.3±0.2</td><td>294</td><td>39</td><td>24.4±0.4</td><td>17.1±0.1</td><td>2097</td><td>220</td></tr><tr><td>MIRt</td><td>23.6±0.8</td><td>20.6±0.5</td><td>41</td><td>35</td><td>27.2±0.7</td><td>20.2±0.8</td><td>294</td><td>216</td></tr><tr><td>SS-ILt</td><td>31.5±0.5</td><td>25.0±0.3</td><td>19</td><td>39</td><td>29.7±0.6</td><td>23.5±0.5</td><td>137</td><td>220</td></tr><tr><td>ER-ACE (ours)</td><td>32.7±0.5</td><td>25.8±0.4</td><td>17</td><td>35</td><td>30.2±0.6</td><td>22.7±0.6</td><td>118</td><td>216</td></tr><tr><td>ER-AML (ours)</td><td>30.2±0.6</td><td>24.3±0.4</td><td>28</td><td>35</td><td>27.0±0.7</td><td>19.3±0.6</td><td>200</td><td>216</td></tr></table>
+
+Table 2: Split CIFAR-100 (left) and Mini-Imagenet (right) results with $M = 1 0 0$ . For each method, we report the best result between using (or not) data augmentations.
+
+Data Augmentation In the settings of Aljundi et al. (2019a); Lopez-Paz et al. (2017); Ji et al. (2020); Shim et al. (2020); Chaudhry et al. (2019) data augmentation is not used. However, this is a standard practice for improving the performance on small datasets and can thus naturally complement most methods utilizing replay buffers. Notably, Prabhu et al. (2020), the offline learning method, utilizes data augmentation when comparing to the above online learners. To avoid unfair comparisons, in our experiments we indicate when a method uses augmentation. When not specified, we treat it as a hyperparameter and report the best performance.
+
+Hyperparameter selection For all datasets considered, we withhold $5 \%$ of the training data for validation. For each method, optimal hyperparameters were selected via a grid search performed on a validation set. The selection process was done on a per dataset basis, that is we picked the configuration which maximized the accuracy averaged over different memory settings. We found that for both ER-AML and ER-ACE, the same hyperparameter configuration worked across all settings and datasets. All necessary details to reproduce our experiments can be found in the Appendix.
+
+# 5.4 STANDARD ONLINE CONTINUAL LEARNING SETTINGS
+
+We evaluate on Split CIFAR-10, Split CIFAR-100 and Split MiniImagenet using the protocol and constraints from Aljundi et al. (2019a); Ji et al. (2020); Shim et al. (2020) . We note in all results each method is run 10 times, and we report the mean and standard error. We first discuss dataset specific results, before analysing the computation cost of each method.
+
+CIFAR-10 results are found in Table 1 using a variety of buffer sizes. In this setting, we see that both the methods we propose, ER-AML and ER-ACE consistently outperform other methods by a significant margin. This result holds in both settings where data augmentation is (or not) used, outperforming previous state-of-the-art methods MIR and $\mathrm { D E R + + }$ . Shifting our attention to SS-IL, its underperformance w.r.t to ER-ACE highlights the importance of having a rehearsal objective that considers the new classes. In Appendix B, we observe that when applying SS-IL in the online setting: (1) the method performs poorly on the current task, as is it unable to consolidate old and new knowledge, (2) yet mitigates representation drift even on a perfectly balanced stream. The latter is surprising, as the method was designed specifically to address stream imbalance. Finally, we note the offline training baseline G-DUMB cannot satisfy the anytime evaluation criteria.
+
+Longer Task Sequence results are shown in Table 2 with CIFAR-100 on the left and MiniImagenet on the right. On both datasets similar findings are observed, our proposed methods match or outperform strong existing baselines. SS-IL performs similarly to our method on mini-imagenet hile having a higher computational and memory cost. As mentioned above, the method struggles to learn the current task, however here the “weight” of the current task is small in the final acc of the 20-task regime. We see that average anytime accuracy is higher for ER-ACE and indeed the anytime curves in Appendix L further illustrate this. Finally, ER-ACE shows relative gains of $35 \%$ in accuracy over ER, without any additional computation cost. For Mini-Imagenet, ER-ACE outperforms the single-pass iid baseline, and nearly reaches the performance of the equal-compute iid baseline.
+
+Computation Budget To provide another view of the computational advantages of our proposal we report the accuracy given compute budget over the length of the sequence in Fig 3. When monitoring the computation performed by each baseline, we notice that several methods do not compete on equal footing. First, the use of Nearest Class Mean (NCM) classifiers leads to a significant compute cost, as shown for iCaRL. For our experiments, we evaluate the model after 10 mini-batches (100 total samples), where NCM classifier must forward the whole buffer to get class prototypes. We argue that such an approach has disadvantages in the online setting due to poor computational trade-offs. Second, MIR Aljundi et al. (2019a) has an expen
+
+![](images/5fbafd56a80cd170a969162310ee91e29711a024531f21a3c5be37f7705ff733.jpg)  
+Figure 3: Total Accuracy as a function of TeraFLOPs spent. Here the models are evaluated on all 10 classes, to ensure consistency across timesteps.
+
+sive sample retrieval cost. It remains to show if this step can be approximated more efficiently. Finally, we note that our method, ER-AML has varying compute: for streams with a small number of classes per task (CIFAR10), it can compute the incoming loss leveraging only the incoming data. In other datasets, where an incoming batch may not have at least two samples of each class, an additional cost to forward a buffered point is incurred.
+
+Evaluation with augmentation The use of augmentations also permits extra benefits of replay methods particularly in settings where buffer overfitting is more present, e.g. in the small buffer regime. From the results in Table 1, we see that augmentations provides significant gains for a large set of methods. It is therefore crucial to compare methods on equal footing, where they can all leverage (or not) data augmentation. For example, gains reported in Prabhu et al. (2020) over ER completely vanish when ER is given the same access to augmented data. We note that for MiniImagenet, augmentations did not help. We hypothesize that since this is the hardest task the risk of overfitting on the buffer is less severe.
+
+# 5.5 BLURRY TASK BOUNDARIES
+
+Table 3: CIFAR-10 Blurry Task Boundary Experiments   
+
+<table><tr><td>Method</td><td>M= 20</td><td>M=100</td></tr><tr><td>ER</td><td>32.1±1.5</td><td>42.7±2.2</td></tr><tr><td>DER++</td><td>31.0±1.4</td><td>41.7±1.4</td></tr><tr><td>ER-AML</td><td>45.6±1.2</td><td>55.2±1.1</td></tr><tr><td>ER-ACE</td><td>44.5±0.5</td><td>50.2±1.1</td></tr></table>
+
+Next, we explore a setting where the distribution is continuously evolving, rather than clearly delineated by task boundaries (similar to settings considered in Aljundi et al. (2019b)). To do this, we linearly interpolate between tasks over time, resulting in new classes being slowly mixed into the data stream. This experiment is done on Split-CIFAR10, and the interpolation is such that at every timestep, the incoming data batch has on average 2 unique labels (as in the original experiment). We only evaluate task-free methods in this setting: methods like MIR and SS-IL cannot be used in such setting. Results in table 3 report the final accuracy, averaged over 5 runs, we report the standard error. We observe our ER-AML and ER-ACE methods perofrm well in this setting. More details provided in Appendix A.2.
+
+# 6 CONCLUSION
+
+We have illustrated how in the online continual learning setting the standard loss applies excessive pressure on old class representations. We proposed two modifications of the loss function, both based on treating the incoming and replay data in an asymmetric fashion. Our proposed method does not require knowledge of the current task and is shown to be suitable for long task sequences achieving strong performance with minimal or no additional cost. We also raise the standard for high quality evaluation in online continual learning by considering a wide number of baselines and metrics.
+
+# 7 REPRODUCIBILITY STATEMENT
+
+We have made several efforts to ensure that the results provided in the paper are fully reproducible. We first provide a detailed codebase from which all the results in this paper are generated. In this codebase, one can find the results of our grid search, as well as optimal hyperparameters for each method and setting. We have provided a Readme file to help guide used to reproduce our results. Details of all hyperparameters are also clearly described in the main paper and particularly in the appendix.
+
+# 8 ACKNOWLEDGEMENTS
+
+Lucas Caccia is funded by Borealis AI. EB and NA are supported by NSERC Discovery Grant RGPIN-2021-04104. We acknowledge resources provided by Compute Canada and Calcul Quebec.
+
+# REFERENCES
+
+Hongjoon Ahn, Jihwan Kwak, Subin Lim, Hyeonsu Bang, Hyojun Kim, and Taesup Moon. Ss-il: Separated softmax for incremental learning. arXiv preprint arXiv:2003.13947, 2020.
+
+Rahaf Aljundi, Francesca Babiloni, Mohamed Elhoseiny, Marcus Rohrbach, and Tinne Tuytelaars. Memory aware synapses: Learning what (not) to forget. arXiv preprint arXiv:1711.09601, 2017.
+
+Rahaf Aljundi, Klaas Kelchtermans, and Tinne Tuytelaars. Task-free continual learning. In CVPR 2019, 2018.
+
+Rahaf Aljundi, Lucas Caccia, Eugene Belilovsky, Massimo Caccia, Laurent Charlin, and Tinne Tuytelaars. Online continual learning with maximally interfered retrieval. In Advances in Neural Information Processing (NeurIPS), 2019a.
+
+Rahaf Aljundi, Min Lin, Baptiste Goujaud, and Yoshua Bengio. Gradient based sample selection for online continual learning. arXiv preprint arXiv:1903.08671, 2019b.
+
+Zalan Borsos, Mojm ´ ´ır Mutny, and Andreas Krause. Coresets via bilevel optimization for continual \` learning and streaming. arXiv preprint arXiv:2006.03875, 2020.
+
+Pietro Buzzega, Matteo Boschini, Angelo Porrello, Davide Abati, and Simone Calderara. Dark experience for general continual learning: a strong, simple baseline. arXiv preprint arXiv:2004.07211, 2020.
+
+Massimo Caccia, Pau Rodriguez, Oleksiy Ostapenko, Fabrice Normandin, Min Lin, Lucas Caccia, Issam Laradji, Irina Rish, Alexandre Lacoste, David Vazquez, et al. Online fast adaptation and knowledge accumulation: a new approach to continual learning. arXiv preprint arXiv:2003.05856, 2020.
+
+Arslan Chaudhry, Marc’Aurelio Ranzato, Marcus Rohrbach, and Mohamed Elhoseiny. Efficient lifelong learning with a-gem. In ICLR 2019.
+
+Arslan Chaudhry, Marcus Rohrbach, Mohamed Elhoseiny, Thalaiyasingam Ajanthan, Puneet K Dokania, Philip HS Torr, and Marc’Aurelio Ranzato. Continual learning with tiny episodic memories. arXiv preprint arXiv:1902.10486, 2019.
+
+Hung-Jen Chen, An-Chieh Cheng, Da-Cheng Juan, Wei Wei, and Min Sun. Mitigating forgetting in online continual learning via instance-aware parameterization. Advances in Neural Information Processing Systems, 33, 2020a.
+
+Ting Chen, Simon Kornblith, Mohammad Norouzi, and Geoffrey Hinton. A simple framework for contrastive learning of visual representations. arXiv preprint arXiv:2002.05709, 2020b.
+
+Matthias De Lange, Rahaf Aljundi, Marc Masana, Sarah Parisot, Xu Jia, Ales Leonardis, Gregory Slabaugh, and Tinne Tuytelaars. Continual learning: A comparative study on how to defy forgetting in classification tasks. arXiv preprint arXiv:1909.08383, 2019.
+
+Sebastian Farquhar and Yarin Gal. Towards robust evaluations of continual learning. arXiv preprint arXiv:1805.09733, 2018.
+
+Kaiming He, Haoqi Fan, Yuxin Wu, Saining Xie, and Ross Girshick. Momentum contrast for unsupervised visual representation learning. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, pp. 9729–9738, 2020.
+
+Xu He, Jakub Sygnowski, Alexandre Galashov, Andrei A. Rusu, Yee Whye Teh, and Razvan Pascanu. Task agnostic continual learning via meta learning. ArXiv, abs/1906.05201, 2019. URL https://arxiv.org/abs/1906.05201.
+
+Elad Hoffer and Nir Ailon. Deep metric learning using triplet network. In International workshop on similarity-based pattern recognition, pp. 84–92. Springer, 2015.
+
+Saihui Hou, Xinyu Pan, Chen Change Loy, Zilei Wang, and Dahua Lin. Learning a unified classifier incrementally via rebalancing. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pp. 831–839, 2019.
+
+Xu Ji, Joao Henriques, Tinne Tuytelaars, and Andrea Vedaldi. Automatic recall machines: Internal replay, continual learning and the brain. arXiv preprint arXiv:2006.12323, 2020.
+
+Prannay Khosla, Piotr Teterwak, Chen Wang, Aaron Sarna, Yonglong Tian, Phillip Isola, Aaron Maschinot, Ce Liu, and Dilip Krishnan. Supervised contrastive learning. In H. Larochelle, M. Ranzato, R. Hadsell, M. F. Balcan, and H. Lin (eds.), Advances in Neural Information Processing Systems, volume 33, pp. 18661–18673. Curran Associates, Inc., 2020. URL https://proceedings.neurips.cc/paper/2020/file/ d89a66c7c80a29b1bdbab0f2a1a94af8-Paper.pdf.
+
+Timothee Lesort, Massimo Caccia, and Irina Rish. Understanding continual learning settings with ´ data distribution drift analysis. arXiv preprint arXiv:2104.01678, 2021.
+
+Zhizhong Li and Derek Hoiem. Learning without forgetting. In European Conference on Computer Vision, pp. 614–629. Springer, 2016.
+
+David Lopez-Paz et al. Gradient episodic memory for continual learning. In Advances in Neural Information Processing Systems, pp. 6467–6476, 2017.
+
+Zheda Mai, Ruiwen Li, Hyunwoo Kim, and Scott Sanner. Supervised contrastive replay: Revisiting the nearest class mean classifier in online class-incremental continual learning. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, pp. 3589–3599, 2021.
+
+Michael McCloskey and Neal J Cohen. Catastrophic interference in connectionist networks: The sequential learning problem. Psychology of learning and motivation, 24:109–165, 1989.
+
+Fabrice Normandin, Florian Golemo, Oleksiy Ostapenko, Matthew Riemer, Pau Rodriguez, Julio Hurtado, Khimya Khetarpal, Timothee Lesort, Laurent Charlin, Irina Rish, and Massimo Caccia.´ Sequoia - towards a systematic organization of continual learning research. https://github. com/lebrice/Sequoia, 2021. URL https://github.com/lebrice/Sequoia.
+
+Oleksiy Ostapenko, Pau Rodriguez, Massimo Caccia, and Laurent Charlin. Continual learning via local module composition. In Thirty-Fifth Conference on Neural Information Processing Systems, 2021. URL https://proceedings.neurips.cc/paper/2021/hash/ fe5e7cb609bdbe6d62449d61849c38b0-Abstract.html.
+
+Ameya Prabhu, Philip HS Torr, and Puneet K Dokania. Gdumb: A simple approach that questions our progress in continual learning. In European Conference on Computer Vision, pp. 524–540. Springer, 2020.
+
+Hang Qi, Matthew Brown, and David G Lowe. Low-shot learning with imprinted weights. In Proceedings of the IEEE conference on computer vision and pattern recognition, pp. 5822–5830, 2018.
+
+Sylvestre-Alvise Rebuffi, Alexander Kolesnikov, Georg Sperl, and Christoph H Lampert. icarl: Incremental classifier and representation learning. In Proc. CVPR, 2017.
+
+David Rolnick, Arun Ahuja, Jonathan Schwarz, Timothy P Lillicrap, and Greg Wayne. Experience replay for continual learning. arXiv preprint arXiv:1811.11682, 2018.
+
+Joan Serra, D \` ´ıdac Sur´ıs, Marius Miron, and Alexandros Karatzoglou. Overcoming catastrophic forgetting with hard attention to the task. arXiv preprint arXiv:1801.01423, 2018.
+
+Dongsub Shim, Zheda Mai, Jihwan Jeong, Scott Sanner, Hyunwoo Kim, and Jongseong Jang. Online class-incremental continual learning with adversarial shapley value. arXiv e-prints, pp. arXiv–2009, 2020.
+
+Dongsub Shim, Zheda Mai, Jihwan Jeong, Scott Sanner, Hyunwoo Kim, and Jongseong Jang. Online class-incremental continual learning with adversarial shapley value. In Proceedings of the AAAI Conference on Artificial Intelligence, volume 35, pp. 9630–9638, 2021.
+
+Binh Tang and David S Matteson. Graph-based continual learning. arXiv preprint arXiv:2007.04813, 2020.
+
+Gido M van de Ven and Andreas S Tolias. Three scenarios for continual learning. arXiv preprint arXiv:1904.07734, 2019. URL https://arxiv.org/abs/1904.07734.
+
+Jeffrey S Vitter. Random sampling with a reservoir. ACM Transactions on Mathematical Software (TOMS), 11(1):37–57, 1985.
+
+Johannes Von Oswald, Dominic Zhao, Seijin Kobayashi, Simon Schug, Massimo Caccia, Nicolas Zucchet, and Joao Sacramento. Learning where to learn: Gradient spar- ˜ sity in meta and continual learning. Advances in Neural Information Processing Systems, 34, 2021. URL https://proceedings.neurips.cc/paper/2021/hash/ 2a10665525774fa2501c2c8c4985ce61-Abstract.html.
+
+Yue Wu, Yinpeng Chen, Lijuan Wang, Yuancheng Ye, Zicheng Liu, Yandong Guo, and Yun Fu. Large scale incremental learning. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pp. 374–382, 2019.
+
+Chen Zeno, Itay Golan, Elad Hoffer, and Daniel Soudry. Task agnostic continual learning using online variational bayes. arXiv preprint arXiv:1803.10123, 2018.
+
+Bowen Zhao, Xi Xiao, Guojun Gan, Bin Zhang, and Shutao Xia. Maintaining discrimination and fairness in class incremental learning. arXiv preprint arXiv:1911.07053, 2019.
+
+# A EXPERIMENTAL SETUP
+
+In this section we provide additional experiments regarding the baselines and hyperparameters. In all experiments, we leave the batch size and the rehearsal batch size fixed at 10, following Aljundi et al. (2019a); Chaudhry et al.. This allows us to fairly compare different approaches, as these parameters have a direct impact on the computational cost of a given run. The model architecture $\boldsymbol { \theta }$ in Alg. 1) is also kept constant, which is a reduced ResNet-18 used in Lopez-Paz et al. (2017); Chaudhry et al.; Aljundi et al. (2019a;b), where the dimensions of the last linear layer change depending on the input height and width. The model has 1.09M params for the CIFAR experiments and 1.15M params for MiniImagenet. For all datasets considered, we keep the original ordering of the classes, meaning that the first task will always contain the first $k$ classes.
+
+# A.1 HYPERPARAMETERS
+
+All results in the paper have been (re)implemented by us, with the expection of GDUMB Prabhu et al. (2020), where results were run from the author’s public codebase. For each method a grid search was ran on the possible hparams, which we detail below. We will also described method specific details.
+
+# $\mathbf { D E R + + }$ Buzzega et al. (2020) :
+
+• LR : [0.1, 0.01, 0.001] • α : [0.25, 0.5, 0.75] • β : [0.5, 0.75, 1]
+
+We also tried to implement the DER (not $\mathrm { D E R + + }$ ) algorithm described in Buzzega et al. (2020). We found that it did not lead to improvements w.r.t to ER in the single epoch setting. Moreover, the setting in the original paper uses a wider Resnet-18. We found that both these differences account for the drop in performance when comparing to the numbers in Buzzega et al. (2020).
+
+Finally, we highlight that in general, methods using distillation (iCaRLRebuffi et al. (2017), SS-IL Ahn et al. (2020), and DER Buzzega et al. (2020)) typically perform better in the onlne setting without it.
+
+# ER Chaudhry et al. :
+
+• LR : [0.1, 0.01, 0.001]
+
+Note that unlike the ER implementation in Aljundi et al. (2019a), we use a “task-free” implementation. This leads to two differences. First, rehearsal begins as soon as the buffer is not empty. Second, when fetching points in the buffer, we do not exclude classes from the current task, as done in MIRAljundi et al. (2019a).
+
+# iCaRL Rebuffi et al. (2017) :
+
+• LR : [0.1, 0.01, 0.001]
+
+For all “task-based” methods (iCaRL, MIR, SS-IL) we fully leverage the task identified and do not start rehearsal until the second tasks. This typically leads to better performance, especially in the small buffer setting, as it reduces the work of overfitting to the buffer.
+
+# MIR Aljundi et al. (2019a) :
+
+• LR : [0.1, 0.01, 0.001]
+
+Note that unlike in the original paper, the final results in the paper are on the full training set. In other words, once the hyperparameter cross-validation is done, we train on the validation set. This changes the results slightly from the original paper. Finally, we kept the number of items subsampled from the buffer for the sampling step $( N _ { c } )$ equal to 50 as in the original codebase.
+
+# SS-ILAhn et al. (2020) :
+
+• LR : [0.1, 0.01, 0.001]   
+• should distill : [Yes, No]. When turned on, this method also uses the distillation loss as prescribed in Ahn et al. (2020)
+
+As we will see in B, using the
+
+# ER-ACE
+
+To implement the masking loss, we simply use logits.maskedfill(mask, $- 1 \in 9$ ) to filter out classes which should not receive gradient. Using a small constant in this step is equivalent to removing the masked classes from the softmax denominator.
+
+# ER-AML :
+
+• LR : [0.1, 0.01, 0.001] • SupCon Temperature : [0.1, 0.2]
+
+# A.2 BLURRY TASK BOUNDARIES EXPERIMENT
+
+Here we provide additional details on the experiment described in Section 5.4. In the original (task based) benchmark, each task comprises 10K samples (or 1K minibatches of 10 samples), so a total of 5K minibatches streamed. For the smooth alternative, at each timestep $t \in \{ 1 , \bar { 2 } , . . , 5 0 0 0 \}$ the unnormalized probability of seeing class $c$ is given by
+
+$$
+p _ { c } ( t ) \sim \dot { \mathcal { N } } ( \mu _ { c } - t , \frac { N _ { c } } { 4 } )
+$$
+
+with $N _ { c }$ denotes the number of samples of class $c$ , and $\begin{array} { r } { \mu _ { c } = \frac { ( 2 c - 1 ) N _ { c } } { 2 } } \end{array}$ (2c−1)Nc . At every timestep we normalize this probability for each class and sample according to a Categorical distribution with these probabilities. The parameters for the mean and variance are chosen so that on average, the model receives 2 unique labels per minibatch of 10 items (as in the original task-based experiment).
+
+In such a setting where there is no notion of the current task, or rather a set of current labels, one cannot use SS-IL, as it needs to leverage a task identifier during training. Through this experiment we show that our method can overcome this limitation, despite sharing some similarities with SS-IL.
+
+# B AN IN-DEPTH ANALYSIS OF SS-IL IN THE ONLINE SETTING
+
+SS-IL is a related method. In this section, we highlight several key observations when deploying SS-IL in the online setting which are on the other hand not issues for ER-AML and ER-ACE. We then provide several additional experiments, shedding some light on the inner workings of the method.
+
+SS-IL fails to learn the current task As stated earlier, the key difference between SS-IL without distillation and ER-ACE is that in the latter, the rehearsal loss in unmasked. In this section, we highlight the problems that occur when using a masked rehearsal loss alongside a masked incoming loss as in SS-IL. We show that since both losses are masked, the model never learns to classify classses across tasks. Specifically, there is no objective in which the model learns to distinguish classes in the current task from classes in the previous tasks. As we show in Figure 4, SS-IL is unable to classify samples from the current task in a single-head setting. The method actually performs worse than random chance on samples form the current task. On the other extreme we see that ER does very well on the current task (shifting abrupty the previous representations to accomodate the new task). Finally, we see that ER-ACE strikes a good tradeoff between the two, reaching a reasonable accuracy on the current task without disrupting the learned representations of previous tasks. We note that the same conclusion is reached when using the original SS-IL method with the distillation loss.
+
+SS-IL does more than correcting for class imbalance SS-IL is motivated as a method which addresses the class imbalance issue arising in replay methods. Specifically, when drawing a fixed number of rehearsal points at every epoch, it follows that as more and more tasks are seen, previous classes are underrepresented in the training stream when compared to points from the current tasks.
+
+In this section, we test whether or not the behavior of SS-IL differs from standard Experience Replay when no class imbalance is present. In this experiment, we increase the number of rehearsal points sampled at every task such that when combining incoming and rehearsal data, we obtain perfectly balanced training data on average. This is experiment is done on the Split-CIFAR10 benchmark with 2 classes per task, with a minibatch of 10 incoming datapoints. Therefore, we sample $0 , 1 0 , 2 0 , 3 0 , 4 0$ rehearsal points per incoming databatch for the first, second, third, fourth and fifth task.
+
+What we observe is that SS-IL still outperforms regular Experience Replay, suggesting that the method does more than simply addressing class imbalance in the data stream. We report final accuracy in Table 4. SS-IL’s performance gap with ER is bigger with small buffer. This is consistent with what we observe for representation drift : methods with larger buffer can better correct for abrupt representation change, making the gap between ER vs ER-ACE and ER-AML smaller. From this we give new insights on the inner workings of SS-IL, namely that it works well because it addresses representation drift rather than class imbalance.
+
+$$
+\begin{array} { l } { { \frac { \mathrm { M e t h o d } \quad M = 2 0 \qquad M = 5 0 \quad M = 1 0 0 } { \mathrm { E R } \qquad 2 1 . 0 \pm 1 . 2 \ 2 5 . 7 \pm 1 . 1 \ 3 7 . 8 \pm 0 . 7 } } } \\ { { \mathrm { S S - L L } \quad 3 0 . 3 \pm 1 . 0 \ 3 4 . 6 \pm 0 . 8 \ 3 9 . 1 \pm 0 . 6 } } \end{array}
+$$
+
+Table 4: Final Accuracy on split CIFAR-10 with class balanced stream.
+
+![](images/a614689c0753957e4c22d1536e4b6427aa32d105f54222fa0e5eb41621a552f3.jpg)  
+Accuracy on the current task   
+Figure 4: For Split-CIFAR-10, we monitor the performance on the current task observed in the stream for SS-IL, ER, and ER-ACE. ER fits too abruptly current task; ER-ACE incorporates this knowledge slowly; SS-IL barely on the other hand is unable to learn new tasks when they are first observed in the stream
+
+# C OVERFITTING ON BUFFERED SAMPLES
+
+We study the extent to which our proposed method reduces over-fitting to samples stored in the buffer.
+
+![](images/e47bc89cad3c9e5aae74a1a54c9daa1144486c90061423b8a31cf273642df0f1.jpg)  
+Figure 5: Alignment between buffer and holdout representations. ER-ACE has constantly larger alignment between seen and unseen samples compared to ER especially for older tasks.
+
+A good model fit should yield a learned representation where same class datapoints are aligned, whether or not they were seen during training. To evaluate this potential mismatch, we first train a model and compare the representations of a) samples in the buffer $M$ after training and b) held-out samples from the validation set $V$ . That is, for each datapoint $x _ { m } \in M$ we find the point $x _ { v } \in V$ with $c ( x _ { m } ) = c ( x _ { v } )$ which maximizes the cosine similarity between $f _ { \theta } ( x _ { m } )$ and $f _ { \theta } ( x _ { v } )$ . This allows to compare alignment across models, irrespective of their internal scaling. We report the results in Figure 5, where similarity values are averaged over points from the same task. We find that our proposed method, ER-ACE, designed to reduce representation drift also reduces the extent to which the model overfits on the buffer. We observe that for earlier tasks, ER-ACE still retains a strong alignment between rehearsal and held-out data, which is not the case for ER.
+
+# D COMBINING ER-ACE WITH DER $^ { + + }$
+
+In this section, we apply our method on top of the strong DER $^ { + + }$ Buzzega et al. (2020) baseline. For this experiment, we use the same setting as in the DER paper. Specifically, we port our implementation to their public codebase https://github.com/aimagelab/mammoth. We keep the default settings for CIFAR-10, using a single pass through the data. We find that combining ER-ACE with $\mathrm { D E R + + }$ yields additional advantages. Not only do we observe small gains in accuracy, we notice significant gains in forgetting. Results are shown in Figure 6. Forgetting is defined as in Chaudhry et al..
+
+![](images/b31eba01db9c5743913e139d0a5cf7842466e1abe076608945f85525512b0f26.jpg)  
+Figure 6: Comparison to Dark Experience Replay (DER). We obtain improved performance and we can enhance the DER method using the ER-ACE approach
+
+Table 5: Average Drift (avg distance in feature space) of buffered representations for CIFAR-10 during learning of the second task. We observe similar behavior to ER-AML with SupCon   
+
+<table><tr><td rowspan=1 colspan=1>ER</td><td rowspan=1 colspan=1>(3.2 ± 1.8) × 10-2</td></tr><tr><td rowspan=1 colspan=1>ER-AML-Tripletw.All Negs</td><td rowspan=1 colspan=1>(3.0±0.6)× 10-2</td></tr><tr><td rowspan=1 colspan=1>ER-AML-Triplet w. Incoming Negs</td><td rowspan=1 colspan=1>(2.5 ±0.6)× 10-²</td></tr></table>
+
+Table 6: Ablation comparing ER-AML with triplet loss to ER-AML with SupCon. We observe both improve over ER but SupCon has better performance in larger buffer sizes   
+
+<table><tr><td colspan="5">Accuracy ↑</td></tr><tr><td></td><td>M=5</td><td>M=20</td><td>M=50</td><td>M=100</td></tr><tr><td>iid online</td><td>60.8±1.0</td><td>60.8±1.0</td><td>60.8 ± 1.0</td><td>60.8±1.0</td></tr><tr><td>iid++ online</td><td>72.0 ± 0.1</td><td>72.0±0.1</td><td>72.0±0.1</td><td>72.0±0.1</td></tr><tr><td>iid offline</td><td>79.2 ± 0.4</td><td>79.2 ± 0.4</td><td>79.2 ± 0.4</td><td>79.2 ± 0.4</td></tr><tr><td>fine-tuning</td><td>18.4± 0.3</td><td>18.4± 0.3</td><td>18.4±0.3</td><td>18.4±0.3</td></tr><tr><td>ER</td><td>19.0 ± 0.1</td><td>26.7± 0.3</td><td>36.1 ± 0.6</td><td>41.5 ± 0.6</td></tr><tr><td>ER-AML Triplet</td><td>33.0 ± 0.3</td><td>40.1± 0.4</td><td>46.0± 0.5</td><td>49.8 ± 0.5</td></tr><tr><td>ER-AML SupCon 33.0 ±0.2</td><td></td><td>41.9 ± 0.1</td><td>48.3±0.2</td><td>51.9 ±0.3</td></tr></table>
+
+# E GRADIENT NORM
+
+Figure 7 shows the gradients norms of the features of previous classes in a stream of two tasks. Note how for normal ER, at the task switch the gradients of the previous classes features are suddenly very high leading potentially to large drift on these features.
+
+![](images/de41102741e910a95a39c664810222c7d11ed2dfb0c616a3d12633dd81336557.jpg)  
+Figure 7: Gradient’s norm for first task features in a two task learning scenario. We observe a sharp increase when all negatives are used and decrease using only incoming negatives.
+
+# F ER-AML WITH TRIPLET LOSS
+
+We observe similar behavior for ER-AML implemented with the triplet loss in terms of the importance of negative selection on drift as illustrated in Table 5. We also ablate ER-AML based on SupCon and Triplet in Table 6 finding the former outperforms in settings with higher buffer sizes, but that both outperform ER.
+
+# G ABLATIONS NEGATIVE SELECTION
+
+As discussed in the main paper, the selection of negatives is a critical aspect of ER-AML and motivates ER-ACE. To further illustrate this we ablate the performance of ER-AML when all possible negatives are used versus the prescribed negative selection strategy (using only classes in the incoming batch). The results are shown in Table 7. We observe that performance of ER-AML with all negatives is similar to but slightly better than ER, while use of well-selected negatives greatly improves performance.
+
+<table><tr><td></td><td>Accuracy (↑is better) M=20 M=50</td><td>Forgetting (↓is better) M=20 M=50</td></tr><tr><td>ER</td><td>26.7±0.3 36.1±0.6</td><td>47.1± 0.8 37.6± 0.9</td></tr><tr><td>ER-AML(all negatives)</td><td>28.5± 0.3 41.4± 0.4</td><td>56.7± 0.6 35.0±0.4</td></tr><tr><td>ER-AML(incoming negatives)</td><td>41.9 ± 0.1 48.3±0.2</td><td>33.6±0.2 25.8±0.3</td></tr></table>
+
+Table 7: Ablation of ER-AML with all negative selection versus negatives selected from incoming classes. We use the CIFAR-10 dataset. We observe that performance of ER-AML with all negatives is similar to but slightly better than ER, while use of well-selected negatives greatly improves performance.
+
+# H ADDITIONAL DRIFT RESULTS
+
+We showed in Figure 2 that the selection of negatives has a significant impact on the amount of representation change. Here we show that a similar behavior is observed with ER vs ER-ACE.
+
+![](images/1e248200d97db6023af8acd49706a7b529f45b161d7205edfbea2aa26865f9ad.jpg)
+
+# I ANALYSIS OF THE REPRESENTATIONS DURING THE SECOND TASK
+
+In this section we take a closer look at the model’s internal representation during the learning of the second task for different methods. This experiment replicates the setup illustrated in Figure 1 (split-CIFAR-10 with $M = 2 0$ ). For each method, the figures for all iterations were projected together to ensure that the figures are comparable across timesteps. All methods were initialized starting from the same base model trained on the first task. The dotted representations shown for each class come from held-out samples.
+
+We start by looking at the representations obtained at the begining of the second task. We see that for all three methods, (i) the prototypes of the classes from the first task (Class 0 and Class 1) are well placed, while the other prototypes are placed at random since they are not trained.
+
+![](images/8067d6fceec63d2590d196c032c9843ad574aa41259d8256ca412176ed4aee0c.jpg)  
+Figure 8: 1 Training Iteration on the Second Task
+
+After 100 training iterations, we see that for ER, the prototypes of the old classes have been significantly displaced and are far from the points of similar class. This is not the case for the latter two methods; for ER-ACE and ER-AML, the model is beginning to separate de classes from one another, and the class prototypes are near their respective classes.
+
+![](images/873631575c72a6087735450419beaffb6daa6d640527147aa6f44d8cc818cea7.jpg)  
+Figure 9: 100 Training Iterations on the Second Task
+
+After 400 training iterations, ER still struggles to align the class prototypes with the respective classes. ER-ACE has already well clustered the respective classes. ER-AML, continues to cluster the classes together, however does not do it as fast as ER-ACE.
+
+![](images/c1c5696e525f4968bea05b2ce2f30f9148af49185a771b6aa645da10fbf316ba.jpg)  
+Figure 10: 400 Training Iterations on the Second Task
+
+At the end of the second task, ER-ACE and ER-AML have successfully clustered the classes and aligned their respective prototypes with the clusters. As for ER, while the data is clustered, the prototypes are not properly aligned with class clusters. Moreover, we still see a strong overlap between prototypes of Class 2 and 3.
+
+![](images/576950f516183a5d18b9c5678938a4b41e99c93c24ab74ad2e61bfc21fcdd329.jpg)  
+Figure 11: End of the Second Task
+
+# J ADDITIONAL BLURRY TASK BOUNDARIES EXPERIMENTS
+
+Here we provide blurry task results for varying levels of task overlap. To give an idea of how much the tasks overlap, we report the average number of unique classes per incoming minibatch (MB): a small number means that the tasks are well separated. A high number means that there is a strong overlap. In the fully i.i.d setting, this number would be maximized. On the other hand, when this equals 1, each data class is streamed one after the other.
+
+Experiments are performed again on CIFAR-10 with $M = 2 0$ . We use augmentations to fairly compare with $\mathrm { D E R + + }$ . Results are averaged over 5 runs.
+
+<table><tr><td>Method</td><td>Avg. unique classes per MB 1 2 3 4 5</td></tr><tr><td>ER 23.1 DER++ 20.3 31.1</td><td>25.7 26.3 31.1 34.4 31.4 37.3 34.4</td></tr><tr><td>ER-ACE 32.8</td><td>36.2 36.8 41.7 44.5</td></tr><tr><td>ER-AML 34.0</td><td>40.4 46.0 47.6 47.9</td></tr></table>
+
+We see that through a wide range of different blurriness levels, our methods show strong improvement over other task-free baselines
+
+# K EXPERIMENTS WITH LIMITED TRAINING DATA AVAILABLE
+
+Next, we evaluate the methods above using varying percentages of the training data from the second task onwards (we use all the data for the first task so the model has converged to a reasonable solution before the first distribution shift). Moreover, we augment the rehearsal batch size for ER, ER-ACE and ER-AML to 20, so that their compute cost equals $\mathrm { D E R + + }$ . This is again on CIFAR-10, $M = 2 0$ . Results averaged over 5 runs.
+
+<table><tr><td>Method</td><td>% ofData Used 5% 10% 25% 50%</td></tr><tr><td>ER 17.3</td><td>22.5 28.0 33.2 32.8</td></tr><tr><td>DER++ 17.4 SS-IL 15.2</td><td>19.9 24.8 21.7 28.6</td></tr><tr><td></td><td>31.9</td></tr><tr><td>ER-ACE 20.5 ER-AML 18.1</td><td>25.4 31.2 36.1 24.3 31.0 38.7</td></tr></table>
+
+Again, we see that the proposed methods outperforms the baselines suggested above.
+
+![](images/3d49c67ed5c7395cf400ef7ac81f6d8d79f975d649daef6d259d168f303050ec.jpg)  
+CIFAR-10 ${ \mathsf { M } } = 5$ Anytime Evaluation Acc
+
+# L ADDITIONAL RESULTS
+
+In this section we provide full results (shown in the figures below) for various memory sizes on all three datasets considered, i.e. Split CIFAR-10, Split CIFAR-100 and Split MiniImagenet, with and without data augmentation. The results largely align with those presented but also illustrate the anytime performance.
+
+L.1 ANYTIME EVALUATION WITHOUT DATA AUGMENTATION
+
+L.2 ANYTIME EVALUATION WITH DATA AUGMENTATION
+
+![](images/27e2b50d0836f8eb85e8ae6113a143bfa29fc39f1cfe94cd90a818e04e06ef1c.jpg)
+
+![](images/7075010bb2b11fff05d8451f59f25219908a71531742d4caf9a73b6f9f6068b4.jpg)
+
+![](images/5f94039abb29cf1f1f63194205d59af13011de5d0f8922a4fb23167a53448bde.jpg)
+
+![](images/1bb0b5c5751e8e51e02cb69a90acd5f023ed34b6ca5c75fa3b68f4945ff83a3c.jpg)
+
+![](images/c0be346899f23875653552fe17a5ae08ef4633650201a1a0bf1598de68119f37.jpg)
+
+![](images/0724fc0c75a9fe00f7de80a176de0b2cfe3f4a9eb9fe98d0545e216803688e42.jpg)

parse/dev/Vu-B0clPfq/Vu-B0clPfq.md

@@ -0,0 +1,300 @@
+# Transformer Memory as a Differentiable Search Index
+
+Yi Tay∗, Vinh Q. Tran∗, Mostafa Dehghani, Jianmo Ni, Dara Bahri, Harsh Mehta Zhen Qin, Kai Hui, Zhe Zhao, Jai Gupta, Tal Schuster William W. Cohen, Donald Metzler Google Research {yitay,vqtran,metzler}@google.com
+
+# Abstract
+
+In this paper, we demonstrate that information retrieval can be accomplished with a single Transformer, in which all information about the corpus is encoded in the parameters of the model. To this end, we introduce the Differentiable Search Index (DSI), a new paradigm that learns a text-to-text model that maps string queries directly to relevant docids; in other words, a DSI model answers queries directly using only its parameters, dramatically simplifying the whole retrieval process. We study variations in how documents and their identifiers are represented, variations in training procedures, and the interplay between models and corpus sizes. Experiments demonstrate that given appropriate design choices, DSI significantly outperforms strong baselines such as dual encoder models. Moreover, DSI demonstrates strong generalization capabilities, outperforming a BM25 baseline in a zero-shot setup.
+
+# 1 Introduction
+
+Information retrieval (IR) systems map a user query $q \in \mathcal { Q }$ to a ranked list of relevant documents $\{ d _ { 1 } , \ldots , d _ { n } \} \subseteq { \mathcal { D } }$ , typically represented by integers or short strings called document identifiers (docids). The most widely used IR approaches are based on pipelined retrieve-then-rank strategies. For retrieval, approaches based on inverted indexes or nearest neighbor search are common where contrastive learning based dual encoders (DEs) (Gillick et al., 2018; Karpukhin et al., 2020; Ni et al., 2021) are the present state-of-the-art.
+
+This paper proposes an alternative architecture, wherein a sequence-to-sequence (seq2seq) learning system (Sutskever et al., 2014) is used to directly map a query $q$ to a relevant docid $j \in \mathcal { V }$ . This proposal is shown in the bottom half of Figure 1, for a sequence-to-sequence encoder-decoder architecture.
+
+We call this proposed architecture a differentiable search index (DSI), and implement it with a large pre-trained Transformer (Vaswani et al., 2017) model, building on the recent success of large generative language models (LMs) (Brown et al., 2020; Raffel et al., 2019; Devlin et al., 2018; Thoppilan et al., 2022; Du et al., 2021). In this proposed architecture, all information of the corpus is encoded within the parameters of the Transformer language model.
+
+At inference time, the trained model takes as input a text query $q$ and outputs a docid $j$ . If desired, beam search can be used to produce a ranked list of potentially-relevant docids. As we show, this process can work surprisingly well when trained properly. In our experiments it can consistently outperform DE baselines, sometimes drastically: for a base-sized T5 model, Hits $@ 1$ on the smallest corpus is improved by more than 20 points, from $12 . 4 \%$ for a DE to $3 3 . 9 \%$ for DSI; and on a corpus
+
+![](images/eacb2af8183bec70b70f2a09eee77df951e39feffe94596b4470a5cd1d6c64bb.jpg)  
+Figure 1: Comparison of dual encoders (top) to differentiable search index (bottom).
+
+Table 1: Information retrieval requires a series of decisions, associated with the subproblems of document representation, indexing, and retrieval. Structured-document variants of DSI are also sensitive to a fourth decision, namely how docids are represented.   
+
+<table><tr><td></td><td>BM25 or TFIDF</td><td>Dual Encoder (DE)</td><td>Differentiable Search Index (DSI</td></tr><tr><td>doc/query rep.</td><td> sparse Vdj vector in R|VI</td><td>dense Vdj vector in Rd</td><td>Various (see Section 3.1.2)</td></tr><tr><td>docid rep.</td><td></td><td></td><td>Various (see Section 3.2)</td></tr><tr><td>indexing</td><td>build inverted index mapping each termt→{dji,...,djx}</td><td>build table mapping each docvec Vd→ j</td><td>train model (see Section 3.1.1) to map dj → j</td></tr><tr><td>retrieval (top-1)</td><td>approximate sparse matmul to find argmaxjv Vdj</td><td>approximate MIPS to find argmaxjv Vdj</td><td>run trained model to find argmax Pr(jlq)</td></tr></table>
+
+$3 0 \times$ larger, performance is improved by nearly 7 points. These gains increase when larger models are used: for an 11B-parameter T5 model, Hits $@ 1$ performance improves by more than 25 points over DE on the small corpus, and more than 15 points on the large corpus. DSI also performs extremely well in a zero-shot setting, e.g., improving Hits $@ 1$ by 14 points over BM25.
+
+In addition to these quantitative gains, the DSI architecture is much simpler than a DE (see Table 1). A DE system fixes a search procedure (MIPS) and learns internal representations that optimize performance for that search procedure; in contrast, a DSI system contains no special-purpose fixed search procedure, instead using standard model inference to map from encodings to docids.
+
+Of particular interest to the machine learning community, as Table 1 shows, in DSI all aspects of retrieval are mapped into well-understood ML tasks. This may lead to new potential approaches to solving long-standing IR problems. As one example, since indexing is now a special case of model training, incrementally updating an index becomes a special case of model updating (Sun et al., 2020).
+
+In this paper, DSI is applied to moderate-sized corpora (from 10k to $3 2 0 \mathrm { k }$ documents), all of which are derived from one challenging retrieval task, and we leave the important question of the scaling DSI to larger corpora to future work. The task considered is retrieving supporting passages given questions from the Natural Questions (NQ) dataset, a challenging task for lexical models.
+
+While the idea of DSI is simple, there are a number of ways it can be realized, some of which work surprisingly well, and some of which work surprisingly poorly. Below we explore a number of variations of the DSI architecture.
+
+Document representation. We explore several approaches to representing documents, including a “naive” approach of using the document’s full text, as well as variants of the bag-of-words representation used by traditional IR engines.
+
+Docid representation. We look at several ways to represent docids. In addition to naively representing integers as text strings, we also consider unstructured atomic docids, where each document is assigned a unique token, and some simple baselines for constructing structured semantic docids that describe how to navigate to a document through a hierarchical clustering of the corpus. Structured docids— either semantically structured via clustering, or naively structured as tokenized integers—scale better to large corpora, since the size of the vocabulary used in the decoder is made larger.
+
+Indexing. A trainable IR system traditionally has two phases: indexing a corpus (i.e., memorizing information about each document), and learning how to effectively retrieve from the index. In DSI, the index is stored in the model parameters, and indexing is simply another kind of model training. Figure 1 suggests one approach to indexing a corpus: namely, to train on (1) examples $( d _ { j } , j )$ that pair document $d _ { j }$ with its docid $j$ , in addition to (2) examples $( q , j )$ that pair a query $q$ with a relevant docid $j$ . In this setup the examples of type (1) are “indexing” examples.
+
+While it is clear that examples of type (2) alone do not provide enough information for a system to generalize to novel retrievals, there are many alternatives to examples of type (1) that might plausibly “teach” a model about the associations between documents and docids. We explore a number of these below, and show that some plausible-seeming techniques perform very poorly. We also explore a number of alternative multi-task optimization and curriculum learning schemes for combining these types of examples.
+
+Effects of model and corpus size. Since recent results suggest that some properties of large LMs emerge only for very large model sizes Brown et al. (2020), we explore the performance of DSI for a range of model sizes and corpus sizes of 10k, 100k, and 320k documents.
+
+Summary. We show that even naive representations for documents and docids, coupled with appropriate training procedures to fine-tune modern large LMs, can perform surprisingly well; we present two improved docid representations, unstructured docids and semantically-structured docids, which improve the naive representation choice. We show that there is substantial variation in performance among indexing/training strategies and we show that performance of DSI significantly and consistently improves with model scale. To our knowledge this is the first case of generative indexing improving performance over strong baselines for a well-studied document retrieval task.
+
+# 2 Related Work
+
+De Cao et al. (2020) describe a related sequence-to-sequence system called autoregressive entity linking, in which documents mentioning an entity—perhaps implicitly, e.g., by posing a question to which that entity is an answer—are mapped to a canonical name of that entity. In the case of Wikipedia, canonical entity names correspond to page titles, so this could be viewed as a sort of document retrieval. This approach has been adapted to other purposes, such as generating knowledge base triples in canonical form (Josifoski et al., 2021). The task we consider is different from those considered in autoregressive entity linking: our goal is to retrieve a document containing the answer, rather than a document whose title is the answer. More importantly, in autoregressive entity linking the generation target is a semantically meaningful name, whereas we allow targets to be arbitrary docids. This makes our approach applicable to general retrieval tasks, but raises new questions about docid representation and indexing strategies.
+
+In autoregressive entity linking, generation is constrained to return an output from a fixed set. It would be feasible to constrain DSI generation outputs to be valid docids. Although we do not use this technique, the degree to which this might improve performance is a worthwhile question.
+
+There is a large body of work on retrieval augmented generation, i.e., retrieving auxiliary documents to enhance language models (Borgeaud et al., 2021; Guu et al., 2020). These techniques are useful for many tasks including question-answering, but rely on traditional retrieval methods such as DEs. Here we use generation to replace a retrieval process, rather than using retrieval to augment a generation process.
+
+Dual encoders (Dehghani et al., 2017; Gillick et al., 2018; Gao et al., 2021; Ni et al., 2021; Karpukhin et al., 2020) are a well-established paradigm for retrieval. The key idea is produce query and document embeddings independently and perform a similarity retrieval in vector space across all embedding pairs. Query and candidate documents are produced by a sequence encoder and training is performed using a form of contrastive loss.
+
+The interpretation of a large Transformer model as a memory store have been investigated in prior work. (Roberts et al., 2020) demonstrated success on a closed-book QA task whereby they train
+
+T5 models to retrieve facts that are encoded within the parameters of the model during pretraining. However, different from CBQA, the presented problem here in this paper is to retrieve full documents based on docids instead of generating direct answers. Meanwhile, (Petroni et al., 2019) also investigated language models as knowledge bases and found that pretrained LMs may already contain relational knowledge. (Geva et al., 2020) analyzes the knowledge encoded within Transformer feedforward layers. There have been also works that demonstrate the relation of Transformers to associative memory and Hopfield networks (Ramsauer et al., 2020), which reinforce the notion that Transformers should intuitively serve as a good associative memory store or search index.
+
+# 3 Differentiable Search Index
+
+The core idea behind the proposed Differentiable Search Index (DSI) is to fully parameterize traditionally multi-stage retrieve-then-rank pipelines within a single neural model. To do so, DSI models must support two basic modes of operation:
+
+• Indexing: a DSI model should learn to associate the content of each document $d _ { j }$ with its corresponding docid $j$ . This paper utilizes a straightforward sequence-to-sequence (seq2seq) approach that takes document tokens as input and generates identifiers as output. • Retrieval: Given an input query, a DSI model should return a ranked list of candidate docids. Here, this is achieved with autoregressive generation.
+
+Following these two operations, a DSI model can be trained to index a corpus of documents and optionally fine-tune on an available set of labeled data (queries and labeled documents), and thereafter used to retrieve relevant documents—all within a single, unified model. As opposed to retrieve-thenrank approaches, this type of model allows for simple end-to-end training and can easily be used as a differentiable sub-component of a larger, more complex neural model.
+
+# 3.1 Indexing Strategies
+
+We investigate various indexing strategies that are meant to learn associations between documents and their identifiers. We train our model to predict docids given a sequence of document tokens. This allows our model to learn which identifier belongs to which document and can be thought of as a differentiable take on traditional search indexes. We consider various alternatives and ablate these settings in subsequent sections. The final strategy employed was Inputs2Targets with direct indexing.
+
+# 3.1.1 Indexing Method
+
+This section discusses the indexing task variants that we consider.
+
+Inputs2Target We frame this as a seq2seq task of doc_tokens docid. As its name suggests, this binds the docids to the document tokens in a straightforward inputs-to-targets fashion. The advantage here is that the identifier is the denoising target, which puts it in closer proximity to the loss function. Since the retrieval task is also concerned with predicting identifiers, this formulation allows the network to follow a similar input-target balance in terms of sequence length. A potential weakness is that the document tokens are not denoising targets and therefore there is no opportunity for general pre-training on document tokens.
+
+Targets2Inputs This formulation considers the opposite of the above, i.e., generating document tokens from identifiers, i.e., docid doc_tokens. Intuitively, this is equivalent to training an autoregressive language model that is conditioned on the docid.
+
+Bidirectional This formulation trains both Inputs2Targets and Targets2Inputs within the same co-training setup. A prefix token is prepended to allow the model to know which direction the task is being performed in.
+
+Span Corruption We also explored a setup that performs span corruption-based denoising (Raffel et al., 2019) with the inclusion of docid tokens. In this approach, we concatenate the identifier to the document tokens as a prefix that can be randomly masked as spans in the span corruption objective.
+
+This method has the advantage of (1) also performing general pre-training during indexing and (2) achieving a good balance of docids as denoising targets and inputs.
+
+# 3.1.2 Document Representation Strategies
+
+In the previous section, we explored “how to index”. This section investigates “what to index?”, i.e., how to best represent doc_tokens. We state our options here and carefully ablate them in our experiments later. The best option in the end was the direct indexing method.
+
+Direct Indexing This strategy represents a document exactly. We take the first $L$ tokens of a document, with sequential order preserved, and associate them with the docid.
+
+Set Indexing Documents may contain repeated terms and/or non-informative words (e.g., stopwords). This strategy de-duplicates repeated terms using the default Python set operation and removes stopwords from the document. The rest of the document after filtering is passed into the model in similar fashion to the direct index.
+
+Inverted Index This strategy maps chunked documents (contiguous blocks of tokens) instead of entire documents directly to the docid. We randomly subsample a single contiguous chunk of $k$ tokens and associate them with the docid. The key advantage of this approach is to allow looking beyond the first $k$ tokens.
+
+# 3.2 Representing Docids for Retrieval
+
+Retrieval within seq2seq-based DSI models is accomplished by decoding docids given an input query. How to do this decoding in an effective way largely depends on how docids are represented in the model. The remainder of this section explores a number of possible ways for representing docids and how to handle decoding for each.
+
+Unstructured Atomic Identifiers The most naive way to represent documents is assign each an arbitrary (and possibly random) unique integer identifier. We refer to these as unstructured atomic identifiers.
+
+With these identifiers, an obvious decoding formulation is to learn a probability distribution over the identifiers. In this case, models are trained to emit one logit for each unique docid $( | N _ { d o c u m e n t s } | )$ This is analogous to the output layer in standard language models, but extended to include docids.
+
+To accommodate this, we extend the output vocabulary of a standard language model as follows:
+
+$$
+O = \mathrm { S o f t m a x } ( [ W _ { t o k e n s } ; W _ { d o c s } ] ^ { T } h _ { l a s t } )
+$$
+
+where $[ ; ]$ is the row-wise concatenation operator, $W _ { t o k e n s } ~ \in ~ \mathbb { R } ^ { d _ { m o d e l } \times | N _ { t o k e n s } | }$ and $W _ { d o c s } ~ \in$ $\mathbb { R } ^ { d _ { m o d e l } \times | N _ { d o c u m e n t s } | }$ . $h _ { l a s t }$ is the last layer’s hidden state $( \in \mathbb { R } ^ { d _ { m o d e l } } )$ of the decoder stack. To retrieve the top- $\mathbf { \nabla } \cdot \mathbf { k }$ documents for a given query, we simply sort the output logits and return the corresponding indices. This is also reminiscent of standard listwise learning to rank where all documents are considered at once.
+
+Naively Structured String Identifiers We also consider an ostensibly absurd approach that treats unstructured identifiers, i.e., arbitrary unique integers, as tokenizable strings. We refer to these as naively structured identifiers.
+
+In this formulation, retrieval is accomplished by decoding a docid string sequentially one token at a time. This eliminates the need for the large softmax output space that comes with unstructured atomic identifiers. It also eliminates the need to learn embeddings for each individual docid.
+
+When decoding, beam search is used to obtain the predicted best docid. With this strategy, it is less straightforward to obtain a top- $\mathbf { \nabla } \cdot \mathbf { k }$ ranking. One could exhaustively comb through the entire docid space and obtain the likelihood of each docid given the query. Instead, we use the partial beam search tree to construct top- $\mathbf { \nabla } \cdot \mathbf { k }$ retrieval scores. We find this approximation to be quite efficient and effective in practice.
+
+Semantically Structured Identifiers All of the approaches for representing docids thus far assumed that the identifiers are assigned in an arbitrary manner. While exploring the limits of arbitrary identifiers is quite interesting, it is only intuitive that imbuing the docid space with semantic structure can lead to better indexing and retrieval capabilities. As such, this section explores semantically structured identifiers.
+
+Specifically, we aim to automatically create identifiers that satisfy the following properties: (1) the docid should capture some information about the semantics of its associated document, (2) the docid should be structured in a way that the search space is effectively reduced after each decoding step. This results in identifiers where semantically similar documents share identifier prefixes.
+
+In this work, we treat this as a fully unsupervised pre-processing step. However, as part of future work it may be possible to integrate and automatically learn semantic identifiers in a fully end-to-end manner.
+
+![](images/ca8e40c9da6bcbfccda494eda170b6ca1aeb739f6da3a4c7c0260e628efbee76.jpg)  
+Figure 2: Visual example of a hierarchical clustering process used to assign semantically structured identifiers. During inference, beam search navigates this trie to decode the correct docid.
+
+# Algorithm 1 Generating semantically structured identifiers. (Referenced in Section 3.2.)
+
+To construct identifiers with this property, we employ a simple hierarchical clustering process over document embeddings to induce a decimal tree (or more generally, a trie).
+
+Given a corpus to be indexed, all documents are clustered into 10 clusters. Each document is assigned an identifier with the number of their cluster from 0-9. For every cluster containing more than $c$ documents, the algorithm is applied recursively, with the next level’s result (the remaining suffix of the identifier) appended to the existing identifier.
+
+<table><tr><td>Input:Document embeddings X1:N,where Xi ∈ Rd Output: Corresponding docid strings J1: N function GENERATESEMANTICIDS(X1:N) C1:10←Cluster(Xi:N，k=10) J←empty list fori= O to 9 do</td></tr><tr><td>Jcurrent ← [i]*|Ci+1l if|Ci+1|&gt;c then Jrest ←GENERATESEMANTICIDS(Ci+1)</td></tr><tr><td>else Jrest ← [0,...,|Ci+1|-1]</td></tr><tr><td>end if Jcluster ←elementwiseStrConcat(Jcurrent,Jrest)</td></tr><tr><td>J ←J.appendElements(Jcluster) end for</td></tr><tr><td>J ←reorderToOriginal(J,X1:N，C1:10) return J</td></tr></table>
+
+For clusters with $c$ documents or less, each element is assigned an arbitrary number from 0 to at most $c - 1$ and likewise its digits are appended to the existing identifier. Although this specific process induces a decimal tree, it is possible to induce similar types of tries using any number of other reasonable strategies.In practice, we simply apply $k$ -means over embeddings generated by a small 8-layer BERT model, with $c = 1 0 0$ . We include pseudo-code for this process in Algorithm 1.
+
+# 3.3 Training and Optimization
+
+The DSI models that we train are optimized for seq2seq cross entropy loss and are trained with teacher forcing. We explored two main strategies for training DSI models. The first and more straightforward strategy is to first train a model to perform indexing (memorization), followed by a fine-tuning stage where the trained model is used to map queries to docids (e.g., retrieval). The second strategy is to train them together in a multi-task setup. To this end, we frame co-training tasks in similar fashion to T5-style co-training (e.g., using task prompts to differentiate them). The latter performed significantly better, especially when the proportion of indexing to retrieval task examples is high. Hence, we adopted multi-task learning as the default strategy.
+
+Here, we make the observation that our setup is unique and unlike traditional multi-task learning or transfer learning. In typical multi-task setups, two tasks have shared commonalities that could improve the performance of both tasks if they were learned together. However, in our setup, the retrieval task is completely dependent on the indexing task. In particular, without the indexing task, the identifiers leveraged by the retrieval task would be completely meaningless. Hence, in order to solve task B (retrieval), the model needs to learn task A (indexing) well enough. This problem setup presents unique and largely unexplored research challenges that might be of interest to the ML community.
+
+# 4 Experiments
+
+In this section, we discuss our experimental setup, datasets used and baselines compared. We also discuss experimental results, findings and effect of various strategies discussed in earlier sections of the paper. Since this is fairly new concept, this work aims to put forth a proof-of-concept and seeks to answer research questions instead of making a ‘sotaeesque’ comparison. We leave extensive comparisons on other setups and baselines to future work.
+
+Dataset We conduct our experiments on the challenging Natural Questions (NQ) (Kwiatkowski et al., 2019) dataset. NQ consists of 307K query-document training pairs and 8K validation pairs, where the queries are natural language questions and the documents are Wikipedia articles. Given a question, the retrieval task is to identify the Wikipedia article that answers it. For evaluating how DSI models perform at different scales, we construct three sets from NQ to form our testbed, namely NQ10K, NQ100K, and NQ320K denoting different numbers of total query-document pairs in the combined train and validation splits. NQ320K is the full NQ set and uses its predetermined training and validation split for evaluation purposes. Unlike NQ320K, NQ10K and NQ100K constructs randomly sampled validation sets. For all datasets, we use the same docid space/budget of 320K tokens for all unstructured atomic and naively structured identifier experiments. Semantically structured identifiers are generated separately for each dataset so as to prevent leakage of semantic information from larger splits into smaller ones. Text is lowercased. Note that there exists fewer unique documents than query-document pairs in these datasets. Please refer to Table 4 (Appendix) which reports the statistics of these datasets.
+
+Metrics We evaluate our models on $\mathrm { H i t s } @ \mathrm { N }$ where $\scriptstyle \mathrm { N = } \{ 1 , 1 0 \}$ . This metric reports the proportion of correct documents ranked in the top $N$ predictions.
+
+Implementation Details All DSI models are initialized using standard pretrained T5 (Raffel et al., 2019) model configurations. The configurations names and corresponding number of model parameters are: Base (0.2B), Large (0.8B), XL (3B) and XXL (11B). For unstructured atomic identifiers runs, we initialize the identifiers randomly as new parameters and only finetune the weights during the indexing stage. We use the Jax/T5X 2 implementation for our experiments. The DSI models are trained for a maximum of 1M steps using a batch size of 128. We pick the best checkpoint based on retrieval validation performance. Our training hardware consists of 128-256 TPUv4 chips for models above 1B parameters and 64-128 TPUv3 or TPUv4 chips otherwise. As an estimate, models above 1B parameters typically take about at least a full day for convergence for NQ320K. We tune the learning rate amongst $\{ 0 . 0 0 1 , 0 . 0 0 0 5 \}$ and linear warmup amongst $\{ 1 0 \mathrm { K } , 1 0 0 \mathrm { K } , 2 0 0 \mathrm { K } .$ $3 0 0 \mathrm { K } \}$ and/or none. Semantically structured identifiers are generated using an 8-layer BERT (Devlin et al., 2018) model 3, and the default $k$ -means clustering in scikit-learn. Based on our early ablation experiments of various DSI setting, the main results presented use direct indexing $L = 3 2$ ) and the Inputs2Targets indexing strategy. We present results for all the docid representation methods. Following the main results, we present our ablation studies.
+
+# 4.1 Baselines
+
+For baselines, we use T5-based dual encoders implemented by (Ni et al., 2021). We use the gensim4 package for computing BM25 scores. For the T5-based dual encoders, we train with contrastive learning on the NQ pairs until convergence $\approx 1 0 \mathrm { K }$ steps) and obtain top-k nearest neighbors with a system similar to ScaNN (Guo et al., 2020). For zero-shot retrieval, we also compare with a state-ofthe-art unsupervised baseline, Sentence T5 (Ni et al., 2021) which have been specially pre-trained with a similarity learning task. There two reasons why we consider (Ni et al., 2021) the relevant dual encoder baseline for this work rather than other dense retrieval works such as DPR (Karpukhin et al.,
+
+Table 2: Experimental results on NQ document retrieval. DSI outperforms BM25 and Dual Encoder baselines. Among all the Docid representation methods, Semantic String Docids perform the best.   
+
+<table><tr><td colspan="4"></td><td colspan="2">NQ10K</td><td colspan="2">NQ100K</td><td colspan="2">NQ320K</td></tr><tr><td>Model</td><td>Size</td><td>Params</td><td>Method</td><td>Hits @1</td><td>Hits @10</td><td>Hits@1</td><td>Hits@10</td><td>Hits@1</td><td>Hits@10</td></tr><tr><td>BM25</td><td></td><td>=</td><td>■</td><td>12.4</td><td>33.5</td><td>20.9</td><td>46.4</td><td>11.6</td><td>34.4</td></tr><tr><td>T5</td><td>Base</td><td>220M</td><td>Dual Encoder</td><td>16.2</td><td>48.6</td><td>18.7</td><td>55.2</td><td>20.5</td><td>58.3</td></tr><tr><td>T5</td><td>Large</td><td>800M</td><td>Dual Encoder</td><td>18.8</td><td>55.7</td><td>22.3</td><td>60.5</td><td>22.4</td><td>63.3</td></tr><tr><td>T5</td><td>XL</td><td>3B</td><td>Dual Encoder</td><td>20.8</td><td>59.6</td><td>23.3</td><td>63.2</td><td>23.9</td><td>65.8</td></tr><tr><td>T5</td><td>XXL</td><td>11B</td><td>Dual Encoder</td><td>22.1</td><td>61.6</td><td>24.1</td><td>64.5</td><td>24.3</td><td>67.3</td></tr><tr><td>DSI</td><td>Base</td><td>250M</td><td>Atomic Docid</td><td>13.0</td><td>38.4</td><td>23.8</td><td>58.6</td><td>20.7</td><td>40.9</td></tr><tr><td>DSI</td><td>Large</td><td>800M</td><td>Atomic Docid</td><td>31.3</td><td>59.4</td><td>17.1</td><td>52.3</td><td>11.6</td><td>37.6</td></tr><tr><td>DSI</td><td>XL</td><td>3B</td><td>Atomic Docid</td><td>40.1</td><td>76.9</td><td>19.0</td><td>55.3</td><td>28.1</td><td>61.9</td></tr><tr><td>DSI</td><td>XXL</td><td>11B</td><td>Atomic Docid</td><td>39.4</td><td>77.0</td><td>25.3</td><td>67.9</td><td>24.0</td><td>55.1</td></tr><tr><td>DSI</td><td>Base</td><td>250M</td><td>Naive String Docid</td><td>28.1</td><td>48.0</td><td>18.7</td><td>44.6</td><td>6.7</td><td>21.0</td></tr><tr><td>DSI</td><td>Large</td><td>800M</td><td>Naive String Docid</td><td>34.7</td><td>60.5</td><td>21.2</td><td>50.7</td><td>13.3</td><td>33.6</td></tr><tr><td>DSI</td><td>XL</td><td>3B</td><td>Naive String Docid</td><td>44.7</td><td>66.4</td><td>24.0</td><td>55.1</td><td>16.7</td><td>58.1</td></tr><tr><td>DSI</td><td>XXL</td><td>11B</td><td>Naive String Docid</td><td>46.7</td><td>77.9</td><td>27.5</td><td>62.4</td><td>23.8</td><td>55.9</td></tr><tr><td>DSI</td><td>Base</td><td>250M</td><td>Semantic String Docid</td><td>33.9</td><td>57.3</td><td>19.0</td><td>44.9</td><td>27.4</td><td>56.6</td></tr><tr><td>DSI</td><td>Large</td><td>800M</td><td>Semantic String Docid</td><td>37.5</td><td>65.1</td><td>20.4</td><td>50.2</td><td>35.6</td><td>62.6</td></tr><tr><td>DSI</td><td>XL</td><td>3B</td><td>Semantic String Docid</td><td>41.9</td><td>67.1</td><td>22.4</td><td>52.2</td><td>39.1</td><td>66.8</td></tr><tr><td>DSI</td><td>XXL</td><td>11B</td><td>Semantic String Docid</td><td>48.5</td><td>72.1</td><td>26.9</td><td>59.5</td><td>40.4</td><td>70.3</td></tr></table>
+
+Table 3: Experimental results on Zero-Shot NQ document retrieval. DSI outperforms BM25, T5 embeddings and SentenceT5, the state-of-the-art for unsupervised similarity modeling. Among Docid representation method, the Atomic Docid performs the best on zero-shot learning.   
+
+<table><tr><td rowspan="2">Size</td><td rowspan="2">Method</td><td rowspan="2"></td><td colspan="2">NQ10K</td><td colspan="2">NQ100K</td><td colspan="2">NQ320K</td></tr><tr><td>Hits@1</td><td>Hits@10</td><td>Hits@1</td><td>Hits@10</td><td>Hits@1</td><td>Hits @10</td></tr><tr><td>BM25</td><td>=</td><td></td><td>12.4</td><td>33.5</td><td>20.9</td><td>46.4</td><td>11.6</td><td>34.4</td></tr><tr><td>T5</td><td>XXL</td><td>Dual Encoder</td><td>0.3</td><td>1.3</td><td>1.9</td><td>8.0</td><td>1.1</td><td>5.9</td></tr><tr><td>SentenceT5</td><td>Large</td><td>Dual Encoder</td><td>17.6</td><td>50.7</td><td>17.4</td><td>50.8</td><td>16.9</td><td>51.0</td></tr><tr><td>DSI</td><td>XXL</td><td>Atomic Docid</td><td>25.7</td><td>60.1</td><td>23.0</td><td>57.3</td><td>25.1</td><td>56.6</td></tr><tr><td>DSI</td><td>XXL</td><td>Naive String Docid</td><td>43.4</td><td>67.4</td><td>17.4</td><td>41.5</td><td>9.2</td><td>22.6</td></tr><tr><td>DSI</td><td>XXL</td><td>Semantic String Docid</td><td>43.9</td><td>68.8</td><td>11.4</td><td>26.6</td><td>13.9</td><td>31.1</td></tr></table>
+
+2020). Firstly, we employ the exact identical pretrained model, which allows systematic ablation of the proposed approach without conflating other factors. Scientifically, we believe this comparison against fine-tuned T5 is the best apples to apples comparison that we provide. Secondly, fine-tuned T5 dual encoders are considered to be architecturally and methodologically very identical to DPR (with some minor differences such as parameter sharing but use the same concept of in-batch negatives).
+
+# 4.2 Experimental Results
+
+Table 2 reports retrieval results for NQ10K, NQ100K, and NQ320K with finetuning and Table 3 reports zero-shot retrieval results. For zero-shot retrieval, the model is only trained on the indexing task and not the retrieval task, so the model sees no labeled query docid data points. Section 7.2 of the Appendix reports extended results regarding the indexing performance and training dynamics of DSI.
+
+Supervised Finetuning Results Our results show that DSI outperforms DE across all dataset sizes. On the small dataset (NQ10K), the performance gap between DSI and DE is large, e.g., the best DSI variant outperforms DE by 2 times. On NQ100K, the gap becomes less prominent with the best DSI model (unstructured atomic identifiers) outperforming DE by $+ 5 \%$ Hits $@ 1$ and Hits $@ 1 0$ . On the large dataset (NQ320K), the best DSI model (structured semantic identifiers) outperform the best DE model by $+ 6 6 \%$ relative Hits $@ 1$ and $+ 4 . 5 \%$ Hits $@ 1 0$ .
+
+Zero-Shot Results Table 3 reports results on zeros-shot retrieval. Recall that zero-shot retrieval is performed by only performing indexing and not the retrieval task. In other words, the model does not see any annotated query or document pairs. Generally, the best result is obtained by DSI with unstructured atomic identifiers on both NQ100K and NQ320K. The best performance on all NQ datasets outperform well-established unsupervised retrieval baselines such as BM25. Moreover, DSI outperforms unsupervised representation learning methods such as SentenceT5 (Ni et al., 2021), which is trained to learn similarity-aware representations via contrastive learning. We also note that raw T5 embeddings perform extremely poorly and do not produce reasonable results on the task of unsupervised retrieval. Given that it is generally difficult for an unsupervised neural method to outperform BM25, we find these early results very encouraging.
+
+![](images/a25295c9c750475e0cada8ddeb780add2a01d5ac609f23b0f174f396b20118ed.jpg)  
+Figure 3: Scaling plots for DSI vs. DE across model sizes. Performance refers to the Hits $@ 1$ metric.
+
+![](images/680d9297a4ac25120008bee489f0dc5a602e475768036fe8b8ce96ca48c08223.jpg)  
+Figure 4: Effect of multi-task ratio of indexing to retrieval examples.
+
+![](images/0643a55d3d5cc43d5ebca292a304e3942d718a5bca8ec0e94659d6c9f16b589a.jpg)  
+Figure 5: Performance of different document representations. (Referenced in Section 4.2.)
+
+Document Identifiers One key research question in this paper is the crucial choice of how to represent docids. Generally, we find that structured semantic identifiers are helpful and improve over unstructured identifiers. When comparing naive versus semantic string identifiers, it seems imperative to use semantic identifiers if possible. This is intuitive, since imbuing the target space with semantic structure can facilitate greater ease of optimization and additional unsupervised representation learning methods as external knowledge. The competitiveness of unstructured atomic identifiers is somewhat mixed and we had some difficulty optimizing such models. We hypothesize that this could possibly be because of the the newly initialized softmax layer and that training such a system from scratch would mitigate these issues. However, we defer this line of investigation to future work. In lieu of the instability and high variance of the unstructured atomic identifiers, the performance is not consistent across the different datasets. Moreover, these docids might also run into intermittent non-convergence which we trace back to an optimization related quirk. However, we also note that unstructured atomic identifiers perform the best, by a wide margin, on the zero-shot retrieval setup and achieve performance often more than double than that of beam decoding methods.
+
+Indexing Strategies In this section, we explore the effect of different indexing methods (Section 3.1.1). We run experiments on NQ100K with the different indexing strategies described earlier. Models are trained using the Naive Docid method. Without indexing, the model achieves $0 \%$ Hits $@ 1$ . This is intuitive, since the Docids are not meaningful without the indexing task. Secondly, the Inputs2Targets and Bidirectional formulation performs the best, with the bidirectional method performing slightly worse (13.5 vs 13.2) compared to the former. Finally, the accuracy with Targets2Inputs and Span Corrpution with Docids yield no meaningful results ( $\mathrm { { \bar { 0 } \% } }$ accuracy). This goes to show that there can be huge variance across indexing strategies whereby some strategies work reasonably well and some completely do not work at all.
+
+Document Representations In this section, we explore the performance of the different document representation strategies described in Section 3.1.2. Figure 5 reports the results on NQ320K. Overall, we find that the direct indexing approach works the best. We also find that it is difficult to train the inverted index method since the docid is repeatedly exposed to different tokens. We also find that shorter document lengths seem to work well where performance seems to substantially dip beyond 64 tokens suggesting that it might be harder to optimize or efficiently memorize when there are a larger number of document tokens. Finally, we also find that there was no additional advantage in applying set processing or stopwords preprocessing to the document tokens.
+
+Scaling Laws Another interesting insight is how the scaling law of DSI differs from Dual Encoders. Understanding the scaling behaviour of Transformers have garnered significant interest in recent years (Kaplan et al., 2020; Tay et al., 2021; Abnar et al., 2021). We find that the gain in retrieval performance obtained from increasing model parameterization in DE seems to be relatively small. Conversely, the scaling properties of DSI seems to be more optimistic.
+
+Figure 3 plots the scaling behaviour (log scale) of three methods (DE and DSI with naive and semantic IDs). DSI (naive) strongly benefits from scale going from base to XXL and seems to still have headroom for improvement. Meanwhile, DSI (semantic) starts off equally competitive as DE base but performs much better with scale. DE models, unfortunately are more or less plateaued at smaller parameterization.
+
+Interplay Between Indexing and Retrieval Our early experiments showed that first learning the indexing task and then learning the retrieval task in a sequential manner results in mediocre performance. There, we focused on exploring good ratios $r$ for co-training the indexing and retrieval tasks together using multi-task learning. Figure 4 shows the effect of modifying the ratio of indexing to retrieval samples. We find the optimization process is significantly influenced by the interplay between the indexing and retrieval tasks. Setting $r$ too high or low generally resulted in poor performance. We find that a rate of 32 generally performed well.
+
+# 5 Conclusion
+
+This paper proposed the Differentiable Search Index (DSI), a new paradigm for learning an end-to-end search system in a unified manner, paving the way for next generation search (Metzler et al., 2021). We define novel indexing and retrieval tasks that encode the relationship between terms and docids completely within the parameters of a Transformer model. The paper proposed a number of different ways to represent documents and docids, and explored different model architectures and model training strategies. Experiments conducted on the Natural Questions data set show that DSI performs favorably against common baselines such as BM25 and dual encoders, both in a standard fine-tuning setup as well as in a zero-shot setup.
+
+Although the models and results presented here are promising, there is a great deal of potential future research that can be explored based on this work to improve this approach. For example, it would be interesting to explore alternative strategies for representing documents and docids, as well as to investigate mixture-of-expert models (Du et al., 2021; Fedus et al., 2021; Lepikhin et al., 2020) for scaling the memory capacity of DSI. One important direction will also be to explore how such models can be updated for dynamic corpora, where documents may be added or removed from the system. Finally it may also be interesting to further investigate DSI as an unsupervised representation learning method and/or memory store for other language models to leverage.
+
+# 6 Acknowledgements
+
+The authors would like to thank you Fernando Pereira, Huaixiu Steven Zheng, Sebastian Ruder, Adam D. Lelkes, Ian Wetherbee and Dani Yogatama for their valuable feedback and discussions. We would also like to extend a special thanks to Sanket Vaibhav Mehta for additional experimental contributions.
+
+# References
+
+Samira Abnar, Mostafa Dehghani, Behnam Neyshabur, and Hanie Sedghi. Exploring the limits of large scale pre-training. arXiv preprint arXiv:2110.02095, 2021.
+
+Sebastian Borgeaud, Arthur Mensch, Jordan Hoffmann, Trevor Cai, Eliza Rutherford, Katie Millican, George van den Driessche, Jean-Baptiste Lespiau, Bogdan Damoc, Aidan Clark, et al. Improving language models by retrieving from trillions of tokens. arXiv preprint arXiv:2112.04426, 2021.
+
+Tom B Brown, Benjamin Mann, Nick Ryder, Melanie Subbiah, Jared Kaplan, Prafulla Dhariwal, Arvind Neelakantan, Pranav Shyam, Girish Sastry, Amanda Askell, et al. Language models are few-shot learners. arXiv preprint arXiv:2005.14165, 2020.
+
+Nicola De Cao, Gautier Izacard, Sebastian Riedel, and Fabio Petroni. Autoregressive entity retrieval. arXiv preprint arXiv:2010.00904, 2020.
+
+Mostafa Dehghani, Hamed Zamani, Aliaksei Severyn, Jaap Kamps, and W Bruce Croft. Neural ranking models with weak supervision. In Proceedings of the 40th International ACM SIGIR Conference on Research and Development in Information Retrieval, pages 65–74, 2017.
+
+Jacob Devlin, Ming-Wei Chang, Kenton Lee, and Kristina Toutanova. Bert: Pre-training of deep bidirectional transformers for language understanding. arXiv preprint arXiv:1810.04805, 2018.
+
+Nan Du, Yanping Huang, Andrew M Dai, Simon Tong, Dmitry Lepikhin, Yuanzhong Xu, Maxim Krikun, Yanqi Zhou, Adams Wei Yu, Orhan Firat, et al. Glam: Efficient scaling of language models with mixture-of-experts. arXiv preprint arXiv:2112.06905, 2021.
+
+William Fedus, Barret Zoph, and Noam Shazeer. Switch transformers: Scaling to trillion parameter models with simple and efficient sparsity. arXiv preprint arXiv:2101.03961, 2021.
+
+Tianyu Gao, Xingcheng Yao, and Danqi Chen. SimCSE: Simple contrastive learning of sentence embeddings. In Proceedings of the 2021 Conference on Empirical Methods in Natural Language Processing, pages 6894–6910, Online and Punta Cana, Dominican Republic, November 2021. Association for Computational Linguistics. doi: 10.18653/v1/2021.emnlp-main.552. URL https: //aclanthology.org/2021.emnlp-main.552.
+
+Mor Geva, Roei Schuster, Jonathan Berant, and Omer Levy. Transformer feed-forward layers are key-value memories. arXiv preprint arXiv:2012.14913, 2020.
+
+Daniel Gillick, Alessandro Presta, and Gaurav Singh Tomar. End-to-end retrieval in continuous space. arXiv preprint arXiv:1811.08008, 2018.
+
+Ruiqi Guo, Philip Sun, Erik Lindgren, Quan Geng, David Simcha, Felix Chern, and Sanjiv Kumar. Accelerating large-scale inference with anisotropic vector quantization. In International Conference on Machine Learning, 2020. URL https://arxiv.org/abs/1908.10396.
+
+Kelvin Guu, Kenton Lee, Zora Tung, and Panupong Pasupat. REALM: Retrieval-Augmented Language Model Pre-Training. In Proceedings of ICML 2020, 2020.
+
+Martin Josifoski, Nicola De Cao, Maxime Peyrard, and Robert West. Genie: Generative information extraction. arXiv preprint arXiv:2112.08340, 2021.
+
+Jared Kaplan, Sam McCandlish, Tom Henighan, Tom B Brown, Benjamin Chess, Rewon Child, Scott Gray, Alec Radford, Jeffrey Wu, and Dario Amodei. Scaling laws for neural language models. arXiv preprint arXiv:2001.08361, 2020.
+
+Vladimir Karpukhin, Barlas Oguz, Sewon Min, Patrick Lewis, Ledell Wu, Sergey Edunov, Danqi ˘ Chen, and Wen-tau Yih. Dense passage retrieval for open-domain question answering. arXiv preprint arXiv:2004.04906, 2020.
+
+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. Natural Questions: a Benchmark for Question Answering Research. In Transactions of the ACL, 2019.
+
+Dmitry Lepikhin, HyoukJoong Lee, Yuanzhong Xu, Dehao Chen, Orhan Firat, Yanping Huang, Maxim Krikun, Noam Shazeer, and Zhifeng Chen. Gshard: Scaling giant models with conditional computation and automatic sharding. arXiv preprint arXiv:2006.16668, 2020.
+
+Donald Metzler, Yi Tay, Dara Bahri, and Marc Najork. Rethinking search: making domain experts out of dilettantes. In ACM SIGIR Forum, volume 55, pages 1–27. ACM New York, NY, USA, 2021.
+
+Jianmo Ni, Gustavo Hernández Ábrego, Noah Constant, Ji Ma, Keith B Hall, Daniel Cer, and Yinfei Yang. Sentence-t5: Scalable sentence encoders from pre-trained text-to-text models. arXiv preprint arXiv:2108.08877, 2021.
+
+Fabio Petroni, Tim Rocktäschel, Patrick Lewis, Anton Bakhtin, Yuxiang Wu, Alexander H Miller, and Sebastian Riedel. Language models as knowledge bases? arXiv preprint arXiv:1909.01066, 2019.
+
+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. arXiv preprint arXiv:1910.10683, 2019.
+
+Hubert Ramsauer, Bernhard Schäfl, Johannes Lehner, Philipp Seidl, Michael Widrich, Thomas Adler, Lukas Gruber, Markus Holzleitner, Milena Pavlovic, Geir Kjetil Sandve, et al. Hopfield networks ´ is all you need. arXiv preprint arXiv:2008.02217, 2020.
+
+Adam Roberts, Colin Raffel, and Noam Shazeer. How much knowledge can you pack into the parameters of a language model? arXiv preprint arXiv:2002.08910, 2020.
+
+Yu Sun, Xiaolong Wang, Zhuang Liu, John Miller, Alexei Efros, and Moritz Hardt. Test-time training with self-supervision for generalization under distribution shifts. In Hal Daumé III and Aarti Singh, editors, Proceedings of the 37th International Conference on Machine Learning, volume 119 of Proceedings of Machine Learning Research, pages 9229–9248. PMLR, 13–18 Jul 2020. URL https://proceedings.mlr.press/v119/sun20b.html.
+
+Ilya Sutskever, Oriol Vinyals, and Quoc V Le. Sequence to sequence learning with neural networks. arXiv preprint arXiv:1409.3215, 2014.
+
+Yi Tay, Mostafa Dehghani, Jinfeng Rao, William Fedus, Samira Abnar, Hyung Won Chung, Sharan Narang, Dani Yogatama, Ashish Vaswani, and Donald Metzler. Scale efficiently: Insights from pre-training and fine-tuning transformers. arXiv preprint arXiv:2109.10686, 2021.
+
+Romal Thoppilan, Daniel De Freitas, Jamie Hall, Noam Shazeer, Apoorv Kulshreshtha, Heng-Tze Cheng, Alicia Jin, Taylor Bos, Leslie Baker, Yu Du, et al. Lamda: Language models for dialog applications. arXiv preprint arXiv:2201.08239, 2022.
+
+Ashish Vaswani, Noam Shazeer, Niki Parmar, Jakob Uszkoreit, Llion Jones, Aidan N Gomez, Łukasz Kaiser, and Illia Polosukhin. Attention is all you need. In Advances in neural information processing systems, pages 5998–6008, 2017.
+
+# Checklist
+
+1. For all authors...
+
+(a) Do the main claims made in the abstract and introduction accurately reflect the paper’s contributions and scope? [Yes]   
+(b) Did you describe the limitations of your work? [Yes] We highlight that this is a proofof-concept for a new paradigm, and not geared towards SOTA comparisons (Section 4). Clearly, many open problems still remain such as index updating, scaling to larger datasets, etc.   
+(c) Did you discuss any potential negative societal impacts of your work? [No] Our work effectively provides the same end functionality as existing information retrieval systems.   
+(d) Have you read the ethics review guidelines and ensured that your paper conforms to them? [Yes]
+
+2. If you are including theoretical results...
+
+(a) Did you state the full set of assumptions of all theoretical results? [N/A] No theoretical results. (b) Did you include complete proofs of all theoretical results? [N/A] No theoretical results
+
+3. If you ran experiments...
+
+(a) Did you include the code, data, and instructions needed to reproduce the main experimental results (either in the supplemental material or as a URL)? [Yes] All experiments were ran using publicly available T5X codebase, with publicly available Natural Questions dataset. All necessary details were included to reproduce the experiments.   
+(b) Did you specify all the training details (e.g., data splits, hyperparameters, how they were chosen)? [Yes] See Section 4, under Implementation Details.   
+(c) Did you report error bars (e.g., with respect to the random seed after running experiments multiple times)? [No] As these experiments are expensive, experiments were not ran multiple times to save compute.   
+(d) Did you include the total amount of compute and the type of resources used (e.g., type of GPUs, internal cluster, or cloud provider)? [Yes] Please see Section 4 under Implementation Details.
+
+4. If you are using existing assets (e.g., code, data, models) or curating/releasing new assets...
+
+(a) If your work uses existing assets, did you cite the creators? [Yes]   
+(b) Did you mention the license of the assets? [No] We comply with the license of all code repositories and public datasets as detailed in the cited sources.   
+(c) Did you include any new assets either in the supplemental material or as a URL? [N/A] No new assets introduced at this time.   
+(d) Did you discuss whether and how consent was obtained from people whose data you’re using/curating? [N/A] We did not curate data.   
+(e) Did you discuss whether the data you are using/curating contains personally identifiable information or offensive content? [N/A] We did not curate data.
+
+5. If you used crowdsourcing or conducted research with human subjects...
+
+(a) Did you include the full text of instructions given to participants and screenshots, if applicable? [N/A]   
+(b) Did you describe any potential participant risks, with links to Institutional Review Board (IRB) approvals, if applicable? [N/A]   
+(c) Did you include the estimated hourly wage paid to participants and the total amount spent on participant compensation? [N/A]

parse/dev/Vu-B0clPfq/Vu-B0clPfq_content_list.json

@@ -0,0 +1,1622 @@
+[
+    {
+        "type": "text",
+        "text": "Transformer Memory as a Differentiable Search Index ",
+        "text_level": 1,
+        "bbox": [
+            331,
+            122,
+            666,
+            172
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Yi Tay∗, Vinh Q. Tran∗, Mostafa Dehghani, Jianmo Ni, Dara Bahri, Harsh Mehta Zhen Qin, Kai Hui, Zhe Zhao, Jai Gupta, Tal Schuster William W. Cohen, Donald Metzler Google Research {yitay,vqtran,metzler}@google.com ",
+        "bbox": [
+            215,
+            220,
+            781,
+            291
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Abstract ",
+        "text_level": 1,
+        "bbox": [
+            462,
+            327,
+            535,
+            343
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "In this paper, we demonstrate that information retrieval can be accomplished with a single Transformer, in which all information about the corpus is encoded in the parameters of the model. To this end, we introduce the Differentiable Search Index (DSI), a new paradigm that learns a text-to-text model that maps string queries directly to relevant docids; in other words, a DSI model answers queries directly using only its parameters, dramatically simplifying the whole retrieval process. We study variations in how documents and their identifiers are represented, variations in training procedures, and the interplay between models and corpus sizes. Experiments demonstrate that given appropriate design choices, DSI significantly outperforms strong baselines such as dual encoder models. Moreover, DSI demonstrates strong generalization capabilities, outperforming a BM25 baseline in a zero-shot setup. ",
+        "bbox": [
+            233,
+            358,
+            766,
+            525
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 Introduction ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            549,
+            312,
+            566
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Information retrieval (IR) systems map a user query $q \\in \\mathcal { Q }$ to a ranked list of relevant documents $\\{ d _ { 1 } , \\ldots , d _ { n } \\} \\subseteq { \\mathcal { D } }$ , typically represented by integers or short strings called document identifiers (docids). The most widely used IR approaches are based on pipelined retrieve-then-rank strategies. For retrieval, approaches based on inverted indexes or nearest neighbor search are common where contrastive learning based dual encoders (DEs) (Gillick et al., 2018; Karpukhin et al., 2020; Ni et al., 2021) are the present state-of-the-art. ",
+        "bbox": [
+            174,
+            580,
+            825,
+            664
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "This paper proposes an alternative architecture, wherein a sequence-to-sequence (seq2seq) learning system (Sutskever et al., 2014) is used to directly map a query $q$ to a relevant docid $j \\in \\mathcal { V }$ . This proposal is shown in the bottom half of Figure 1, for a sequence-to-sequence encoder-decoder architecture. ",
+        "bbox": [
+            174,
+            670,
+            825,
+            726
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "We call this proposed architecture a differentiable search index (DSI), and implement it with a large pre-trained Transformer (Vaswani et al., 2017) model, building on the recent success of large generative language models (LMs) (Brown et al., 2020; Raffel et al., 2019; Devlin et al., 2018; Thoppilan et al., 2022; Du et al., 2021). In this proposed architecture, all information of the corpus is encoded within the parameters of the Transformer language model. ",
+        "bbox": [
+            174,
+            733,
+            825,
+            803
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "At inference time, the trained model takes as input a text query $q$ and outputs a docid $j$ . If desired, beam search can be used to produce a ranked list of potentially-relevant docids. As we show, this process can work surprisingly well when trained properly. In our experiments it can consistently outperform DE baselines, sometimes drastically: for a base-sized T5 model, Hits $@ 1$ on the smallest corpus is improved by more than 20 points, from $12 . 4 \\%$ for a DE to $3 3 . 9 \\%$ for DSI; and on a corpus ",
+        "bbox": [
+            174,
+            808,
+            823,
+            878
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "image",
+        "img_path": "images/eacb2af8183bec70b70f2a09eee77df951e39feffe94596b4470a5cd1d6c64bb.jpg",
+        "image_caption": [
+            "Figure 1: Comparison of dual encoders (top) to differentiable search index (bottom). "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            189,
+            88,
+            818,
+            276
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "table",
+        "img_path": "images/724a9c34e150a667a630e5761fdfbefed61ea0e4d5c14f54be038e07f59d1e63.jpg",
+        "table_caption": [
+            "Table 1: Information retrieval requires a series of decisions, associated with the subproblems of document representation, indexing, and retrieval. Structured-document variants of DSI are also sensitive to a fourth decision, namely how docids are represented. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td></td><td>BM25 or TFIDF</td><td>Dual Encoder (DE)</td><td>Differentiable Search Index (DSI</td></tr><tr><td>doc/query rep.</td><td> sparse Vdj vector in R|VI</td><td>dense Vdj vector in Rd</td><td>Various (see Section 3.1.2)</td></tr><tr><td>docid rep.</td><td></td><td></td><td>Various (see Section 3.2)</td></tr><tr><td>indexing</td><td>build inverted index mapping each termt→{dji,...,djx}</td><td>build table mapping each docvec Vd→ j</td><td>train model (see Section 3.1.1) to map dj → j</td></tr><tr><td>retrieval (top-1)</td><td>approximate sparse matmul to find argmaxjv Vdj</td><td>approximate MIPS to find argmaxjv Vdj</td><td>run trained model to find argmax Pr(jlq)</td></tr></table>",
+        "bbox": [
+            173,
+            371,
+            839,
+            496
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "$3 0 \\times$ larger, performance is improved by nearly 7 points. These gains increase when larger models are used: for an 11B-parameter T5 model, Hits $@ 1$ performance improves by more than 25 points over DE on the small corpus, and more than 15 points on the large corpus. DSI also performs extremely well in a zero-shot setting, e.g., improving Hits $@ 1$ by 14 points over BM25. ",
+        "bbox": [
+            173,
+            525,
+            825,
+            580
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "In addition to these quantitative gains, the DSI architecture is much simpler than a DE (see Table 1). A DE system fixes a search procedure (MIPS) and learns internal representations that optimize performance for that search procedure; in contrast, a DSI system contains no special-purpose fixed search procedure, instead using standard model inference to map from encodings to docids. ",
+        "bbox": [
+            174,
+            587,
+            825,
+            642
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Of particular interest to the machine learning community, as Table 1 shows, in DSI all aspects of retrieval are mapped into well-understood ML tasks. This may lead to new potential approaches to solving long-standing IR problems. As one example, since indexing is now a special case of model training, incrementally updating an index becomes a special case of model updating (Sun et al., 2020). ",
+        "bbox": [
+            174,
+            648,
+            825,
+            704
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "In this paper, DSI is applied to moderate-sized corpora (from 10k to $3 2 0 \\mathrm { k }$ documents), all of which are derived from one challenging retrieval task, and we leave the important question of the scaling DSI to larger corpora to future work. The task considered is retrieving supporting passages given questions from the Natural Questions (NQ) dataset, a challenging task for lexical models. ",
+        "bbox": [
+            174,
+            710,
+            825,
+            767
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "While the idea of DSI is simple, there are a number of ways it can be realized, some of which work surprisingly well, and some of which work surprisingly poorly. Below we explore a number of variations of the DSI architecture. ",
+        "bbox": [
+            174,
+            772,
+            825,
+            814
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Document representation. We explore several approaches to representing documents, including a “naive” approach of using the document’s full text, as well as variants of the bag-of-words representation used by traditional IR engines. ",
+        "bbox": [
+            174,
+            820,
+            825,
+            863
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Docid representation. We look at several ways to represent docids. In addition to naively representing integers as text strings, we also consider unstructured atomic docids, where each document is assigned a unique token, and some simple baselines for constructing structured semantic docids that describe how to navigate to a document through a hierarchical clustering of the corpus. Structured docids— either semantically structured via clustering, or naively structured as tokenized integers—scale better to large corpora, since the size of the vocabulary used in the decoder is made larger. ",
+        "bbox": [
+            174,
+            869,
+            825,
+            911
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            90,
+            823,
+            132
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Indexing. A trainable IR system traditionally has two phases: indexing a corpus (i.e., memorizing information about each document), and learning how to effectively retrieve from the index. In DSI, the index is stored in the model parameters, and indexing is simply another kind of model training. Figure 1 suggests one approach to indexing a corpus: namely, to train on (1) examples $( d _ { j } , j )$ that pair document $d _ { j }$ with its docid $j$ , in addition to (2) examples $( q , j )$ that pair a query $q$ with a relevant docid $j$ . In this setup the examples of type (1) are “indexing” examples. ",
+        "bbox": [
+            174,
+            140,
+            825,
+            223
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "While it is clear that examples of type (2) alone do not provide enough information for a system to generalize to novel retrievals, there are many alternatives to examples of type (1) that might plausibly “teach” a model about the associations between documents and docids. We explore a number of these below, and show that some plausible-seeming techniques perform very poorly. We also explore a number of alternative multi-task optimization and curriculum learning schemes for combining these types of examples. ",
+        "bbox": [
+            173,
+            229,
+            825,
+            313
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Effects of model and corpus size. Since recent results suggest that some properties of large LMs emerge only for very large model sizes Brown et al. (2020), we explore the performance of DSI for a range of model sizes and corpus sizes of 10k, 100k, and 320k documents. ",
+        "bbox": [
+            178,
+            319,
+            821,
+            359
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Summary. We show that even naive representations for documents and docids, coupled with appropriate training procedures to fine-tune modern large LMs, can perform surprisingly well; we present two improved docid representations, unstructured docids and semantically-structured docids, which improve the naive representation choice. We show that there is substantial variation in performance among indexing/training strategies and we show that performance of DSI significantly and consistently improves with model scale. To our knowledge this is the first case of generative indexing improving performance over strong baselines for a well-studied document retrieval task. ",
+        "bbox": [
+            174,
+            367,
+            825,
+            464
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "2 Related Work ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            489,
+            321,
+            506
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "De Cao et al. (2020) describe a related sequence-to-sequence system called autoregressive entity linking, in which documents mentioning an entity—perhaps implicitly, e.g., by posing a question to which that entity is an answer—are mapped to a canonical name of that entity. In the case of Wikipedia, canonical entity names correspond to page titles, so this could be viewed as a sort of document retrieval. This approach has been adapted to other purposes, such as generating knowledge base triples in canonical form (Josifoski et al., 2021). The task we consider is different from those considered in autoregressive entity linking: our goal is to retrieve a document containing the answer, rather than a document whose title is the answer. More importantly, in autoregressive entity linking the generation target is a semantically meaningful name, whereas we allow targets to be arbitrary docids. This makes our approach applicable to general retrieval tasks, but raises new questions about docid representation and indexing strategies. ",
+        "bbox": [
+            174,
+            525,
+            825,
+            678
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "In autoregressive entity linking, generation is constrained to return an output from a fixed set. It would be feasible to constrain DSI generation outputs to be valid docids. Although we do not use this technique, the degree to which this might improve performance is a worthwhile question. ",
+        "bbox": [
+            174,
+            684,
+            825,
+            726
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "There is a large body of work on retrieval augmented generation, i.e., retrieving auxiliary documents to enhance language models (Borgeaud et al., 2021; Guu et al., 2020). These techniques are useful for many tasks including question-answering, but rely on traditional retrieval methods such as DEs. Here we use generation to replace a retrieval process, rather than using retrieval to augment a generation process. ",
+        "bbox": [
+            174,
+            731,
+            825,
+            801
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Dual encoders (Dehghani et al., 2017; Gillick et al., 2018; Gao et al., 2021; Ni et al., 2021; Karpukhin et al., 2020) are a well-established paradigm for retrieval. The key idea is produce query and document embeddings independently and perform a similarity retrieval in vector space across all embedding pairs. Query and candidate documents are produced by a sequence encoder and training is performed using a form of contrastive loss. ",
+        "bbox": [
+            174,
+            806,
+            825,
+            876
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "The interpretation of a large Transformer model as a memory store have been investigated in prior work. (Roberts et al., 2020) demonstrated success on a closed-book QA task whereby they train ",
+        "bbox": [
+            174,
+            883,
+            821,
+            911
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "T5 models to retrieve facts that are encoded within the parameters of the model during pretraining. However, different from CBQA, the presented problem here in this paper is to retrieve full documents based on docids instead of generating direct answers. Meanwhile, (Petroni et al., 2019) also investigated language models as knowledge bases and found that pretrained LMs may already contain relational knowledge. (Geva et al., 2020) analyzes the knowledge encoded within Transformer feedforward layers. There have been also works that demonstrate the relation of Transformers to associative memory and Hopfield networks (Ramsauer et al., 2020), which reinforce the notion that Transformers should intuitively serve as a good associative memory store or search index. ",
+        "bbox": [
+            174,
+            90,
+            825,
+            202
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3 Differentiable Search Index ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            220,
+            436,
+            238
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "The core idea behind the proposed Differentiable Search Index (DSI) is to fully parameterize traditionally multi-stage retrieve-then-rank pipelines within a single neural model. To do so, DSI models must support two basic modes of operation: ",
+        "bbox": [
+            176,
+            252,
+            823,
+            295
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "• Indexing: a DSI model should learn to associate the content of each document $d _ { j }$ with its corresponding docid $j$ . This paper utilizes a straightforward sequence-to-sequence (seq2seq) approach that takes document tokens as input and generates identifiers as output. • Retrieval: Given an input query, a DSI model should return a ranked list of candidate docids. Here, this is achieved with autoregressive generation. ",
+        "bbox": [
+            214,
+            308,
+            825,
+            382
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Following these two operations, a DSI model can be trained to index a corpus of documents and optionally fine-tune on an available set of labeled data (queries and labeled documents), and thereafter used to retrieve relevant documents—all within a single, unified model. As opposed to retrieve-thenrank approaches, this type of model allows for simple end-to-end training and can easily be used as a differentiable sub-component of a larger, more complex neural model. ",
+        "bbox": [
+            174,
+            395,
+            825,
+            464
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3.1 Indexing Strategies ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            481,
+            348,
+            496
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "We investigate various indexing strategies that are meant to learn associations between documents and their identifiers. We train our model to predict docids given a sequence of document tokens. This allows our model to learn which identifier belongs to which document and can be thought of as a differentiable take on traditional search indexes. We consider various alternatives and ablate these settings in subsequent sections. The final strategy employed was Inputs2Targets with direct indexing. ",
+        "bbox": [
+            174,
+            506,
+            825,
+            577
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3.1.1 Indexing Method ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            590,
+            346,
+            604
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "This section discusses the indexing task variants that we consider. ",
+        "bbox": [
+            174,
+            613,
+            602,
+            628
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Inputs2Target We frame this as a seq2seq task of doc_tokens docid. As its name suggests, this binds the docids to the document tokens in a straightforward inputs-to-targets fashion. The advantage here is that the identifier is the denoising target, which puts it in closer proximity to the loss function. Since the retrieval task is also concerned with predicting identifiers, this formulation allows the network to follow a similar input-target balance in terms of sequence length. A potential weakness is that the document tokens are not denoising targets and therefore there is no opportunity for general pre-training on document tokens. ",
+        "bbox": [
+            174,
+            643,
+            825,
+            741
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Targets2Inputs This formulation considers the opposite of the above, i.e., generating document tokens from identifiers, i.e., docid doc_tokens. Intuitively, this is equivalent to training an autoregressive language model that is conditioned on the docid. ",
+        "bbox": [
+            176,
+            756,
+            821,
+            797
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Bidirectional This formulation trains both Inputs2Targets and Targets2Inputs within the same co-training setup. A prefix token is prepended to allow the model to know which direction the task is being performed in. ",
+        "bbox": [
+            174,
+            811,
+            825,
+            854
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Span Corruption We also explored a setup that performs span corruption-based denoising (Raffel et al., 2019) with the inclusion of docid tokens. In this approach, we concatenate the identifier to the document tokens as a prefix that can be randomly masked as spans in the span corruption objective. ",
+        "bbox": [
+            176,
+            869,
+            825,
+            911
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "This method has the advantage of (1) also performing general pre-training during indexing and (2) achieving a good balance of docids as denoising targets and inputs. ",
+        "bbox": [
+            173,
+            90,
+            825,
+            119
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "3.1.2 Document Representation Strategies ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            136,
+            478,
+            150
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "In the previous section, we explored “how to index”. This section investigates “what to index?”, i.e., how to best represent doc_tokens. We state our options here and carefully ablate them in our experiments later. The best option in the end was the direct indexing method. ",
+        "bbox": [
+            174,
+            160,
+            825,
+            202
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Direct Indexing This strategy represents a document exactly. We take the first $L$ tokens of a document, with sequential order preserved, and associate them with the docid. ",
+        "bbox": [
+            173,
+            218,
+            823,
+            247
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Set Indexing Documents may contain repeated terms and/or non-informative words (e.g., stopwords). This strategy de-duplicates repeated terms using the default Python set operation and removes stopwords from the document. The rest of the document after filtering is passed into the model in similar fashion to the direct index. ",
+        "bbox": [
+            174,
+            263,
+            825,
+            319
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Inverted Index This strategy maps chunked documents (contiguous blocks of tokens) instead of entire documents directly to the docid. We randomly subsample a single contiguous chunk of $k$ tokens and associate them with the docid. The key advantage of this approach is to allow looking beyond the first $k$ tokens. ",
+        "bbox": [
+            174,
+            335,
+            825,
+            392
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "3.2 Representing Docids for Retrieval ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            410,
+            447,
+            424
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Retrieval within seq2seq-based DSI models is accomplished by decoding docids given an input query. How to do this decoding in an effective way largely depends on how docids are represented in the model. The remainder of this section explores a number of possible ways for representing docids and how to handle decoding for each. ",
+        "bbox": [
+            174,
+            435,
+            825,
+            492
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Unstructured Atomic Identifiers The most naive way to represent documents is assign each an arbitrary (and possibly random) unique integer identifier. We refer to these as unstructured atomic identifiers. ",
+        "bbox": [
+            174,
+            507,
+            825,
+            550
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "With these identifiers, an obvious decoding formulation is to learn a probability distribution over the identifiers. In this case, models are trained to emit one logit for each unique docid $( | N _ { d o c u m e n t s } | )$ This is analogous to the output layer in standard language models, but extended to include docids. ",
+        "bbox": [
+            174,
+            556,
+            825,
+            599
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "To accommodate this, we extend the output vocabulary of a standard language model as follows: ",
+        "bbox": [
+            173,
+            604,
+            805,
+            619
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/2311678b9ee6105cb2cfa042d3bcac074c634138ba1be41fbd0c541bdd03ffd8.jpg",
+        "text": "$$\nO = \\mathrm { S o f t m a x } ( [ W _ { t o k e n s } ; W _ { d o c s } ] ^ { T } h _ { l a s t } )\n$$",
+        "text_format": "latex",
+        "bbox": [
+            362,
+            627,
+            633,
+            647
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "where $[ ; ]$ is the row-wise concatenation operator, $W _ { t o k e n s } ~ \\in ~ \\mathbb { R } ^ { d _ { m o d e l } \\times | N _ { t o k e n s } | }$ and $W _ { d o c s } ~ \\in$ $\\mathbb { R } ^ { d _ { m o d e l } \\times | N _ { d o c u m e n t s } | }$ . $h _ { l a s t }$ is the last layer’s hidden state $( \\in \\mathbb { R } ^ { d _ { m o d e l } } )$ of the decoder stack. To retrieve the top- $\\mathbf { \\nabla } \\cdot \\mathbf { k }$ documents for a given query, we simply sort the output logits and return the corresponding indices. This is also reminiscent of standard listwise learning to rank where all documents are considered at once. ",
+        "bbox": [
+            174,
+            656,
+            825,
+            729
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Naively Structured String Identifiers We also consider an ostensibly absurd approach that treats unstructured identifiers, i.e., arbitrary unique integers, as tokenizable strings. We refer to these as naively structured identifiers. ",
+        "bbox": [
+            174,
+            744,
+            825,
+            787
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "In this formulation, retrieval is accomplished by decoding a docid string sequentially one token at a time. This eliminates the need for the large softmax output space that comes with unstructured atomic identifiers. It also eliminates the need to learn embeddings for each individual docid. ",
+        "bbox": [
+            174,
+            792,
+            825,
+            835
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "When decoding, beam search is used to obtain the predicted best docid. With this strategy, it is less straightforward to obtain a top- $\\mathbf { \\nabla } \\cdot \\mathbf { k }$ ranking. One could exhaustively comb through the entire docid space and obtain the likelihood of each docid given the query. Instead, we use the partial beam search tree to construct top- $\\mathbf { \\nabla } \\cdot \\mathbf { k }$ retrieval scores. We find this approximation to be quite efficient and effective in practice. ",
+        "bbox": [
+            174,
+            842,
+            823,
+            911
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Semantically Structured Identifiers All of the approaches for representing docids thus far assumed that the identifiers are assigned in an arbitrary manner. While exploring the limits of arbitrary identifiers is quite interesting, it is only intuitive that imbuing the docid space with semantic structure can lead to better indexing and retrieval capabilities. As such, this section explores semantically structured identifiers. ",
+        "bbox": [
+            174,
+            92,
+            826,
+            160
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Specifically, we aim to automatically create identifiers that satisfy the following properties: (1) the docid should capture some information about the semantics of its associated document, (2) the docid should be structured in a way that the search space is effectively reduced after each decoding step. This results in identifiers where semantically similar documents share identifier prefixes. ",
+        "bbox": [
+            174,
+            170,
+            468,
+            294
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "In this work, we treat this as a fully unsupervised pre-processing step. However, as part of future work it may be possible to integrate and automatically learn semantic identifiers in a fully end-to-end manner. ",
+        "bbox": [
+            174,
+            308,
+            468,
+            376
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "image",
+        "img_path": "images/ca8e40c9da6bcbfccda494eda170b6ca1aeb739f6da3a4c7c0260e628efbee76.jpg",
+        "image_caption": [
+            "Figure 2: Visual example of a hierarchical clustering process used to assign semantically structured identifiers. During inference, beam search navigates this trie to decode the correct docid. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            508,
+            181,
+            828,
+            277
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Algorithm 1 Generating semantically structured identifiers. (Referenced in Section 3.2.) ",
+        "text_level": 1,
+        "bbox": [
+            503,
+            356,
+            830,
+            385
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "To construct identifiers with this property, we employ a simple hierarchical clustering process over document embeddings to induce a decimal tree (or more generally, a trie). ",
+        "bbox": [
+            174,
+            390,
+            468,
+            445
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Given a corpus to be indexed, all documents are clustered into 10 clusters. Each document is assigned an identifier with the number of their cluster from 0-9. For every cluster containing more than $c$ documents, the algorithm is applied recursively, with the next level’s result (the remaining suffix of the identifier) appended to the existing identifier. ",
+        "bbox": [
+            174,
+            459,
+            468,
+            570
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "table",
+        "img_path": "images/9cdd31114014cf257fed70452482196752e145da3971bdb72a9732438ba8142f.jpg",
+        "table_caption": [],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Input:Document embeddings X1:N,where Xi ∈ Rd Output: Corresponding docid strings J1: N function GENERATESEMANTICIDS(X1:N) C1:10←Cluster(Xi:N，k=10) J←empty list fori= O to 9 do</td></tr><tr><td>Jcurrent ← [i]*|Ci+1l if|Ci+1|&gt;c then Jrest ←GENERATESEMANTICIDS(Ci+1)</td></tr><tr><td>else Jrest ← [0,...,|Ci+1|-1]</td></tr><tr><td>end if Jcluster ←elementwiseStrConcat(Jcurrent,Jrest)</td></tr><tr><td>J ←J.appendElements(Jcluster) end for</td></tr><tr><td>J ←reorderToOriginal(J,X1:N，C1:10) return J</td></tr></table>",
+        "bbox": [
+            508,
+            388,
+            802,
+            573
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "For clusters with $c$ documents or less, each element is assigned an arbitrary number from 0 to at most $c - 1$ and likewise its digits are appended to the existing identifier. Although this specific process induces a decimal tree, it is possible to induce similar types of tries using any number of other reasonable strategies.In practice, we simply apply $k$ -means over embeddings generated by a small 8-layer BERT model, with $c = 1 0 0$ . We include pseudo-code for this process in Algorithm 1. ",
+        "bbox": [
+            174,
+            590,
+            825,
+            660
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "3.3 Training and Optimization ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            683,
+            400,
+            698
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "The DSI models that we train are optimized for seq2seq cross entropy loss and are trained with teacher forcing. We explored two main strategies for training DSI models. The first and more straightforward strategy is to first train a model to perform indexing (memorization), followed by a fine-tuning stage where the trained model is used to map queries to docids (e.g., retrieval). The second strategy is to train them together in a multi-task setup. To this end, we frame co-training tasks in similar fashion to T5-style co-training (e.g., using task prompts to differentiate them). The latter performed significantly better, especially when the proportion of indexing to retrieval task examples is high. Hence, we adopted multi-task learning as the default strategy. ",
+        "bbox": [
+            173,
+            710,
+            825,
+            821
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Here, we make the observation that our setup is unique and unlike traditional multi-task learning or transfer learning. In typical multi-task setups, two tasks have shared commonalities that could improve the performance of both tasks if they were learned together. However, in our setup, the retrieval task is completely dependent on the indexing task. In particular, without the indexing task, the identifiers leveraged by the retrieval task would be completely meaningless. Hence, in order to solve task B (retrieval), the model needs to learn task A (indexing) well enough. This problem setup presents unique and largely unexplored research challenges that might be of interest to the ML community. ",
+        "bbox": [
+            174,
+            828,
+            825,
+            911
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            92,
+            823,
+            119
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "4 Experiments ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            140,
+            312,
+            156
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "In this section, we discuss our experimental setup, datasets used and baselines compared. We also discuss experimental results, findings and effect of various strategies discussed in earlier sections of the paper. Since this is fairly new concept, this work aims to put forth a proof-of-concept and seeks to answer research questions instead of making a ‘sotaeesque’ comparison. We leave extensive comparisons on other setups and baselines to future work. ",
+        "bbox": [
+            174,
+            171,
+            825,
+            241
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Dataset We conduct our experiments on the challenging Natural Questions (NQ) (Kwiatkowski et al., 2019) dataset. NQ consists of 307K query-document training pairs and 8K validation pairs, where the queries are natural language questions and the documents are Wikipedia articles. Given a question, the retrieval task is to identify the Wikipedia article that answers it. For evaluating how DSI models perform at different scales, we construct three sets from NQ to form our testbed, namely NQ10K, NQ100K, and NQ320K denoting different numbers of total query-document pairs in the combined train and validation splits. NQ320K is the full NQ set and uses its predetermined training and validation split for evaluation purposes. Unlike NQ320K, NQ10K and NQ100K constructs randomly sampled validation sets. For all datasets, we use the same docid space/budget of 320K tokens for all unstructured atomic and naively structured identifier experiments. Semantically structured identifiers are generated separately for each dataset so as to prevent leakage of semantic information from larger splits into smaller ones. Text is lowercased. Note that there exists fewer unique documents than query-document pairs in these datasets. Please refer to Table 4 (Appendix) which reports the statistics of these datasets. ",
+        "bbox": [
+            174,
+            257,
+            825,
+            450
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Metrics We evaluate our models on $\\mathrm { H i t s } @ \\mathrm { N }$ where $\\scriptstyle \\mathrm { N = } \\{ 1 , 1 0 \\}$ . This metric reports the proportion of correct documents ranked in the top $N$ predictions. ",
+        "bbox": [
+            176,
+            465,
+            823,
+            494
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Implementation Details All DSI models are initialized using standard pretrained T5 (Raffel et al., 2019) model configurations. The configurations names and corresponding number of model parameters are: Base (0.2B), Large (0.8B), XL (3B) and XXL (11B). For unstructured atomic identifiers runs, we initialize the identifiers randomly as new parameters and only finetune the weights during the indexing stage. We use the Jax/T5X 2 implementation for our experiments. The DSI models are trained for a maximum of 1M steps using a batch size of 128. We pick the best checkpoint based on retrieval validation performance. Our training hardware consists of 128-256 TPUv4 chips for models above 1B parameters and 64-128 TPUv3 or TPUv4 chips otherwise. As an estimate, models above 1B parameters typically take about at least a full day for convergence for NQ320K. We tune the learning rate amongst $\\{ 0 . 0 0 1 , 0 . 0 0 0 5 \\}$ and linear warmup amongst $\\{ 1 0 \\mathrm { K } , 1 0 0 \\mathrm { K } , 2 0 0 \\mathrm { K } .$ $3 0 0 \\mathrm { K } \\}$ and/or none. Semantically structured identifiers are generated using an 8-layer BERT (Devlin et al., 2018) model 3, and the default $k$ -means clustering in scikit-learn. Based on our early ablation experiments of various DSI setting, the main results presented use direct indexing $L = 3 2$ ) and the Inputs2Targets indexing strategy. We present results for all the docid representation methods. Following the main results, we present our ablation studies. ",
+        "bbox": [
+            174,
+            511,
+            825,
+            717
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "4.1 Baselines ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            736,
+            277,
+            750
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "For baselines, we use T5-based dual encoders implemented by (Ni et al., 2021). We use the gensim4 package for computing BM25 scores. For the T5-based dual encoders, we train with contrastive learning on the NQ pairs until convergence $\\approx 1 0 \\mathrm { K }$ steps) and obtain top-k nearest neighbors with a system similar to ScaNN (Guo et al., 2020). For zero-shot retrieval, we also compare with a state-ofthe-art unsupervised baseline, Sentence T5 (Ni et al., 2021) which have been specially pre-trained with a similarity learning task. There two reasons why we consider (Ni et al., 2021) the relevant dual encoder baseline for this work rather than other dense retrieval works such as DPR (Karpukhin et al., ",
+        "bbox": [
+            174,
+            761,
+            825,
+            858
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "table",
+        "img_path": "images/db0d91f6b353ef1cc9b057ec77bcd815e75fbd2a0cbd7febf57ff5925c90ffab.jpg",
+        "table_caption": [
+            "Table 2: Experimental results on NQ document retrieval. DSI outperforms BM25 and Dual Encoder baselines. Among all the Docid representation methods, Semantic String Docids perform the best. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td colspan=\"4\"></td><td colspan=\"2\">NQ10K</td><td colspan=\"2\">NQ100K</td><td colspan=\"2\">NQ320K</td></tr><tr><td>Model</td><td>Size</td><td>Params</td><td>Method</td><td>Hits @1</td><td>Hits @10</td><td>Hits@1</td><td>Hits@10</td><td>Hits@1</td><td>Hits@10</td></tr><tr><td>BM25</td><td></td><td>=</td><td>■</td><td>12.4</td><td>33.5</td><td>20.9</td><td>46.4</td><td>11.6</td><td>34.4</td></tr><tr><td>T5</td><td>Base</td><td>220M</td><td>Dual Encoder</td><td>16.2</td><td>48.6</td><td>18.7</td><td>55.2</td><td>20.5</td><td>58.3</td></tr><tr><td>T5</td><td>Large</td><td>800M</td><td>Dual Encoder</td><td>18.8</td><td>55.7</td><td>22.3</td><td>60.5</td><td>22.4</td><td>63.3</td></tr><tr><td>T5</td><td>XL</td><td>3B</td><td>Dual Encoder</td><td>20.8</td><td>59.6</td><td>23.3</td><td>63.2</td><td>23.9</td><td>65.8</td></tr><tr><td>T5</td><td>XXL</td><td>11B</td><td>Dual Encoder</td><td>22.1</td><td>61.6</td><td>24.1</td><td>64.5</td><td>24.3</td><td>67.3</td></tr><tr><td>DSI</td><td>Base</td><td>250M</td><td>Atomic Docid</td><td>13.0</td><td>38.4</td><td>23.8</td><td>58.6</td><td>20.7</td><td>40.9</td></tr><tr><td>DSI</td><td>Large</td><td>800M</td><td>Atomic Docid</td><td>31.3</td><td>59.4</td><td>17.1</td><td>52.3</td><td>11.6</td><td>37.6</td></tr><tr><td>DSI</td><td>XL</td><td>3B</td><td>Atomic Docid</td><td>40.1</td><td>76.9</td><td>19.0</td><td>55.3</td><td>28.1</td><td>61.9</td></tr><tr><td>DSI</td><td>XXL</td><td>11B</td><td>Atomic Docid</td><td>39.4</td><td>77.0</td><td>25.3</td><td>67.9</td><td>24.0</td><td>55.1</td></tr><tr><td>DSI</td><td>Base</td><td>250M</td><td>Naive String Docid</td><td>28.1</td><td>48.0</td><td>18.7</td><td>44.6</td><td>6.7</td><td>21.0</td></tr><tr><td>DSI</td><td>Large</td><td>800M</td><td>Naive String Docid</td><td>34.7</td><td>60.5</td><td>21.2</td><td>50.7</td><td>13.3</td><td>33.6</td></tr><tr><td>DSI</td><td>XL</td><td>3B</td><td>Naive String Docid</td><td>44.7</td><td>66.4</td><td>24.0</td><td>55.1</td><td>16.7</td><td>58.1</td></tr><tr><td>DSI</td><td>XXL</td><td>11B</td><td>Naive String Docid</td><td>46.7</td><td>77.9</td><td>27.5</td><td>62.4</td><td>23.8</td><td>55.9</td></tr><tr><td>DSI</td><td>Base</td><td>250M</td><td>Semantic String Docid</td><td>33.9</td><td>57.3</td><td>19.0</td><td>44.9</td><td>27.4</td><td>56.6</td></tr><tr><td>DSI</td><td>Large</td><td>800M</td><td>Semantic String Docid</td><td>37.5</td><td>65.1</td><td>20.4</td><td>50.2</td><td>35.6</td><td>62.6</td></tr><tr><td>DSI</td><td>XL</td><td>3B</td><td>Semantic String Docid</td><td>41.9</td><td>67.1</td><td>22.4</td><td>52.2</td><td>39.1</td><td>66.8</td></tr><tr><td>DSI</td><td>XXL</td><td>11B</td><td>Semantic String Docid</td><td>48.5</td><td>72.1</td><td>26.9</td><td>59.5</td><td>40.4</td><td>70.3</td></tr></table>",
+        "bbox": [
+            173,
+            125,
+            826,
+            368
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "table",
+        "img_path": "images/545ea09f504be1c5b37993638892278c0e33224a5953a7e8bddf1ab229f7f06b.jpg",
+        "table_caption": [
+            "Table 3: Experimental results on Zero-Shot NQ document retrieval. DSI outperforms BM25, T5 embeddings and SentenceT5, the state-of-the-art for unsupervised similarity modeling. Among Docid representation method, the Atomic Docid performs the best on zero-shot learning. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=\"2\">Size</td><td rowspan=\"2\">Method</td><td rowspan=\"2\"></td><td colspan=\"2\">NQ10K</td><td colspan=\"2\">NQ100K</td><td colspan=\"2\">NQ320K</td></tr><tr><td>Hits@1</td><td>Hits@10</td><td>Hits@1</td><td>Hits@10</td><td>Hits@1</td><td>Hits @10</td></tr><tr><td>BM25</td><td>=</td><td></td><td>12.4</td><td>33.5</td><td>20.9</td><td>46.4</td><td>11.6</td><td>34.4</td></tr><tr><td>T5</td><td>XXL</td><td>Dual Encoder</td><td>0.3</td><td>1.3</td><td>1.9</td><td>8.0</td><td>1.1</td><td>5.9</td></tr><tr><td>SentenceT5</td><td>Large</td><td>Dual Encoder</td><td>17.6</td><td>50.7</td><td>17.4</td><td>50.8</td><td>16.9</td><td>51.0</td></tr><tr><td>DSI</td><td>XXL</td><td>Atomic Docid</td><td>25.7</td><td>60.1</td><td>23.0</td><td>57.3</td><td>25.1</td><td>56.6</td></tr><tr><td>DSI</td><td>XXL</td><td>Naive String Docid</td><td>43.4</td><td>67.4</td><td>17.4</td><td>41.5</td><td>9.2</td><td>22.6</td></tr><tr><td>DSI</td><td>XXL</td><td>Semantic String Docid</td><td>43.9</td><td>68.8</td><td>11.4</td><td>26.6</td><td>13.9</td><td>31.1</td></tr></table>",
+        "bbox": [
+            173,
+            433,
+            825,
+            545
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "2020). Firstly, we employ the exact identical pretrained model, which allows systematic ablation of the proposed approach without conflating other factors. Scientifically, we believe this comparison against fine-tuned T5 is the best apples to apples comparison that we provide. Secondly, fine-tuned T5 dual encoders are considered to be architecturally and methodologically very identical to DPR (with some minor differences such as parameter sharing but use the same concept of in-batch negatives). ",
+        "bbox": [
+            174,
+            571,
+            825,
+            641
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "4.2 Experimental Results ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            659,
+            362,
+            674
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Table 2 reports retrieval results for NQ10K, NQ100K, and NQ320K with finetuning and Table 3 reports zero-shot retrieval results. For zero-shot retrieval, the model is only trained on the indexing task and not the retrieval task, so the model sees no labeled query docid data points. Section 7.2 of the Appendix reports extended results regarding the indexing performance and training dynamics of DSI. ",
+        "bbox": [
+            174,
+            684,
+            825,
+            753
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Supervised Finetuning Results Our results show that DSI outperforms DE across all dataset sizes. On the small dataset (NQ10K), the performance gap between DSI and DE is large, e.g., the best DSI variant outperforms DE by 2 times. On NQ100K, the gap becomes less prominent with the best DSI model (unstructured atomic identifiers) outperforming DE by $+ 5 \\%$ Hits $@ 1$ and Hits $@ 1 0$ . On the large dataset (NQ320K), the best DSI model (structured semantic identifiers) outperform the best DE model by $+ 6 6 \\%$ relative Hits $@ 1$ and $+ 4 . 5 \\%$ Hits $@ 1 0$ . ",
+        "bbox": [
+            174,
+            770,
+            825,
+            853
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Zero-Shot Results Table 3 reports results on zeros-shot retrieval. Recall that zero-shot retrieval is performed by only performing indexing and not the retrieval task. In other words, the model does not see any annotated query or document pairs. Generally, the best result is obtained by DSI with unstructured atomic identifiers on both NQ100K and NQ320K. The best performance on all NQ datasets outperform well-established unsupervised retrieval baselines such as BM25. Moreover, DSI outperforms unsupervised representation learning methods such as SentenceT5 (Ni et al., 2021), which is trained to learn similarity-aware representations via contrastive learning. We also note that raw T5 embeddings perform extremely poorly and do not produce reasonable results on the task of unsupervised retrieval. Given that it is generally difficult for an unsupervised neural method to outperform BM25, we find these early results very encouraging. ",
+        "bbox": [
+            174,
+            869,
+            825,
+            911
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "image",
+        "img_path": "images/a25295c9c750475e0cada8ddeb780add2a01d5ac609f23b0f174f396b20118ed.jpg",
+        "image_caption": [
+            "Figure 3: Scaling plots for DSI vs. DE across model sizes. Performance refers to the Hits $@ 1$ metric. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            202,
+            106,
+            436,
+            268
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "image",
+        "img_path": "images/680d9297a4ac25120008bee489f0dc5a602e475768036fe8b8ce96ca48c08223.jpg",
+        "image_caption": [
+            "Figure 4: Effect of multi-task ratio of indexing to retrieval examples. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            534,
+            101,
+            767,
+            272
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "image",
+        "img_path": "images/0643a55d3d5cc43d5ebca292a304e3942d718a5bca8ec0e94659d6c9f16b589a.jpg",
+        "image_caption": [
+            "Figure 5: Performance of different document representations. (Referenced in Section 4.2.) "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            336,
+            332,
+            658,
+            439
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            491,
+            825,
+            589
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Document Identifiers One key research question in this paper is the crucial choice of how to represent docids. Generally, we find that structured semantic identifiers are helpful and improve over unstructured identifiers. When comparing naive versus semantic string identifiers, it seems imperative to use semantic identifiers if possible. This is intuitive, since imbuing the target space with semantic structure can facilitate greater ease of optimization and additional unsupervised representation learning methods as external knowledge. The competitiveness of unstructured atomic identifiers is somewhat mixed and we had some difficulty optimizing such models. We hypothesize that this could possibly be because of the the newly initialized softmax layer and that training such a system from scratch would mitigate these issues. However, we defer this line of investigation to future work. In lieu of the instability and high variance of the unstructured atomic identifiers, the performance is not consistent across the different datasets. Moreover, these docids might also run into intermittent non-convergence which we trace back to an optimization related quirk. However, we also note that unstructured atomic identifiers perform the best, by a wide margin, on the zero-shot retrieval setup and achieve performance often more than double than that of beam decoding methods. ",
+        "bbox": [
+            174,
+            604,
+            825,
+            799
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Indexing Strategies In this section, we explore the effect of different indexing methods (Section 3.1.1). We run experiments on NQ100K with the different indexing strategies described earlier. Models are trained using the Naive Docid method. Without indexing, the model achieves $0 \\%$ Hits $@ 1$ . This is intuitive, since the Docids are not meaningful without the indexing task. Secondly, the Inputs2Targets and Bidirectional formulation performs the best, with the bidirectional method performing slightly worse (13.5 vs 13.2) compared to the former. Finally, the accuracy with Targets2Inputs and Span Corrpution with Docids yield no meaningful results ( $\\mathrm { { \\bar { 0 } \\% } }$ accuracy). This goes to show that there can be huge variance across indexing strategies whereby some strategies work reasonably well and some completely do not work at all. ",
+        "bbox": [
+            174,
+            814,
+            825,
+            911
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            92,
+            823,
+            119
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Document Representations In this section, we explore the performance of the different document representation strategies described in Section 3.1.2. Figure 5 reports the results on NQ320K. Overall, we find that the direct indexing approach works the best. We also find that it is difficult to train the inverted index method since the docid is repeatedly exposed to different tokens. We also find that shorter document lengths seem to work well where performance seems to substantially dip beyond 64 tokens suggesting that it might be harder to optimize or efficiently memorize when there are a larger number of document tokens. Finally, we also find that there was no additional advantage in applying set processing or stopwords preprocessing to the document tokens. ",
+        "bbox": [
+            174,
+            136,
+            825,
+            247
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Scaling Laws Another interesting insight is how the scaling law of DSI differs from Dual Encoders. Understanding the scaling behaviour of Transformers have garnered significant interest in recent years (Kaplan et al., 2020; Tay et al., 2021; Abnar et al., 2021). We find that the gain in retrieval performance obtained from increasing model parameterization in DE seems to be relatively small. Conversely, the scaling properties of DSI seems to be more optimistic. ",
+        "bbox": [
+            174,
+            262,
+            825,
+            332
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Figure 3 plots the scaling behaviour (log scale) of three methods (DE and DSI with naive and semantic IDs). DSI (naive) strongly benefits from scale going from base to XXL and seems to still have headroom for improvement. Meanwhile, DSI (semantic) starts off equally competitive as DE base but performs much better with scale. DE models, unfortunately are more or less plateaued at smaller parameterization. ",
+        "bbox": [
+            174,
+            338,
+            825,
+            407
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Interplay Between Indexing and Retrieval Our early experiments showed that first learning the indexing task and then learning the retrieval task in a sequential manner results in mediocre performance. There, we focused on exploring good ratios $r$ for co-training the indexing and retrieval tasks together using multi-task learning. Figure 4 shows the effect of modifying the ratio of indexing to retrieval samples. We find the optimization process is significantly influenced by the interplay between the indexing and retrieval tasks. Setting $r$ too high or low generally resulted in poor performance. We find that a rate of 32 generally performed well. ",
+        "bbox": [
+            174,
+            424,
+            825,
+            522
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "5 Conclusion ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            541,
+            299,
+            559
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "This paper proposed the Differentiable Search Index (DSI), a new paradigm for learning an end-to-end search system in a unified manner, paving the way for next generation search (Metzler et al., 2021). We define novel indexing and retrieval tasks that encode the relationship between terms and docids completely within the parameters of a Transformer model. The paper proposed a number of different ways to represent documents and docids, and explored different model architectures and model training strategies. Experiments conducted on the Natural Questions data set show that DSI performs favorably against common baselines such as BM25 and dual encoders, both in a standard fine-tuning setup as well as in a zero-shot setup. ",
+        "bbox": [
+            174,
+            574,
+            825,
+            685
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Although the models and results presented here are promising, there is a great deal of potential future research that can be explored based on this work to improve this approach. For example, it would be interesting to explore alternative strategies for representing documents and docids, as well as to investigate mixture-of-expert models (Du et al., 2021; Fedus et al., 2021; Lepikhin et al., 2020) for scaling the memory capacity of DSI. One important direction will also be to explore how such models can be updated for dynamic corpora, where documents may be added or removed from the system. Finally it may also be interesting to further investigate DSI as an unsupervised representation learning method and/or memory store for other language models to leverage. ",
+        "bbox": [
+            174,
+            691,
+            825,
+            803
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "6 Acknowledgements ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            823,
+            367,
+            840
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "The authors would like to thank you Fernando Pereira, Huaixiu Steven Zheng, Sebastian Ruder, Adam D. Lelkes, Ian Wetherbee and Dani Yogatama for their valuable feedback and discussions. We would also like to extend a special thanks to Sanket Vaibhav Mehta for additional experimental contributions. ",
+        "bbox": [
+            174,
+            856,
+            825,
+            911
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "References ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            89,
+            267,
+            106
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Samira Abnar, Mostafa Dehghani, Behnam Neyshabur, and Hanie Sedghi. Exploring the limits of large scale pre-training. arXiv preprint arXiv:2110.02095, 2021. ",
+        "bbox": [
+            173,
+            113,
+            825,
+            142
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Sebastian Borgeaud, Arthur Mensch, Jordan Hoffmann, Trevor Cai, Eliza Rutherford, Katie Millican, George van den Driessche, Jean-Baptiste Lespiau, Bogdan Damoc, Aidan Clark, et al. Improving language models by retrieving from trillions of tokens. arXiv preprint arXiv:2112.04426, 2021. ",
+        "bbox": [
+            176,
+            150,
+            823,
+            193
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Tom B Brown, Benjamin Mann, Nick Ryder, Melanie Subbiah, Jared Kaplan, Prafulla Dhariwal, Arvind Neelakantan, Pranav Shyam, Girish Sastry, Amanda Askell, et al. Language models are few-shot learners. arXiv preprint arXiv:2005.14165, 2020. ",
+        "bbox": [
+            174,
+            200,
+            823,
+            243
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Nicola De Cao, Gautier Izacard, Sebastian Riedel, and Fabio Petroni. Autoregressive entity retrieval. arXiv preprint arXiv:2010.00904, 2020. ",
+        "bbox": [
+            169,
+            251,
+            826,
+            280
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Mostafa Dehghani, Hamed Zamani, Aliaksei Severyn, Jaap Kamps, and W Bruce Croft. Neural ranking models with weak supervision. In Proceedings of the 40th International ACM SIGIR Conference on Research and Development in Information Retrieval, pages 65–74, 2017. ",
+        "bbox": [
+            173,
+            287,
+            825,
+            332
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Jacob Devlin, Ming-Wei Chang, Kenton Lee, and Kristina Toutanova. Bert: Pre-training of deep bidirectional transformers for language understanding. arXiv preprint arXiv:1810.04805, 2018. ",
+        "bbox": [
+            169,
+            338,
+            823,
+            368
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Nan Du, Yanping Huang, Andrew M Dai, Simon Tong, Dmitry Lepikhin, Yuanzhong Xu, Maxim Krikun, Yanqi Zhou, Adams Wei Yu, Orhan Firat, et al. Glam: Efficient scaling of language models with mixture-of-experts. arXiv preprint arXiv:2112.06905, 2021. ",
+        "bbox": [
+            174,
+            375,
+            823,
+            419
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "William Fedus, Barret Zoph, and Noam Shazeer. Switch transformers: Scaling to trillion parameter models with simple and efficient sparsity. arXiv preprint arXiv:2101.03961, 2021. ",
+        "bbox": [
+            171,
+            426,
+            823,
+            455
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Tianyu Gao, Xingcheng Yao, and Danqi Chen. SimCSE: Simple contrastive learning of sentence embeddings. In Proceedings of the 2021 Conference on Empirical Methods in Natural Language Processing, pages 6894–6910, Online and Punta Cana, Dominican Republic, November 2021. Association for Computational Linguistics. doi: 10.18653/v1/2021.emnlp-main.552. URL https: //aclanthology.org/2021.emnlp-main.552. ",
+        "bbox": [
+            173,
+            463,
+            825,
+            534
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Mor Geva, Roei Schuster, Jonathan Berant, and Omer Levy. Transformer feed-forward layers are key-value memories. arXiv preprint arXiv:2012.14913, 2020. ",
+        "bbox": [
+            169,
+            541,
+            823,
+            570
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Daniel Gillick, Alessandro Presta, and Gaurav Singh Tomar. End-to-end retrieval in continuous space. arXiv preprint arXiv:1811.08008, 2018. ",
+        "bbox": [
+            171,
+            578,
+            825,
+            608
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Ruiqi Guo, Philip Sun, Erik Lindgren, Quan Geng, David Simcha, Felix Chern, and Sanjiv Kumar. Accelerating large-scale inference with anisotropic vector quantization. In International Conference on Machine Learning, 2020. URL https://arxiv.org/abs/1908.10396. ",
+        "bbox": [
+            173,
+            614,
+            823,
+            659
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Kelvin Guu, Kenton Lee, Zora Tung, and Panupong Pasupat. REALM: Retrieval-Augmented Language Model Pre-Training. In Proceedings of ICML 2020, 2020. ",
+        "bbox": [
+            171,
+            666,
+            823,
+            695
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Martin Josifoski, Nicola De Cao, Maxime Peyrard, and Robert West. Genie: Generative information extraction. arXiv preprint arXiv:2112.08340, 2021. ",
+        "bbox": [
+            171,
+            703,
+            823,
+            732
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Jared Kaplan, Sam McCandlish, Tom Henighan, Tom B Brown, Benjamin Chess, Rewon Child, Scott Gray, Alec Radford, Jeffrey Wu, and Dario Amodei. Scaling laws for neural language models. arXiv preprint arXiv:2001.08361, 2020. ",
+        "bbox": [
+            174,
+            739,
+            825,
+            782
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Vladimir Karpukhin, Barlas Oguz, Sewon Min, Patrick Lewis, Ledell Wu, Sergey Edunov, Danqi ˘ Chen, and Wen-tau Yih. Dense passage retrieval for open-domain question answering. arXiv preprint arXiv:2004.04906, 2020. ",
+        "bbox": [
+            174,
+            790,
+            825,
+            833
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "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. Natural Questions: a Benchmark for Question Answering Research. In Transactions of the ACL, 2019. ",
+        "bbox": [
+            174,
+            842,
+            825,
+            911
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Dmitry Lepikhin, HyoukJoong Lee, Yuanzhong Xu, Dehao Chen, Orhan Firat, Yanping Huang, Maxim Krikun, Noam Shazeer, and Zhifeng Chen. Gshard: Scaling giant models with conditional computation and automatic sharding. arXiv preprint arXiv:2006.16668, 2020. ",
+        "bbox": [
+            176,
+            90,
+            823,
+            133
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Donald Metzler, Yi Tay, Dara Bahri, and Marc Najork. Rethinking search: making domain experts out of dilettantes. In ACM SIGIR Forum, volume 55, pages 1–27. ACM New York, NY, USA, 2021. ",
+        "bbox": [
+            174,
+            142,
+            823,
+            185
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Jianmo Ni, Gustavo Hernández Ábrego, Noah Constant, Ji Ma, Keith B Hall, Daniel Cer, and Yinfei Yang. Sentence-t5: Scalable sentence encoders from pre-trained text-to-text models. arXiv preprint arXiv:2108.08877, 2021. ",
+        "bbox": [
+            173,
+            193,
+            823,
+            236
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Fabio Petroni, Tim Rocktäschel, Patrick Lewis, Anton Bakhtin, Yuxiang Wu, Alexander H Miller, and Sebastian Riedel. Language models as knowledge bases? arXiv preprint arXiv:1909.01066, 2019. ",
+        "bbox": [
+            171,
+            244,
+            825,
+            286
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "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. arXiv preprint arXiv:1910.10683, 2019. ",
+        "bbox": [
+            173,
+            296,
+            825,
+            339
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Hubert Ramsauer, Bernhard Schäfl, Johannes Lehner, Philipp Seidl, Michael Widrich, Thomas Adler, Lukas Gruber, Markus Holzleitner, Milena Pavlovic, Geir Kjetil Sandve, et al. Hopfield networks ´ is all you need. arXiv preprint arXiv:2008.02217, 2020. ",
+        "bbox": [
+            174,
+            347,
+            825,
+            391
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Adam Roberts, Colin Raffel, and Noam Shazeer. How much knowledge can you pack into the parameters of a language model? arXiv preprint arXiv:2002.08910, 2020. ",
+        "bbox": [
+            173,
+            398,
+            823,
+            429
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Yu Sun, Xiaolong Wang, Zhuang Liu, John Miller, Alexei Efros, and Moritz Hardt. Test-time training with self-supervision for generalization under distribution shifts. In Hal Daumé III and Aarti Singh, editors, Proceedings of the 37th International Conference on Machine Learning, volume 119 of Proceedings of Machine Learning Research, pages 9229–9248. PMLR, 13–18 Jul 2020. URL https://proceedings.mlr.press/v119/sun20b.html. ",
+        "bbox": [
+            173,
+            436,
+            826,
+            507
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Ilya Sutskever, Oriol Vinyals, and Quoc V Le. Sequence to sequence learning with neural networks. arXiv preprint arXiv:1409.3215, 2014. ",
+        "bbox": [
+            168,
+            515,
+            825,
+            545
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Yi Tay, Mostafa Dehghani, Jinfeng Rao, William Fedus, Samira Abnar, Hyung Won Chung, Sharan Narang, Dani Yogatama, Ashish Vaswani, and Donald Metzler. Scale efficiently: Insights from pre-training and fine-tuning transformers. arXiv preprint arXiv:2109.10686, 2021. ",
+        "bbox": [
+            176,
+            553,
+            823,
+            597
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Romal Thoppilan, Daniel De Freitas, Jamie Hall, Noam Shazeer, Apoorv Kulshreshtha, Heng-Tze Cheng, Alicia Jin, Taylor Bos, Leslie Baker, Yu Du, et al. Lamda: Language models for dialog applications. arXiv preprint arXiv:2201.08239, 2022. ",
+        "bbox": [
+            176,
+            604,
+            823,
+            648
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Ashish Vaswani, Noam Shazeer, Niki Parmar, Jakob Uszkoreit, Llion Jones, Aidan N Gomez, Łukasz Kaiser, and Illia Polosukhin. Attention is all you need. In Advances in neural information processing systems, pages 5998–6008, 2017. ",
+        "bbox": [
+            174,
+            656,
+            825,
+            699
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Checklist ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            89,
+            254,
+            106
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "1. For all authors... ",
+        "bbox": [
+            214,
+            116,
+            339,
+            130
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "(a) Do the main claims made in the abstract and introduction accurately reflect the paper’s contributions and scope? [Yes]   \n(b) Did you describe the limitations of your work? [Yes] We highlight that this is a proofof-concept for a new paradigm, and not geared towards SOTA comparisons (Section 4). Clearly, many open problems still remain such as index updating, scaling to larger datasets, etc.   \n(c) Did you discuss any potential negative societal impacts of your work? [No] Our work effectively provides the same end functionality as existing information retrieval systems.   \n(d) Have you read the ethics review guidelines and ensured that your paper conforms to them? [Yes] ",
+        "bbox": [
+            238,
+            136,
+            825,
+            295
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "2. If you are including theoretical results... ",
+        "bbox": [
+            214,
+            299,
+            493,
+            314
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "(a) Did you state the full set of assumptions of all theoretical results? [N/A] No theoretical results. (b) Did you include complete proofs of all theoretical results? [N/A] No theoretical results ",
+        "bbox": [
+            238,
+            318,
+            825,
+            363
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "3. If you ran experiments... ",
+        "bbox": [
+            214,
+            367,
+            393,
+            381
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "(a) Did you include the code, data, and instructions needed to reproduce the main experimental results (either in the supplemental material or as a URL)? [Yes] All experiments were ran using publicly available T5X codebase, with publicly available Natural Questions dataset. All necessary details were included to reproduce the experiments.   \n(b) Did you specify all the training details (e.g., data splits, hyperparameters, how they were chosen)? [Yes] See Section 4, under Implementation Details.   \n(c) Did you report error bars (e.g., with respect to the random seed after running experiments multiple times)? [No] As these experiments are expensive, experiments were not ran multiple times to save compute.   \n(d) Did you include the total amount of compute and the type of resources used (e.g., type of GPUs, internal cluster, or cloud provider)? [Yes] Please see Section 4 under Implementation Details. ",
+        "bbox": [
+            238,
+            386,
+            825,
+            559
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "4. If you are using existing assets (e.g., code, data, models) or curating/releasing new assets... ",
+        "bbox": [
+            212,
+            564,
+            823,
+            578
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "(a) If your work uses existing assets, did you cite the creators? [Yes]   \n(b) Did you mention the license of the assets? [No] We comply with the license of all code repositories and public datasets as detailed in the cited sources.   \n(c) Did you include any new assets either in the supplemental material or as a URL? [N/A] No new assets introduced at this time.   \n(d) Did you discuss whether and how consent was obtained from people whose data you’re using/curating? [N/A] We did not curate data.   \n(e) Did you discuss whether the data you are using/curating contains personally identifiable information or offensive content? [N/A] We did not curate data. ",
+        "bbox": [
+            238,
+            582,
+            825,
+            717
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "5. If you used crowdsourcing or conducted research with human subjects... ",
+        "bbox": [
+            214,
+            720,
+            705,
+            736
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "(a) Did you include the full text of instructions given to participants and screenshots, if applicable? [N/A]   \n(b) Did you describe any potential participant risks, with links to Institutional Review Board (IRB) approvals, if applicable? [N/A]   \n(c) Did you include the estimated hourly wage paid to participants and the total amount spent on participant compensation? [N/A] ",
+        "bbox": [
+            238,
+            739,
+            825,
+            829
+        ],
+        "page_idx": 12
+    }
+]

parse/dev/zDbsSscmuj/zDbsSscmuj.md

@@ -0,0 +1,250 @@
+# Leveraging Pre-trained Large Language Models to Construct and Utilize World Models for Model-based Task Planning
+
+Lin Guan ∗   
+School of Computing & AI   
+Arizona State University   
+Tempe, AZ 85281   
+lguan9@asu.edu Karthik Valmeekam ∗   
+School of Computing & AI   
+Arizona State University Tempe, AZ 85281 kvalmeek@asu.edu
+
+Sarath Sreedharan Department of Computer Science Colorado State University Fort Collins, CO 80523 sarath.sreedharan@colostate.edu
+
+Subbarao Kambhampati   
+School of Computing & AI   
+Arizona State University Tempe, AZ 85281 rao@asu.edu
+
+# Abstract
+
+There is a growing interest in applying pre-trained large language models (LLMs) to planning problems. However, methods that use LLMs directly as planners are currently impractical due to several factors, including limited correctness of plans, strong reliance on feedback from interactions with simulators or even the actual environment, and the inefficiency in utilizing human feedback. In this work, we introduce a novel alternative paradigm that constructs an explicit world (domain) model in planning domain definition language (PDDL) and then uses it to plan with sound domain-independent planners. To address the fact that LLMs may not generate a fully functional PDDL model initially, we employ LLMs as an interface between PDDL and sources of corrective feedback, such as PDDL validators and humans. For users who lack a background in PDDL, we show that LLMs can translate PDDL into natural language and effectively encode corrective feedback back to the underlying domain model. Our framework not only enjoys the correctness guarantee offered by the external planners but also reduces human involvement by allowing users to correct domain models at the beginning, rather than inspecting and correcting (through interactive prompting) every generated plan as in previous work. On two IPC domains and a Household domain that is more complicated than commonly used benchmarks such as ALFWorld, we demonstrate that GPT-4 can be leveraged to produce high-quality PDDL models for over 40 actions, and the corrected PDDL models are then used to successfully solve 48 challenging planning tasks. Resources, including the source code, are released at: https://guansuns.github.io/pages/llm-dm.
+
+# 1 Introduction
+
+The field of artificial intelligence has been revolutionized with the advent of large pre-trained models. Of particular significance are transformer-based large language models (LLMs) which have showcased remarkable performance in natural language processing tasks. Along with these tasks, LLMs have been tested to perform another widely-studied crucial aspect of AI agents, namely, sequential decisionmaking or planning. Preliminary studies suggest that, in some everyday domains, LLMs are capable of suggesting sensible action plans [19, 1]. However, the correctness and executability of these plans are often limited. For instance, LLMs may regularly overlook the physical plausibility of actions in certain states and may not effectively handle long-term dependencies across multiple actions. Several approaches have been proposed to improve the planning capabilities of LLMs. One promising approach involves collecting feedback from the environment during plan execution and subsequently refining the plans. By incorporating various forms of feedback, such as sensory information [20], human corrections [60], or information of unmet preconditions [42, 56], the planners can re-plan and produce plans that are closer to a satisficing plan.
+
+Despite the improvements in planning performance, LLMs are still far from being a usable and reliable planner due to various factors:
+
+(a) LLMs have not yet demonstrated sufficient capabilities in reasoning and planning [24, 55, 53, 54, 31]. Recent investigations show that even when provided with detailed descriptions of actions, such as a PDDL domain model [33] or a natural-language version of a PDDL model, LLMs still struggle to produce correct and executable plans [48, 55].   
+(b) Existing LLMs-planning paradigms only allow for feedback collection in a fully online manner, meaning that the feedback signals are only available after the agent has started executing the plan. However, when a faithful simulator is not available or is expensive to use, collecting feedback through actual plan execution can be costly and may not fully exploit the advantages of provably sound planning, as seen in classical-planning literature [11, 13].   
+(c) LLMs exhibit complex behaviors that are not yet fully understood, particularly with respect to error occurrences. LLM planners are prone to repeating the same mistakes in slightly different scenarios. Repeatedly providing the same feedback can lead to frustration for end users.
+
+To overcome these limitations, rather than using LLMs directly as planners, we advocate a modelbased paradigm, wherein a PDDL world model is teased out of LLMs. We follow the identical problem setup as existing approaches, which involves providing the planner with a set of actions and their brief natural language descriptions. However, instead of directly mapping user commands to plans, we utilize LLMs to extract a symbolic representation of the actions in the form of PDDL action models. This intermediate output can be used with an external domain-independent planner to reliably search for feasible plans, or it can be used to validate and correct "heuristic" plans generated by an LLM planner. Additionally, our modular method essentially divides the planning process into two distinct parts, namely modeling the causal dependencies of actions and determining the appropriate sequence of actions to accomplish the goals. LLMs, which have been trained on extensive web-scale knowledge, exhibit greater proficiency in the former task rather than the latter.
+
+Nevertheless, we still take into account the fact that the LLMs may not be able to generate error-free PDDL models at the outset. To address this, we show that LLMs can also serve as an interface between PDDL and any feedback sources that can provide corrective feedback in natural language, such as humans and the PDDL validator in VAL [18]. The LLM middle layer translates PDDL representation to natural language and presents it to users for inspection. The acquired feedback is then incorporated and archived back to the PDDL models. This conceals the complexity of PDDL from users who do not have prior knowledge of PDDL, and enables seamless inclusion of feedback. We conducted an extensive evaluation of our methodology on two IPC domains [22] from classical planning literature and a household domain that has a more diverse set of actions and constraints than commonly used benchmarks such as ALFWORLD [47]. We assess the quality of the generated PDDL models through manual evaluation. Results show that GPT-4 [37] generates high-quality PDDL domain models with over 400 literals for 41 actions in total. Then, by replaying and continuing the PDDL-construction dialogue, we show that GPT-4 can readily correct all the errors according to natural language feedback from PDDL validators and humans.
+
+We consider two use cases of the generated PDDL action models for downstream planning tasks. For one, by utilizing an LLM to translate user instructions into goal specifications in PDDL [58, 30], we can use any standard domain-independent planner to search for a plan. On the other hand, the extracted PDDL model can be used to validate plans suggested by an LLM planner and to provide corrective feedback in the form of unmet preconditions or goal conditions. In this case, the PDDL model is essentially serving as an inexpensive high-level simulator or a human proxy to ensure plan correctness.
+
+This reduces the reliance on faithful simulators or extensive manual inspection of plans by domain experts. Compared to the first approach, the second approach potentially offers better flexibility in incorporating both explicit and implicit user constraints in common-sense domains because of the LLM planner. For instance, the LLM planner can directly incorporate ordering constraints such as "heat the potato first before mashing it" and "bring me a fork first, then a plate." On the contrary, an approach purely based on classical planners would require extra steps, such as introducing extra state variables in the PDDL models, in order to accommodate such constraints. However, as demonstrated in our experiments, although the validation feedback significantly improves the plan correctness on average, the performance of the second approach is still limited by the "planning capability" of LLMs.
+
+# 2 Related Work
+
+LLMs and planning. The growing interest in evaluating the emergent abilities of LLMs paved way into exploring their abilities in sequential decision-making tasks. Preliminary studies [24, 55] have shown that off-the-shelf LLMs are currently incapable of producing accurate plans. But their plans can be used as heuristics or seeds to either an external planner or a human in the loop [55, 48]. SayCan [1] and Text2Motion [29] employ an LLM as a heuristic by utilizing it to score high-level actions, followed by a low-level planner that grounds these actions to determine the executability in the physical world. In a similar vein, [28, 50] use LLMs to generate plans represented in Python-style code. Other works have aimed to improve the planning performance of LLMs through prompt engineering [60] or collecting various forms of feedback such as sensory information [51, 20, 34], human corrections [60], self-corrections [46] or information of unmet preconditions [42, 56].
+
+Training transformers for sequential decision-making tasks. Along with using off-the-shelf LLMs, there are works that either fine-tune LLMs [55, 38] or train sequence models [62, 27, 7, 43] for sequential decision making tasks. Experiments in [26] have shown that training sequence models on a specific task gives rise to an internal world representation within the model. In this work, we use off-the-shelf LLMs to construct symbolic world models without performing any extra training.
+
+Learning/acquiring symbolic domain models. In classical planning, the community has explored numerous learning-based methods [59, 61, 9, 25, 4] and interactive editor-based methods [49] for acquiring symbolic domain models. For a more comprehensive survey, we refer the reader to [2, 6]. Here, we are interested in leveraging the common-world knowledge embedded in LLMs and their in-context learning ability for constructing domain models. Recent studies have shown the efficacy of LLMs in translating natural language to formal descriptions [35] or constructing PDDL goals from natural-language instructions [58, 32]. Moreover, a contemporary work [15] considers the use of LLM as a parametric world model and plan critic. However, unlike a symbolic model that can simulate plan outcomes with guaranteed correctness, using LLMs directly as a world model actually adds another layer of errors. There is evidence that autoregressive models lack reliable capacity for reasoning about action effects [3, 31] and capturing errors in candidate plans [53, 54].
+
+Language models with access to external tools. Since LLMs are approximately omniscient, they may not always outperform specialized models or tools in specific downstream tasks. To address this limitation, frameworks have been developed to enable LLMs to utilize external tools for performing sub-tasks like arithmetic [45] and logical reasoning [39, 57]. In this context, our work can be regarded as an exercise in employing external sound planners to augment the capacity of LLMs for more reliable plan generation.
+
+# 3 Problem Setting and Background
+
+Our work focuses on a scenario where an intelligent agent receives high-level instructions or tasks, denoted as $i$ , from a user. The agent is capable of only executing skills or operations that are part of a skill library $\Pi$ , where each skill $k$ has a short language description $l _ { k }$ . We assume that the agent is equipped with the low-level control policies corresponding to these high-level skills. In order to achieve the goal conditions specified in $i$ , a planner, which can be either an LLM or an external planner [16, 12, 17], needs to come up with a sequence of high-level skills that the agent can execute. This type of problem is referred to as a sequential decision-making or planning problem. Similar to previous works such as [60, 20], we also allow for human-in-the-loop feedback during both the domain-model construction and plan execution stages. In the next subsections, we describe the formalism behind planning problems and a standard way in the literature to specify them.
+
+# 3.1 Classical planning problems
+
+The most fundamental planning formalism is goal-directed deterministic planning problem, referred to as a classical planning problem in the planning literature. A classical planning problem [44] can be formally represented with a tuple $\bar { \mathcal { P } } = \langle \mathcal { D } , \mathcal { I } , \mathcal { G } \rangle$ . $\mathcal { D }$ is referred to as the domain, $I$ is the initial state, and $\mathcal { G }$ is the goal specification. The state space of a planning problem consists of the truth assignments for predicates. The domain $\mathcal { D }$ is further defined by the tuple ${ \mathcal { D } } = \langle { \mathcal { F } } , A \rangle$ . $\mathcal { F }$ corresponds to the set of fluents, i.e., the state variables used to define the state space with each fluent corresponding to a predicate with some arity. $\mathcal { A }$ corresponds to the set of actions that can be performed. Each action $a _ { i } [ \mathcal { V } ] \in \mathcal { A }$ (where $\nu$ is the set of variables used by the operator $a _ { i }$ and each variable could be mapped to an object) can be further defined by two components, the precondition $\mathsf { p r e c } [ \mathcal { V } ]$ which describes when an action can be executed, and the effects eff $[ \nu ]$ which defines what happens when an action is executed. We assume that prec $[ \nu ]$ consists of a set of predicates defined over the variables $\nu$ . An action is assumed to be executable only if its preconditions are met, i.e, the predicates in the precondition hold in the given state. The effect set eff $[ \nu ]$ is further defined by the tuple $\langle \mathsf { a d d } [ \mathcal { V } ] , \mathsf { d e l } [ \mathcal { V } ] \rangle$ , where $\mathsf { a d d } [ \nu ]$ is the set of predicates that will be set true by the action and $\mathsf { d e l } [ \nu ]$ is the set of predicates that will be set false by the action. An action is said to be grounded if we replace each of the variables with an object, else it is referred to as a lifted action model. A solution to a planning problem is called a plan, and it is a sequence of actions that once executed in the initial state would lead to a state where the goal specification holds. Classical planning problems are one of the simpler classes in planning and there are multiple extensions with more complex forms of preconditions, conditional effects, and also support for richer planning formalisms.
+
+# 3.2 PDDL
+
+Planning Definition and Domain Language (PDDL) [33], is the standard encoding language for classical planning problems. Here is an example of a lifted action in PDDL which corresponds to putting a block onto the table in the classical Blocksworld domain:
+
+(:action PutDownBlock :parameters (?x - block) :precondition (and (robot-holding $? \mathbf { x } )$ ) :effect (and (not (robot-holding $? \mathbf { x } )$ ) (block-clear ?x) (robot-hand-empty) (block-on-table $? { \bf x } )$ ))
+
+The parameters line provides the possible variable(s), and in this case, $\ ? \mathbf { x }$ represents the block to put down. The precondition states that the robot must be holding the block in its gripper. The effects line describes the expected outcome of this action.
+
+# 4 Methodology
+
+PDDL provides a succinct and standardized way to represent a world model. Once a PDDL model is constructed, it can be seamlessly used by any domain-independent planner developed in the automated planning community to search for a plan given the initial state and goal conditions. In this section, we will introduce our solution for constructing PDDL models using LLMs. We then discuss techniques for correcting errors in the generated PDDL models. Finally, we present the full pipeline for utilizing the generated PDDL models to solve planning problems.
+
+# 4.1 Constructing PDDL models with LLMs
+
+Our approach involves prompting pre-trained LLMs with the following information: (a) detailed instructions for the PDDL generation task, outlining components of upcoming inputs and desired outputs; (b) one or two examples from other domains (e.g., the classical Blocksworld domain) for illustrating the input and output formats; (c) a description of the current domain, including contextual information about the agent’s tasks and physical constraints due to the specific embodiment of the agent; (d) a description of the agent’s action; and (e) a dynamically updated list of predicates that the LLM can reuse to maintain consistent use of symbols across multiple actions. Note that the predicate list is initialized to an empty list, and thus all predicates are introduced by the LLM. The structure of the prompt is illustrated in Fig. 2, and a complete prompt for the household-robot domain can be found at Appx. A.6.1.
+
+![](images/07144245efd6d17b9a3f71bf358d907857248bc85cbcf0a3600c058743ac31c7.jpg)  
+Figure 1: An overview of our framework and existing methods that use LLMs directly as planners.
+
+Depending on the information included in the action description or the domain context, users may gain varying levels of control over the extracted PDDL or receive differing levels of support from the LLMs. On one hand, when the user provides only a minimal description of the action, such as "this action enables the robot to use a microwave to heat food," we not only use the LLM as a PDDL constructor but also leverage the common world knowledge encoded within the model for knowledge acquisition. This is particularly useful when expanding the set of actions for an AI agent. For example, a robot engineer could set up a training environment for skill learning by following the suggested preconditions and effects. On the other hand, when some preconditions or effects are explicitly mentioned in the prompt, we rely more on the LLM’s ability to parse the knowledge provided in natural language and to precisely represent it by devising a collection of predicates. This capability is useful when there could be different initial setups of a skill, and the engineers have already made some assumptions on the preconditions at the time of designing the skill. This capability is also crucial when constructing PDDL for specialized domains. For instance, robots such as Fetch and Spot Robot have only one robot arm, which is less flexible than a human arm, and are therefore subject to many uncommon physical constraints.
+
+The desired output comprises the following elements: (a) the list of arguments for the action; (b) the preconditions and effects expressed in PDDL; and (c) a list of any newly defined predicates and their descriptions in natural language, if applicable. An example output is shown in Fig. 2. Our algorithm generates PDDL models for each action separately, one at a time, by iterating over the set of actions. Any newly defined predicates will be added to an actively maintained predicate list, such that the LLM can reuse existing predicates in subsequent actions without creating redundant ones. Once we obtain the initial PDDL models and the full predicate list, we repeat the entire process but with all of the extracted predicates presented to the LLM. Running the generation process twice is useful because the LLMs may be unaware of some precondition(s) during the first iteration, especially if the precondition(s) are not explicitly mentioned. For instance, the LLM may overlook the fact that a furniture piece can be openable, but a predicate created in the "open a furniture piece or appliance" skill can inform the LLM of this fact. One alternative to this action-by-action generation could be to include descriptions of all the actions in the prompt and require the LLM to construct the entire domain model in a single dialogue. An additional discussion on this can be found at Sec. A.2 in Appendix.
+
+It is worth noting that every time a new predicate is defined, the LLM is required to give the natural language description of it. As we will see in the following sections, this is crucial for enabling any user to easily understand and inspect the generated PDDL models without having to delve into the low-level symbolic representation. Additionally, natural language descriptions allow the predicate values of the initial state to be automatically grounded by using LLMs to translate environment description in natural language to PDDL [30], or leveraging pre-trained vision-language models
+
+Instructions for the PDDL generation task   
+You are defining the preconditions and effects (represented in PDDL format) of an AI agent's $\hookrightarrow$ actions. Information about the AI agent will be provided in the domain description ... One or two examples from other domains for illustrating the input and output formats   
+Here are two examples from the classical BlocksWorld domain for demonstrating the output format. Here is the task.
+
+A natural language description of the domain
+
+Domain information: The AI agent here is a household robot that can navigate to various large and $\hookrightarrow$ normally immovable furniture pieces or appliances in the house to carry out household tasks $\hookrightarrow$
+
+A natural language description of the action
+
+Action: This action enables the robot to toggle small appliances (like humidifiers and light $\hookrightarrow$ bulbs) which are toggleable to switch them on
+
+The dynamically updated list of predicates
+
+You can create and define new predicates, but you may also reuse the following predicates:
+
+1. (robot-at ?r - robot ?f - furnitureAppliance): true if the robot $\mathord { ? } \mathbf { r }$ is at the furniture or $\hookrightarrow$ appliance ?f
+
+2. (object-in-on ?o - householdObject ?f - furnitureAppliance): true if the object ?o is in or on $\hookrightarrow$ the furniture or appliance ?f
+
+Parameters:
+
+# The LLM:
+
+![](images/d901b4063bc05cf5435f6666e2be758e7e524efd02219a279a79281f33d84b2f.jpg)  
+Figure 2: The prompt template for PDDL construction and an example of the LLM output for the household domain.
+
+[41, 37, 10] and querying them in a question-answering manner, based on observations from the environment.
+
+# 4.2 Correcting errors in the initial PDDL models
+
+As with any use case involving LLMs, there is no guarantee that the output is completely error-free. Therefore, it is essential to incorporate error-correction mechanisms. While it may be easy for PDDL experts to directly inspect and correct the generated PDDL models, we cannot assume that all end users possess this level of expertise. Our solution is to use the LLM as a middle layer or interface between the underlying PDDL model and any feedback source that can provide corrective feedback in natural language. We consider two feedback sources in this work, namely the PDDL model validation tools (e.g., the one in VAL [18]) and human domain experts. The former is used to detect basic syntax errors, while the latter is mainly responsible for catching factual errors, such as missing effects. It is worth noting that the feedback sources are not limited to those mentioned above, and we leave the investigation of other sources for future research.
+
+For corrective feedback from PDDL validators, a generated PDDL model is directly presented to the validator to obtain brief but readable error messages. Examples of feedback messages for syntax errors are shown in Appx. A.3. For corrective feedback from users, a PDDL model is translated into its natural-language version based on the natural language descriptions of the predicates and parameters (Sec. 4.1). The user can then examine potentially erroneous action models. Human corrections can occur both during the construction of PDDL models and after the models have been used for planning. Although there are techniques available to assist users to locate errors in the models (as discussed in
+
+Appx. A.4), this is beyond the scope of this work, since the focus here is to investigate the feasibility of using LLMs to correct PDDL models based on feedback. We also note that correcting action models is not more cognitively demanding than correcting plans or the "reasoning traces" of an LLM planner [60]. In fact, when correcting plans, humans must also maintain the action models and their causal chains in mind in order to validate the plans. More importantly, once the action models are corrected, users no longer need to provide similar feedback repeatedly. Finally, corrective feedback is integrated by replaying and continuing the PDDL-construction dialogue. Examples of such dialogues can be found in Sec. A.7, Sec. A.9, and Sec. A.11 in Appendix.
+
+# 4.3 Generating plans with the extracted PDDL models
+
+Recall that given the set of extracted predicates and their natural language descriptions, we can get the grounded initial state by using LLMs to translate descriptions of the environment to PDDL, or by observing the environment and querying pre-trained vision-language models. Besides, the goal specification can be obtained by using an LLM to parse the user’s command and convert it into a symbolic form, as done previously in [30, 58, 32]. With this setup, the following two methods can be used to generate the final plans.
+
+Classical planner with LLM-acquired PDDL model. One straightforward approach is to employ a standard domain-independent planner to reliably find a satisficing or even optimal plan for the specified goal. In common-sense domains where LLMs may generate meaningful "heuristics", the LLM plans may also be used as seed plans for a local-search planner such as LPG [12] to accelerate the plan searching. This is similar to the approach suggested in [55], but with a higher degree of automation.
+
+LLM modulo planner backprompted by VAL using LLM-acquired PDDL model. As outlined in Sec. 1, we can also use the extracted PDDL as a symbolic simulator or human proxy to provide corrective feedback based on validation information to an LLM planner. With this setup, the planner can iteratively refine the plans through re-prompting [42].
+
+It is worth noting that depending on the specific problem settings, the extracted PDDL model can also be used for tasks other than task planning. For instance, in cases where reinforcement learning is permissible, the domain model can be used to guide skill learning [21, 8] or exploration even if the model is not fully situated [14].
+
+# 5 Empirical Evaluation
+
+We conduct our experiments 2 on an everyday household-robot domain and two more specialized IPC domains (i.e., Tyreworld and Logistics). The Household domain is similar to other commonly used benchmarks like ALFWORLD [47] and VirtualHome [40]. However, in our household domain, a single-arm robot is equipped with a more diverse and extended set of 22 mobile and manipulation skills. In addition, we apply more rigorous physical-plausibility constraints to each skill. A detailed description of this domain can be found at Appx. A.5. In our experiments, we first evaluate the quality of PDDL models generated by the LLMs. Next, we assess the ability of the LLMs to incorporate corrective feedback from both PDDL validators and users in order to obtain error-free PDDL models. Lastly, we showcase multiple ways to use the corrected PDDL model for downstream planning tasks. We present the results of GPT-4 [37] and GPT-3.5-Turbo [36] for PDDL construction (we also conducted experiments with GPT-3 [5], and observe that its performance is comparable to that of GPT-3.5-Turbo).
+
+# 5.1 Constructing PDDL
+
+In PDDL construction tasks, we aim to investigate the extent to which LLMs can construct accurate PDDL models before getting corrective feedback from domain experts. For all the domains, two actions from the classical Blocksworld domain are used as demonstrations in the prompt so that the end user is not required to come up with any domain-specific example. To evaluate the degree of correctness, we recruit multiple graduate students who possess expertise in PDDL. These experts are responsible for annotating and correcting any errors present in the generated PDDL models. As an evaluation metric, we count and report the total number of annotations, which may include the removal of irrelevant preconditions, the addition of missing preconditions, the replacement of incorrect predicates, the inclusion of missing parameters, and other commonly made corrections. Note that the number of annotations can be viewed as the approximate distance between a generated PDDL model and its corrected version. In order to provide the reader with a comprehensive understanding of the quality of the generated models, we also list all the models and collected annotations in Appendix. In each of the figures, errors that affect the functionality of the PDDL model are highlighted in yellow, while minor issues are highlighted in green. One example of a minor issue is the redundant inclusion of (pickupable ?o) in preconditions when (robot-holding ?o) has already been listed. The former is unnecessary because it can be implied by the latter, but this only affects conciseness rather than functionality.
+
+Table 1: The number of errors in the domain models produced by the LLMs for each of the domains. A $" + "$ mark indicates that the generated model is excessively noisy, making it challenging to determine an exact number of errors.   
+
+<table><tr><td>Domain</td><td># of actions</td><td># of params and literals</td><td># of GPT-4 errors</td><td># of GPT-3.5-Turbo errors</td></tr><tr><td>Household</td><td>22</td><td>271</td><td>53</td><td>218+</td></tr><tr><td>Logistics</td><td>6</td><td>54</td><td>2</td><td>38</td></tr><tr><td>Tyreworld</td><td>13</td><td>108</td><td>4</td><td>94+</td></tr></table>
+
+We first evaluate the PDDL models generated when partial constraint information is given, as this is closer to most of the practical use cases where constraints on skills in the library $\Pi$ are often pre-specified. In this setting, our evaluation focuses on the LLMs’ ability to accurately recover a "ground truth PDDL" that captures the mentioned constraints and underlying dependencies among skills. Our results indicate that GPT-4 can produce high-quality PDDL models with significantly fewer errors when compared to GPT-3.5-Turbo. Table 1 presents the number of errors in the generated domain models for each domain. To help the readers understand the complexities of the action models, we additionally report the total number of parameters and literals in the final corrected domain models produced by GPT-4. Out of the total 59 errors made by GPT-4, three of them are syntax errors and the rest are factual errors such as missing preconditions and effects. This observation suggests that while GPT-4 demonstrates proficiency in adhering to the grammar of PDDL, it may still have an inaccurate understanding of the actions. By examining the set of predicates (listed in the Appendix), we also find that GPT-4 can devise a set of intuitively-named predicates that can concisely and precisely describe the states of objects and events in the domain. In contrast, GPT-3.5-Turbo produces highly noisy outputs with over 350 errors. This suggests that our framework relies heavily on GPT-4’s improved capability in understanding symbols, and future work may investigate how to enable the use of more lightweight models (e.g., by fine-tuning on some PDDL datasets). Furthermore, recall that when the action description contains minimal information, LLMs could also be utilized to propose preconditions and effects to assist with knowledge acquisition. To verify this hypothesis, we conduct additional experiments on the Household domain that can have a more open-ended action design. In this setting, the correctness of the action models is determined based on whether the preconditions and effects establish correct connections among the actions. Our results show that GPT-4 can suggest meaningful action models, and the generated PDDL models have only around 45 errors.
+
+Although GPT-4 has shown improved performance in the PDDL construction task, our experiments still uncover some limitations. Firstly, GPT-4 still exhibits a shallow understanding of the causal relationships between actions, particularly when it comes to tasks involving reasoning skills such as spatial reasoning. For instance, when constructing the model of action "pick up an object from a furniture piece," GPT-4 fails to consider that there could be other objects stacked on top of the target object, even if relevant predicates are provided (which were created in the action "stack objects"). In addition, although it occurs rarely, GPT-4 may output contradictory effects. For instance, in the action of mashing food with a blender, GPT-4 lists both (not (object-in-receptacle ...)) and (object-in-receptacle ...) as effects at the same time.
+
+# 5.2 Correcting PDDL with domain experts
+
+We proceed with the PDDL models generated by GPT-4 when the constraint information is partially given. Our objective is to demonstrate the feasibility of using GPT-4 as a middle layer to incorporate natural-language feedback and correct the PDDL models. As discussed in Sec. 4.2, we use PDDL validators to capture basic syntax errors. In the Household domain, there are two syntax errors associated with improper usage of relevant predicates due to issues with the object types of parameters . As shown in Appx. A.7.1, by continuing the PDDL-construction dialogue with a feedback message "the second parameter of object-on should be a furnitureAppliance but a householdObject was given," GPT-4 can locate the inaccurate PDDL snippet and replace it with a correct one. For the other factual errors, GPT-4 successfully corrects all of them based on the natural language feedback. An example feedback message on factual errors is "there is a missing effect: the item is no longer pickupable after being mashed." More PDDL-correction conversations can be found in Appendix. We also experiment with feedback written in various ways, and GPT-4 is able to understand all the messages and successfully correct the models. To quantify how effectively GPT-4 utilizes feedback from domain experts, we count the number of feedback messages concerning factual errors. Our result shows that GPT-4 required 59 feedback messages to address a total of 56 factual errors. There are three instances where additional feedback was needed. One case involved the user reiterating the error, while the other two cases involved GPT-4 introducing new errors. Furthermore, we attempt to correct the same errors using GPT-3.5-Turbo. Results show that GPT-3.5-Turbo not only fails to correct all the errors but also occasionally introduces new errors, again confirming its lack of ability to manipulate symbols. Some examples can be found in Appendix starting from Sec. A.7.3.
+
+# 5.3 Generating plans with the extracted PDDL models
+
+For planning tasks (i.e., user instructions and initial states), we use the Household domain and Logistics domain, where state-of-the-art LLM planners struggle to find valid plans. We sampled 27 tasks for Household and 21 for Logistics. For the initial states, we assume the grounding is provided, and for the goals, we leverage GPT-4 to translate user instructions into PDDL goal specifications in terms of the extracted predicates (an example prompt can be found at Appx. A.13), and send it over to a standard STRIPS planner which already has access to the domain model acquired through LLMs. With this setup, a classical planner Fast Downward [16] can effectively find valid plans in $9 5 \%$ of the cases (the failures were only due to goal translation errors). Note that in contrast to earlier methods such as [30] that use LLMs only as a mechanism for translating user goals to PDDL format, and throw that over to external sound planners with hand-crafted correct PDDL domain models, our approach uses LLMs themselves to develop the PDDL world model driving the external planner.
+
+On the other hand, for the approach that utilizes PDDL models to validate LLM plans (i.e., LLM modulo planner back-prompted by VAL using LLMacquired domain model), we employ the state-of-the-art algorithm ReAct [60] with GPT-4 as the underlying LLM planner. However, we made two modifications to the prompt design. Firstly, we provide a detailed description of all actions in natural language, including parameters, preconditions, and effects. These descriptions are ob
+
+Table 2: Success rates of different planning approaches in the Household domain and the Logistics domain.   
+
+<table><tr><td>Planner Type</td><td>Household</td><td>Logistics</td></tr><tr><td>Only LLMPlanner</td><td>15%</td><td>0%</td></tr><tr><td>Fast Downward with LLM-acquired PDDL model</td><td>95%</td><td>100%</td></tr><tr><td>LLM backprompted by VAL using LLM-acquired PDDL model</td><td>48%</td><td>33%</td></tr></table>
+
+tained by using another LLM to translate the generated PDDL domain model into natural language. Secondly, we use only two fixed examples for each domain because end users might not always be able to provide a large pool of examples, and the planner should rely on the action model information. The LLM plans, symbolic goal specifications, initial states and domain models are passed to a plan validation system (i.e., VAL) to check for unmet precondition(s) or goal condition(s). The validation results (given in PDDL) are then translated into natural language with GPT-4 and provided to the LLM planner by continuing the planning dialogue (see Appx. A.12.1 for examples). In our experiments, we limit the number of feedbacks per task to 8 due to the restricted access to GPT-4. Table 2 provides a summary of the average success rates of all approaches. Not surprisingly, the vanilla LLM planner constantly overlooks action preconditions and achieves an extremely low success rate. With the integration of validation feedback, we observe a notable improvement in plan correctness. Despite this improvement, the overall performance is still not satisfactory, as the success rate remains below
+
+$50 \%$ . Furthermore, we have observed that GPT-4 fails to effectively utilize the feedback, often getting stuck in a loop by repeatedly generating the same plan. In some cases, it may also introduce new errors while attempting to rectify the plans.
+
+Beyond the notion of correctness, the experiments also uncover intriguing properties of the LLM planner. In the Household domain, we intentionally introduce ordering constraints in some instructions that cannot be expressed using existing predicates (refer to Appx. A.12 for examples). Remarkably, upon manual examination of the generated plans, we observe that all LLM plans adhere to the specified ordering, despite not being entirely correct or executable. Furthermore, also in the Household domain, we observe that classical planners occasionally generate physically plausible but unconventional actions, such as placing a knife on a toaster when the knife is not being used. In contrast, the LLM planner rarely exhibits such actions, suggesting that LLMs possess knowledge of implicit human preferences. It would be meaningful to explore methods that more effectively combine the strengths of LLM planners and the correctness guarantee provided by symbolic domain models, particularly in determining which information from LLM plans should be preserved.
+
+# 6 Conclusion
+
+We introduce a new paradigm for leveraging LLMs in planning tasks, which involves maintaining an explicit world model instead of directly mapping user prompts to plans. This is motivated by the insight that LLMs, while incapable of the combinatorial search needed to produce correct plans, may be better suited as the source of world models. We present a complete pipeline that begins with generating high-quality PDDL models using GPT-4, then corrects the PDDL models with naturallanguage feedback, and finally utilizes the extracted domain models to reliably plan in multiple ways. Our experiments demonstrate that pairing LLMs with an external planner significantly outperforms existing methods when applied to two IPC domains and a household-robot domain that has more action-wise constraints than commonly used benchmarks such as ALFWorld. Apart from directions for further research that we have previously mentioned, there are several exciting opportunities for extending this work. Firstly, the complexity of our evaluation domains is still lower than that of many domains used in the classical planning literature. It remains to be seen whether LLMs can effectively scale to write PDDL models that express more intricate logic. Secondly, our framework assumes full observability, meaning that the agent must fully explore the environment to acquire object states at the beginning. It would be useful to support partial observability. Finally, our experiments assume the grounding of predicate values is done perfectly. However, it would be useful to take into account that perception can be noisy in practice.
+
+# Acknowledgement
+
+This research was supported by ONR grants N00014-18-1-2442, N00014-18-1-2840, N00014- 19-1-2119 and N00014-23-1-2409, AFOSR grant FA9550-18-1-0067, DARPA SAIL-ON grant W911NF-19-2-0006, and a JP Morgan AI Faculty Research Grant to Kambhampati. Sreedharan was supported in part by NSF grant 2303019.
+
+# References
+
+[1] Michael Ahn, Anthony Brohan, Noah Brown, Yevgen Chebotar, Omar Cortes, Byron David, Chelsea Finn, Keerthana Gopalakrishnan, Karol Hausman, Alex Herzog, et al. Do as i can, not as i say: Grounding language in robotic affordances. arXiv preprint arXiv:2204.01691, 2022.   
+[2] Ankuj Arora, Humbert Fiorino, Damien Pellier, Marc Métivier, and Sylvie Pesty. A review of learning planning action models. The Knowledge Engineering Review, 33:e20, 2018.   
+[3] Pratyay Banerjee, Chitta Baral, Man Luo, Arindam Mitra, Kuntal Pal, Tran C Son, and Neeraj Varshney. Can transformers reason about effects of actions? arXiv preprint arXiv:2012.09938, 2020.   
+[4] Blai Bonet and Hector Geffner. Learning first-order symbolic representations for planning from the structure of the state space. arXiv preprint arXiv:1909.05546, 2019.   
+[5] Tom Brown, Benjamin Mann, Nick Ryder, Melanie Subbiah, Jared D Kaplan, Prafulla Dhariwal, Arvind Neelakantan, Pranav Shyam, Girish Sastry, Amanda Askell, et al. Language models are few-shot learners. Advances in neural information processing systems, 33:1877–1901, 2020. [6] Ethan Callanan, Rebecca De Venezia, Victoria Armstrong, Alison Paredes, Tathagata Chakraborti, and Christian Muise. Macq: A holistic view of model acquisition techniques. In The ICAPS Workshop on Knowledge Engineering for Planning and Scheduling (KEPS), 2022. [7] Hongyi Chen, Yilun Du, Yiye Chen, Joshua B. Tenenbaum, and Patricio A. Vela. Planning with sequence models through iterative energy minimization. In The Eleventh International Conference on Learning Representations, 2023. [8] Shuo Cheng and Danfei Xu. Guided skill learning and abstraction for long-horizon manipulation. arXiv preprint arXiv:2210.12631, 2022. [9] Stephen N Cresswell, Thomas L McCluskey, and Margaret M West. Acquiring planning domain models using locm. The Knowledge Engineering Review, 28(2):195–213, 2013.   
+[10] Danny Driess, Fei Xia, Mehdi SM Sajjadi, Corey Lynch, Aakanksha Chowdhery, Brian Ichter, Ayzaan Wahid, Jonathan Tompson, Quan Vuong, Tianhe Yu, et al. Palm-e: An embodied multimodal language model. arXiv preprint arXiv:2303.03378, 2023.   
+[11] Richard E Fikes and Nils J Nilsson. Strips: A new approach to the application of theorem proving to problem solving. Artificial intelligence, 2(3-4):189–208, 1971.   
+[12] Alfonso Gerevini and Ivan Serina. Lpg: A planner based on local search for planning graphs with action costs. In AIPS, volume 2, pages 281–290, 2002.   
+[13] Malik Ghallab, Dana Nau, and Paolo Traverso. Automated Planning: theory and practice. Elsevier, 2004.   
+[14] Lin Guan, Sarath Sreedharan, and Subbarao Kambhampati. Leveraging approximate symbolic models for reinforcement learning via skill diversity. In International Conference on Machine Learning, pages 7949–7967. PMLR, 2022.   
+[15] Shibo Hao, Yi Gu, Haodi Ma, Joshua Jiahua Hong, Zhen Wang, Daisy Zhe Wang, and Zhiting Hu. Reasoning with language model is planning with world model. arXiv preprint arXiv:2305.14992, 2023.   
+[16] Malte Helmert. The fast downward planning system. Journal of Artificial Intelligence Research, 26:191–246, 2006.   
+[17] Jörg Hoffmann and Bernhard Nebel. The ff planning system: Fast plan generation through heuristic search. Journal of Artificial Intelligence Research, 14:253–302, 2001.   
+[18] Richard Howey, Derek Long, and Maria Fox. Val: Automatic plan validation, continuous effects and mixed initiative planning using pddl. In 16th IEEE International Conference on Tools with Artificial Intelligence, pages 294–301. IEEE, 2004.   
+[19] Wenlong Huang, Pieter Abbeel, Deepak Pathak, and Igor Mordatch. Language models as zero-shot planners: Extracting actionable knowledge for embodied agents. In International Conference on Machine Learning, pages 9118–9147. PMLR, 2022.   
+[20] Wenlong Huang, Fei Xia, Ted Xiao, Harris Chan, Jacky Liang, Pete Florence, Andy Zeng, Jonathan Tompson, Igor Mordatch, Yevgen Chebotar, et al. Inner monologue: Embodied reasoning through planning with language models. arXiv preprint arXiv:2207.05608, 2022.   
+[21] León Illanes, Xi Yan, Rodrigo Toro Icarte, and Sheila A McIlraith. Symbolic plans as high-level instructions for reinforcement learning. In Proceedings of the international conference on automated planning and scheduling, volume 30, pages 540–550, 2020.   
+[22] IPC. International planning competition, 1998.   
+[23] Subbarao Kambhampati, Sarath Sreedharan, Mudit Verma, Yantian Zha, and Lin Guan. Symbols as a lingua franca for bridging human-ai chasm for explainable and advisable ai systems. In Proceedings of the AAAI Conference on Artificial Intelligence, volume 36, pages 12262–12267, 2022.
+
+[24] Subbarao Kambhampati, Karthik Valmeekam, Matthew Marquez, and Lin Guan. On the role of large language models in planning, July 2023. Tutorial presented at the International Conference on Automated Planning and Scheduling (ICAPS), Prague. https://yochan-lab.github. io/tutorial/ICAPS-2023/.
+
+[25] George Konidaris, Leslie Pack Kaelbling, and Tomas Lozano-Perez. From skills to symbols: Learning symbolic representations for abstract high-level planning. Journal of Artificial Intelligence Research, 61:215–289, 2018.
+
+[26] Kenneth Li, Aspen K Hopkins, David Bau, Fernanda Viégas, Hanspeter Pfister, and Martin Wattenberg. Emergent world representations: Exploring a sequence model trained on a synthetic task. In The Eleventh International Conference on Learning Representations, 2023.
+
+[27] Shuang Li, Xavier Puig, Chris Paxton, Yilun Du, Clinton Wang, Linxi Fan, Tao Chen, De-An Huang, Ekin Akyürek, Anima Anandkumar, et al. Pre-trained language models for interactive decision-making. Advances in Neural Information Processing Systems, 35:31199–31212, 2022.
+
+[28] Jacky Liang, Wenlong Huang, Fei Xia, Peng Xu, Karol Hausman, Brian Ichter, Pete Florence, and Andy Zeng. Code as policies: Language model programs for embodied control. arXiv preprint arXiv:2209.07753, 2022.
+
+[29] Kevin Lin, Christopher Agia, Toki Migimatsu, Marco Pavone, and Jeannette Bohg. Text2motion: From natural language instructions to feasible plans. arXiv preprint arXiv:2303.12153, 2023.
+
+[30] Bo Liu, Yuqian Jiang, Xiaohan Zhang, Qiang Liu, Shiqi Zhang, Joydeep Biswas, and Peter Stone. Llm+ p: Empowering large language models with optimal planning proficiency. arXiv preprint arXiv:2304.11477, 2023.
+
+[31] Man Luo, Shrinidhi Kumbhar, Mihir Parmar, Neeraj Varshney, Pratyay Banerjee, Somak Aditya, Chitta Baral, et al. Towards logiglue: A brief survey and a benchmark for analyzing logical reasoning capabilities of language models. arXiv preprint arXiv:2310.00836, 2023.
+
+[32] Qing Lyu, Shreya Havaldar, Adam Stein, Li Zhang, Delip Rao, Eric Wong, Marianna Apidianaki, and Chris Callison-Burch. Faithful chain-of-thought reasoning. arXiv preprint arXiv:2301.13379, 2023.
+
+[33] Drew McDermott, Malik Ghallab, Adele E. Howe, Craig A. Knoblock, Ashwin Ram, Manuela M. Veloso, Daniel S. Weld, and David E. Wilkins. Pddl-the planning domain definition language. 1998.
+
+[34] Kolby Nottingham, Prithviraj Ammanabrolu, Alane Suhr, Yejin Choi, Hannaneh Hajishirzi, Sameer Singh, and Roy Fox. Do embodied agents dream of pixelated sheep?: Embodied decision making using language guided world modelling. arXiv preprint arXiv:2301.12050, 2023.
+
+[35] Alberto Olmo, Sarath Sreedharan, and Subbarao Kambhampati. Gpt3-to-plan: Extracting plans from text using gpt-3. arXiv preprint arXiv:2106.07131, 2021.
+
+[36] OpenAI. Introducing chatgpt by openai, 2022.
+
+[37] OpenAI. Gpt-4 technical report, 2023.
+
+[38] Vishal Pallagani, Bharath Muppasani, Keerthiram Murugesan, Francesca Rossi, Lior Horesh, Biplav Srivastava, Francesco Fabiano, and Andrea Loreggia. Plansformer: Generating symbolic plans using transformers. arXiv preprint arXiv:2212.08681, 2022.
+
+[39] Liangming Pan, Alon Albalak, Xinyi Wang, and William Yang Wang. Logic-lm: Empowering large language models with symbolic solvers for faithful logical reasoning. arXiv preprint arXiv:2305.12295, 2023.
+
+[40] Xavier Puig, Kevin Ra, Marko Boben, Jiaman Li, Tingwu Wang, Sanja Fidler, and Antonio Torralba. Virtualhome: Simulating household activities via programs. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pages 8494–8502, 2018.
+
+[41] Alec Radford, Jong Wook Kim, Chris Hallacy, Aditya Ramesh, Gabriel Goh, Sandhini Agarwal, Girish Sastry, Amanda Askell, Pamela Mishkin, Jack Clark, et al. Learning transferable visual models from natural language supervision. In International conference on machine learning, pages 8748–8763. PMLR, 2021.   
+[42] Shreyas Sundara Raman, Vanya Cohen, Eric Rosen, Ifrah Idrees, David Paulius, and Stefanie Tellex. Planning with large language models via corrective re-prompting. arXiv preprint arXiv:2211.09935, 2022.   
+[43] Scott Reed, Konrad Zolna, Emilio Parisotto, Sergio Gomez Colmenarejo, Alexander Novikov, Gabriel Barth-Maron, Mai Gimenez, Yury Sulsky, Jackie Kay, Jost Tobias Springenberg, et al. A generalist agent. arXiv preprint arXiv:2205.06175, 2022.   
+[44] Stuart Jonathan Russell. Norvig (2003). Artificial intelligence: a modern approach, 25:26, 2003.   
+[45] Timo Schick, Jane Dwivedi-Yu, Roberto Dessì, Roberta Raileanu, Maria Lomeli, Luke Zettlemoyer, Nicola Cancedda, and Thomas Scialom. Toolformer: Language models can teach themselves to use tools. arXiv preprint arXiv:2302.04761, 2023.   
+[46] Noah Shinn, Beck Labash, and Ashwin Gopinath. Reflexion: an autonomous agent with dynamic memory and self-reflection. arXiv preprint arXiv:2303.11366, 2023.   
+[47] Mohit Shridhar, Xingdi Yuan, Marc-Alexandre Côté, Yonatan Bisk, Adam Trischler, and Matthew Hausknecht. ALFWorld: Aligning Text and Embodied Environments for Interactive Learning. In Proceedings of the International Conference on Learning Representations (ICLR), 2021.   
+[48] Tom Silver, Varun Hariprasad, Reece S Shuttleworth, Nishanth Kumar, Tomás Lozano-Pérez, and Leslie Pack Kaelbling. Pddl planning with pretrained large language models. In NeurIPS 2022 Foundation Models for Decision Making Workshop, 2022.   
+[49] Ron M Simpson, Diane E Kitchin, and Thomas Leo McCluskey. Planning domain definition using gipo. The Knowledge Engineering Review, 22(2):117–134, 2007.   
+[50] Ishika Singh, Valts Blukis, Arsalan Mousavian, Ankit Goyal, Danfei Xu, Jonathan Tremblay, Dieter Fox, Jesse Thomason, and Animesh Garg. Progprompt: Generating situated robot task plans using large language models. arXiv preprint arXiv:2209.11302, 2022.   
+[51] Chan Hee Song, Jiaman Wu, Clayton Washington, Brian M Sadler, Wei-Lun Chao, and Yu Su. Llm-planner: Few-shot grounded planning for embodied agents with large language models. arXiv preprint arXiv:2212.04088, 2022.   
+[52] Sarath Sreedharan, Tathagata Chakraborti, Christian Muise, Yasaman Khazaeni, and Subbarao Kambhampati. –d3wa+–a case study of xaip in a model acquisition task for dialogue planning. In Proceedings of the International Conference on Automated Planning and Scheduling, volume 30, pages 488–497, 2020.   
+[53] Kaya Stechly, Matthew Marquez, and Subbarao Kambhampati. Gpt-4 doesn’t know it’s wrong: An analysis of iterative prompting for reasoning problems. arXiv preprint arXiv:2310.12397, 2023.   
+[54] Karthik Valmeekam, Matthew Marquez, and Subbarao Kambhampati. Can large language models really improve by self-critiquing their own plans? arXiv preprint arXiv:2310.08118, 2023.   
+[55] Karthik Valmeekam, Matthew Marquez, Sarath Sreedharan, and Subbarao Kambhampati. On the planning abilities of large language models–a critical investigation. arXiv preprint arXiv:2305.15771, 2023.   
+[56] Zihao Wang, Shaofei Cai, Anji Liu, Xiaojian Ma, and Yitao Liang. Describe, explain, plan and select: Interactive planning with large language models enables open-world multi-task agents. arXiv preprint arXiv:2302.01560, 2023.   
+[57] Lionel Wong, Gabriel Grand, Alexander K Lew, Noah D Goodman, Vikash K Mansinghka, Jacob Andreas, and Joshua B Tenenbaum. From word models to world models: Translating from natural language to the probabilistic language of thought. arXiv preprint arXiv:2306.12672, 2023.   
+[58] Yaqi Xie, Chen Yu, Tongyao Zhu, Jinbin Bai, Ze Gong, and Harold Soh. Translating natural language to planning goals with large-language models. arXiv preprint arXiv:2302.05128, 2023.   
+[59] Qiang Yang, Kangheng Wu, and Yunfei Jiang. Learning action models from plan examples using weighted max-sat. Artificial Intelligence, 171(2-3):107–143, 2007.   
+[60] Shunyu Yao, Jeffrey Zhao, Dian Yu, Nan Du, Izhak Shafran, Karthik R Narasimhan, and Yuan Cao. React: Synergizing reasoning and acting in language models. In The Eleventh International Conference on Learning Representations, 2023.   
+[61] Hankz Hankui Zhuo, Qiang Yang, Derek Hao Hu, and Lei Li. Learning complex action models with quantifiers and logical implications. Artificial Intelligence, 174(18):1540–1569, 2010.   
+[62] Hankz Hankui Zhuo, Yantian Zha, Subbarao Kambhampati, and Xin Tian. Discovering underlying plans based on shallow models. ACM Transactions on Intelligent Systems and Technology (TIST), 11(2):1–30, 2020.

parse/dev/zDbsSscmuj/zDbsSscmuj_content_list.json

@@ -0,0 +1,1172 @@
+[
+    {
+        "type": "text",
+        "text": "Leveraging Pre-trained Large Language Models to Construct and Utilize World Models for Model-based Task Planning ",
+        "text_level": 1,
+        "bbox": [
+            178,
+            122,
+            820,
+            198
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Lin Guan ∗   \nSchool of Computing & AI   \nArizona State University   \nTempe, AZ 85281   \nlguan9@asu.edu Karthik Valmeekam ∗   \nSchool of Computing & AI   \nArizona State University Tempe, AZ 85281 kvalmeek@asu.edu ",
+        "bbox": [
+            267,
+            251,
+            449,
+            320
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            549,
+            251,
+            730,
+            320
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Sarath Sreedharan Department of Computer Science Colorado State University Fort Collins, CO 80523 sarath.sreedharan@colostate.edu ",
+        "bbox": [
+            238,
+            342,
+            506,
+            411
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Subbarao Kambhampati   \nSchool of Computing & AI   \nArizona State University Tempe, AZ 85281 rao@asu.edu ",
+        "bbox": [
+            578,
+            342,
+            759,
+            411
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Abstract ",
+        "text_level": 1,
+        "bbox": [
+            462,
+            446,
+            535,
+            463
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "There is a growing interest in applying pre-trained large language models (LLMs) to planning problems. However, methods that use LLMs directly as planners are currently impractical due to several factors, including limited correctness of plans, strong reliance on feedback from interactions with simulators or even the actual environment, and the inefficiency in utilizing human feedback. In this work, we introduce a novel alternative paradigm that constructs an explicit world (domain) model in planning domain definition language (PDDL) and then uses it to plan with sound domain-independent planners. To address the fact that LLMs may not generate a fully functional PDDL model initially, we employ LLMs as an interface between PDDL and sources of corrective feedback, such as PDDL validators and humans. For users who lack a background in PDDL, we show that LLMs can translate PDDL into natural language and effectively encode corrective feedback back to the underlying domain model. Our framework not only enjoys the correctness guarantee offered by the external planners but also reduces human involvement by allowing users to correct domain models at the beginning, rather than inspecting and correcting (through interactive prompting) every generated plan as in previous work. On two IPC domains and a Household domain that is more complicated than commonly used benchmarks such as ALFWorld, we demonstrate that GPT-4 can be leveraged to produce high-quality PDDL models for over 40 actions, and the corrected PDDL models are then used to successfully solve 48 challenging planning tasks. Resources, including the source code, are released at: https://guansuns.github.io/pages/llm-dm. ",
+        "bbox": [
+            232,
+            473,
+            764,
+            777
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 Introduction ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            792,
+            312,
+            809
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "The field of artificial intelligence has been revolutionized with the advent of large pre-trained models. Of particular significance are transformer-based large language models (LLMs) which have showcased remarkable performance in natural language processing tasks. Along with these tasks, LLMs have been tested to perform another widely-studied crucial aspect of AI agents, namely, sequential decisionmaking or planning. Preliminary studies suggest that, in some everyday domains, LLMs are capable of suggesting sensible action plans [19, 1]. However, the correctness and executability of these plans are often limited. For instance, LLMs may regularly overlook the physical plausibility of actions in certain states and may not effectively handle long-term dependencies across multiple actions. Several approaches have been proposed to improve the planning capabilities of LLMs. One promising approach involves collecting feedback from the environment during plan execution and subsequently refining the plans. By incorporating various forms of feedback, such as sensory information [20], human corrections [60], or information of unmet preconditions [42, 56], the planners can re-plan and produce plans that are closer to a satisficing plan. ",
+        "bbox": [
+            174,
+            818,
+            825,
+            873
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            90,
+            825,
+            217
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Despite the improvements in planning performance, LLMs are still far from being a usable and reliable planner due to various factors: ",
+        "bbox": [
+            176,
+            224,
+            823,
+            252
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "(a) LLMs have not yet demonstrated sufficient capabilities in reasoning and planning [24, 55, 53, 54, 31]. Recent investigations show that even when provided with detailed descriptions of actions, such as a PDDL domain model [33] or a natural-language version of a PDDL model, LLMs still struggle to produce correct and executable plans [48, 55].   \n(b) Existing LLMs-planning paradigms only allow for feedback collection in a fully online manner, meaning that the feedback signals are only available after the agent has started executing the plan. However, when a faithful simulator is not available or is expensive to use, collecting feedback through actual plan execution can be costly and may not fully exploit the advantages of provably sound planning, as seen in classical-planning literature [11, 13].   \n(c) LLMs exhibit complex behaviors that are not yet fully understood, particularly with respect to error occurrences. LLM planners are prone to repeating the same mistakes in slightly different scenarios. Repeatedly providing the same feedback can lead to frustration for end users. ",
+        "bbox": [
+            200,
+            261,
+            825,
+            457
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "To overcome these limitations, rather than using LLMs directly as planners, we advocate a modelbased paradigm, wherein a PDDL world model is teased out of LLMs. We follow the identical problem setup as existing approaches, which involves providing the planner with a set of actions and their brief natural language descriptions. However, instead of directly mapping user commands to plans, we utilize LLMs to extract a symbolic representation of the actions in the form of PDDL action models. This intermediate output can be used with an external domain-independent planner to reliably search for feasible plans, or it can be used to validate and correct \"heuristic\" plans generated by an LLM planner. Additionally, our modular method essentially divides the planning process into two distinct parts, namely modeling the causal dependencies of actions and determining the appropriate sequence of actions to accomplish the goals. LLMs, which have been trained on extensive web-scale knowledge, exhibit greater proficiency in the former task rather than the latter. ",
+        "bbox": [
+            174,
+            465,
+            825,
+            617
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Nevertheless, we still take into account the fact that the LLMs may not be able to generate error-free PDDL models at the outset. To address this, we show that LLMs can also serve as an interface between PDDL and any feedback sources that can provide corrective feedback in natural language, such as humans and the PDDL validator in VAL [18]. The LLM middle layer translates PDDL representation to natural language and presents it to users for inspection. The acquired feedback is then incorporated and archived back to the PDDL models. This conceals the complexity of PDDL from users who do not have prior knowledge of PDDL, and enables seamless inclusion of feedback. We conducted an extensive evaluation of our methodology on two IPC domains [22] from classical planning literature and a household domain that has a more diverse set of actions and constraints than commonly used benchmarks such as ALFWORLD [47]. We assess the quality of the generated PDDL models through manual evaluation. Results show that GPT-4 [37] generates high-quality PDDL domain models with over 400 literals for 41 actions in total. Then, by replaying and continuing the PDDL-construction dialogue, we show that GPT-4 can readily correct all the errors according to natural language feedback from PDDL validators and humans. ",
+        "bbox": [
+            174,
+            626,
+            825,
+            819
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "We consider two use cases of the generated PDDL action models for downstream planning tasks. For one, by utilizing an LLM to translate user instructions into goal specifications in PDDL [58, 30], we can use any standard domain-independent planner to search for a plan. On the other hand, the extracted PDDL model can be used to validate plans suggested by an LLM planner and to provide corrective feedback in the form of unmet preconditions or goal conditions. In this case, the PDDL model is essentially serving as an inexpensive high-level simulator or a human proxy to ensure plan correctness. ",
+        "bbox": [
+            174,
+            828,
+            825,
+            911
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "This reduces the reliance on faithful simulators or extensive manual inspection of plans by domain experts. Compared to the first approach, the second approach potentially offers better flexibility in incorporating both explicit and implicit user constraints in common-sense domains because of the LLM planner. For instance, the LLM planner can directly incorporate ordering constraints such as \"heat the potato first before mashing it\" and \"bring me a fork first, then a plate.\" On the contrary, an approach purely based on classical planners would require extra steps, such as introducing extra state variables in the PDDL models, in order to accommodate such constraints. However, as demonstrated in our experiments, although the validation feedback significantly improves the plan correctness on average, the performance of the second approach is still limited by the \"planning capability\" of LLMs. ",
+        "bbox": [
+            173,
+            90,
+            825,
+            229
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "2 Related Work ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            243,
+            321,
+            260
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "LLMs and planning. The growing interest in evaluating the emergent abilities of LLMs paved way into exploring their abilities in sequential decision-making tasks. Preliminary studies [24, 55] have shown that off-the-shelf LLMs are currently incapable of producing accurate plans. But their plans can be used as heuristics or seeds to either an external planner or a human in the loop [55, 48]. SayCan [1] and Text2Motion [29] employ an LLM as a heuristic by utilizing it to score high-level actions, followed by a low-level planner that grounds these actions to determine the executability in the physical world. In a similar vein, [28, 50] use LLMs to generate plans represented in Python-style code. Other works have aimed to improve the planning performance of LLMs through prompt engineering [60] or collecting various forms of feedback such as sensory information [51, 20, 34], human corrections [60], self-corrections [46] or information of unmet preconditions [42, 56]. ",
+        "bbox": [
+            173,
+            268,
+            825,
+            406
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Training transformers for sequential decision-making tasks. Along with using off-the-shelf LLMs, there are works that either fine-tune LLMs [55, 38] or train sequence models [62, 27, 7, 43] for sequential decision making tasks. Experiments in [26] have shown that training sequence models on a specific task gives rise to an internal world representation within the model. In this work, we use off-the-shelf LLMs to construct symbolic world models without performing any extra training. ",
+        "bbox": [
+            174,
+            414,
+            823,
+            483
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Learning/acquiring symbolic domain models. In classical planning, the community has explored numerous learning-based methods [59, 61, 9, 25, 4] and interactive editor-based methods [49] for acquiring symbolic domain models. For a more comprehensive survey, we refer the reader to [2, 6]. Here, we are interested in leveraging the common-world knowledge embedded in LLMs and their in-context learning ability for constructing domain models. Recent studies have shown the efficacy of LLMs in translating natural language to formal descriptions [35] or constructing PDDL goals from natural-language instructions [58, 32]. Moreover, a contemporary work [15] considers the use of LLM as a parametric world model and plan critic. However, unlike a symbolic model that can simulate plan outcomes with guaranteed correctness, using LLMs directly as a world model actually adds another layer of errors. There is evidence that autoregressive models lack reliable capacity for reasoning about action effects [3, 31] and capturing errors in candidate plans [53, 54]. ",
+        "bbox": [
+            174,
+            491,
+            825,
+            643
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Language models with access to external tools. Since LLMs are approximately omniscient, they may not always outperform specialized models or tools in specific downstream tasks. To address this limitation, frameworks have been developed to enable LLMs to utilize external tools for performing sub-tasks like arithmetic [45] and logical reasoning [39, 57]. In this context, our work can be regarded as an exercise in employing external sound planners to augment the capacity of LLMs for more reliable plan generation. ",
+        "bbox": [
+            174,
+            651,
+            825,
+            734
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3 Problem Setting and Background ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            747,
+            485,
+            765
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Our work focuses on a scenario where an intelligent agent receives high-level instructions or tasks, denoted as $i$ , from a user. The agent is capable of only executing skills or operations that are part of a skill library $\\Pi$ , where each skill $k$ has a short language description $l _ { k }$ . We assume that the agent is equipped with the low-level control policies corresponding to these high-level skills. In order to achieve the goal conditions specified in $i$ , a planner, which can be either an LLM or an external planner [16, 12, 17], needs to come up with a sequence of high-level skills that the agent can execute. This type of problem is referred to as a sequential decision-making or planning problem. Similar to previous works such as [60, 20], we also allow for human-in-the-loop feedback during both the domain-model construction and plan execution stages. In the next subsections, we describe the formalism behind planning problems and a standard way in the literature to specify them. ",
+        "bbox": [
+            174,
+            772,
+            825,
+            911
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3.1 Classical planning problems ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            92,
+            408,
+            106
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "The most fundamental planning formalism is goal-directed deterministic planning problem, referred to as a classical planning problem in the planning literature. A classical planning problem [44] can be formally represented with a tuple $\\bar { \\mathcal { P } } = \\langle \\mathcal { D } , \\mathcal { I } , \\mathcal { G } \\rangle$ . $\\mathcal { D }$ is referred to as the domain, $I$ is the initial state, and $\\mathcal { G }$ is the goal specification. The state space of a planning problem consists of the truth assignments for predicates. The domain $\\mathcal { D }$ is further defined by the tuple ${ \\mathcal { D } } = \\langle { \\mathcal { F } } , A \\rangle$ . $\\mathcal { F }$ corresponds to the set of fluents, i.e., the state variables used to define the state space with each fluent corresponding to a predicate with some arity. $\\mathcal { A }$ corresponds to the set of actions that can be performed. Each action $a _ { i } [ \\mathcal { V } ] \\in \\mathcal { A }$ (where $\\nu$ is the set of variables used by the operator $a _ { i }$ and each variable could be mapped to an object) can be further defined by two components, the precondition $\\mathsf { p r e c } [ \\mathcal { V } ]$ which describes when an action can be executed, and the effects eff $[ \\nu ]$ which defines what happens when an action is executed. We assume that prec $[ \\nu ]$ consists of a set of predicates defined over the variables $\\nu$ . An action is assumed to be executable only if its preconditions are met, i.e, the predicates in the precondition hold in the given state. The effect set eff $[ \\nu ]$ is further defined by the tuple $\\langle \\mathsf { a d d } [ \\mathcal { V } ] , \\mathsf { d e l } [ \\mathcal { V } ] \\rangle$ , where $\\mathsf { a d d } [ \\nu ]$ is the set of predicates that will be set true by the action and $\\mathsf { d e l } [ \\nu ]$ is the set of predicates that will be set false by the action. An action is said to be grounded if we replace each of the variables with an object, else it is referred to as a lifted action model. A solution to a planning problem is called a plan, and it is a sequence of actions that once executed in the initial state would lead to a state where the goal specification holds. Classical planning problems are one of the simpler classes in planning and there are multiple extensions with more complex forms of preconditions, conditional effects, and also support for richer planning formalisms. ",
+        "bbox": [
+            173,
+            109,
+            825,
+            387
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3.2 PDDL ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            398,
+            256,
+            412
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Planning Definition and Domain Language (PDDL) [33], is the standard encoding language for classical planning problems. Here is an example of a lifted action in PDDL which corresponds to putting a block onto the table in the classical Blocksworld domain: ",
+        "bbox": [
+            176,
+            419,
+            825,
+            460
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "(:action PutDownBlock :parameters (?x - block) :precondition (and (robot-holding $? \\mathbf { x } )$ ) :effect (and (not (robot-holding $? \\mathbf { x } )$ ) (block-clear ?x) (robot-hand-empty) (block-on-table $? { \\bf x } )$ )) ",
+        "bbox": [
+            199,
+            487,
+            797,
+            530
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "The parameters line provides the possible variable(s), and in this case, $\\ ? \\mathbf { x }$ represents the block to put down. The precondition states that the robot must be holding the block in its gripper. The effects line describes the expected outcome of this action. ",
+        "bbox": [
+            176,
+            575,
+            825,
+            617
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "4 Methodology ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            632,
+            313,
+            650
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "PDDL provides a succinct and standardized way to represent a world model. Once a PDDL model is constructed, it can be seamlessly used by any domain-independent planner developed in the automated planning community to search for a plan given the initial state and goal conditions. In this section, we will introduce our solution for constructing PDDL models using LLMs. We then discuss techniques for correcting errors in the generated PDDL models. Finally, we present the full pipeline for utilizing the generated PDDL models to solve planning problems. ",
+        "bbox": [
+            174,
+            659,
+            825,
+            741
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "4.1 Constructing PDDL models with LLMs ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            753,
+            488,
+            768
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Our approach involves prompting pre-trained LLMs with the following information: (a) detailed instructions for the PDDL generation task, outlining components of upcoming inputs and desired outputs; (b) one or two examples from other domains (e.g., the classical Blocksworld domain) for illustrating the input and output formats; (c) a description of the current domain, including contextual information about the agent’s tasks and physical constraints due to the specific embodiment of the agent; (d) a description of the agent’s action; and (e) a dynamically updated list of predicates that the LLM can reuse to maintain consistent use of symbols across multiple actions. Note that the predicate list is initialized to an empty list, and thus all predicates are introduced by the LLM. The structure of the prompt is illustrated in Fig. 2, and a complete prompt for the household-robot domain can be found at Appx. A.6.1. ",
+        "bbox": [
+            174,
+            772,
+            825,
+            911
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "image",
+        "img_path": "images/07144245efd6d17b9a3f71bf358d907857248bc85cbcf0a3600c058743ac31c7.jpg",
+        "image_caption": [
+            "Figure 1: An overview of our framework and existing methods that use LLMs directly as planners. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            183,
+            97,
+            816,
+            327
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Depending on the information included in the action description or the domain context, users may gain varying levels of control over the extracted PDDL or receive differing levels of support from the LLMs. On one hand, when the user provides only a minimal description of the action, such as \"this action enables the robot to use a microwave to heat food,\" we not only use the LLM as a PDDL constructor but also leverage the common world knowledge encoded within the model for knowledge acquisition. This is particularly useful when expanding the set of actions for an AI agent. For example, a robot engineer could set up a training environment for skill learning by following the suggested preconditions and effects. On the other hand, when some preconditions or effects are explicitly mentioned in the prompt, we rely more on the LLM’s ability to parse the knowledge provided in natural language and to precisely represent it by devising a collection of predicates. This capability is useful when there could be different initial setups of a skill, and the engineers have already made some assumptions on the preconditions at the time of designing the skill. This capability is also crucial when constructing PDDL for specialized domains. For instance, robots such as Fetch and Spot Robot have only one robot arm, which is less flexible than a human arm, and are therefore subject to many uncommon physical constraints. ",
+        "bbox": [
+            174,
+            395,
+            825,
+            602
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "The desired output comprises the following elements: (a) the list of arguments for the action; (b) the preconditions and effects expressed in PDDL; and (c) a list of any newly defined predicates and their descriptions in natural language, if applicable. An example output is shown in Fig. 2. Our algorithm generates PDDL models for each action separately, one at a time, by iterating over the set of actions. Any newly defined predicates will be added to an actively maintained predicate list, such that the LLM can reuse existing predicates in subsequent actions without creating redundant ones. Once we obtain the initial PDDL models and the full predicate list, we repeat the entire process but with all of the extracted predicates presented to the LLM. Running the generation process twice is useful because the LLMs may be unaware of some precondition(s) during the first iteration, especially if the precondition(s) are not explicitly mentioned. For instance, the LLM may overlook the fact that a furniture piece can be openable, but a predicate created in the \"open a furniture piece or appliance\" skill can inform the LLM of this fact. One alternative to this action-by-action generation could be to include descriptions of all the actions in the prompt and require the LLM to construct the entire domain model in a single dialogue. An additional discussion on this can be found at Sec. A.2 in Appendix. ",
+        "bbox": [
+            173,
+            612,
+            825,
+            819
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "It is worth noting that every time a new predicate is defined, the LLM is required to give the natural language description of it. As we will see in the following sections, this is crucial for enabling any user to easily understand and inspect the generated PDDL models without having to delve into the low-level symbolic representation. Additionally, natural language descriptions allow the predicate values of the initial state to be automatically grounded by using LLMs to translate environment description in natural language to PDDL [30], or leveraging pre-trained vision-language models ",
+        "bbox": [
+            174,
+            828,
+            823,
+            911
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Instructions for the PDDL generation task   \nYou are defining the preconditions and effects (represented in PDDL format) of an AI agent's $\\hookrightarrow$ actions. Information about the AI agent will be provided in the domain description ... One or two examples from other domains for illustrating the input and output formats   \nHere are two examples from the classical BlocksWorld domain for demonstrating the output format. Here is the task. ",
+        "bbox": [
+            197,
+            99,
+            810,
+            174
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "A natural language description of the domain ",
+        "bbox": [
+            199,
+            175,
+            467,
+            184
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Domain information: The AI agent here is a household robot that can navigate to various large and $\\hookrightarrow$ normally immovable furniture pieces or appliances in the house to carry out household tasks $\\hookrightarrow$ ",
+        "bbox": [
+            194,
+            185,
+            795,
+            215
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "A natural language description of the action ",
+        "bbox": [
+            200,
+            217,
+            468,
+            226
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Action: This action enables the robot to toggle small appliances (like humidifiers and light $\\hookrightarrow$ bulbs) which are toggleable to switch them on ",
+        "bbox": [
+            196,
+            227,
+            759,
+            246
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "The dynamically updated list of predicates ",
+        "bbox": [
+            199,
+            247,
+            459,
+            257
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "You can create and define new predicates, but you may also reuse the following predicates: ",
+        "bbox": [
+            204,
+            258,
+            759,
+            267
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "1. (robot-at ?r - robot ?f - furnitureAppliance): true if the robot $\\mathord { ? } \\mathbf { r }$ is at the furniture or $\\hookrightarrow$ appliance ?f ",
+        "bbox": [
+            194,
+            268,
+            772,
+            287
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "2. (object-in-on ?o - householdObject ?f - furnitureAppliance): true if the object ?o is in or on $\\hookrightarrow$ the furniture or appliance ?f ",
+        "bbox": [
+            194,
+            289,
+            784,
+            308
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Parameters: ",
+        "bbox": [
+            199,
+            319,
+            266,
+            327
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "The LLM: ",
+        "text_level": 1,
+        "bbox": [
+            199,
+            338,
+            251,
+            348
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "image",
+        "img_path": "images/d901b4063bc05cf5435f6666e2be758e7e524efd02219a279a79281f33d84b2f.jpg",
+        "image_caption": [
+            "Figure 2: The prompt template for PDDL construction and an example of the LLM output for the household domain. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            197,
+            344,
+            818,
+            532
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "[41, 37, 10] and querying them in a question-answering manner, based on observations from the environment. ",
+        "bbox": [
+            173,
+            606,
+            823,
+            633
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "4.2 Correcting errors in the initial PDDL models ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            646,
+            526,
+            661
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "As with any use case involving LLMs, there is no guarantee that the output is completely error-free. Therefore, it is essential to incorporate error-correction mechanisms. While it may be easy for PDDL experts to directly inspect and correct the generated PDDL models, we cannot assume that all end users possess this level of expertise. Our solution is to use the LLM as a middle layer or interface between the underlying PDDL model and any feedback source that can provide corrective feedback in natural language. We consider two feedback sources in this work, namely the PDDL model validation tools (e.g., the one in VAL [18]) and human domain experts. The former is used to detect basic syntax errors, while the latter is mainly responsible for catching factual errors, such as missing effects. It is worth noting that the feedback sources are not limited to those mentioned above, and we leave the investigation of other sources for future research. ",
+        "bbox": [
+            173,
+            666,
+            825,
+            804
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "For corrective feedback from PDDL validators, a generated PDDL model is directly presented to the validator to obtain brief but readable error messages. Examples of feedback messages for syntax errors are shown in Appx. A.3. For corrective feedback from users, a PDDL model is translated into its natural-language version based on the natural language descriptions of the predicates and parameters (Sec. 4.1). The user can then examine potentially erroneous action models. Human corrections can occur both during the construction of PDDL models and after the models have been used for planning. Although there are techniques available to assist users to locate errors in the models (as discussed in ",
+        "bbox": [
+            174,
+            814,
+            825,
+            911
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Appx. A.4), this is beyond the scope of this work, since the focus here is to investigate the feasibility of using LLMs to correct PDDL models based on feedback. We also note that correcting action models is not more cognitively demanding than correcting plans or the \"reasoning traces\" of an LLM planner [60]. In fact, when correcting plans, humans must also maintain the action models and their causal chains in mind in order to validate the plans. More importantly, once the action models are corrected, users no longer need to provide similar feedback repeatedly. Finally, corrective feedback is integrated by replaying and continuing the PDDL-construction dialogue. Examples of such dialogues can be found in Sec. A.7, Sec. A.9, and Sec. A.11 in Appendix. ",
+        "bbox": [
+            174,
+            90,
+            825,
+            202
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "4.3 Generating plans with the extracted PDDL models ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            212,
+            563,
+            227
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Recall that given the set of extracted predicates and their natural language descriptions, we can get the grounded initial state by using LLMs to translate descriptions of the environment to PDDL, or by observing the environment and querying pre-trained vision-language models. Besides, the goal specification can be obtained by using an LLM to parse the user’s command and convert it into a symbolic form, as done previously in [30, 58, 32]. With this setup, the following two methods can be used to generate the final plans. ",
+        "bbox": [
+            174,
+            231,
+            825,
+            314
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Classical planner with LLM-acquired PDDL model. One straightforward approach is to employ a standard domain-independent planner to reliably find a satisficing or even optimal plan for the specified goal. In common-sense domains where LLMs may generate meaningful \"heuristics\", the LLM plans may also be used as seed plans for a local-search planner such as LPG [12] to accelerate the plan searching. This is similar to the approach suggested in [55], but with a higher degree of automation. ",
+        "bbox": [
+            174,
+            320,
+            825,
+            404
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "LLM modulo planner backprompted by VAL using LLM-acquired PDDL model. As outlined in Sec. 1, we can also use the extracted PDDL as a symbolic simulator or human proxy to provide corrective feedback based on validation information to an LLM planner. With this setup, the planner can iteratively refine the plans through re-prompting [42]. ",
+        "bbox": [
+            174,
+            411,
+            823,
+            467
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "It is worth noting that depending on the specific problem settings, the extracted PDDL model can also be used for tasks other than task planning. For instance, in cases where reinforcement learning is permissible, the domain model can be used to guide skill learning [21, 8] or exploration even if the model is not fully situated [14]. ",
+        "bbox": [
+            174,
+            473,
+            825,
+            529
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "5 Empirical Evaluation ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            541,
+            385,
+            559
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "We conduct our experiments 2 on an everyday household-robot domain and two more specialized IPC domains (i.e., Tyreworld and Logistics). The Household domain is similar to other commonly used benchmarks like ALFWORLD [47] and VirtualHome [40]. However, in our household domain, a single-arm robot is equipped with a more diverse and extended set of 22 mobile and manipulation skills. In addition, we apply more rigorous physical-plausibility constraints to each skill. A detailed description of this domain can be found at Appx. A.5. In our experiments, we first evaluate the quality of PDDL models generated by the LLMs. Next, we assess the ability of the LLMs to incorporate corrective feedback from both PDDL validators and users in order to obtain error-free PDDL models. Lastly, we showcase multiple ways to use the corrected PDDL model for downstream planning tasks. We present the results of GPT-4 [37] and GPT-3.5-Turbo [36] for PDDL construction (we also conducted experiments with GPT-3 [5], and observe that its performance is comparable to that of GPT-3.5-Turbo). ",
+        "bbox": [
+            173,
+            566,
+            826,
+            733
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "5.1 Constructing PDDL ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            743,
+            351,
+            757
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "In PDDL construction tasks, we aim to investigate the extent to which LLMs can construct accurate PDDL models before getting corrective feedback from domain experts. For all the domains, two actions from the classical Blocksworld domain are used as demonstrations in the prompt so that the end user is not required to come up with any domain-specific example. To evaluate the degree of correctness, we recruit multiple graduate students who possess expertise in PDDL. These experts are responsible for annotating and correcting any errors present in the generated PDDL models. As an evaluation metric, we count and report the total number of annotations, which may include the removal of irrelevant preconditions, the addition of missing preconditions, the replacement of incorrect predicates, the inclusion of missing parameters, and other commonly made corrections. Note that the number of annotations can be viewed as the approximate distance between a generated PDDL model and its corrected version. In order to provide the reader with a comprehensive understanding of the quality of the generated models, we also list all the models and collected annotations in Appendix. In each of the figures, errors that affect the functionality of the PDDL model are highlighted in yellow, while minor issues are highlighted in green. One example of a minor issue is the redundant inclusion of (pickupable ?o) in preconditions when (robot-holding ?o) has already been listed. The former is unnecessary because it can be implied by the latter, but this only affects conciseness rather than functionality. ",
+        "bbox": [
+            174,
+            761,
+            825,
+            886
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            90,
+            825,
+            203
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "table",
+        "img_path": "images/d0e2efdeffe32409b295806e5b1262e76f36be546617dd3317a90a9867a6717b.jpg",
+        "table_caption": [
+            "Table 1: The number of errors in the domain models produced by the LLMs for each of the domains. A $\" + \"$ mark indicates that the generated model is excessively noisy, making it challenging to determine an exact number of errors. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Domain</td><td># of actions</td><td># of params and literals</td><td># of GPT-4 errors</td><td># of GPT-3.5-Turbo errors</td></tr><tr><td>Household</td><td>22</td><td>271</td><td>53</td><td>218+</td></tr><tr><td>Logistics</td><td>6</td><td>54</td><td>2</td><td>38</td></tr><tr><td>Tyreworld</td><td>13</td><td>108</td><td>4</td><td>94+</td></tr></table>",
+        "bbox": [
+            191,
+            218,
+            807,
+            285
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "We first evaluate the PDDL models generated when partial constraint information is given, as this is closer to most of the practical use cases where constraints on skills in the library $\\Pi$ are often pre-specified. In this setting, our evaluation focuses on the LLMs’ ability to accurately recover a \"ground truth PDDL\" that captures the mentioned constraints and underlying dependencies among skills. Our results indicate that GPT-4 can produce high-quality PDDL models with significantly fewer errors when compared to GPT-3.5-Turbo. Table 1 presents the number of errors in the generated domain models for each domain. To help the readers understand the complexities of the action models, we additionally report the total number of parameters and literals in the final corrected domain models produced by GPT-4. Out of the total 59 errors made by GPT-4, three of them are syntax errors and the rest are factual errors such as missing preconditions and effects. This observation suggests that while GPT-4 demonstrates proficiency in adhering to the grammar of PDDL, it may still have an inaccurate understanding of the actions. By examining the set of predicates (listed in the Appendix), we also find that GPT-4 can devise a set of intuitively-named predicates that can concisely and precisely describe the states of objects and events in the domain. In contrast, GPT-3.5-Turbo produces highly noisy outputs with over 350 errors. This suggests that our framework relies heavily on GPT-4’s improved capability in understanding symbols, and future work may investigate how to enable the use of more lightweight models (e.g., by fine-tuning on some PDDL datasets). Furthermore, recall that when the action description contains minimal information, LLMs could also be utilized to propose preconditions and effects to assist with knowledge acquisition. To verify this hypothesis, we conduct additional experiments on the Household domain that can have a more open-ended action design. In this setting, the correctness of the action models is determined based on whether the preconditions and effects establish correct connections among the actions. Our results show that GPT-4 can suggest meaningful action models, and the generated PDDL models have only around 45 errors. ",
+        "bbox": [
+            173,
+            375,
+            825,
+            693
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Although GPT-4 has shown improved performance in the PDDL construction task, our experiments still uncover some limitations. Firstly, GPT-4 still exhibits a shallow understanding of the causal relationships between actions, particularly when it comes to tasks involving reasoning skills such as spatial reasoning. For instance, when constructing the model of action \"pick up an object from a furniture piece,\" GPT-4 fails to consider that there could be other objects stacked on top of the target object, even if relevant predicates are provided (which were created in the action \"stack objects\"). In addition, although it occurs rarely, GPT-4 may output contradictory effects. For instance, in the action of mashing food with a blender, GPT-4 lists both (not (object-in-receptacle ...)) and (object-in-receptacle ...) as effects at the same time. ",
+        "bbox": [
+            174,
+            700,
+            825,
+            825
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "5.2 Correcting PDDL with domain experts ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            835,
+            482,
+            852
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "We proceed with the PDDL models generated by GPT-4 when the constraint information is partially given. Our objective is to demonstrate the feasibility of using GPT-4 as a middle layer to incorporate natural-language feedback and correct the PDDL models. As discussed in Sec. 4.2, we use PDDL validators to capture basic syntax errors. In the Household domain, there are two syntax errors associated with improper usage of relevant predicates due to issues with the object types of parameters . As shown in Appx. A.7.1, by continuing the PDDL-construction dialogue with a feedback message \"the second parameter of object-on should be a furnitureAppliance but a householdObject was given,\" GPT-4 can locate the inaccurate PDDL snippet and replace it with a correct one. For the other factual errors, GPT-4 successfully corrects all of them based on the natural language feedback. An example feedback message on factual errors is \"there is a missing effect: the item is no longer pickupable after being mashed.\" More PDDL-correction conversations can be found in Appendix. We also experiment with feedback written in various ways, and GPT-4 is able to understand all the messages and successfully correct the models. To quantify how effectively GPT-4 utilizes feedback from domain experts, we count the number of feedback messages concerning factual errors. Our result shows that GPT-4 required 59 feedback messages to address a total of 56 factual errors. There are three instances where additional feedback was needed. One case involved the user reiterating the error, while the other two cases involved GPT-4 introducing new errors. Furthermore, we attempt to correct the same errors using GPT-3.5-Turbo. Results show that GPT-3.5-Turbo not only fails to correct all the errors but also occasionally introduces new errors, again confirming its lack of ability to manipulate symbols. Some examples can be found in Appendix starting from Sec. A.7.3. ",
+        "bbox": [
+            174,
+            856,
+            825,
+            911
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            90,
+            825,
+            325
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "5.3 Generating plans with the extracted PDDL models ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            337,
+            565,
+            352
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "For planning tasks (i.e., user instructions and initial states), we use the Household domain and Logistics domain, where state-of-the-art LLM planners struggle to find valid plans. We sampled 27 tasks for Household and 21 for Logistics. For the initial states, we assume the grounding is provided, and for the goals, we leverage GPT-4 to translate user instructions into PDDL goal specifications in terms of the extracted predicates (an example prompt can be found at Appx. A.13), and send it over to a standard STRIPS planner which already has access to the domain model acquired through LLMs. With this setup, a classical planner Fast Downward [16] can effectively find valid plans in $9 5 \\%$ of the cases (the failures were only due to goal translation errors). Note that in contrast to earlier methods such as [30] that use LLMs only as a mechanism for translating user goals to PDDL format, and throw that over to external sound planners with hand-crafted correct PDDL domain models, our approach uses LLMs themselves to develop the PDDL world model driving the external planner. ",
+        "bbox": [
+            173,
+            356,
+            825,
+            507
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "On the other hand, for the approach that utilizes PDDL models to validate LLM plans (i.e., LLM modulo planner back-prompted by VAL using LLMacquired domain model), we employ the state-of-the-art algorithm ReAct [60] with GPT-4 as the underlying LLM planner. However, we made two modifications to the prompt design. Firstly, we provide a detailed description of all actions in natural language, including parameters, preconditions, and effects. These descriptions are ob",
+        "bbox": [
+            174,
+            515,
+            419,
+            694
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "table",
+        "img_path": "images/11bfb59fead5323d2896eddc2027f6a74d32ef7ff6b34a56923deb0f579b7cd2.jpg",
+        "table_caption": [
+            "Table 2: Success rates of different planning approaches in the Household domain and the Logistics domain. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Planner Type</td><td>Household</td><td>Logistics</td></tr><tr><td>Only LLMPlanner</td><td>15%</td><td>0%</td></tr><tr><td>Fast Downward with LLM-acquired PDDL model</td><td>95%</td><td>100%</td></tr><tr><td>LLM backprompted by VAL using LLM-acquired PDDL model</td><td>48%</td><td>33%</td></tr></table>",
+        "bbox": [
+            431,
+            531,
+            825,
+            637
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "tained by using another LLM to translate the generated PDDL domain model into natural language. Secondly, we use only two fixed examples for each domain because end users might not always be able to provide a large pool of examples, and the planner should rely on the action model information. The LLM plans, symbolic goal specifications, initial states and domain models are passed to a plan validation system (i.e., VAL) to check for unmet precondition(s) or goal condition(s). The validation results (given in PDDL) are then translated into natural language with GPT-4 and provided to the LLM planner by continuing the planning dialogue (see Appx. A.12.1 for examples). In our experiments, we limit the number of feedbacks per task to 8 due to the restricted access to GPT-4. Table 2 provides a summary of the average success rates of all approaches. Not surprisingly, the vanilla LLM planner constantly overlooks action preconditions and achieves an extremely low success rate. With the integration of validation feedback, we observe a notable improvement in plan correctness. Despite this improvement, the overall performance is still not satisfactory, as the success rate remains below ",
+        "bbox": [
+            174,
+            694,
+            826,
+            859
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "$50 \\%$ . Furthermore, we have observed that GPT-4 fails to effectively utilize the feedback, often getting stuck in a loop by repeatedly generating the same plan. In some cases, it may also introduce new errors while attempting to rectify the plans. ",
+        "bbox": [
+            176,
+            92,
+            823,
+            133
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Beyond the notion of correctness, the experiments also uncover intriguing properties of the LLM planner. In the Household domain, we intentionally introduce ordering constraints in some instructions that cannot be expressed using existing predicates (refer to Appx. A.12 for examples). Remarkably, upon manual examination of the generated plans, we observe that all LLM plans adhere to the specified ordering, despite not being entirely correct or executable. Furthermore, also in the Household domain, we observe that classical planners occasionally generate physically plausible but unconventional actions, such as placing a knife on a toaster when the knife is not being used. In contrast, the LLM planner rarely exhibits such actions, suggesting that LLMs possess knowledge of implicit human preferences. It would be meaningful to explore methods that more effectively combine the strengths of LLM planners and the correctness guarantee provided by symbolic domain models, particularly in determining which information from LLM plans should be preserved. ",
+        "bbox": [
+            174,
+            140,
+            825,
+            291
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "6 Conclusion ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            304,
+            299,
+            320
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "We introduce a new paradigm for leveraging LLMs in planning tasks, which involves maintaining an explicit world model instead of directly mapping user prompts to plans. This is motivated by the insight that LLMs, while incapable of the combinatorial search needed to produce correct plans, may be better suited as the source of world models. We present a complete pipeline that begins with generating high-quality PDDL models using GPT-4, then corrects the PDDL models with naturallanguage feedback, and finally utilizes the extracted domain models to reliably plan in multiple ways. Our experiments demonstrate that pairing LLMs with an external planner significantly outperforms existing methods when applied to two IPC domains and a household-robot domain that has more action-wise constraints than commonly used benchmarks such as ALFWorld. Apart from directions for further research that we have previously mentioned, there are several exciting opportunities for extending this work. Firstly, the complexity of our evaluation domains is still lower than that of many domains used in the classical planning literature. It remains to be seen whether LLMs can effectively scale to write PDDL models that express more intricate logic. Secondly, our framework assumes full observability, meaning that the agent must fully explore the environment to acquire object states at the beginning. It would be useful to support partial observability. Finally, our experiments assume the grounding of predicate values is done perfectly. However, it would be useful to take into account that perception can be noisy in practice. ",
+        "bbox": [
+            174,
+            329,
+            825,
+            563
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Acknowledgement ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            575,
+            330,
+            593
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "This research was supported by ONR grants N00014-18-1-2442, N00014-18-1-2840, N00014- 19-1-2119 and N00014-23-1-2409, AFOSR grant FA9550-18-1-0067, DARPA SAIL-ON grant W911NF-19-2-0006, and a JP Morgan AI Faculty Research Grant to Kambhampati. Sreedharan was supported in part by NSF grant 2303019. ",
+        "bbox": [
+            174,
+            599,
+            825,
+            656
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "References ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            669,
+            266,
+            684
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "[1] Michael Ahn, Anthony Brohan, Noah Brown, Yevgen Chebotar, Omar Cortes, Byron David, Chelsea Finn, Keerthana Gopalakrishnan, Karol Hausman, Alex Herzog, et al. Do as i can, not as i say: Grounding language in robotic affordances. arXiv preprint arXiv:2204.01691, 2022.   \n[2] Ankuj Arora, Humbert Fiorino, Damien Pellier, Marc Métivier, and Sylvie Pesty. A review of learning planning action models. The Knowledge Engineering Review, 33:e20, 2018.   \n[3] Pratyay Banerjee, Chitta Baral, Man Luo, Arindam Mitra, Kuntal Pal, Tran C Son, and Neeraj Varshney. Can transformers reason about effects of actions? arXiv preprint arXiv:2012.09938, 2020.   \n[4] Blai Bonet and Hector Geffner. Learning first-order symbolic representations for planning from the structure of the state space. arXiv preprint arXiv:1909.05546, 2019.   \n[5] Tom Brown, Benjamin Mann, Nick Ryder, Melanie Subbiah, Jared D Kaplan, Prafulla Dhariwal, Arvind Neelakantan, Pranav Shyam, Girish Sastry, Amanda Askell, et al. Language models are few-shot learners. Advances in neural information processing systems, 33:1877–1901, 2020. [6] Ethan Callanan, Rebecca De Venezia, Victoria Armstrong, Alison Paredes, Tathagata Chakraborti, and Christian Muise. Macq: A holistic view of model acquisition techniques. In The ICAPS Workshop on Knowledge Engineering for Planning and Scheduling (KEPS), 2022. [7] Hongyi Chen, Yilun Du, Yiye Chen, Joshua B. Tenenbaum, and Patricio A. Vela. Planning with sequence models through iterative energy minimization. In The Eleventh International Conference on Learning Representations, 2023. [8] Shuo Cheng and Danfei Xu. Guided skill learning and abstraction for long-horizon manipulation. arXiv preprint arXiv:2210.12631, 2022. [9] Stephen N Cresswell, Thomas L McCluskey, and Margaret M West. Acquiring planning domain models using locm. The Knowledge Engineering Review, 28(2):195–213, 2013.   \n[10] Danny Driess, Fei Xia, Mehdi SM Sajjadi, Corey Lynch, Aakanksha Chowdhery, Brian Ichter, Ayzaan Wahid, Jonathan Tompson, Quan Vuong, Tianhe Yu, et al. Palm-e: An embodied multimodal language model. arXiv preprint arXiv:2303.03378, 2023.   \n[11] Richard E Fikes and Nils J Nilsson. Strips: A new approach to the application of theorem proving to problem solving. Artificial intelligence, 2(3-4):189–208, 1971.   \n[12] Alfonso Gerevini and Ivan Serina. Lpg: A planner based on local search for planning graphs with action costs. In AIPS, volume 2, pages 281–290, 2002.   \n[13] Malik Ghallab, Dana Nau, and Paolo Traverso. Automated Planning: theory and practice. Elsevier, 2004.   \n[14] Lin Guan, Sarath Sreedharan, and Subbarao Kambhampati. Leveraging approximate symbolic models for reinforcement learning via skill diversity. In International Conference on Machine Learning, pages 7949–7967. PMLR, 2022.   \n[15] Shibo Hao, Yi Gu, Haodi Ma, Joshua Jiahua Hong, Zhen Wang, Daisy Zhe Wang, and Zhiting Hu. Reasoning with language model is planning with world model. arXiv preprint arXiv:2305.14992, 2023.   \n[16] Malte Helmert. The fast downward planning system. Journal of Artificial Intelligence Research, 26:191–246, 2006.   \n[17] Jörg Hoffmann and Bernhard Nebel. The ff planning system: Fast plan generation through heuristic search. Journal of Artificial Intelligence Research, 14:253–302, 2001.   \n[18] Richard Howey, Derek Long, and Maria Fox. Val: Automatic plan validation, continuous effects and mixed initiative planning using pddl. In 16th IEEE International Conference on Tools with Artificial Intelligence, pages 294–301. IEEE, 2004.   \n[19] Wenlong Huang, Pieter Abbeel, Deepak Pathak, and Igor Mordatch. Language models as zero-shot planners: Extracting actionable knowledge for embodied agents. In International Conference on Machine Learning, pages 9118–9147. PMLR, 2022.   \n[20] Wenlong Huang, Fei Xia, Ted Xiao, Harris Chan, Jacky Liang, Pete Florence, Andy Zeng, Jonathan Tompson, Igor Mordatch, Yevgen Chebotar, et al. Inner monologue: Embodied reasoning through planning with language models. arXiv preprint arXiv:2207.05608, 2022.   \n[21] León Illanes, Xi Yan, Rodrigo Toro Icarte, and Sheila A McIlraith. Symbolic plans as high-level instructions for reinforcement learning. In Proceedings of the international conference on automated planning and scheduling, volume 30, pages 540–550, 2020.   \n[22] IPC. International planning competition, 1998.   \n[23] Subbarao Kambhampati, Sarath Sreedharan, Mudit Verma, Yantian Zha, and Lin Guan. Symbols as a lingua franca for bridging human-ai chasm for explainable and advisable ai systems. In Proceedings of the AAAI Conference on Artificial Intelligence, volume 36, pages 12262–12267, 2022. ",
+        "bbox": [
+            181,
+            690,
+            826,
+            911
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            171,
+            36,
+            828,
+            922
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "[24] Subbarao Kambhampati, Karthik Valmeekam, Matthew Marquez, and Lin Guan. On the role of large language models in planning, July 2023. Tutorial presented at the International Conference on Automated Planning and Scheduling (ICAPS), Prague. https://yochan-lab.github. io/tutorial/ICAPS-2023/. ",
+        "bbox": [
+            173,
+            90,
+            828,
+            147
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "[25] George Konidaris, Leslie Pack Kaelbling, and Tomas Lozano-Perez. From skills to symbols: Learning symbolic representations for abstract high-level planning. Journal of Artificial Intelligence Research, 61:215–289, 2018. ",
+        "bbox": [
+            173,
+            156,
+            823,
+            199
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "[26] Kenneth Li, Aspen K Hopkins, David Bau, Fernanda Viégas, Hanspeter Pfister, and Martin Wattenberg. Emergent world representations: Exploring a sequence model trained on a synthetic task. In The Eleventh International Conference on Learning Representations, 2023. ",
+        "bbox": [
+            173,
+            208,
+            825,
+            252
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "[27] Shuang Li, Xavier Puig, Chris Paxton, Yilun Du, Clinton Wang, Linxi Fan, Tao Chen, De-An Huang, Ekin Akyürek, Anima Anandkumar, et al. Pre-trained language models for interactive decision-making. Advances in Neural Information Processing Systems, 35:31199–31212, 2022. ",
+        "bbox": [
+            173,
+            261,
+            825,
+            304
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "[28] Jacky Liang, Wenlong Huang, Fei Xia, Peng Xu, Karol Hausman, Brian Ichter, Pete Florence, and Andy Zeng. Code as policies: Language model programs for embodied control. arXiv preprint arXiv:2209.07753, 2022. ",
+        "bbox": [
+            171,
+            313,
+            825,
+            356
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "[29] Kevin Lin, Christopher Agia, Toki Migimatsu, Marco Pavone, and Jeannette Bohg. Text2motion: From natural language instructions to feasible plans. arXiv preprint arXiv:2303.12153, 2023. ",
+        "bbox": [
+            169,
+            364,
+            825,
+            395
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "[30] Bo Liu, Yuqian Jiang, Xiaohan Zhang, Qiang Liu, Shiqi Zhang, Joydeep Biswas, and Peter Stone. Llm+ p: Empowering large language models with optimal planning proficiency. arXiv preprint arXiv:2304.11477, 2023. ",
+        "bbox": [
+            176,
+            402,
+            823,
+            446
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "[31] Man Luo, Shrinidhi Kumbhar, Mihir Parmar, Neeraj Varshney, Pratyay Banerjee, Somak Aditya, Chitta Baral, et al. Towards logiglue: A brief survey and a benchmark for analyzing logical reasoning capabilities of language models. arXiv preprint arXiv:2310.00836, 2023. ",
+        "bbox": [
+            173,
+            455,
+            823,
+            498
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "[32] Qing Lyu, Shreya Havaldar, Adam Stein, Li Zhang, Delip Rao, Eric Wong, Marianna Apidianaki, and Chris Callison-Burch. Faithful chain-of-thought reasoning. arXiv preprint arXiv:2301.13379, 2023. ",
+        "bbox": [
+            174,
+            507,
+            823,
+            550
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "[33] Drew McDermott, Malik Ghallab, Adele E. Howe, Craig A. Knoblock, Ashwin Ram, Manuela M. Veloso, Daniel S. Weld, and David E. Wilkins. Pddl-the planning domain definition language. 1998. ",
+        "bbox": [
+            174,
+            559,
+            826,
+            602
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "[34] Kolby Nottingham, Prithviraj Ammanabrolu, Alane Suhr, Yejin Choi, Hannaneh Hajishirzi, Sameer Singh, and Roy Fox. Do embodied agents dream of pixelated sheep?: Embodied decision making using language guided world modelling. arXiv preprint arXiv:2301.12050, 2023. ",
+        "bbox": [
+            174,
+            611,
+            826,
+            666
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "[35] Alberto Olmo, Sarath Sreedharan, and Subbarao Kambhampati. Gpt3-to-plan: Extracting plans from text using gpt-3. arXiv preprint arXiv:2106.07131, 2021. ",
+        "bbox": [
+            169,
+            678,
+            825,
+            707
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "[36] OpenAI. Introducing chatgpt by openai, 2022. ",
+        "bbox": [
+            176,
+            715,
+            513,
+            731
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "[37] OpenAI. Gpt-4 technical report, 2023. ",
+        "bbox": [
+            174,
+            739,
+            462,
+            756
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "[38] Vishal Pallagani, Bharath Muppasani, Keerthiram Murugesan, Francesca Rossi, Lior Horesh, Biplav Srivastava, Francesco Fabiano, and Andrea Loreggia. Plansformer: Generating symbolic plans using transformers. arXiv preprint arXiv:2212.08681, 2022. ",
+        "bbox": [
+            171,
+            765,
+            825,
+            808
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "[39] Liangming Pan, Alon Albalak, Xinyi Wang, and William Yang Wang. Logic-lm: Empowering large language models with symbolic solvers for faithful logical reasoning. arXiv preprint arXiv:2305.12295, 2023. ",
+        "bbox": [
+            171,
+            816,
+            825,
+            859
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "[40] Xavier Puig, Kevin Ra, Marko Boben, Jiaman Li, Tingwu Wang, Sanja Fidler, and Antonio Torralba. Virtualhome: Simulating household activities via programs. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pages 8494–8502, 2018. ",
+        "bbox": [
+            174,
+            868,
+            826,
+            912
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "[41] Alec Radford, Jong Wook Kim, Chris Hallacy, Aditya Ramesh, Gabriel Goh, Sandhini Agarwal, Girish Sastry, Amanda Askell, Pamela Mishkin, Jack Clark, et al. Learning transferable visual models from natural language supervision. In International conference on machine learning, pages 8748–8763. PMLR, 2021.   \n[42] Shreyas Sundara Raman, Vanya Cohen, Eric Rosen, Ifrah Idrees, David Paulius, and Stefanie Tellex. Planning with large language models via corrective re-prompting. arXiv preprint arXiv:2211.09935, 2022.   \n[43] Scott Reed, Konrad Zolna, Emilio Parisotto, Sergio Gomez Colmenarejo, Alexander Novikov, Gabriel Barth-Maron, Mai Gimenez, Yury Sulsky, Jackie Kay, Jost Tobias Springenberg, et al. A generalist agent. arXiv preprint arXiv:2205.06175, 2022.   \n[44] Stuart Jonathan Russell. Norvig (2003). Artificial intelligence: a modern approach, 25:26, 2003.   \n[45] Timo Schick, Jane Dwivedi-Yu, Roberto Dessì, Roberta Raileanu, Maria Lomeli, Luke Zettlemoyer, Nicola Cancedda, and Thomas Scialom. Toolformer: Language models can teach themselves to use tools. arXiv preprint arXiv:2302.04761, 2023.   \n[46] Noah Shinn, Beck Labash, and Ashwin Gopinath. Reflexion: an autonomous agent with dynamic memory and self-reflection. arXiv preprint arXiv:2303.11366, 2023.   \n[47] Mohit Shridhar, Xingdi Yuan, Marc-Alexandre Côté, Yonatan Bisk, Adam Trischler, and Matthew Hausknecht. ALFWorld: Aligning Text and Embodied Environments for Interactive Learning. In Proceedings of the International Conference on Learning Representations (ICLR), 2021.   \n[48] Tom Silver, Varun Hariprasad, Reece S Shuttleworth, Nishanth Kumar, Tomás Lozano-Pérez, and Leslie Pack Kaelbling. Pddl planning with pretrained large language models. In NeurIPS 2022 Foundation Models for Decision Making Workshop, 2022.   \n[49] Ron M Simpson, Diane E Kitchin, and Thomas Leo McCluskey. Planning domain definition using gipo. The Knowledge Engineering Review, 22(2):117–134, 2007.   \n[50] Ishika Singh, Valts Blukis, Arsalan Mousavian, Ankit Goyal, Danfei Xu, Jonathan Tremblay, Dieter Fox, Jesse Thomason, and Animesh Garg. Progprompt: Generating situated robot task plans using large language models. arXiv preprint arXiv:2209.11302, 2022.   \n[51] Chan Hee Song, Jiaman Wu, Clayton Washington, Brian M Sadler, Wei-Lun Chao, and Yu Su. Llm-planner: Few-shot grounded planning for embodied agents with large language models. arXiv preprint arXiv:2212.04088, 2022.   \n[52] Sarath Sreedharan, Tathagata Chakraborti, Christian Muise, Yasaman Khazaeni, and Subbarao Kambhampati. –d3wa+–a case study of xaip in a model acquisition task for dialogue planning. In Proceedings of the International Conference on Automated Planning and Scheduling, volume 30, pages 488–497, 2020.   \n[53] Kaya Stechly, Matthew Marquez, and Subbarao Kambhampati. Gpt-4 doesn’t know it’s wrong: An analysis of iterative prompting for reasoning problems. arXiv preprint arXiv:2310.12397, 2023.   \n[54] Karthik Valmeekam, Matthew Marquez, and Subbarao Kambhampati. Can large language models really improve by self-critiquing their own plans? arXiv preprint arXiv:2310.08118, 2023.   \n[55] Karthik Valmeekam, Matthew Marquez, Sarath Sreedharan, and Subbarao Kambhampati. On the planning abilities of large language models–a critical investigation. arXiv preprint arXiv:2305.15771, 2023.   \n[56] Zihao Wang, Shaofei Cai, Anji Liu, Xiaojian Ma, and Yitao Liang. Describe, explain, plan and select: Interactive planning with large language models enables open-world multi-task agents. arXiv preprint arXiv:2302.01560, 2023.   \n[57] Lionel Wong, Gabriel Grand, Alexander K Lew, Noah D Goodman, Vikash K Mansinghka, Jacob Andreas, and Joshua B Tenenbaum. From word models to world models: Translating from natural language to the probabilistic language of thought. arXiv preprint arXiv:2306.12672, 2023.   \n[58] Yaqi Xie, Chen Yu, Tongyao Zhu, Jinbin Bai, Ze Gong, and Harold Soh. Translating natural language to planning goals with large-language models. arXiv preprint arXiv:2302.05128, 2023.   \n[59] Qiang Yang, Kangheng Wu, and Yunfei Jiang. Learning action models from plan examples using weighted max-sat. Artificial Intelligence, 171(2-3):107–143, 2007.   \n[60] Shunyu Yao, Jeffrey Zhao, Dian Yu, Nan Du, Izhak Shafran, Karthik R Narasimhan, and Yuan Cao. React: Synergizing reasoning and acting in language models. In The Eleventh International Conference on Learning Representations, 2023.   \n[61] Hankz Hankui Zhuo, Qiang Yang, Derek Hao Hu, and Lei Li. Learning complex action models with quantifiers and logical implications. Artificial Intelligence, 174(18):1540–1569, 2010.   \n[62] Hankz Hankui Zhuo, Yantian Zha, Subbarao Kambhampati, and Xin Tian. Discovering underlying plans based on shallow models. ACM Transactions on Intelligent Systems and Technology (TIST), 11(2):1–30, 2020. ",
+        "bbox": [
+            169,
+            53,
+            828,
+            916
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            171,
+            90,
+            828,
+            377
+        ],
+        "page_idx": 13
+    }
+]

parse/dev/zeGpMIt6Pfq/zeGpMIt6Pfq.md

@@ -0,0 +1,285 @@
+# BIOLCNET: REWARD-MODULATED LOCALLY CONNECTED SPIKING NEURAL NETWORKS
+
+Anonymous authors Paper under double-blind review
+
+# ABSTRACT
+
+Recent studies have shown that convolutional neural networks (CNNs) are not the only feasible solution for image classification. Furthermore, weight sharing and backpropagation used in CNNs do not correspond to the mechanisms present in the biological visual system. To propose a more biologically plausible solution, we designed a locally connected spiking neural network (SNN) trained using spike-timing-dependent plasticity (STDP) and its reward-modulated variant (R-STDP) learning rules. The use of spiking neurons and local connections along with reinforcement learning (RL) led us to the nomenclature BioLCNet for our proposed architecture. Our network consists of a rate-coded input layer followed by a locally connected hidden layer and a decoding output layer. A spike population-based voting scheme is adopted for decoding in the output layer. We used the MNIST dataset to obtain image classification accuracy and to assess the robustness of our rewarding system to varying target responses.
+
+# 1 INTRODUCTION
+
+For many years, deep convolutional neural network (DCNN) has dominated the field of computer vision and object recognition Goodfellow et al. (2016); LeCun et al. (2015). Although novel methods, such as visual transformers Carion et al. (2020) and very recent MLP-based models Tatsunami & Taki (2021) are threatening its reign, CNN is still the most popular architecture employed for solving visual tasks. However, CNNs lack biological plausibility. First of all, neuron activations in an artificial neural network (ANN) are static real-numbered values, that are modeled by differentiable, non-linear activation functions. This is in contrast to biological neurons that use discrete, and mostly sparse spike trains to transmit information between each other, and in addition to the rate of spikes (spatial encoding), they also use spike timing to encode information temporally Tavanaei et al. (2019). Therefore, a spiking neural network (SNN) is more akin to the neural networks in the brain. Spiking neural networks also require fewer labeled data and operations, which makes them compatible with energy-efficient neuromorphic hardware.
+
+Secondly, the brain is incapable of error backpropagation, as done in traditional ANNs. One issue with error backpropagation in ANNs is the weight transport problem, i.e., the fact that weight connectivity in feedforward and feedback directions is symmetric Liao et al. (2016); Bartunov et al. (2018). Additionally, error feedback propagation that does not affect neural activity is not compliant with the feedback mechanisms that biological neurons use for communication Lillicrap et al. (2020).
+
+Furthermore, although convolutional neural networks has shown great potential in solving any translation-invariant task, its use of weight sharing is biologically problematic. There is no empirical support for explicit weight sharing in the brain Pogodin et al. (2021). However, local connections between neurons is biologically plausible, since neurons in the biological visual system exploit them to have local visual receptive fields Gregor & LeCun (2010). To be compatible with this fact, we also used a locally-connected scheme without explicit weight sharing to design our network. Despite the biological nature of local connections, they mostly underperform convolution-based methods with weight sharing in the visual domain, especially on large-scale datasets Bartunov et al. (2018). This weaker performance may be mainly attributed to the smaller number of parameters and better generalization in CNNs. Fewer parameters in CNNs would also require less memory and computational cost, and would lead to faster training Poggio et al. (2017). Studies are being done to bridge
+
+the performance gap between convolutional and locally-connected networks Lillicrap et al. (2020);   
+Bartunov et al. (2018).
+
+Noting the above considerations, in this paper, we are proposing BioLCNet, a reward-modulated locally-connected spiking neural network. Our network is trained using the unsupervised spiketiming-dependent plasticity and its semi-supervised variant reward-modulated STDP. The input images are encoded proportional to the pixels intensity using Poisson rate-coding that converts intensity to average neuron firing rate in Hertz. In the output layer, there are neuronal groups for each class label, and decision making is based on aggregated number of spikes during the decision period. Our novel dynamic reward prediction error $( R P E )$ mechanism exploits strongly supported empirical findings to improve classification performance. We test the classification capabilities of our network with different sets of hyperparameters on the MNIST dataset LeCun et al. (1999). We also conduct a classical conditioning experiment to prove the effectiveness of our decoding scheme and rewarding mechanisms.
+
+# 2 RELATED WORK
+
+Neuroscientists and deep learning researchers have long been searching for more biologically plausible deep learning approaches in terms of neuronal characteristics, learning rules, and connection types. Regarding neuronal characteristics, researchers have turned to biological neuronal models and spiking neural networks. The vanishing performance gap between deep neural netwroks (DNNs) and SNNs, and the compatibility of SNNs with neuromorphic hardware and online on-chip training Schemmel et al. (2010) has piqued the interest of researchers Mozafari et al. (2019). For comprehensive reviews on deep learning in spiking neural networks, see Tavanaei et al. (2019); Pfeiffer & Pfeil (2018).
+
+Spiking neurons are activated by discrete input spike trains. This differs from artificial neurons used in an ANN that have differentiable activation functions and can easily employ backpropagation and gradient-based optimization. There are works that use gradient-based methods with SNNs Kheradpisheh & Masquelier (2020); Wu et al. (2018); Neftci et al. (2019); Bellec et al. (2020) and some of them have achieved great performances. On the other hand, many works in this area use derivations of the Hebbian learning rule where changes in connection weights depend on the activities of the pre and post-synaptic neurons Hebb (1949). Spike-timing-dependent plasticity (STDP) and its variants, apply asymmetric weight updates based on the temporal activities of neurons. Normal STDP requires an external read-out for classification Mozafari et al. (2018), and have been applied to image reconstruction and classification tasks by many researchers. Some have employed fully-connected architectures Beyeler et al. (2013); Tavanaei & Maida (2015); Allred & Roy (2016), while others used convolutional layers for feature extraction Masquelier & Thorpe (2007); Panda & Roy (2016); Kheradpisheh et al. (2016; 2018). Reward-modulated STDP (R-STDP) uses a reward (or punishment) signal to directly modulate the STDP weight change, and can be used to decode the output without an external cue. Izhikevich (2007) solved the distal reward problem in reinforcement learning by using a version of R-STDP with decaying eligibility traces that gives recent spiking activity more importance. Around the same time, Florian (2007) showed that R-STDP can be employed to solve a simple XOR task with both rate and temporal encoding of the output. Also, Caporale & Dan (2008) used R-STDP to generate specific spiking patterns in the output of their spiking network. Historically, R-STDP was first adopted with temporal (rank-order) encoding for image classification Mozafari et al. (2018). They employed a convolutional architecture based on Masquelier & Thorpe (2007) and a time-to-first-spike decoding scheme. An extended architecture was later developed which had multiple hidden layers Mozafari et al. (2019). The use of R-STDP with Poisson ratecoding has been mostly limited to fully-connected architectures for solving reinforcement learning robot navigation tasks Shim & Li (2017); Bing et al. (2019). To our knowledge, image recognition problems have not yet been addressed by combining R-STDP and rate-based encoding.
+
+The most prevalent architectures used for image classification in deep learning with both DNNs and SNNs are based on convolutional layers and weight sharing. However, there are arguments against the biological plausibility of these approaches Bartunov et al. (2018); Pogodin et al. (2021). Locally connected (LC) networks are an alternative to the convolutional ones. Illing et al. (2019) show that shallow networks with localized connectivity and receptive fields perform much better than fully-connected networks on the MNIST benchmark. However, Bartunov et al. (2018) showed that the lower generalization of LC networks compared to CNNs results in their underperforming CNNs in most image classification tasks, and prevents their scalability to larger datasets such as ImageNet Deng et al. (2009). Very recently, Pogodin et al. (2021) proposed bio-inspired dynamic weight sharing and adding lateral connections to locally-connected layers to achieve the same regularization goals of weight sharing and normal convolutional filters. The first work to integrate a locally-connected (LC) layer into an SNN Saunders et al. (2019) used a network with no hidden layers where the rate-coded input is passed to the output layer via local connections. They exploited recurrent inhibitory connections similar to the ones employed by Diehl & Cook (2015) to simulate a winner-take-all (WTA) inhibition mechanism in their output. Their learning rule is STDP, and therefore an external readout, in this case n-gram voting, is required for classification. Their network scheme was inspiring in designing our locally connected hidden layer.
+
+# 3 THEORY
+
+In this section, we will outline the theoretical foundations underlying our proposed method. Specifically, the dynamics of the spiking neuronal model, the learning rules used, and the connection type employed in our network will be described.
+
+# 3.1 ADAPTIVE LIF NEURON MODEL
+
+The famous leaky and integrate fire neuronal model is governed by the following differential equation Gerstner et al. (2014),
+
+$$
+\tau _ { m } \frac { d u } { d t } = - [ u ( t ) - u _ { r e s t } ] + R I ( t ) ,
+$$
+
+where $u ( t )$ denotes the neuron membrane potential and is a function of time, $R$ is the membrane resistance, $I ( t )$ is any arbitrary input current, and $\tau _ { m }$ is the membrane time constant. Equation (1) dictates that the neuron potential exponentially decays to a constant value $u _ { r e s t }$ over time. When a pre-synaptic neuron fires (spikes), it generates a current that reaches its post-synaptic neurons. In the simple leaky integrate and fire (LIF) model, a neuron fires when its potential surpasses a constant threshold $u _ { t h r }$ . After firing, the neuron’s potential resets to a constant $u _ { r e s e t }$ and will not be affected by any input current for a period of time known as the refractory period $( \Delta t _ { r e f } )$ .
+
+A variant of the LIF model uses adaptive firing thresholds. In this model, $u _ { t h r }$ can change over time based on the neuron’s rate of activity Diehl & Cook (2015). When a neuron fires, its tolerance to the input stimuli and consequently its firing threshold increases by a constant amount, $g _ { 0 }$ , otherwise the threshold decays exponentially with a time constant $\tau _ { g }$ to the default threshold $u _ { t h r _ { 0 } }$ . Equations (2) to (4) explain the dynamics of the adaptive LIF model,
+
+$$
+u _ { t h r } ( t ) = u _ { t h r _ { 0 } } + g ( t ) ,
+$$
+
+where,
+
+$$
+\tau _ { g } d _ { g } / d _ { t } = - g ( t ) ,
+$$
+
+and
+
+$$
+s p i k e \Rightarrow g ( t ) = g ( t - 1 ) + g _ { 0 } ,
+$$
+
+# 3.2 REWARD-MODULATED STDP
+
+Spike-timing-dependent plasticity is a type of biological Hebbian learning rule that is also aligned with human intuition (”Neurons that fire together wire together.” (Lowel & Singer, 1992)). The normal STDP is characterized by two asymmetric update rules. The synaptic weights are updated based on the temporal activities of pre and post-synaptic neurons. When a pre-synaptic neuron fires shortly before its post-synaptic neuron, the causal connection between the first and the second neuron temporal activity is acknowledged, and the connection weight is increased. On the other hand, if the post-synaptic neuron fires shortly after the pre-synaptic neuron, the causality is undermined and the synaptic strength will decrease Hebb (1949). These weight updates, called long-term potentiation (LTP) and long-term depression (LTD), can be performed with asymmetric learning rates to adapt the learning rule to the excitatory to inhibitory neuron ratio or the connection patterns of a specific neural network. A popular variant of STDP that integrates reinforcement learning into the learning mechanism of spiking neural networks is reward-modulated STDP (also known as RSTDP or MSTDP Florian (2007)). In R-STDP, a global reward or punishment signal, which can be a function of time, is generated as the result of the network’s activity or task performance. Using a notation similar to Florian (2007), to mathematically formulate both STDP and R-STDP, we can define the spike train of a pre-synaptic neuron as the sum of Dirac functions over the spikes of the post-synaptic neurons,
+
+$$
+\Phi ( t ) = \sum _ { \mathcal { F } _ { i } } \delta ( t - t _ { i } ^ { f } ) .
+$$
+
+where $t _ { i } ^ { f }$ is the firing time of the $i ^ { t h }$ post-syanptic neuron. Now, we can define the variables $P _ { i j } ^ { + }$ and $P _ { i j } ^ { - }$ to respectively track the influence of pre or post-synaptic spikes on weight updates. Now, the spike trace $\xi$ for a given spike from neuron $i$ to $j$ can be defined as below,
+
+$$
+\xi _ { i j } = P _ { i j } ^ { + } \Phi _ { i } ( t ) + P _ { i j } ^ { - } \Phi _ { j } ( t ) ,
+$$
+
+where: (assuming the same ,
+
+$$
+d P _ { j } ^ { + } / d t = - P _ { j } ^ { + } / \tau _ { + } + \eta _ { p o s t } \Phi _ { j } ( t ) ,
+$$
+
+$$
+d P _ { i } ^ { - } / d t = - P _ { i } ^ { - } / \tau _ { - } - \eta _ { p r e } \Phi _ { i } ( t ) ,
+$$
+
+where we assumed that $P _ { i j } = P _ { j }$ for all pre-synaptic connections related to neuron $j$ , and $P _ { i j } = P _ { i }$ for all post-synaptic connections related to neuron $i$ .
+
+The variables $\tau _ { \pm }$ are the time constants determining the time window in which a spike can affect the weight updates. Using larger time constants will cause spikes that are further apart to also trigger weight updates. The variables $\eta _ { p o s t }$ and $\eta _ { p r e }$ determine the learning rate for LTP and LTD updates respectively. We denote the reward or punishment signal with $r ( t )$ . The R-STDP update rules for positive and negative rewards can be written as,
+
+$$
+\frac { d w _ { i j } ( t ) } { d t } = \gamma r ( t ) \xi _ { i j } ( t ) ,
+$$
+
+where $\gamma$ is a scaling factor. The update rule for normal STDP can also be written as,
+
+$$
+\frac { d w _ { i j } ( t ) } { d t } = \gamma \xi _ { i j } ( t ) .
+$$
+
+Based on Equation (9), we note that R-STDP updates only take effect when a non-zero modulation signal is received at time step $t$ . However, STDP updates do not depend on the modulation signal, and are applied at every time step. In other words, STDP can be considered a special case of RSTDP where the reward function is equal to 1 in every time step. This causes STDP to respond to the most frequent patterns regardless of their desirability.
+
+![](images/7d16d30ca22f5af673ef7c16b44c6d342f983954e53442bb9a7b0d15131bd48b.jpg)  
+Figure 1: Visual comparison of convolutional and local connections for a given filter; in convolutional connections, the weights are shared between all receptive fields. However, in a local connections, each receptive field has its own set of weights.
+
+# 3.3 LOCAL CONNECTIONS
+
+A local connection in a neural network is similar to a convolutional connection but with distinct filters for each receptive field. As seen in Fig. 1, in normal convolutional connections, there is one filter for each channel that is convolved with all receptive fields as it moves along the layer’s input. This filter has one set of weights that are updated using the network’s update rule. However, In local connection (LC), after taking each stride, a new set of parameters characterize a whole new filter for the next receptive field. This type of connectivity between the input and the LC layer resembles the physical structure of retinal Ganglion cells. Because there are more filters in an LC, the number of distinct synapses in a local connection is greater than a convolutional connection, yet much lower than a dense connection. Similar to a convolutional connection, assuming square filters, and equal horizontal and vertical strides, we can specify a local connection by the number of channels (filters) $( c h _ { l c } )$ , the kernel size $( k )$ , and the stride (s).
+
+# 4 ARCHITECTURE AND METHODS
+
+BioLCNet consists of an input layer, a locally connected hidden layer, and a decoding layer. Each layer structure and its properties alongside the training and rewarding procedure will be delineated in this section. A graphical representation of our network is presented in Fig. 2. The simulation time $T$ is divided into three phases, adaptation period $( T _ { a d a p t } )$ , decision period $( T _ { d e c } )$ , and learning period $( T _ { l e a r n } )$ . The details of each phase will be specified in the remainder of this section.
+
+![](images/5fdf75263ec24542831806da2a28750016c3f859a907223b028482ab6ed6b1c4.jpg)  
+Figure 2: Graphical representation of the proposed network; locally connected filters will be applied to the rate-coded input image. Based on a winner-take-all inhibition mechanism, the most relevant features from each receptive field transmit their spikes to the decoding layer, which selects the most active neuronal group as the predicted label exploiting lateral inhibitory connections. The red lines indicate inhibitory connections.
+
+# 4.1 ENCODING LAYER
+
+The input of the network is an image of dimensions $( c h _ { i n } , h _ { i n } , w _ { i n } )$ . For a grayscale image dataset such as MNIST, $c h _ { i n }$ equals to one. Each input channel is rate-coded using a Poisson encoding scheme, i.e, the spiking neuron corresponding to each pixel has an average firing rate proportional to the intensity of that pixel. By choosing the maximum firing rate $f _ { m a x }$ , the spike trains average firing rates will be distributed in the interval $[ 0 , f _ { m a x } ]$ Hertz based on the pixel values.
+
+# 4.2 FEATURE EXTRACTION LAYER (LOCAL CONNECTIONS)
+
+The encoded input at each simulation time step passes through local connections with $c h _ { o u t }$ distinct filters for each receptive field. Therefore, the output of this layer will have dimensions $( c h _ { o u t }$ , $h _ { o u t }$ , $w _ { o u t , }$ ), where the output size depends on the size of the kernel and the stride. There are generally two approaches in the SNN literature for training a feature extraction layer with rate-coded inputs using STDP to attain a rich feature representation and also prevent the weights from growing too large. One is allowing the weights to have negative values, which corresponds to having inhibitory neurons, as done in the convolutional layers used by Lee et al. (2018). The other is to use a combination of recurrent inhibitory connections and adaptive thresholds as done by Diehl & Cook (2015); Saunders et al. (2018; 2019). In this work, we used the latter approach for our feature extraction LC layer. We use adaptive LIF neurons and inhibitory connections between neurons that share the same receptive field. This is equivalent to the winner-take-all inhibition mechanism which causes a competition between neurons to select the most relevant features. The inhibitory connections are non-plastic and they all have a static negative weight $w _ { i n h }$ with a large absolute value.
+
+In normal STDP, the LTP learning rate $( \eta _ { p o s t } )$ is usually chosen larger than the LTD rate $( \eta _ { p r e } )$ to suppress the random firing of neurons that triggers many LTD updates during the early stages of training. However, this may become problematic in the later stages, and the weights may grow too large. Therefore, in practice, different mechanisms, such as weight clipping and normalization are used to prevent the weights running amok. In this work, we clipped the weights to stay in the range $[ 0 , 1 ]$ . We also employed the normalization technique used by Saunders et al. (2019) and normalized the pre-synaptic weights of each neuron in the LC layer to have a constant mean of $c _ { n o r m }$ at the end of each time step.
+
+# 4.3 DECODING LAYER AND REWARDING MECHANISMS
+
+The final layer of our network is a fully connected layer for reward-based decoding. The layer is divided into $n _ { c }$ neuronal groups where $n _ { c }$ is the number of classes related to the task. Consequently, the $n _ { o u t }$ neurons in this layer are divided equally into $n _ { c }$ neuronal groups. The predicted label for a given test sample is the class whose group has the most number of spikes aggregated over the decision period $( T _ { d e c } )$ . This decoding layer is trained using reinforcement learning and R-STDP during the learning period $( T _ { l e a r n } )$ based on the modulation signal generated by the rewarding mechanism. We designed two different rewarding mechanisms, static and dynamic reward prediction error (RPE). In the static mechanism, we use a fixed reward or punishment signal for the whole learning period $( T _ { l e a r n } )$ based on the prediction of the network for the $i ^ { t h }$ training sample,
+
+$$
+r _ { i } = \left\{ \begin{array} { c } { { 1 : \ p r e d i c t e d l a b e l = t a r g e t l a b e l } } \\ { { - 1 : \qquad o t h e r w i s e } } \end{array} \right.
+$$
+
+The second mechanism, dynamic $R P E$ is based on the reward prediction error theory in reinforcement learning. According to this theory, the dopaminergic neurons in the brain release dopamine proportional to the difference between the actual reward and the expected reward (not solely based on the actual reward) Schultz et al. (1997); Sutton & Barto (2018). We formulate our dynamic RPE mechanism as below,
+
+$$
+R _ { i } = R _ { i - 1 } - \eta _ { r p e } ( r _ { i } - \mathrm { E M A } _ { R } )
+$$
+
+where $R _ { i }$ is the scalar R-STDP modulation signal used during the whole learning period $( T _ { l e a r n } )$ of the $i ^ { t h }$ training sample, $r _ { i }$ is the reward signal received based on the prediction, and ${ \mathrm { E M A } _ { R } }$ is the exponential moving average of the modulation signals with a smoothing factor $\alpha$ .
+
+# 4.4 TRAINING PROCEDURE
+
+The network is trained in a layer-wise fashion. After initializing the weights uniformly between $[ 0 , 1 ]$ , we train the feature extraction LC layer in a completely unsupervised manner using STDP. Simulation time for training the feature extraction layer is $T _ { l e a r n }$ time steps. After this layer is trained, the weights are freezed, and we train the decoding FC layer in a semi-supervised manner using R-STDP and the selected rewarding mechanism. Training this layer requires all three simulation phases. The input image is first presented to the network for $T _ { a d a p t }$ time steps to let the LC layer neurons adapt to the input image and select its relevant features. During $T _ { d e c }$ time steps, the decoding layer accumulates the number of spikes received by each neuronal group to determine the predicted label. Afterwards, the modulation signal is generated and the decoding layer weights are updated using R-STDP for $T _ { l e a r n }$ time steps.
+
+When training the LC layer, we observed that after a specific number of iterations (training samples), the weights of this layer converge and remain constant. Fig. 3a visualizes the filters learned after 2000 iterations for 100 filters of size 15 with a stride of 4 applied to the input images. This fast convergence is an evidence showing the strength of STDP learning. Considering these observations, and to save computation time, we limit the number of training sample of the LC layer to 2000 for all of the hyperparameter configurations. Given an input image (Fig. 3b), we can plot the activation map of the LC layer (Fig. 3c). This map shows the post-synaptic neurons corresponding to the relevant features activate, and suppress the other neurons in accordance with the WTA inhibition mechanism.
+
+The network is implemented using PyTorch Paszke et al. (2019), and mostly on top of the BindsNet framework Hazan et al. (2018) to make our code more efficient. We reimplemented the local connection topology to make it compatible with multi-channel inputs and a possible deep extension of our network.
+
+![](images/0decd3b3924b810633377d52c352a922683153280606c399e810843c871f63b8.jpg)  
+Figure 3: Input and LC layer visualizations. (a) LC layer learned filters; the red lines separate filters corresponding to each receptive field. (b) A sample input image. (c) The LC layer activation map corresponding to the sample input image shown.
+
+Table 1: BioLCNet (hyper-)parameters; best-performing value for (hyper-)parameters subject to grid search are in bold.   
+
+<table><tr><td rowspan=1 colspan=1>Parameter</td><td rowspan=1 colspan=1>Value</td></tr><tr><td rowspan=1 colspan=1>Uthro</td><td rowspan=1 colspan=1>-52 (mV)</td></tr><tr><td rowspan=1 colspan=1>Urest,Ureset</td><td rowspan=1 colspan=1>-65 (mV)</td></tr><tr><td rowspan=1 colspan=1>go</td><td rowspan=1 colspan=1>0.05 (mV)</td></tr><tr><td rowspan=1 colspan=1>Tg</td><td rowspan=1 colspan=1>10 (ms)</td></tr><tr><td rowspan=1 colspan=1>△tref</td><td rowspan=1 colspan=1>5(ms)</td></tr><tr><td rowspan=1 colspan=1>Tm</td><td rowspan=1 colspan=1>20(ms)</td></tr><tr><td rowspan=1 colspan=1>fmax</td><td rowspan=1 colspan=1>128(Hz)</td></tr><tr><td rowspan=1 colspan=1>hin，Win</td><td rowspan=1 colspan=1>22</td></tr><tr><td rowspan=1 colspan=1>nout</td><td rowspan=1 colspan=1>[100,500,1000]</td></tr><tr><td rowspan=1 colspan=1>chlc</td><td rowspan=1 colspan=1>[25,50,100,250]</td></tr><tr><td rowspan=1 colspan=1>k</td><td rowspan=1 colspan=1>[11,13, 15,17]</td></tr><tr><td rowspan=1 colspan=1>S</td><td rowspan=1 colspan=1>[2, 3,4]</td></tr><tr><td rowspan=1 colspan=1>Tadapt,Tdec,Tlearn</td><td rowspan=1 colspan=1>256 (ms)</td></tr><tr><td rowspan=1 colspan=1>(Npre,Npost)STDP</td><td rowspan=1 colspan=1>(0.0001,0.01)</td></tr><tr><td rowspan=1 colspan=1>(npre,post)R-STDP</td><td rowspan=1 colspan=1>(0.1,0.1)</td></tr><tr><td rowspan=1 colspan=1>2</td><td rowspan=1 colspan=1>1</td></tr><tr><td rowspan=1 colspan=1>nrpe</td><td rowspan=1 colspan=1>[(static),0.075,0.125,0.175,0.25]</td></tr><tr><td rowspan=1 colspan=1>a</td><td rowspan=1 colspan=1>0.9</td></tr><tr><td rowspan=1 colspan=1>Winh</td><td rowspan=1 colspan=1>-100</td></tr><tr><td rowspan=1 colspan=1>Cnorm</td><td rowspan=1 colspan=1>0.25</td></tr></table>
+
+# 5 EXPERIMENTS AND DISCUSSION
+
+# 5.1 IMAGE CLASSIFICATION
+
+To evaluate our network’s classification performance, we trained our model on the MNIST benchmark. Some of the hyperparameters were fixed and others were subject to grid search. The full list of hyperparameters are given in Table 1.
+
+Considering the hyperparameters mentioned in Table 1, we report in Table 2, the classification accuracy on the whole MNIST test set (10000 samples) for four hyperparameter configurations chosen based on the highest test accuracy obtained after conducting a grid search. The number of neurons and synapses for each model are also reported in this table. The final models were all trained using 10000 training samples from the MNIST training set. Using more training samples did not improve the classification performance as can be observed from Fig. 4. The mean and standard deviations reported are estimated from ten independent runs. In addition to the RL-based models, another classification approach was employed. In this approach, for each training sample, we create a feature vector containing the number of spikes aggregated over $T _ { l e a r n }$ time steps for every filter in the LC layer. We use these feature vectors to train a support vector machine (SVM) classifier. The SVM results are also obtained by training on 10000 training samples, and testing on the whole MNIST test set. The SVM test results for two different hyperparameter configurations are reported in Table 2 and are compared to the RL-based results. The best performance of SVM and RL-based classification are 87.50, and 76.40 respectively. Table3 compares the MNIST test performance obtained by different SNN approaches along with the bio-plausibility criteria to which they adhere.
+
+Table 2: MNIST test dataset accuracies obtained by four different sets of hyper-parameters; the test accuracies are averaged over ten independent runs   
+
+<table><tr><td rowspan=1 colspan=1>Parameters[k,s,nrpe,nout]</td><td rowspan=1 colspan=1>nneurons</td><td rowspan=1 colspan=1>nsynapses</td><td rowspan=1 colspan=1>Test accuracy</td><td rowspan=1 colspan=1>SVM test accuracy</td></tr><tr><td rowspan=1 colspan=1>[13,3,0.025,100]</td><td rowspan=1 colspan=1>1700</td><td rowspan=1 colspan=1>430400</td><td rowspan=1 colspan=1>61.30 ±3.14</td><td rowspan=1 colspan=1>87.5±1.32</td></tr><tr><td rowspan=1 colspan=1>[15,4,0.175,1000]</td><td rowspan=1 colspan=1>1884</td><td rowspan=1 colspan=1>490000</td><td rowspan=1 colspan=1>75.00 ±2.68</td><td rowspan=1 colspan=1>83.3±1.74</td></tr><tr><td rowspan=1 colspan=1>[15,4,0.125,1000]</td><td rowspan=1 colspan=1>1884</td><td rowspan=1 colspan=1>490000</td><td rowspan=1 colspan=1>76.40 ±2.43</td><td rowspan=1 colspan=1>83.3±1.74</td></tr><tr><td rowspan=1 colspan=1>[15,4,(static),100]</td><td rowspan=1 colspan=1>984</td><td rowspan=1 colspan=1>130000</td><td rowspan=1 colspan=1>68.8±2.87</td><td rowspan=1 colspan=1>83.3±1.74</td></tr></table>
+
+Table 3: MNIST test dataset accuracies obtained by different SNN approaches   
+
+<table><tr><td rowspan=1 colspan=1>Paper</td><td rowspan=1 colspan=1>Encoding</td><td rowspan=1 colspan=1>Architecture</td><td rowspan=1 colspan=1>Bio-plausibility criteria</td><td rowspan=1 colspan=1>Acc.</td></tr><tr><td rowspan=1 colspan=1>BioLCNet (proposed, RL)</td><td rowspan=1 colspan=1>rate-based</td><td rowspan=1 colspan=1>Locally connected+Dense</td><td rowspan=1 colspan=1>STDP, RL, LC</td><td rowspan=1 colspan=1>76.40</td></tr><tr><td rowspan=1 colspan=1>BioLCNet (proposed,SVM)</td><td rowspan=1 colspan=1>rate-based</td><td rowspan=1 colspan=1>Locally connected</td><td rowspan=1 colspan=1>STDP, LC</td><td rowspan=1 colspan=1>87.5</td></tr><tr><td rowspan=1 colspan=1>Beyeler et al. (2013)</td><td rowspan=1 colspan=1>rate-based</td><td rowspan=1 colspan=1>Dense</td><td rowspan=1 colspan=1>STDP</td><td rowspan=1 colspan=1>91.60</td></tr><tr><td rowspan=1 colspan=1>Diehl&amp; Cook (2015)</td><td rowspan=1 colspan=1>rate-based</td><td rowspan=1 colspan=1>Dense</td><td rowspan=1 colspan=1>STDP</td><td rowspan=1 colspan=1>95.00</td></tr><tr><td rowspan=1 colspan=1>Tavanaei &amp;Maida (2015)</td><td rowspan=1 colspan=1>rate-based</td><td rowspan=1 colspan=1>Dense</td><td rowspan=1 colspan=1>STDP</td><td rowspan=1 colspan=1>75.93</td></tr><tr><td rowspan=1 colspan=1>Allred &amp; Roy (2016)</td><td rowspan=1 colspan=1>rate-based</td><td rowspan=1 colspan=1>Dense</td><td rowspan=1 colspan=1>STDP</td><td rowspan=1 colspan=1>86.59</td></tr><tr><td rowspan=1 colspan=1>Kheradpisheh et al. (2018)</td><td rowspan=1 colspan=1>rank-order</td><td rowspan=1 colspan=1>Convolutional</td><td rowspan=1 colspan=1>STDP</td><td rowspan=1 colspan=1>98.40</td></tr><tr><td rowspan=1 colspan=1>Saunders et al. (2018)</td><td rowspan=1 colspan=1>rate-based</td><td rowspan=1 colspan=1>Convolutional</td><td rowspan=1 colspan=1>STDP</td><td rowspan=1 colspan=1>84.23</td></tr><tr><td rowspan=1 colspan=1>Lee et al. (2018)</td><td rowspan=1 colspan=1>rate-based</td><td rowspan=1 colspan=1>Convolutional</td><td rowspan=1 colspan=1>STDP</td><td rowspan=1 colspan=1>91.1</td></tr><tr><td rowspan=1 colspan=1>Mozafari et al. (2019)</td><td rowspan=1 colspan=1>rank-order</td><td rowspan=1 colspan=1>Convolutional</td><td rowspan=1 colspan=1>STDP, RL</td><td rowspan=1 colspan=1>97.2</td></tr><tr><td rowspan=1 colspan=1>Saunders et al. (2019)</td><td rowspan=1 colspan=1>rate-based</td><td rowspan=1 colspan=1>Locally connected</td><td rowspan=1 colspan=1>STDP, LC</td><td rowspan=1 colspan=1>95.07</td></tr></table>
+
+![](images/482e4a9d69fa8e69ad9b163d17afcb7732c0bce5812040cd207c4efe158cd3d5.jpg)  
+Figure 4: Smoothed running accuracy over the training set for four sets of hyperparameters using the R-STDP classifier
+
+Overall, the supervised SVM has achieved a better performance than the R-STDP method. Two important observations can be made from Table 2. First, the classification accuracy has a positive correlation with the filter size, and the number of neurons in the decoding layer. Secondly, the dynamic RPE mechanism improved the classification performance compared to the default static rewarding mechanism. dynamic RPE plays a similar role to the adaptive learning rate method employed by Mozafari et al. (2018), yet with more biological roots and empirical support.
+
+# 5.2 CLASSICAL CONDITIONING
+
+In order to show the effectiveness of our rewarding mechanism, we perform a classical (Pavlovian) conditioning experiment. This type of conditioning pairs up a neutral stimulus with an automatic conditioned response by the agent. In this experiment, we present the network with images belonging to one class of the MNIST dataset as the neutral stimuli. We used the pre-trained feature extraction layer of the network with 25 filters of size 13 and stride of 3, following by a decoding layer with 20 neurons for a two-class prediction task. In the first half of the experiment (task 1), the target response is class 1, and the network receives a constant reward of 1 if it predicts this class regardless of the input. A punishment signal of -1 is received if the agent predicts class 0. We monitor the rate of the reward and punishment received during the experiment. After the convergence in about 50 iterations, Fig. 5 shows that the agent has become completely conditioned on the rewarding response. After 200 iterations, we swap the rewarding and punishing classes, and continue running the network. In task 2, the network should predict the input images as class 0. The RL agent (the network) adapts to the change notably fast, and completely changes its behavior after about 100 iterations. The heat maps in Fig. 5 visualize the weights of the output layer through the training.
+
+![](images/8f859c87f1c13d06b557b110e4326581592fd1b4ea20647586d4c42985854d66.jpg)  
+Figure 5: Classical conditioning experiment; in this experiment, we tested the adaptability of the network to varying target responses. The plot shows the rate of receiving reward and punishment averaged over 20 runs, and the decoding layer weight maps at iterations 0, 200, 300, 400, and 600. The right side of the weight maps correspond to the task 1 target response neurons, and the left side corresponds to the task 2 target response neurons. The weights adapt to the varying target response during the experiment.
+
+The reward adaptability of an RL agent is critical because in many real-world problems the environment is non-stationary. Integration of reward adaptation into spiking neural networks, as done in this work, can pave the path for models that simulate human behaviour with the same spike-based computation as done in the human brain.
+
+# 6 CONCLUSIONS AND FUTURE WORK
+
+In this work, we examined the capabilities of a neural network with three-fold biological plausibility; spiking neurons, local visual receptive fields, and a reward-modulated learning rule. The R-STDP learning rule has been only used for sequential decision making or temporal-coded visual tasks. As the first work to employ R-STDP in locally connected SNNs, we did not expect to achieve state-of-the-art performance. However, we hope that using the novel dynamic RPE rewarding mechanism alongside the emerging local connection scheme will make the future prospects of biological learning rules and architectures in solving real-world problems, more promising.
+
+In the future, by bringing ideas such as dynamic weight sharing and lateral connections Pogodin et al. (2021) to spiking neural networks, we may be able to obtain richer feature representations using locally connected SNNs. We can also exploit the recent advances in SNN minibatch processing Saunders et al. (2020) and neuromorphic hardware Schemmel et al. (2010) to extend our network with deeper architectures and solve more complex tasks.
+
+# REFERENCES
+
+Jason M Allred and Kaushik Roy. Unsupervised incremental stdp learning using forced firing of dormant or idle neurons. In 2016 International Joint Conference on Neural Networks (IJCNN), pp. 2492–2499. IEEE, 2016.
+
+Sergey Bartunov, Adam Santoro, Blake Richards, Luke Marris, Geoffrey E Hinton, and Timothy Lillicrap. Assessing the scalability of biologically-motivated deep learning algorithms and architectures. In S. Bengio, H. Wallach, H. Larochelle, K. Grauman, N. Cesa-Bianchi, and R. Garnett (eds.), Advances in Neural Information Processing Systems, volume 31. Curran Associates, Inc., 2018. URL https://proceedings.neurips.cc/paper/2018/file/ 63c3ddcc7b23daa1e42dc41f9a44a873-Paper.pdf.
+
+Guillaume Bellec, Franz Scherr, Anand Subramoney, Elias Hajek, Darjan Salaj, Robert Legenstein, and Wolfgang Maass. A solution to the learning dilemma for recurrent networks of spiking neurons. Nature communications, 11(1):1–15, 2020.
+
+Michael Beyeler, Nikil D Dutt, and Jeffrey L Krichmar. Categorization and decision-making in a neurobiologically plausible spiking network using a stdp-like learning rule. Neural Networks, 48: 109–124, 2013.
+
+Zhenshan Bing, Zhuangyi Jiang, Long Cheng, Caixia Cai, Kai Huang, and Alois Knoll. End to end learning of a multi-layered snn based on r-stdp for a target tracking snake-like robot. In 2019 International Conference on Robotics and Automation (ICRA), pp. 9645–9651. IEEE, 2019.
+
+Natalia Caporale and Yang Dan. Spike timing–dependent plasticity: a hebbian learning rule. Annu. Rev. Neurosci., 31:25–46, 2008.
+
+Nicolas Carion, Francisco Massa, Gabriel Synnaeve, Nicolas Usunier, Alexander Kirillov, and Sergey Zagoruyko. End-to-end object detection with transformers. In European Conference on Computer Vision, pp. 213–229. Springer, 2020.
+
+Jia Deng, Wei Dong, Richard Socher, Li-Jia Li, Kai Li, and Li Fei-Fei. Imagenet: A large-scale hierarchical image database. In 2009 IEEE Conference on Computer Vision and Pattern Recognition, pp. 248–255, 2009. doi: 10.1109/CVPR.2009.5206848.
+
+Peter U Diehl and Matthew Cook. Unsupervised learning of digit recognition using spike-timingdependent plasticity. Frontiers in computational neuroscience, 9:99, 2015.
+
+Razvan V Florian. Reinforcement learning through modulation of spike-timing-dependent synaptic ˘ plasticity. Neural computation, 19(6):1468–1502, 2007.
+
+Wulfram Gerstner, Werner M Kistler, Richard Naud, and Liam Paninski. Neuronal dynamics: From single neurons to networks and models of cognition. Cambridge University Press, 2014.
+
+Ian Goodfellow, Yoshua Bengio, and Aaron Courville. Deep Learning. MIT Press, 2016. http: //www.deeplearningbook.org.
+
+Karo Gregor and Yann LeCun. Emergence of complex-like cells in a temporal product network with local receptive fields, 2010.
+
+Hananel Hazan, Daniel J Saunders, Hassaan Khan, Devdhar Patel, Darpan T Sanghavi, Hava T Siegelmann, and Robert Kozma. Bindsnet: A machine learning-oriented spiking neural networks library in python. Frontiers in neuroinformatics, 12:89, 2018.
+
+Donald Olding Hebb. The organisation of behaviour: a neuropsychological theory. Science Editions New York, 1949.
+
+Bernd Illing, Wulfram Gerstner, and Johanni Brea. Biologically plausible deep learning—but how far can we go with shallow networks? Neural Networks, 118:90–101, 2019.
+
+Eugene M Izhikevich. Solving the distal reward problem through linkage of stdp and dopamine signaling. Cerebral cortex, 17(10):2443–2452, 2007.
+
+Saeed Reza Kheradpisheh and Timothee Masquelier. Temporal backpropagation for spiking neural ´ networks with one spike per neuron. International Journal of Neural Systems, 30(06):2050027, 2020.
+
+Saeed Reza Kheradpisheh, Mohammad Ganjtabesh, and Timothee Masquelier. Bio-inspired unsu- ´ pervised learning of visual features leads to robust invariant object recognition. Neurocomputing, 205:382–392, 2016.
+
+Saeed Reza Kheradpisheh, Mohammad Ganjtabesh, Simon J Thorpe, and Timothee Masquelier. ´ Stdp-based spiking deep convolutional neural networks for object recognition. Neural Networks, 99:56–67, 2018.
+
+Y LeCun, C Cortes, and C Burges. The mnist dataset of handwritten digits (images). NYU: New York, NY, USA, 1999.
+
+Yann LeCun, Yoshua Bengio, and Geoffrey Hinton. Deep learning. nature, 521(7553):436–444, 2015.
+
+Chankyu Lee, Gopalakrishnan Srinivasan, Priyadarshini Panda, and Kaushik Roy. Deep spiking convolutional neural network trained with unsupervised spike-timing-dependent plasticity. IEEE Transactions on Cognitive and Developmental Systems, 11(3):384–394, 2018.
+
+Qianli Liao, Joel Leibo, and Tomaso Poggio. How important is weight symmetry in backpropagation? In Proceedings of the AAAI Conference on Artificial Intelligence, volume 30, 2016.
+
+Timothy P Lillicrap, Adam Santoro, Luke Marris, Colin J Akerman, and Geoffrey Hinton. Backpropagation and the brain. Nature Reviews Neuroscience, 21(6):335–346, 2020.
+
+Siegrid Lowel and Wolf Singer. Selection of intrinsic horizontal connections in the visual cortex by correlated neuronal activity. Science, 255(5041):209–212, 1992.
+
+Timothee Masquelier and Simon J Thorpe. Unsupervised learning of visual features through spike´ timing dependent plasticity. PLoS computational biology, 3(2):e31, 2007.
+
+Milad Mozafari, Saeed Reza Kheradpisheh, Timothee Masquelier, Abbas Nowzari-Dalini, and Mo- ´ hammad Ganjtabesh. First-spike-based visual categorization using reward-modulated stdp. IEEE transactions on neural networks and learning systems, 29(12):6178–6190, 2018.
+
+Milad Mozafari, Mohammad Ganjtabesh, Abbas Nowzari-Dalini, Simon J Thorpe, and Timothee´ Masquelier. Bio-inspired digit recognition using reward-modulated spike-timing-dependent plasticity in deep convolutional networks. Pattern recognition, 94:87–95, 2019.
+
+Emre O Neftci, Hesham Mostafa, and Friedemann Zenke. Surrogate gradient learning in spiking neural networks: Bringing the power of gradient-based optimization to spiking neural networks. IEEE Signal Processing Magazine, 36(6):51–63, 2019.
+
+Priyadarshini Panda and Kaushik Roy. Unsupervised regenerative learning of hierarchical features in spiking deep networks for object recognition. In 2016 International Joint Conference on Neural Networks (IJCNN), pp. 299–306. IEEE, 2016.
+
+Adam Paszke, Sam Gross, Francisco Massa, Adam Lerer, James Bradbury, Gregory Chanan, Trevor Killeen, Zeming Lin, Natalia Gimelshein, Luca Antiga, Alban Desmaison, Andreas Kopf, Edward Yang, Zachary DeVito, Martin Raison, Alykhan Tejani, Sasank Chilamkurthy, Benoit Steiner, Lu Fang, Junjie Bai, and Soumith Chintala. Pytorch: An imperative style, high-performance deep learning library. In H. Wallach, H. Larochelle, A. Beygelzimer, F. d'Alche-Buc, ´ E. Fox, and R. Garnett (eds.), Advances in Neural Information Processing Systems 32, pp. 8024–8035. Curran Associates, Inc., 2019. URL http://papers.neurips.cc/paper/ 9015-pytorch-an-imperative-style-high-performance-deep-learning-library. pdf.
+
+Michael Pfeiffer and Thomas Pfeil. Deep learning with spiking neurons: opportunities and challenges. Frontiers in neuroscience, 12:774, 2018.
+
+Tomaso Poggio, Hrushikesh Mhaskar, Lorenzo Rosasco, Brando Miranda, and Qianli Liao. Why and when can deep-but not shallow-networks avoid the curse of dimensionality: a review. International Journal of Automation and Computing, 14(5):503–519, 2017.
+
+Roman Pogodin, Yash Mehta, Timothy P. Lillicrap, and Peter E. Latham. Towards biologically plausible convolutional networks, 2021.
+
+Daniel J Saunders, Hava T Siegelmann, Robert Kozma, et al. Stdp learning of image patches with convolutional spiking neural networks. In 2018 international joint conference on neural networks (IJCNN), pp. 1–7. IEEE, 2018.
+
+Daniel J Saunders, Devdhar Patel, Hananel Hazan, Hava T Siegelmann, and Robert Kozma. Locally connected spiking neural networks for unsupervised feature learning. Neural Networks, 119: 332–340, 2019.
+
+Daniel J Saunders, Cooper Sigrist, Kenneth Chaney, Robert Kozma, and Hava T Siegelmann. Minibatch processing for speed-up and scalability of spiking neural network simulation. In 2020 International Joint Conference on Neural Networks (IJCNN), pp. 1–8. IEEE, 2020.
+
+Johannes Schemmel, Daniel Bruderle, Andreas Gr ¨ ubl, Matthias Hock, Karlheinz Meier, and Se- ¨ bastian Millner. A wafer-scale neuromorphic hardware system for large-scale neural modeling. In 2010 IEEE International Symposium on Circuits and Systems (ISCAS), pp. 1947–1950. IEEE, 2010.
+
+Wolfram Schultz, Peter Dayan, and P Read Montague. A neural substrate of prediction and reward. Science, 275(5306):1593–1599, 1997.
+
+Myung Seok Shim and Peng Li. Biologically inspired reinforcement learning for mobile robot collision avoidance. In 2017 International Joint Conference on Neural Networks (IJCNN), pp. 3098–3105. IEEE, 2017.
+
+Richard S Sutton and Andrew G Barto. Reinforcement learning: An introduction. MIT press, 2018.
+
+Yuki Tatsunami and Masato Taki. Raftmlp: Do mlp-based models dream of winning over computer vision? arXiv preprint arXiv:2108.04384, 2021.
+
+Amirhossein Tavanaei and Anthony S Maida. A minimal spiking neural network to rapidly train and classify handwritten digits in binary and 10-digit tasks. International journal of advanced research in artificial intelligence, 4(7):1–8, 2015.
+
+Amirhossein Tavanaei, Masoud Ghodrati, Saeed Reza Kheradpisheh, Timothee Masquelier, and ´ Anthony Maida. Deep learning in spiking neural networks. Neural Networks, 111:47–63, 2019.
+
+Yujie Wu, Lei Deng, Guoqi Li, Jun Zhu, and Luping Shi. Spatio-temporal backpropagation for training high-performance spiking neural networks. Frontiers in neuroscience, 12:331, 2018.

parse/dev/zeGpMIt6Pfq/zeGpMIt6Pfq_content_list.json

@@ -0,0 +1,1520 @@
+[
+    {
+        "type": "text",
+        "text": "BIOLCNET: REWARD-MODULATED LOCALLY CONNECTED SPIKING NEURAL NETWORKS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            98,
+            821,
+            146
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Anonymous authors Paper under double-blind review ",
+        "bbox": [
+            183,
+            171,
+            398,
+            198
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "ABSTRACT ",
+        "text_level": 1,
+        "bbox": [
+            454,
+            234,
+            544,
+            251
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Recent studies have shown that convolutional neural networks (CNNs) are not the only feasible solution for image classification. Furthermore, weight sharing and backpropagation used in CNNs do not correspond to the mechanisms present in the biological visual system. To propose a more biologically plausible solution, we designed a locally connected spiking neural network (SNN) trained using spike-timing-dependent plasticity (STDP) and its reward-modulated variant (R-STDP) learning rules. The use of spiking neurons and local connections along with reinforcement learning (RL) led us to the nomenclature BioLCNet for our proposed architecture. Our network consists of a rate-coded input layer followed by a locally connected hidden layer and a decoding output layer. A spike population-based voting scheme is adopted for decoding in the output layer. We used the MNIST dataset to obtain image classification accuracy and to assess the robustness of our rewarding system to varying target responses. ",
+        "bbox": [
+            233,
+            270,
+            764,
+            450
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 INTRODUCTION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            486,
+            334,
+            502
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "For many years, deep convolutional neural network (DCNN) has dominated the field of computer vision and object recognition Goodfellow et al. (2016); LeCun et al. (2015). Although novel methods, such as visual transformers Carion et al. (2020) and very recent MLP-based models Tatsunami & Taki (2021) are threatening its reign, CNN is still the most popular architecture employed for solving visual tasks. However, CNNs lack biological plausibility. First of all, neuron activations in an artificial neural network (ANN) are static real-numbered values, that are modeled by differentiable, non-linear activation functions. This is in contrast to biological neurons that use discrete, and mostly sparse spike trains to transmit information between each other, and in addition to the rate of spikes (spatial encoding), they also use spike timing to encode information temporally Tavanaei et al. (2019). Therefore, a spiking neural network (SNN) is more akin to the neural networks in the brain. Spiking neural networks also require fewer labeled data and operations, which makes them compatible with energy-efficient neuromorphic hardware. ",
+        "bbox": [
+            174,
+            520,
+            825,
+            686
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Secondly, the brain is incapable of error backpropagation, as done in traditional ANNs. One issue with error backpropagation in ANNs is the weight transport problem, i.e., the fact that weight connectivity in feedforward and feedback directions is symmetric Liao et al. (2016); Bartunov et al. (2018). Additionally, error feedback propagation that does not affect neural activity is not compliant with the feedback mechanisms that biological neurons use for communication Lillicrap et al. (2020). ",
+        "bbox": [
+            176,
+            694,
+            823,
+            763
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Furthermore, although convolutional neural networks has shown great potential in solving any translation-invariant task, its use of weight sharing is biologically problematic. There is no empirical support for explicit weight sharing in the brain Pogodin et al. (2021). However, local connections between neurons is biologically plausible, since neurons in the biological visual system exploit them to have local visual receptive fields Gregor & LeCun (2010). To be compatible with this fact, we also used a locally-connected scheme without explicit weight sharing to design our network. Despite the biological nature of local connections, they mostly underperform convolution-based methods with weight sharing in the visual domain, especially on large-scale datasets Bartunov et al. (2018). This weaker performance may be mainly attributed to the smaller number of parameters and better generalization in CNNs. Fewer parameters in CNNs would also require less memory and computational cost, and would lead to faster training Poggio et al. (2017). Studies are being done to bridge ",
+        "bbox": [
+            174,
+            771,
+            825,
+            924
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "the performance gap between convolutional and locally-connected networks Lillicrap et al. (2020);   \nBartunov et al. (2018). ",
+        "bbox": [
+            173,
+            103,
+            823,
+            132
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Noting the above considerations, in this paper, we are proposing BioLCNet, a reward-modulated locally-connected spiking neural network. Our network is trained using the unsupervised spiketiming-dependent plasticity and its semi-supervised variant reward-modulated STDP. The input images are encoded proportional to the pixels intensity using Poisson rate-coding that converts intensity to average neuron firing rate in Hertz. In the output layer, there are neuronal groups for each class label, and decision making is based on aggregated number of spikes during the decision period. Our novel dynamic reward prediction error $( R P E )$ mechanism exploits strongly supported empirical findings to improve classification performance. We test the classification capabilities of our network with different sets of hyperparameters on the MNIST dataset LeCun et al. (1999). We also conduct a classical conditioning experiment to prove the effectiveness of our decoding scheme and rewarding mechanisms. ",
+        "bbox": [
+            174,
+            138,
+            825,
+            291
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2 RELATED WORK ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            318,
+            344,
+            334
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Neuroscientists and deep learning researchers have long been searching for more biologically plausible deep learning approaches in terms of neuronal characteristics, learning rules, and connection types. Regarding neuronal characteristics, researchers have turned to biological neuronal models and spiking neural networks. The vanishing performance gap between deep neural netwroks (DNNs) and SNNs, and the compatibility of SNNs with neuromorphic hardware and online on-chip training Schemmel et al. (2010) has piqued the interest of researchers Mozafari et al. (2019). For comprehensive reviews on deep learning in spiking neural networks, see Tavanaei et al. (2019); Pfeiffer & Pfeil (2018). ",
+        "bbox": [
+            174,
+            354,
+            825,
+            465
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Spiking neurons are activated by discrete input spike trains. This differs from artificial neurons used in an ANN that have differentiable activation functions and can easily employ backpropagation and gradient-based optimization. There are works that use gradient-based methods with SNNs Kheradpisheh & Masquelier (2020); Wu et al. (2018); Neftci et al. (2019); Bellec et al. (2020) and some of them have achieved great performances. On the other hand, many works in this area use derivations of the Hebbian learning rule where changes in connection weights depend on the activities of the pre and post-synaptic neurons Hebb (1949). Spike-timing-dependent plasticity (STDP) and its variants, apply asymmetric weight updates based on the temporal activities of neurons. Normal STDP requires an external read-out for classification Mozafari et al. (2018), and have been applied to image reconstruction and classification tasks by many researchers. Some have employed fully-connected architectures Beyeler et al. (2013); Tavanaei & Maida (2015); Allred & Roy (2016), while others used convolutional layers for feature extraction Masquelier & Thorpe (2007); Panda & Roy (2016); Kheradpisheh et al. (2016; 2018). Reward-modulated STDP (R-STDP) uses a reward (or punishment) signal to directly modulate the STDP weight change, and can be used to decode the output without an external cue. Izhikevich (2007) solved the distal reward problem in reinforcement learning by using a version of R-STDP with decaying eligibility traces that gives recent spiking activity more importance. Around the same time, Florian (2007) showed that R-STDP can be employed to solve a simple XOR task with both rate and temporal encoding of the output. Also, Caporale & Dan (2008) used R-STDP to generate specific spiking patterns in the output of their spiking network. Historically, R-STDP was first adopted with temporal (rank-order) encoding for image classification Mozafari et al. (2018). They employed a convolutional architecture based on Masquelier & Thorpe (2007) and a time-to-first-spike decoding scheme. An extended architecture was later developed which had multiple hidden layers Mozafari et al. (2019). The use of R-STDP with Poisson ratecoding has been mostly limited to fully-connected architectures for solving reinforcement learning robot navigation tasks Shim & Li (2017); Bing et al. (2019). To our knowledge, image recognition problems have not yet been addressed by combining R-STDP and rate-based encoding. ",
+        "bbox": [
+            174,
+            473,
+            825,
+            833
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "The most prevalent architectures used for image classification in deep learning with both DNNs and SNNs are based on convolutional layers and weight sharing. However, there are arguments against the biological plausibility of these approaches Bartunov et al. (2018); Pogodin et al. (2021). Locally connected (LC) networks are an alternative to the convolutional ones. Illing et al. (2019) show that shallow networks with localized connectivity and receptive fields perform much better than fully-connected networks on the MNIST benchmark. However, Bartunov et al. (2018) showed that the lower generalization of LC networks compared to CNNs results in their underperforming CNNs in most image classification tasks, and prevents their scalability to larger datasets such as ImageNet Deng et al. (2009). Very recently, Pogodin et al. (2021) proposed bio-inspired dynamic weight sharing and adding lateral connections to locally-connected layers to achieve the same regularization goals of weight sharing and normal convolutional filters. The first work to integrate a locally-connected (LC) layer into an SNN Saunders et al. (2019) used a network with no hidden layers where the rate-coded input is passed to the output layer via local connections. They exploited recurrent inhibitory connections similar to the ones employed by Diehl & Cook (2015) to simulate a winner-take-all (WTA) inhibition mechanism in their output. Their learning rule is STDP, and therefore an external readout, in this case n-gram voting, is required for classification. Their network scheme was inspiring in designing our locally connected hidden layer. ",
+        "bbox": [
+            174,
+            840,
+            825,
+            922
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            103,
+            825,
+            256
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3 THEORY ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            277,
+            276,
+            292
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "In this section, we will outline the theoretical foundations underlying our proposed method. Specifically, the dynamics of the spiking neuronal model, the learning rules used, and the connection type employed in our network will be described. ",
+        "bbox": [
+            174,
+            309,
+            823,
+            352
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3.1 ADAPTIVE LIF NEURON MODEL ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            369,
+            434,
+            383
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "The famous leaky and integrate fire neuronal model is governed by the following differential equation Gerstner et al. (2014), ",
+        "bbox": [
+            174,
+            395,
+            823,
+            424
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/197e345b6efd4c8dc531c6a5a88a1f2ae35aa9c264218a23cfa98a2d4124e7e8.jpg",
+        "text": "$$\n\\tau _ { m } \\frac { d u } { d t } = - [ u ( t ) - u _ { r e s t } ] + R I ( t ) ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            380,
+            422,
+            616,
+            453
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "where $u ( t )$ denotes the neuron membrane potential and is a function of time, $R$ is the membrane resistance, $I ( t )$ is any arbitrary input current, and $\\tau _ { m }$ is the membrane time constant. Equation (1) dictates that the neuron potential exponentially decays to a constant value $u _ { r e s t }$ over time. When a pre-synaptic neuron fires (spikes), it generates a current that reaches its post-synaptic neurons. In the simple leaky integrate and fire (LIF) model, a neuron fires when its potential surpasses a constant threshold $u _ { t h r }$ . After firing, the neuron’s potential resets to a constant $u _ { r e s e t }$ and will not be affected by any input current for a period of time known as the refractory period $( \\Delta t _ { r e f } )$ . ",
+        "bbox": [
+            174,
+            457,
+            825,
+            554
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "A variant of the LIF model uses adaptive firing thresholds. In this model, $u _ { t h r }$ can change over time based on the neuron’s rate of activity Diehl & Cook (2015). When a neuron fires, its tolerance to the input stimuli and consequently its firing threshold increases by a constant amount, $g _ { 0 }$ , otherwise the threshold decays exponentially with a time constant $\\tau _ { g }$ to the default threshold $u _ { t h r _ { 0 } }$ . Equations (2) to (4) explain the dynamics of the adaptive LIF model, ",
+        "bbox": [
+            174,
+            560,
+            823,
+            631
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/b6b8ca5308960619ae43cbcaba3086510a139df49456fb32d8a77f204f95ac27.jpg",
+        "text": "$$\nu _ { t h r } ( t ) = u _ { t h r _ { 0 } } + g ( t ) ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            418,
+            638,
+            578,
+            656
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "where, ",
+        "bbox": [
+            174,
+            664,
+            220,
+            676
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/cb5095b5897354e4954905265df24c834fc5f0715d1e407ba0f66a233dd6846a.jpg",
+        "text": "$$\n\\tau _ { g } d _ { g } / d _ { t } = - g ( t ) ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            436,
+            676,
+            560,
+            694
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "and ",
+        "bbox": [
+            173,
+            699,
+            200,
+            712
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/ea95355ea89f9a2c8626462af8d6c238703d5eb5ea790035b3a2f923aaffe2f2.jpg",
+        "text": "$$\ns p i k e \\Rightarrow g ( t ) = g ( t - 1 ) + g _ { 0 } ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            393,
+            710,
+            604,
+            728
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3.2 REWARD-MODULATED STDP ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            744,
+            418,
+            758
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Spike-timing-dependent plasticity is a type of biological Hebbian learning rule that is also aligned with human intuition (”Neurons that fire together wire together.” (Lowel & Singer, 1992)). The normal STDP is characterized by two asymmetric update rules. The synaptic weights are updated based on the temporal activities of pre and post-synaptic neurons. When a pre-synaptic neuron fires shortly before its post-synaptic neuron, the causal connection between the first and the second neuron temporal activity is acknowledged, and the connection weight is increased. On the other hand, if the post-synaptic neuron fires shortly after the pre-synaptic neuron, the causality is undermined and the synaptic strength will decrease Hebb (1949). These weight updates, called long-term potentiation (LTP) and long-term depression (LTD), can be performed with asymmetric learning rates to adapt the learning rule to the excitatory to inhibitory neuron ratio or the connection patterns of a specific neural network. A popular variant of STDP that integrates reinforcement learning into the learning mechanism of spiking neural networks is reward-modulated STDP (also known as RSTDP or MSTDP Florian (2007)). In R-STDP, a global reward or punishment signal, which can be a function of time, is generated as the result of the network’s activity or task performance. Using a notation similar to Florian (2007), to mathematically formulate both STDP and R-STDP, we can define the spike train of a pre-synaptic neuron as the sum of Dirac functions over the spikes of the post-synaptic neurons, ",
+        "bbox": [
+            173,
+            770,
+            825,
+            924
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            103,
+            825,
+            188
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/d3ee8d74757c6e6ac5c52ac0e9f43a1dd5a7a59d031868045f28fc39784237b6.jpg",
+        "text": "$$\n\\Phi ( t ) = \\sum _ { \\mathcal { F } _ { i } } \\delta ( t - t _ { i } ^ { f } ) .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            415,
+            185,
+            583,
+            213
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "where $t _ { i } ^ { f }$ is the firing time of the $i ^ { t h }$ post-syanptic neuron. Now, we can define the variables $P _ { i j } ^ { + }$ and $P _ { i j } ^ { - }$ to respectively track the influence of pre or post-synaptic spikes on weight updates. Now, the spike trace $\\xi$ for a given spike from neuron $i$ to $j$ can be defined as below, ",
+        "bbox": [
+            174,
+            218,
+            825,
+            266
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/1db09b2767a62ee15ab8d044653d97a7562243d27cae4f98c714ee49435379f2.jpg",
+        "text": "$$\n\\xi _ { i j } = P _ { i j } ^ { + } \\Phi _ { i } ( t ) + P _ { i j } ^ { - } \\Phi _ { j } ( t ) ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            403,
+            271,
+            593,
+            291
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "where: (assuming the same , ",
+        "bbox": [
+            174,
+            296,
+            362,
+            310
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/9a46ac05bf0cf9cbb4bd6d7c6f34da0e9b02d19c7df9b1473a4255603a7bef4c.jpg",
+        "text": "$$\nd P _ { j } ^ { + } / d t = - P _ { j } ^ { + } / \\tau _ { + } + \\eta _ { p o s t } \\Phi _ { j } ( t ) ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            379,
+            315,
+            617,
+            335
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/3d834c7cf58c42a5f1388aabd7803d1666796d5b31cae4947dc1b785408d1124.jpg",
+        "text": "$$\nd P _ { i } ^ { - } / d t = - P _ { i } ^ { - } / \\tau _ { - } - \\eta _ { p r e } \\Phi _ { i } ( t ) ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            383,
+            342,
+            612,
+            359
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "where we assumed that $P _ { i j } = P _ { j }$ for all pre-synaptic connections related to neuron $j$ , and $P _ { i j } = P _ { i }$ for all post-synaptic connections related to neuron $i$ . ",
+        "bbox": [
+            173,
+            362,
+            828,
+            390
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "The variables $\\tau _ { \\pm }$ are the time constants determining the time window in which a spike can affect the weight updates. Using larger time constants will cause spikes that are further apart to also trigger weight updates. The variables $\\eta _ { p o s t }$ and $\\eta _ { p r e }$ determine the learning rate for LTP and LTD updates respectively. We denote the reward or punishment signal with $r ( t )$ . The R-STDP update rules for positive and negative rewards can be written as, ",
+        "bbox": [
+            173,
+            397,
+            825,
+            467
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/0be17c52ec8b9e53282eda420bdc115e840312b4bddc4e511ef340c8dc29862a.jpg",
+        "text": "$$\n\\frac { d w _ { i j } ( t ) } { d t } = \\gamma r ( t ) \\xi _ { i j } ( t ) ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            421,
+            473,
+            576,
+            505
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "where $\\gamma$ is a scaling factor. The update rule for normal STDP can also be written as, ",
+        "bbox": [
+            173,
+            508,
+            723,
+            523
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/2c2e9dc2608bb21368be24cff57f8e57b3fd2fc89cdb0a9f74e12028475845bb.jpg",
+        "text": "$$\n\\frac { d w _ { i j } ( t ) } { d t } = \\gamma \\xi _ { i j } ( t ) .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            434,
+            530,
+            563,
+            561
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Based on Equation (9), we note that R-STDP updates only take effect when a non-zero modulation signal is received at time step $t$ . However, STDP updates do not depend on the modulation signal, and are applied at every time step. In other words, STDP can be considered a special case of RSTDP where the reward function is equal to 1 in every time step. This causes STDP to respond to the most frequent patterns regardless of their desirability. ",
+        "bbox": [
+            173,
+            565,
+            825,
+            636
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "image",
+        "img_path": "images/7d16d30ca22f5af673ef7c16b44c6d342f983954e53442bb9a7b0d15131bd48b.jpg",
+        "image_caption": [
+            "Figure 1: Visual comparison of convolutional and local connections for a given filter; in convolutional connections, the weights are shared between all receptive fields. However, in a local connections, each receptive field has its own set of weights. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            328,
+            655,
+            673,
+            772
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3.3 LOCAL CONNECTIONS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            869,
+            369,
+            883
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "A local connection in a neural network is similar to a convolutional connection but with distinct filters for each receptive field. As seen in Fig. 1, in normal convolutional connections, there is one filter for each channel that is convolved with all receptive fields as it moves along the layer’s input. This filter has one set of weights that are updated using the network’s update rule. However, In local connection (LC), after taking each stride, a new set of parameters characterize a whole new filter for the next receptive field. This type of connectivity between the input and the LC layer resembles the physical structure of retinal Ganglion cells. Because there are more filters in an LC, the number of distinct synapses in a local connection is greater than a convolutional connection, yet much lower than a dense connection. Similar to a convolutional connection, assuming square filters, and equal horizontal and vertical strides, we can specify a local connection by the number of channels (filters) $( c h _ { l c } )$ , the kernel size $( k )$ , and the stride (s). ",
+        "bbox": [
+            173,
+            895,
+            823,
+            924
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            103,
+            825,
+            229
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "4 ARCHITECTURE AND METHODS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            250,
+            470,
+            266
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "BioLCNet consists of an input layer, a locally connected hidden layer, and a decoding layer. Each layer structure and its properties alongside the training and rewarding procedure will be delineated in this section. A graphical representation of our network is presented in Fig. 2. The simulation time $T$ is divided into three phases, adaptation period $( T _ { a d a p t } )$ , decision period $( T _ { d e c } )$ , and learning period $( T _ { l e a r n } )$ . The details of each phase will be specified in the remainder of this section. ",
+        "bbox": [
+            174,
+            281,
+            825,
+            352
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "image",
+        "img_path": "images/5fdf75263ec24542831806da2a28750016c3f859a907223b028482ab6ed6b1c4.jpg",
+        "image_caption": [
+            "Figure 2: Graphical representation of the proposed network; locally connected filters will be applied to the rate-coded input image. Based on a winner-take-all inhibition mechanism, the most relevant features from each receptive field transmit their spikes to the decoding layer, which selects the most active neuronal group as the predicted label exploiting lateral inhibitory connections. The red lines indicate inhibitory connections. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            300,
+            377,
+            684,
+            515
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "4.1 ENCODING LAYER ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            645,
+            341,
+            659
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "The input of the network is an image of dimensions $( c h _ { i n } , h _ { i n } , w _ { i n } )$ . For a grayscale image dataset such as MNIST, $c h _ { i n }$ equals to one. Each input channel is rate-coded using a Poisson encoding scheme, i.e, the spiking neuron corresponding to each pixel has an average firing rate proportional to the intensity of that pixel. By choosing the maximum firing rate $f _ { m a x }$ , the spike trains average firing rates will be distributed in the interval $[ 0 , f _ { m a x } ]$ Hertz based on the pixel values. ",
+        "bbox": [
+            174,
+            670,
+            825,
+            741
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "4.2 FEATURE EXTRACTION LAYER (LOCAL CONNECTIONS) ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            758,
+            593,
+            773
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "The encoded input at each simulation time step passes through local connections with $c h _ { o u t }$ distinct filters for each receptive field. Therefore, the output of this layer will have dimensions $( c h _ { o u t }$ , $h _ { o u t }$ , $w _ { o u t , }$ ), where the output size depends on the size of the kernel and the stride. There are generally two approaches in the SNN literature for training a feature extraction layer with rate-coded inputs using STDP to attain a rich feature representation and also prevent the weights from growing too large. One is allowing the weights to have negative values, which corresponds to having inhibitory neurons, as done in the convolutional layers used by Lee et al. (2018). The other is to use a combination of recurrent inhibitory connections and adaptive thresholds as done by Diehl & Cook (2015); Saunders et al. (2018; 2019). In this work, we used the latter approach for our feature extraction LC layer. We use adaptive LIF neurons and inhibitory connections between neurons that share the same receptive field. This is equivalent to the winner-take-all inhibition mechanism which causes a competition between neurons to select the most relevant features. The inhibitory connections are non-plastic and they all have a static negative weight $w _ { i n h }$ with a large absolute value. ",
+        "bbox": [
+            174,
+            784,
+            825,
+            924
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            103,
+            823,
+            146
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "In normal STDP, the LTP learning rate $( \\eta _ { p o s t } )$ is usually chosen larger than the LTD rate $( \\eta _ { p r e } )$ to suppress the random firing of neurons that triggers many LTD updates during the early stages of training. However, this may become problematic in the later stages, and the weights may grow too large. Therefore, in practice, different mechanisms, such as weight clipping and normalization are used to prevent the weights running amok. In this work, we clipped the weights to stay in the range $[ 0 , 1 ]$ . We also employed the normalization technique used by Saunders et al. (2019) and normalized the pre-synaptic weights of each neuron in the LC layer to have a constant mean of $c _ { n o r m }$ at the end of each time step. ",
+        "bbox": [
+            173,
+            152,
+            825,
+            265
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "4.3 DECODING LAYER AND REWARDING MECHANISMS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            284,
+            565,
+            297
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "The final layer of our network is a fully connected layer for reward-based decoding. The layer is divided into $n _ { c }$ neuronal groups where $n _ { c }$ is the number of classes related to the task. Consequently, the $n _ { o u t }$ neurons in this layer are divided equally into $n _ { c }$ neuronal groups. The predicted label for a given test sample is the class whose group has the most number of spikes aggregated over the decision period $( T _ { d e c } )$ . This decoding layer is trained using reinforcement learning and R-STDP during the learning period $( T _ { l e a r n } )$ based on the modulation signal generated by the rewarding mechanism. We designed two different rewarding mechanisms, static and dynamic reward prediction error (RPE). In the static mechanism, we use a fixed reward or punishment signal for the whole learning period $( T _ { l e a r n } )$ based on the prediction of the network for the $i ^ { t h }$ training sample, ",
+        "bbox": [
+            173,
+            309,
+            825,
+            435
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "equation",
+        "img_path": "images/7e383164a30af869dc72efc9e012acf32e5be7f8450075b6f4dc2dbac4c4e301.jpg",
+        "text": "$$\nr _ { i } = \\left\\{ \\begin{array} { c } { { 1 : \\ p r e d i c t e d l a b e l = t a r g e t l a b e l } } \\\\ { { - 1 : \\qquad o t h e r w i s e } } \\end{array} \\right.\n$$",
+        "text_format": "latex",
+        "bbox": [
+            336,
+            443,
+            651,
+            478
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "The second mechanism, dynamic $R P E$ is based on the reward prediction error theory in reinforcement learning. According to this theory, the dopaminergic neurons in the brain release dopamine proportional to the difference between the actual reward and the expected reward (not solely based on the actual reward) Schultz et al. (1997); Sutton & Barto (2018). We formulate our dynamic RPE mechanism as below, ",
+        "bbox": [
+            174,
+            484,
+            823,
+            555
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "equation",
+        "img_path": "images/26c004e5626db5382228ea02095370acd11e9368e1201f0a7a61b371adde13f6.jpg",
+        "text": "$$\nR _ { i } = R _ { i - 1 } - \\eta _ { r p e } ( r _ { i } - \\mathrm { E M A } _ { R } )\n$$",
+        "text_format": "latex",
+        "bbox": [
+            388,
+            556,
+            609,
+            574
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "where $R _ { i }$ is the scalar R-STDP modulation signal used during the whole learning period $( T _ { l e a r n } )$ of the $i ^ { t h }$ training sample, $r _ { i }$ is the reward signal received based on the prediction, and ${ \\mathrm { E M A } _ { R } }$ is the exponential moving average of the modulation signals with a smoothing factor $\\alpha$ . ",
+        "bbox": [
+            174,
+            578,
+            825,
+            621
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "4.4 TRAINING PROCEDURE ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            640,
+            374,
+            654
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "The network is trained in a layer-wise fashion. After initializing the weights uniformly between $[ 0 , 1 ]$ , we train the feature extraction LC layer in a completely unsupervised manner using STDP. Simulation time for training the feature extraction layer is $T _ { l e a r n }$ time steps. After this layer is trained, the weights are freezed, and we train the decoding FC layer in a semi-supervised manner using R-STDP and the selected rewarding mechanism. Training this layer requires all three simulation phases. The input image is first presented to the network for $T _ { a d a p t }$ time steps to let the LC layer neurons adapt to the input image and select its relevant features. During $T _ { d e c }$ time steps, the decoding layer accumulates the number of spikes received by each neuronal group to determine the predicted label. Afterwards, the modulation signal is generated and the decoding layer weights are updated using R-STDP for $T _ { l e a r n }$ time steps. ",
+        "bbox": [
+            174,
+            665,
+            825,
+            806
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "When training the LC layer, we observed that after a specific number of iterations (training samples), the weights of this layer converge and remain constant. Fig. 3a visualizes the filters learned after 2000 iterations for 100 filters of size 15 with a stride of 4 applied to the input images. This fast convergence is an evidence showing the strength of STDP learning. Considering these observations, and to save computation time, we limit the number of training sample of the LC layer to 2000 for all of the hyperparameter configurations. Given an input image (Fig. 3b), we can plot the activation map of the LC layer (Fig. 3c). This map shows the post-synaptic neurons corresponding to the relevant features activate, and suppress the other neurons in accordance with the WTA inhibition mechanism. ",
+        "bbox": [
+            174,
+            811,
+            825,
+            924
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "The network is implemented using PyTorch Paszke et al. (2019), and mostly on top of the BindsNet framework Hazan et al. (2018) to make our code more efficient. We reimplemented the local connection topology to make it compatible with multi-channel inputs and a possible deep extension of our network. ",
+        "bbox": [
+            174,
+            103,
+            825,
+            159
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/0decd3b3924b810633377d52c352a922683153280606c399e810843c871f63b8.jpg",
+        "image_caption": [
+            "Figure 3: Input and LC layer visualizations. (a) LC layer learned filters; the red lines separate filters corresponding to each receptive field. (b) A sample input image. (c) The LC layer activation map corresponding to the sample input image shown. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            202,
+            170,
+            800,
+            304
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "table",
+        "img_path": "images/b321c205b552332ad5559920e96c85838a02e243c5b067cb4bf283855846c438.jpg",
+        "table_caption": [
+            "Table 1: BioLCNet (hyper-)parameters; best-performing value for (hyper-)parameters subject to grid search are in bold. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=1 colspan=1>Parameter</td><td rowspan=1 colspan=1>Value</td></tr><tr><td rowspan=1 colspan=1>Uthro</td><td rowspan=1 colspan=1>-52 (mV)</td></tr><tr><td rowspan=1 colspan=1>Urest,Ureset</td><td rowspan=1 colspan=1>-65 (mV)</td></tr><tr><td rowspan=1 colspan=1>go</td><td rowspan=1 colspan=1>0.05 (mV)</td></tr><tr><td rowspan=1 colspan=1>Tg</td><td rowspan=1 colspan=1>10 (ms)</td></tr><tr><td rowspan=1 colspan=1>△tref</td><td rowspan=1 colspan=1>5(ms)</td></tr><tr><td rowspan=1 colspan=1>Tm</td><td rowspan=1 colspan=1>20(ms)</td></tr><tr><td rowspan=1 colspan=1>fmax</td><td rowspan=1 colspan=1>128(Hz)</td></tr><tr><td rowspan=1 colspan=1>hin，Win</td><td rowspan=1 colspan=1>22</td></tr><tr><td rowspan=1 colspan=1>nout</td><td rowspan=1 colspan=1>[100,500,1000]</td></tr><tr><td rowspan=1 colspan=1>chlc</td><td rowspan=1 colspan=1>[25,50,100,250]</td></tr><tr><td rowspan=1 colspan=1>k</td><td rowspan=1 colspan=1>[11,13, 15,17]</td></tr><tr><td rowspan=1 colspan=1>S</td><td rowspan=1 colspan=1>[2, 3,4]</td></tr><tr><td rowspan=1 colspan=1>Tadapt,Tdec,Tlearn</td><td rowspan=1 colspan=1>256 (ms)</td></tr><tr><td rowspan=1 colspan=1>(Npre,Npost)STDP</td><td rowspan=1 colspan=1>(0.0001,0.01)</td></tr><tr><td rowspan=1 colspan=1>(npre,post)R-STDP</td><td rowspan=1 colspan=1>(0.1,0.1)</td></tr><tr><td rowspan=1 colspan=1>2</td><td rowspan=1 colspan=1>1</td></tr><tr><td rowspan=1 colspan=1>nrpe</td><td rowspan=1 colspan=1>[(static),0.075,0.125,0.175,0.25]</td></tr><tr><td rowspan=1 colspan=1>a</td><td rowspan=1 colspan=1>0.9</td></tr><tr><td rowspan=1 colspan=1>Winh</td><td rowspan=1 colspan=1>-100</td></tr><tr><td rowspan=1 colspan=1>Cnorm</td><td rowspan=1 colspan=1>0.25</td></tr></table>",
+        "bbox": [
+            308,
+            417,
+            686,
+            696
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "5 EXPERIMENTS AND DISCUSSION ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            733,
+            477,
+            750
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "5.1 IMAGE CLASSIFICATION ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            765,
+            382,
+            780
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "To evaluate our network’s classification performance, we trained our model on the MNIST benchmark. Some of the hyperparameters were fixed and others were subject to grid search. The full list of hyperparameters are given in Table 1. ",
+        "bbox": [
+            174,
+            790,
+            823,
+            833
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Considering the hyperparameters mentioned in Table 1, we report in Table 2, the classification accuracy on the whole MNIST test set (10000 samples) for four hyperparameter configurations chosen based on the highest test accuracy obtained after conducting a grid search. The number of neurons and synapses for each model are also reported in this table. The final models were all trained using 10000 training samples from the MNIST training set. Using more training samples did not improve the classification performance as can be observed from Fig. 4. The mean and standard deviations reported are estimated from ten independent runs. In addition to the RL-based models, another classification approach was employed. In this approach, for each training sample, we create a feature vector containing the number of spikes aggregated over $T _ { l e a r n }$ time steps for every filter in the LC layer. We use these feature vectors to train a support vector machine (SVM) classifier. The SVM results are also obtained by training on 10000 training samples, and testing on the whole MNIST test set. The SVM test results for two different hyperparameter configurations are reported in Table 2 and are compared to the RL-based results. The best performance of SVM and RL-based classification are 87.50, and 76.40 respectively. Table3 compares the MNIST test performance obtained by different SNN approaches along with the bio-plausibility criteria to which they adhere. ",
+        "bbox": [
+            173,
+            840,
+            825,
+            924
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "table",
+        "img_path": "images/94cd41f846b366def871d445fe87cf59826a159bca9079dab010b3698dbd68e2.jpg",
+        "table_caption": [
+            "Table 2: MNIST test dataset accuracies obtained by four different sets of hyper-parameters; the test accuracies are averaged over ten independent runs "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=1 colspan=1>Parameters[k,s,nrpe,nout]</td><td rowspan=1 colspan=1>nneurons</td><td rowspan=1 colspan=1>nsynapses</td><td rowspan=1 colspan=1>Test accuracy</td><td rowspan=1 colspan=1>SVM test accuracy</td></tr><tr><td rowspan=1 colspan=1>[13,3,0.025,100]</td><td rowspan=1 colspan=1>1700</td><td rowspan=1 colspan=1>430400</td><td rowspan=1 colspan=1>61.30 ±3.14</td><td rowspan=1 colspan=1>87.5±1.32</td></tr><tr><td rowspan=1 colspan=1>[15,4,0.175,1000]</td><td rowspan=1 colspan=1>1884</td><td rowspan=1 colspan=1>490000</td><td rowspan=1 colspan=1>75.00 ±2.68</td><td rowspan=1 colspan=1>83.3±1.74</td></tr><tr><td rowspan=1 colspan=1>[15,4,0.125,1000]</td><td rowspan=1 colspan=1>1884</td><td rowspan=1 colspan=1>490000</td><td rowspan=1 colspan=1>76.40 ±2.43</td><td rowspan=1 colspan=1>83.3±1.74</td></tr><tr><td rowspan=1 colspan=1>[15,4,(static),100]</td><td rowspan=1 colspan=1>984</td><td rowspan=1 colspan=1>130000</td><td rowspan=1 colspan=1>68.8±2.87</td><td rowspan=1 colspan=1>83.3±1.74</td></tr></table>",
+        "bbox": [
+            210,
+            141,
+            787,
+            209
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "table",
+        "img_path": "images/db95bf4749e26b3255ae329f5fce4c9e0ed1edb5c0f6defd8ec97413ab4f1dc1.jpg",
+        "table_caption": [
+            "Table 3: MNIST test dataset accuracies obtained by different SNN approaches "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=1 colspan=1>Paper</td><td rowspan=1 colspan=1>Encoding</td><td rowspan=1 colspan=1>Architecture</td><td rowspan=1 colspan=1>Bio-plausibility criteria</td><td rowspan=1 colspan=1>Acc.</td></tr><tr><td rowspan=1 colspan=1>BioLCNet (proposed, RL)</td><td rowspan=1 colspan=1>rate-based</td><td rowspan=1 colspan=1>Locally connected+Dense</td><td rowspan=1 colspan=1>STDP, RL, LC</td><td rowspan=1 colspan=1>76.40</td></tr><tr><td rowspan=1 colspan=1>BioLCNet (proposed,SVM)</td><td rowspan=1 colspan=1>rate-based</td><td rowspan=1 colspan=1>Locally connected</td><td rowspan=1 colspan=1>STDP, LC</td><td rowspan=1 colspan=1>87.5</td></tr><tr><td rowspan=1 colspan=1>Beyeler et al. (2013)</td><td rowspan=1 colspan=1>rate-based</td><td rowspan=1 colspan=1>Dense</td><td rowspan=1 colspan=1>STDP</td><td rowspan=1 colspan=1>91.60</td></tr><tr><td rowspan=1 colspan=1>Diehl&amp; Cook (2015)</td><td rowspan=1 colspan=1>rate-based</td><td rowspan=1 colspan=1>Dense</td><td rowspan=1 colspan=1>STDP</td><td rowspan=1 colspan=1>95.00</td></tr><tr><td rowspan=1 colspan=1>Tavanaei &amp;Maida (2015)</td><td rowspan=1 colspan=1>rate-based</td><td rowspan=1 colspan=1>Dense</td><td rowspan=1 colspan=1>STDP</td><td rowspan=1 colspan=1>75.93</td></tr><tr><td rowspan=1 colspan=1>Allred &amp; Roy (2016)</td><td rowspan=1 colspan=1>rate-based</td><td rowspan=1 colspan=1>Dense</td><td rowspan=1 colspan=1>STDP</td><td rowspan=1 colspan=1>86.59</td></tr><tr><td rowspan=1 colspan=1>Kheradpisheh et al. (2018)</td><td rowspan=1 colspan=1>rank-order</td><td rowspan=1 colspan=1>Convolutional</td><td rowspan=1 colspan=1>STDP</td><td rowspan=1 colspan=1>98.40</td></tr><tr><td rowspan=1 colspan=1>Saunders et al. (2018)</td><td rowspan=1 colspan=1>rate-based</td><td rowspan=1 colspan=1>Convolutional</td><td rowspan=1 colspan=1>STDP</td><td rowspan=1 colspan=1>84.23</td></tr><tr><td rowspan=1 colspan=1>Lee et al. (2018)</td><td rowspan=1 colspan=1>rate-based</td><td rowspan=1 colspan=1>Convolutional</td><td rowspan=1 colspan=1>STDP</td><td rowspan=1 colspan=1>91.1</td></tr><tr><td rowspan=1 colspan=1>Mozafari et al. (2019)</td><td rowspan=1 colspan=1>rank-order</td><td rowspan=1 colspan=1>Convolutional</td><td rowspan=1 colspan=1>STDP, RL</td><td rowspan=1 colspan=1>97.2</td></tr><tr><td rowspan=1 colspan=1>Saunders et al. (2019)</td><td rowspan=1 colspan=1>rate-based</td><td rowspan=1 colspan=1>Locally connected</td><td rowspan=1 colspan=1>STDP, LC</td><td rowspan=1 colspan=1>95.07</td></tr></table>",
+        "bbox": [
+            173,
+            255,
+            826,
+            415
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            443,
+            825,
+            568
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "image",
+        "img_path": "images/482e4a9d69fa8e69ad9b163d17afcb7732c0bce5812040cd207c4efe158cd3d5.jpg",
+        "image_caption": [
+            "Figure 4: Smoothed running accuracy over the training set for four sets of hyperparameters using the R-STDP classifier "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            321,
+            583,
+            676,
+            704
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Overall, the supervised SVM has achieved a better performance than the R-STDP method. Two important observations can be made from Table 2. First, the classification accuracy has a positive correlation with the filter size, and the number of neurons in the decoding layer. Secondly, the dynamic RPE mechanism improved the classification performance compared to the default static rewarding mechanism. dynamic RPE plays a similar role to the adaptive learning rate method employed by Mozafari et al. (2018), yet with more biological roots and empirical support. ",
+        "bbox": [
+            173,
+            767,
+            825,
+            852
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "5.2 CLASSICAL CONDITIONING ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            869,
+            403,
+            883
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "In order to show the effectiveness of our rewarding mechanism, we perform a classical (Pavlovian) conditioning experiment. This type of conditioning pairs up a neutral stimulus with an automatic conditioned response by the agent. In this experiment, we present the network with images belonging to one class of the MNIST dataset as the neutral stimuli. We used the pre-trained feature extraction layer of the network with 25 filters of size 13 and stride of 3, following by a decoding layer with 20 neurons for a two-class prediction task. In the first half of the experiment (task 1), the target response is class 1, and the network receives a constant reward of 1 if it predicts this class regardless of the input. A punishment signal of -1 is received if the agent predicts class 0. We monitor the rate of the reward and punishment received during the experiment. After the convergence in about 50 iterations, Fig. 5 shows that the agent has become completely conditioned on the rewarding response. After 200 iterations, we swap the rewarding and punishing classes, and continue running the network. In task 2, the network should predict the input images as class 0. The RL agent (the network) adapts to the change notably fast, and completely changes its behavior after about 100 iterations. The heat maps in Fig. 5 visualize the weights of the output layer through the training. ",
+        "bbox": [
+            174,
+            895,
+            823,
+            924
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "image",
+        "img_path": "images/8f859c87f1c13d06b557b110e4326581592fd1b4ea20647586d4c42985854d66.jpg",
+        "image_caption": [
+            "Figure 5: Classical conditioning experiment; in this experiment, we tested the adaptability of the network to varying target responses. The plot shows the rate of receiving reward and punishment averaged over 20 runs, and the decoding layer weight maps at iterations 0, 200, 300, 400, and 600. The right side of the weight maps correspond to the task 1 target response neurons, and the left side corresponds to the task 2 target response neurons. The weights adapt to the varying target response during the experiment. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            357,
+            106,
+            638,
+            294
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            440,
+            825,
+            608
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "The reward adaptability of an RL agent is critical because in many real-world problems the environment is non-stationary. Integration of reward adaptation into spiking neural networks, as done in this work, can pave the path for models that simulate human behaviour with the same spike-based computation as done in the human brain. ",
+        "bbox": [
+            174,
+            614,
+            825,
+            670
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "6 CONCLUSIONS AND FUTURE WORK ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            708,
+            503,
+            724
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "In this work, we examined the capabilities of a neural network with three-fold biological plausibility; spiking neurons, local visual receptive fields, and a reward-modulated learning rule. The R-STDP learning rule has been only used for sequential decision making or temporal-coded visual tasks. As the first work to employ R-STDP in locally connected SNNs, we did not expect to achieve state-of-the-art performance. However, we hope that using the novel dynamic RPE rewarding mechanism alongside the emerging local connection scheme will make the future prospects of biological learning rules and architectures in solving real-world problems, more promising. ",
+        "bbox": [
+            174,
+            750,
+            825,
+            847
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "In the future, by bringing ideas such as dynamic weight sharing and lateral connections Pogodin et al. (2021) to spiking neural networks, we may be able to obtain richer feature representations using locally connected SNNs. We can also exploit the recent advances in SNN minibatch processing Saunders et al. (2020) and neuromorphic hardware Schemmel et al. (2010) to extend our network with deeper architectures and solve more complex tasks. ",
+        "bbox": [
+            174,
+            854,
+            823,
+            924
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "REFERENCES ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            103,
+            285,
+            117
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Jason M Allred and Kaushik Roy. Unsupervised incremental stdp learning using forced firing of dormant or idle neurons. In 2016 International Joint Conference on Neural Networks (IJCNN), pp. 2492–2499. IEEE, 2016. ",
+        "bbox": [
+            174,
+            126,
+            825,
+            167
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Sergey Bartunov, Adam Santoro, Blake Richards, Luke Marris, Geoffrey E Hinton, and Timothy Lillicrap. Assessing the scalability of biologically-motivated deep learning algorithms and architectures. In S. Bengio, H. Wallach, H. Larochelle, K. Grauman, N. Cesa-Bianchi, and R. Garnett (eds.), Advances in Neural Information Processing Systems, volume 31. Curran Associates, Inc., 2018. URL https://proceedings.neurips.cc/paper/2018/file/ 63c3ddcc7b23daa1e42dc41f9a44a873-Paper.pdf. ",
+        "bbox": [
+            173,
+            178,
+            825,
+            262
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Guillaume Bellec, Franz Scherr, Anand Subramoney, Elias Hajek, Darjan Salaj, Robert Legenstein, and Wolfgang Maass. A solution to the learning dilemma for recurrent networks of spiking neurons. Nature communications, 11(1):1–15, 2020. ",
+        "bbox": [
+            173,
+            272,
+            825,
+            315
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Michael Beyeler, Nikil D Dutt, and Jeffrey L Krichmar. Categorization and decision-making in a neurobiologically plausible spiking network using a stdp-like learning rule. Neural Networks, 48: 109–124, 2013. ",
+        "bbox": [
+            173,
+            324,
+            826,
+            367
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Zhenshan Bing, Zhuangyi Jiang, Long Cheng, Caixia Cai, Kai Huang, and Alois Knoll. End to end learning of a multi-layered snn based on r-stdp for a target tracking snake-like robot. In 2019 International Conference on Robotics and Automation (ICRA), pp. 9645–9651. IEEE, 2019. ",
+        "bbox": [
+            171,
+            376,
+            823,
+            420
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Natalia Caporale and Yang Dan. Spike timing–dependent plasticity: a hebbian learning rule. Annu. Rev. Neurosci., 31:25–46, 2008. ",
+        "bbox": [
+            168,
+            429,
+            821,
+            458
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Nicolas Carion, Francisco Massa, Gabriel Synnaeve, Nicolas Usunier, Alexander Kirillov, and Sergey Zagoruyko. End-to-end object detection with transformers. In European Conference on Computer Vision, pp. 213–229. Springer, 2020. ",
+        "bbox": [
+            173,
+            468,
+            825,
+            511
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Jia Deng, Wei Dong, Richard Socher, Li-Jia Li, Kai Li, and Li Fei-Fei. Imagenet: A large-scale hierarchical image database. In 2009 IEEE Conference on Computer Vision and Pattern Recognition, pp. 248–255, 2009. doi: 10.1109/CVPR.2009.5206848. ",
+        "bbox": [
+            173,
+            520,
+            825,
+            563
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Peter U Diehl and Matthew Cook. Unsupervised learning of digit recognition using spike-timingdependent plasticity. Frontiers in computational neuroscience, 9:99, 2015. ",
+        "bbox": [
+            173,
+            573,
+            823,
+            602
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Razvan V Florian. Reinforcement learning through modulation of spike-timing-dependent synaptic ˘ plasticity. Neural computation, 19(6):1468–1502, 2007. ",
+        "bbox": [
+            173,
+            611,
+            823,
+            640
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Wulfram Gerstner, Werner M Kistler, Richard Naud, and Liam Paninski. Neuronal dynamics: From single neurons to networks and models of cognition. Cambridge University Press, 2014. ",
+        "bbox": [
+            173,
+            650,
+            825,
+            679
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Ian Goodfellow, Yoshua Bengio, and Aaron Courville. Deep Learning. MIT Press, 2016. http: //www.deeplearningbook.org. ",
+        "bbox": [
+            174,
+            688,
+            823,
+            718
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Karo Gregor and Yann LeCun. Emergence of complex-like cells in a temporal product network with local receptive fields, 2010. ",
+        "bbox": [
+            171,
+            727,
+            823,
+            756
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Hananel Hazan, Daniel J Saunders, Hassaan Khan, Devdhar Patel, Darpan T Sanghavi, Hava T Siegelmann, and Robert Kozma. Bindsnet: A machine learning-oriented spiking neural networks library in python. Frontiers in neuroinformatics, 12:89, 2018. ",
+        "bbox": [
+            176,
+            765,
+            825,
+            809
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Donald Olding Hebb. The organisation of behaviour: a neuropsychological theory. Science Editions New York, 1949. ",
+        "bbox": [
+            171,
+            818,
+            823,
+            847
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Bernd Illing, Wulfram Gerstner, and Johanni Brea. Biologically plausible deep learning—but how far can we go with shallow networks? Neural Networks, 118:90–101, 2019. ",
+        "bbox": [
+            173,
+            856,
+            821,
+            886
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Eugene M Izhikevich. Solving the distal reward problem through linkage of stdp and dopamine signaling. Cerebral cortex, 17(10):2443–2452, 2007. ",
+        "bbox": [
+            176,
+            895,
+            821,
+            924
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Saeed Reza Kheradpisheh and Timothee Masquelier. Temporal backpropagation for spiking neural ´ networks with one spike per neuron. International Journal of Neural Systems, 30(06):2050027, 2020. ",
+        "bbox": [
+            176,
+            103,
+            823,
+            146
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Saeed Reza Kheradpisheh, Mohammad Ganjtabesh, and Timothee Masquelier. Bio-inspired unsu- ´ pervised learning of visual features leads to robust invariant object recognition. Neurocomputing, 205:382–392, 2016. ",
+        "bbox": [
+            174,
+            156,
+            825,
+            198
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Saeed Reza Kheradpisheh, Mohammad Ganjtabesh, Simon J Thorpe, and Timothee Masquelier. ´ Stdp-based spiking deep convolutional neural networks for object recognition. Neural Networks, 99:56–67, 2018. ",
+        "bbox": [
+            173,
+            208,
+            825,
+            251
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Y LeCun, C Cortes, and C Burges. The mnist dataset of handwritten digits (images). NYU: New York, NY, USA, 1999. ",
+        "bbox": [
+            176,
+            261,
+            823,
+            290
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Yann LeCun, Yoshua Bengio, and Geoffrey Hinton. Deep learning. nature, 521(7553):436–444, 2015. ",
+        "bbox": [
+            173,
+            300,
+            823,
+            329
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Chankyu Lee, Gopalakrishnan Srinivasan, Priyadarshini Panda, and Kaushik Roy. Deep spiking convolutional neural network trained with unsupervised spike-timing-dependent plasticity. IEEE Transactions on Cognitive and Developmental Systems, 11(3):384–394, 2018. ",
+        "bbox": [
+            174,
+            339,
+            823,
+            382
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Qianli Liao, Joel Leibo, and Tomaso Poggio. How important is weight symmetry in backpropagation? In Proceedings of the AAAI Conference on Artificial Intelligence, volume 30, 2016. ",
+        "bbox": [
+            173,
+            392,
+            821,
+            421
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Timothy P Lillicrap, Adam Santoro, Luke Marris, Colin J Akerman, and Geoffrey Hinton. Backpropagation and the brain. Nature Reviews Neuroscience, 21(6):335–346, 2020. ",
+        "bbox": [
+            173,
+            431,
+            821,
+            460
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Siegrid Lowel and Wolf Singer. Selection of intrinsic horizontal connections in the visual cortex by correlated neuronal activity. Science, 255(5041):209–212, 1992. ",
+        "bbox": [
+            174,
+            469,
+            821,
+            500
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Timothee Masquelier and Simon J Thorpe. Unsupervised learning of visual features through spike´ timing dependent plasticity. PLoS computational biology, 3(2):e31, 2007. ",
+        "bbox": [
+            173,
+            508,
+            825,
+            539
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Milad Mozafari, Saeed Reza Kheradpisheh, Timothee Masquelier, Abbas Nowzari-Dalini, and Mo- ´ hammad Ganjtabesh. First-spike-based visual categorization using reward-modulated stdp. IEEE transactions on neural networks and learning systems, 29(12):6178–6190, 2018. ",
+        "bbox": [
+            173,
+            547,
+            825,
+            590
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Milad Mozafari, Mohammad Ganjtabesh, Abbas Nowzari-Dalini, Simon J Thorpe, and Timothee´ Masquelier. Bio-inspired digit recognition using reward-modulated spike-timing-dependent plasticity in deep convolutional networks. Pattern recognition, 94:87–95, 2019. ",
+        "bbox": [
+            176,
+            601,
+            821,
+            643
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Emre O Neftci, Hesham Mostafa, and Friedemann Zenke. Surrogate gradient learning in spiking neural networks: Bringing the power of gradient-based optimization to spiking neural networks. IEEE Signal Processing Magazine, 36(6):51–63, 2019. ",
+        "bbox": [
+            176,
+            654,
+            823,
+            696
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Priyadarshini Panda and Kaushik Roy. Unsupervised regenerative learning of hierarchical features in spiking deep networks for object recognition. In 2016 International Joint Conference on Neural Networks (IJCNN), pp. 299–306. IEEE, 2016. ",
+        "bbox": [
+            174,
+            707,
+            825,
+            750
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Adam Paszke, Sam Gross, Francisco Massa, Adam Lerer, James Bradbury, Gregory Chanan, Trevor Killeen, Zeming Lin, Natalia Gimelshein, Luca Antiga, Alban Desmaison, Andreas Kopf, Edward Yang, Zachary DeVito, Martin Raison, Alykhan Tejani, Sasank Chilamkurthy, Benoit Steiner, Lu Fang, Junjie Bai, and Soumith Chintala. Pytorch: An imperative style, high-performance deep learning library. In H. Wallach, H. Larochelle, A. Beygelzimer, F. d'Alche-Buc, ´ E. Fox, and R. Garnett (eds.), Advances in Neural Information Processing Systems 32, pp. 8024–8035. Curran Associates, Inc., 2019. URL http://papers.neurips.cc/paper/ 9015-pytorch-an-imperative-style-high-performance-deep-learning-library. pdf. ",
+        "bbox": [
+            174,
+            758,
+            897,
+            885
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Michael Pfeiffer and Thomas Pfeil. Deep learning with spiking neurons: opportunities and challenges. Frontiers in neuroscience, 12:774, 2018. ",
+        "bbox": [
+            174,
+            895,
+            823,
+            922
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Tomaso Poggio, Hrushikesh Mhaskar, Lorenzo Rosasco, Brando Miranda, and Qianli Liao. Why and when can deep-but not shallow-networks avoid the curse of dimensionality: a review. International Journal of Automation and Computing, 14(5):503–519, 2017. ",
+        "bbox": [
+            176,
+            103,
+            821,
+            146
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Roman Pogodin, Yash Mehta, Timothy P. Lillicrap, and Peter E. Latham. Towards biologically plausible convolutional networks, 2021. ",
+        "bbox": [
+            174,
+            155,
+            823,
+            184
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Daniel J Saunders, Hava T Siegelmann, Robert Kozma, et al. Stdp learning of image patches with convolutional spiking neural networks. In 2018 international joint conference on neural networks (IJCNN), pp. 1–7. IEEE, 2018. ",
+        "bbox": [
+            176,
+            193,
+            823,
+            234
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Daniel J Saunders, Devdhar Patel, Hananel Hazan, Hava T Siegelmann, and Robert Kozma. Locally connected spiking neural networks for unsupervised feature learning. Neural Networks, 119: 332–340, 2019. ",
+        "bbox": [
+            173,
+            244,
+            823,
+            286
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Daniel J Saunders, Cooper Sigrist, Kenneth Chaney, Robert Kozma, and Hava T Siegelmann. Minibatch processing for speed-up and scalability of spiking neural network simulation. In 2020 International Joint Conference on Neural Networks (IJCNN), pp. 1–8. IEEE, 2020. ",
+        "bbox": [
+            173,
+            295,
+            826,
+            338
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Johannes Schemmel, Daniel Bruderle, Andreas Gr ¨ ubl, Matthias Hock, Karlheinz Meier, and Se- ¨ bastian Millner. A wafer-scale neuromorphic hardware system for large-scale neural modeling. In 2010 IEEE International Symposium on Circuits and Systems (ISCAS), pp. 1947–1950. IEEE, 2010. ",
+        "bbox": [
+            173,
+            347,
+            825,
+            404
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Wolfram Schultz, Peter Dayan, and P Read Montague. A neural substrate of prediction and reward. Science, 275(5306):1593–1599, 1997. ",
+        "bbox": [
+            173,
+            412,
+            821,
+            441
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Myung Seok Shim and Peng Li. Biologically inspired reinforcement learning for mobile robot collision avoidance. In 2017 International Joint Conference on Neural Networks (IJCNN), pp. 3098–3105. IEEE, 2017. ",
+        "bbox": [
+            173,
+            450,
+            821,
+            493
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Richard S Sutton and Andrew G Barto. Reinforcement learning: An introduction. MIT press, 2018. ",
+        "bbox": [
+            169,
+            502,
+            823,
+            517
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Yuki Tatsunami and Masato Taki. Raftmlp: Do mlp-based models dream of winning over computer vision? arXiv preprint arXiv:2108.04384, 2021. ",
+        "bbox": [
+            169,
+            526,
+            823,
+            555
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Amirhossein Tavanaei and Anthony S Maida. A minimal spiking neural network to rapidly train and classify handwritten digits in binary and 10-digit tasks. International journal of advanced research in artificial intelligence, 4(7):1–8, 2015. ",
+        "bbox": [
+            176,
+            564,
+            823,
+            607
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Amirhossein Tavanaei, Masoud Ghodrati, Saeed Reza Kheradpisheh, Timothee Masquelier, and ´ Anthony Maida. Deep learning in spiking neural networks. Neural Networks, 111:47–63, 2019. ",
+        "bbox": [
+            171,
+            614,
+            823,
+            645
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Yujie Wu, Lei Deng, Guoqi Li, Jun Zhu, and Luping Shi. Spatio-temporal backpropagation for training high-performance spiking neural networks. Frontiers in neuroscience, 12:331, 2018. ",
+        "bbox": [
+            173,
+            652,
+            823,
+            683
+        ],
+        "page_idx": 11
+    }
+]