Add files using upload-large-folder tool

md/dev/TG8KACxEON/TG8KACxEON.md

@@ -0,0 +1,299 @@
+# Training language models to follow instructions with human feedback
+
+Long Ouyang∗ Jeff Wu∗ Xu Jiang∗ Diogo Almeida∗ Carroll L. Wainwright∗
+
+Pamela Mishkin∗ Chong Zhang Sandhini Agarwal Katarina Slama Alex Ray
+
+John Schulman Jacob Hilton Fraser Kelton Luke Miller Maddie Simens
+
+Amanda Askell† Peter Welinder Paul Christiano∗†
+
+Jan Leike∗
+
+Ryan Lowe∗
+
+OpenAI
+
+# Abstract
+
+Making language models bigger does not inherently make them better at following a user’s intent. For example, large language models can generate outputs that are untruthful, toxic, or simply not helpful to the user. In other words, these models are not aligned with their users. In this paper, we show an avenue for aligning language models with user intent on a wide range of tasks by fine-tuning with human feedback. Starting with a set of labeler-written prompts and prompts submitted through a language model API, we collect a dataset of labeler demonstrations of the desired model behavior, which we use to fine-tune GPT-3 using supervised learning. We then collect a dataset of rankings of model outputs, which we use to further fine-tune this supervised model using reinforcement learning from human feedback. We call the resulting models InstructGPT. In human evaluations on our prompt distribution, outputs from the 1.3B parameter InstructGPT model are preferred to outputs from the 175B GPT-3, despite having $1 0 0 \mathrm { x }$ fewer parameters. Moreover, InstructGPT models show improvements in truthfulness and reductions in toxic output generation while having minimal performance regressions on public NLP datasets. Even though InstructGPT still makes simple mistakes, our results show that fine-tuning with human feedback is a promising direction for aligning language models with human intent.
+
+# 1 Introduction
+
+Large language models (LMs) can be prompted to perform a range of natural language processing (NLP) tasks, given some examples of the task as input. However, these models often express unintended behaviors such as making up facts, generating biased or toxic text, or simply not following user instructions (Bender et al., 2021; Bommasani et al., 2021; Kenton et al., 2021; Weidinger et al., 2021; Tamkin et al., 2021; Gehman et al., 2020). This is because the language modeling objective used for many recent large LMs—predicting the next token on a webpage from the internet—is different from the objective “follow the user’s instructions helpfully and safely” (Radford et al., 2019; Brown et al., 2020; Fedus et al., 2021; Rae et al., 2021; Thoppilan et al., 2022). Thus, we say that the language modeling objective is misaligned. Averting these unintended behaviors is especially important for language models that are deployed and used in hundreds of applications.
+
+![](images/36c317e156d97ff18f68e828bb6161692c5c91c39bb9e1d8c247acd03ece3095.jpg)  
+Figure 1: Human evaluations of various models on the API prompt distribution, evaluated by how often outputs from each model were preferred to those from the 175B SFT model. Our InstructGPT models (PPO-ptx) as well as its variant trained without pretraining mix (PPO) significantly outperform the GPT-3 baselines (GPT, GPT prompted); outputs from our 1.3B PPO-ptx model are preferred to those from the 175B GPT-3. Error bars throughout the paper are $9 5 \%$ confidence intervals.
+
+We make progress on aligning language models by training them to act in accordance with the user’s intention (Leike et al., 2018). This encompasses both explicit intentions such as following instructions and implicit intentions such as staying truthful, and not being biased, toxic, or otherwise harmful. Using the language of Askell et al. (2021), we want language models to be helpful (they should help the user solve their task), honest (they shouldn’t fabricate information or mislead the user), and harmless (they should not cause physical, psychological, or social harm to people or the environment). We elaborate on the evaluation of these criteria in Section 3.5.
+
+We focus on fine-tuning approaches to aligning language models. Specifically, we use reinforcement learning from human feedback (RLHF; Christiano et al., 2017; Stiennon et al., 2020) to fine-tune GPT-3 to follow a broad class of written instructions (see Figure 2). This technique uses human preferences as a reward signal to fine-tune our models. We first hire a team of 40 contractors to label our data, based on their performance on a screening test (see Section 3.3 and Appendix B.1 for more details). We then collect a dataset of human-written demonstrations of the desired output behavior on (mostly English) prompts submitted to a language model API and some labeler-written prompts, and use this to train our supervised learning baselines. Next, we collect a dataset of human-labeled comparisons between outputs from our models on a larger set of API prompts. We then train a reward model (RM) on this dataset to predict which model output our labelers would prefer. Finally, we use this RM as a reward function and fine-tune our supervised learning baseline to maximize this reward using the PPO algorithm (Schulman et al., 2017). We illustrate this process in Figure 2. This procedure aligns the behavior of GPT-3 to the stated preferences of a specific group of people (mostly our labelers and researchers), rather than any broader notion of “human values”; we discuss this further in Appendix G.2. We call the resulting models InstructGPT.
+
+We mainly evaluate our models by having our labelers rate the quality of model outputs on our test set, consisting of prompts from held-out users (who are not represented in the training data). We also conduct automatic evaluations on a range of public NLP datasets. We train three model sizes (1.3B, 6B, and 175B parameters), and all of our models use the GPT-3 architecture. Our main findings are:
+
+Labelers significantly prefer InstructGPT outputs over outputs from GPT-3. Outputs from the 1.3B parameter InstructGPT model are preferred to outputs from the 175B GPT-3, despite having over $1 0 0 \mathrm { x }$ fewer parameters. These models have the same architecture, and differ only by the fact that InstructGPT is fine-tuned on our human data. This result holds true even when we add a few-shot prompt to GPT-3 to make it better at following instructions. Outputs from our 175B InstructGPT are preferred to 175B GPT-3 outputs $8 5 \pm 3 \%$ of the time, and preferred $7 1 \pm 4 \%$ of the time to few-shot 175B GPT-3. InstructGPT also generates more appropriate outputs according to our labelers.
+
+InstructGPT models show improvements in truthfulness over GPT-3. On the TruthfulQA benchmark, InstructGPT generates truthful and informative answers more often than GPT-3. On “closed-domain” tasks from our API prompt distribution, where the output should not contain information that is not present in the input, InstructGPT models make up information not present in the input about half as often as GPT-3 (a $21 \%$ vs. $41 \%$ hallucination rate, respectively).
+
+InstructGPT shows small improvements in toxicity over GPT-3, but not bias. To measure toxicity, we use the RealToxicityPrompts dataset (Gehman et al., 2020) and conduct both automatic and human evaluations. InstructGPT models generate about $25 \%$ fewer toxic outputs than GPT-3 when prompted to be respectful. InstructGPT does not significantly improve over GPT-3 on the Winogender (Rudinger et al., 2018) and CrowSPairs (Nangia et al., 2020) datasets.
+
+We can minimize performance regressions on public NLP datasets by modifying our RLHF fine-tuning procedure. During RLHF fine-tuning, we observe performance regressions compared to GPT-3 on certain public NLP datasets. We can greatly reduce the performance regressions on these datasets by mixing PPO updates with updates that increase the log likelihood of the pretraining distribution (PPO-ptx), without compromising labeler preference scores.
+
+Our models generalize to the preferences of “held-out” labelers that did not produce any training data. To test the generalization of our models, we conduct a preliminary experiment with held-out labelers, and find that they prefer InstructGPT outputs to outputs from GPT-3 at about the same rate as our training labelers. However, more work is needed to study how these models perform on broader groups of users, and how they perform on inputs where humans disagree about the desired behavior.
+
+Public NLP datasets are not reflective of how our language models are used. We compare GPT-3 fine-tuned on our human preference data (i.e. InstructGPT) to GPT-3 fine-tuned on two different compilations of public NLP tasks: the FLAN (Wei et al., 2021) and T0 (Sanh et al., 2021) (in particular, the $\mathrm { T 0 + + }$ variant). These datasets consist of a variety of NLP tasks, combined with natural language instructions for each task. On our API prompt distribution, our FLAN and T0 models perform slightly worse than our SFT baseline, and labelers significantly prefer InstructGPT to these models.
+
+InstructGPT models show promising generalization to instructions outside of the RLHF finetuning distribution. We qualitatively probe InstructGPT’s capabilities, and find that it is able to follow instructions for summarizing code, answer questions about code, and sometimes follows instructions in different languages, despite these instructions being very rare in the fine-tuning distribution. This result is exciting because it suggests that our models are able to generalize the notion of “following instructions.” They retain some alignment even on tasks for which they get very little direct supervision.
+
+InstructGPT still makes simple mistakes. For example, InstructGPT can still fail to follow instructions, make up facts, give long hedging answers to simple questions, or fail to detect instructions with false premises.
+
+Overall, our results indicate that fine-tuning large language models using human preferences significantly improves their behavior on a wide range of tasks, though much work remains to be done to improve their safety and reliability.
+
+# 2 Related work
+
+Research on alignment and learning from human feedback. We build on previous techniques to align models with human intentions, particularly reinforcement learning from human feedback (RLHF). Originally developed for training simple robots in simulated environments and Atari games (Christiano et al., 2017; Ibarz et al., 2018), it has recently been applied to fine-tuning language models to summarize text (Ziegler et al., 2019; Stiennon et al., 2020; Böhm et al., 2019; Wu et al., 2021). This work is in turn influenced by similar work using human feedback as a reward in domains such as dialogue (Jaques et al., 2019; Yi et al., 2019; Hancock et al., 2019), translation (Kreutzer et al., 2018; Bahdanau et al., 2016), semantic parsing (Lawrence and Riezler, 2018), story generation (Zhou and Xu, 2020), review generation (Cho et al., 2018), and evidence extraction (Perez et al., 2019). In concurrent work, Askell et al. (2021); Bai et al. (2022) propose language assistants as a testbed for alignment research, and train models using RLHF. Our work can be seen as a direct application of RLHF to aligning language models on a broad distribution of language tasks.
+
+![](images/29a11bec338a1b6613290bf164124faed43e910f1e42f4ca55025fa358f15994.jpg)  
+Step1 Collect demonstration data, and train a supervised policy.
+
+![](images/d21aa252e64334e240b87b770cc3feced17f6b3d991daffa45552dd4ac355cf3.jpg)  
+Step2 Collect comparison data, and train a reward model.
+
+![](images/c93137012283372d57282c50dd82956bc210d92fd468b356668d6bf07b1f71b4.jpg)  
+Step3 Optimize a policy against the reward model using reinforcement learning.   
+Figure 2: A diagram illustrating the three steps of our method: (1) supervised fine-tuning (SFT), (2) reward model (RM) training, and (3) reinforcement learning via proximal policy optimization (PPO) on this reward model. Blue arrows indicate that this data is used to train one of our models. In Step 2, boxes A-D are samples from our models that get ranked by labelers.
+
+Training language models to follow instructions. Our work is also related to research on crosstask generalization in language models, where LMs are fine-tuned on a broad range of public NLP datasets (usually prefixed with an appropriate instruction) and evaluated on a different set of NLP tasks. There has been a range of work in this domain (Yi et al., 2019; Mishra et al., 2021; Wei et al., 2021; Khashabi et al., 2020; Sanh et al., 2021; Aribandi et al., 2021), which differ in training and evaluation data, formatting of instructions, size of pretrained models, and other experimental details.
+
+Mitigating the harms of language models. A goal of modifying the behavior of language models is to mitigate the harms of these models when they’re deployed in the real world. These risks have been extensively documented (Bender et al., 2021; Bommasani et al., 2021; Kenton et al., 2021; Weidinger et al., 2021; Tamkin et al., 2021). Language models can produce biased outputs (Dhamala et al., 2021; Liang et al., 2021; Manela et al., 2021; Caliskan et al., 2017; Kirk et al., 2021), leak private data (Carlini et al., 2021), generate misinformation (Solaiman et al., 2019; Buchanan et al., 2021), and be used maliciously; for a thorough review we direct the reader to Weidinger et al. (2021). There are many ways to mitigate these harms, including by fine-tuning on a small, valuetargeted dataset (Solaiman and Dennison, 2021), filtering the pretraining dataset (Ngo et al., 2021), or human-in-the-loop data collection (Dinan et al., 2019; Xu et al., 2020).
+
+# 3 Methods and experimental details
+
+# 3.1 High-level methodology
+
+Our methodology follows that of Ziegler et al. (2019) and Stiennon et al. (2020), who applied it in the stylistic continuation and summarization domains. We start with a pretrained language model (Radford et al., 2019; Brown et al., 2020; Fedus et al., 2021; Rae et al., 2021; Thoppilan et al., 2022), a distribution of prompts on which we want our model to produce aligned outputs, and a team of trained human labelers (see Section 3.3 for details). We then apply the following three steps (Figure 2).
+
+Step 1: Collect demonstration data, and train a supervised policy. Our labelers provide demonstrations of the desired behavior on the input prompt distribution (see Section 3.2 for details on this distribution). We then fine-tune a pretrained GPT-3 model on this data using supervised learning.
+
+Step 2: Collect comparison data, and train a reward model. We collect a dataset of comparisons between model outputs, where labelers indicate which output they prefer for a given input. We then train a reward model to predict the human-preferred output.
+
+Step 3: Optimize a policy against the reward model using PPO. We use the output of the RM as a scalar reward. We fine-tune the supervised policy to optimize this reward using the PPO algorithm (Schulman et al., 2017).
+
+Steps 2 and 3 can be iterated continuously; more comparison data is collected on the current best policy, which is used to train a new RM and then a new policy. In practice, most of our comparison data comes from our supervised policies, with some coming from our PPO policies.
+
+# 3.2 Dataset
+
+Our prompt dataset consists primarily of text prompts submitted to a commercial language model API, as well as a small number of labeler-written prompts. These prompts are very diverse and include generation, question answering, dialog, summarization, extractions, and other natural language tasks (see Appendix A). Our dataset is over $9 6 \%$ English. We heuristically deduplicate prompts, and ensure that the validation and test sets contain no data from users whose data is in the training set. We also filter prompts containing personally identifiable information (PII).
+
+From these prompts, we produce three different datasets used in our fine-tuning procedure: (1) our SFT dataset, with labeler demonstrations used to train our SFT models, (2) our RM dataset, with labeler rankings of model outputs used to train our RMs, and (3) our PPO dataset, without any human labels, which are used as inputs for RLHF fine-tuning. The SFT dataset contains about $1 3 \mathrm { k }$ training prompts (from the API and labeler-written), the RM dataset has 33k training prompts (from the API and labeler-written), and the PPO dataset has 31k training prompts (only from the API). More details on dataset sizes are provided in Table 3.
+
+# 3.3 Human data collection
+
+To produce our demonstration and comparison data, and to conduct our main evaluations, we hired a team of about 40 contractors on Upwork and through ScaleAI. Compared to earlier work that collects human preference data on the task of summarization (Ziegler et al., 2019; Stiennon et al., 2020; Wu et al., 2021), our inputs span a much broader range of tasks, and can occasionally include controversial and sensitive topics. Our aim was to select a group of labelers who were sensitive to the preferences of different demographic groups, and who were good at identifying outputs that were potentially harmful. Thus, we conducted a screening test designed to measure labeler performance on these axes (see Appendix B.1). As an initial study to see how well our model generalizes to the preferences of other labelers, we hire a separate set of labelers who do not produce any of the training data. These labelers are sourced from the same vendors, but do not undergo a screening test.
+
+Despite the complexity of the task, we find that inter-annotator agreement rates are quite high: training labelers agree with each-other $7 2 . 6 \pm 1 . 5 \%$ of the time, while for held-out labelers this number is $7 7 . 3 \pm 1 . 3 \%$ . For comparison, in the summarization work of Stiennon et al. (2020) researcher-researcher agreement was $7 3 \pm 4 \%$ .
+
+# 3.4 Models
+
+Starting from GPT-3 (Brown et al., 2020), we train models with three different techniques:
+
+Supervised fine-tuning (SFT). We fine-tune GPT-3 on our labeler demonstrations using supervised learning. We trained for 16 epochs, using a cosine learning rate decay, and residual dropout of 0.2. We do our final SFT model selection based on the RM score on the validation set. Similarly to Wu et al. (2021), we find that our SFT models overfit on validation loss after 1 epoch; however, we find that training for more epochs helps both the RM score and human preference ratings.
+
+Reward modeling (RM). We fine-tune GPT-3 to take in a prompt and response, and output a scalar reward. In this paper we only use 6B RMs, as this saves a lot of compute, and we found that 175B RM training could be unstable and thus was less suitable to be used as the value function during RL (see Appendix D for more details).
+
+In Stiennon et al. (2020), the RM is trained on a dataset of comparisons between two model outputs on the same input. They use a cross-entropy loss, with the comparisons as labels—the difference in rewards represents the log odds that one response will be preferred to the other by a human labeler. In order to speed up comparison collection, we have labelers rank between $K = 4$ and $K = 9$ responses, and train on all $\binom { K } { 2 }$ comparisons from each prompt as a single batch element, for computational efficiency (see Appendix D. The loss function for the RM becomes:
+
+$$
+\log { \left( \theta \right) } = - \frac { 1 } { { \binom { K } { 2 } } } E _ { \left( x , y _ { w } , y _ { l } \right) \sim D } \left[ \log { \left( \sigma \left( r _ { \theta } \left( x , y _ { w } \right) - r _ { \theta } \left( x , y _ { l } \right) \right) \right) } \right]
+$$
+
+where $r _ { \theta } ( x , y )$ is the scalar output of the reward model for prompt $x$ and completion $y$ with parameters $\theta$ , $y _ { w }$ is the preferred completion out of the pair of $y _ { w }$ and $y _ { l }$ , and $D$ is the comparison dataset.
+
+Reinforcement learning (RL). Again following Stiennon et al. (2020), we fine-tuned the SFT model using PPO (Schulman et al., 2017). The environment is a bandit environment which presents a random user prompt and expects a response to the prompt. Given the prompt and response, it produces a reward determined by the reward model and ends the episode. In addition, we add a per-token KL penalty from the SFT model at each token to mitigate over-optimization of the reward model. The value function is initialized from the RM. We call these models “PPO.”
+
+We also experiment with mixing the pretraining gradients into the PPO gradients, in order to fix the performance regressions on public NLP datasets (see Appendix D.4). We call these models “PPO-ptx.” Unless otherwise specified, in this paper InstructGPT refers to the PPO-ptx models.
+
+Baselines. We compare the performance of our PPO models to our SFT models and GPT-3. We also compare to GPT-3 when it is provided a few-shot prefix to ‘prompt’ it into an instruction-following mode (GPT-3-prompted). This prefix is prepended to the user-specified instruction.
+
+We additionally compare InstructGPT to fine-tuning 175B GPT-3 on the FLAN (Wei et al., 2021) and T0 (Sanh et al., 2021) datasets, which both consist of a variety of NLP tasks, combined with natural language instructions for each task (they differ in the NLP datasets included, and the style of instructions used). We fine-tune them on approximately 1 million examples and choose the checkpoint which obtains the highest RM score on the validation set (see Appendix D for more details).
+
+# 3.5 Evaluation
+
+Following Askell et al. (2021), we say our models are aligned if they are helpful, truthful, and harmless (we elaborate in Appendix C.2). We divide our quantitative evaluations into two parts:
+
+Evaluations on API distribution. Our main metric is human preference ratings on a held out set of prompts from the same source as our training distribution. When using prompts from the API for evaluation, we only select prompts by users we haven’t included in training. For each model we calculate how often its outputs are preferred to a baseline policy; we choose our 175B SFT model as the baseline since its performance is near the middle of the pack. Additionally, we ask labelers to judge the overall quality of each response on a 1-7 Likert scale and collect a range of metadata for each model output (see Table 11). In particular, we collect data that aims to capture different aspects of behavior in a deployed model that could end up being harmful: we have labelers evaluate whether an output is inappropriate in the context of a customer assistant, denigrates a protected class, or contains sexual or violent content.
+
+![](images/265ce500d8e515a106dacfa49cea6240b983708ef116375cc98361fadecf8d7f.jpg)  
+Figure 3: Preference results of our models, measured by winrate against the 175B SFT model.
+
+![](images/e4beefb4743caf615365017d28d57ee06a55fb7a3546c7df6bfd0b116b08fedf.jpg)  
+Figure 4: Metadata results on the API distribution, averaged over model sizes.
+
+Evaluations on public NLP datasets. We evaluate on two types of public datasets: those that capture an aspect of language model safety, particularly truthfulness, toxicity, and bias, and those that capture zero-shot performance on traditional NLP tasks like question answering, reading comprehension, and summarization. We also conduct human evaluations on the RealToxicityPrompts dataset (Gehman et al., 2020).
+
+# 4 Results
+
+# 4.1 Results on the API distribution
+
+Labelers significantly prefer InstructGPT outputs over outputs from GPT-3. On our test set, our labelers significantly prefer InstructGPT outputs across model sizes (Figure 1). We find that GPT-3 outputs perform the worst, and one can obtain significant step-size improvements by using a well-crafted few-shot prompt (GPT-3 (prompted)), then by training on demonstrations using supervised learning (SFT), and finally by training on comparison data using PPO. Adding updates on the pretraining mix during PPO does not lead to large changes in labeler preference. To illustrate the magnitude of our gains: when compared directly, 175B InstructGPT outputs are preferred to GPT-3 outputs $8 5 \pm 3 \%$ of the time, and preferred $7 1 \pm 4 \%$ of the time to few-shot GPT-3.
+
+In Figure 4 we show that labelers also rate InstructGPT outputs favorably along several more concrete axes. Specifically, compared to GPT-3, InstructGPT outputs are more appropriate in the context of a customer assistant, more often follow explicit constraints defined in the instruction (e.g. “Write your answer in 2 paragraphs or less.”), are less likely to fail to follow the correct instruction entirely, and make up facts (‘hallucinate’) less often in closed-domain tasks.
+
+![](images/2d12f6fc8de06781b0a0e879fab4947632f3ea286c7731fdb68b34054a7464f4.jpg)  
+Figure 5: (a) Comparing our models with GPT-3 fine-tuned on the FLAN and T0 datasets, in terms of 1-7 Likert scores, on our prompt distribution. (b) Human evaluations on the TruthfulQA dataset. Gray bars indicate ratings of truthfulness; colored bars indicate ratings of truthfulness and informativeness. (c) Human evaluations on RealToxicityPrompts, with and without "respectful" instructions.
+
+Our models generalize to the preferences of "held-out" labelers that did not produce any training data. Held-out labelers have similar ranking preferences as workers who we used to produce training data (see Figure 3). In particular, according to held-out workers, all of our InstructGPT models still greatly outperform the GPT-3 baselines. Thus, our InstructGPT models aren’t simply overfitting to the preferences of our training labelers.
+
+Public NLP datasets are not reflective of how our language models are used. In Figure 5a, we also compare InstructGPT to our 175B GPT-3 baselines fine-tuned on the FLAN (Wei et al., 2021) and T0 (Sanh et al., 2021) datasets (see Appendix D for details). We find that these models perform better than GPT-3, on par with GPT-3 with a well-chosen prompt, and worse than our SFT baseline. This indicates that these datasets are not sufficiently diverse to improve performance on our API prompt distribution. We believe this is partly because academic datasets focus on tasks where performance is easily measured, like classification and QA, while our API distribution consists of mostly (about $57 \%$ ) open-ended generation tasks.
+
+# 4.2 Results on public NLP datasets
+
+InstructGPT models show improvements in truthfulness over GPT-3. As measured by human evaluations on the TruthfulQA dataset, our PPO models show small but significant improvements in generating truthful and informative outputs compared to GPT-3 (see Figure 5b). This behavior is the default: our models do not have to be specifically instructed to tell the truth to exhibit improved truthfulness. Interestingly, the exception is our 1.3B PPO-ptx model, which performs slightly worse than a GPT-3 model of the same size. Our improvements in truthfulness are also evidenced by the fact that our PPO models hallucinate less often on closed-domain tasks (Figure 4).
+
+InstructGPT shows small improvements in toxicity over GPT-3, but not bias. We first evaluate our models on the RealToxicityPrompts dataset (Gehman et al., 2020) using human evaluations. Our results are in Figure 5c. We find that, when instructed to produce a safe and respectful output (“respectful prompt”), InstructGPT models generate less toxic outputs than those from GPT-3 according to the Perspective API. This advantage disappears when the respectful prompt is removed (“no prompt”). We see similar results when evaluating using the Perspective API (Appendix F.7).
+
+We can minimize performance regressions on public NLP datasets by modifying our RLHF fine-tuning procedure. In Figure 25 we show that adding pretraining updates to our PPO finetuning (PPO-ptx) mitigates performance regressions on public NLP datasets, and even surpasses GPT-3 on HellaSwag. The performance of the PPO-ptx model still lags behind GPT-3 on DROP, SQuADv2, and translation; more work is needed to study and further eliminate these performance regressions. We also find that mixing in pretraining updates performs better than the simpler solution of increasing the KL coefficient (Figure 36).
+
+# 4.3 Qualitative results
+
+InstructGPT models show promising generalization to instructions outside of the RLHF finetuning distribution. In particular, we find that InstructGPT shows ability to follow instructions in non-English languages, and perform summarization and question-answering for code. This is interesting because non-English languages and code form a tiny minority of our fine-tuning data, and it suggests that, in some cases, alignment methods could generalize to producing the desired behavior on inputs that humans did not directly supervise. We show some qualitative examples in Figure 26.
+
+InstructGPT still makes simple mistakes. In interacting with our 175B PPO-ptx model, we have noticed it can still make simple mistakes, despite its strong performance on many different language tasks. To give a few examples: (1) when given an instruction with a false premise, the model sometimes incorrectly assumes the premise is true, (2) the model can overly hedge; when given a simple question, it can sometimes say that there is no one answer to the question and give multiple possible answers, even when there is one fairly clear answer from the context, and (3) the model’s performance degrades when instructions contain multiple explicit constraints (e.g. “list 10 movies made in the 1930’s set in France”) or when constraints can be challenging for language models (e.g. writing a summary in a specified number of sentences).
+
+We show some examples of these behaviors in Figure 27. We suspect that behavior (2) emerges partly because we instruct labelers to reward epistemic humility; thus, they may tend to reward outputs that hedge, and this gets picked up by our reward model. We suspect that behavior (1) occurs because there are few prompts in the training set that assume false premises, and our models don’t generalize well to these examples. We believe both these behaviors could be dramatically reduced with adversarial data collection (Dinan et al., 2019).
+
+# 5 Discussion
+
+# 5.1 Implications for alignment research
+
+Our approach to alignment research in this work is iterative: we are improving the alignment of current AI systems instead of focusing abstractly on aligning AI systems that don’t yet exist, which provides us with a clear empirical feedback loop of what works and what does not. We believe that this feedback loop is essential to refine our alignment techniques, and it forces us to keep pace with progress in machine learning.
+
+From this work, we can draw lessons for alignment research more generally. First, the cost of increasing model alignment is modest relative to pretraining. Training our 175B SFT model requires 4.9 petaflops/s-days and training our 175B PPO-ptx model requires 60 petaflops/s-days, compared to 3,640 petaflops/s-days for GPT-3 (Brown et al., 2020). At the same time, our results show that RLHF is very effective at making language models more helpful to users, more so than a $1 0 0 \mathrm { x }$ model size increase. This suggests that right now increasing investments in alignment of existing language models is more cost-effective than training larger models. Second, we’ve seen some evidence that InstructGPT generalizes ‘following instructions’ to settings that we don’t supervise it in. This is an important property because it’s prohibitively expensive to have humans supervise models on every task they perform. Finally, we were able to mitigate most of the performance degradations introduced by our fine-tuning. If this was not the case, these performance degradations would constitute an alignment tax—an additional cost for aligning the model. Any alignment technique with a high tax might not see adoption, and thus such a tax is important to avoid.
+
+# 5.2 Limitations
+
+Methodology. The behavior of our InstructGPT models is determined in part by the human feedback obtained from our contractors. Some of the labeling tasks rely on value judgments that may be impacted by the identity of our contractors, their beliefs, cultural backgrounds, and personal history. We kept our team of contractors small because this facilitates high-bandwidth communication with a smaller set of contractors who are doing the task full-time. However, this group is clearly not representative of the full spectrum of people affected by these models. As a simple example, our labelers are primarily English-speaking and our data consists almost entirely of English instructions.
+
+Models. Our models are neither fully aligned nor fully safe; they still generate toxic or biased outputs, make up facts, and generate sexual and violent content without explicit prompting. They can also fail to generate reasonable outputs on some inputs; we show some examples of this in Figure 27. Perhaps the greatest limitation of our models is that, in most cases, they follow the user’s instruction, even if that could lead to harm in the real world. For example, when prompting the models to be maximally biased, InstructGPT generates more toxic outputs than equivalently-sized GPT-3 models.
+
+# 5.3 Broader impacts
+
+This work is motivated by our aim to increase the positive impact of large language models by training them to do what a given set of humans want them to do. By default, language models optimize the next word prediction objective, which is only a proxy for what we want these models to do. Our results indicate that our techniques hold promise for making language models more helpful, truthful, and harmless. In the longer term, alignment failures could lead to more severe consequences, particularly if these models are deployed in safety-critical situations.
+
+However, making language models better at following user intentions also makes them easier to misuse. It may be easier to use these models to generate convincing misinformation, or hateful or abusive content. Alignment techniques are not a panacea for resolving safety issues associated with large language models; rather, they should be used as one tool in a broader safety ecosystem. Aside from intentional misuse, there are many domains where large language models should be deployed only with great care, or not at all. Examples include high-stakes domains such as medical diagnoses, classifying people based on protected characteristics, determining eligibility for credit, employment, or housing, generating political advertisements, and law enforcement.
+
+Finally, the question of who these models are aligned to is extremely important, and will significantly affect whether the net impact of these models is positive or negative; we discuss this in Appendix G.2.
+
+# Acknowledgements
+
+First, we would like to thank Lilian Weng, Jason Kwon, Boris Power, Che Chang, Josh Achiam, Steven Adler, Gretchen Krueger, Miles Brundage, Tyna Eloundou, Gillian Hadfield, Irene Soliaman, Christy Dennison, Daniel Ziegler, William Saunders, Beth Barnes, Cathy Yeh, Nick Cammaratta, Jonathan Ward, Matt Knight, Pranav Shyam, Alec Radford, and others at OpenAI for discussions throughout the course of the project that helped shape our research direction. We thank Brian Green, Irina Raicu, Subbu Vincent, Varoon Mathur, Kate Crawford, Su Lin Blodgett, Bertie Vidgen, and Paul Röttger for discussions and feedback on our approach. Finally, we thank Sam Bowman, Matthew Rahtz, Ben Mann, Liam Fedus, Helen Ngo, Josh Achiam, Leo Gao, Jared Kaplan, Cathy Yeh, Miles Brundage, Gillian Hadfield, Cooper Raterink, Gretchen Krueger, Tyna Eloundou, Rafal Jakubanis, and Steven Adler for providing feedback on this paper. We’d also like to thank Owain Evans and Stephanie Lin for pointing out the fact that the automatic TruthfulQA metrics were overstating the gains of our PPO models.
+
+Thanks to those who contributed in various ways to the infrastructure used to train and deploy our models, including: Daniel Ziegler, William Saunders, Brooke Chan, Dave Cummings, Chris Hesse, Shantanu Jain, Michael Petrov, Greg Brockman, Felipe Such, Alethea Power, and the entire OpenAI supercomputing team. We’d also like to thank Suchir Balaji for help with recalibration, to Alper Ercetin and Justin Wang for designing the main diagram in this paper, and to the OpenAI Comms team for helping with the release, including: Steve Dowling, Hannah Wong, Natalie Summers, and Elie Georges.
+
+Finally, we want to thank our labelers, without whom this work would not have been possible: Meave Fryer, Sara Tirmizi, James Carroll, Jian Ouyang, Michelle Brothers, Conor Agnew, Joe Kwon, John Morton, Emma Duncan, Delia Randolph, Kaylee Weeks, Alexej Savreux, Siam Ahsan, Rashed Sorwar, Atresha Singh, Muhaiminul Rukshat, Caroline Oliveira, Juan Pablo Castaño Rendón, Atqiya Abida Anjum, Tinashe Mapolisa, Celeste Fejzo, Caio Oleskovicz, Salahuddin Ahmed, Elena Green, Ben Harmelin, Vladan Djordjevic, Victoria Ebbets, Melissa Mejia, Emill Jayson Caypuno, Rachelle Froyalde, Russell M. Bernandez, Jennifer Brillo, Jacob Bryan, Carla Rodriguez, Evgeniya Rabinovich, Morris Stuttard, Rachelle Froyalde, Roxanne Addison, Sarah Nogly, Chait Singh.
+
+# 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? [Yes]   
+(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)? [No]   
+(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)? [Yes]   
+(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)? [No] : we provide some info on the amount of compute used in the Discussion section.
+
+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]   
+(c) Did you include any new assets either in the supplemental material or as a URL? [No]   
+(d) Did you discuss whether and how consent was obtained from people whose data you’re using/curating? [Yes]   
+(e) Did you discuss whether the data you are using/curating contains personally identifiable information or offensive content? [Yes] : PII was removed, the dataset contains some offensive content.
+
+5. If you used crowdsourcing or conducted research with human subjects...
+
+(a) Did you include the full text of instructions given to participants and screenshots, if applicable? [No] : we provide excerpts of instructions given to labelers in the Appendix, but the full instructions are very long.   
+(b) Did you describe any potential participant risks, with links to Institutional Review Board (IRB) approvals, if applicable? [No]   
+(c) Did you include the estimated hourly wage paid to participants and the total amount spent on participant compensation? [No] : though we provide lots of information about labelers, including a labeler satisfaction survey, in the Appendix.
+
+# References
+
+Achiam, J., Held, D., Tamar, A., and Abbeel, P. (2017). Constrained policy optimization. In International Conference on Machine Learning, pages 22–31. PMLR.   
+Anthony, T., Tian, Z., and Barber, D. (2017). Thinking fast and slow with deep learning and tree search. arXiv preprint arXiv:1705.08439.   
+Aribandi, V., Tay, Y., Schuster, T., Rao, J., Zheng, H. S., Mehta, S. V., Zhuang, H., Tran, V. Q., Bahri, D., Ni, J., et al. (2021). Ext5: Towards extreme multi-task scaling for transfer learning. arXiv preprint arXiv:2111.10952.   
+Askell, A., Bai, Y., Chen, A., Drain, D., Ganguli, D., Henighan, T., Jones, A., Joseph, N., Mann, B., DasSarma, N., et al. (2021). A general language assistant as a laboratory for alignment. arXiv preprint arXiv:2112.00861.   
+Bahdanau, D., Brakel, P., Xu, K., Goyal, A., Lowe, R., Pineau, J., Courville, A., and Bengio, Y. (2016). An actor-critic algorithm for sequence prediction. arXiv preprint arXiv:1607.07086.   
+Bai, Y., Jones, A., Ndousse, K., Askell, A., Chen, A., DasSarma, N., Drain, D., Fort, S., Ganguli, D., Henighan, T., et al. (2022). Training a helpful and harmless assistant with reinforcement learning from human feedback. arXiv preprint arXiv:2204.05862.   
+Bender, E. M., Gebru, T., McMillan-Major, A., and Shmitchell, S. (2021). On the dangers of stochastic parrots: Can language models be too big? In Proceedings of the 2021 ACM Conference on Fairness, Accountability, and Transparency, pages 610–623.   
+Böhm, F., Gao, Y., Meyer, C. M., Shapira, O., Dagan, I., and Gurevych, I. (2019). Better rewards yield better summaries: Learning to summarise without references. arXiv preprint arXiv:1909.01214.   
+Bojar, O., Chatterjee, R., Federmann, C., Haddow, B., Huck, M., Hokamp, C., Koehn, P., Logacheva, V., Monz, C., Negri, M., Post, M., Scarton, C., Specia, L., and Turchi, M. (2015). Findings of the 2015 workshop on statistical machine translation. In Proceedings of the Tenth Workshop on Statistical Machine Translation, pages 1–46, Lisbon, Portugal. Association for Computational Linguistics.   
+Bommasani, R., Hudson, D. A., Adeli, E., Altman, R., Arora, S., von Arx, S., Bernstein, M. S., Bohg, J., Bosselut, A., Brunskill, E., et al. (2021). On the opportunities and risks of foundation models. arXiv preprint arXiv:2108.07258.   
+Brown, T. B., Mann, B., Ryder, N., Subbiah, M., Kaplan, J., Dhariwal, P., Neelakantan, A., Shyam, P., Sastry, G., Askell, A., et al. (2020). Language models are few-shot learners. arXiv preprint arXiv:2005.14165.   
+Buchanan, B., Lohn, A., Musser, M., and Sedova, K. (2021). Truth, lies, and automation. Technical report, Center for the Study of Emerging Technology.   
+Caliskan, A., Bryson, J. J., and Narayanan, A. (2017). Semantics derived automatically from language corpora contain human-like biases. Science, 356(6334):183–186.   
+Carlini, N., Tramer, F., Wallace, E., Jagielski, M., Herbert-Voss, A., Lee, K., Roberts, A., Brown, T., Song, D., Erlingsson, U., et al. (2021). Extracting training data from large language models. In 30th USENIX Security Symposium (USENIX Security 21), pages 2633–2650.   
+Chen, M., Tworek, J., Jun, H., Yuan, Q., Pinto, H. P. d. O., Kaplan, J., Edwards, H., Burda, Y., Joseph, N., Brockman, G., et al. (2021). Evaluating large language models trained on code. arXiv preprint arXiv:2107.03374.   
+Cho, W. S., Zhang, P., Zhang, Y., Li, X., Galley, M., Brockett, C., Wang, M., and Gao, J. (2018). Towards coherent and cohesive long-form text generation. arXiv preprint arXiv:1811.00511.   
+Choi, E., He, H., Iyyer, M., Yatskar, M., Yih, W.-t., Choi, Y., Liang, P., and Zettlemoyer, L. (2018). Quac: Question answering in context. In Proceedings of the 2018 Conference on Empirical Methods in Natural Language Processing, pages 2174–2184.   
+Christiano, P. F., Leike, J., Brown, T., Martic, M., Legg, S., and Amodei, D. (2017). Deep reinforcement learning from human preferences. In Advances in Neural Information Processing Systems, pages 4299–4307.   
+Dathathri, S., Madotto, A., Lan, J., Hung, J., Frank, E., Molino, P., Yosinski, J., and Liu, R. (2019). Plug and play language models: A simple approach to controlled text generation. arXiv preprint arXiv:1912.02164.   
+Dhamala, J., Sun, T., Kumar, V., Krishna, S., Pruksachatkun, Y., Chang, K.-W., and Gupta, R. (2021). Bold: Dataset and metrics for measuring biases in open-ended language generation. In Proceedings of the 2021 ACM Conference on Fairness, Accountability, and Transparency, pages 862–872.   
+Dinan, E., Humeau, S., Chintagunta, B., and Weston, J. (2019). Build it break it fix it for dialogue safety: Robustness from adversarial human attack. arXiv preprint arXiv:1908.06083.   
+Dua, D., Wang, Y., Dasigi, P., Stanovsky, G., Singh, S., and Gardner, M. (2019). Drop: A reading comprehension benchmark requiring discrete reasoning over paragraphs. arXiv preprint arXiv:1903.00161.   
+Fedus, W., Zoph, B., and Shazeer, N. (2021). Switch transformers: Scaling to trillion parameter models with simple and efficient sparsity. arXiv preprint arXiv:2101.03961.   
+Gabriel, I. (2020). Artificial intelligence, values, and alignment. Minds and machines, 30(3):411–437.   
+Gehman, S., Gururangan, S., Sap, M., Choi, Y., and Smith, N. A. (2020). Realtoxicityprompts: Evaluating neural toxic degeneration in language models. arXiv preprint arXiv:2009.11462.   
+Hancock, B., Bordes, A., Mazare, P.-E., and Weston, J. (2019). Learning from dialogue after deployment: Feed yourself, chatbot! arXiv preprint arXiv:1901.05415.   
+Ibarz, B., Leike, J., Pohlen, T., Irving, G., Legg, S., and Amodei, D. (2018). Reward learning from human preferences and demonstrations in atari. In Advances in neural information processing systems, pages 8011–8023.   
+Jaques, N., Ghandeharioun, A., Shen, J. H., Ferguson, C., Lapedriza, A., Jones, N., Gu, S., and Picard, R. (2019). Way off-policy batch deep reinforcement learning of implicit human preferences in dialog. arXiv preprint arXiv:1907.00456.   
+Kenton, Z., Everitt, T., Weidinger, L., Gabriel, I., Mikulik, V., and Irving, G. (2021). Alignment of language agents. arXiv preprint arXiv:2103.14659.   
+Keskar, N. S., McCann, B., Varshney, L. R., Xiong, C., and Socher, R. (2019). Ctrl: A conditional transformer language model for controllable generation. arXiv preprint arXiv:1909.05858.   
+Khashabi, D., Min, S., Khot, T., Sabharwal, A., Tafjord, O., Clark, P., and Hajishirzi, H. (2020). Unifiedqa: Crossing format boundaries with a single qa system. arXiv preprint arXiv:2005.00700.   
+Kirk, H., Jun, Y., Iqbal, H., Benussi, E., Volpin, F., Dreyer, F. A., Shtedritski, A., and Asano, Y. M. (2021). How true is gpt-2? an empirical analysis of intersectional occupational biases. arXiv preprint arXiv:2102.04130.   
+Krause, B., Gotmare, A. D., McCann, B., Keskar, N. S., Joty, S., Socher, R., and Rajani, N. F. (2020). Gedi: Generative discriminator guided sequence generation. arXiv preprint arXiv:2009.06367.   
+Kreutzer, J., Khadivi, S., Matusov, E., and Riezler, S. (2018). Can neural machine translation be improved with user feedback? arXiv preprint arXiv:1804.05958.   
+Lawrence, C. and Riezler, S. (2018). Improving a neural semantic parser by counterfactual learning from human bandit feedback. arXiv preprint arXiv:1805.01252.   
+Leike, J., Krueger, D., Everitt, T., Martic, M., Maini, V., and Legg, S. (2018). Scalable agent alignment via reward modeling: a research direction. arXiv preprint arXiv:1811.07871.   
+Liang, P. P., Wu, C., Morency, L.-P., and Salakhutdinov, R. (2021). Towards understanding and mitigating social biases in language models. In International Conference on Machine Learning, pages 6565–6576. PMLR.   
+Lin, S., Hilton, J., and Evans, O. (2021). Truthfulqa: Measuring how models mimic human falsehoods. arXiv preprint arXiv:2109.07958.   
+Manela, D. d. V., Errington, D., Fisher, T., van Breugel, B., and Minervini, P. (2021). Stereotype and skew: Quantifying gender bias in pre-trained and fine-tuned language models. arXiv preprint arXiv:2101.09688.   
+Mishra, S., Khashabi, D., Baral, C., and Hajishirzi, H. (2021). Cross-task generalization via natural language crowdsourcing instructions. arXiv preprint arXiv:2104.08773.   
+Nakano, R., Hilton, J., Balaji, S., Wu, J., Ouyang, L., Kim, C., Hesse, C., Jain, S., Kosaraju, V., Saunders, W., et al. (2021). Webgpt: Browser-assisted question-answering with human feedback. arXiv preprint arXiv:2112.09332.   
+Nallapati, R., Zhou, B., Gulcehre, C., Xiang, B., et al. (2016). Abstractive text summarization using sequence-to-sequence rnns and beyond. arXiv preprint arXiv:1602.06023.   
+Nangia, N., Vania, C., Bhalerao, R., and Bowman, S. R. (2020). CrowS-Pairs: A Challenge Dataset for Measuring Social Biases in Masked Language Models. In Proceedings of the 2020 Conference on Empirical Methods in Natural Language Processing, Online. Association for Computational Linguistics.   
+Ngo, H., Raterink, C., Araújo, J. G., Zhang, I., Chen, C., Morisot, A., and Frosst, N. (2021). Mitigating harm in language models with conditional-likelihood filtration. arXiv preprint arXiv:2108.07790.   
+Perez, E., Karamcheti, S., Fergus, R., Weston, J., Kiela, D., and Cho, K. (2019). Finding generalizable evidence by learning to convince q&a models. arXiv preprint arXiv:1909.05863.   
+Radford, A., Wu, J., Child, R., Luan, D., Amodei, D., and Sutskever, I. (2019). Language models are unsupervised multitask learners. OpenAI Blog, 1(8):9.   
+Rae, J. W., Borgeaud, S., Cai, T., Millican, K., Hoffmann, J., Song, F., Aslanides, J., Henderson, S., Ring, R., Young, S., et al. (2021). Scaling language models: Methods, analysis & insights from training gopher. arXiv preprint arXiv:2112.11446.   
+Rajpurkar, P., Jia, R., and Liang, P. (2018). Know what you don’t know: Unanswerable questions for squad. arXiv preprint arXiv:1806.03822.   
+Rudinger, R., Naradowsky, J., Leonard, B., and Van Durme, B. (2018). Gender bias in coreference resolution. In Proceedings of the 2018 Conference of the North American Chapter of the Association for Computational Linguistics: Human Language Technologies, New Orleans, Louisiana. Association for Computational Linguistics.   
+Sanh, V., Webson, A., Raffel, C., Bach, S. H., Sutawika, L., Alyafeai, Z., Chaffin, A., Stiegler, A., Scao, T. L., Raja, A., et al. (2021). Multitask prompted training enables zero-shot task generalization. arXiv preprint arXiv:2110.08207.   
+Schulman, J., Moritz, P., Levine, S., Jordan, M., and Abbeel, P. (2016). High-dimensional continuous control using generalized advantage estimation. In Proceedings of the International Conference on Learning Representations (ICLR).   
+Schulman, J., Wolski, F., Dhariwal, P., Radford, A., and Klimov, O. (2017). Proximal policy optimization algorithms. arXiv preprint arXiv:1707.06347.   
+Silver, D., Hubert, T., Schrittwieser, J., Antonoglou, I., Lai, M., Guez, A., Lanctot, M., Sifre, L., Kumaran, D., Graepel, T., et al. (2017). Mastering chess and shogi by self-play with a general reinforcement learning algorithm. arXiv preprint arXiv:1712.01815.   
+Socher, R., Perelygin, A., Wu, J., Chuang, J., Manning, C. D., Ng, A. Y., and Potts, C. (2013). Recursive deep models for semantic compositionality over a sentiment treebank. In Proceedings of the 2013 conference on empirical methods in natural language processing, pages 1631–1642.   
+Solaiman, I., Brundage, M., Clark, J., Askell, A., Herbert-Voss, A., Wu, J., Radford, A., Krueger, G., Kim, J. W., Kreps, S., et al. (2019). Release strategies and the social impacts of language models. arXiv preprint arXiv:1908.09203.   
+Solaiman, I. and Dennison, C. (2021). Process for adapting language models to society (palms) with values-targeted datasets. arXiv preprint arXiv:2106.10328.   
+Stiennon, N., Ouyang, L., Wu, J., Ziegler, D. M., Lowe, R., Voss, C., Radford, A., Amodei, D., and Christiano, P. (2020). Learning to summarize from human feedback. arXiv preprint arXiv:2009.01325.   
+Tamkin, A., Brundage, M., Clark, J., and Ganguli, D. (2021). Understanding the capabilities, limitations, and societal impact of large language models. arXiv preprint arXiv:2102.02503.   
+Thoppilan, R., De Freitas, D., Hall, J., Shazeer, N., Kulshreshtha, A., Cheng, H.-T., Jin, A., Bos, T., Baker, L., Du, Y., et al. (2022). Lamda: Language models for dialog applications. arXiv preprint arXiv:2201.08239.   
+Völske, M., Potthast, M., Syed, S., and Stein, B. (2017). Tl; dr: Mining reddit to learn automatic summarization. In Proceedings of the Workshop on New Frontiers in Summarization, pages 59–63.   
+Wang, A., Pruksachatkun, Y., Nangia, N., Singh, A., Michael, J., Hill, F., Levy, O., and Bowman, S. R. (2019). Superglue: A stickier benchmark for general-purpose language understanding systems. arXiv preprint arXiv:1905.00537.   
+Wei, J., Bosma, M., Zhao, V. Y., Guu, K., Yu, A. W., Lester, B., Du, N., Dai, A. M., and Le, Q. V. (2021). Finetuned language models are zero-shot learners. arXiv preprint arXiv:2109.01652.   
+Weidinger, L., Mellor, J., Rauh, M., Griffin, C., Uesato, J., Huang, P.-S., Cheng, M., Glaese, M., Balle, B., Kasirzadeh, A., et al. (2021). Ethical and social risks of harm from language models. arXiv preprint arXiv:2112.04359.   
+Wu, J., Ouyang, L., Ziegler, D. M., Stiennon, N., Lowe, R., Leike, J., and Christiano, P. (2021). Recursively summarizing books with human feedback. arXiv preprint arXiv:2109.10862.   
+Xu, J., Ju, D., Li, M., Boureau, Y.-L., Weston, J., and Dinan, E. (2020). Recipes for safety in open-domain chatbots. arXiv preprint arXiv:2010.07079.   
+Yi, S., Goel, R., Khatri, C., Cervone, A., Chung, T., Hedayatnia, B., Venkatesh, A., Gabriel, R., and Hakkani-Tur, D. (2019). Towards coherent and engaging spoken dialog response generation using automatic conversation evaluators. arXiv preprint arXiv:1904.13015.   
+Zellers, R., Holtzman, A., Bisk, Y., Farhadi, A., and Choi, Y. (2019). Hellaswag: Can a machine really finish your sentence? In Association for Computational Linguistics, pages 4791–4800.   
+Zhou, W. and Xu, K. (2020). Learning to compare for better training and evaluation of open domain natural language generation models. arXiv preprint arXiv:2002.05058.   
+Ziegler, D. M., Stiennon, N., Wu, J., Brown, T. B., Radford, A., Amodei, D., Christiano, P., and Irving, G. (2019). Fine-tuning language models from human preferences. arXiv preprint arXiv:1909.08593.

parse/dev/VY1dqOF2RjC/VY1dqOF2RjC.md

@@ -0,0 +1,243 @@
+# ZSON: Zero-Shot Object-Goal Navigation using Multimodal Goal Embeddings
+
+Arjun Majumdar∗, Gunjan Aggarwal∗, Bhavika Devnani, Judy Hoffman, Dhruv Batra
+
+Georgia Institute of Technology
+
+# Abstract
+
+We present a scalable approach for learning open-world object-goal navigation (ObjectNav) – the task of asking a virtual robot (agent) to find any instance of an object in an unexplored environment (e.g., “find a sink”). Our approach is entirely zero-shot – i.e., it does not require ObjectNav rewards or demonstrations of any kind. Instead, we train on the image-goal navigation (ImageNav) task, in which agents find the location where a picture (i.e., goal image) was captured. Specifically, we encode goal images into a multimodal, semantic embedding space to enable training semantic-goal navigation (SemanticNav) agents at scale in unannotated 3D environments (e.g., HM3D). After training, SemanticNav agents can be instructed to find objects described in free-form natural language (e.g., “sink,” “bathroom sink,” etc.) by projecting language goals into the same multimodal, semantic embedding space. As a result, our approach enables open-world ObjectNav. We extensively evaluate our agents on three ObjectNav datasets (Gibson, HM3D, and MP3D) and observe absolute improvements in success of $4 . 2 \% \textit { - } 2 0 . 0 \%$ over existing zero-shot methods. For reference, these gains are similar or better than the $5 \%$ improvement in success between the Habitat 2020 and 2021 ObjectNav challenge winners. In an open-world setting, we discover that our agents can generalize to compound instructions with a room explicitly mentioned (e.g., “Find a kitchen sink”) and when the target room can be inferred (e.g., “Find a sink and a stove”).
+
+# 1 Introduction
+
+Imagine asking a home assistant robot to find a “flat-head screwdriver” or the “medicine case near the bathroom sink.” Building such assistive agents is a problem of deep scientific and societal value.
+
+To study this problem systematically, the embodied AI community has rallied around a problem called object-goal navigation ( ObjectNav) [1]. Given the name of an object (e.g., “chair”), ObjectNav involves exploring a 3D environment to find any instance of the object. The last few years have witnessed the development of new environments [2–6], annotated 3D scans [7–9], datasets of human demonstrations [10], and approaches for ObjectNav [11–16], cumulatively leading to strong progress. For instance, the entries in the annual Habitat challenge [17] have jumped from $6 \%$ success (DD-PPO baseline in 2020) to $53 \%$ success (top entry in ongoing 2022 Habitat Challenge public leaderboard).
+
+While this progress is exciting, we believe that a subtle but insidious assumption has snuck into this line of work: the closed-world assumption. We started by discussing an open-world scenario where a person may describe any object in language (e.g., “flat-head screwdriver”), but ObjectNav is currently formulated over a closed predetermined vocabulary of object categories (“chair”, “bed”, “sofa”, etc.), with approaches using pre-trained object detectors and segmenters for these categories [10– 13]. While this assumption may have been essential to get started on this problem, it is now important to move beyond it and ask – how can embodied agents find objects in an open-world setting?
+
+![](images/287e5d645e92d203ff553e5f117ddd25a77b20f01266fe5a82918a8ec4215b63.jpg)  
+Figure 1: We propose projecting navigation goals (from images or text) into a common, semantic embedding space using a pre-trained vision and language model (CLIP). This allows agents trained with image-goals to understand goals expressed in free-form natural language (e.g., “Find a bathroom sink.”). Accordingly, our approach enables open-world object-goal navigation in a zero-shot manner – i.e., without using ObjectNav rewards or demonstrations for training.
+
+In this work, we develop an approach for ObjectNav that is both zero-shot, i.e., does not require any ObjectNav rewards or demonstrations, and open-world, i.e., does not require committing to a taxonomy of categories. Our key insight is that we can create a visiolinguistic embedding space to decouple two problems – (1) describing and representing semantic goals (“chair”, “brown chair”, picture of brown chair) from (2) learning to navigate to semantic goals.2
+
+To represent semantic goals (1), we leverage recent advances in multimodal AI research on learning a common embedding space for images and text using large collections of image-captions pairs. Specifically, we use CLIP [19], a method for training dual vision and language encoders that produce similar representations for paired data such as an image and its caption. As shown in Fig. 1, we use CLIP to transform image-goals (e.g., a picture of the kitchen island) and object-goals (e.g., “bathroom sink”) into semantic-goals representing navigation targets. Our main observation is that a semanticgoal produced from an image (e.g., a picture of the bathroom sink) should be similar to semantic goals produced from descriptions of the same target (e.g, “bathroom sink”). Thus, we hypothesize that these modalities (images and language) can be used interchangeably for creating semantic goals.
+
+Accordingly, for learning to navigate to semantic goals (2), we train agents using image-goals encoded via CLIP’s image encoder. Then, we evaluate the learned navigation policy on ObjectNav, where goals are specified in language (e.g., “chair”) and encoded via CLIP’s text encoder. As a result, our agents perform ObjectNav without ever directly training for the task – i.e., in a zero-shot manner.
+
+An important advantage of our approach is that it reduces the data labeling burden. Image-goals can be procedurally generated by randomly sampling points in 3D environments. This is in stark contrast to ObjectNav, which requires annotating 3D meshes [7–9] and potentially collecting large-scale human demonstrations [10] for training. Secondly, the interface to our agents is a natural language description – matching the grand vision that inspired the ObjectNav task. Through this interface we can refine object-goals by, for instance, specifying object attributes (“brown chair”) or indicating which room the object is in (“bathroom sink”) – which is not possible with traditional ObjectNav agents.
+
+We perform large-scale experiments on three ObjectNav datasets – Gibson [4], MP3D [8], and HM3D [20]. Our zero-shot agent (that has not seen a single 3D semantic annotation or ObjectNav training episode) achieves a $3 1 . 3 \%$ success in Gibson environments, which is a $2 0 . 0 \%$ absolute improvement over previous zero-shot results [18]. In MP3D, our agent achieves $1 5 . 3 \%$ success, a $4 . 2 \%$ absolute gain over existing zero-shot methods[21]. For reference, these gains are on par or better than the $5 \%$ improvement in success between the Habitat 2020 and 2021 ObjectNav challenge winners. On HM3D, our agent’s zero-shot SPL matches a state-of-the-art ObjectNav method [16] that trains with direct supervision from $4 0 \mathrm { k }$ human demonstrations.
+
+Additionally, we study two techniques that are used in our approach to improve zero-shot ObjectNav performance. First, we find that pretraining the visual observation encoder has an outsized effect on zero-shot transfer. Specifically, success on the ImageNav training task improves $4 . 5 \% - 5 . 8 \%$ , while downstream success on zero-shot ObjectNav improves by $9 . 4 \% - 1 0 . 4 \%$ . Similarly, increasing the number of training environments (from 72 to 800) leads to a small drop in ImageNav success, but results in a substantial improvement of $6 . 6 \%$ in success on zero-shot ObjectNav.
+
+Finally, we qualitatively experiment with an open-world setting and observe that our SemanticNav agents can properly change behavior in response to instructions that include room information. For instance, when finding a “bathroom sink” the agent does not enter the kitchen, and when looking for a “kitchen sink” it does not enter bathrooms. Furthermore, we observe similar room awareness patterns for instructions such as “Find a sink and a stove,” where the target room (“kitchen”) can be inferred. Source code for reproducing our results will be publicly released.
+
+# 2 Related Work
+
+Our work builds on research studying image-text alignment techniques (e.g., CLIP [19]) and their use in visual navigation. In this section, we discuss methods most related to our proposed approach.
+
+Image-Text Alignment Models. Recent progress in vision-and-language pretraining has led to models such as CLIP [19], ALIGN [22], and BASIC [23] that can perform open-world image classification, and achieve strong performance on standard computer vision benchmarks (e.g., ImageNet [24]). These models learn visual representations by training on massive datasets of image-caption pairs scraped from the web (e.g., the 400M pairs used for CLIP or 6.6B for BASIC). In this work, we take advantage of the semantic representations learned by CLIP to project navigation goals (e.g., a picture of a brown chair or “brown chair”) into a multimodal, semantic-goal embedding space.
+
+CLIP for Visual Navigation. A straightforward approach for using CLIP in a visual navigation agent is to process the agent’s observations and navigation instructions (e.g., “Find a chair”) with the CLIP image and text encoders, then learn a navigation policy that operates on these embeddings. Such a solution was explored in EmbCLIP [25] with promising results. However, this approach requires ObjectNav rewards or demonstrations to supervise the navigation policy, which is difficult and costly to collect at scale. As a result, existing training datasets tend to be small and agents generalize poorly to new settings. For instance, EmbCLIP only achieves an $8 \%$ success rate in finding objects that were not used in training. By contrast, we train using the image-goal navigation task, which does not require annotated environments. Thus, we are able to scale training to 800 unannotated 3D scenes, which substantially improves generalization (as demonstrated in Section 5).
+
+Zero-Shot ObjectNav. Two recent works [18, 21] directly address our motivation (zero-shot ObjectNav) and are most related. First, ZER [18] proposes a two-stage framework in which an image-goal navigation (ImageNav) agent is first trained from scratch. Then, independent encoders are trained to map from various modalities (including language) into the image-goal embedding space. A key challenge with this approach is that image-goal embeddings may not capture semantic information because semantic annotations are not used in ImageNav training. Instead, an ImageNav agent trained from scratch may learn to pattern match visual observations and goal image embeddings. By contrast, our approach reverses these two stages, with CLIP pretraining representing stage one. Thus, our approach uses a goal embedding space that captures semantics by design. We empirically demonstrate the benefits of our proposed approach in Section 5.
+
+![](images/fde2231cc317d8dd7be7bbd213c2e3f3ddc6a4527727238bb0a3ecbce840fb74.jpg)  
+Figure 2: We tackle both ImageNav and ObjectNav via a common SemanticNav agent. This agent accepts a semantic goal embedding $( s ^ { g } )$ , which comes from either CLIP’s visual encoder $\textstyle ( \mathtt { C L I P } _ { v } )$ in ImageNav or CLIP’s textual encoder $\textstyle ( \mathtt { C L I P } _ { t } )$ in ObjectNav. Our agent has a simple architecture: RGB observations are encoded with a pretrained ResNet-50, and a recurrent policy network predicts actions using encodings of the goal $s ^ { g }$ , observation, and the previous action $a _ { t - 1 }$ .
+
+In concurrent work, CLIP-on-Wheels (CoW) [21] uses a gradient-based visualization technique (GradCAM [26]) with CLIP to localize objects in the agent’s observations. This is combined with a heuristic exploration policy to enable zero-shot object-goal navigation. In contrast, we demonstrate that learning a navigation policy can substantially outperform the heuristic exploration approach proposed in [21] without using explicit object localization techniques.
+
+# 3 Preliminaries: Image-Text Alignment and Image-Goal Navigation
+
+Image-Text Alignment Models. Multimodal alignment models aim to learn a mapping from images $v$ and text $t$ into a shared embedding space such that representations for corresponding imagetext pairs (e.g., a picture and its caption) are similar. Recent image-text alignment models [19, 22, 23] use a dual-encoder framework and optimize the InfoNCE [27] contrastive learning objective, which maximizes cosine similarity between representations of matching image-text pairs and minimizes similarity for non-matching pairs. In this work, we leverage CLIP [19], which was trained on $4 0 0 \mathbf { M }$ image-text pairs that cover a wide range of visual concepts.
+
+Image-Goal Navigation. In image-goal navigation (ImageNav) [28], agents explore an environment to find the position where a goal-image $v ^ { g }$ was captured. We consider a setting in which both the goal-image and the agent’s observations consist of RGB images taken from the agent’s egocentric point of view. An agent can select from four actions: MOVE_FORWARD by $0 . 2 5 \mathrm { m }$ , TURN_LEFT by $3 0 ^ { \circ }$ , TURN_RIGHT by $3 0 ^ { \circ }$ , or STOP. The agent succeeds if it selects STOP within $1 . 0 \mathrm { m }$ of the goal.
+
+An ImageNav episode is uniquely defined by a starting position and (reachable) goal viewpoint within a 3D environment. Thus, ImageNav training data can be procedurally generated without annotating the scene – i.e., the objects and rooms do not need to be labeled. As a result, the size of an ImageNav dataset is only limited by the number of environments available for training. In this work, we use ImageNav to train visual navigation agents at scale (in terms of the number of training environments).
+
+# 4 Approach
+
+This section describes our framework for training visual navigation agents. We use CLIP [19] to produce semantic goal embeddings of image-goals (e.g., a picture of the sink) and object-goals (e.g., “sink”). This allows training semantic-goal navigation agents at scale using image-goals in HM3D environments [20], then deploying these agents for object-goal navigation in a zero-shot manner. In other words, our agents execute object-goal navigation without ever directly training for the task.
+
+# 4.1 Learning Semantic-Goal Navigation
+
+As illustrated in Fig. 2 (top-left), given an image-goal $v ^ { g }$ , we use a CLIP visual encoder $\mathtt { C L I P } _ { v }$ to generate a semantic goal embedding $s _ { v } ^ { g } = \mathtt { C L I P } _ { v } ( v ^ { g } )$ that is used to guide navigation. Conceptually, encoding image-goals with CLIP preserves semantic information about the goal, such as visual concepts that might be described in image captions (e.g., “a sofa in a living room”). However, semantic goal embeddings are less likely to include low-level features (e.g., the exact patterns in a wood floor) that do not correlate with web-scraped captions. While removing low-level information might make the navigation task more difficult, our goal is to learn a policy that transfers to ObjectNav in which agents only receives high-level goals (e.g., “Find a sofa”). As an added benefit, generating semantic goal embeddings as a pre-processing step substantially improves training time (by ${ \sim } 3 . 5 \mathrm { x }$ ).
+
+Our agent architecture is shown in Fig. 2. At each timestep $t$ , our agent receives an egocentric RGB observation $v _ { t }$ and a goal representation $s _ { v } ^ { g }$ . The observation is processed by a ResNet-50 [29] encoder, which is pretrained on the Omnidata Starter Dataset (OSD) [30] using self-supervised learning (DINO [31]) following the pretraining recipe presented in OVRL [16]. The output from the ResNet-50 encoder is concatenated with the goal representation $s _ { v } ^ { g }$ and an embedding of the agent’s previous action $a _ { t - 1 }$ and then passed to the policy network composed of a two-layer LSTM. The policy network outputs a distribution over the action space.
+
+We train our SemanticNav agent with reinforcement learning (RL). During RL training, we use two data augmentation techniques: color jitter and random translation (adapted from [16]). Specifically, we train with DD-PPO [32] using a reward function proposed for ImageNav by Al-Halah et al. [18]:
+
+$$
+r _ { t } = r _ { \mathrm { s u c c e s s } } + r _ { \mathrm { a n g l e - s u c c e s s } } - \Delta _ { \mathrm { d t g } } - \Delta _ { \mathrm { a t g } } + r _ { \mathrm { s l a c k } }
+$$
+
+where $r _ { \mathrm { s u c c e s s } } = 5$ if STOP is called when the agent is within $1 \mathrm { m }$ of the goal position (and 0 otherwise), $r _ { \mathrm { a n g l e - s u c c e s s } } = 5$ if STOP is called when the agent is within $1 \mathrm { m }$ of the goal position and the agent is pointing within $2 5 ^ { \circ }$ of the goal heading – i.e., the direction the camera was pointing when the goal image was collected – (and 0 otherwise), $\Delta _ { \mathrm { d t g } }$ is the change in the agent’s distance-to-goal – i.e., the geodesic distance to the goal position, $\Delta _ { \mathrm { a t g } }$ is the change in the agent’s angle-to-goal – i.e., the difference between the agent’s heading and the goal heading – but is set to 0 if the agent is greater than $1 \mathrm { m }$ from the goal, and $r _ { \mathrm { s l a c k } } = - 0 . 0 1$ to encourage efficient navigation. In general, this reward function encourages both reaching the goal and looking towards the goal before calling STOP, which matches the requirements of the downstream ObjectNav task.
+
+# 4.2 Zero-Shot Object-Goal Navigation
+
+Recall that in ObjectNav [1], agents are given a target category (e.g., “sofa” or “chair”) and must locate any instance of that object (i.e., “any sofa” or “any chair”). Similar to ImageNav, ObjectNav requires exploring new environments that the agent has never seen before. However, in ObjectNav, the goal (e.g., “sofa”) provides a minimal amount of information about where the agent must go and it requires recognizing any version of the goal object in the new scene.
+
+To address this task, we transform object-goals $o ^ { g }$ (e.g., “sofa”) into semantic goal embeddings using the CLIP text encoder ${ \mathrm { C L I P } } _ { t }$ , which results in the semantic goal $s _ { o } ^ { g } = \mathtt { C L I P } _ { t } ( o ^ { g } )$ . CLIP aligns image and text, thus the semantic goals from text $s _ { o } ^ { g }$ should be close (in terms of cosine similarity) to the CLIP visual embeddings $s _ { v } ^ { g }$ used in training. To keep our approach simple and easily reproducible, we do not use any prompt engineering (e.g., using a template such as $^ { 6 6 } \mathtt { A }$ photo of a $< > ^ { \dag \dag } ,$ ). Instead, we simply use the object name (e.g., “sofa”) as the object-goal input $o ^ { g }$ .
+
+# 5 Experimental Findings and Qualitative Results
+
+This section studies the zero-shot ObjectNav performance of our proposed approach. First, we evaluate our method in the traditional ObjectNav setting [1] where agents must find any instance of the goal object (“Find a chair”). Then, we explore variations of ObjectNav in which additional information, such as a room location (e.g., “bathroom sink”), is given to refine the task. These experiments aim to demonstrate both the effectiveness and versatility of our approach.
+
+# 5.1 Experimental Setup
+
+Training Dataset. We generate a dataset for training our SemanticNav agent using the 800 training environments from HM3D [20]. First, we sample 9k ImageNav episodes for each HM3D scan, split equally between 3 difficulty levels corresponding with path length: EASY $( 1 . 5 \mathrm { - } 3 \mathrm { m } )$ , MEDIUM (3- $5 \mathrm { m } )$ , and HARD $( 5 \mathrm { - } 1 0 \mathrm { m } )$ . We follow the episode generation approach from [33]. This results in $9 \mathbf { k } \times 8 0 0 = 7 . 2 \mathbf { M }$ navigation episodes for training. Next, we pre-process the goal-images with the ResNet-50 version of CLIP [19] to produce 1024 dimensional semantic goal vectors $s _ { v } ^ { g }$ for each navigation episode. During pre-processing, we further augment the dataset by sampling goal-images at four evenly-spaced heading angles to produce 36M total episodes for training. Sampling at multiple angles approximates the randomized sampling used in [18].
+
+Agent Configurations. Two different agent configurations are frequently used in prior work on visual navigation. Configuration A is generally used for ImageNav and has an agent height of $1 . 5 \mathrm { m }$ , radius of $0 . 1 \mathrm { m }$ , and a single $1 2 8 \times 1 2 8$ RGB sensor with a $9 0 ^ { \circ }$ horizontal field-of-view (HFOV) placed $1 . 2 5 \mathrm { m }$ from the ground. Configuration B is typically used for ObjectNav and approximately matches a LoCoBot, with an agent height of $0 . 8 8 \mathrm { m }$ , radius of $0 . 1 8 \mathrm { m }$ , and a single $6 4 0 \times 4 8 0$ RGB sensor with a $7 9 ^ { \circ }$ HFOV placed $0 . 8 8 \mathrm { m }$ from the ground. Both configurations use the aforementioned step size of $0 . 2 5 \mathrm { m }$ and left and right turning angle of $3 0 ^ { \circ }$ .
+
+Evaluation Datasets. We measure performance on one ImageNav and three ObjectNav datasets:
+
+– ImageNav (Gibson) consists of 4,200 episodes from 14 Gibson [4] validation scenes. The dataset was produced by Mezghani et al. [33] for agents with configuration A. – ObjectNav (Gibson) was generated by Al-Halah et al. [18] for agents with configuration A. The dataset consists of 1,000 episodes in 5 Gibson [4] validation scenes for 6 object categories. ObjectNav (HM3D), released with the Habitat 2022 challenge, consists of 2,000 episodes from 20 HM3D [20] validation scenes with objects from 6 categories, and uses agents with configuration B. ObjectNav (MP3D) released with the Habitat 2020 challenge, contains 2,195 episodes from 11 MP3D [8] validation scenes for 21 object categories, and requires agents with configuration B.
+
+Due to the different agent configurations required by these evaluation datasets, we train agents with both settings to make fair comparisons with prior work on zero-shot ObjectNav. For all experiments, we report two standard metrics for visual navigation tasks: success rate (SR) and success rate weighted by normalized inverse path length (SPL) [34].
+
+Implementation Details. We generate a SemanticNav dataset for each agent configuration (A and B). The CLIP ResNet-50 encoder processes $2 2 4 \times 2 2 4$ images. Accordingly, for configuration A, we render $5 1 2 \times 5 1 2$ RGB frames, then resize to $2 2 4 \times 2 2 4$ . For configuration B, we render at $6 4 0 \times$ 480, then resize and center crop. We train agents using PyTorch [35] and the Habitat simulator [2, 3]. Each training run was conducted on a single compute node with 8 NVIDIA A40 GPUs. We train agents for 500M steps, requiring $\mathord { \sim } 1 , 7 0 4$ GPU-hours to train two agents (one for each configuration). Additional training hyperparamters are detailed in the Appendix. We report results using the best checkpoint, selected based on ObjectNav validation success rate (SR). During evaluations we sample actions from the agent’s output distribution. We report results averaged over three evaluation runs.
+
+Baselines. We provide comparisons with the, to the best of our knowledge, only two existing zero-shot methods for object-goal navigation (ObjectNav):
+
+– Zero Experience Required (ZER) [18]: first trains an ImageNav agent composed of two ResNet-9 encoders for processing the goal-image and agent observations, and a policy network consisting of a 2-layer GRU. After training the navigation policy, a 2-layer MLP is trained to map from a goal object categories into the goal-image embedding space learned through ImageNav training. This mapping is learned using an in-domain dataset containing 14K images with object category labels.
+
+Table 1: Zero-shot ObjectNav performance on Gibson [4], HM3D [20], and MP3D [8] validation. All methods use a single RGB sensor for agent observations except CoW [21], which also uses depth observations and OVRL [16], which uses $\mathtt { G P S + }$ Compass for ObjectNav. Our approach (ZSON) substantially improves on previous zero-shot methods and narrows the gap to SOTA fully-supervised methods such as OVRL [16], which is not zero-shot and provided for reference. We report ZSON results averaged over three evaluation trials. The standard deviation in ZSON ObjectNav SR is $0 . 0 2 \%$ in Gibson, $0 . 4 6 \%$ in HM3D, and $0 . 1 1 \%$ in MP3D. ∗indicates reproduced results   
+
+<table><tr><td></td><td colspan="2">ImageNav (Gibson)</td><td colspan="2">ObjectNav (Gibson)</td></tr><tr><td>Method</td><td>SPL</td><td>SR</td><td>SPL</td><td>sr</td></tr><tr><td>OVRL [16]</td><td>27.0%</td><td>54.2%</td><td></td><td></td></tr><tr><td>ZER [18]</td><td>21.6%</td><td>29.2%</td><td></td><td>11.3%</td></tr><tr><td>ZSON (ours)</td><td>28.0%</td><td>36.9%</td><td>12.0%</td><td>31.3%</td></tr></table>
+
+(a) Configuration A
+
+<table><tr><td></td><td colspan="2">ObjectNav (HM3D)</td><td colspan="2">ObjectNav (MP3D)</td></tr><tr><td>Method</td><td>SPL</td><td>Sr</td><td>SPL</td><td>Sr</td></tr><tr><td>OVRL [16]</td><td>12.3%*</td><td>32.8%*</td><td>7.0%</td><td>25.3%</td></tr><tr><td>CoW [21] (w/depth)</td><td>-</td><td>-</td><td>6.3%</td><td>11.1%</td></tr><tr><td>ZSON (ours)</td><td>12.6%</td><td>25.5%</td><td>4.8%</td><td> 15.3%</td></tr></table>
+
+(b) Configuration B
+
+– CLIP on Wheels (CoW) [21]: builds an occupancy map by projecting depth observations, then searches the environment with frontier-based exploration [36]. At each step, CoW calculates a 3D saliency map using a depth and RGB observations and the goal object category via Grad-CAM [26], a gradient-based visualization technique. When the 3D saliency exceeds a threshold the agent navigates to that location and stops. As such, CoW does not require a learned navigation policy.
+
+Fully-Supervised ObjectNav. To understand the gap to fully-supervised ObjectNav methods, we compare with OVRL [16], a two-stage framework that achieves state-of-the-art ObjectNav results in our single RGB camera setting. We highlight OVRL in blue to indicate the use of direct supervision.
+
+# 5.2 Zero-Shot Object-Goal Navigation
+
+In Table 1 we report zero-shot ObjectNav performance. We compare with ZER [18] in Table 1a using agent configuration A. Notice that our agent is stronger than ZER on ImageNav, which is the base pretraining task before ObjectNav can be studied. Specifically, we observe a $7 . 7 \%$ improvement in ImageNav SR $( 2 9 . 2 \%  3 6 . 9 \% )$ . This improvement results from (1) learning to navigate to semantic goal embeddings (as proposed in this work) instead of navigating to image-goal embeddings that are learned from scratch (as done in ZER), (2) using more diverse training environments, and (3) from using a pretrained visual encoder. We provide additional comparisons with ZER using the same set of training environments and without using visual encoder pretraining in Section 5.3, where we also observe improved performance. In Table 1a, we see even larger improvements in ObjectNav SR of $2 0 . 0 \%$ $1 1 . 3 \%  3 1 . 3 \% )$ . These results indicate that our design decisions are particularly useful for zero-shot ObjectNav.
+
+In Table 1b we compare with CoW [21] using agent configuration B. In ObjectNav on the MP3D validation set, we find that training a SemanticNav agent improves ObjectNav SR by $4 . 2 \%$ absolute and $3 7 . 8 \%$ relative $1 1 . 1 \%  1 5 . 3 \%$ ). These results demonstrate that learning a navigation policy improves zero-shot ObjectNav SR over the hand-designed exploration strategy and stopping criteria proposed by $\mathbf { \mathrm { C o W } } .$ Moreover, we expect further improvements in zero-shot ObjectNav performance from scaling our approach (e.g., by collecting more training environments). Such scaling is simply not possible with heuristic methods such as $\mathbf { \mathrm { C o W } }$ because the navigation policy is not learned. The SPL of our approach is $1 . 5 \%$ lower than CoW. However, unlike CoW, our agent navigates without depth observations, which may reduce path efficiency. On HM3D we find that our agent achieves a strong SR of $2 5 . 5 \%$ and SPL of $12 . 6 \%$ . Impressively, this zero-shot SPL matches OVRL [16], which is directly trained on $4 0 \mathrm { k }$ human demonstrations [10] for the ObjectNav task with imitation learning.
+
+# 5.3 Comparison with ZER without Encoder Pretraining and Training Environment Diversity
+
+In Table 2, we train our approach in Gibson environments (instead of HM3D) and do not use a pretrained observation encoder. These settings match ZER [18], allowing for a direct comparison between the two methods. We observe that our approach results in a $4 . 0 \%$ absolute and $3 5 \%$ relative improvement in zero-shot ObjectNav success $1 1 . 3 \%  1 5 . 3 \% )$ . These results demonstrate that learning to navigate to semantic-goal embeddings outperforms the inverse approach proposed by ZER of first training for image-goal navigation, then learning a mapping from object categories into the image-goal embedding space.
+
+Table 2: Comparison with ZER [18] using a ResNet-9 and the Gibson dataset with our approach. Learning SemanticNav (Ours) outperforms learning ImageNav then language grounding (ZER [18]).   
+
+<table><tr><td></td><td></td><td></td><td colspan="2">ImageNav (Gibson)</td><td colspan="2">ObjectNav (Gibson)</td></tr><tr><td>Method</td><td>Visual Encoder</td><td>Training Dataset</td><td>SPL</td><td>SR</td><td>SPL</td><td>SR</td></tr><tr><td>ZER [18]</td><td>ResNet-9</td><td>Gibson</td><td>21.6%</td><td>29.2%</td><td>■</td><td>11.3%</td></tr><tr><td>Ours</td><td>ResNet-9</td><td>Gibson</td><td>22.8%</td><td>33.3%</td><td>7.4%</td><td>15.3%</td></tr></table>
+
+# 5.4 Additional Ablations
+
+In Table 3, we study the impact of two key design decisions within our method: (1) the visual observation encoder and (2) the number of training environments. While pretraining the visual observation encoder is known to improve visual navigation task performance (demonstrated in [16]), here we study the impacts on zero-shot transfer to ObjectNav. We find that OVRL pretraining improves ImageNav success by $4 . 5 \%$ (rows 1 vs. 3) or $5 . 8 \%$ (rows 2 vs. 4) depending on the dataset used for training. However, the impact on zero-shot ObjectNav performance is substantially larger. Specifically, ObjectNav success improves by $9 . 4 \%$ (rows 1 vs. 3) and $1 0 . 4 \%$ (rows 2 vs. 4). These results suggest that a strong visual encoder is often essential for zero-shot transfer to ObjectNav.
+
+In rows 3 vs. 4, we switch the training dataset from the 72 Gibson [4] training environments (row 3) to the 800 (unannotated) HM3D [20] training environments. Surprisingly, we observe a $0 . 9 \%$ drop in ImageNav success, yet a $6 . 6 \%$ improvement in ObjectNav success (rows 3 vs. 4). A similar trend is observed in rows 1 vs. 2. These trends indicate that training environment diversity is particularly useful for zero-shot ObjectNav.
+
+Table 3: Ablations of the visual encoder and dataset used for training our SemanticNav agents.   
+
+<table><tr><td></td><td></td><td></td><td colspan="2">ImageNav (Gibson)</td><td colspan="2">ObjectNav (Gibson)</td></tr><tr><td>#</td><td>Visual Encoder</td><td>Training Dataset</td><td>SPL</td><td>SR</td><td>SPL</td><td>Sr</td></tr><tr><td>1</td><td>ResNet-9 from scratch</td><td>Gibson</td><td>22.8%</td><td>33.3%</td><td>7.4%</td><td>15.3%</td></tr><tr><td>2</td><td>ResNet-9 from scratch</td><td>HM3D</td><td>23.4%</td><td>31.1%</td><td>9.5%</td><td>20.9%</td></tr><tr><td>3</td><td>OVRL (ResNet-50,pretrained)</td><td>Gibson</td><td>27.6%</td><td>37.8%</td><td>10.0%</td><td>24.7%</td></tr><tr><td>4</td><td>OVRL (ResNet-50, pretrained)</td><td>HM3D</td><td>28.0%</td><td>36.9%</td><td>12.0%</td><td> 31.3%</td></tr></table>
+
+# 5.5 Qualitative Analysis
+
+In Fig. 3, we present qualitative examples of our agent navigating to more complex object descriptions (e.g., $^ { \ast \ast } F i n d a b a t h r o o m s i n k ^ { \prime \prime } )$ . In each trial, the agent starts at the same position and heading (next to the front door looking into the house). The only thing that changes about the initial conditions is the instructions given to the agent (“Find a...” “...bathroom sink”, “...kitchen sink” .sink and a toilet”, or “...sink and a stove”). Since the agent’s policy is stochastic, we show 5 sampled rollouts and highlight the first run in bold colors.
+
+![](images/af741677d13d6a231b10160d5204bd67e32a690020f006bd78e11c2c60ffa425.jpg)  
+Figure 3: Qualitative examples for navigating to complex object descriptions. For each trail, the agent is spawned at the start position looking into the house (i.e., to the right on the maps) and given one of four instructions. Each instruction is run five times with the path for the first trail highlighted in bold colors. Our agent appropriately navigates to the correct rooms, demonstrating an understanding of both explicit (“Find a kitchen sink”) and implicit (“Find a sink and a stove”) room information.
+
+We find that given room information such as “bathroom” or “kitchen”, the agent appropriately finds a “sink” in the corresponding rooms in the house. Furthermore, in these examples the agent does not enter the “kitchen” when prompted to look for a $^ { \cdots } b a t h r o o m \ s i n k , ^ { \prime \prime }$ and vice-versa. In these long trajectories (ranging from 88 to 225 steps), we observe more exploration in the living room and direct navigation when target rooms are visible. We qualitatively observe interesting learned behaviors – for instance, the agent often performs a $3 6 0 ^ { \circ }$ turn before navigating, possibly to survey the environment.
+
+Next, we experiment with variations in which room information can be inferred from the instruction, but is not explicit. We use “sink and a toilet” to indicate “bathroom” and “sink and a stove” for “kitchen”. In these examples, we discover that our agent still navigates to the correct rooms, suggesting that it learns some priors of indoor spaces, such as that a “stove” is often found within a “kitchen.”
+
+# 6 Discussion
+
+We present a zero-shot method for learning open-world object-goal navigation (ObjectNav). Our approach involves projecting image-goals into a semantic-goal embedding space using an image-and-text alignment model (CLIP). This creates a semantic-goal navigation task that does not require annotated
+
+3D environments or collecting human demonstrations. Thus, our method is easy to scale. We discover that SemanticNav agents outperform previous zero-shot ObjectNav methods, and we identify two factors that have a strong impact on navigation success – pretraining the visual encoder and training in a diverse set of environments. In an open-world setting, we observe navigation patterns that suggest that SemanticNav agents can understand complex instructions, such as “Find a sink and a stove.”
+
+Limitations and Impact. SemanticNav agents appear to learn useful priors of indoor environments such as which room contains a “stove.” However, agents may struggle in scenes where a navigation target is in an unusual location (e.g., a stove in a bedroom). Biases in the 3D environments used to train such agents might exaggerate these issues and affect deployments in non-traditional settings. Thus, interventions to mitigate this problem should be considered. Future work might explore how to use the natural language interface to SemanticNav agents to guide exploration in such scenarios.
+
+# Acknowledgements
+
+The Georgia Tech effort was supported in part by NSF, ONR YIP, ARO PECASE, and ARL. The views and conclusions contained herein are those of the authors and should not be interpreted as necessarily representing the official policies or endorsements, either expressed or implied, of the U.S. Government, or any sponsor.
+
+# References
+
+[1] Dhruv Batra, Aaron Gokaslan, Aniruddha Kembhavi, Oleksandr Maksymets, Roozbeh Mottaghi, Manolis Savva, Alexander Toshev, and Erik Wijmans. Objectnav Revisited: On Evaluation of Embodied Agents Navigating to Objects. arXiv preprint arXiv:2006.13171, 2020. 1, 5, 6   
+[2] Manolis Savva, Abhishek Kadian, Oleksandr Maksymets, Yili Zhao, Erik Wijmans, Bhavana Jain, Julian Straub, Jia Liu, Vladlen Koltun, Jitendra Malik, et al. Habitat: A platform for embodied ai research. In ICCV, 2019. 1, 6, 15   
+[3] Andrew Szot, Alexander Clegg, Eric Undersander, Erik Wijmans, Yili Zhao, John Turner, Noah Maestre, Mustafa Mukadam, Devendra Singh Chaplot, Oleksandr Maksymets, et al. Habitat 2.0: Training home assistants to rearrange their habitat. NeurIPS, 2021. 6   
+[4] Fei Xia, Amir R Zamir, Zhiyang He, Alexander Sax, Jitendra Malik, and Silvio Savarese. Gibson Env: Real-World Perception for Embodied Agents. In CVPR, pages 9068–9079, 2018. 3, 6, 7, 8, 15   
+[5] Eric Kolve, Roozbeh Mottaghi, Winson Han, Eli VanderBilt, Luca Weihs, Alvaro Herrasti, Daniel Gordon, Yuke Zhu, Abhinav Gupta, and Ali Farhadi. AI2-THOR: An Interactive 3D Environment for Visual AI. arXiv, 2017.   
+[6] Ben Talbot, David Hall, Haoyang Zhang, Suman Raj Bista, Rohan Smith, Feras Dayoub, and Niko Sünderhauf. BenchBot: Evaluating Robotics Research in Photorealistic 3D Simulation and on Real Robots, 2020. 1   
+[7] Angel X. Chang, Thomas Funkhouser, Leonidas Guibas, Pat Hanrahan, Qixing Huang, Zimo Li, Silvio Savarese, Manolis Savva, Shuran Song, Hao Su, Jianxiong Xiao, Li Yi, and Fisher Yu. ShapeNet: An Information-Rich 3D Model Repository. Technical Report arXiv:1512.03012 [cs.GR], Stanford University — Princeton University — Toyota Technological Institute at Chicago, 2015. 1, 2   
+[8] Angel Chang, Angela Dai, Thomas Funkhouser, Maciej Halber, Matthias Niessner, Manolis Savva, Shuran Song, Andy Zeng, and Yinda Zhang. Matterport3D: Learning from RGB-D Data in Indoor Environments. In ThreeDV, 2017. MatterPort3D dataset license: http://kaldir.vc.in.tum.de/matterport/MP_ TOS.pdf. 3, 6, 7, 15   
+[9] Iro Armeni, Zhi-Yang He, JunYoung Gwak, Amir R Zamir, Martin Fischer, Jitendra Malik, and Silvio Savarese. 3D Scene Graph: A Structure for Unified Semantics, 3D Space, and Camera. In ICCV, 2019. 1, 2   
+[10] Ram Ramrakhya, Eric Undersander, Dhruv Batra, and Abhishek Das. Habitat-web: Learning embodied object-search strategies from human demonstrations at scale. In CVPR, 2022. 1, 2, 7, 14   
+[11] Devendra Singh Chaplot, Dhiraj Gandhi, Abhinav Gupta, and Ruslan Salakhutdinov. Object goal navigation using goal-oriented semantic exploration. In NeurIPS, 2020. 1   
+[12] Joel Ye, Dhruv Batra, Abhishek Das, and Erik Wijmans. Auxiliary tasks and exploration enable objectnav. In ICCV, 2021.   
+[13] Oleksandr Maksymets, Vincent Cartillier, Aaron Gokaslan, Erik Wijmans, Wojciech Galuba, Stefan Lee, and Dhruv Batra. Thda: Treasure hunt data augmentation for semantic navigation. In ICCV, 2021. 2, 14   
+[14] Yiqing Liang, Boyuan Chen, and Shuran Song. SSCNav: Confidence-Aware Semantic Scene Completion for Visual Semantic Navigation. In ICRA, 2021.   
+[15] Haokuan Luo, Albert Yue, Zhang-Wei Hong, and Pulkit Agrawal. Stubborn: A Strong Baseline for Indoor Object Navigation. arXiv preprint arXiv:2203.07359, 2022.   
+[16] Karmesh Yadav, Ram Ramrakhya, Arjun Majumdar, Vincent-Pierre Berges, Sachit Kuhar, Dhruv Batra, Alexei Baevski, and Oleksandr Maksymets. Offline Visual Representation Learning for Embodied Navigation. arXiv preprint arXiv:2204.13226, 2022. 1, 3, 5, 7, 8, 14, 15   
+[17] Karmesh Yadav, Santhosh Kumar Ramakrishnan, Aaron Gokaslan, Oleksandr Maksymets, Rishabh Jain, Ram Ramrakhya, Angel X Chang, Alexander Clegg, Manolis Savva, Eric Undersander, Devendra Singh Chaplot, and Dhruv Batra. Habitat challenge 2022. https://aihabitat.org/challenge/2022/, 2022. 1   
+[18] Ziad Al-Halah, Santhosh K Ramakrishnan, and Kristen Grauman. Zero Experience Required: Plug & Play Modular Transfer Learning for Semantic Visual Navigation. arXiv preprint arXiv:2202.02440, 2022. 2, 3, 5, 6, 7, 8, 14, 15   
+[19] 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 ICML, 2021. 2, 3, 4, 5, 6, 14   
+[20] Santhosh Kumar Ramakrishnan, Aaron Gokaslan, Erik Wijmans, Oleksandr Maksymets, Alexander Clegg, John M Turner, Eric Undersander, Wojciech Galuba, Andrew Westbury, Angel X Chang, Manolis Savva, Yili Zhao, and Dhruv Batra. Habitat-matterport 3d dataset (HM3d): 1000 large-scale 3d environments for embodied AI. In NeurIPS Datasets and Benchmarks Track, 2021. 3, 5, 6, 7, 8, 15   
+[21] Samir Yitzhak Gadre, Mitchell Wortsman, Gabriel Ilharco, Ludwig Schmidt, and Shuran Song. CLIP on Wheels: Zero-Shot Object Navigation as Object Localization and Exploration. arXiv preprint arXiv:2203.10421, 2022. 3, 4, 7, 14   
+[22] Chao Jia, Yinfei Yang, Ye Xia, Yi-Ting Chen, Zarana Parekh, Hieu Pham, Quoc Le, Yun-Hsuan Sung, Zhen Li, and Tom Duerig. Scaling Up Visual and Vision-Language Representation Learning With Noisy Text Supervision. In ICML, 2021. 3, 4   
+[23] Hieu Pham, Zihang Dai, Golnaz Ghiasi, Hanxiao Liu, Adams Wei Yu, Minh-Thang Luong, Mingxing Tan, and Quoc V Le. Combined Scaling for Zero-shot Transfer Learning. arXiv preprint arXiv:2111.10050, 2021. 3, 4   
+[24] Jia Deng, Wei Dong, Richard Socher, Li-Jia Li, Kai Li, and Li Fei-Fei. Imagenet: A Large-Scale Hierarchical Image Database. In CVPR, 2009. 3   
+[25] Apoorv Khandelwal, Luca Weihs, Roozbeh Mottaghi, and Aniruddha Kembhavi. Simple but Effective: CLIP Embeddings for Embodied AI. arXiv preprint arXiv:2111.09888, 2021. 3, 14   
+[26] Ramprasaath R Selvaraju, Michael Cogswell, Abhishek Das, Ramakrishna Vedantam, Devi Parikh, and Dhruv Batra. Grad-CAM: Visual Explanations from Deep Networks via Gradient-Based Localization. In ICCV, 2017. 4, 7   
+[27] Aaron van den Oord, Yazhe Li, and Oriol Vinyals. Representation learning with contrastive predictive coding. arXiv preprint arXiv:1807.03748, 2018. 4   
+[28] Yuke Zhu, Roozbeh Mottaghi, Eric Kolve, Joseph J. Lim, Abhinav Kumar Gupta, Li Fei-Fei, and Ali Farhadi. Target-driven Visual Navigation in Indoor Scenes using Deep Reinforcement Learning. ICRA, 2017. 4   
+[29] Kaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. Deep Residual Learning for Image Recognition. In CVPR, 2016. 5   
+[30] Ainaz Eftekhar, Alexander Sax, Jitendra Malik, and Amir Zamir. Omnidata: A Scalable Pipeline for Making Multi-Task Mid-Level Vision Datasets From 3D Scans. In ICCV, 2021. 5
+
+[31] Mathilde Caron, Hugo Touvron, Ishan Misra, Hervé Jégou, Julien Mairal, Piotr Bojanowski, and Armand Joulin. Emerging Properties in Self-Supervised Vision Transformers. In ICCV, 2021. 5
+
+[32] Erik Wijmans, Abhishek Kadian, Ari Morcos, Stefan Lee, Irfan Essa, Devi Parikh, Manolis Savva, and Dhruv Batra. DD-PPO: Learning Near-Perfect PointGoal Navigators from 2.5 Billion Frames. In ICLR, 2019. 5
+
+[33] Lina Mezghani, Sainbayar Sukhbaatar, Thibaut Lavril, Oleksandr Maksymets, Dhruv Batra, Piotr Bojanowski, and Karteek Alahari. Memory-Augmented Reinforcement Learning for Image-Goal Navigation. arXiv preprint arXiv:2101.05181, 2021. 6
+
+[34] Peter Anderson, Angel Chang, Devendra Singh Chaplot, Alexey Dosovitskiy, Saurabh Gupta, Vladlen Koltun, Jana Kosecka, Jitendra Malik, Roozbeh Mottaghi, Manolis Savva, et al. On Evaluation of Embodied Navigation Agents. arXiv preprint arXiv:1807.06757, 2018. 6
+
+[35] 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 NeurIPS, 2019. 6
+
+[36] Brian Yamauchi. A frontier-based approach for autonomous exploration. In CIRA, 1997. 7 [37] Ram Ramrakhya, Erik Wijmans, Dhruv Batra, and Abhishek Das. Not all demonstrations are created equal: An objectnav case study for effectively combining imitation and reinforcement learning. https: //github.com/Ram81/il_rl_baselines, 2022. 15
+
+# 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? [Yes]   
+(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)? [Yes]   
+(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? [Yes]   
+(e) Did you discuss whether the data you are using/curating contains personally identifiable information or offensive content? [Yes]
+
+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/VY1dqOF2RjC/VY1dqOF2RjC_content_list.json

@@ -0,0 +1,1145 @@
+[
+    {
+        "type": "text",
+        "text": "ZSON: Zero-Shot Object-Goal Navigation using Multimodal Goal Embeddings ",
+        "text_level": 1,
+        "bbox": [
+            209,
+            122,
+            790,
+            172
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Arjun Majumdar∗, Gunjan Aggarwal∗, Bhavika Devnani, Judy Hoffman, Dhruv Batra ",
+        "bbox": [
+            187,
+            224,
+            812,
+            241
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Georgia Institute of Technology ",
+        "bbox": [
+            393,
+            252,
+            602,
+            266
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Abstract ",
+        "text_level": 1,
+        "bbox": [
+            462,
+            308,
+            535,
+            324
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "We present a scalable approach for learning open-world object-goal navigation (ObjectNav) – the task of asking a virtual robot (agent) to find any instance of an object in an unexplored environment (e.g., “find a sink”). Our approach is entirely zero-shot – i.e., it does not require ObjectNav rewards or demonstrations of any kind. Instead, we train on the image-goal navigation (ImageNav) task, in which agents find the location where a picture (i.e., goal image) was captured. Specifically, we encode goal images into a multimodal, semantic embedding space to enable training semantic-goal navigation (SemanticNav) agents at scale in unannotated 3D environments (e.g., HM3D). After training, SemanticNav agents can be instructed to find objects described in free-form natural language (e.g., “sink,” “bathroom sink,” etc.) by projecting language goals into the same multimodal, semantic embedding space. As a result, our approach enables open-world ObjectNav. We extensively evaluate our agents on three ObjectNav datasets (Gibson, HM3D, and MP3D) and observe absolute improvements in success of $4 . 2 \\% \\textit { - } 2 0 . 0 \\%$ over existing zero-shot methods. For reference, these gains are similar or better than the $5 \\%$ improvement in success between the Habitat 2020 and 2021 ObjectNav challenge winners. In an open-world setting, we discover that our agents can generalize to compound instructions with a room explicitly mentioned (e.g., “Find a kitchen sink”) and when the target room can be inferred (e.g., “Find a sink and a stove”). ",
+        "bbox": [
+            232,
+            338,
+            766,
+            616
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 Introduction ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            648,
+            310,
+            666
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Imagine asking a home assistant robot to find a “flat-head screwdriver” or the “medicine case near the bathroom sink.” Building such assistive agents is a problem of deep scientific and societal value. ",
+        "bbox": [
+            174,
+            681,
+            823,
+            709
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "To study this problem systematically, the embodied AI community has rallied around a problem called object-goal navigation ( ObjectNav) [1]. Given the name of an object (e.g., “chair”), ObjectNav involves exploring a 3D environment to find any instance of the object. The last few years have witnessed the development of new environments [2–6], annotated 3D scans [7–9], datasets of human demonstrations [10], and approaches for ObjectNav [11–16], cumulatively leading to strong progress. For instance, the entries in the annual Habitat challenge [17] have jumped from $6 \\%$ success (DD-PPO baseline in 2020) to $53 \\%$ success (top entry in ongoing 2022 Habitat Challenge public leaderboard). ",
+        "bbox": [
+            174,
+            715,
+            825,
+            813
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "While this progress is exciting, we believe that a subtle but insidious assumption has snuck into this line of work: the closed-world assumption. We started by discussing an open-world scenario where a person may describe any object in language (e.g., “flat-head screwdriver”), but ObjectNav is currently formulated over a closed predetermined vocabulary of object categories (“chair”, “bed”, “sofa”, etc.), with approaches using pre-trained object detectors and segmenters for these categories [10– 13]. While this assumption may have been essential to get started on this problem, it is now important to move beyond it and ask – how can embodied agents find objects in an open-world setting? ",
+        "bbox": [
+            174,
+            819,
+            823,
+            875
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "image",
+        "img_path": "images/287e5d645e92d203ff553e5f117ddd25a77b20f01266fe5a82918a8ec4215b63.jpg",
+        "image_caption": [
+            "Figure 1: We propose projecting navigation goals (from images or text) into a common, semantic embedding space using a pre-trained vision and language model (CLIP). This allows agents trained with image-goals to understand goals expressed in free-form natural language (e.g., “Find a bathroom sink.”). Accordingly, our approach enables open-world object-goal navigation in a zero-shot manner – i.e., without using ObjectNav rewards or demonstrations for training. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            212,
+            87,
+            789,
+            382
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            492,
+            828,
+            535
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "In this work, we develop an approach for ObjectNav that is both zero-shot, i.e., does not require any ObjectNav rewards or demonstrations, and open-world, i.e., does not require committing to a taxonomy of categories. Our key insight is that we can create a visiolinguistic embedding space to decouple two problems – (1) describing and representing semantic goals (“chair”, “brown chair”, picture of brown chair) from (2) learning to navigate to semantic goals.2 ",
+        "bbox": [
+            174,
+            541,
+            825,
+            611
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "To represent semantic goals (1), we leverage recent advances in multimodal AI research on learning a common embedding space for images and text using large collections of image-captions pairs. Specifically, we use CLIP [19], a method for training dual vision and language encoders that produce similar representations for paired data such as an image and its caption. As shown in Fig. 1, we use CLIP to transform image-goals (e.g., a picture of the kitchen island) and object-goals (e.g., “bathroom sink”) into semantic-goals representing navigation targets. Our main observation is that a semanticgoal produced from an image (e.g., a picture of the bathroom sink) should be similar to semantic goals produced from descriptions of the same target (e.g, “bathroom sink”). Thus, we hypothesize that these modalities (images and language) can be used interchangeably for creating semantic goals. ",
+        "bbox": [
+            173,
+            617,
+            825,
+            742
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Accordingly, for learning to navigate to semantic goals (2), we train agents using image-goals encoded via CLIP’s image encoder. Then, we evaluate the learned navigation policy on ObjectNav, where goals are specified in language (e.g., “chair”) and encoded via CLIP’s text encoder. As a result, our agents perform ObjectNav without ever directly training for the task – i.e., in a zero-shot manner. ",
+        "bbox": [
+            174,
+            747,
+            825,
+            804
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "An important advantage of our approach is that it reduces the data labeling burden. Image-goals can be procedurally generated by randomly sampling points in 3D environments. This is in stark contrast to ObjectNav, which requires annotating 3D meshes [7–9] and potentially collecting large-scale human demonstrations [10] for training. Secondly, the interface to our agents is a natural language description – matching the grand vision that inspired the ObjectNav task. Through this interface we can refine object-goals by, for instance, specifying object attributes (“brown chair”) or indicating which room the object is in (“bathroom sink”) – which is not possible with traditional ObjectNav agents. ",
+        "bbox": [
+            174,
+            810,
+            825,
+            880
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            92,
+            821,
+            119
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "We perform large-scale experiments on three ObjectNav datasets – Gibson [4], MP3D [8], and HM3D [20]. Our zero-shot agent (that has not seen a single 3D semantic annotation or ObjectNav training episode) achieves a $3 1 . 3 \\%$ success in Gibson environments, which is a $2 0 . 0 \\%$ absolute improvement over previous zero-shot results [18]. In MP3D, our agent achieves $1 5 . 3 \\%$ success, a $4 . 2 \\%$ absolute gain over existing zero-shot methods[21]. For reference, these gains are on par or better than the $5 \\%$ improvement in success between the Habitat 2020 and 2021 ObjectNav challenge winners. On HM3D, our agent’s zero-shot SPL matches a state-of-the-art ObjectNav method [16] that trains with direct supervision from $4 0 \\mathrm { k }$ human demonstrations. ",
+        "bbox": [
+            174,
+            126,
+            825,
+            236
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Additionally, we study two techniques that are used in our approach to improve zero-shot ObjectNav performance. First, we find that pretraining the visual observation encoder has an outsized effect on zero-shot transfer. Specifically, success on the ImageNav training task improves $4 . 5 \\% - 5 . 8 \\%$ , while downstream success on zero-shot ObjectNav improves by $9 . 4 \\% - 1 0 . 4 \\%$ . Similarly, increasing the number of training environments (from 72 to 800) leads to a small drop in ImageNav success, but results in a substantial improvement of $6 . 6 \\%$ in success on zero-shot ObjectNav. ",
+        "bbox": [
+            174,
+            242,
+            825,
+            325
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Finally, we qualitatively experiment with an open-world setting and observe that our SemanticNav agents can properly change behavior in response to instructions that include room information. For instance, when finding a “bathroom sink” the agent does not enter the kitchen, and when looking for a “kitchen sink” it does not enter bathrooms. Furthermore, we observe similar room awareness patterns for instructions such as “Find a sink and a stove,” where the target room (“kitchen”) can be inferred. Source code for reproducing our results will be publicly released. ",
+        "bbox": [
+            174,
+            332,
+            825,
+            416
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "2 Related Work ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            434,
+            321,
+            452
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Our work builds on research studying image-text alignment techniques (e.g., CLIP [19]) and their use in visual navigation. In this section, we discuss methods most related to our proposed approach. ",
+        "bbox": [
+            176,
+            465,
+            825,
+            494
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Image-Text Alignment Models. Recent progress in vision-and-language pretraining has led to models such as CLIP [19], ALIGN [22], and BASIC [23] that can perform open-world image classification, and achieve strong performance on standard computer vision benchmarks (e.g., ImageNet [24]). These models learn visual representations by training on massive datasets of image-caption pairs scraped from the web (e.g., the 400M pairs used for CLIP or 6.6B for BASIC). In this work, we take advantage of the semantic representations learned by CLIP to project navigation goals (e.g., a picture of a brown chair or “brown chair”) into a multimodal, semantic-goal embedding space. ",
+        "bbox": [
+            174,
+            508,
+            825,
+            606
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "CLIP for Visual Navigation. A straightforward approach for using CLIP in a visual navigation agent is to process the agent’s observations and navigation instructions (e.g., “Find a chair”) with the CLIP image and text encoders, then learn a navigation policy that operates on these embeddings. Such a solution was explored in EmbCLIP [25] with promising results. However, this approach requires ObjectNav rewards or demonstrations to supervise the navigation policy, which is difficult and costly to collect at scale. As a result, existing training datasets tend to be small and agents generalize poorly to new settings. For instance, EmbCLIP only achieves an $8 \\%$ success rate in finding objects that were not used in training. By contrast, we train using the image-goal navigation task, which does not require annotated environments. Thus, we are able to scale training to 800 unannotated 3D scenes, which substantially improves generalization (as demonstrated in Section 5). ",
+        "bbox": [
+            174,
+            619,
+            825,
+            758
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Zero-Shot ObjectNav. Two recent works [18, 21] directly address our motivation (zero-shot ObjectNav) and are most related. First, ZER [18] proposes a two-stage framework in which an image-goal navigation (ImageNav) agent is first trained from scratch. Then, independent encoders are trained to map from various modalities (including language) into the image-goal embedding space. A key challenge with this approach is that image-goal embeddings may not capture semantic information because semantic annotations are not used in ImageNav training. Instead, an ImageNav agent trained from scratch may learn to pattern match visual observations and goal image embeddings. By contrast, our approach reverses these two stages, with CLIP pretraining representing stage one. Thus, our approach uses a goal embedding space that captures semantics by design. We empirically demonstrate the benefits of our proposed approach in Section 5. ",
+        "bbox": [
+            174,
+            772,
+            825,
+            911
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "image",
+        "img_path": "images/fde2231cc317d8dd7be7bbd213c2e3f3ddc6a4527727238bb0a3ecbce840fb74.jpg",
+        "image_caption": [
+            "Figure 2: We tackle both ImageNav and ObjectNav via a common SemanticNav agent. This agent accepts a semantic goal embedding $( s ^ { g } )$ , which comes from either CLIP’s visual encoder $\\textstyle ( \\mathtt { C L I P } _ { v } )$ in ImageNav or CLIP’s textual encoder $\\textstyle ( \\mathtt { C L I P } _ { t } )$ in ObjectNav. Our agent has a simple architecture: RGB observations are encoded with a pretrained ResNet-50, and a recurrent policy network predicts actions using encodings of the goal $s ^ { g }$ , observation, and the previous action $a _ { t - 1 }$ . "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            174,
+            89,
+            800,
+            348
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "In concurrent work, CLIP-on-Wheels (CoW) [21] uses a gradient-based visualization technique (GradCAM [26]) with CLIP to localize objects in the agent’s observations. This is combined with a heuristic exploration policy to enable zero-shot object-goal navigation. In contrast, we demonstrate that learning a navigation policy can substantially outperform the heuristic exploration approach proposed in [21] without using explicit object localization techniques. ",
+        "bbox": [
+            174,
+            486,
+            825,
+            556
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3 Preliminaries: Image-Text Alignment and Image-Goal Navigation ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            593,
+            753,
+            611
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Image-Text Alignment Models. Multimodal alignment models aim to learn a mapping from images $v$ and text $t$ into a shared embedding space such that representations for corresponding imagetext pairs (e.g., a picture and its caption) are similar. Recent image-text alignment models [19, 22, 23] use a dual-encoder framework and optimize the InfoNCE [27] contrastive learning objective, which maximizes cosine similarity between representations of matching image-text pairs and minimizes similarity for non-matching pairs. In this work, we leverage CLIP [19], which was trained on $4 0 0 \\mathbf { M }$ image-text pairs that cover a wide range of visual concepts. ",
+        "bbox": [
+            173,
+            636,
+            825,
+            733
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Image-Goal Navigation. In image-goal navigation (ImageNav) [28], agents explore an environment to find the position where a goal-image $v ^ { g }$ was captured. We consider a setting in which both the goal-image and the agent’s observations consist of RGB images taken from the agent’s egocentric point of view. An agent can select from four actions: MOVE_FORWARD by $0 . 2 5 \\mathrm { m }$ , TURN_LEFT by $3 0 ^ { \\circ }$ , TURN_RIGHT by $3 0 ^ { \\circ }$ , or STOP. The agent succeeds if it selects STOP within $1 . 0 \\mathrm { m }$ of the goal. ",
+        "bbox": [
+            174,
+            766,
+            825,
+            835
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "An ImageNav episode is uniquely defined by a starting position and (reachable) goal viewpoint within a 3D environment. Thus, ImageNav training data can be procedurally generated without annotating the scene – i.e., the objects and rooms do not need to be labeled. As a result, the size of an ImageNav dataset is only limited by the number of environments available for training. In this work, we use ImageNav to train visual navigation agents at scale (in terms of the number of training environments). ",
+        "bbox": [
+            174,
+            842,
+            825,
+            911
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "4 Approach ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            89,
+            287,
+            107
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "This section describes our framework for training visual navigation agents. We use CLIP [19] to produce semantic goal embeddings of image-goals (e.g., a picture of the sink) and object-goals (e.g., “sink”). This allows training semantic-goal navigation agents at scale using image-goals in HM3D environments [20], then deploying these agents for object-goal navigation in a zero-shot manner. In other words, our agents execute object-goal navigation without ever directly training for the task. ",
+        "bbox": [
+            171,
+            126,
+            825,
+            195
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "4.1 Learning Semantic-Goal Navigation ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            220,
+            464,
+            236
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "As illustrated in Fig. 2 (top-left), given an image-goal $v ^ { g }$ , we use a CLIP visual encoder $\\mathtt { C L I P } _ { v }$ to generate a semantic goal embedding $s _ { v } ^ { g } = \\mathtt { C L I P } _ { v } ( v ^ { g } )$ that is used to guide navigation. Conceptually, encoding image-goals with CLIP preserves semantic information about the goal, such as visual concepts that might be described in image captions (e.g., “a sofa in a living room”). However, semantic goal embeddings are less likely to include low-level features (e.g., the exact patterns in a wood floor) that do not correlate with web-scraped captions. While removing low-level information might make the navigation task more difficult, our goal is to learn a policy that transfers to ObjectNav in which agents only receives high-level goals (e.g., “Find a sofa”). As an added benefit, generating semantic goal embeddings as a pre-processing step substantially improves training time (by ${ \\sim } 3 . 5 \\mathrm { x }$ ). ",
+        "bbox": [
+            174,
+            250,
+            825,
+            375
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Our agent architecture is shown in Fig. 2. At each timestep $t$ , our agent receives an egocentric RGB observation $v _ { t }$ and a goal representation $s _ { v } ^ { g }$ . The observation is processed by a ResNet-50 [29] encoder, which is pretrained on the Omnidata Starter Dataset (OSD) [30] using self-supervised learning (DINO [31]) following the pretraining recipe presented in OVRL [16]. The output from the ResNet-50 encoder is concatenated with the goal representation $s _ { v } ^ { g }$ and an embedding of the agent’s previous action $a _ { t - 1 }$ and then passed to the policy network composed of a two-layer LSTM. The policy network outputs a distribution over the action space. ",
+        "bbox": [
+            173,
+            381,
+            825,
+            478
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "We train our SemanticNav agent with reinforcement learning (RL). During RL training, we use two data augmentation techniques: color jitter and random translation (adapted from [16]). Specifically, we train with DD-PPO [32] using a reward function proposed for ImageNav by Al-Halah et al. [18]: ",
+        "bbox": [
+            174,
+            484,
+            825,
+            526
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/545d5f7b1fe99a9b483dcadcb0de937b82d4fd31d472375847c2072d1e3af6de.jpg",
+        "text": "$$\nr _ { t } = r _ { \\mathrm { s u c c e s s } } + r _ { \\mathrm { a n g l e - s u c c e s s } } - \\Delta _ { \\mathrm { d t g } } - \\Delta _ { \\mathrm { a t g } } + r _ { \\mathrm { s l a c k } }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            338,
+            541,
+            658,
+            559
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "where $r _ { \\mathrm { s u c c e s s } } = 5$ if STOP is called when the agent is within $1 \\mathrm { m }$ of the goal position (and 0 otherwise), $r _ { \\mathrm { a n g l e - s u c c e s s } } = 5$ if STOP is called when the agent is within $1 \\mathrm { m }$ of the goal position and the agent is pointing within $2 5 ^ { \\circ }$ of the goal heading – i.e., the direction the camera was pointing when the goal image was collected – (and 0 otherwise), $\\Delta _ { \\mathrm { d t g } }$ is the change in the agent’s distance-to-goal – i.e., the geodesic distance to the goal position, $\\Delta _ { \\mathrm { a t g } }$ is the change in the agent’s angle-to-goal – i.e., the difference between the agent’s heading and the goal heading – but is set to 0 if the agent is greater than $1 \\mathrm { m }$ from the goal, and $r _ { \\mathrm { s l a c k } } = - 0 . 0 1$ to encourage efficient navigation. In general, this reward function encourages both reaching the goal and looking towards the goal before calling STOP, which matches the requirements of the downstream ObjectNav task. ",
+        "bbox": [
+            173,
+            571,
+            825,
+            698
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "4.2 Zero-Shot Object-Goal Navigation ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            723,
+            452,
+            738
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Recall that in ObjectNav [1], agents are given a target category (e.g., “sofa” or “chair”) and must locate any instance of that object (i.e., “any sofa” or “any chair”). Similar to ImageNav, ObjectNav requires exploring new environments that the agent has never seen before. However, in ObjectNav, the goal (e.g., “sofa”) provides a minimal amount of information about where the agent must go and it requires recognizing any version of the goal object in the new scene. ",
+        "bbox": [
+            174,
+            752,
+            825,
+            821
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "To address this task, we transform object-goals $o ^ { g }$ (e.g., “sofa”) into semantic goal embeddings using the CLIP text encoder ${ \\mathrm { C L I P } } _ { t }$ , which results in the semantic goal $s _ { o } ^ { g } = \\mathtt { C L I P } _ { t } ( o ^ { g } )$ . CLIP aligns image and text, thus the semantic goals from text $s _ { o } ^ { g }$ should be close (in terms of cosine similarity) to the CLIP visual embeddings $s _ { v } ^ { g }$ used in training. To keep our approach simple and easily reproducible, we do not use any prompt engineering (e.g., using a template such as $^ { 6 6 } \\mathtt { A }$ photo of a $< > ^ { \\dag \\dag } ,$ ). Instead, we simply use the object name (e.g., “sofa”) as the object-goal input $o ^ { g }$ . ",
+        "bbox": [
+            174,
+            827,
+            825,
+            911
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "5 Experimental Findings and Qualitative Results ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            88,
+            598,
+            107
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "This section studies the zero-shot ObjectNav performance of our proposed approach. First, we evaluate our method in the traditional ObjectNav setting [1] where agents must find any instance of the goal object (“Find a chair”). Then, we explore variations of ObjectNav in which additional information, such as a room location (e.g., “bathroom sink”), is given to refine the task. These experiments aim to demonstrate both the effectiveness and versatility of our approach. ",
+        "bbox": [
+            174,
+            119,
+            825,
+            189
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "5.1 Experimental Setup ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            205,
+            351,
+            220
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Training Dataset. We generate a dataset for training our SemanticNav agent using the 800 training environments from HM3D [20]. First, we sample 9k ImageNav episodes for each HM3D scan, split equally between 3 difficulty levels corresponding with path length: EASY $( 1 . 5 \\mathrm { - } 3 \\mathrm { m } )$ , MEDIUM (3- $5 \\mathrm { m } )$ , and HARD $( 5 \\mathrm { - } 1 0 \\mathrm { m } )$ . We follow the episode generation approach from [33]. This results in $9 \\mathbf { k } \\times 8 0 0 = 7 . 2 \\mathbf { M }$ navigation episodes for training. Next, we pre-process the goal-images with the ResNet-50 version of CLIP [19] to produce 1024 dimensional semantic goal vectors $s _ { v } ^ { g }$ for each navigation episode. During pre-processing, we further augment the dataset by sampling goal-images at four evenly-spaced heading angles to produce 36M total episodes for training. Sampling at multiple angles approximates the randomized sampling used in [18]. ",
+        "bbox": [
+            173,
+            231,
+            825,
+            356
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Agent Configurations. Two different agent configurations are frequently used in prior work on visual navigation. Configuration A is generally used for ImageNav and has an agent height of $1 . 5 \\mathrm { m }$ , radius of $0 . 1 \\mathrm { m }$ , and a single $1 2 8 \\times 1 2 8$ RGB sensor with a $9 0 ^ { \\circ }$ horizontal field-of-view (HFOV) placed $1 . 2 5 \\mathrm { m }$ from the ground. Configuration B is typically used for ObjectNav and approximately matches a LoCoBot, with an agent height of $0 . 8 8 \\mathrm { m }$ , radius of $0 . 1 8 \\mathrm { m }$ , and a single $6 4 0 \\times 4 8 0$ RGB sensor with a $7 9 ^ { \\circ }$ HFOV placed $0 . 8 8 \\mathrm { m }$ from the ground. Both configurations use the aforementioned step size of $0 . 2 5 \\mathrm { m }$ and left and right turning angle of $3 0 ^ { \\circ }$ . ",
+        "bbox": [
+            173,
+            369,
+            825,
+            467
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Evaluation Datasets. We measure performance on one ImageNav and three ObjectNav datasets: ",
+        "bbox": [
+            174,
+            482,
+            821,
+            496
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "– ImageNav (Gibson) consists of 4,200 episodes from 14 Gibson [4] validation scenes. The dataset was produced by Mezghani et al. [33] for agents with configuration A. – ObjectNav (Gibson) was generated by Al-Halah et al. [18] for agents with configuration A. The dataset consists of 1,000 episodes in 5 Gibson [4] validation scenes for 6 object categories. ObjectNav (HM3D), released with the Habitat 2022 challenge, consists of 2,000 episodes from 20 HM3D [20] validation scenes with objects from 6 categories, and uses agents with configuration B. ObjectNav (MP3D) released with the Habitat 2020 challenge, contains 2,195 episodes from 11 MP3D [8] validation scenes for 21 object categories, and requires agents with configuration B. ",
+        "bbox": [
+            171,
+            506,
+            826,
+            625
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Due to the different agent configurations required by these evaluation datasets, we train agents with both settings to make fair comparisons with prior work on zero-shot ObjectNav. For all experiments, we report two standard metrics for visual navigation tasks: success rate (SR) and success rate weighted by normalized inverse path length (SPL) [34]. ",
+        "bbox": [
+            174,
+            635,
+            825,
+            690
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Implementation Details. We generate a SemanticNav dataset for each agent configuration (A and B). The CLIP ResNet-50 encoder processes $2 2 4 \\times 2 2 4$ images. Accordingly, for configuration A, we render $5 1 2 \\times 5 1 2$ RGB frames, then resize to $2 2 4 \\times 2 2 4$ . For configuration B, we render at $6 4 0 \\times$ 480, then resize and center crop. We train agents using PyTorch [35] and the Habitat simulator [2, 3]. Each training run was conducted on a single compute node with 8 NVIDIA A40 GPUs. We train agents for 500M steps, requiring $\\mathord { \\sim } 1 , 7 0 4$ GPU-hours to train two agents (one for each configuration). Additional training hyperparamters are detailed in the Appendix. We report results using the best checkpoint, selected based on ObjectNav validation success rate (SR). During evaluations we sample actions from the agent’s output distribution. We report results averaged over three evaluation runs. ",
+        "bbox": [
+            173,
+            705,
+            825,
+            830
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Baselines. We provide comparisons with the, to the best of our knowledge, only two existing zero-shot methods for object-goal navigation (ObjectNav): ",
+        "bbox": [
+            171,
+            844,
+            823,
+            872
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "– Zero Experience Required (ZER) [18]: first trains an ImageNav agent composed of two ResNet-9 encoders for processing the goal-image and agent observations, and a policy network consisting of a 2-layer GRU. After training the navigation policy, a 2-layer MLP is trained to map from a goal object categories into the goal-image embedding space learned through ImageNav training. This mapping is learned using an in-domain dataset containing 14K images with object category labels. ",
+        "bbox": [
+            173,
+            883,
+            821,
+            911
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "table",
+        "img_path": "images/5e128d7ab7e38cca0daa7709098c3ca9f20c887a9bd7de3df955f35eb151b378.jpg",
+        "table_caption": [
+            "Table 1: Zero-shot ObjectNav performance on Gibson [4], HM3D [20], and MP3D [8] validation. All methods use a single RGB sensor for agent observations except CoW [21], which also uses depth observations and OVRL [16], which uses $\\mathtt { G P S + }$ Compass for ObjectNav. Our approach (ZSON) substantially improves on previous zero-shot methods and narrows the gap to SOTA fully-supervised methods such as OVRL [16], which is not zero-shot and provided for reference. We report ZSON results averaged over three evaluation trials. The standard deviation in ZSON ObjectNav SR is $0 . 0 2 \\%$ in Gibson, $0 . 4 6 \\%$ in HM3D, and $0 . 1 1 \\%$ in MP3D. ∗indicates reproduced results "
+        ],
+        "table_footnote": [
+            "(a) Configuration A "
+        ],
+        "table_body": "<table><tr><td></td><td colspan=\"2\">ImageNav (Gibson)</td><td colspan=\"2\">ObjectNav (Gibson)</td></tr><tr><td>Method</td><td>SPL</td><td>SR</td><td>SPL</td><td>sr</td></tr><tr><td>OVRL [16]</td><td>27.0%</td><td>54.2%</td><td></td><td></td></tr><tr><td>ZER [18]</td><td>21.6%</td><td>29.2%</td><td></td><td>11.3%</td></tr><tr><td>ZSON (ours)</td><td>28.0%</td><td>36.9%</td><td>12.0%</td><td>31.3%</td></tr></table>",
+        "bbox": [
+            176,
+            204,
+            488,
+            300
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "table",
+        "img_path": "images/bf56dadd7a33c6dfe8e683001956406bee3a27e05980ea0e7733ad7953069e17.jpg",
+        "table_caption": [],
+        "table_footnote": [
+            "(b) Configuration B "
+        ],
+        "table_body": "<table><tr><td></td><td colspan=\"2\">ObjectNav (HM3D)</td><td colspan=\"2\">ObjectNav (MP3D)</td></tr><tr><td>Method</td><td>SPL</td><td>Sr</td><td>SPL</td><td>Sr</td></tr><tr><td>OVRL [16]</td><td>12.3%*</td><td>32.8%*</td><td>7.0%</td><td>25.3%</td></tr><tr><td>CoW [21] (w/depth)</td><td>-</td><td>-</td><td>6.3%</td><td>11.1%</td></tr><tr><td>ZSON (ours)</td><td>12.6%</td><td>25.5%</td><td>4.8%</td><td> 15.3%</td></tr></table>",
+        "bbox": [
+            513,
+            204,
+            823,
+            300
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            186,
+            363,
+            825,
+            405
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "– CLIP on Wheels (CoW) [21]: builds an occupancy map by projecting depth observations, then searches the environment with frontier-based exploration [36]. At each step, CoW calculates a 3D saliency map using a depth and RGB observations and the goal object category via Grad-CAM [26], a gradient-based visualization technique. When the 3D saliency exceeds a threshold the agent navigates to that location and stops. As such, CoW does not require a learned navigation policy. ",
+        "bbox": [
+            171,
+            410,
+            825,
+            481
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Fully-Supervised ObjectNav. To understand the gap to fully-supervised ObjectNav methods, we compare with OVRL [16], a two-stage framework that achieves state-of-the-art ObjectNav results in our single RGB camera setting. We highlight OVRL in blue to indicate the use of direct supervision. ",
+        "bbox": [
+            173,
+            503,
+            825,
+            546
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "5.2 Zero-Shot Object-Goal Navigation ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            570,
+            452,
+            587
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "In Table 1 we report zero-shot ObjectNav performance. We compare with ZER [18] in Table 1a using agent configuration A. Notice that our agent is stronger than ZER on ImageNav, which is the base pretraining task before ObjectNav can be studied. Specifically, we observe a $7 . 7 \\%$ improvement in ImageNav SR $( 2 9 . 2 \\%  3 6 . 9 \\% )$ . This improvement results from (1) learning to navigate to semantic goal embeddings (as proposed in this work) instead of navigating to image-goal embeddings that are learned from scratch (as done in ZER), (2) using more diverse training environments, and (3) from using a pretrained visual encoder. We provide additional comparisons with ZER using the same set of training environments and without using visual encoder pretraining in Section 5.3, where we also observe improved performance. In Table 1a, we see even larger improvements in ObjectNav SR of $2 0 . 0 \\%$ $1 1 . 3 \\%  3 1 . 3 \\% )$ . These results indicate that our design decisions are particularly useful for zero-shot ObjectNav. ",
+        "bbox": [
+            174,
+            599,
+            825,
+            752
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "In Table 1b we compare with CoW [21] using agent configuration B. In ObjectNav on the MP3D validation set, we find that training a SemanticNav agent improves ObjectNav SR by $4 . 2 \\%$ absolute and $3 7 . 8 \\%$ relative $1 1 . 1 \\%  1 5 . 3 \\%$ ). These results demonstrate that learning a navigation policy improves zero-shot ObjectNav SR over the hand-designed exploration strategy and stopping criteria proposed by $\\mathbf { \\mathrm { C o W } } .$ Moreover, we expect further improvements in zero-shot ObjectNav performance from scaling our approach (e.g., by collecting more training environments). Such scaling is simply not possible with heuristic methods such as $\\mathbf { \\mathrm { C o W } }$ because the navigation policy is not learned. The SPL of our approach is $1 . 5 \\%$ lower than CoW. However, unlike CoW, our agent navigates without depth observations, which may reduce path efficiency. On HM3D we find that our agent achieves a strong SR of $2 5 . 5 \\%$ and SPL of $12 . 6 \\%$ . Impressively, this zero-shot SPL matches OVRL [16], which is directly trained on $4 0 \\mathrm { k }$ human demonstrations [10] for the ObjectNav task with imitation learning. ",
+        "bbox": [
+            174,
+            758,
+            825,
+            911
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "5.3 Comparison with ZER without Encoder Pretraining and Training Environment Diversity ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            90,
+            823,
+            107
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "In Table 2, we train our approach in Gibson environments (instead of HM3D) and do not use a pretrained observation encoder. These settings match ZER [18], allowing for a direct comparison between the two methods. We observe that our approach results in a $4 . 0 \\%$ absolute and $3 5 \\%$ relative improvement in zero-shot ObjectNav success $1 1 . 3 \\%  1 5 . 3 \\% )$ . These results demonstrate that learning to navigate to semantic-goal embeddings outperforms the inverse approach proposed by ZER of first training for image-goal navigation, then learning a mapping from object categories into the image-goal embedding space. ",
+        "bbox": [
+            173,
+            116,
+            825,
+            214
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "table",
+        "img_path": "images/fe005e2fed223305b0f0b937d46d1290ccc1fab40365622b819c3005cb8e9372.jpg",
+        "table_caption": [
+            "Table 2: Comparison with ZER [18] using a ResNet-9 and the Gibson dataset with our approach. Learning SemanticNav (Ours) outperforms learning ImageNav then language grounding (ZER [18]). "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td></td><td></td><td></td><td colspan=\"2\">ImageNav (Gibson)</td><td colspan=\"2\">ObjectNav (Gibson)</td></tr><tr><td>Method</td><td>Visual Encoder</td><td>Training Dataset</td><td>SPL</td><td>SR</td><td>SPL</td><td>SR</td></tr><tr><td>ZER [18]</td><td>ResNet-9</td><td>Gibson</td><td>21.6%</td><td>29.2%</td><td>■</td><td>11.3%</td></tr><tr><td>Ours</td><td>ResNet-9</td><td>Gibson</td><td>22.8%</td><td>33.3%</td><td>7.4%</td><td>15.3%</td></tr></table>",
+        "bbox": [
+            302,
+            272,
+            691,
+            364
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "5.4 Additional Ablations ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            385,
+            357,
+            400
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "In Table 3, we study the impact of two key design decisions within our method: (1) the visual observation encoder and (2) the number of training environments. While pretraining the visual observation encoder is known to improve visual navigation task performance (demonstrated in [16]), here we study the impacts on zero-shot transfer to ObjectNav. We find that OVRL pretraining improves ImageNav success by $4 . 5 \\%$ (rows 1 vs. 3) or $5 . 8 \\%$ (rows 2 vs. 4) depending on the dataset used for training. However, the impact on zero-shot ObjectNav performance is substantially larger. Specifically, ObjectNav success improves by $9 . 4 \\%$ (rows 1 vs. 3) and $1 0 . 4 \\%$ (rows 2 vs. 4). These results suggest that a strong visual encoder is often essential for zero-shot transfer to ObjectNav. ",
+        "bbox": [
+            173,
+            410,
+            825,
+            522
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "In rows 3 vs. 4, we switch the training dataset from the 72 Gibson [4] training environments (row 3) to the 800 (unannotated) HM3D [20] training environments. Surprisingly, we observe a $0 . 9 \\%$ drop in ImageNav success, yet a $6 . 6 \\%$ improvement in ObjectNav success (rows 3 vs. 4). A similar trend is observed in rows 1 vs. 2. These trends indicate that training environment diversity is particularly useful for zero-shot ObjectNav. ",
+        "bbox": [
+            174,
+            527,
+            825,
+            598
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "table",
+        "img_path": "images/7af9c6d13b03535b1ae895a841c043bd6da81af0553628c0120a63df271371f0.jpg",
+        "table_caption": [
+            "Table 3: Ablations of the visual encoder and dataset used for training our SemanticNav agents. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td></td><td></td><td></td><td colspan=\"2\">ImageNav (Gibson)</td><td colspan=\"2\">ObjectNav (Gibson)</td></tr><tr><td>#</td><td>Visual Encoder</td><td>Training Dataset</td><td>SPL</td><td>SR</td><td>SPL</td><td>Sr</td></tr><tr><td>1</td><td>ResNet-9 from scratch</td><td>Gibson</td><td>22.8%</td><td>33.3%</td><td>7.4%</td><td>15.3%</td></tr><tr><td>2</td><td>ResNet-9 from scratch</td><td>HM3D</td><td>23.4%</td><td>31.1%</td><td>9.5%</td><td>20.9%</td></tr><tr><td>3</td><td>OVRL (ResNet-50,pretrained)</td><td>Gibson</td><td>27.6%</td><td>37.8%</td><td>10.0%</td><td>24.7%</td></tr><tr><td>4</td><td>OVRL (ResNet-50, pretrained)</td><td>HM3D</td><td>28.0%</td><td>36.9%</td><td>12.0%</td><td> 31.3%</td></tr></table>",
+        "bbox": [
+            236,
+            642,
+            756,
+            781
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "5.5 Qualitative Analysis ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            803,
+            354,
+            818
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "In Fig. 3, we present qualitative examples of our agent navigating to more complex object descriptions (e.g., $^ { \\ast \\ast } F i n d a b a t h r o o m s i n k ^ { \\prime \\prime } )$ . In each trial, the agent starts at the same position and heading (next to the front door looking into the house). The only thing that changes about the initial conditions is the instructions given to the agent (“Find a...” “...bathroom sink”, “...kitchen sink” .sink and a toilet”, or “...sink and a stove”). Since the agent’s policy is stochastic, we show 5 sampled rollouts and highlight the first run in bold colors. ",
+        "bbox": [
+            174,
+            827,
+            825,
+            911
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "image",
+        "img_path": "images/af741677d13d6a231b10160d5204bd67e32a690020f006bd78e11c2c60ffa425.jpg",
+        "image_caption": [
+            "Figure 3: Qualitative examples for navigating to complex object descriptions. For each trail, the agent is spawned at the start position looking into the house (i.e., to the right on the maps) and given one of four instructions. Each instruction is run five times with the path for the first trail highlighted in bold colors. Our agent appropriately navigates to the correct rooms, demonstrating an understanding of both explicit (“Find a kitchen sink”) and implicit (“Find a sink and a stove”) room information. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            171,
+            88,
+            823,
+            550
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "We find that given room information such as “bathroom” or “kitchen”, the agent appropriately finds a “sink” in the corresponding rooms in the house. Furthermore, in these examples the agent does not enter the “kitchen” when prompted to look for a $^ { \\cdots } b a t h r o o m \\ s i n k , ^ { \\prime \\prime }$ and vice-versa. In these long trajectories (ranging from 88 to 225 steps), we observe more exploration in the living room and direct navigation when target rooms are visible. We qualitatively observe interesting learned behaviors – for instance, the agent often performs a $3 6 0 ^ { \\circ }$ turn before navigating, possibly to survey the environment. ",
+        "bbox": [
+            173,
+            674,
+            825,
+            757
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Next, we experiment with variations in which room information can be inferred from the instruction, but is not explicit. We use “sink and a toilet” to indicate “bathroom” and “sink and a stove” for “kitchen”. In these examples, we discover that our agent still navigates to the correct rooms, suggesting that it learns some priors of indoor spaces, such as that a “stove” is often found within a “kitchen.” ",
+        "bbox": [
+            173,
+            763,
+            825,
+            819
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "6 Discussion ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            838,
+            292,
+            854
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "We present a zero-shot method for learning open-world object-goal navigation (ObjectNav). Our approach involves projecting image-goals into a semantic-goal embedding space using an image-and-text alignment model (CLIP). This creates a semantic-goal navigation task that does not require annotated ",
+        "bbox": [
+            174,
+            869,
+            825,
+            911
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "3D environments or collecting human demonstrations. Thus, our method is easy to scale. We discover that SemanticNav agents outperform previous zero-shot ObjectNav methods, and we identify two factors that have a strong impact on navigation success – pretraining the visual encoder and training in a diverse set of environments. In an open-world setting, we observe navigation patterns that suggest that SemanticNav agents can understand complex instructions, such as “Find a sink and a stove.” ",
+        "bbox": [
+            174,
+            92,
+            825,
+            160
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Limitations and Impact. SemanticNav agents appear to learn useful priors of indoor environments such as which room contains a “stove.” However, agents may struggle in scenes where a navigation target is in an unusual location (e.g., a stove in a bedroom). Biases in the 3D environments used to train such agents might exaggerate these issues and affect deployments in non-traditional settings. Thus, interventions to mitigate this problem should be considered. Future work might explore how to use the natural language interface to SemanticNav agents to guide exploration in such scenarios. ",
+        "bbox": [
+            174,
+            176,
+            825,
+            258
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Acknowledgements ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            279,
+            338,
+            295
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "The Georgia Tech effort was supported in part by NSF, ONR YIP, ARO PECASE, and ARL. The views and conclusions contained herein are those of the authors and should not be interpreted as necessarily representing the official policies or endorsements, either expressed or implied, of the U.S. Government, or any sponsor. ",
+        "bbox": [
+            174,
+            309,
+            826,
+            364
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "References ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            383,
+            266,
+            400
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "[1] Dhruv Batra, Aaron Gokaslan, Aniruddha Kembhavi, Oleksandr Maksymets, Roozbeh Mottaghi, Manolis Savva, Alexander Toshev, and Erik Wijmans. Objectnav Revisited: On Evaluation of Embodied Agents Navigating to Objects. arXiv preprint arXiv:2006.13171, 2020. 1, 5, 6   \n[2] Manolis Savva, Abhishek Kadian, Oleksandr Maksymets, Yili Zhao, Erik Wijmans, Bhavana Jain, Julian Straub, Jia Liu, Vladlen Koltun, Jitendra Malik, et al. Habitat: A platform for embodied ai research. In ICCV, 2019. 1, 6, 15   \n[3] Andrew Szot, Alexander Clegg, Eric Undersander, Erik Wijmans, Yili Zhao, John Turner, Noah Maestre, Mustafa Mukadam, Devendra Singh Chaplot, Oleksandr Maksymets, et al. Habitat 2.0: Training home assistants to rearrange their habitat. NeurIPS, 2021. 6   \n[4] Fei Xia, Amir R Zamir, Zhiyang He, Alexander Sax, Jitendra Malik, and Silvio Savarese. Gibson Env: Real-World Perception for Embodied Agents. In CVPR, pages 9068–9079, 2018. 3, 6, 7, 8, 15   \n[5] Eric Kolve, Roozbeh Mottaghi, Winson Han, Eli VanderBilt, Luca Weihs, Alvaro Herrasti, Daniel Gordon, Yuke Zhu, Abhinav Gupta, and Ali Farhadi. AI2-THOR: An Interactive 3D Environment for Visual AI. arXiv, 2017.   \n[6] Ben Talbot, David Hall, Haoyang Zhang, Suman Raj Bista, Rohan Smith, Feras Dayoub, and Niko Sünderhauf. BenchBot: Evaluating Robotics Research in Photorealistic 3D Simulation and on Real Robots, 2020. 1   \n[7] Angel X. Chang, Thomas Funkhouser, Leonidas Guibas, Pat Hanrahan, Qixing Huang, Zimo Li, Silvio Savarese, Manolis Savva, Shuran Song, Hao Su, Jianxiong Xiao, Li Yi, and Fisher Yu. ShapeNet: An Information-Rich 3D Model Repository. Technical Report arXiv:1512.03012 [cs.GR], Stanford University — Princeton University — Toyota Technological Institute at Chicago, 2015. 1, 2   \n[8] Angel Chang, Angela Dai, Thomas Funkhouser, Maciej Halber, Matthias Niessner, Manolis Savva, Shuran Song, Andy Zeng, and Yinda Zhang. Matterport3D: Learning from RGB-D Data in Indoor Environments. In ThreeDV, 2017. MatterPort3D dataset license: http://kaldir.vc.in.tum.de/matterport/MP_ TOS.pdf. 3, 6, 7, 15   \n[9] Iro Armeni, Zhi-Yang He, JunYoung Gwak, Amir R Zamir, Martin Fischer, Jitendra Malik, and Silvio Savarese. 3D Scene Graph: A Structure for Unified Semantics, 3D Space, and Camera. In ICCV, 2019. 1, 2   \n[10] Ram Ramrakhya, Eric Undersander, Dhruv Batra, and Abhishek Das. Habitat-web: Learning embodied object-search strategies from human demonstrations at scale. In CVPR, 2022. 1, 2, 7, 14   \n[11] Devendra Singh Chaplot, Dhiraj Gandhi, Abhinav Gupta, and Ruslan Salakhutdinov. Object goal navigation using goal-oriented semantic exploration. In NeurIPS, 2020. 1   \n[12] Joel Ye, Dhruv Batra, Abhishek Das, and Erik Wijmans. Auxiliary tasks and exploration enable objectnav. In ICCV, 2021.   \n[13] Oleksandr Maksymets, Vincent Cartillier, Aaron Gokaslan, Erik Wijmans, Wojciech Galuba, Stefan Lee, and Dhruv Batra. Thda: Treasure hunt data augmentation for semantic navigation. In ICCV, 2021. 2, 14   \n[14] Yiqing Liang, Boyuan Chen, and Shuran Song. SSCNav: Confidence-Aware Semantic Scene Completion for Visual Semantic Navigation. In ICRA, 2021.   \n[15] Haokuan Luo, Albert Yue, Zhang-Wei Hong, and Pulkit Agrawal. Stubborn: A Strong Baseline for Indoor Object Navigation. arXiv preprint arXiv:2203.07359, 2022.   \n[16] Karmesh Yadav, Ram Ramrakhya, Arjun Majumdar, Vincent-Pierre Berges, Sachit Kuhar, Dhruv Batra, Alexei Baevski, and Oleksandr Maksymets. Offline Visual Representation Learning for Embodied Navigation. arXiv preprint arXiv:2204.13226, 2022. 1, 3, 5, 7, 8, 14, 15   \n[17] Karmesh Yadav, Santhosh Kumar Ramakrishnan, Aaron Gokaslan, Oleksandr Maksymets, Rishabh Jain, Ram Ramrakhya, Angel X Chang, Alexander Clegg, Manolis Savva, Eric Undersander, Devendra Singh Chaplot, and Dhruv Batra. Habitat challenge 2022. https://aihabitat.org/challenge/2022/, 2022. 1   \n[18] Ziad Al-Halah, Santhosh K Ramakrishnan, and Kristen Grauman. Zero Experience Required: Plug & Play Modular Transfer Learning for Semantic Visual Navigation. arXiv preprint arXiv:2202.02440, 2022. 2, 3, 5, 6, 7, 8, 14, 15   \n[19] 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 ICML, 2021. 2, 3, 4, 5, 6, 14   \n[20] Santhosh Kumar Ramakrishnan, Aaron Gokaslan, Erik Wijmans, Oleksandr Maksymets, Alexander Clegg, John M Turner, Eric Undersander, Wojciech Galuba, Andrew Westbury, Angel X Chang, Manolis Savva, Yili Zhao, and Dhruv Batra. Habitat-matterport 3d dataset (HM3d): 1000 large-scale 3d environments for embodied AI. In NeurIPS Datasets and Benchmarks Track, 2021. 3, 5, 6, 7, 8, 15   \n[21] Samir Yitzhak Gadre, Mitchell Wortsman, Gabriel Ilharco, Ludwig Schmidt, and Shuran Song. CLIP on Wheels: Zero-Shot Object Navigation as Object Localization and Exploration. arXiv preprint arXiv:2203.10421, 2022. 3, 4, 7, 14   \n[22] Chao Jia, Yinfei Yang, Ye Xia, Yi-Ting Chen, Zarana Parekh, Hieu Pham, Quoc Le, Yun-Hsuan Sung, Zhen Li, and Tom Duerig. Scaling Up Visual and Vision-Language Representation Learning With Noisy Text Supervision. In ICML, 2021. 3, 4   \n[23] Hieu Pham, Zihang Dai, Golnaz Ghiasi, Hanxiao Liu, Adams Wei Yu, Minh-Thang Luong, Mingxing Tan, and Quoc V Le. Combined Scaling for Zero-shot Transfer Learning. arXiv preprint arXiv:2111.10050, 2021. 3, 4   \n[24] Jia Deng, Wei Dong, Richard Socher, Li-Jia Li, Kai Li, and Li Fei-Fei. Imagenet: A Large-Scale Hierarchical Image Database. In CVPR, 2009. 3   \n[25] Apoorv Khandelwal, Luca Weihs, Roozbeh Mottaghi, and Aniruddha Kembhavi. Simple but Effective: CLIP Embeddings for Embodied AI. arXiv preprint arXiv:2111.09888, 2021. 3, 14   \n[26] Ramprasaath R Selvaraju, Michael Cogswell, Abhishek Das, Ramakrishna Vedantam, Devi Parikh, and Dhruv Batra. Grad-CAM: Visual Explanations from Deep Networks via Gradient-Based Localization. In ICCV, 2017. 4, 7   \n[27] Aaron van den Oord, Yazhe Li, and Oriol Vinyals. Representation learning with contrastive predictive coding. arXiv preprint arXiv:1807.03748, 2018. 4   \n[28] Yuke Zhu, Roozbeh Mottaghi, Eric Kolve, Joseph J. Lim, Abhinav Kumar Gupta, Li Fei-Fei, and Ali Farhadi. Target-driven Visual Navigation in Indoor Scenes using Deep Reinforcement Learning. ICRA, 2017. 4   \n[29] Kaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. Deep Residual Learning for Image Recognition. In CVPR, 2016. 5   \n[30] Ainaz Eftekhar, Alexander Sax, Jitendra Malik, and Amir Zamir. Omnidata: A Scalable Pipeline for Making Multi-Task Mid-Level Vision Datasets From 3D Scans. In ICCV, 2021. 5 ",
+        "bbox": [
+            171,
+            398,
+            826,
+            917
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            169,
+            59,
+            828,
+            921
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "[31] Mathilde Caron, Hugo Touvron, Ishan Misra, Hervé Jégou, Julien Mairal, Piotr Bojanowski, and Armand Joulin. Emerging Properties in Self-Supervised Vision Transformers. In ICCV, 2021. 5 ",
+        "bbox": [
+            169,
+            92,
+            823,
+            118
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "[32] Erik Wijmans, Abhishek Kadian, Ari Morcos, Stefan Lee, Irfan Essa, Devi Parikh, Manolis Savva, and Dhruv Batra. DD-PPO: Learning Near-Perfect PointGoal Navigators from 2.5 Billion Frames. In ICLR, 2019. 5 ",
+        "bbox": [
+            174,
+            127,
+            821,
+            165
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "[33] Lina Mezghani, Sainbayar Sukhbaatar, Thibaut Lavril, Oleksandr Maksymets, Dhruv Batra, Piotr Bojanowski, and Karteek Alahari. Memory-Augmented Reinforcement Learning for Image-Goal Navigation. arXiv preprint arXiv:2101.05181, 2021. 6 ",
+        "bbox": [
+            173,
+            174,
+            823,
+            213
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "[34] Peter Anderson, Angel Chang, Devendra Singh Chaplot, Alexey Dosovitskiy, Saurabh Gupta, Vladlen Koltun, Jana Kosecka, Jitendra Malik, Roozbeh Mottaghi, Manolis Savva, et al. On Evaluation of Embodied Navigation Agents. arXiv preprint arXiv:1807.06757, 2018. 6 ",
+        "bbox": [
+            173,
+            222,
+            823,
+            262
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "[35] 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 NeurIPS, 2019. 6 ",
+        "bbox": [
+            173,
+            270,
+            826,
+            333
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "[36] Brian Yamauchi. A frontier-based approach for autonomous exploration. In CIRA, 1997. 7 [37] Ram Ramrakhya, Erik Wijmans, Dhruv Batra, and Abhishek Das. Not all demonstrations are created equal: An objectnav case study for effectively combining imitation and reinforcement learning. https: //github.com/Ram81/il_rl_baselines, 2022. 15 ",
+        "bbox": [
+            173,
+            343,
+            743,
+            357
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            176,
+            366,
+            823,
+            405
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Checklist ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            431,
+            254,
+            446
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "1. For all authors... ",
+        "bbox": [
+            214,
+            458,
+            339,
+            472
+        ],
+        "page_idx": 11
+    },
+    {
+        "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? [Yes]   \n(d) Have you read the ethics review guidelines and ensured that your paper conforms to them? [Yes] ",
+        "bbox": [
+            238,
+            477,
+            825,
+            568
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "2. If you are including theoretical results... ",
+        "bbox": [
+            214,
+            571,
+            493,
+            587
+        ],
+        "page_idx": 11
+    },
+    {
+        "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,
+            590,
+            736,
+            621
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "3. If you ran experiments... ",
+        "bbox": [
+            212,
+            626,
+            393,
+            640
+        ],
+        "page_idx": 11
+    },
+    {
+        "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)? [Yes]   \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,
+            643,
+            825,
+            762
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "4. If you are using existing assets (e.g., code, data, models) or curating/releasing new assets... ",
+        "bbox": [
+            217,
+            766,
+            825,
+            781
+        ],
+        "page_idx": 11
+    },
+    {
+        "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? [Yes]   \n(e) Did you discuss whether the data you are using/curating contains personally identifiable information or offensive content? [Yes] ",
+        "bbox": [
+            238,
+            785,
+            823,
+            893
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "5. If you used crowdsourcing or conducted research with human subjects... ",
+        "bbox": [
+            212,
+            897,
+            705,
+            911
+        ],
+        "page_idx": 11
+    },
+    {
+        "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,
+            90,
+            826,
+            180
+        ],
+        "page_idx": 12
+    }
+]

parse/dev/gq4xkwQZ1l/gq4xkwQZ1l.md

@@ -0,0 +1,284 @@
+# Diffusion with Forward Models: Solving Stochastic Inverse Problems Without Direct Supervision
+
+Ayush Tewari1∗ Tianwei Yin1∗ George Cazenavette1 Semon Rezchikov4 Joshua B. Tenenbaum1,2,3 Frédo Durand1 William T. Freeman1 Vincent Sitzmann1
+
+1MIT CSAIL 2MIT BCS 3MIT CBMM 4Princeton IAS
+
+# Abstract
+
+Denoising diffusion models have emerged as a powerful class of generative models capable of capturing the distributions of complex, real-world signals. However, current approaches can only model distributions for which training samples are directly accessible, which is not the case in many real-world tasks. In inverse graphics, for instance, we seek to sample from a distribution over 3D scenes consistent with an image but do not have access to ground-truth 3D scenes, only 2D images. We present a new class of conditional denoising diffusion probabilistic models that learn to sample from distributions of signals that are never observed directly, but instead are only measured through a known differentiable forward model that generates partial observations of the unknown signal. To accomplish this, we directly integrate the forward model into the denoising process. At test time, our approach enables us to sample from the distribution over underlying signals consistent with some partial observation. We demonstrate the efficacy of our approach on three challenging computer vision tasks. For instance, in inverse graphics, we demonstrate that our model in combination with a 3D-structured conditioning method enables us to directly sample from the distribution of 3D scenes consistent with a single 2D input image.
+
+# 1 Introduction
+
+Consider the problem of reconstructing a 3D scene from a single picture. Since much of the 3D scene is unobserved, there are an infinite number of 3D scenes that could have produced the image, due to the 3D-to-2D projection, occlusion, and limited field-of-view that leaves a large part of the 3D scene unobserved. Given the ill-posedness of this problem, it is desirable for a reconstruction algorithm to be able to sample from the distribution over all plausible 3D scenes that are consistent with the 2D image, generating unseen parts in plausible manners. Previous data-completion methods, such as in-painting in 2D images, are trained on large sets of ground-truth output images along with their incomplete (input) counterparts. Such techniques do not easily extend to 3D scene completion, since curating a large dataset of ground-truth 3D scene representations is very challenging.
+
+This 3D scene completion problem, known as inverse graphics, is just one instance of a broad class of problems often referred to as Stochastic Inverse Problems, which arise across scientific disciplines whenever we capture partial observations of the world through a sensor. In this paper, we introduce a diffusion-based framework that can tackle this problem class, enabling us to sample from a distribution of signals that are consistent with a set of partial observations that are generated from the signal by a non-invertible, generally nonlinear, forward model. For instance, in inverse graphics, we learn to sample 3D scenes given an image, yet never observe paired observations of images and 3D scenes at training time, nor observe 3D scenes directly.
+
+While progress in deep learning for generative modeling has been impressive, this problem remains unsolved. In particular, variational autoencoders and conditional neural processes are natural approaches but have empirically fallen short of modeling the multi-modal distributions required in, for instance, inverse graphics. They have so far been limited to simple datasets. Emerging diffusion models [1], in contrast, enable sampling from highly complex conditional distributions but require samples from the output distribution that is to be modeled for training, e.g. full 3D models. Some recent work in inverse graphics has resorted to a two-stage approach, where one first reconstructs a large dataset of 3D scenes to then train an image-conditional diffusion model to sample from the conditional distribution over these scenes [2, 3]. To avoid a two-stage approach, another recent line of work trains a conditional diffusion model to sample from the distribution over novel views of a scene, only requiring image observations at training time [4, 5]. However, such methods do not model the distribution over 3D scenes directly and therefore cannot sample from the distribution over 3D scenes consistent with an image observation. Thus, a multi-view consistent 3D scene can only be obtained in a costly post-processing stage [6]. A notable exception is the recently proposed RenderDiffusion [7], demonstrating that it is possible to train an unconditional diffusion model over 3D scenes from observing only monocular images. While one can perform conditional sampling even with unconditional models, they are fundamentally limited to simple distributions, in this case, single objects in canonical orientations.
+
+Our core contribution is a novel approach for integrating any differentiable forward model that describes how partial observations are obtained from signals, such as 2D image observations and 3D scenes, with conditional denoising diffusion models. By sampling an observation from our model, we jointly sample the signal that gave rise to that observation. Our approach has a number of advantages that make it highly attractive for solving complex Stochastic Inverse Problems. First, our model is trained end-to-end and does away with two-stage approaches that first require reconstruction of a large dataset of signals. Second, our model directly yields diverse samples of the signal of interest. For instance, in the inverse graphics setting, our model directly yields highly diverse samples of 3D scenes consistent with an observation that can then be rendered from novel views with guaranteed multi-view consistency. Finally, our model naturally leverages domain knowledge in the form of known forward models, such as differentiable rendering, with all guarantees that such forward models provide. We validate our approach on three challenging computer vision tasks: inverse graphics (the focus of this paper), as well as single-image motion prediction and GAN inversion.
+
+In summary, we make the following contributions:
+
+1. We propose a new method that integrates differentiable forward models with conditional diffusion models, replacing prior two-step approaches with a conditional generative model trained end-to-end.   
+2. We apply our framework to build the first conditional diffusion model that learns to sample from the distribution of 3D scenes trained only on 2D images. In contrast to prior work, we directly learn image-conditional 3D radiance field generation, instead of sampling from the distribution of novel views conditioned on a context view. Our treatment of inverse graphics exceeds a mere application of the proposed framework, contributing a novel, 3D-structured denoising step that leverages differentiable rendering both for conditioning and for the differentiable forward model.   
+3. We formally prove that under natural assumptions, as the number of observations of each signal in the training set goes to infinity, the proposed model maximizes not only the likelihood of observations, but also the likelihood of the unobserved signals.   
+4. We demonstrate the efficacy of our model for two more downstream tasks with structured forward models: single-image motion prediction, where the forward model is a warping operation, and GAN inversion, where the forward model is a pretrained StyleGAN [8] generator.
+
+# 2 Method
+
+Consider observations $( \mathbf { O } _ { j } ^ { i } , \phi _ { j } ^ { i } )$ that are generated from underlying signals $\mathbf { S } _ { j }$ according to a known forward model forward(), i.e., $\mathbf { O } _ { j } ^ { i } = \mathtt { f o r w a r d } ( \mathbf { S } _ { j } , \phi _ { j } ^ { i } )$ , where $\phi _ { j } ^ { i }$ are parameters of the forward model corresponding to observation $\mathbf { O } _ { j } ^ { i }$ . Each observation can be partial. Specifically, given a single observation, there is an infinite number of signals that could have generated this observation. However, we assume that given a hypothetical set of all possible observations, the signal is fully determined. In the case of inverse graphics, $\mathbf { O } _ { j } ^ { i }$ are image observations of 3D scenes $\mathbf { S } _ { j }$ and $\phi _ { j } ^ { i }$ are the camera parameters, where we index scenes with $j$ and observations of the $j$ -th scene via $i$ forward() is the rendering function. Note that if we were to capture every possible image of a 3D scene, the 3D scene is uniquely determined, but given a single image, there are an infinite number of 3D scenes that could have generated that image, both due to the fact that rendering is a projection from 3D and 2D, and due to the fact that a single image only constrains the visible part of the 3D scene. We will drop the subscript $j$ in the following, and leave it implied that we always consider many observations generated from many signals. Fig. 1 provides an illustration of the data.
+
+![](images/08e3fadae5b8538ef6afb8f767fec522d7436b3f59682357f380afdb39c9c0f1.jpg)  
+Figure 1: Overview of our proposed method. (a) We assume a dataset of tuples of observations $( \mathbf { O } , \phi ) ^ { i }$ , generated from unobserved signals S via a differentiable forward model. (b) We propose to integrate the forward model directly into the denoising step of a diffusion model: given a pair of observations of the same signal, we designate context $\mathbf { O } ^ { \mathrm { { c u x t } } }$ and target $\mathbf { \bar { O } } ^ { \mathrm { t r g t } }$ . We add noise to $\mathbf { O } ^ { \mathrm { { t r g t } } }$ , then feed $( { \bf O } ^ { \mathrm { c t x t } } , \phi ^ { \mathrm { c t x t } } , { \bf O } _ { t } ^ { \mathrm { t r g t } } , \phi ^ { \mathrm { t r g t } } )$ to a neural network denoise to estimate the signal $\mathbf { S } _ { t - 1 }$ . We then apply the forward model to obtain an estimate of the clean target observation, $\hat { \mathbf { O } } _ { t - 1 } ^ { \mathrm { t r g t } }$ . (c) The graphical model of the diffusion process.
+
+We are now interested in training a model that, at test time, allows us to sample from the distribution of signals that are consistent with a previously unseen observation O. Formally, we aim to model the conditional distribution $p ( \mathbf { S } | \mathbf { O } , \phi )$ . We make the following assumptions:
+
+• We have access to a differentiable implementation of forward().   
+• We have access to a large dataset of observations and corresponding parameters of the forward model, $\{ ( \mathbf { O } ^ { i } , \phi ^ { i } ) \} _ { i } ^ { N }$ .   
+• In our training set, we have access to several observations per signal.
+
+Crucially, we do not assume that we have direct access to the underlying signal that gave rise to a particular observation, i.e., we do not assume access to tuples of $( \mathbf { O } , \phi , \mathbf { S } )$ . Further, we also do not assume that we have access to any prior distribution over the signal of interest, i.e., we never observe a dataset of signals of the form $\{ \bar { \bf S } ^ { j } \} _ { j }$ , and thus cannot train a generative model to sample from an unconditional distribution over signals.
+
+Recent advances in deep-learning-based generative modeling have seen the emergence of denoising diffusion models as powerful generative models that can be trained to generate highly diverse samples from complex, multi-modal distributions. We are thus motivated to leverage denoising diffusion probabilistic models to model $p ( \mathbf { S } | \mathbf { O } , \phi )$ . However, existing approaches cannot be trained if we do not have access to signals S. In the following, we give background on denoising diffusion models and discuss the limitation.
+
+# 2.1 Background: Denoising Diffusion Probabilistic Models and their Limitation
+
+Denoising diffusion probablistic models are a class of generative models that learn to sample from a distribution by learning to iteratively denoise samples. Consider the problem of modeling the distribution $p _ { \theta } ( \mathbf { x } )$ over samples $\mathbf { x }$ . A forward Markovian process $q \big ( \mathbf { x } _ { 0 : T } \big )$ adds noise to the data as
+
+$$
+q ( \mathbf { x } _ { t } \mid \mathbf { x } _ { t - 1 } ) = { \mathcal { N } } ( \mathbf { x } _ { t } ; { \sqrt { 1 - \beta _ { t } } } \mathbf { x } _ { t - 1 } , \beta _ { t } \mathbf { I } ) .
+$$
+
+Here, $\beta _ { t }$ , $t \in { 1 \dots T }$ are the hyperparameters that control the variance schedule. A denoising diffusion model learns the reverse process, where samples from a distribution $p ( x _ { T } ) = \mathcal { N } ( \mathbf { 0 } , \mathbf { I } )$ are transformed incrementally into the data manifold as $\begin{array} { r } { p _ { \theta } ( \mathbf { x } _ { 0 : T } ) = p ( x _ { T } ) \prod _ { t = 1 } ^ { T } p _ { \theta } ( \mathbf { x } _ { t - 1 } \mid \mathbf { x } _ { t } ) } \end{array}$ , where
+
+$$
+p _ { \theta } ( \mathbf { x } _ { t - 1 } \mid \mathbf { x } _ { t } ) = \mathcal { N } ( \mathbf { x } _ { t - 1 } ; \mu ( \mathbf { x } _ { t } , t ) , \Sigma ( \mathbf { x } _ { t } , t ) ) .
+$$
+
+A neural network denoise $_ { \theta } ( )$ with learnable parameters $\theta$ learns to reverse the diffusion process. It is also possible to model conditional distributions $p _ { \theta } ( \mathbf { x } _ { 0 : T } \mid \mathbf { c } )$ , where the output is computed as denoise ${ \bf \nabla } _ { \theta } ( \mathbf { x } _ { t } , t , \mathbf { c } )$ . The forward process does not change in this case; in practice, we merely add the conditional signal as input to the denoising model.
+
+Unfortunately, we cannot train existing denoising diffusion models to sample from $p ( \mathbf { S } \mid \mathbf { O } , \phi )$ , or, in fact, even from an unconditional distribution $p ( \mathbf { S } )$ . This would require computation of the Markovian forward process in Eq. 1. However, recall that we do not have access to any signals $\{ \mathbf { S } ^ { j } \} _ { j }$ - we thus can not add any noise to any signals to then train a denoising neural network. In other words, since no S is directly observed, we cannot compute $q ( \mathbf { S } _ { t } \mid \mathbf { S } _ { t - 1 } )$ .
+
+# 2.2 Integrating Denoising Diffusion with Differentiable Forward Models
+
+We now introduce a class of denoising diffusion models that we train to directly model the distribution $p ( \mathbf { S } \mid \mathbf { O } ^ { \mathrm { c t x t } } ; \phi ^ { \mathrm { c t x t } } )$ over signals $\mathbf { S }$ given an observation $( \mathbf { O } ^ { \mathrm { c t x t } } , \phi ^ { \mathrm { c t x t } } )$ . Our key contribution is to directly integrate the differentiable forward model forward() into the iterative conditional denoising process. This enables us to add noise to and denoise the observations, while nevertheless sampling the underlying signal that generates that observation.
+
+Our model is trained on pairs of “context” and “target” observations of the same signal, denoted as $\mathbf { O } ^ { \mathrm { c t x t } }$ and ${ \bf O } ^ { \mathrm { t r g t } }$ . As in conventional diffusion models, for the forward process, we have $q ( \mathbf O _ { t } ^ { \mathrm { t r g t } } \mid$ ${ \bf O } _ { t - 1 } ^ { \mathrm { t r g t } } ) = \mathcal { N } ( { \bf O } _ { t } ^ { \mathrm { t r g t } } ; \sqrt { 1 - \beta _ { t } } { \bf O } _ { t - 1 } ^ { \mathrm { t r g t } } , \beta _ { t } { \bf I } )$ . In the reverse process, we similarly denoise ${ \bf O } ^ { \mathrm { t r g t } }$ conditional on Octxt:
+
+$$
+p _ { \theta } ( \mathbf { O } _ { 0 : T } ^ { \mathrm { t r g t } } \mid \mathbf { O } ^ { \mathrm { c t x t } } ; \phi ^ { \mathrm { c t x t } } , \phi ^ { \mathrm { t r g t } } ) = p ( \mathbf { O } _ { T } ^ { \mathrm { t r g t } } ) \prod _ { t = 0 } ^ { T } p _ { \theta } ( \mathbf { O } _ { t - 1 } ^ { \mathrm { t r g t } } \mid \mathbf { O } _ { t } ^ { \mathrm { t r g t } } , \mathbf { O } ^ { \mathrm { c t x t } } ; \phi ^ { \mathrm { c t x t } } , \phi ^ { \mathrm { t r g t } } ) ,
+$$
+
+However, unlike conventional diffusion models, we implement $p _ { \theta } ( \mathbf { O } _ { t - 1 } ^ { \mathrm { t r g t } } \mid \mathbf { O } _ { t } ^ { \mathrm { t r g t } } , \mathbf { O } ^ { \mathrm { c t x t } } ; \phi ^ { \mathrm { c t x t } } , \phi ^ { \mathrm { t r g t } } )$ by first predicting an estimate of the underlying signal $\mathbf { S } _ { t - 1 }$ and then mapping it to an estimate of the denoised observations via the differentiable forward:
+
+$$
+\begin{array} { r l } & { { \bf S } _ { t - 1 } = \mathrm { d e n o i s e } _ { \theta } ( { \bf O } ^ { \mathrm { c t x t } } , { \bf O } _ { t } ^ { \mathrm { t r g t } } ; t , \phi ^ { \mathrm { c t x t } } , \phi ^ { \mathrm { t r g t } } ) , } \\ & { \hat { \bf O } _ { t - 1 } ^ { \mathrm { t r g t } } = \mathrm { f o r w a r d } ( { \bf S } _ { t - 1 } , \phi ^ { \mathrm { t r g t } } ) } \\ & { { \bf O } _ { t - 1 } ^ { \mathrm { t r g t } } \sim \mathcal { N } ( { \bf O } _ { t - 1 } ^ { \mathrm { t r g t } } ; C _ { t - 1 } \hat { \bf O } _ { t - 1 } ^ { \mathrm { t r g t } } , \hat { \beta } _ { t - 1 } { \bf I } ) } \end{array}
+$$
+
+Here, $\hat { \mathbf { O } } _ { t - 1 } ^ { \mathrm { t r g t } }$ is an estimate of the clean observation, and the constants $C _ { t - 1 }$ and $\hat { \beta } _ { t - 1 }$ are chosen to match the total noise added by the forward process at time $t$ -1. See Fig. 1 for an overview. At test time, a signal is sampled by iterating Eq. 4, 5, and 6 starting with $p ( \mathbf { O } _ { t = T } ^ { \mathrm { t r g t } } ) \sim \mathcal { N } ( \mathbf { 0 } , \mathbf { I } )$ . Importantly, our models define a generative model over the underlying signal via Eq. 4:
+
+$$
+p _ { \theta , \phi ^ { \mathrm { t r g t } } } ( \mathbf { S } _ { 0 : T } \mid \mathbf { O } ^ { \mathrm { c t x t } } ; \phi ^ { \mathrm { c t x t } } ) = \prod _ { t = 1 } ^ { T } p _ { \theta } ( \mathbf { S } _ { t - 1 } \mid \mathbf { O } _ { t } ^ { \mathrm { t r g t } } , \mathbf { O } ^ { \mathrm { c t x t } } ; \phi ^ { \mathrm { c t x t } } , \phi ^ { \mathrm { t r g t } } ) .
+$$
+
+We will suppress the subscript in the notation, and refer to this distribution as $p ( \mathbf { S } _ { 0 : T } \mid \mathbf { O } ^ { \mathrm { c t x t } } ; \phi ^ { \mathrm { c t x t } } )$ for brevity from now.
+
+Loss Function. We train to minimize the following two loss terms:
+
+$$
+\begin{array} { r l } & { \mathcal { L } _ { \theta } ^ { \mathrm { t r g t } } = \mathbb { E } _ { \mathbf { O } ^ { \mathrm { c u t } } , \mathbf { O } ^ { \mathrm { t r g t } } , \phi ^ { \mathrm { s r u } } , \phi ^ { \mathrm { i r g t } } , t } \Big [ \| \mathbf { O } ^ { \mathrm { t r g t } } - \underbrace { \underline { { \boldsymbol { \Sigma } } } \boldsymbol { \mathrm { o r w a r d } } \big ( \mathbf { d e n o \mathrm { i } } \mathbf { s } \boldsymbol { \mathrm { e } } _ { \theta } \big ( \mathbf { O } ^ { \mathrm { c u t } } , \mathbf { O } _ { t } ^ { \mathrm { t r g t } } ; t , \phi ^ { \mathrm { c u t } } , \phi ^ { \mathrm { t r g t } } \big ) , \phi ^ { \mathrm { t r g t } } \big ) } _ { = \hat { \mathbf { O } } _ { t - 1 } ^ { \mathrm { t r g t } } } \| ^ { 2 } \Big ] , } \end{array}
+$$
+
+$$
+\begin{array} { r } { \mathcal { L } _ { \theta } ^ { \mathrm { n o w e l } } = \mathbb { E } _ { \mathbf { O } ^ { \mathrm { c u t } } , \mathbf { O } ^ { \mathrm { n o w e l } } , \phi ^ { \mathrm { c u t } } , \phi ^ { \mathrm { n o w } } , \phi ^ { \mathrm { n o w e l } } , t } [ \| \mathbf { O } ^ { \mathrm { n o w e l } } - \underbrace { \underline { { \boldsymbol { \Sigma } } } \boldsymbol { \mathrm { o r w a r d } } \big ( \mathbf { d e n o i } \mathbf { s } \boldsymbol { \Theta } _ { \theta } \big ( \mathbf { O } ^ { \mathrm { c u t } } , \mathbf { O } _ { t } ^ { \mathrm { i n f } } ; t , \phi ^ { \mathrm { c u t } } , \phi ^ { \mathrm { n o r t } } \big ) , \phi ^ { \mathrm { n o w e l } } \big ) } _ { = \hat { \mathbf { O } } _ { t - 1 } ^ { \mathrm { n o w e l } } }  } \end{array}
+$$
+
+Here, we compute the estimate of the observation from the target, as well as a separate, novel forward model parameter $\phi ^ { \mathrm { n o v e l } }$ . In the supplemental document, we show that these losses approximate a total observation loss, maximizing the likelihood of all possible observations of the signal S.
+
+Characterizing the Conditional Distribution Over Signals. Due to the complexity of the reverse process, it may not be clear that the learned distribution over signals will agree with the true distribution, even in the limit of infinite data. However, this model will indeed asymptotically learn the true conditional distribution over signals, as we formally prove in the supplement:
+
+![](images/4b82c45eef40a032ce294a783e3372e2edf6e48277663a89072d22b1b57d1ff0.jpg)  
+Figure 2: Overview of 3D Generative Modeling. We build a 3D-structured denoise operator on top of pixelNeRF [9] that learns to sample from the distribution of 3D scenes from image observations only. Given a context image $\mathbf { O } ^ { \mathrm { { c u x t } } }$ with camera pose $\phi ^ { \mathrm { c t x t } }$ , we pick a target pose $\phi ^ { \mathrm { t r g t } }$ . We render out a deterministic estimate of the depth, RGB, and features of the target view $\mathbf { O } _ { \mathrm { d e t } } ^ { \mathrm { t r g t } }$ using pixel-aligned features $\mathbf { f } ^ { \mathrm { c u t } }$ extracted from the (left, only RGB shown here). To generate a 3D scene, we concatenate the deterministic estimate with noise $\mathbf { O } _ { t } ^ { \mathrm { t r g t } }$ , and extract features $\mathbf { f } _ { t } ^ { \mathrm { t r g t } }$ for the target view with $\mathtt { e n c } _ { t }$ . $\mathbf { f } _ { t } ^ { \mathrm { t r g t } }$ and $\mathbf { f } ^ { \mathrm { c t x t } }$ now jointly parameterize the radiance field of the generated scene $\mathbf { S } _ { t - 1 }$ , and we may render an estimate of the clean target view $\hat { \mathbf { O } } _ { t - 1 } ^ { \mathrm { t r g t } }$ . The model is trained end-to-end via a re-rendering loss.
+
+Proposition 1. Suppose that any signal S can be reconstructed from the set of all all possible observations of S. Under this assumption, if in the limit as the number of known observations per signal goes to infinity, there are parameters $\theta$ such that $\mathcal { L } _ { \theta } ^ { \mathrm { t r g t } } + \mathcal { L } ^ { \mathrm { n o v e l } }$ is minimized, then the conditional probability distribution over signals discovered by our model $p ( \mathbf { S } \mid \mathbf { O } ^ { \mathrm { c t x t } } ; \phi ^ { \mathrm { c t x t } } )$ agrees with the true distribution $p ^ { \mathrm { t r u e } } ( \mathbf { S } \mid \mathbf { O } ^ { \mathrm { c t x t } } ; \phi ^ { \mathrm { c t x t } } )$ .
+
+The proof follows by showing that our losses implicitly minimize a diffusion model loss over total observations, which are collections of all possible observations of our signal. As such, when the observations suffice to completely reconstruct the signal, the correctness of the estimated distribution over total observations forces the estimated distribution over signals to be correct, as well.
+
+# 3 Prior Work on Latent Variable Models for Inverse Problems
+
+Variational Autoencoders [10, 11], normalizing flows [12], conditional [13] and attentive neural processes [14] are latent-variable models that can be combined with forward models to learn to sample from the distribution of unobserved signals from observations [15, 16]. However, they empirically fall short of accurately modeling complex signal distributions - in inverse graphics, for instance, such models have so far been limited to synthetic 3D scenes. Generative Adversarial Networks can be trained with differentiable forward models in-the-loop, and have yielded impressive results in unconditional generative modeling of unobserved signals [17–19]. Similarly, in concurrent work, diffusion models have been leveraged for unconditional generative modeling through differentiable forward models [2, 7, 20]. However, unconditional models are limited to tight distributions, and no conditional generative modeling of similar quality has been demonstrated. Diffusion models trained directly on signals have been effectively applied to diverse inverse problems such as superresolution [21–25], inpainting [21, 23–26], and medical imaging [27]. These works utilize the learned prior of the data distribution to recover the latent signal through a “plug and play” approach [28–30], integrating the diffusion model with a forward measurement process according to Bayes’ rule. These approaches are versatile and can easily adapt to new inverse problems without retraining. However, unlike our models, they rely on direct supervision over the signals in the form of large datasets.
+
+# 4 Applications
+
+We now apply our framework to three stochastic inverse problems. We focus on applications in computer vision, where we tackle the problems of inverse graphics, single-image motion prediction, and GAN inversion. For each application, we give a detailed description of the forward model, the dataset and baselines, as well as a brief description of prior work.
+
+![](images/7f738113db8e3aac5992b6bba808f143d99dded384ac2d55c81cd7f2dca1a794.jpg)  
+Figure 3: Sample Diversity. We illustrate different 3D scenes sampled from the same context image for RealEstate10k and Co3D datasets. Unlike deterministic methods like pixelNeRF [9], our method generates diverse and distinct 3D scenes that all align with the context image. Co3D results are generated using autoregressive sampling, where a 360 degree trajectory can be generated by iteratively sampling target images. Note the photorealism and diversity of the generated structures for the indoor scene, such as doors and cabinets. Also note the high-fidelity geometry of the occluded parts of the hydrant and the diverse background appearance.
+
+# 4.1 Inverse Graphics
+
+We seek to learn a model that, given a single image of a 3D scene enables us to sample from the distribution over 3D scenes that are consistent with the observation. We expect that 3D regions visible in the image are reconstructed faithfully, while unobserved parts are generated plausibly. Every time we sample, we expect a different plausible 3D generation. Signals $\mathbf { S }$ are 3D scenes, and observations are 2D images $\mathbf { O }$ and their camera parameters $\phi$ . At training time, we assume that we have access to at least two image observations and their camera parameters per scene, such that we can assemble tuples of $( { \bf O } ^ { \mathrm { c t x t } } , \bar { \phi } ^ { \mathrm { c t x t } } , { \bf O } ^ { \mathrm { t r g t } } , \phi ^ { \mathrm { t r g t } } )$ , with 2D images $\mathbf { \bar { O } } ^ { \mathrm { c t x t } } , \mathbf { O } ^ { \mathrm { t r g t } }$ , and camera parameters $\phi ^ { \mathrm { c t x t } } , \phi ^ { \mathrm { t r g t } }$ .
+
+Scope. We note that our treatment of inverse graphics exceeds a mere application of the presented framework. In particular, we not only integrate the differentiable rendering forward function, but further propose a novel 3D-structured denoise function. Here, we enable state-of-the-art conditional generation of complex, real-world 3D scenes.
+
+Related Work. Few-shot reconstruction of 3D scene representations via differentiable rendering was pioneered by deterministic methods [9, 31, 32, 32–41] that blur regions of the 3D scene unobserved in the context observations. Probabilistic methods have been proposed that can sample from the distribution of novel views trained only on images [4, 5, 42–45]. While results are impressive, these methods do not allow sampling from the distribution of 3D scenes, but only from the distribution of novel views. Generations are not multi-view consistent. Obtaining a 3D scene requires costly post-processing via score distillation [6]. Several approaches [2, 3] use a two-stage design: they first reconstruct a dataset of 3D scenes, and then train a 3D diffusion model. However, pre-computing large 3D datasets is expensive. Further, to obtain high-quality results, dense observations are required per scene. RenderDiffusion [7] and HoloDiffusion [20] integrate differentiable forward rendering with an unconditional diffusion model, enabling unconditional sampling of simple, single-object scenes. Similar to us, RenderDiffusion performs denoising in the image space, while HoloDiffusion uses a 3D denoising architecture. Other methods use priors learned by text-conditioned image diffusion models to optimize 3D scenes [46–48]. Here, the generative model does not have explicit knowledge about the 3D information of scenes. These methods often suffer from geometric artifacts.
+
+Structure of S and forward model render. We can afford only an abridged discussion here - please see the supplement for a more detailed description. We use NeRF [49] as the parameterization of 3D scenes, such that S is a function that maps a 3D coordinate $\mathbf { p }$ to a color c and density $\sigma$ as $\mathbf { S } ( \mathbf { p } ) = \left( \sigma , \mathbf { c } \right)$ . We require a generalizable NeRF that is predicted in a feed-forward pass by an encoder that takes a set of $M$ context images and corresponding camera poses $\{ ( \mathbf { O } _ { i } , \phi _ { i } ) \} _ { i } ^ { \hat { M } }$ as input.
+
+![](images/5fb866e243066062c7db8344499725f0fd3b459fa32b32a376e54ec5ca0024fc.jpg)  
+Figure 4: Qualitative Comparison for Inverse Graphics application. We benchmark with SparseFusion [5] and the deterministic pixelNeRF [9]. SparseFusion samples 2D novel views conditioned on a deterministic rendering (Diffusion Out.), and generates multi-view consistent 3D scenes only after Score Distillation. Our method consistently generates higher-quality scenes, while directly sampling 3D scenes.
+
+We base our model on pixelNeRF [9]. pixelNeRF first extracts image features $\{ \mathbf { F } _ { i } \} _ { i }$ from each context observation via an encoder enc as $\mathbf { F } _ { i } = \mathtt { e n c } ( \mathbf { O } _ { i } )$ . Given a 3D point $\mathbf { p }$ , it obtains its pixel coordinates in each context view via $\mathbf { p } _ { i } ^ { \mathrm { p i x } } = \pi ( \mathbf { p } , \phi _ { i } )$ via the projection operator $\pi$ , and recovers a corresponding feature as $\mathbf { f } _ { i } = \mathbf { F } _ { i } ( \mathbf { p } _ { i } ^ { \mathrm { p i x } } )$ by sampling the feature map at pixel coordinate $\mathbf { p } _ { i } ^ { \mathrm { p i x } }$ . It then parameterizes $\mathbf { S }$ via an MLP as:
+
+$$
+\mathbf { S } ( \mathbf { p } ) = ( \sigma ( \mathbf { p } ) , \mathbf { c } ( \mathbf { p } ) ) = \mathtt { M L P } ( \{ ( \mathbf { f } _ { i } \oplus \mathbf { p } _ { i } \} _ { i } ^ { M } ) ,
+$$
+
+where $\oplus$ is concatenation and $\mathbf { p } _ { i }$ is the 3D point $\mathbf { p }$ transformed into the camera coordinates of observation $i$ . The number of context images $M$ is flexible, and we may condition S on a single or several observations. It will be convenient to refer to a pixelNeRF that is reconstructed from context and target observations $( \mathbf { O } ^ { \mathrm { c t x t } } , \phi ^ { \mathrm { c t x t } } )$ and $( { \bf O } ^ { \mathrm { t r g t } } , \phi ^ { \mathrm { t r g t } } )$ as
+
+$$
+\mathbf { S } ( \cdot \mid \mathrm { e n c } ( \mathbf { O } ^ { \mathrm { c t x t } } ) , \mathrm { e n c } ( \mathbf { O } ^ { \mathrm { t r g t } } ) ) ,
+$$
+
+where we make the pixelNeRF encoder enc explicit and drop the poses $\phi ^ { \mathrm { t r g t } }$ and $\phi ^ { \mathrm { c t x t } }$ . We leverage differentiable volume rendering [49] as forward model, such that
+
+$$
+\mathbf { O } = { \mathrm { r e n d e r } } ( \mathbf { S } , \phi ) ,
+$$
+
+where S is rendered from a camera with parameters $\phi$ .
+
+Implementation of denoise. Fig. 2 gives an overview of the denoising procedure. Following our framework, we obtain the denoised target observation $\hat { \mathbf { O } } _ { t - 1 } ^ { \mathrm { t r g t } }$ as:
+
+$$
+\begin{array} { r } { \hat { \mathbf { O } } _ { t - 1 } ^ { \mathrm { t r g t } } = \tt r e n d e r ( \mathbf { S } _ { t - 1 } , \phi ^ { \mathrm { t r g t } } ) , \quad \mathrm { w h e r e } } \\ { \mathbf { S } _ { t - 1 } = \mathbf { S } ( \cdot \mid \mathrm { e n c } _ { t = 0 } ( \mathbf { O } ^ { \mathrm { c t x t } } ) , \mathrm { e n c } _ { t } ( \mathbf { O } _ { t } ^ { \mathrm { t r g t } } ) ) , } \end{array}
+$$
+
+where the image encoder $\mathtt { e n c } _ { t }$ is now conditioned on the timestep $t$ . In other words, we will generate a target view $\hat { \mathbf { O } } _ { t - 1 } ^ { \mathrm { t r g t } }$ by rendering the pixelNeRF conditioned on the context and noisy target observations. However, feeding the noisy $\mathbf { O } _ { t } ^ { \mathrm { t r g t } }$ directly to pixelNeRF is insufficient. This is because the pixelaligned features $\mathsf { e n c } _ { t } ( \mathbf { O } )$ are obtained from each view separately - thus, the features generated by $\mathtt { e n c } _ { t } ( \mathbf { O } _ { t } ^ { \mathrm { t r g t } } )$ will be uninformative. To successfully generate a 3D scene, we have to augment the $\mathbf { O } _ { t } ^ { \mathrm { t r g t } }$ with information from the context view. We propose to generate conditioning information for $\mathbf { O } _ { t } ^ { \mathrm { t r g t } }$ by rendering a deterministic estimate ${ \bf O } _ { \mathrm { d e t } } ^ { \mathrm { t r g t } } = \mathrm { r e n d e r } ( { \bf S } ( \cdot \mid \mathrm { e n c } _ { t = 0 } ( { \bf O } ^ { \mathrm { c t x t } } ) ) , \phi ^ { \mathrm { t r g t } } )$ . I.e., we condition pixelNeRF only on the context view, and render an estimate of the target view via volume rendering. However, in the extreme case of a completely uncertain target view, this results in a completely blurry image. We thus propose to additionally render high-dimensional features. Recall that any 3D point $\mathbf { p }$ , we have $( \sigma ( \mathbf { p } ) , \mathbf { \bar { c } } ( \mathbf { \bar { p } } ) ) = \mathsf { M L P } _ { t } ( \mathbf { p } )$ . We modify $\mathtt { M L P } _ { t }$ to also output a high-dimensional feature and render a deterministic feature map to augment $\mathbf { O } _ { t } ^ { \mathrm { t r g t } }$ (only RGB shown in figure). We generate the final 3D scene as $\mathbf { S } _ { t - 1 } = \mathbf { S } ( \cdot \mid \mathrm { e n c } _ { t = 0 } ( \mathbf { O } ^ { \mathrm { c t x t } } )$ , $\mathbf { e n c } _ { t } ( \mathbf { O } _ { \mathrm { d e t } } ^ { \mathrm { t r g t } } \oplus \mathbf { O } _ { t } ^ { \mathrm { t r g t } } ) ,$ . The final denoised target view is then obtained according to the rendering Eq. 13 above.
+
+![](images/f71460f37c341c06e7fe429fe010c39358087fe433954aa44f2c7b3fadc9e12a.jpg)  
+Figure 5: Qualitative Results for Single-Image Motion Prediction (left) and GAN Inversion (right).
+
+Loss and Training. Our loss consists of simple least-squares terms on re-rendered views, identical to the general loss terms presented in Eqs. 8 and 9, in addition to regularizers that penalize degenerate 3D scenes. We discuss these regularizers, as well as training details, in the supplement.
+
+# 4.1.1 Results
+
+Datasets We evaluate on two challenging real-world datasets. We use Co3D hydrants [50] to evaluate our method on object-centric scenes. For scene-level 3D synthesis, we use the challenging RealEstate10k dataset [51], consisting of indoor and outdoor videos of scenes.
+
+Baselines We compare our approach with state-of-the-art approaches in deterministic and probabilistic 3D scene completion. We use pixelNeRF as the representative method for deterministic methods that takes a single image as input and deterministically reconstructs a 3D scene. Our method is the first to probabilistically reconstruct 3D scenes in an end-to-end manner. Regardless, we compare with the concurrent SparseFusion [52] that learns an image-space generative model over novel views of a 3D scene. Score distillation of this generative model is required every time we want to obtain a multi-view consistent 3D scene, which is costly.
+
+Qualitative Results. In Fig. 3, we show multiple samples of 3D scenes sampled from a monocular image. For the indoor scenes of RealEstate10k, there are large regions of uncertainty. We can sample from the distribution of valid 3D scenes, resulting in significantly different 3D scenes with plausible geometry and colors. The objects are faithfully reconstructed for the object-centric Co3D scenes, and the uncertainty in the scene is captured. We can sample larger 3D scenes and render longer trajectories by autoregressive sampling, i.e., we treat intermediate diffused images as additional context observations to sample another target observation. The Co3D results in Fig. 3 were generated autoregressively for a complete 360 degrees trajectory. In Fig. 4, we compare our results with pixelNeRF [9] and SparseFusion [5]. pixelNeRF is a deterministic method and thus leads to very blurry results in uncertain regions. SparseFusion reconstructs scenes by score-distillation over a 2D generative model. This optimization is very expensive, and does not lead to natural-looking results.
+
+Quantitative Results. For the object-centric Co3D dataset, we evaluate the accuracy of novel views using PSNR and LPIPS [53] metrics. Note that PSNR/LPIPS are not meaningful metrics for large scenes since the predictions have a large amount of uncertainty, i.e., a wide range of novel view images can be consistent with any input image. Thus, we report FID [54] and KID [55] scores to evaluate the realism of reconstructions in these cases. Our approach outperforms all baselines for LPIPS, FID, and KID metrics, as our model achieves more realistic results. We achieve slightly lower PSNR compared to pixelNeRF [9]. Note that PSNR favors mean estimates, and that we only evaluate our model using a single randomly sampled scene for an input image due to computational constraints.
+
+# 4.2 Single-Image Motion Prediction
+
+Here, we seek to train a model that, given a single static image, allows us to sample from all possible motions of pixels in the image. Given, for instance, an image of a person performing a task, such as kicking a soccer ball, it is possible to predict potential future states. This is a stochastic problem, as there are multiple possible motions consistent with an image. We train on a dataset of natural videos [56]. We only observe RGB frames and never directly observe the underlying motion, i.e, the pixel correspondences in time are unavailable. We use tuples of two frames from videos within a small temporal window, and use them as our context and target observations for training.
+
+GAN Inversion   
+
+<table><tr><td></td><td>FFHQ</td></tr><tr><td></td><td>FID↓ KID↓</td></tr><tr><td>Determ.</td><td>25.7 0.019</td></tr><tr><td>Ours</td><td>7.45 0.002</td></tr></table>
+
+3D Scene Completion   
+
+<table><tr><td></td><td colspan="4">Co3D</td><td colspan="2">RealEstate10k</td></tr><tr><td></td><td>PSNR↑</td><td>LPIPS↓</td><td>FID↓</td><td>KID↓</td><td>FID↓</td><td>KID↓</td></tr><tr><td>pixelNeRF</td><td>17.93</td><td>0.54</td><td>180.20</td><td>0.14</td><td>195.40</td><td>0.14</td></tr><tr><td>SparseFusion</td><td>12.06</td><td>0.63</td><td>252.13</td><td>0.16</td><td>99.44</td><td>0.04</td></tr><tr><td>Ours</td><td>17.47</td><td>0.42</td><td>84.63</td><td>0.05</td><td>42.84</td><td>0.01</td></tr></table>
+
+Table 1: Quantitative evaluation. (left) We benchmark our 3D generative model with state-of-the-art baselines pixelNeRF [9] and SparseFusion [5]. (right) We benchmark with a deterministic baseline on GAN inversion, which we drastically outperform.
+
+Related Work. Several papers tackle this problem, where motion in the form of optical flow [57–59], 2D trajectories [60, 61], and human motion [62, 63] are recovered from a static image; however, all these methods assume supervision over the underlying motion. Learning to reason about motion requires the neural network to learn about the properties and behavior of the different objects in the world. Thus, this serves as a useful proxy task for representation learning, and can be used as a backbone for many downstream applications [60, 64].
+
+Structure of S and forward model warp. Our signal S stores the appearance and motion information in a 2D grid. At any pixel u, the signal is defined as $\mathbf { S } ( \mathbf { u } ) = ( \mathbf { S } _ { c } ( \bar { \mathbf { u } } ) , \mathbf { S } _ { m } ( \mathbf { u } ) )$ , where $\mathbf { S } _ { c } ( \mathbf { u } ) \in \mathbb { R } ^ { 3 }$ is the color value, and $\bar { \bf S } _ { m } ( { \bf u } ) \in \mathbb { R } ^ { 2 }$ is a 2D motion vector. The forward model is a warping operator, such that warp $( \mathbf { S } , \phi ) ( \mathbf { u } + \phi \mathbf { S } _ { m } ( \mathbf { u } ) ) = \mathbf { S } _ { c } ( \mathbf { u } )$ and $\phi$ is a scalar that changes the magnitude of motion. We implement this function using a differentiable point splatting operation [65].
+
+Implementation of denoise. The inset figure illustrates our design. We use a 2D network that takes $\mathbf { O } ^ { \mathrm { c t x t } }$ , $\mathbf { O } _ { t } ^ { \mathrm { t r g t } }$ , and $t$ as input, and generates the motion map $\mathbf { S } _ { m }$ as the output. The signal is then reconstructed as ${ \bf S } = ( { \bf O } ^ { \mathrm { c t x t } } , { \bf S } _ { m } )$ . Context and target frames correspond to parameters $\phi ^ { \mathrm { c t x t } } = 0$ and $\phi ^ { \mathrm { t r g t } } = 1$ and can be reconstructed from the signal using warp.
+
+![](images/7cd794f259a725888aed4dc15d47a7cf4dc4e3d3a207f2568508d0994189d262.jpg)
+
+Loss and Evaluation. Similar to inverse graphics, we use reconstruction and regularization losses. The reconstruction losses are identical to Eqs. 8 and 9, and the regularization loss is a smoothness term that encourages a natural motion of the scene, see supplement for details. We show results in Fig. 5 (left), where we can estimate a diverse set of possible motion flows from monocular images. By smoothly interpolating $\phi$ , we can generate short video sequences, even though our model only saw low-framerate video frames during training. We also train a deterministic baseline, which only generates a single motion field. Due to the amount of uncertainty in this problem, the deterministic estimate collapses to a near-zero motion field regardless of the input image, and thus, fails to learn any meaningful features from images.
+
+# 4.3 GAN Inversion
+
+Projecting images onto the latent space of generative adversarial networks is a well-studied problem [8, 66], and enables interesting applications, as manipulating latents along known directions allows a user to effectively edit images [67–69]. Here, we solve the problem of projecting partial images: given a small visible patch in an image, our goal is to model the distribution of possible StyleGAN2 [8] latents that agree with the input patch. There are a diverse set of latents that can correspond to the input observation, and we train our method without observing supervised (image, latent) pairs. Instead, we train on pairs of $( \mathbf { O } ^ { \mathrm { c t x t } } , \mathbf { O } ^ { \mathrm { t r g t } } )$ observations, where $\mathbf { O } ^ { \mathrm { c t x t } }$ are the small patches in images, and ${ \bf O } ^ { \mathrm { t r g t } }$ are the full images.
+
+Related Work. While most GAN inversion methods focus on inverting a complete image into the generator’s latent space [70–78], some also reconstruct GAN latents from small patches via supervised training. Inversion is not trivial, and papers often rely on regularization [77] or integrate the inversion with editing tasks [79] for higher quality. We also integrate the inpainting task with the inversion, and seek to model the uncertainty of the GAN inversion task given only a partial observation (patch) of the target image.
+
+Structure of S and forward model synthesize. Our signal $\mathbf { S } \in \mathbb { R } ^ { 5 1 2 }$ is a 512 dimensional latent code representing the “w” space of StyleGAN2 [8] trained on the FFHQ [80] dataset. The forward model synthesize ${ \bf \Phi } _ { : } ( { \bf S } , \phi ) \bar { \bf \Phi } = { \tt G A N } ( { \bf S } ) \bar { [ \phi ] }$ first reconstructs the image corresponding to S using a forward pass of the GAN. It then extracts a patch using the forward model’s parameters $\phi$ that encode the patch coordinates.
+
+Implementation of denoise, Loss, and Evaluation. Please see the inset figure for an illustration of the method. The denoising network receives $\mathbf { O } ^ { \mathrm { c t x t } }$ , $\mathbf { O } _ { t } ^ { \mathrm { t r g t } }$ , and timestep t as input, and generates an estimate of the StyleGAN latent w. The loss function is identical to Eq. 8 and compares the reconstructed sample with ground truth.
+
+We show results in Fig. 5 (right). We obtain diverse samples that are all consistent with the input patch. We also compare with a deterministic baseline that minimizes the same loss but only produces a single estimate. While this deterministic estimate also agrees with the input image, it does not model the diversity of outputs. We consequently achieve significantly better FID [54] and KID [55] scores than the deterministic baseline, reported in Tab. 1 (right).
+
+![](images/b35beda113f899a1382d37d071b450b64e9a073c643e66f25ed012264c2cdc3b.jpg)
+
+# 5 Discussion
+
+Limitations. While our method makes significant advances in generative modeling, it still has several limitations. Sampling 3D scenes at test time can be very slow, due to the expensive nature of the denoising process and the cost of volume rendering. We need multi-view observations of training scenes for the inverse graphics application. Our models are not trained on very large-scale datasets, and can thus not generalize to out-of-distribution data.
+
+Conclusion We have introduced a new method that tightly integrates differentiable forward models and conditional diffusion models. Our model learns to sample from the distribution of signals trained only using their observations. We demonstrate the efficacy of our approach on three challenging computer vision problems. In inverse graphics, our method, in combination with a 3D-structured conditioning method, enables us to directly sample from the distribution of real-world 3D scenes consistent with a single image observation. We can then render multi-view consistent novel views while obtaining diverse samples of 3D geometry and appearance in unobserved regions of the scene. We further tackle single-image conditional motion synthesis, where we learn to sample from the distribution of 2D motion conditioned on a single image, as well as GAN inversion, where we learn to sample images that exist in the latent space of a GAN that are consistent with a given patch. With this work, we make contributions that broaden the applicability of state-of-the-art generative modeling to a large range of scientifically relevant applications, and hope to inspire future research in this direction.
+
+Acknowledgements. This work was supported by the National Science Foundation under Grant No. 2211259, by the Singapore DSTA under DST00OECI20300823 (New Representations for Vision), by the NSF award 1955864 (Occlusion and Directional Resolution in Computational Imaging), by the ONR MURI grant N00014-22-1-2740, and by the Amazon Science Hub. We are grateful for helpful conversations with members of the Scene Representation Group David Charatan, Cameron Smith, and Boyuan Chen. We thank Zhizhuo Zhou for thoughtful discussions about the SparseFusion baseline. This article solely reflects the opinions and conclusions of its authors and no other entity.
+
+Author contributions. Ayush and Vincent conceived the idea of diffusion with forward models, designed experiments, generated most figures, and wrote most of the paper. Ayush contributed the key insight to integrate differentiable rendering with diffusion models by denoising in image space while generating 3D scenes. Ayush and Vincent generalized this to general forward models, and conceived the single-image motion application. Vincent contributed the 3D-structured conditioning and generated the overview and methods figures. Ayush wrote all initial code and ran all initial experiments. Ayush and Tianwei implemented the inverse graphics application and generated most of the 3D results of our model, while George helped with the baseline 3D results. Ayush executed all single-image motion experiments. George conceived, implemented, and executed all GAN inversion experiments. Semon helped formalizing the method and wrote the proposition and its proof. Frédo and Bill were involved in regular meetings and gave valuable feedback on results and experiments. Josh provided intriguing cognitive science perspectives and feedback on results and experiments, and provided a significant part of the compute. Vincent’s Scene Representation Group provided a significant part of the compute, and the project profited from code infrastructure developed by and conversations with other members of the Scene Representation Group.
+
+References   
+[1] Jascha Sohl-Dickstein, Eric Weiss, Niru Maheswaranathan, and Surya Ganguli. Deep unsupervised learning using nonequilibrium thermodynamics. In Proc. ICML, 2015. 2   
+[2] Norman Müller, , Yawar Siddiqui, Lorenzo Porzi, Samuel Rota Bulò, Peter Kontschieder, and Matthias Nießner. Diffrf: Rendering-guided 3d radiance field diffusion. Proc. CVPR, 2023. 2, 5, 6   
+[3] Seung Wook Kim, Bradley Brown, Kangxue Yin, Karsten Kreis, Katja Schwarz, Daiqing Li, Robin Rombach, Antonio Torralba, and Sanja Fidler. Neuralfield-ldm: Scene generation with hierarchical latent diffusion models. Proc. CVPR, 2023. 2, 6   
+[4] Eric R Chan, Koki Nagano, Matthew A Chan, Alexander W Bergman, Jeong Joon Park, Axel Levy, Miika Aittala, Shalini De Mello, Tero Karras, and Gordon Wetzstein. Generative novel view synthesis with 3d-aware diffusion models. arXiv preprint arXiv:2304.02602, 2023. 2, 6   
+[5] Zhizhuo Zhou and Shubham Tulsiani. Sparsefusion: Distilling view-conditioned diffusion for 3d reconstruction. Proc. CVPR, 2023. 2, 6, 7, 8, 9   
+[6] Ben Poole, Ajay Jain, Jonathan T. Barron, and Ben Mildenhall. Dreamfusion: Text-to-3d using 2d diffusion. Proc. ICLR, 2023. 2, 6   
+[7] Titas Anciukevicius, Zexiang Xu, Matthew Fisher, Paul Henderson, Hakan Bilen, Niloy J Mitra, and Paul ˇ Guerrero. Renderdiffusion: Image diffusion for 3d reconstruction, inpainting and generation. Proc. CVPR, 2023. 2, 5, 6   
+[8] Tero Karras, Samuli Laine, Miika Aittala, Janne Hellsten, Jaakko Lehtinen, and Timo Aila. Analyzing and improving the image quality of stylegan. In Proc. CVPR, 2020. 2, 9   
+[9] Alex Yu, Vickie Ye, Matthew Tancik, and Angjoo Kanazawa. pixelnerf: Neural radiance fields from one or few images. In Proc. CVPR, 2021. 5, 6, 7, 8, 9   
+[10] Diederik P Kingma and Max Welling. Auto-encoding variational bayes. Proc. ICLR, 2014. 5   
+[11] Danilo Jimenez Rezende, Shakir Mohamed, and Daan Wierstra. Stochastic backpropagation and approximate inference in deep generative models. In Proc. ICML, 2014. 5   
+[12] Danilo Rezende and Shakir Mohamed. Variational inference with normalizing flows. In Proc. ICML, 2015. 5   
+[13] Marta Garnelo, Dan Rosenbaum, Christopher Maddison, Tiago Ramalho, David Saxton, Murray Shanahan, Yee Whye Teh, Danilo Rezende, and SM Ali Eslami. Conditional neural processes. In Proc. ICML, 2018. 5   
+[14] Hyunjik Kim, Andriy Mnih, Jonathan Schwarz, Marta Garnelo, Ali Eslami, Dan Rosenbaum, Oriol Vinyals, and Yee Whye Teh. Attentive neural processes. Proc. ICLR, 2019. 5   
+[15] Adam R Kosiorek, Heiko Strathmann, Daniel Zoran, Pol Moreno, Rosalia Schneider, Sona Mokrá, and Danilo Jimenez Rezende. Nerf-vae: A geometry aware 3d scene generative model. In Proc. ICML, 2021. 5   
+[16] Pol Moreno, Adam R Kosiorek, Heiko Strathmann, Daniel Zoran, Rosalia G Schneider, Björn Winckler, Larisa Markeeva, Théophane Weber, and Danilo J Rezende. Laser: Latent set representations for 3d generative modeling. arXiv preprint arXiv:2301.05747, 2023. 5   
+[17] Eric R Chan, Marco Monteiro, Petr Kellnhofer, Jiajun Wu, and Gordon Wetzstein. pi-gan: Periodic implicit generative adversarial networks for 3d-aware image synthesis. In Proc. CVPR, 2021. 5   
+[18] Jun Gao, Tianchang Shen, Zian Wang, Wenzheng Chen, Kangxue Yin, Daiqing Li, Or Litany, Zan Gojcic, and Sanja Fidler. Get3d: A generative model of high quality 3d textured shapes learned from images. Proc. NeurIPS, 2022. 5   
+[19] Terrance DeVries, Miguel Angel Bautista, Nitish Srivastava, Graham W Taylor, and Joshua M Susskind. Unconstrained scene generation with locally conditioned radiance fields. In Proc. ICCV, 2021. 5   
+[20] Animesh Karnewar, Andrea Vedaldi, David Novotny, and Niloy Mitra. Holodiffusion: Training a 3d diffusion model using 2d images. Proc. CVPR, 2023. 5, 6   
+[21] Hyungjin Chung, Jeongsol Kim, Michael Thompson Mccann, Marc Louis Klasky, and Jong Chul Ye. Diffusion posterior sampling for general noisy inverse problems. In Proc. ICLR, 2023. 5 [22] Jooyoung Choi, Sungwon Kim, Yonghyun Jeong, Youngjune Gwon, and Sungroh Yoon. Ilvr: Conditioning method for denoising diffusion probabilistic models. Proc. ICCV, 2021. 5 [23] Bahjat Kawar, Michael Elad, Stefano Ermon, and Jiaming Song. Denoising diffusion restoration models. In Proc. NeurIPS, 2022. 5 [24] Jiaming Song, Arash Vahdat, Morteza Mardani, and Jan Kautz. Pseudoinverse-guided diffusion models for inverse problems. In Proc. ICLR, 2023. 5 [25] Zahra Kadkhodaie and Eero Simoncelli. Stochastic solutions for linear inverse problems using the prior implicit in a denoiser. Advances in Neural Information Processing Systems, 34:13242–13254, 2021. 5 [26] Yang Song, Jascha Sohl-Dickstein, Diederik P Kingma, Abhishek Kumar, Stefano Ermon, and Ben Poole. Score-based generative modeling through stochastic differential equations. In Proc. ICLR, 2021. 5 [27] Yang Song, Liyue Shen, Lei Xing, and Stefano Ermon. Solving inverse problems in medical imaging with score-based generative models. Proc. ICLR, 2022. 5 [28] Johnathan M Bardsley. Mcmc-based image reconstruction with uncertainty quantification. SIAM Journal on Scientific Computing, 34(3):A1316–A1332, 2012. 5 [29] Singanallur Venkatakrishnan, Charles A. Bouman, and Brendt Wohlberg. Plug-and-play priors for model based reconstruction. 2013 IEEE Global Conference on Signal and Information Processing, pages 945–948,   
+2013. 5 [30] Yaniv Romano, Michael Elad, and Peyman Milanfar. The little engine that could: Regularization by denoising (red). SIAM Journal on Imaging Sciences, 10(4):1804–1844, 2017. 5 [31] Vincent Sitzmann, Michael Zollhöfer, and Gordon Wetzstein. Scene representation networks: Continuous   
+3d-structure-aware neural scene representations. Proc. NeurIPS, 2019. 6 [32] Michael Niemeyer, Lars Mescheder, Michael Oechsle, and Andreas Geiger. Differentiable volumetric rendering: Learning implicit 3d representations without 3d supervision. In Proc. CVPR, 2020. 6 [33] Philipp Henzler, Jeremy Reizenstein, Patrick Labatut, Roman Shapovalov, Tobias Ritschel, Andrea Vedaldi, and David Novotny. Unsupervised learning of 3d object categories from videos in the wild. In Proc. CVPR,   
+2021. 6 [34] Prafull Sharma, Ayush Tewari, Yilun Du, Sergey Zakharov, Rares Andrei Ambrus, Adrien Gaidon, William T Freeman, Fredo Durand, Joshua B Tenenbaum, and Vincent Sitzmann. Neural groundplans: Persistent neural scene representations from a single image. In Proc. ICLR. 6 [35] Anpei Chen, Zexiang Xu, Fuqiang Zhao, Xiaoshuai Zhang, Fanbo Xiang, Jingyi Yu, and Hao Su. Mvsnerf: Fast generalizable radiance field reconstruction from multi-view stereo. In Proc. ICCV, 2021. 6 [36] Yilun Du, Cameron Smith, Ayush Tewari, and Vincent Sitzmann. Learning to render novel views from wide-baseline stereo pairs. In Proc. CVPR, 2023. 6 [37] Alex Trevithick and Bo Yang. Grf: Learning a general radiance field for 3d representation and rendering. In Proc. ICCV, 2021. 6 [38] Mohammed Suhail, Carlos Esteves, Leonid Sigal, and Ameesh Makadia. Generalizable patch-based neural rendering. In Proc. ECCV, 2022. 6 [39] Julian Chibane, Aayush Bansal, Verica Lazova, and Gerard Pons-Moll. Stereo radiance fields (srf): Learning view synthesis for sparse views of novel scenes. In Proc. CVPR, 2021. 6 [40] Qianqian Wang, Zhicheng Wang, Kyle Genova, Pratul P Srinivasan, Howard Zhou, Jonathan T Barron, Ricardo Martin-Brualla, Noah Snavely, and Thomas Funkhouser. Ibrnet: Learning multi-view image-based rendering. In Proc. CVPR, 2021. 6 [41] Shamit Lal, Mihir Prabhudesai, Ishita Mediratta, Adam W Harley, and Katerina Fragkiadaki. Coconets: Continuous contrastive 3d scene representations. In Proc. CVPR, 2021. 6 [42] Daniel Watson, William Chan, Ricardo Martin-Brualla, Jonathan Ho, Andrea Tagliasacchi, and Mohammad Norouzi. Novel view synthesis with diffusion models. Proc. ICLR, 2023. 6 [43] SM Ali Eslami, Danilo Jimenez Rezende, Frederic Besse, Fabio Viola, Ari S Morcos, Marta Garnelo, Avraham Ruderman, Andrei A Rusu, Ivo Danihelka, Karol Gregor, et al. Neural scene representation and rendering. Science, 360(6394):1204–1210, 2018. 6   
+[44] Hung-Yu Tseng, Qinbo Li, Changil Kim, Suhib Alsisan, Jia-Bin Huang, and Johannes Kopf. Consistent view synthesis with pose-guided diffusion models. arXiv preprint arXiv:2303.17598, 2023. 6   
+[45] Jiatao Gu, Qingzhe Gao, Shuangfei Zhai, Baoquan Chen, Lingjie Liu, and Josh Susskind. Learning controllable 3d diffusion models from single-view images. arXiv preprint arXiv:2304.06700, 2023. 6   
+[46] Luke Melas-Kyriazi, Christian Rupprecht, Iro Laina, and Andrea Vedaldi. Realfusion: 360 {\deg} reconstruction of any object from a single image. Proc. CVPR, 2023. 6   
+[47] Lukas Höllein, Ang Cao, Andrew Owens, Justin Johnson, and Matthias Nießner. Text2room: Extracting textured 3d meshes from 2d text-to-image models. arXiv preprint arXiv:2303.11989, 2023. 6   
+[48] Rafail Fridman, Amit Abecasis, Yoni Kasten, and Tali Dekel. Scenescape: Text-driven consistent scene generation. arXiv preprint arXiv:2302.01133, 2023. 6   
+[49] Ben Mildenhall, Pratul P. Srinivasan, Matthew Tancik, Jonathan T. Barron, Ravi Ramamoorthi, and Ren Ng. Nerf: Representing scenes as neural radiance fields for view synthesis. In Proc. ECCV, 2020. 6, 7   
+[50] Jeremy Reizenstein, Roman Shapovalov, Philipp Henzler, Luca Sbordone, Patrick Labatut, and David Novotny. Common objects in 3d: Large-scale learning and evaluation of real-life 3d category reconstruction. In Proc. ICCV, 2021. 8   
+[51] Tinghui Zhou, Richard Tucker, John Flynn, Graham Fyffe, and Noah Snavely. Stereo magnification: Learning view synthesis using multiplane images. ACM Trans. Graph. (Proc. SIGGRAPH), 37, 2018. 8   
+[52] Yi Ding, Alex Rich, Mason Wang, Noah Stier, Matthew Turk, Pradeep Sen, and Tobias Höllerer. Sparse fusion for multimodal transformers. arXiv preprint arXiv:2111.11992, 2021. 8   
+[53] Richard Zhang, Phillip Isola, Alexei A Efros, Eli Shechtman, and Oliver Wang. The unreasonable effectiveness of deep features as a perceptual metric. In Proc. CVPR, 2018. 8   
+[54] Martin Heusel, Hubert Ramsauer, Thomas Unterthiner, Bernhard Nessler, and Sepp Hochreiter. Gans trained by a two time-scale update rule converge to a local nash equilibrium. Proc. NeurIPS, 2017. 8, 10   
+[55] Mikołaj Binkowski, Danica J Sutherland, Michael Arbel, and Arthur Gretton. Demystifying mmd gans. ´ arXiv preprint arXiv:1801.01401, 2018. 8, 10   
+[56] Tianfan Xue, Baian Chen, Jiajun Wu, Donglai Wei, and William T Freeman. Video enhancement with task-oriented flow. International Journal of Computer Vision, 127:1106–1125, 2019. 8   
+[57] Ruohan Gao, Bo Xiong, and Kristen Grauman. Im2flow: Motion hallucination from static images for action recognition. In Proc. CVPR, 2018. 9   
+[58] Jacob Walker, Abhinav Gupta, and Martial Hebert. Dense optical flow prediction from a static image. In Proc. ICCV, 2015. 9   
+[59] Silvia L Pintea, Jan C van Gemert, and Arnold WM Smeulders. Déja vu: Motion prediction in static images. In Proc. ECCV, 2014. 9   
+[60] Jacob Walker, Carl Doersch, Abhinav Gupta, and Martial Hebert. An uncertain future: Forecasting from static images using variational autoencoders. In Proc. ECCV. Springer, 2016. 9   
+[61] Yijun Li, Chen Fang, Jimei Yang, Zhaowen Wang, Xin Lu, and Ming-Hsuan Yang. Flow-grounded spatial-temporal video prediction from still images. In Proc. ICCV, 2018. 9   
+[62] Jacob Walker, Kenneth Marino, Abhinav Gupta, and Martial Hebert. The pose knows: Video forecasting by generating pose futures. In Proc. ICCV, 2017. 9   
+[63] Angjoo Kanazawa, Shubham Tulsiani, Alexei A Efros, and Jitendra Malik. Learning category-specific mesh reconstruction from image collections. In Proc. ECCV, 2018. 9   
+[64] Subhabrata Choudhury, Laurynas Karazija, Iro Laina, Andrea Vedaldi, and Christian Rupprecht. Guess what moves: unsupervised video and image segmentation by anticipating motion. arXiv preprint arXiv:2205.07844, 2022. 9   
+[65] Simon Niklaus and Feng Liu. Softmax splatting for video frame interpolation. In Proc. CVPR, 2020. 9   
+[66] Jun-Yan Zhu, Philipp Krähenbühl, Eli Shechtman, and Alexei A. Efros. Generative visual manipulation on the natural image manifold. In Proc. ECCV, 2016. 9   
+[67] Erik Härkönen, Aaron Hertzmann, Jaakko Lehtinen, and Sylvain Paris. Ganspace: Discovering interpretable gan controls. Proc. NeurIPS, 2020. 9   
+[68] Ayush Tewari, Mohamed Elgharib, Gaurav Bharaj, Florian Bernard, Hans-Peter Seidel, Patrick Pérez, Michael Zollhofer, and Christian Theobalt. Stylerig: Rigging stylegan for 3d control over portrait images. In Proc. CVPR, 2020. 9   
+[69] Yujun Shen, Ceyuan Yang, Xiaoou Tang, and Bolei Zhou. Interfacegan: Interpreting the disentangled face representation learned by gans. IEEE transactions on pattern analysis and machine intelligence, 44(4):2004–2018, 2020. 9   
+[70] Rameen Abdal, Yipeng Qin, and Peter Wonka. Image2stylegan: How to embed images into the stylegan latent space? In Proc. ICCV, 2019. 9   
+[71] Rameen Abdal, Yipeng Qin, and Peter Wonka. Image2stylegan $^ { + + }$ : How to edit the embedded images? In Proc. CVPR, 2020. 9   
+[72] David Bau, Hendrik Strobelt, William Peebles, Jonas Wulff, Bolei Zhou, Jun-Yan Zhu, and Antonio Torralba. Semantic photo manipulation with a generative image prior. arXiv preprint arXiv:2005.07727, 2020. 9   
+[73] Yuval Alaluf, Or Patashnik, and Daniel Cohen-Or. Restyle: A residual-based stylegan encoder via iterative refinement. In Proc. ICCV, 2021. 9   
+[74] Shanyan Guan, Ying Tai, Bingbing Ni, Feida Zhu, Feiyue Huang, and Xiaokang Yang. Collaborative learning for faster stylegan embedding. arXiv preprint arXiv:2007.01758, 2020. 9   
+[75] Stanislav Pidhorskyi, Donald A Adjeroh, and Gianfranco Doretto. Adversarial latent autoencoders. In Proc. CVPR, 2020. 9   
+[76] Elad Richardson, Yuval Alaluf, Or Patashnik, Yotam Nitzan, Yaniv Azar, Stav Shapiro, and Daniel Cohen-Or. Encoding in style: a stylegan encoder for image-to-image translation. In Proc. CVPR, 2021. 9   
+[77] Omer Tov, Yuval Alaluf, Yotam Nitzan, Or Patashnik, and Daniel Cohen-Or. Designing an encoder for stylegan image manipulation. ACM Transactions on Graphics (TOG), 40(4):1–14, 2021. 9   
+[78] Tengfei Wang, Yong Zhang, Yanbo Fan, Jue Wang, and Qifeng Chen. High-fidelity gan inversion for image attribute editing. In Proc. CVPR, 2022. 9   
+[79] Ayush Tewari, Mohamed Elgharib, Florian Bernard, Hans-Peter Seidel, Patrick Pérez, Michael Zollhöfer, and Christian Theobalt. Pie: Portrait image embedding for semantic control. ACM Transactions on Graphics (TOG), 39(6):1–14, 2020. 9   
+[80] Tero Karras, Samuli Laine, and Timo Aila. A style-based generator architecture for generative adversarial networks. In Proc. CVPR, 2019. 9

parse/dev/gq4xkwQZ1l/gq4xkwQZ1l_content_list.json

@@ -0,0 +1,1173 @@
+[
+    {
+        "type": "text",
+        "text": "Diffusion with Forward Models: Solving Stochastic Inverse Problems Without Direct Supervision ",
+        "text_level": 1,
+        "bbox": [
+            191,
+            122,
+            810,
+            172
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Ayush Tewari1∗ Tianwei Yin1∗ George Cazenavette1 Semon Rezchikov4 Joshua B. Tenenbaum1,2,3 Frédo Durand1 William T. Freeman1 Vincent Sitzmann1 ",
+        "bbox": [
+            183,
+            223,
+            839,
+            256
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1MIT CSAIL 2MIT BCS 3MIT CBMM 4Princeton IAS ",
+        "bbox": [
+            294,
+            266,
+            704,
+            281
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Abstract ",
+        "text_level": 1,
+        "bbox": [
+            462,
+            304,
+            535,
+            320
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Denoising diffusion models have emerged as a powerful class of generative models capable of capturing the distributions of complex, real-world signals. However, current approaches can only model distributions for which training samples are directly accessible, which is not the case in many real-world tasks. In inverse graphics, for instance, we seek to sample from a distribution over 3D scenes consistent with an image but do not have access to ground-truth 3D scenes, only 2D images. We present a new class of conditional denoising diffusion probabilistic models that learn to sample from distributions of signals that are never observed directly, but instead are only measured through a known differentiable forward model that generates partial observations of the unknown signal. To accomplish this, we directly integrate the forward model into the denoising process. At test time, our approach enables us to sample from the distribution over underlying signals consistent with some partial observation. We demonstrate the efficacy of our approach on three challenging computer vision tasks. For instance, in inverse graphics, we demonstrate that our model in combination with a 3D-structured conditioning method enables us to directly sample from the distribution of 3D scenes consistent with a single 2D input image. ",
+        "bbox": [
+            233,
+            337,
+            766,
+            571
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 Introduction ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            599,
+            310,
+            617
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Consider the problem of reconstructing a 3D scene from a single picture. Since much of the 3D scene is unobserved, there are an infinite number of 3D scenes that could have produced the image, due to the 3D-to-2D projection, occlusion, and limited field-of-view that leaves a large part of the 3D scene unobserved. Given the ill-posedness of this problem, it is desirable for a reconstruction algorithm to be able to sample from the distribution over all plausible 3D scenes that are consistent with the 2D image, generating unseen parts in plausible manners. Previous data-completion methods, such as in-painting in 2D images, are trained on large sets of ground-truth output images along with their incomplete (input) counterparts. Such techniques do not easily extend to 3D scene completion, since curating a large dataset of ground-truth 3D scene representations is very challenging. ",
+        "bbox": [
+            174,
+            632,
+            825,
+            757
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "This 3D scene completion problem, known as inverse graphics, is just one instance of a broad class of problems often referred to as Stochastic Inverse Problems, which arise across scientific disciplines whenever we capture partial observations of the world through a sensor. In this paper, we introduce a diffusion-based framework that can tackle this problem class, enabling us to sample from a distribution of signals that are consistent with a set of partial observations that are generated from the signal by a non-invertible, generally nonlinear, forward model. For instance, in inverse graphics, we learn to sample 3D scenes given an image, yet never observe paired observations of images and 3D scenes at training time, nor observe 3D scenes directly. ",
+        "bbox": [
+            174,
+            762,
+            825,
+            875
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "While progress in deep learning for generative modeling has been impressive, this problem remains unsolved. In particular, variational autoencoders and conditional neural processes are natural approaches but have empirically fallen short of modeling the multi-modal distributions required in, for instance, inverse graphics. They have so far been limited to simple datasets. Emerging diffusion models [1], in contrast, enable sampling from highly complex conditional distributions but require samples from the output distribution that is to be modeled for training, e.g. full 3D models. Some recent work in inverse graphics has resorted to a two-stage approach, where one first reconstructs a large dataset of 3D scenes to then train an image-conditional diffusion model to sample from the conditional distribution over these scenes [2, 3]. To avoid a two-stage approach, another recent line of work trains a conditional diffusion model to sample from the distribution over novel views of a scene, only requiring image observations at training time [4, 5]. However, such methods do not model the distribution over 3D scenes directly and therefore cannot sample from the distribution over 3D scenes consistent with an image observation. Thus, a multi-view consistent 3D scene can only be obtained in a costly post-processing stage [6]. A notable exception is the recently proposed RenderDiffusion [7], demonstrating that it is possible to train an unconditional diffusion model over 3D scenes from observing only monocular images. While one can perform conditional sampling even with unconditional models, they are fundamentally limited to simple distributions, in this case, single objects in canonical orientations. ",
+        "bbox": [
+            174,
+            90,
+            825,
+            339
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Our core contribution is a novel approach for integrating any differentiable forward model that describes how partial observations are obtained from signals, such as 2D image observations and 3D scenes, with conditional denoising diffusion models. By sampling an observation from our model, we jointly sample the signal that gave rise to that observation. Our approach has a number of advantages that make it highly attractive for solving complex Stochastic Inverse Problems. First, our model is trained end-to-end and does away with two-stage approaches that first require reconstruction of a large dataset of signals. Second, our model directly yields diverse samples of the signal of interest. For instance, in the inverse graphics setting, our model directly yields highly diverse samples of 3D scenes consistent with an observation that can then be rendered from novel views with guaranteed multi-view consistency. Finally, our model naturally leverages domain knowledge in the form of known forward models, such as differentiable rendering, with all guarantees that such forward models provide. We validate our approach on three challenging computer vision tasks: inverse graphics (the focus of this paper), as well as single-image motion prediction and GAN inversion. ",
+        "bbox": [
+            174,
+            345,
+            825,
+            525
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "In summary, we make the following contributions: ",
+        "bbox": [
+            173,
+            532,
+            503,
+            546
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "1. We propose a new method that integrates differentiable forward models with conditional diffusion models, replacing prior two-step approaches with a conditional generative model trained end-to-end.   \n2. We apply our framework to build the first conditional diffusion model that learns to sample from the distribution of 3D scenes trained only on 2D images. In contrast to prior work, we directly learn image-conditional 3D radiance field generation, instead of sampling from the distribution of novel views conditioned on a context view. Our treatment of inverse graphics exceeds a mere application of the proposed framework, contributing a novel, 3D-structured denoising step that leverages differentiable rendering both for conditioning and for the differentiable forward model.   \n3. We formally prove that under natural assumptions, as the number of observations of each signal in the training set goes to infinity, the proposed model maximizes not only the likelihood of observations, but also the likelihood of the unobserved signals.   \n4. We demonstrate the efficacy of our model for two more downstream tasks with structured forward models: single-image motion prediction, where the forward model is a warping operation, and GAN inversion, where the forward model is a pretrained StyleGAN [8] generator. ",
+        "bbox": [
+            168,
+            558,
+            826,
+            784
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2 Method ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            804,
+            271,
+            821
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Consider observations $( \\mathbf { O } _ { j } ^ { i } , \\phi _ { j } ^ { i } )$ that are generated from underlying signals $\\mathbf { S } _ { j }$ according to a known forward model forward(), i.e., $\\mathbf { O } _ { j } ^ { i } = \\mathtt { f o r w a r d } ( \\mathbf { S } _ { j } , \\phi _ { j } ^ { i } )$ , where $\\phi _ { j } ^ { i }$ are parameters of the forward model corresponding to observation $\\mathbf { O } _ { j } ^ { i }$ . Each observation can be partial. Specifically, given a single observation, there is an infinite number of signals that could have generated this observation. However, we assume that given a hypothetical set of all possible observations, the signal is fully determined. In the case of inverse graphics, $\\mathbf { O } _ { j } ^ { i }$ are image observations of 3D scenes $\\mathbf { S } _ { j }$ and $\\phi _ { j } ^ { i }$ are the camera parameters, where we index scenes with $j$ and observations of the $j$ -th scene via $i$ forward() is the rendering function. Note that if we were to capture every possible image of a 3D scene, the 3D scene is uniquely determined, but given a single image, there are an infinite number of 3D scenes that could have generated that image, both due to the fact that rendering is a projection from 3D and 2D, and due to the fact that a single image only constrains the visible part of the 3D scene. We will drop the subscript $j$ in the following, and leave it implied that we always consider many observations generated from many signals. Fig. 1 provides an illustration of the data. ",
+        "bbox": [
+            174,
+            835,
+            825,
+            911
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "image",
+        "img_path": "images/08e3fadae5b8538ef6afb8f767fec522d7436b3f59682357f380afdb39c9c0f1.jpg",
+        "image_caption": [
+            "Figure 1: Overview of our proposed method. (a) We assume a dataset of tuples of observations $( \\mathbf { O } , \\phi ) ^ { i }$ , generated from unobserved signals S via a differentiable forward model. (b) We propose to integrate the forward model directly into the denoising step of a diffusion model: given a pair of observations of the same signal, we designate context $\\mathbf { O } ^ { \\mathrm { { c u x t } } }$ and target $\\mathbf { \\bar { O } } ^ { \\mathrm { t r g t } }$ . We add noise to $\\mathbf { O } ^ { \\mathrm { { t r g t } } }$ , then feed $( { \\bf O } ^ { \\mathrm { c t x t } } , \\phi ^ { \\mathrm { c t x t } } , { \\bf O } _ { t } ^ { \\mathrm { t r g t } } , \\phi ^ { \\mathrm { t r g t } } )$ to a neural network denoise to estimate the signal $\\mathbf { S } _ { t - 1 }$ . We then apply the forward model to obtain an estimate of the clean target observation, $\\hat { \\mathbf { O } } _ { t - 1 } ^ { \\mathrm { t r g t } }$ . (c) The graphical model of the diffusion process. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            173,
+            88,
+            826,
+            229
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            320,
+            825,
+            434
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "We are now interested in training a model that, at test time, allows us to sample from the distribution of signals that are consistent with a previously unseen observation O. Formally, we aim to model the conditional distribution $p ( \\mathbf { S } | \\mathbf { O } , \\phi )$ . We make the following assumptions: ",
+        "bbox": [
+            174,
+            439,
+            821,
+            482
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "• We have access to a differentiable implementation of forward().   \n• We have access to a large dataset of observations and corresponding parameters of the forward model, $\\{ ( \\mathbf { O } ^ { i } , \\phi ^ { i } ) \\} _ { i } ^ { N }$ .   \n• In our training set, we have access to several observations per signal. ",
+        "bbox": [
+            176,
+            488,
+            825,
+            544
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Crucially, we do not assume that we have direct access to the underlying signal that gave rise to a particular observation, i.e., we do not assume access to tuples of $( \\mathbf { O } , \\phi , \\mathbf { S } )$ . Further, we also do not assume that we have access to any prior distribution over the signal of interest, i.e., we never observe a dataset of signals of the form $\\{ \\bar { \\bf S } ^ { j } \\} _ { j }$ , and thus cannot train a generative model to sample from an unconditional distribution over signals. ",
+        "bbox": [
+            174,
+            549,
+            825,
+            619
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Recent advances in deep-learning-based generative modeling have seen the emergence of denoising diffusion models as powerful generative models that can be trained to generate highly diverse samples from complex, multi-modal distributions. We are thus motivated to leverage denoising diffusion probabilistic models to model $p ( \\mathbf { S } | \\mathbf { O } , \\phi )$ . However, existing approaches cannot be trained if we do not have access to signals S. In the following, we give background on denoising diffusion models and discuss the limitation. ",
+        "bbox": [
+            173,
+            626,
+            825,
+            708
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "2.1 Background: Denoising Diffusion Probabilistic Models and their Limitation ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            723,
+            738,
+            739
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Denoising diffusion probablistic models are a class of generative models that learn to sample from a distribution by learning to iteratively denoise samples. Consider the problem of modeling the distribution $p _ { \\theta } ( \\mathbf { x } )$ over samples $\\mathbf { x }$ . A forward Markovian process $q \\big ( \\mathbf { x } _ { 0 : T } \\big )$ adds noise to the data as ",
+        "bbox": [
+            174,
+            750,
+            825,
+            791
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/04b9e349f8d5ef91b40992a4a07adca570d92f29fd5fab21c40f1060c059891a.jpg",
+        "text": "$$\nq ( \\mathbf { x } _ { t } \\mid \\mathbf { x } _ { t - 1 } ) = { \\mathcal { N } } ( \\mathbf { x } _ { t } ; { \\sqrt { 1 - \\beta _ { t } } } \\mathbf { x } _ { t - 1 } , \\beta _ { t } \\mathbf { I } ) .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            356,
+            795,
+            640,
+            814
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Here, $\\beta _ { t }$ , $t \\in { 1 \\dots T }$ are the hyperparameters that control the variance schedule. A denoising diffusion model learns the reverse process, where samples from a distribution $p ( x _ { T } ) = \\mathcal { N } ( \\mathbf { 0 } , \\mathbf { I } )$ are transformed incrementally into the data manifold as $\\begin{array} { r } { p _ { \\theta } ( \\mathbf { x } _ { 0 : T } ) = p ( x _ { T } ) \\prod _ { t = 1 } ^ { T } p _ { \\theta } ( \\mathbf { x } _ { t - 1 } \\mid \\mathbf { x } _ { t } ) } \\end{array}$ , where ",
+        "bbox": [
+            174,
+            816,
+            825,
+            862
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/efb92a7a6323683eb71523f1bbc0f64a644f1d09dd94e8eb509cdb0a710dd372.jpg",
+        "text": "$$\np _ { \\theta } ( \\mathbf { x } _ { t - 1 } \\mid \\mathbf { x } _ { t } ) = \\mathcal { N } ( \\mathbf { x } _ { t - 1 } ; \\mu ( \\mathbf { x } _ { t } , t ) , \\Sigma ( \\mathbf { x } _ { t } , t ) ) .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            348,
+            864,
+            643,
+            881
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "A neural network denoise $_ { \\theta } ( )$ with learnable parameters $\\theta$ learns to reverse the diffusion process. It is also possible to model conditional distributions $p _ { \\theta } ( \\mathbf { x } _ { 0 : T } \\mid \\mathbf { c } )$ , where the output is computed as denoise ${ \\bf \\nabla } _ { \\theta } ( \\mathbf { x } _ { t } , t , \\mathbf { c } )$ . The forward process does not change in this case; in practice, we merely add the conditional signal as input to the denoising model. ",
+        "bbox": [
+            171,
+            883,
+            826,
+            912
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            90,
+            823,
+            119
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Unfortunately, we cannot train existing denoising diffusion models to sample from $p ( \\mathbf { S } \\mid \\mathbf { O } , \\phi )$ , or, in fact, even from an unconditional distribution $p ( \\mathbf { S } )$ . This would require computation of the Markovian forward process in Eq. 1. However, recall that we do not have access to any signals $\\{ \\mathbf { S } ^ { j } \\} _ { j }$ - we thus can not add any noise to any signals to then train a denoising neural network. In other words, since no S is directly observed, we cannot compute $q ( \\mathbf { S } _ { t } \\mid \\mathbf { S } _ { t - 1 } )$ . ",
+        "bbox": [
+            173,
+            126,
+            825,
+            196
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "2.2 Integrating Denoising Diffusion with Differentiable Forward Models ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            210,
+            687,
+            226
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "We now introduce a class of denoising diffusion models that we train to directly model the distribution $p ( \\mathbf { S } \\mid \\mathbf { O } ^ { \\mathrm { c t x t } } ; \\phi ^ { \\mathrm { c t x t } } )$ over signals $\\mathbf { S }$ given an observation $( \\mathbf { O } ^ { \\mathrm { c t x t } } , \\phi ^ { \\mathrm { c t x t } } )$ . Our key contribution is to directly integrate the differentiable forward model forward() into the iterative conditional denoising process. This enables us to add noise to and denoise the observations, while nevertheless sampling the underlying signal that generates that observation. ",
+        "bbox": [
+            173,
+            234,
+            825,
+            306
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Our model is trained on pairs of “context” and “target” observations of the same signal, denoted as $\\mathbf { O } ^ { \\mathrm { c t x t } }$ and ${ \\bf O } ^ { \\mathrm { t r g t } }$ . As in conventional diffusion models, for the forward process, we have $q ( \\mathbf O _ { t } ^ { \\mathrm { t r g t } } \\mid$ ${ \\bf O } _ { t - 1 } ^ { \\mathrm { t r g t } } ) = \\mathcal { N } ( { \\bf O } _ { t } ^ { \\mathrm { t r g t } } ; \\sqrt { 1 - \\beta _ { t } } { \\bf O } _ { t - 1 } ^ { \\mathrm { t r g t } } , \\beta _ { t } { \\bf I } )$ . In the reverse process, we similarly denoise ${ \\bf O } ^ { \\mathrm { t r g t } }$ conditional on Octxt: ",
+        "bbox": [
+            174,
+            310,
+            825,
+            371
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/159f13d874f2c7206299b20e2f6ce3eefd55f48d99e11a0ac0a3f68d9f7fd710.jpg",
+        "text": "$$\np _ { \\theta } ( \\mathbf { O } _ { 0 : T } ^ { \\mathrm { t r g t } } \\mid \\mathbf { O } ^ { \\mathrm { c t x t } } ; \\phi ^ { \\mathrm { c t x t } } , \\phi ^ { \\mathrm { t r g t } } ) = p ( \\mathbf { O } _ { T } ^ { \\mathrm { t r g t } } ) \\prod _ { t = 0 } ^ { T } p _ { \\theta } ( \\mathbf { O } _ { t - 1 } ^ { \\mathrm { t r g t } } \\mid \\mathbf { O } _ { t } ^ { \\mathrm { t r g t } } , \\mathbf { O } ^ { \\mathrm { c t x t } } ; \\phi ^ { \\mathrm { c t x t } } , \\phi ^ { \\mathrm { t r g t } } ) ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            246,
+            372,
+            748,
+            415
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "However, unlike conventional diffusion models, we implement $p _ { \\theta } ( \\mathbf { O } _ { t - 1 } ^ { \\mathrm { t r g t } } \\mid \\mathbf { O } _ { t } ^ { \\mathrm { t r g t } } , \\mathbf { O } ^ { \\mathrm { c t x t } } ; \\phi ^ { \\mathrm { c t x t } } , \\phi ^ { \\mathrm { t r g t } } )$ by first predicting an estimate of the underlying signal $\\mathbf { S } _ { t - 1 }$ and then mapping it to an estimate of the denoised observations via the differentiable forward: ",
+        "bbox": [
+            173,
+            417,
+            825,
+            460
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/2ae9c03c3a21cda32dbd88ba2393d8800dfcbbec073f5de191912d7bf4890ae8.jpg",
+        "text": "$$\n\\begin{array} { r l } & { { \\bf S } _ { t - 1 } = \\mathrm { d e n o i s e } _ { \\theta } ( { \\bf O } ^ { \\mathrm { c t x t } } , { \\bf O } _ { t } ^ { \\mathrm { t r g t } } ; t , \\phi ^ { \\mathrm { c t x t } } , \\phi ^ { \\mathrm { t r g t } } ) , } \\\\ & { \\hat { \\bf O } _ { t - 1 } ^ { \\mathrm { t r g t } } = \\mathrm { f o r w a r d } ( { \\bf S } _ { t - 1 } , \\phi ^ { \\mathrm { t r g t } } ) } \\\\ & { { \\bf O } _ { t - 1 } ^ { \\mathrm { t r g t } } \\sim \\mathcal { N } ( { \\bf O } _ { t - 1 } ^ { \\mathrm { t r g t } } ; C _ { t - 1 } \\hat { \\bf O } _ { t - 1 } ^ { \\mathrm { t r g t } } , \\hat { \\beta } _ { t - 1 } { \\bf I } ) } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            351,
+            462,
+            643,
+            525
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Here, $\\hat { \\mathbf { O } } _ { t - 1 } ^ { \\mathrm { t r g t } }$ is an estimate of the clean observation, and the constants $C _ { t - 1 }$ and $\\hat { \\beta } _ { t - 1 }$ are chosen to match the total noise added by the forward process at time $t$ -1. See Fig. 1 for an overview. At test time, a signal is sampled by iterating Eq. 4, 5, and 6 starting with $p ( \\mathbf { O } _ { t = T } ^ { \\mathrm { t r g t } } ) \\sim \\mathcal { N } ( \\mathbf { 0 } , \\mathbf { I } )$ . Importantly, our models define a generative model over the underlying signal via Eq. 4: ",
+        "bbox": [
+            174,
+            527,
+            825,
+            587
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/ea95c691e4e029777a6b31f5a9920a1ede3ede54abe93ef3d884c5ec8deeadfe.jpg",
+        "text": "$$\np _ { \\theta , \\phi ^ { \\mathrm { t r g t } } } ( \\mathbf { S } _ { 0 : T } \\mid \\mathbf { O } ^ { \\mathrm { c t x t } } ; \\phi ^ { \\mathrm { c t x t } } ) = \\prod _ { t = 1 } ^ { T } p _ { \\theta } ( \\mathbf { S } _ { t - 1 } \\mid \\mathbf { O } _ { t } ^ { \\mathrm { t r g t } } , \\mathbf { O } ^ { \\mathrm { c t x t } } ; \\phi ^ { \\mathrm { c t x t } } , \\phi ^ { \\mathrm { t r g t } } ) .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            285,
+            588,
+            710,
+            631
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "We will suppress the subscript in the notation, and refer to this distribution as $p ( \\mathbf { S } _ { 0 : T } \\mid \\mathbf { O } ^ { \\mathrm { c t x t } } ; \\phi ^ { \\mathrm { c t x t } } )$ for brevity from now. ",
+        "bbox": [
+            173,
+            632,
+            825,
+            661
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Loss Function. We train to minimize the following two loss terms: ",
+        "bbox": [
+            173,
+            667,
+            614,
+            683
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/e8b73765d93822dfdb75f07757d3cf83887bb2e2ab79d046ff95963cad52a418.jpg",
+        "text": "$$\n\\begin{array} { r l } & { \\mathcal { L } _ { \\theta } ^ { \\mathrm { t r g t } } = \\mathbb { E } _ { \\mathbf { O } ^ { \\mathrm { c u t } } , \\mathbf { O } ^ { \\mathrm { t r g t } } , \\phi ^ { \\mathrm { s r u } } , \\phi ^ { \\mathrm { i r g t } } , t } \\Big [ \\| \\mathbf { O } ^ { \\mathrm { t r g t } } - \\underbrace { \\underline { { \\boldsymbol { \\Sigma } } } \\boldsymbol { \\mathrm { o r w a r d } } \\big ( \\mathbf { d e n o \\mathrm { i } } \\mathbf { s } \\boldsymbol { \\mathrm { e } } _ { \\theta } \\big ( \\mathbf { O } ^ { \\mathrm { c u t } } , \\mathbf { O } _ { t } ^ { \\mathrm { t r g t } } ; t , \\phi ^ { \\mathrm { c u t } } , \\phi ^ { \\mathrm { t r g t } } \\big ) , \\phi ^ { \\mathrm { t r g t } } \\big ) } _ { = \\hat { \\mathbf { O } } _ { t - 1 } ^ { \\mathrm { t r g t } } } \\| ^ { 2 } \\Big ] , } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            218,
+            684,
+            826,
+            731
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/8fd688fd6099309c61b9c06be7eefc9b11e35ee7a1db91fed7f25a739718d43a.jpg",
+        "text": "$$\n\\begin{array} { r } { \\mathcal { L } _ { \\theta } ^ { \\mathrm { n o w e l } } = \\mathbb { E } _ { \\mathbf { O } ^ { \\mathrm { c u t } } , \\mathbf { O } ^ { \\mathrm { n o w e l } } , \\phi ^ { \\mathrm { c u t } } , \\phi ^ { \\mathrm { n o w } } , \\phi ^ { \\mathrm { n o w e l } } , t } [ \\| \\mathbf { O } ^ { \\mathrm { n o w e l } } - \\underbrace { \\underline { { \\boldsymbol { \\Sigma } } } \\boldsymbol { \\mathrm { o r w a r d } } \\big ( \\mathbf { d e n o i } \\mathbf { s } \\boldsymbol { \\Theta } _ { \\theta } \\big ( \\mathbf { O } ^ { \\mathrm { c u t } } , \\mathbf { O } _ { t } ^ { \\mathrm { i n f } } ; t , \\phi ^ { \\mathrm { c u t } } , \\phi ^ { \\mathrm { n o r t } } \\big ) , \\phi ^ { \\mathrm { n o w e l } } \\big ) } _ { = \\hat { \\mathbf { O } } _ { t - 1 } ^ { \\mathrm { n o w e l } } }  } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            171,
+            744,
+            816,
+            791
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Here, we compute the estimate of the observation from the target, as well as a separate, novel forward model parameter $\\phi ^ { \\mathrm { n o v e l } }$ . In the supplemental document, we show that these losses approximate a total observation loss, maximizing the likelihood of all possible observations of the signal S. ",
+        "bbox": [
+            176,
+            806,
+            826,
+            849
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Characterizing the Conditional Distribution Over Signals. Due to the complexity of the reverse process, it may not be clear that the learned distribution over signals will agree with the true distribution, even in the limit of infinite data. However, this model will indeed asymptotically learn the true conditional distribution over signals, as we formally prove in the supplement: ",
+        "bbox": [
+            174,
+            854,
+            825,
+            911
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "image",
+        "img_path": "images/4b82c45eef40a032ce294a783e3372e2edf6e48277663a89072d22b1b57d1ff0.jpg",
+        "image_caption": [
+            "Figure 2: Overview of 3D Generative Modeling. We build a 3D-structured denoise operator on top of pixelNeRF [9] that learns to sample from the distribution of 3D scenes from image observations only. Given a context image $\\mathbf { O } ^ { \\mathrm { { c u x t } } }$ with camera pose $\\phi ^ { \\mathrm { c t x t } }$ , we pick a target pose $\\phi ^ { \\mathrm { t r g t } }$ . We render out a deterministic estimate of the depth, RGB, and features of the target view $\\mathbf { O } _ { \\mathrm { d e t } } ^ { \\mathrm { t r g t } }$ using pixel-aligned features $\\mathbf { f } ^ { \\mathrm { c u t } }$ extracted from the (left, only RGB shown here). To generate a 3D scene, we concatenate the deterministic estimate with noise $\\mathbf { O } _ { t } ^ { \\mathrm { t r g t } }$ , and extract features $\\mathbf { f } _ { t } ^ { \\mathrm { t r g t } }$ for the target view with $\\mathtt { e n c } _ { t }$ . $\\mathbf { f } _ { t } ^ { \\mathrm { t r g t } }$ and $\\mathbf { f } ^ { \\mathrm { c t x t } }$ now jointly parameterize the radiance field of the generated scene $\\mathbf { S } _ { t - 1 }$ , and we may render an estimate of the clean target view $\\hat { \\mathbf { O } } _ { t - 1 } ^ { \\mathrm { t r g t } }$ . The model is trained end-to-end via a re-rendering loss. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            173,
+            88,
+            825,
+            273
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Proposition 1. Suppose that any signal S can be reconstructed from the set of all all possible observations of S. Under this assumption, if in the limit as the number of known observations per signal goes to infinity, there are parameters $\\theta$ such that $\\mathcal { L } _ { \\theta } ^ { \\mathrm { t r g t } } + \\mathcal { L } ^ { \\mathrm { n o v e l } }$ is minimized, then the conditional probability distribution over signals discovered by our model $p ( \\mathbf { S } \\mid \\mathbf { O } ^ { \\mathrm { c t x t } } ; \\phi ^ { \\mathrm { c t x t } } )$ agrees with the true distribution $p ^ { \\mathrm { t r u e } } ( \\mathbf { S } \\mid \\mathbf { O } ^ { \\mathrm { c t x t } } ; \\phi ^ { \\mathrm { c t x t } } )$ . ",
+        "bbox": [
+            174,
+            393,
+            825,
+            465
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "The proof follows by showing that our losses implicitly minimize a diffusion model loss over total observations, which are collections of all possible observations of our signal. As such, when the observations suffice to completely reconstruct the signal, the correctness of the estimated distribution over total observations forces the estimated distribution over signals to be correct, as well. ",
+        "bbox": [
+            174,
+            476,
+            825,
+            531
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "3 Prior Work on Latent Variable Models for Inverse Problems ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            551,
+            707,
+            569
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Variational Autoencoders [10, 11], normalizing flows [12], conditional [13] and attentive neural processes [14] are latent-variable models that can be combined with forward models to learn to sample from the distribution of unobserved signals from observations [15, 16]. However, they empirically fall short of accurately modeling complex signal distributions - in inverse graphics, for instance, such models have so far been limited to synthetic 3D scenes. Generative Adversarial Networks can be trained with differentiable forward models in-the-loop, and have yielded impressive results in unconditional generative modeling of unobserved signals [17–19]. Similarly, in concurrent work, diffusion models have been leveraged for unconditional generative modeling through differentiable forward models [2, 7, 20]. However, unconditional models are limited to tight distributions, and no conditional generative modeling of similar quality has been demonstrated. Diffusion models trained directly on signals have been effectively applied to diverse inverse problems such as superresolution [21–25], inpainting [21, 23–26], and medical imaging [27]. These works utilize the learned prior of the data distribution to recover the latent signal through a “plug and play” approach [28–30], integrating the diffusion model with a forward measurement process according to Bayes’ rule. These approaches are versatile and can easily adapt to new inverse problems without retraining. However, unlike our models, they rely on direct supervision over the signals in the form of large datasets. ",
+        "bbox": [
+            174,
+            583,
+            826,
+            804
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "4 Applications ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            824,
+            310,
+            842
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "We now apply our framework to three stochastic inverse problems. We focus on applications in computer vision, where we tackle the problems of inverse graphics, single-image motion prediction, and GAN inversion. For each application, we give a detailed description of the forward model, the dataset and baselines, as well as a brief description of prior work. ",
+        "bbox": [
+            176,
+            856,
+            825,
+            911
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "image",
+        "img_path": "images/7f738113db8e3aac5992b6bba808f143d99dded384ac2d55c81cd7f2dca1a794.jpg",
+        "image_caption": [
+            "Figure 3: Sample Diversity. We illustrate different 3D scenes sampled from the same context image for RealEstate10k and Co3D datasets. Unlike deterministic methods like pixelNeRF [9], our method generates diverse and distinct 3D scenes that all align with the context image. Co3D results are generated using autoregressive sampling, where a 360 degree trajectory can be generated by iteratively sampling target images. Note the photorealism and diversity of the generated structures for the indoor scene, such as doors and cabinets. Also note the high-fidelity geometry of the occluded parts of the hydrant and the diverse background appearance. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            171,
+            84,
+            823,
+            340
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "4.1 Inverse Graphics ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            435,
+            331,
+            450
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "We seek to learn a model that, given a single image of a 3D scene enables us to sample from the distribution over 3D scenes that are consistent with the observation. We expect that 3D regions visible in the image are reconstructed faithfully, while unobserved parts are generated plausibly. Every time we sample, we expect a different plausible 3D generation. Signals $\\mathbf { S }$ are 3D scenes, and observations are 2D images $\\mathbf { O }$ and their camera parameters $\\phi$ . At training time, we assume that we have access to at least two image observations and their camera parameters per scene, such that we can assemble tuples of $( { \\bf O } ^ { \\mathrm { c t x t } } , \\bar { \\phi } ^ { \\mathrm { c t x t } } , { \\bf O } ^ { \\mathrm { t r g t } } , \\phi ^ { \\mathrm { t r g t } } )$ , with 2D images $\\mathbf { \\bar { O } } ^ { \\mathrm { c t x t } } , \\mathbf { O } ^ { \\mathrm { t r g t } }$ , and camera parameters $\\phi ^ { \\mathrm { c t x t } } , \\phi ^ { \\mathrm { t r g t } }$ . ",
+        "bbox": [
+            174,
+            463,
+            825,
+            560
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Scope. We note that our treatment of inverse graphics exceeds a mere application of the presented framework. In particular, we not only integrate the differentiable rendering forward function, but further propose a novel 3D-structured denoise function. Here, we enable state-of-the-art conditional generation of complex, real-world 3D scenes. ",
+        "bbox": [
+            174,
+            566,
+            825,
+            621
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Related Work. Few-shot reconstruction of 3D scene representations via differentiable rendering was pioneered by deterministic methods [9, 31, 32, 32–41] that blur regions of the 3D scene unobserved in the context observations. Probabilistic methods have been proposed that can sample from the distribution of novel views trained only on images [4, 5, 42–45]. While results are impressive, these methods do not allow sampling from the distribution of 3D scenes, but only from the distribution of novel views. Generations are not multi-view consistent. Obtaining a 3D scene requires costly post-processing via score distillation [6]. Several approaches [2, 3] use a two-stage design: they first reconstruct a dataset of 3D scenes, and then train a 3D diffusion model. However, pre-computing large 3D datasets is expensive. Further, to obtain high-quality results, dense observations are required per scene. RenderDiffusion [7] and HoloDiffusion [20] integrate differentiable forward rendering with an unconditional diffusion model, enabling unconditional sampling of simple, single-object scenes. Similar to us, RenderDiffusion performs denoising in the image space, while HoloDiffusion uses a 3D denoising architecture. Other methods use priors learned by text-conditioned image diffusion models to optimize 3D scenes [46–48]. Here, the generative model does not have explicit knowledge about the 3D information of scenes. These methods often suffer from geometric artifacts. ",
+        "bbox": [
+            174,
+            628,
+            825,
+            835
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Structure of S and forward model render. We can afford only an abridged discussion here - please see the supplement for a more detailed description. We use NeRF [49] as the parameterization of 3D scenes, such that S is a function that maps a 3D coordinate $\\mathbf { p }$ to a color c and density $\\sigma$ as $\\mathbf { S } ( \\mathbf { p } ) = \\left( \\sigma , \\mathbf { c } \\right)$ . We require a generalizable NeRF that is predicted in a feed-forward pass by an encoder that takes a set of $M$ context images and corresponding camera poses $\\{ ( \\mathbf { O } _ { i } , \\phi _ { i } ) \\} _ { i } ^ { \\hat { M } }$ as input. ",
+        "bbox": [
+            174,
+            842,
+            825,
+            911
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "image",
+        "img_path": "images/5fb866e243066062c7db8344499725f0fd3b459fa32b32a376e54ec5ca0024fc.jpg",
+        "image_caption": [
+            "Figure 4: Qualitative Comparison for Inverse Graphics application. We benchmark with SparseFusion [5] and the deterministic pixelNeRF [9]. SparseFusion samples 2D novel views conditioned on a deterministic rendering (Diffusion Out.), and generates multi-view consistent 3D scenes only after Score Distillation. Our method consistently generates higher-quality scenes, while directly sampling 3D scenes. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            171,
+            87,
+            826,
+            325
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "We base our model on pixelNeRF [9]. pixelNeRF first extracts image features $\\{ \\mathbf { F } _ { i } \\} _ { i }$ from each context observation via an encoder enc as $\\mathbf { F } _ { i } = \\mathtt { e n c } ( \\mathbf { O } _ { i } )$ . Given a 3D point $\\mathbf { p }$ , it obtains its pixel coordinates in each context view via $\\mathbf { p } _ { i } ^ { \\mathrm { p i x } } = \\pi ( \\mathbf { p } , \\phi _ { i } )$ via the projection operator $\\pi$ , and recovers a corresponding feature as $\\mathbf { f } _ { i } = \\mathbf { F } _ { i } ( \\mathbf { p } _ { i } ^ { \\mathrm { p i x } } )$ by sampling the feature map at pixel coordinate $\\mathbf { p } _ { i } ^ { \\mathrm { p i x } }$ . It then parameterizes $\\mathbf { S }$ via an MLP as: ",
+        "bbox": [
+            173,
+            391,
+            825,
+            468
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "equation",
+        "img_path": "images/0b029ede01ae164b7fb171ac4b2014ed3b2ee4df71d7de0dcd5c7a2c598771af.jpg",
+        "text": "$$\n\\mathbf { S } ( \\mathbf { p } ) = ( \\sigma ( \\mathbf { p } ) , \\mathbf { c } ( \\mathbf { p } ) ) = \\mathtt { M L P } ( \\{ ( \\mathbf { f } _ { i } \\oplus \\mathbf { p } _ { i } \\} _ { i } ^ { M } ) ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            352,
+            474,
+            643,
+            493
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "where $\\oplus$ is concatenation and $\\mathbf { p } _ { i }$ is the 3D point $\\mathbf { p }$ transformed into the camera coordinates of observation $i$ . The number of context images $M$ is flexible, and we may condition S on a single or several observations. It will be convenient to refer to a pixelNeRF that is reconstructed from context and target observations $( \\mathbf { O } ^ { \\mathrm { c t x t } } , \\phi ^ { \\mathrm { c t x t } } )$ and $( { \\bf O } ^ { \\mathrm { t r g t } } , \\phi ^ { \\mathrm { t r g t } } )$ as ",
+        "bbox": [
+            173,
+            500,
+            825,
+            556
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "equation",
+        "img_path": "images/4aa9fa05247bd46231dd4a5037def4dfc57f7b37df971138464eac177c90235c.jpg",
+        "text": "$$\n\\mathbf { S } ( \\cdot \\mid \\mathrm { e n c } ( \\mathbf { O } ^ { \\mathrm { c t x t } } ) , \\mathrm { e n c } ( \\mathbf { O } ^ { \\mathrm { t r g t } } ) ) ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            400,
+            561,
+            596,
+            579
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "where we make the pixelNeRF encoder enc explicit and drop the poses $\\phi ^ { \\mathrm { t r g t } }$ and $\\phi ^ { \\mathrm { c t x t } }$ . We leverage differentiable volume rendering [49] as forward model, such that ",
+        "bbox": [
+            173,
+            585,
+            825,
+            614
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "equation",
+        "img_path": "images/9d9ae27908c357b42357e57095a66dfcc1cc0971fcb94ba6a31803350cccb2ea.jpg",
+        "text": "$$\n\\mathbf { O } = { \\mathrm { r e n d e r } } ( \\mathbf { S } , \\phi ) ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            431,
+            621,
+            566,
+            638
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "where S is rendered from a camera with parameters $\\phi$ . ",
+        "bbox": [
+            173,
+            643,
+            531,
+            660
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Implementation of denoise. Fig. 2 gives an overview of the denoising procedure. Following our framework, we obtain the denoised target observation $\\hat { \\mathbf { O } } _ { t - 1 } ^ { \\mathrm { t r g t } }$ as: ",
+        "bbox": [
+            171,
+            665,
+            823,
+            696
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "equation",
+        "img_path": "images/94b558e4705bfb28c3f84d434ca0def452f8d766a190468baf6774f9f2f94293.jpg",
+        "text": "$$\n\\begin{array} { r } { \\hat { \\mathbf { O } } _ { t - 1 } ^ { \\mathrm { t r g t } } = \\tt r e n d e r ( \\mathbf { S } _ { t - 1 } , \\phi ^ { \\mathrm { t r g t } } ) , \\quad \\mathrm { w h e r e } } \\\\ { \\mathbf { S } _ { t - 1 } = \\mathbf { S } ( \\cdot \\mid \\mathrm { e n c } _ { t = 0 } ( \\mathbf { O } ^ { \\mathrm { c t x t } } ) , \\mathrm { e n c } _ { t } ( \\mathbf { O } _ { t } ^ { \\mathrm { t r g t } } ) ) , } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            361,
+            702,
+            635,
+            744
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "where the image encoder $\\mathtt { e n c } _ { t }$ is now conditioned on the timestep $t$ . In other words, we will generate a target view $\\hat { \\mathbf { O } } _ { t - 1 } ^ { \\mathrm { t r g t } }$ by rendering the pixelNeRF conditioned on the context and noisy target observations. However, feeding the noisy $\\mathbf { O } _ { t } ^ { \\mathrm { t r g t } }$ directly to pixelNeRF is insufficient. This is because the pixelaligned features $\\mathsf { e n c } _ { t } ( \\mathbf { O } )$ are obtained from each view separately - thus, the features generated by $\\mathtt { e n c } _ { t } ( \\mathbf { O } _ { t } ^ { \\mathrm { t r g t } } )$ will be uninformative. To successfully generate a 3D scene, we have to augment the $\\mathbf { O } _ { t } ^ { \\mathrm { t r g t } }$ with information from the context view. We propose to generate conditioning information for $\\mathbf { O } _ { t } ^ { \\mathrm { t r g t } }$ by rendering a deterministic estimate ${ \\bf O } _ { \\mathrm { d e t } } ^ { \\mathrm { t r g t } } = \\mathrm { r e n d e r } ( { \\bf S } ( \\cdot \\mid \\mathrm { e n c } _ { t = 0 } ( { \\bf O } ^ { \\mathrm { c t x t } } ) ) , \\phi ^ { \\mathrm { t r g t } } )$ . I.e., we condition pixelNeRF only on the context view, and render an estimate of the target view via volume rendering. However, in the extreme case of a completely uncertain target view, this results in a completely blurry image. We thus propose to additionally render high-dimensional features. Recall that any 3D point $\\mathbf { p }$ , we have $( \\sigma ( \\mathbf { p } ) , \\mathbf { \\bar { c } } ( \\mathbf { \\bar { p } } ) ) = \\mathsf { M L P } _ { t } ( \\mathbf { p } )$ . We modify $\\mathtt { M L P } _ { t }$ to also output a high-dimensional feature and render a deterministic feature map to augment $\\mathbf { O } _ { t } ^ { \\mathrm { t r g t } }$ (only RGB shown in figure). We generate the final 3D scene as $\\mathbf { S } _ { t - 1 } = \\mathbf { S } ( \\cdot \\mid \\mathrm { e n c } _ { t = 0 } ( \\mathbf { O } ^ { \\mathrm { c t x t } } )$ , $\\mathbf { e n c } _ { t } ( \\mathbf { O } _ { \\mathrm { d e t } } ^ { \\mathrm { t r g t } } \\oplus \\mathbf { O } _ { t } ^ { \\mathrm { t r g t } } ) ,$ . The final denoised target view is then obtained according to the rendering Eq. 13 above. ",
+        "bbox": [
+            173,
+            748,
+            826,
+            912
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/f71460f37c341c06e7fe429fe010c39358087fe433954aa44f2c7b3fadc9e12a.jpg",
+        "image_caption": [
+            "Figure 5: Qualitative Results for Single-Image Motion Prediction (left) and GAN Inversion (right). "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            173,
+            88,
+            823,
+            193
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            220,
+            825,
+            265
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Loss and Training. Our loss consists of simple least-squares terms on re-rendered views, identical to the general loss terms presented in Eqs. 8 and 9, in addition to regularizers that penalize degenerate 3D scenes. We discuss these regularizers, as well as training details, in the supplement. ",
+        "bbox": [
+            174,
+            272,
+            825,
+            314
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "4.1.1 Results ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            328,
+            276,
+            343
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Datasets We evaluate on two challenging real-world datasets. We use Co3D hydrants [50] to evaluate our method on object-centric scenes. For scene-level 3D synthesis, we use the challenging RealEstate10k dataset [51], consisting of indoor and outdoor videos of scenes. ",
+        "bbox": [
+            176,
+            352,
+            823,
+            393
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Baselines We compare our approach with state-of-the-art approaches in deterministic and probabilistic 3D scene completion. We use pixelNeRF as the representative method for deterministic methods that takes a single image as input and deterministically reconstructs a 3D scene. Our method is the first to probabilistically reconstruct 3D scenes in an end-to-end manner. Regardless, we compare with the concurrent SparseFusion [52] that learns an image-space generative model over novel views of a 3D scene. Score distillation of this generative model is required every time we want to obtain a multi-view consistent 3D scene, which is costly. ",
+        "bbox": [
+            174,
+            400,
+            825,
+            497
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Qualitative Results. In Fig. 3, we show multiple samples of 3D scenes sampled from a monocular image. For the indoor scenes of RealEstate10k, there are large regions of uncertainty. We can sample from the distribution of valid 3D scenes, resulting in significantly different 3D scenes with plausible geometry and colors. The objects are faithfully reconstructed for the object-centric Co3D scenes, and the uncertainty in the scene is captured. We can sample larger 3D scenes and render longer trajectories by autoregressive sampling, i.e., we treat intermediate diffused images as additional context observations to sample another target observation. The Co3D results in Fig. 3 were generated autoregressively for a complete 360 degrees trajectory. In Fig. 4, we compare our results with pixelNeRF [9] and SparseFusion [5]. pixelNeRF is a deterministic method and thus leads to very blurry results in uncertain regions. SparseFusion reconstructs scenes by score-distillation over a 2D generative model. This optimization is very expensive, and does not lead to natural-looking results. ",
+        "bbox": [
+            174,
+            503,
+            825,
+            655
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Quantitative Results. For the object-centric Co3D dataset, we evaluate the accuracy of novel views using PSNR and LPIPS [53] metrics. Note that PSNR/LPIPS are not meaningful metrics for large scenes since the predictions have a large amount of uncertainty, i.e., a wide range of novel view images can be consistent with any input image. Thus, we report FID [54] and KID [55] scores to evaluate the realism of reconstructions in these cases. Our approach outperforms all baselines for LPIPS, FID, and KID metrics, as our model achieves more realistic results. We achieve slightly lower PSNR compared to pixelNeRF [9]. Note that PSNR favors mean estimates, and that we only evaluate our model using a single randomly sampled scene for an input image due to computational constraints. ",
+        "bbox": [
+            174,
+            661,
+            825,
+            773
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "4.2 Single-Image Motion Prediction ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            789,
+            434,
+            804
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Here, we seek to train a model that, given a single static image, allows us to sample from all possible motions of pixels in the image. Given, for instance, an image of a person performing a task, such as kicking a soccer ball, it is possible to predict potential future states. This is a stochastic problem, as there are multiple possible motions consistent with an image. We train on a dataset of natural videos [56]. We only observe RGB frames and never directly observe the underlying motion, i.e, the pixel correspondences in time are unavailable. We use tuples of two frames from videos within a small temporal window, and use them as our context and target observations for training. ",
+        "bbox": [
+            174,
+            814,
+            825,
+            911
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "table",
+        "img_path": "images/f17a6227c81fb1a6ef6bc3e03d582b83b096b6e597227b41e38217d870469d38.jpg",
+        "table_caption": [
+            "GAN Inversion "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td></td><td>FFHQ</td></tr><tr><td></td><td>FID↓ KID↓</td></tr><tr><td>Determ.</td><td>25.7 0.019</td></tr><tr><td>Ours</td><td>7.45 0.002</td></tr></table>",
+        "bbox": [
+            650,
+            111,
+            825,
+            167
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "table",
+        "img_path": "images/af8dde511f3011fb78164717ee0f4ed8c93d33887e59a9748e9970bf3aedde7f.jpg",
+        "table_caption": [
+            "3D Scene Completion "
+        ],
+        "table_footnote": [
+            "Table 1: Quantitative evaluation. (left) We benchmark our 3D generative model with state-of-the-art baselines pixelNeRF [9] and SparseFusion [5]. (right) We benchmark with a deterministic baseline on GAN inversion, which we drastically outperform. "
+        ],
+        "table_body": "<table><tr><td></td><td colspan=\"4\">Co3D</td><td colspan=\"2\">RealEstate10k</td></tr><tr><td></td><td>PSNR↑</td><td>LPIPS↓</td><td>FID↓</td><td>KID↓</td><td>FID↓</td><td>KID↓</td></tr><tr><td>pixelNeRF</td><td>17.93</td><td>0.54</td><td>180.20</td><td>0.14</td><td>195.40</td><td>0.14</td></tr><tr><td>SparseFusion</td><td>12.06</td><td>0.63</td><td>252.13</td><td>0.16</td><td>99.44</td><td>0.04</td></tr><tr><td>Ours</td><td>17.47</td><td>0.42</td><td>84.63</td><td>0.05</td><td>42.84</td><td>0.01</td></tr></table>",
+        "bbox": [
+            181,
+            111,
+            642,
+            178
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Related Work. Several papers tackle this problem, where motion in the form of optical flow [57–59], 2D trajectories [60, 61], and human motion [62, 63] are recovered from a static image; however, all these methods assume supervision over the underlying motion. Learning to reason about motion requires the neural network to learn about the properties and behavior of the different objects in the world. Thus, this serves as a useful proxy task for representation learning, and can be used as a backbone for many downstream applications [60, 64]. ",
+        "bbox": [
+            173,
+            231,
+            825,
+            315
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Structure of S and forward model warp. Our signal S stores the appearance and motion information in a 2D grid. At any pixel u, the signal is defined as $\\mathbf { S } ( \\mathbf { u } ) = ( \\mathbf { S } _ { c } ( \\bar { \\mathbf { u } } ) , \\mathbf { S } _ { m } ( \\mathbf { u } ) )$ , where $\\mathbf { S } _ { c } ( \\mathbf { u } ) \\in \\mathbb { R } ^ { 3 }$ is the color value, and $\\bar { \\bf S } _ { m } ( { \\bf u } ) \\in \\mathbb { R } ^ { 2 }$ is a 2D motion vector. The forward model is a warping operator, such that warp $( \\mathbf { S } , \\phi ) ( \\mathbf { u } + \\phi \\mathbf { S } _ { m } ( \\mathbf { u } ) ) = \\mathbf { S } _ { c } ( \\mathbf { u } )$ and $\\phi$ is a scalar that changes the magnitude of motion. We implement this function using a differentiable point splatting operation [65]. ",
+        "bbox": [
+            173,
+            321,
+            823,
+            391
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Implementation of denoise. The inset figure illustrates our design. We use a 2D network that takes $\\mathbf { O } ^ { \\mathrm { c t x t } }$ , $\\mathbf { O } _ { t } ^ { \\mathrm { t r g t } }$ , and $t$ as input, and generates the motion map $\\mathbf { S } _ { m }$ as the output. The signal is then reconstructed as ${ \\bf S } = ( { \\bf O } ^ { \\mathrm { c t x t } } , { \\bf S } _ { m } )$ . Context and target frames correspond to parameters $\\phi ^ { \\mathrm { c t x t } } = 0$ and $\\phi ^ { \\mathrm { t r g t } } = 1$ and can be reconstructed from the signal using warp. ",
+        "bbox": [
+            174,
+            397,
+            591,
+            482
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "image",
+        "img_path": "images/7cd794f259a725888aed4dc15d47a7cf4dc4e3d3a207f2568508d0994189d262.jpg",
+        "image_caption": [],
+        "image_footnote": [],
+        "bbox": [
+            602,
+            398,
+            821,
+            473
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Loss and Evaluation. Similar to inverse graphics, we use reconstruction and regularization losses. The reconstruction losses are identical to Eqs. 8 and 9, and the regularization loss is a smoothness term that encourages a natural motion of the scene, see supplement for details. We show results in Fig. 5 (left), where we can estimate a diverse set of possible motion flows from monocular images. By smoothly interpolating $\\phi$ , we can generate short video sequences, even though our model only saw low-framerate video frames during training. We also train a deterministic baseline, which only generates a single motion field. Due to the amount of uncertainty in this problem, the deterministic estimate collapses to a near-zero motion field regardless of the input image, and thus, fails to learn any meaningful features from images. ",
+        "bbox": [
+            174,
+            488,
+            825,
+            613
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "4.3 GAN Inversion ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            635,
+            318,
+            650
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Projecting images onto the latent space of generative adversarial networks is a well-studied problem [8, 66], and enables interesting applications, as manipulating latents along known directions allows a user to effectively edit images [67–69]. Here, we solve the problem of projecting partial images: given a small visible patch in an image, our goal is to model the distribution of possible StyleGAN2 [8] latents that agree with the input patch. There are a diverse set of latents that can correspond to the input observation, and we train our method without observing supervised (image, latent) pairs. Instead, we train on pairs of $( \\mathbf { O } ^ { \\mathrm { c t x t } } , \\mathbf { O } ^ { \\mathrm { t r g t } } )$ observations, where $\\mathbf { O } ^ { \\mathrm { c t x t } }$ are the small patches in images, and ${ \\bf O } ^ { \\mathrm { t r g t } }$ are the full images. ",
+        "bbox": [
+            173,
+            662,
+            825,
+            773
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Related Work. While most GAN inversion methods focus on inverting a complete image into the generator’s latent space [70–78], some also reconstruct GAN latents from small patches via supervised training. Inversion is not trivial, and papers often rely on regularization [77] or integrate the inversion with editing tasks [79] for higher quality. We also integrate the inpainting task with the inversion, and seek to model the uncertainty of the GAN inversion task given only a partial observation (patch) of the target image. ",
+        "bbox": [
+            174,
+            779,
+            825,
+            863
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Structure of S and forward model synthesize. Our signal $\\mathbf { S } \\in \\mathbb { R } ^ { 5 1 2 }$ is a 512 dimensional latent code representing the “w” space of StyleGAN2 [8] trained on the FFHQ [80] dataset. The forward model synthesize ${ \\bf \\Phi } _ { : } ( { \\bf S } , \\phi ) \\bar { \\bf \\Phi } = { \\tt G A N } ( { \\bf S } ) \\bar { [ \\phi ] }$ first reconstructs the image corresponding to S using a forward pass of the GAN. It then extracts a patch using the forward model’s parameters $\\phi$ that encode the patch coordinates. ",
+        "bbox": [
+            176,
+            869,
+            823,
+            912
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            90,
+            821,
+            119
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Implementation of denoise, Loss, and Evaluation. Please see the inset figure for an illustration of the method. The denoising network receives $\\mathbf { O } ^ { \\mathrm { c t x t } }$ , $\\mathbf { O } _ { t } ^ { \\mathrm { t r g t } }$ , and timestep t as input, and generates an estimate of the StyleGAN latent w. The loss function is identical to Eq. 8 and compares the reconstructed sample with ground truth. ",
+        "bbox": [
+            174,
+            126,
+            617,
+            195
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "We show results in Fig. 5 (right). We obtain diverse samples that are all consistent with the input patch. We also compare with a deterministic baseline that minimizes the same loss but only produces a single estimate. While this deterministic estimate also agrees with the input image, it does not model the diversity of outputs. We consequently achieve significantly better FID [54] and KID [55] scores than the deterministic baseline, reported in Tab. 1 (right). ",
+        "bbox": [
+            174,
+            196,
+            826,
+            265
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "image",
+        "img_path": "images/b35beda113f899a1382d37d071b450b64e9a073c643e66f25ed012264c2cdc3b.jpg",
+        "image_caption": [],
+        "image_footnote": [],
+        "bbox": [
+            629,
+            117,
+            823,
+            191
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "5 Discussion ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            284,
+            292,
+            301
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Limitations. While our method makes significant advances in generative modeling, it still has several limitations. Sampling 3D scenes at test time can be very slow, due to the expensive nature of the denoising process and the cost of volume rendering. We need multi-view observations of training scenes for the inverse graphics application. Our models are not trained on very large-scale datasets, and can thus not generalize to out-of-distribution data. ",
+        "bbox": [
+            174,
+            315,
+            825,
+            386
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Conclusion We have introduced a new method that tightly integrates differentiable forward models and conditional diffusion models. Our model learns to sample from the distribution of signals trained only using their observations. We demonstrate the efficacy of our approach on three challenging computer vision problems. In inverse graphics, our method, in combination with a 3D-structured conditioning method, enables us to directly sample from the distribution of real-world 3D scenes consistent with a single image observation. We can then render multi-view consistent novel views while obtaining diverse samples of 3D geometry and appearance in unobserved regions of the scene. We further tackle single-image conditional motion synthesis, where we learn to sample from the distribution of 2D motion conditioned on a single image, as well as GAN inversion, where we learn to sample images that exist in the latent space of a GAN that are consistent with a given patch. With this work, we make contributions that broaden the applicability of state-of-the-art generative modeling to a large range of scientifically relevant applications, and hope to inspire future research in this direction. ",
+        "bbox": [
+            174,
+            392,
+            825,
+            570
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Acknowledgements. This work was supported by the National Science Foundation under Grant No. 2211259, by the Singapore DSTA under DST00OECI20300823 (New Representations for Vision), by the NSF award 1955864 (Occlusion and Directional Resolution in Computational Imaging), by the ONR MURI grant N00014-22-1-2740, and by the Amazon Science Hub. We are grateful for helpful conversations with members of the Scene Representation Group David Charatan, Cameron Smith, and Boyuan Chen. We thank Zhizhuo Zhou for thoughtful discussions about the SparseFusion baseline. This article solely reflects the opinions and conclusions of its authors and no other entity. ",
+        "bbox": [
+            173,
+            578,
+            825,
+            674
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Author contributions. Ayush and Vincent conceived the idea of diffusion with forward models, designed experiments, generated most figures, and wrote most of the paper. Ayush contributed the key insight to integrate differentiable rendering with diffusion models by denoising in image space while generating 3D scenes. Ayush and Vincent generalized this to general forward models, and conceived the single-image motion application. Vincent contributed the 3D-structured conditioning and generated the overview and methods figures. Ayush wrote all initial code and ran all initial experiments. Ayush and Tianwei implemented the inverse graphics application and generated most of the 3D results of our model, while George helped with the baseline 3D results. Ayush executed all single-image motion experiments. George conceived, implemented, and executed all GAN inversion experiments. Semon helped formalizing the method and wrote the proposition and its proof. Frédo and Bill were involved in regular meetings and gave valuable feedback on results and experiments. Josh provided intriguing cognitive science perspectives and feedback on results and experiments, and provided a significant part of the compute. Vincent’s Scene Representation Group provided a significant part of the compute, and the project profited from code infrastructure developed by and conversations with other members of the Scene Representation Group. ",
+        "bbox": [
+            174,
+            681,
+            825,
+            888
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "References   \n[1] Jascha Sohl-Dickstein, Eric Weiss, Niru Maheswaranathan, and Surya Ganguli. Deep unsupervised learning using nonequilibrium thermodynamics. In Proc. ICML, 2015. 2   \n[2] Norman Müller, , Yawar Siddiqui, Lorenzo Porzi, Samuel Rota Bulò, Peter Kontschieder, and Matthias Nießner. Diffrf: Rendering-guided 3d radiance field diffusion. Proc. CVPR, 2023. 2, 5, 6   \n[3] Seung Wook Kim, Bradley Brown, Kangxue Yin, Karsten Kreis, Katja Schwarz, Daiqing Li, Robin Rombach, Antonio Torralba, and Sanja Fidler. Neuralfield-ldm: Scene generation with hierarchical latent diffusion models. Proc. CVPR, 2023. 2, 6   \n[4] Eric R Chan, Koki Nagano, Matthew A Chan, Alexander W Bergman, Jeong Joon Park, Axel Levy, Miika Aittala, Shalini De Mello, Tero Karras, and Gordon Wetzstein. Generative novel view synthesis with 3d-aware diffusion models. arXiv preprint arXiv:2304.02602, 2023. 2, 6   \n[5] Zhizhuo Zhou and Shubham Tulsiani. Sparsefusion: Distilling view-conditioned diffusion for 3d reconstruction. Proc. CVPR, 2023. 2, 6, 7, 8, 9   \n[6] Ben Poole, Ajay Jain, Jonathan T. Barron, and Ben Mildenhall. Dreamfusion: Text-to-3d using 2d diffusion. Proc. ICLR, 2023. 2, 6   \n[7] Titas Anciukevicius, Zexiang Xu, Matthew Fisher, Paul Henderson, Hakan Bilen, Niloy J Mitra, and Paul ˇ Guerrero. Renderdiffusion: Image diffusion for 3d reconstruction, inpainting and generation. Proc. CVPR, 2023. 2, 5, 6   \n[8] Tero Karras, Samuli Laine, Miika Aittala, Janne Hellsten, Jaakko Lehtinen, and Timo Aila. Analyzing and improving the image quality of stylegan. In Proc. CVPR, 2020. 2, 9   \n[9] Alex Yu, Vickie Ye, Matthew Tancik, and Angjoo Kanazawa. pixelnerf: Neural radiance fields from one or few images. In Proc. CVPR, 2021. 5, 6, 7, 8, 9   \n[10] Diederik P Kingma and Max Welling. Auto-encoding variational bayes. Proc. ICLR, 2014. 5   \n[11] Danilo Jimenez Rezende, Shakir Mohamed, and Daan Wierstra. Stochastic backpropagation and approximate inference in deep generative models. In Proc. ICML, 2014. 5   \n[12] Danilo Rezende and Shakir Mohamed. Variational inference with normalizing flows. In Proc. ICML, 2015. 5   \n[13] Marta Garnelo, Dan Rosenbaum, Christopher Maddison, Tiago Ramalho, David Saxton, Murray Shanahan, Yee Whye Teh, Danilo Rezende, and SM Ali Eslami. Conditional neural processes. In Proc. ICML, 2018. 5   \n[14] Hyunjik Kim, Andriy Mnih, Jonathan Schwarz, Marta Garnelo, Ali Eslami, Dan Rosenbaum, Oriol Vinyals, and Yee Whye Teh. Attentive neural processes. Proc. ICLR, 2019. 5   \n[15] Adam R Kosiorek, Heiko Strathmann, Daniel Zoran, Pol Moreno, Rosalia Schneider, Sona Mokrá, and Danilo Jimenez Rezende. Nerf-vae: A geometry aware 3d scene generative model. In Proc. ICML, 2021. 5   \n[16] Pol Moreno, Adam R Kosiorek, Heiko Strathmann, Daniel Zoran, Rosalia G Schneider, Björn Winckler, Larisa Markeeva, Théophane Weber, and Danilo J Rezende. Laser: Latent set representations for 3d generative modeling. arXiv preprint arXiv:2301.05747, 2023. 5   \n[17] Eric R Chan, Marco Monteiro, Petr Kellnhofer, Jiajun Wu, and Gordon Wetzstein. pi-gan: Periodic implicit generative adversarial networks for 3d-aware image synthesis. In Proc. CVPR, 2021. 5   \n[18] Jun Gao, Tianchang Shen, Zian Wang, Wenzheng Chen, Kangxue Yin, Daiqing Li, Or Litany, Zan Gojcic, and Sanja Fidler. Get3d: A generative model of high quality 3d textured shapes learned from images. Proc. NeurIPS, 2022. 5   \n[19] Terrance DeVries, Miguel Angel Bautista, Nitish Srivastava, Graham W Taylor, and Joshua M Susskind. Unconstrained scene generation with locally conditioned radiance fields. In Proc. ICCV, 2021. 5   \n[20] Animesh Karnewar, Andrea Vedaldi, David Novotny, and Niloy Mitra. Holodiffusion: Training a 3d diffusion model using 2d images. Proc. CVPR, 2023. 5, 6   \n[21] Hyungjin Chung, Jeongsol Kim, Michael Thompson Mccann, Marc Louis Klasky, and Jong Chul Ye. Diffusion posterior sampling for general noisy inverse problems. In Proc. ICLR, 2023. 5 [22] Jooyoung Choi, Sungwon Kim, Yonghyun Jeong, Youngjune Gwon, and Sungroh Yoon. Ilvr: Conditioning method for denoising diffusion probabilistic models. Proc. ICCV, 2021. 5 [23] Bahjat Kawar, Michael Elad, Stefano Ermon, and Jiaming Song. Denoising diffusion restoration models. In Proc. NeurIPS, 2022. 5 [24] Jiaming Song, Arash Vahdat, Morteza Mardani, and Jan Kautz. Pseudoinverse-guided diffusion models for inverse problems. In Proc. ICLR, 2023. 5 [25] Zahra Kadkhodaie and Eero Simoncelli. Stochastic solutions for linear inverse problems using the prior implicit in a denoiser. Advances in Neural Information Processing Systems, 34:13242–13254, 2021. 5 [26] Yang Song, Jascha Sohl-Dickstein, Diederik P Kingma, Abhishek Kumar, Stefano Ermon, and Ben Poole. Score-based generative modeling through stochastic differential equations. In Proc. ICLR, 2021. 5 [27] Yang Song, Liyue Shen, Lei Xing, and Stefano Ermon. Solving inverse problems in medical imaging with score-based generative models. Proc. ICLR, 2022. 5 [28] Johnathan M Bardsley. Mcmc-based image reconstruction with uncertainty quantification. SIAM Journal on Scientific Computing, 34(3):A1316–A1332, 2012. 5 [29] Singanallur Venkatakrishnan, Charles A. Bouman, and Brendt Wohlberg. Plug-and-play priors for model based reconstruction. 2013 IEEE Global Conference on Signal and Information Processing, pages 945–948,   \n2013. 5 [30] Yaniv Romano, Michael Elad, and Peyman Milanfar. The little engine that could: Regularization by denoising (red). SIAM Journal on Imaging Sciences, 10(4):1804–1844, 2017. 5 [31] Vincent Sitzmann, Michael Zollhöfer, and Gordon Wetzstein. Scene representation networks: Continuous   \n3d-structure-aware neural scene representations. Proc. NeurIPS, 2019. 6 [32] Michael Niemeyer, Lars Mescheder, Michael Oechsle, and Andreas Geiger. Differentiable volumetric rendering: Learning implicit 3d representations without 3d supervision. In Proc. CVPR, 2020. 6 [33] Philipp Henzler, Jeremy Reizenstein, Patrick Labatut, Roman Shapovalov, Tobias Ritschel, Andrea Vedaldi, and David Novotny. Unsupervised learning of 3d object categories from videos in the wild. In Proc. CVPR,   \n2021. 6 [34] Prafull Sharma, Ayush Tewari, Yilun Du, Sergey Zakharov, Rares Andrei Ambrus, Adrien Gaidon, William T Freeman, Fredo Durand, Joshua B Tenenbaum, and Vincent Sitzmann. Neural groundplans: Persistent neural scene representations from a single image. In Proc. ICLR. 6 [35] Anpei Chen, Zexiang Xu, Fuqiang Zhao, Xiaoshuai Zhang, Fanbo Xiang, Jingyi Yu, and Hao Su. Mvsnerf: Fast generalizable radiance field reconstruction from multi-view stereo. In Proc. ICCV, 2021. 6 [36] Yilun Du, Cameron Smith, Ayush Tewari, and Vincent Sitzmann. Learning to render novel views from wide-baseline stereo pairs. In Proc. CVPR, 2023. 6 [37] Alex Trevithick and Bo Yang. Grf: Learning a general radiance field for 3d representation and rendering. In Proc. ICCV, 2021. 6 [38] Mohammed Suhail, Carlos Esteves, Leonid Sigal, and Ameesh Makadia. Generalizable patch-based neural rendering. In Proc. ECCV, 2022. 6 [39] Julian Chibane, Aayush Bansal, Verica Lazova, and Gerard Pons-Moll. Stereo radiance fields (srf): Learning view synthesis for sparse views of novel scenes. In Proc. CVPR, 2021. 6 [40] Qianqian Wang, Zhicheng Wang, Kyle Genova, Pratul P Srinivasan, Howard Zhou, Jonathan T Barron, Ricardo Martin-Brualla, Noah Snavely, and Thomas Funkhouser. Ibrnet: Learning multi-view image-based rendering. In Proc. CVPR, 2021. 6 [41] Shamit Lal, Mihir Prabhudesai, Ishita Mediratta, Adam W Harley, and Katerina Fragkiadaki. Coconets: Continuous contrastive 3d scene representations. In Proc. CVPR, 2021. 6 [42] Daniel Watson, William Chan, Ricardo Martin-Brualla, Jonathan Ho, Andrea Tagliasacchi, and Mohammad Norouzi. Novel view synthesis with diffusion models. Proc. ICLR, 2023. 6 [43] SM Ali Eslami, Danilo Jimenez Rezende, Frederic Besse, Fabio Viola, Ari S Morcos, Marta Garnelo, Avraham Ruderman, Andrei A Rusu, Ivo Danihelka, Karol Gregor, et al. Neural scene representation and rendering. Science, 360(6394):1204–1210, 2018. 6   \n[44] Hung-Yu Tseng, Qinbo Li, Changil Kim, Suhib Alsisan, Jia-Bin Huang, and Johannes Kopf. Consistent view synthesis with pose-guided diffusion models. arXiv preprint arXiv:2303.17598, 2023. 6   \n[45] Jiatao Gu, Qingzhe Gao, Shuangfei Zhai, Baoquan Chen, Lingjie Liu, and Josh Susskind. Learning controllable 3d diffusion models from single-view images. arXiv preprint arXiv:2304.06700, 2023. 6   \n[46] Luke Melas-Kyriazi, Christian Rupprecht, Iro Laina, and Andrea Vedaldi. Realfusion: 360 {\\deg} reconstruction of any object from a single image. Proc. CVPR, 2023. 6   \n[47] Lukas Höllein, Ang Cao, Andrew Owens, Justin Johnson, and Matthias Nießner. Text2room: Extracting textured 3d meshes from 2d text-to-image models. arXiv preprint arXiv:2303.11989, 2023. 6   \n[48] Rafail Fridman, Amit Abecasis, Yoni Kasten, and Tali Dekel. Scenescape: Text-driven consistent scene generation. arXiv preprint arXiv:2302.01133, 2023. 6   \n[49] Ben Mildenhall, Pratul P. Srinivasan, Matthew Tancik, Jonathan T. Barron, Ravi Ramamoorthi, and Ren Ng. Nerf: Representing scenes as neural radiance fields for view synthesis. In Proc. ECCV, 2020. 6, 7   \n[50] Jeremy Reizenstein, Roman Shapovalov, Philipp Henzler, Luca Sbordone, Patrick Labatut, and David Novotny. Common objects in 3d: Large-scale learning and evaluation of real-life 3d category reconstruction. In Proc. ICCV, 2021. 8   \n[51] Tinghui Zhou, Richard Tucker, John Flynn, Graham Fyffe, and Noah Snavely. Stereo magnification: Learning view synthesis using multiplane images. ACM Trans. Graph. (Proc. SIGGRAPH), 37, 2018. 8   \n[52] Yi Ding, Alex Rich, Mason Wang, Noah Stier, Matthew Turk, Pradeep Sen, and Tobias Höllerer. Sparse fusion for multimodal transformers. arXiv preprint arXiv:2111.11992, 2021. 8   \n[53] Richard Zhang, Phillip Isola, Alexei A Efros, Eli Shechtman, and Oliver Wang. The unreasonable effectiveness of deep features as a perceptual metric. In Proc. CVPR, 2018. 8   \n[54] Martin Heusel, Hubert Ramsauer, Thomas Unterthiner, Bernhard Nessler, and Sepp Hochreiter. Gans trained by a two time-scale update rule converge to a local nash equilibrium. Proc. NeurIPS, 2017. 8, 10   \n[55] Mikołaj Binkowski, Danica J Sutherland, Michael Arbel, and Arthur Gretton. Demystifying mmd gans. ´ arXiv preprint arXiv:1801.01401, 2018. 8, 10   \n[56] Tianfan Xue, Baian Chen, Jiajun Wu, Donglai Wei, and William T Freeman. Video enhancement with task-oriented flow. International Journal of Computer Vision, 127:1106–1125, 2019. 8   \n[57] Ruohan Gao, Bo Xiong, and Kristen Grauman. Im2flow: Motion hallucination from static images for action recognition. In Proc. CVPR, 2018. 9   \n[58] Jacob Walker, Abhinav Gupta, and Martial Hebert. Dense optical flow prediction from a static image. In Proc. ICCV, 2015. 9   \n[59] Silvia L Pintea, Jan C van Gemert, and Arnold WM Smeulders. Déja vu: Motion prediction in static images. In Proc. ECCV, 2014. 9   \n[60] Jacob Walker, Carl Doersch, Abhinav Gupta, and Martial Hebert. An uncertain future: Forecasting from static images using variational autoencoders. In Proc. ECCV. Springer, 2016. 9   \n[61] Yijun Li, Chen Fang, Jimei Yang, Zhaowen Wang, Xin Lu, and Ming-Hsuan Yang. Flow-grounded spatial-temporal video prediction from still images. In Proc. ICCV, 2018. 9   \n[62] Jacob Walker, Kenneth Marino, Abhinav Gupta, and Martial Hebert. The pose knows: Video forecasting by generating pose futures. In Proc. ICCV, 2017. 9   \n[63] Angjoo Kanazawa, Shubham Tulsiani, Alexei A Efros, and Jitendra Malik. Learning category-specific mesh reconstruction from image collections. In Proc. ECCV, 2018. 9   \n[64] Subhabrata Choudhury, Laurynas Karazija, Iro Laina, Andrea Vedaldi, and Christian Rupprecht. Guess what moves: unsupervised video and image segmentation by anticipating motion. arXiv preprint arXiv:2205.07844, 2022. 9   \n[65] Simon Niklaus and Feng Liu. Softmax splatting for video frame interpolation. In Proc. CVPR, 2020. 9   \n[66] Jun-Yan Zhu, Philipp Krähenbühl, Eli Shechtman, and Alexei A. Efros. Generative visual manipulation on the natural image manifold. In Proc. ECCV, 2016. 9   \n[67] Erik Härkönen, Aaron Hertzmann, Jaakko Lehtinen, and Sylvain Paris. Ganspace: Discovering interpretable gan controls. Proc. NeurIPS, 2020. 9   \n[68] Ayush Tewari, Mohamed Elgharib, Gaurav Bharaj, Florian Bernard, Hans-Peter Seidel, Patrick Pérez, Michael Zollhofer, and Christian Theobalt. Stylerig: Rigging stylegan for 3d control over portrait images. In Proc. CVPR, 2020. 9   \n[69] Yujun Shen, Ceyuan Yang, Xiaoou Tang, and Bolei Zhou. Interfacegan: Interpreting the disentangled face representation learned by gans. IEEE transactions on pattern analysis and machine intelligence, 44(4):2004–2018, 2020. 9   \n[70] Rameen Abdal, Yipeng Qin, and Peter Wonka. Image2stylegan: How to embed images into the stylegan latent space? In Proc. ICCV, 2019. 9   \n[71] Rameen Abdal, Yipeng Qin, and Peter Wonka. Image2stylegan $^ { + + }$ : How to edit the embedded images? In Proc. CVPR, 2020. 9   \n[72] David Bau, Hendrik Strobelt, William Peebles, Jonas Wulff, Bolei Zhou, Jun-Yan Zhu, and Antonio Torralba. Semantic photo manipulation with a generative image prior. arXiv preprint arXiv:2005.07727, 2020. 9   \n[73] Yuval Alaluf, Or Patashnik, and Daniel Cohen-Or. Restyle: A residual-based stylegan encoder via iterative refinement. In Proc. ICCV, 2021. 9   \n[74] Shanyan Guan, Ying Tai, Bingbing Ni, Feida Zhu, Feiyue Huang, and Xiaokang Yang. Collaborative learning for faster stylegan embedding. arXiv preprint arXiv:2007.01758, 2020. 9   \n[75] Stanislav Pidhorskyi, Donald A Adjeroh, and Gianfranco Doretto. Adversarial latent autoencoders. In Proc. CVPR, 2020. 9   \n[76] Elad Richardson, Yuval Alaluf, Or Patashnik, Yotam Nitzan, Yaniv Azar, Stav Shapiro, and Daniel Cohen-Or. Encoding in style: a stylegan encoder for image-to-image translation. In Proc. CVPR, 2021. 9   \n[77] Omer Tov, Yuval Alaluf, Yotam Nitzan, Or Patashnik, and Daniel Cohen-Or. Designing an encoder for stylegan image manipulation. ACM Transactions on Graphics (TOG), 40(4):1–14, 2021. 9   \n[78] Tengfei Wang, Yong Zhang, Yanbo Fan, Jue Wang, and Qifeng Chen. High-fidelity gan inversion for image attribute editing. In Proc. CVPR, 2022. 9   \n[79] Ayush Tewari, Mohamed Elgharib, Florian Bernard, Hans-Peter Seidel, Patrick Pérez, Michael Zollhöfer, and Christian Theobalt. Pie: Portrait image embedding for semantic control. ACM Transactions on Graphics (TOG), 39(6):1–14, 2020. 9   \n[80] Tero Karras, Samuli Laine, and Timo Aila. A style-based generator architecture for generative adversarial networks. In Proc. CVPR, 2019. 9 ",
+        "bbox": [
+            173,
+            82,
+            828,
+            919
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            55,
+            828,
+            914
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            171,
+            61,
+            828,
+            916
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            171,
+            87,
+            828,
+            633
+        ],
+        "page_idx": 13
+    }
+]

parse/dev/puMfaHb1hY/puMfaHb1hY.md

@@ -0,0 +1,346 @@
+# G-EVAL: NLG Evaluation using GPT-4 with Better Human Alignment
+
+Yang Liu Dan Iter Yichong Xu Shuohang Wang Ruochen Xu Chenguang Zhu
+
+Microsoft Azure AI yaliu10@microsoft.com
+
+# Abstract
+
+The quality of texts generated by natural language generation (NLG) systems is hard to measure automatically. Conventional referencebased metrics, such as BLEU and ROUGE, have been shown to have relatively low correlation with human judgments, especially for tasks that require creativity and diversity. Recent studies suggest using large language models (LLMs) as reference-free metrics for NLG evaluation, which have the benefit of being applicable to new tasks that lack human references. However, these LLM-based evaluators still have lower human correspondence than medium-size neural evaluators. In this work, we present G-EVAL, a framework of using large language models with chain-of-thoughts (CoT) and a form-filling paradigm, to assess the quality of NLG outputs. We experiment with two generation tasks, text summarization and dialogue generation. We show that G-EVAL with GPT-4 as the backbone model achieves a Spearman correlation of 0.514 with human on summarization task, outperforming all previous methods by a large margin. We also propose analysis on the behavior of LLM-based evaluators, and highlight the potential concern of LLM-based evaluators having a bias towards the LLM-generated texts.
+
+Moreover, these metrics require associated reference output, which is costly to collect for new tasks.
+
+Recent studies propose directly using LLMs as reference-free NLG evaluators (Fu et al., 2023; Wang et al., 2023a). The idea is to use the LLMs to score the candidate output based on its generation probability without any reference target, under the assumption that the LLMs have learned to assign higher probabilities to high-quality and fluent texts. Meanwhile, it is becoming popular to use more powerful LLMs like GPT-4 to evaluate smaller or student models, like in Alpaca (Taori et al., 2023) and Vicuna (Zheng et al., 2023). However, the validity and reliability of using LLMs as NLG evaluators have not been systematically investigated. In addition, meta-evaluations show that these LLMbased evaluators still have lower human correspondence than medium-size neural evaluators (Zhong et al., 2022). Thus, there is a need for a more effective and reliable framework for using LLMs for NLG evaluation.
+
+# 1 Introduction
+
+Evaluating the quality of natural language generation systems is a challenging problem even when large language models can generate high-quality and diverse texts that are often indistinguishable from human-written texts (Ouyang et al., 2022). Traditional automatic metrics, such as BLEU (Papineni et al., 2002), ROUGE (Lin, 2004), and METEOR (Banerjee and Lavie, 2005), are widely used for NLG evaluation, but they have been shown to have relatively low correlation with human judgments, especially for open-ended generation tasks.
+
+In this paper, we propose G-EVAL, a framework of using LLMs with chain-of-thoughts (CoT) (Wei et al., 2022) to evaluate the quality of generated texts in a form-filling paradigm. By only feeding the Task Introduction and the Evaluation Criteria as a prompt, we ask LLMs to generate a CoT of detailed Evaluation Steps. Then we use the prompt along with the generated CoT to evaluate the NLG outputs. The evaluator output is formatted as a form. Moreover, the probabilities of the output rating tokens can be used to refine the final metric. We conduct extensive experiments on three meta-evaluation benchmarks of two NLG tasks: text summarization and dialogue generation. The results show that G-EVAL can outperform existing NLG evaluators by a large margin in terms of correlation with human evaluations. Finally, we conduct analysis on the behavior of LLM-based evaluators, and highlight the potential issue of LLM-based evaluator having a bias towards the LLM-generated
+
+texts.
+
+To summarize, our main contributions and findings in this paper are:
+
+1. G-EVAL generally outperforms referencebased and reference-free baseline metrics in terms of correlation with human quality judgments, especially for open-ended and creative NLG tasks, such as dialogue response generation.
+
+2. We propose to use automatic chain-of-thought to improve the performance of LLM-based evaluators by providing more context and guidance.
+
+3. We propose to re-weight the discrete scores by their respective token probabilities to provide a more fine-grained continuous score for GEVAL.
+
+4. We conduct an analysis of the potential issue that LLM-based metrics have a preference of LLM-generated texts over humanwritten texts, which may lead to the selfreinforcement of LLMs if LLM-based metrics are used as the reward signal for improving themselves.
+
+# 2 Method
+
+G-EVAL is a prompt-based evaluator with three main components: 1) a prompt that contains the definition of the evaluation task and the desired evaluation criteria, 2) a chain-of-thoughts (CoT) that is a set of intermediate instructions generated by the LLM describing the detailed evaluation steps, and 3) a scoring function that calls LLM and calculates the score based on the probabilities of the return tokens.
+
+Prompt for NLG Evaluation The prompt is a natural language instruction that defines the evaluation task and the desired evaluation criteria. For example, for text summarization, the prompt can be:
+
+You will be given one summary written for a news article. Your task is to rate the summary on one metric.
+
+Please make sure you read and understand these instructions carefully. Please keep this document open while reviewing, and refer to it as needed.
+
+The prompt should also contain customized evaluation criteria for different NLG tasks and, such as coherence, conciseness, or grammar. For example, for evaluating coherence in text summarization, we add the following content to the prompt:
+
+# Evaluation Criteria:
+
+Coherence (1-5) - the collective quality of all sentences. We align this dimension with the DUC quality question of structure and coherence whereby "the summary should be well-structured and well-organized. The summary should not just be a heap of related information, but should build from sentence to sentence to a coherent body of information about a topic."
+
+# Auto Chain-of-Thoughts for NLG Evaluation
+
+The chain-of-thoughts (CoT) is a sequence of intermediate representations that are generated by the LLM during the text generation process. For evaluation tasks, some criteria need a more detailed evaluation instruction beyond the simple definition, and it is time-consuming to manually design such evaluation steps for each task. We find that LLM can generate such evaluation steps by itself. The CoT can provide more context and guidance for the LLM to evaluate the generated text, and can also help to explain the evaluation process and results. For example, for evaluating coherence in text summarization, we add a line of “Evaluation Steps:" to the prompt and let LLM to generate the following CoT automatically:
+
+1. Read the news article carefully and identify the main topic and key points.
+
+2. Read the summary and compare it to the news article. Check if the summary covers the main topic and key points of the news article, and if it presents them in a clear and logical order.
+
+3. Assign a score for coherence on a scale of 1 to 5, where 1 is the lowest and 5 is the highest based on the Evaluation Criteria.
+
+Scoring Function The scoring function calls the LLM with the designed prompt, auto CoT, the input context and the target text that needs to be evaluated. Unlike GPTScore (Fu et al., 2023) which uses the conditional probability of generating the target text as an evaluation metric, G-EVAL directly performs the evaluation task with a form-filling paradigm. This provides a more flexible way to evaluate the text as the model can behave directly based on the evaluation criteria and steps. For example, for evaluating coherence in text summarization, we concatenate the prompt, the CoT, the news article, and the summary, and then call the LLM to output a score from 1 to 5 for each evaluation aspect, based on the defined criteria.
+
+![](images/1f5c6f4472af2ebba638b602393c7f721b474eedddf16198e530d0830bdc7a61.jpg)  
+Figure 1: The overall framework of G-EVAL. We first input Task Introduction and Evaluation Criteria to the LLM, and ask it to generate a CoT of detailed Evaluation Steps. Then we use the prompt along with the generated CoT to evaluate the NLG outputs in a form-filling paradigm. Finally, we use the probability-weighted summation of the output scores as the final score.
+
+However, we notice this direct scoring function has two issues:
+
+1. For some evaluation tasks, one digit usually dominates the distribution of the scores, such as 3 for a 1 - 5 scale. This may lead to the low variance of the scores and the low correlation with human judgments.
+
+2. LLMs usually only output integer scores, even when the prompt explicitly requests decimal values. This leads to many ties in evaluation scores which do not capture the subtle difference between generated texts.
+
+To address these issues, we propose using the probabilities of output tokens from LLMs to normalize the scores and take their weighted summation as the final results. Formally, given a set of scores (like from 1 to 5) predefined in the prompt ${ \cal S } = \{ s _ { 1 } , s _ { 2 } , . . . , s _ { n } \}$ , the probability of each score $p ( s _ { i } )$ is calculated by the LLM, and the final score is:
+
+$$
+s c o r e = \sum _ { i = 1 } ^ { n } p ( s _ { i } ) \times s _ { i }
+$$
+
+This method obtains more fine-grained, continuous scores that better reflect the quality and diversity of the generated texts.
+
+# 3 Experiments
+
+Following Zhong et al. (2022), we meta-evaluate our evaluator on three benchmarks, SummEval, Topical-Chat and QAGS, of two NLG tasks, summarization and dialogue response generation.
+
+# 3.1 Implementation Details
+
+We use OpenAI’s GPT family as our LLMs, including GPT-3.5 (text-davinci-003) and GPT-4. For GPT-3.5, we set decoding temperature to 0 to increase the model’s determinism. For GPT-4, as it does not support the output of token probabilities, we set $= 2 0 , t e m p e r a t u r e = 1 , t o p \_ p = 1 ^ { \prime }$ to sample 20 times to estimate the token probabilities. We use G-EVAL-4 to indicate G-EVAL with GPT-4 as the backbone model, and G-EVAL-3.5 to indicate G-EVAL with GPT-3.5 as the backbone model. Example prompts for each task are provided in the Appendix.
+
+Table 1: Summary-level Spearman $( \rho )$ and Kendall-Tau $( \tau )$ correlations of different metrics on SummEval benchmark. G-EVAL without probabilities (italicized) should not be considered as a fair comparison to other metrics on $\tau$ , as it leads to many ties in the scores. This results in a higher Kendall-Tau correlation, but it does not fairly reflect the true evaluation ability. More details are in Section 4.   
+
+<table><tr><td rowspan="2">Metrics</td><td colspan="2">Coherence</td><td colspan="2">Consistency</td><td colspan="2">Fluency</td><td colspan="2">Relevance</td><td colspan="2">AVG</td></tr><tr><td>p</td><td>T</td><td>p</td><td>T</td><td>p T</td><td>p</td><td>T</td><td></td><td>p</td><td>T</td></tr><tr><td>ROUGE-1</td><td>0.167</td><td>0.126</td><td>0.160</td><td>0.130</td><td>0.115</td><td>0.094</td><td>0.326</td><td>0.252</td><td>0.192</td><td>0.150</td></tr><tr><td>ROUGE-2</td><td>0.184</td><td>0.139</td><td>0.187</td><td>0.155</td><td>0.159</td><td>0.128</td><td>0.290</td><td>0.219</td><td>0.205</td><td>0.161</td></tr><tr><td>ROUGE-L</td><td>0.128</td><td>0.099</td><td>0.115</td><td>0.092</td><td>0.105</td><td>0.084</td><td>0.311</td><td>0.237</td><td>0.165</td><td>0.128</td></tr><tr><td>BERTScore</td><td>0.284</td><td>0.211</td><td>0.110</td><td>0.090</td><td>0.193</td><td>0.158</td><td>0.312</td><td>0.243</td><td>0.225</td><td>0.175</td></tr><tr><td>MOVERSscore</td><td>0.159</td><td>0.118</td><td>0.157</td><td>0.127</td><td>0.129</td><td>0.105</td><td>0.318</td><td>0.244</td><td>0.191</td><td>0.148</td></tr><tr><td>BARTScore</td><td>0.448</td><td>0.342</td><td>0.382</td><td>0.315</td><td>0.356</td><td>0.292</td><td>0.356</td><td>0.273</td><td>0.385</td><td>0.305</td></tr><tr><td>UniEval</td><td>0.575</td><td>0.442</td><td>0.446</td><td>0.371</td><td>0.449</td><td>0.371</td><td>0.426</td><td>0.325</td><td>0.474</td><td>0.377</td></tr><tr><td>GPTScore</td><td>0.434</td><td>1</td><td>0.449</td><td>1</td><td>0.403</td><td>1</td><td>0.381</td><td>1</td><td>0.417</td><td>1</td></tr><tr><td>G-EVAL-3.5</td><td>0.440</td><td>0.335</td><td>0.386</td><td>0.318</td><td>0.424</td><td>0.347</td><td>0.385</td><td>0.293</td><td>0.401</td><td>0.320</td></tr><tr><td>- Probs</td><td>0.359</td><td>0.313</td><td>0.361</td><td>0.344</td><td>0.339</td><td>0.323</td><td>0.327</td><td>0.288</td><td>0.346</td><td>0.317</td></tr><tr><td>G-EVAL-4</td><td>0.582</td><td>0.457</td><td>0.507</td><td>0.425</td><td>0.506</td><td>0.455</td><td>0.547</td><td>0.433</td><td>0.514</td><td>0.418</td></tr><tr><td>- Probs</td><td>0.560</td><td>0.472</td><td>0.501</td><td>0.459</td><td>0.505</td><td>0.473</td><td>0.511</td><td>0.444</td><td>0.502</td><td>0.446</td></tr><tr><td>-CoT</td><td>0.564</td><td>0.454</td><td>0.493</td><td>0.413</td><td>0.483</td><td>0.431</td><td>0.538</td><td>0.427</td><td>0.500</td><td>0.407</td></tr><tr><td> - Description</td><td>0.513</td><td>0.424</td><td>0.421</td><td>0.344</td><td>0.447</td><td>0.373</td><td>0.479</td><td>0.388</td><td>0.479</td><td>0.377</td></tr></table>
+
+# 3.2 Benchmarks
+
+We adopt three meta-evaluation benchmarks to measure the correlation between G-EVAL and human judgments.
+
+SummEval (Fabbri et al., 2021) is a benchmark that compares different evaluation methods for summarization. It gives human ratings for four aspects of each summary: fluency, coherence, consistency and relevance. It is built on the CNN/DailyMail dataset (Hermann et al., 2015)
+
+Topical-Chat (Mehri and Eskenazi, 2020) is a testbed for meta-evaluating different evaluators on dialogue response generation systems that use knowledge. We follow (Zhong et al., 2022) to use its human ratings on four aspects: naturalness, coherence, engagingness and groundedness.
+
+QAGS (Wang et al., 2020) is a benchmark for evaluating hallucinations in the summarization task. It aims to measure the consistency dimension of summaries by asking and answering questions. It is collected from two different news summarization datasets CNN/DailyMail and XSum.
+
+# 3.3 Baselines
+
+We evaluate G-EVAL against various evaluators that achieved state-of-the-art performance.
+
+BERTScore (Zhang et al., 2019) measures the similarity between two texts based on the contextualized embedding from BERT (Devlin et al., 2019).
+
+MoverScore (Zhao et al., 2019) improves BERTScore by adding soft alignments and new aggregation methods to obtain a more robust similarity measure.
+
+BARTScore (Yuan et al., 2021) is a unified evaluator which evaluate with the average likelihood of the pretrained encoder-decoder model, BART (Lewis et al., 2020). It can predict different scores depending on the formats of source and target.
+
+FactCC and QAGS (Krysci ´ nski et al. ´ , 2020; Wang et al., 2020) are two evaluators that measure the factual consistency of generated summaries. FactCC is a BERT-based classifier that predicts whether a summary is consistent with the source document. QAGS is a question-answering based evaluator that generates questions from the summary and checks if the answers can be found in the source document.
+
+<table><tr><td rowspan="2">Metrics</td><td colspan="2">Naturalness</td><td colspan="2">Coherence</td><td colspan="2">Engagingness</td><td colspan="2">Groundedness</td><td colspan="2">AVG</td></tr><tr><td>r</td><td>p</td><td>r</td><td>p</td><td>r</td><td>p</td><td>r</td><td>p</td><td>r</td><td>p</td></tr><tr><td>ROUGE-L</td><td>0.176</td><td>0.146</td><td>0.193</td><td>0.203</td><td>0.295</td><td>0.300</td><td>0.310</td><td>0.327</td><td>0.243</td><td>0.244</td></tr><tr><td>BLEU-4</td><td>0.180</td><td>0.175</td><td>0.131</td><td>0.235</td><td>0.232</td><td>0.316</td><td>0.213</td><td>0.310</td><td>0.189</td><td>0.259</td></tr><tr><td>METEOR</td><td>0.212</td><td>0.191</td><td>0.250</td><td>0.302</td><td>0.367</td><td>0.439</td><td>0.333</td><td>0.391</td><td>0.290</td><td>0.331</td></tr><tr><td>BERTScore</td><td>0.226</td><td>0.209</td><td>0.214</td><td>0.233</td><td>0.317</td><td>0.335</td><td>0.291</td><td>0.317</td><td>0.262</td><td>0.273</td></tr><tr><td>USR</td><td>0.337</td><td>0.325</td><td>0.416</td><td>0.377</td><td>0.456</td><td>0.465</td><td>0.222</td><td>0.447</td><td>0.358</td><td>0.403</td></tr><tr><td>UniEval</td><td>0.455</td><td>0.330</td><td>0.602</td><td>0.455</td><td>0.573</td><td>0.430</td><td>0.577</td><td>0.453</td><td>0.552</td><td>0.417</td></tr><tr><td>G-EVAL-3.5</td><td>0.532</td><td>0.539</td><td>0.519</td><td>0.544</td><td>0.660</td><td>0.691</td><td>0.586</td><td>0.567</td><td>0.574</td><td>0.585</td></tr><tr><td>G-EVAL-4</td><td>0.549</td><td>0.565</td><td>0.594</td><td>0.605</td><td>0.627</td><td>0.631</td><td>0.531</td><td>0.551</td><td>0.575</td><td>0.588</td></tr></table>
+
+Table 2: Turn-level Spearman $( \rho )$ and Kendall-Tau $( \tau )$ correlations of different metrics on Topical-Chat benchmark.
+
+USR (Mehri and Eskenazi, 2020) is evaluator that assesses dialogue response generation from different perspectives. It has several versions that assign different scores to each target response.
+
+UniEval (Zhong et al., 2022) is a unified evaluator that can evaluate different aspects of text generation as QA tasks. It uses a pretrained T5 model (Raffel et al., 2020) to encode the evaluation task, source and target texts as questions and answers, and then computes the QA score as the evaluation score. It can also handle different evaluation tasks by changing the question format.
+
+GPTScore (Fu et al., 2023) is a new framework that evaluates texts with generative pre-training models like GPT-3. It assumes that a generative pre-training model will assign a higher probability of high-quality generated text following a given instruction and context. Unlike G-EVAL, GPTScore formulates the evaluation task as a conditional generation problem instead of a form-filling problem. We report the score of GPTScore with GPT3-textdavinci-003 as the LLM, which is also usually referred as GPT-3.5.
+
+# 3.4 Results for Summarization
+
+We adopt the same approach as Zhong et al. (2022) to evaluate different summarization metrics using summary-level Spearman and Kendall-Tau correlation. The first part of Table 1 shows the results of metrics that compare the semantic similarity between the model output and the reference text. These metrics perform poorly on most dimensions. The second part shows the results of metrics that use neural networks to learn from human ratings of summary quality. These metrics have much higher correlations than the similarity-based metrics, suggesting that they are more reliable for summarization evaluation.
+
+In the last part of Table 1 which corresponds to GPT-based evaluators, GPTScore also uses GPTs for evaluating summarization texts, but relies on GPT’s conditional probabilities of the given target. G-EVAL substantially surpasses all previous state-of-the-art evaluators on the SummEval benchmark. G-EVAL-4 achieved much higher human correspondence compared with G-EVAL-3.5 on both Spearman and Kendall-Tau correlation, which indicates that the larger model size of GPT-4 is beneficial for summarization evaluation. G-EVAL also outperforms GPTScore on several dimension, demonstrating the effectiveness of the simple formfilling paradigm.
+
+# 3.5 Results for Dialogue Generation
+
+We use the Topical-chat benchmark from Mehri and Eskenazi (2020) to measure how well different evaluators agree with human ratings on the quality of dialogue responses. We calculate the Pearson and Spearman correlation for each turn of the dialogue. Table 2 shows that similarity-based metrics have good agreement with humans on how engaging and grounded the responses are, but not on the other aspects. With respect to the learningbased evaluators, before G-EVAL, UniEval predicts scores that are most consistent with human judgments across all aspects.
+
+As shown in the last part, G-EVAL also substantially surpasses all previous state-of-the-art evaluator on the Topical-Chat benchmark. Notably, the G-EVAL-3.5 can achieve similar results with G-EVAL-4. This indicates that this benchmark is relatively easy for the G-EVAL model.
+
+# 3.6 Results on Hallucinations
+
+Advanced NLG models often produce text that does not match the context input (Cao et al., 2018), and recent studies find even powerful LLMs also suffer from the problem of hallucination. This motivates recent research to design evaluators for measuring the consistency aspect in summarization (Krys-´ cinski et al. ´ , 2020; Wang et al., 2020; Cao et al., 2020; Durmus et al., 2020). We test the QAGS meta-evaluation benchmark, which includes two different summarization datasets: CNN/DailyMail and XSum (Narayan et al., 2018) Table 3 shows that BARTScore performs well on the more extractive subset (QAGS-CNN), but has low correlation on the more abstractive subset (QAGS-Xsum). UniEval has good correlation on both subsets of the data.
+
+<table><tr><td rowspan="2">Metrics</td><td colspan="3">QAGS-CNN</td><td colspan="3">QAGS-XSUM</td><td colspan="3">Average</td></tr><tr><td>r</td><td>p</td><td>T</td><td>r</td><td>p</td><td>T</td><td>r</td><td>p</td><td>T</td></tr><tr><td>ROUGE-2</td><td>0.459</td><td>0.418</td><td>0.333</td><td>0.097</td><td>0.083</td><td>0.068</td><td>0.278</td><td>0.250</td><td>0.200</td></tr><tr><td>ROUGE-L</td><td>0.357</td><td>0.324</td><td>0.254</td><td>0.024</td><td>-0.011</td><td>-0.009</td><td>0.190</td><td>0.156</td><td>0.122</td></tr><tr><td>BERTScore</td><td>0.576</td><td>0.505</td><td>0.399</td><td>0.024</td><td>0.008</td><td>0.006</td><td>0.300</td><td>0.256</td><td>0.202</td></tr><tr><td>MoverScore</td><td>0.414</td><td>0.347</td><td>0.271</td><td>0.054</td><td>0.044</td><td>0.036</td><td>0.234</td><td>0.195</td><td>0.153</td></tr><tr><td>FactCC</td><td>0.416</td><td>0.484</td><td>0.376</td><td>0.297</td><td>0.259</td><td>0.212</td><td>0.356</td><td>0.371</td><td>0.294</td></tr><tr><td>QAGS</td><td>0.545</td><td>-</td><td>1</td><td>0.175</td><td>1</td><td>1</td><td>0.375</td><td>1</td><td>1</td></tr><tr><td>BARTScore</td><td>0.735</td><td>0.680</td><td>0.557</td><td>0.184</td><td>0.159</td><td>0.130</td><td>0.459</td><td>0.420</td><td>0.343</td></tr><tr><td>CTC</td><td>0.619</td><td>0.564</td><td>0.450</td><td>0.309</td><td>0.295</td><td>0.242</td><td>0.464</td><td>0.430</td><td>0.346</td></tr><tr><td>UniEval</td><td>0.682</td><td>0.662</td><td>0.532</td><td>0.461</td><td>0.488</td><td>0.399</td><td>0.571</td><td>0.575</td><td>0.465</td></tr><tr><td>G-EVAL-3.5</td><td>0.477</td><td>0.516</td><td>0.410</td><td>0.211</td><td>0.406</td><td>0.343</td><td>0.344</td><td>0.461</td><td>0.377</td></tr><tr><td>G-EVAL-4</td><td>0.631</td><td>0.685</td><td>0.591</td><td>0.558</td><td>0.537</td><td>0.472</td><td>0.599</td><td>0.611</td><td>0.525</td></tr></table>
+
+Table 3: Pearson $( r )$ , Spearman $( \rho )$ and Kendall-Tau $( \tau )$ correlations of different metrics on QAGS benchmark.
+
+On average, G-EVAL-4 outperforms all state-ofthe-art evaluators on QAGS, with a large margin on QAGS-Xsum. G-EVAL-3.5, on the other hand, failed to perform well on this benchmark, which indicates that the consistency aspect is sensitive to the LLM’s capacity. This result is consistent with Table 1.
+
+# 4 Analysis
+
+Will G-EVAL prefer LLM-based outputs? One concern about using LLM as an evaluator is that it may prefer the outputs generated by the LLM itself, rather than the high-quality human-written texts. To investigate this issue, we conduct an experiment on the summarization task, where we compare the evaluation scores of the LLM-generated and the human-written summaries. We use the dataset collected in Zhang et al. (2023), where they first ask freelance writers to write high-quality summaries for news articles, and then ask annotators to compare human-written summaries and LLMgenerated summaries (using GPT-3.5, text-davinci003).
+
+![](images/14310d11da9813f4681270efcb4b023f8cef3919f186f06d0862cd52441b8bdd.jpg)  
+Figure 2: Averaged G-EVAL-4’s scores for humanwritten summaries and GPT-3.5 summaries, divided by human judges’ preference.
+
+The dataset can be divided in three categories: 1) human-written summaries that are rated higher than GPT-3.5 summaries by human judges, 2) human-written summaries that are rated lower than GPT-3.5 summaries by human judges, and 3) human-written summaries and GPT-3.5 summaries are rated equally good by human judges. We use GEVAL-4 to evaluate the summaries in each category, and compare the averaged scores. 2
+
+The results are shown in Figure 2. We can see that, G-EVAL-4 assigns higher scores to humanwritten summaries when human judges also prefer human-written summaries, and assigns lower scores when human judges prefer GPT-3.5 summaries. However, G-EVAL-4 always gives higher scores to GPT-3.5 summaries than human-written summaries, even when human judges prefer humanwritten summaries. We propose two potential reasons for this phenomenon:
+
+1. NLG outputs from high-quality systems are in natural difficult to evaluate. The authors of the original paper found that inter-annotator agreement on judging human-written and LLM-generated summaries is very low, with Krippendorff’s alpha at 0.07. 2. G-EVAL may have a bias towards the LLMgenerated summaries because the model could share the same concept of evaluation criteria during generation and evaluation.
+
+Our work should be considered as a preliminary study on this issue, and more research is needed to fully understand the behavior of LLM-based evaluators to reduce its inherent bias towards LLMgenerated text. We highlight this concern in the context that LLM-based evaluators may lead to self-reinforcement of LLMs if the evaluation score is used as a reward signal for further tuning. And this could result in the over-fitting of the LLMs to their own evaluation criteria, rather than the true evaluation criteria of the NLG tasks.
+
+The Effect of Chain-of-Thoughts We compare the performance of G-EVAL with and without chain-of-thoughts (CoT) on the SummEval benchmark. Table 1 shows that G-EVAL-4 with CoT has higher correlation than G-EVAL-4 without CoT on all dimensions, especially for fluency. This suggests that CoT can provide more context and guidance for the LLM to evaluate the generated text, and can also help to explain the evaluation process and results. And it is shown that CoT is more useful on consistency and fluency dimensions. We also provide results of G-EVAL with a simple prompting baseline on SummEval (only asking GPT-4 to score a summary from 1-5 on each dimension, without detailed task introduction, evaluation criteria and CoT).
+
+The Effect of Probability Normalization We compare the performance of G-EVAL with and without probability normalization on the SummEval benchmark. Table 1 shows that, on KendallTau correlation, G-EVAL-4 with probabilities is inferior to G-EVAL-4 without probabilities on SummEval. We believe this is related to the calculation of Kendall-Tau correlation, which is based on the number of concordant and discordant pairs. Direct scoring without probabilities can lead to many ties, which are not counted as either concordant or discordant. This may result in a higher Kendall-Tau correlation, but it does not reflect the model’s true capacity of evaluating the generated texts. On the other hand, probability normalization can obtain more fine-grained, continuous scores that better capture the subtle difference between generated texts. This is reflected by the higher Spearman correlation of G-EVAL-4 with probabilities, which is based on the rank order of the scores.
+
+The Effect of Different LLMs We compare the performance of G-EVAL with different LLMs on the SummEval and QAGS benchmarks. Table 1 and Table 3 show that G-EVAL-4 has higher correlation than G-EVAL-3.5 on most dimensions and datasets, except for engagingness and groundedness on the Topical-Chat benchmark. This demonstrates that a better LLM can improve the performance of G-EVAL, especially for more challenging and complex evaluation tasks, such as consistency and relevance.
+
+# 5 Related Work
+
+Ngram-based Metrics Ngram-based metrics refer to the scores for evaluating the NLG models by measuring the lexical overlap between a generated text and a reference text. BLEU (Papineni et al., 2002) is the most widely used metric for machine translation evaluation, which calculates the geometric mean of modified n-gram precision and a brevity penalty. ROUGE (Lin, 2004) is a recall-oriented metric for summarization evaluation, which measures the n-gram overlap between a generated summary and a set of reference summaries. It has been shown that more than $60 \%$ of recent papers on NLG only rely on ROUGE or BLEU to evaluate their systems (Kasai et al., 2022). However, these metrics fail to measure content quality (Reiter and Belz, 2009) or capture syntactic errors (Stent et al., 2005), and therefore do not reflect the reliability of NLG systems accurately.
+
+Embedding-based Metrics Embedding-based metrics refer to the scores for evaluating the NLG models by measuring the semantic similarity between a generated text and a reference text based on the word or sentence embeddings. WMD (Kusner et al., 2015) is a metric that measures the distance between two texts based on the word embeddings. BERTScore (Zhang et al., 2019) measures the similarity between two texts based on the contextualized embedding from BERT (Devlin et al., 2019). MoverScore (Zhao et al., 2019) improves BERTScore by adding soft alignments and new aggregation methods to obtain a more robust similarity measure. (Clark et al., 2019) propose a metric that evaluates multi-sentence texts by computing the similarity between the generated text and the reference text based on the sentence embeddings.
+
+Task-specific Evaluators Task-specific metrics refer to the scores for evaluating the NLG models by measuring the quality of the generated texts based on the specific task requirements. For example, summarization tasks need to assess the consistency of the generated summaries (Krys-´ cinski et al. ´ , 2020; Wang et al., 2020; Cao et al., 2020; Durmus et al., 2020), and dialogue response generation tasks need to assess the coherence of the generated responses (Dziri et al., 2019; Ye et al., 2021; Ghazarian et al., 2019). However, these metrics are not generalizable to other NLG tasks, and they are not able to measure the overall quality of the generated texts.
+
+Unified Evaluators Recently, some evaluators have been developed to assess text quality from multiple dimensions by varying the input and output contents (Yuan et al., 2021) or the model variants (Mehri and Eskenazi, 2020) they use. UniEval (Zhong et al., 2022) is a unified evaluator that can evaluate different aspects of text generation as QA tasks. By changing the question format, it can handle different evaluation tasks.
+
+LLM-based Evaluators Fu et al. (2023) propose GPTScore, a new framework that evaluated texts with generative pre-training models like GPT-3. It assumes that a generative pre-training model will assign a higher probability of high-quality generated text following a given instruction and context. Wang et al. (2023a) conduct a preliminary survey of using ChatGPT as a NLG evaluator. Kocmi and Federmann (2023); Lu et al. (2023) proposed to use GPT models for evaluating machine translation tasks. Very recently, Wang et al. (2023b) investigated the problem of unfairness when using large models in evaluating dialogue responses.
+
+extensive experiments on two NLG tasks, text summarization and dialogue generation, and show that G-EVAL can outperform state-of-the-art evaluators and achieve higher human correspondence. We also propose preliminary analysis on the behavior of LLM-based evaluators, and highlight the potential issue of LLM-based evaluator having a bias towards the LLM-generated texts. We hope our work can inspire more research on using LLMs for NLG evaluation, and also raise awareness of the potential risks and challenges of using LLMs as evaluators.
+
+# Limitations
+
+G-EVAL is a framework that uses LLMs to evaluate the quality of generated texts. However, it also has some limitations that need to be addressed in future work.
+
+1. As we already discussed in the paper, G-EVAL may have a bias towards the LLM-generated texts. This may lead to the self-reinforcement of LLMs if the evaluation score is used as a reward signal for further tuning. And this could result in the over-fitting of the LLMs to their own evaluation criteria, rather than the true evaluation criteria of the NLG tasks.
+
+2. G-EVAL is limited by the availability and accessibility of LLMs. Currently, most LLMs are not publicly available, and require special access or payment to use. This may limit the applicability and reproducibility of G-EVAL. Moreover, the LLMs are constantly updated, which may lead to inconsistent evaluation results across different versions of the LLMs.
+
+3. We meta-evaluate G-EVAL on two NLG tasks, text summarization and dialogue generation. However, there are some emerging NLG tasks in the LLM era where users prompt with freeform natural language instructions. In this case, the evaluation criteria may need to be more flexible and adaptive to the user’s intention and preference. Therefore, more research is needed to explore how to use G-EVAL for evaluating these new types of NLG tasks.
+
+# 6 Conclusion
+
+In this paper, we propose G-EVAL, a framework of using LLM with chain-of-thoughts (CoT) to evaluate the quality of generated texts. We conduct
+
+# Ethics Statement
+
+The G-EVAL framework we proposed is designed to offer a more effective and reliable method for assessing natural language generation systems. Its purpose is to aid researchers, developers, and other interested parties in evaluating the quality of text produced by NLG systems. Possible risks could exist if G-EVAL is unable to precisely evaluate the quality of produced texts or shows a preference for LLM-created texts. This could lead to developers overestimating the performance of their systems or unintentionally reinforcing biases in their models. Furthermore, users depending on the generated material may receive low-quality or biased information.
+
+# References
+
+Satanjeev Banerjee and Alon Lavie. 2005. Meteor: An automatic metric for mt evaluation with improved correlation with human judgments. In Proceedings of the acl workshop on intrinsic and extrinsic evaluation measures for machine translation and/or summarization, pages 65–72.
+
+Meng Cao, Yue Dong, Jiapeng Wu, and Jackie Chi Kit Cheung. 2020. Factual error correction for abstractive summarization models. In Proceedings of the 2020 Conference on Empirical Methods in Natural Language Processing (EMNLP), pages 6251–6258.
+
+Ziqiang Cao, Furu Wei, Wenjie Li, and Sujian Li. 2018. Faithful to the original: Fact aware neural abstractive summarization. In thirty-second AAAI conference on artificial intelligence.
+
+Elizabeth Clark, Asli Celikyilmaz, and Noah A Smith. 2019. Sentence mover’s similarity: Automatic evaluation for multi-sentence texts. In Proceedings of the 57th Annual Meeting of the Association for Computational Linguistics, pages 2748–2760.
+
+Jacob Devlin, Ming-Wei Chang, Kenton Lee, and Kristina Toutanova. 2019. Bert: Pre-training of deep bidirectional transformers for language understanding. In Proceedings of the 2019 Conference of the North American Chapter of the Association for Computational Linguistics: Human Language Technologies, Volume 1 (Long and Short Papers), pages 4171– 4186.
+
+Esin Durmus, He He, and Mona Diab. 2020. Feqa: A question answering evaluation framework for faithfulness assessment in abstractive summarization. In Proceedings of the 58th Annual Meeting of the Association for Computational Linguistics, pages 5055– 5070.
+
+Nouha Dziri, Ehsan Kamalloo, Kory Mathewson, and Osmar R Zaiane. 2019. Evaluating coherence in dialogue systems using entailment. In Proceedings of the 2019 Conference of the North American Chapter of the Association for Computational Linguistics: Human Language Technologies, Volume 1 (Long and Short Papers), pages 3806–3812.
+
+Alexander R Fabbri, Wojciech Krysci ´ nski, Bryan Mc- ´ Cann, Caiming Xiong, Richard Socher, and Dragomir Radev. 2021. Summeval: Re-evaluating summarization evaluation. Transactions of the Association for Computational Linguistics, 9:391–409.
+
+Jinlan Fu, See-Kiong Ng, Zhengbao Jiang, and Pengfei Liu. 2023. Gptscore: Evaluate as you desire. arXiv preprint arXiv:2302.04166.
+
+Sarik Ghazarian, Johnny Wei, Aram Galstyan, and Nanyun Peng. 2019. Better automatic evaluation of open-domain dialogue systems with contextualized embeddings. In Proceedings of the Workshop on Methods for Optimizing and Evaluating Neural Language Generation, pages 82–89, Minneapolis, Minnesota. Association for Computational Linguistics.
+
+Karl Moritz Hermann, Tomas Kocisky, Edward Grefenstette, Lasse Espeholt, Will Kay, Mustafa Suleyman, and Phil Blunsom. 2015. Teaching machines to read and comprehend. Advances in neural information processing systems, 28.
+
+Jungo Kasai, Keisuke Sakaguchi, Ronan Le Bras, Lavinia Dunagan, Jacob Morrison, Alexander Fabbri, Yejin Choi, and Noah A. Smith. 2022. Bidimensional leaderboards: Generate and evaluate language hand in hand. In Proceedings of the 2022 Conference of the North American Chapter of the Association for Computational Linguistics: Human Language Technologies, pages 3540–3557, Seattle, United States. Association for Computational Linguistics.
+
+Tom Kocmi and Christian Federmann. 2023. Large language models are state-of-the-art evaluators of translation quality. arXiv preprint arXiv:2302.14520.
+
+Wojciech Krysci ´ nski, Bryan McCann, Caiming Xiong, ´ and Richard Socher. 2020. Evaluating the factual consistency of abstractive text summarization. In Proceedings of the 2020 Conference on Empirical Methods in Natural Language Processing (EMNLP), pages 9332–9346.
+
+Matt Kusner, Yu Sun, Nicholas Kolkin, and Kilian Weinberger. 2015. From word embeddings to document distances. In International conference on machine learning, pages 957–966. PMLR.
+
+Mike Lewis, Yinhan Liu, Naman Goyal, Marjan Ghazvininejad, Abdelrahman Mohamed, Omer Levy, Veselin Stoyanov, and Luke Zettlemoyer. 2020. BART: denoising sequence-to-sequence pre-training for natural language generation, translation, and comprehension. In Proceedings of the 58th Annual Meeting of the Association for Computational Linguistics, ACL 2020, Online, July 5-10, 2020, pages 7871–7880. Association for Computational Linguistics.
+
+Chin-Yew Lin. 2004. Rouge: A package for automatic evaluation of summaries. In Text summarization branches out, pages 74–81.
+
+Qingyu Lu, Baopu Qiu, Liang Ding, Liping Xie, and Dacheng Tao. 2023. Error analysis prompting enables human-like translation evaluation in large language models: A case study on chatgpt. arXiv preprint arXiv:2303.13809.
+
+Shikib Mehri and Maxine Eskenazi. 2020. USR: An unsupervised and reference free evaluation metric for dialog generation. In Proceedings of the 58th Annual Meeting of the Association for Computational Linguistics, pages 681–707, Online. Association for Computational Linguistics.
+
+Shashi Narayan, Shay B Cohen, and Mirella Lapata. 2018. Don’t give me the details, just the summary! topic-aware convolutional neural networks for extreme summarization. In Proceedings of the 2018 Conference on Empirical Methods in Natural Language Processing, pages 1797–1807.
+
+Long Ouyang, Jeffrey Wu, Xu Jiang, Diogo Almeida, Carroll Wainwright, Pamela Mishkin, Chong Zhang, Sandhini Agarwal, Katarina Slama, Alex Ray, et al. 2022. Training language models to follow instructions with human feedback. Advances in Neural Information Processing Systems, 35:27730–27744.
+
+Kishore Papineni, Salim Roukos, Todd Ward, and WeiJing Zhu. 2002. Bleu: a method for automatic evaluation of machine translation. In Proceedings of the 40th annual meeting of the Association for Computational Linguistics, pages 311–318.
+
+Colin Raffel, Noam Shazeer, Adam Roberts, Katherine Lee, Sharan Narang, Michael Matena, Yanqi Zhou, Wei Li, and Peter J Liu. 2020. Exploring the limits of transfer learning with a unified text-to-text transformer. Journal of Machine Learning Research, 21:1– 67.
+
+Ehud Reiter and Anja Belz. 2009. An investigation into the validity of some metrics for automatically evaluating natural language generation systems. Computational Linguistics, 35(4):529–558.
+
+Amanda Stent, Matthew Marge, and Mohit Singhai. 2005. Evaluating evaluation methods for generation in the presence of variation. In Proceedings of the 6th international conference on Computational Linguistics and Intelligent Text Processing, pages 341–351.
+
+Rohan Taori, Ishaan Gulrajani, Tianyi Zhang, Yann Dubois, Xuechen Li, Carlos Guestrin, Percy Liang, and Tatsunori B. Hashimoto. 2023. Stanford alpaca: An instruction-following llama model. https:// github.com/tatsu-lab/stanford_alpaca.
+
+Alex Wang, Kyunghyun Cho, and Mike Lewis. 2020. Asking and answering questions to evaluate the factual consistency of summaries. In Proceedings of the 58th Annual Meeting of the Association for Computational Linguistics, pages 5008–5020.
+
+Jiaan Wang, Yunlong Liang, Fandong Meng, Haoxiang Shi, Zhixu Li, Jinan Xu, Jianfeng Qu, and Jie Zhou. 2023a. Is chatgpt a good nlg evaluator? a preliminary study. arXiv preprint arXiv:2303.04048.
+
+Peiyi Wang, Lei Li, Liang Chen, Dawei Zhu, Binghuai Lin, Yunbo Cao, Qi Liu, Tianyu Liu, and Zhifang Sui. 2023b. Large language models are not fair evaluators. arXiv preprint arXiv:2305.17926.
+
+Jason Wei, Xuezhi Wang, Dale Schuurmans, Maarten Bosma, Ed Chi, Quoc Le, and Denny Zhou. 2022. Chain of thought prompting elicits reasoning in large language models. Advances in neural information processing systems, 28.
+
+Zheng Ye, Liucun Lu, Lishan Huang, Liang Lin, and Xiaodan Liang. 2021. Towards quantifiable dialogue coherence evaluation. In Proceedings of the 59th Annual Meeting of the Association for Computational Linguistics and the 11th International Joint Conference on Natural Language Processing (Volume 1: Long Papers), pages 2718–2729.
+
+Weizhe Yuan, Graham Neubig, and Pengfei Liu. 2021. Bartscore: Evaluating generated text as text generation. Advances in Neural Information Processing Systems, 34.
+
+Tianyi Zhang, Varsha Kishore, Felix Wu, Kilian Q Weinberger, and Yoav Artzi. 2019. Bertscore: Evaluating text generation with bert. arXiv preprint arXiv:1904.09675.
+
+Tianyi Zhang, Faisal Ladhak, Esin Durmus, Percy Liang, Kathleen McKeown, and Tatsunori B. Hashimoto. 2023. Benchmarking large language models for news summarization.
+
+Wei Zhao, Maxime Peyrard, Fei Liu, Yang Gao, Christian M Meyer, and Steffen Eger. 2019. Moverscore: Text generation evaluating with contextualized embeddings and earth mover distance. In Proceedings of the 2019 Conference on Empirical Methods in Natural Language Processing and the 9th International Joint Conference on Natural Language Processing (EMNLP-IJCNLP), pages 563–578.
+
+Lianmin Zheng, Wei-Lin Chiang, Ying Sheng, Siyuan Zhuang, Zhanghao Wu, Yonghao Zhuang, Zi Lin, Zhuohan Li, Dacheng Li, Eric. P Xing, Hao Zhang, Joseph E. Gonzalez, and Ion Stoica. 2023. Judging llm-as-a-judge with mt-bench and chatbot arena.
+
+Ming Zhong, Yang Liu, Da Yin, Yuning Mao, Yizhu Jiao, Pengfei Liu, Chenguang Zhu, Heng Ji, and Jiawei Han. 2022. Towards a unified multidimensional evaluator for text generation. In Proceedings of the 2022 Conference on Empirical Methods in Natural Language Processing, pages 2023– 2038, Abu Dhabi, United Arab Emirates.
+
+# A Example Prompts
+
+# Evaluate Coherence in the Summarization Task
+
+You will be given one summary written for a news article.
+
+Your task is to rate the summary on one metric.
+
+Please make sure you read and understand these instructions carefully. Please keep this document open while reviewing, and refer to it as needed.
+
+# Evaluation Criteria:
+
+Coherence (1-5) - the collective quality of all sentences. We align this dimension with the DUC quality question of structure and coherence whereby "the summary should be well-structured and well-organized. The summary should not just be a heap of related information, but should build from sentence to sentence to a coherent body of information about a topic."
+
+# Evaluation Steps:
+
+1. Read the news article carefully and identify the main topic and key points.
+
+2. Read the summary and compare it to the news article. Check if the summary covers the main topic and key points of the news article, and if it presents them in a clear and logical order.
+
+3. Assign a score for coherence on a scale of 1 to 5, where 1 is the lowest and 5 is the highest based on the Evaluation Criteria.
+
+Example: Source Text: {{Document}} Summary: {{Summary}}
+
+Evaluation Form (scores ONLY): - Coherence:
+
+# Evaluate Engagingness in the Dialogue Generation Task
+
+You will be given a conversation between two individuals. You will then be given one potential response for the next turn in the conversation. The response concerns an interesting fact, which will be provided as well.
+
+Your task is to rate the responses on one metric.
+
+Please make sure you read and understand these instructions carefully. Please keep this document open while reviewing, and refer to it as needed.
+
+# Evaluation Crieteria:
+
+Engagingness (1-3) Is the response dull/interesting?
+
+- A score of 1 (dull) means that the response is generic and dull.
+
+- A score of 2 (somewhat interesting) means the response is somewhat interesting and could engage you in the conversation (e.g., an opinion, thought)
+
+- A score of 3 (interesting) means the response is very interesting or presents an interesting fact
+
+# Evaluation Steps:
+
+1. Read the conversation, the corresponding fact and the response carefully.
+
+2. Rate the response on a scale of 1-3 for engagingness, according to the criteria above.
+
+3. Provide a brief explanation for your rating, referring to specific aspects of the response and the conversation.
+
+# Example:
+
+Conversation History:   
+{{Document}}   
+Corresponding Fact:   
+{{Fact}}   
+Response:   
+{{Response}}
+
+Evaluation Form (scores ONLY): - Engagingness:
+
+# Evaluate Hallucinations
+
+Human Evaluation of Text Summarization Systems:
+
+Factual Consistency: Does the summary untruthful or misleading facts that are not supported by the source text?
+
+Source Text: {{Document}} Summary: {{Summary}}
+
+Does the summary contain factual inconsistency?
+
+Answer:

parse/dev/yJE7iQSAep/yJE7iQSAep.md

@@ -0,0 +1,342 @@
+# On the Parameterization and Initialization of Diagonal State Space Models
+
+Albert $\mathbf { G u } ^ { \dagger }$ , Ankit Gupta‡, Karan Goel†, Christopher Re´†
+
+† Department of Computer Science, Stanford University ‡ IBM Research   
+{albertgu,knrg}@stanford.edu, chrismre@cs.stanford.edu ankitgupta.iitkanpur@gmail.com
+
+# Abstract
+
+State space models (SSM) have recently been shown to be very effective as a deep learning layer as a promising alternative to sequence models such as RNNs, CNNs, or Transformers. The first version to show this potential was the S4 model, which is particularly effective on tasks involving long-range dependencies by using a prescribed state matrix called the HiPPO matrix. While this has an interpretable mathematical mechanism for modeling long dependencies, it introduces a custom representation and algorithm that can be difficult to implement. On the other hand, a recent variant of S4 called DSS showed that restricting the state matrix to be fully diagonal can still preserve the performance of the original model when using a specific initialization based on approximating S4’s matrix. This work seeks to systematically understand how to parameterize and initialize such diagonal state space models. While it follows from classical results that almost all SSMs have an equivalent diagonal form, we show that the initialization is critical for performance. We explain why DSS works mathematically, by showing that the diagonal restriction of S4’s matrix surprisingly recovers the same kernel in the limit of infinite state dimension. We also systematically describe various design choices in parameterizing and computing diagonal SSMs, and perform a controlled empirical study ablating the effects of these choices. Our final model S4D is a simple diagonal version of S4 whose kernel computation requires just 2 lines of code and performs comparably to S4 in almost all settings, with state-of-the-art results for image, audio, and medical time-series domains, and averaging $8 5 \%$ on the Long Range Arena benchmark.
+
+# 1 Introduction
+
+A core class of models in modern deep learning are sequence models, which are parameterized mappings operating on arbitrary sequences of inputs. Recent approaches based on state space models (SSMs) have outperformed traditional deep sequence models such as recurrent neural networks (RNNs), convolutional neural networks (CNNs), and Transformers, in both computational efficiency and modeling ability. In particular, the S4 model displayed strong results on a range of sequence modeling tasks, especially on long sequences [9]. Its ability to model long-range dependencies arises from being defined with a particular state matrix called the “HiPPO matrix” [6], which allows S4 to be viewed as a convolutional model that decomposes an input onto an orthogonal system of smooth basis functions[10].
+
+However, beyond its theoretical interpretation, actually computing S4 as a deep learning model requires a sophisticated algorithm with many linear algebraic techniques that are difficult to understand and implement. These techniques were necessitated by parameterizing its state matrix as a diagonal plus low-rank (DPLR) matrix, which is necessary to capture HiPPO matrices. A natural question is whether simplifications of this parameterization and algorithm are possible. In particular, removing the low-rank term would result in a diagonal state space model (diagonal SSM) that is dramatically simpler to implement and understand.
+
+![](images/27c8f33e4d7cf53989b9f9b74e4bb545cac85e1e89d3a410409b423d17fd5b4e.jpg)  
+Figure 1: S4D is a diagonal SSM which inherits the strengths of S4 while being much simpler. (Left) The diagonal structure allows it to be viewed as a collection of 1-dimensional SSMs. (Right) As a convolutional model, S4D has a simple interpretable convolution kernel which can be implemented in two lines of code. Colors denote independent 1-D SSMs; purple denotes trainable parameters.
+
+Although it is known that almost all SSMs have an equivalent diagonal form—and therefore (complex) diagonal SSMs are fully expressive algebraically—they may not represent all SSMs numerically, and finding a good initialization is critical. Gu et al. [9] showed that it is difficult to find a performant diagonal SSM, and that many alternative parameterizations of the state matrix – including by random diagonal matrices – are much less effective empirically, which motivated the necessity of the more complicated HiPPO matrix. However, recently Gupta [11] made the empirical observation that a variant of S4 using a particular diagonal matrix is nearly as effective as the original S4 method. This matrix is based on the original HiPPO matrix and is defined by simply chopping off the low-rank term in the DPLR representation.
+
+The discovery of performant diagonal state matrices opens up new possibilities for simplifying deep state space models, and consolidating models such as S4 and DSS to understand and improve them. First, the strongest version of DSS computes the SSM with a complex-valued softmax that complicates the algorithm, and is actually less efficient than S4. Additionally, DSS and S4 differ in several auxiliary aspects of parameterizing SSMs that can conflate performance effects, making it more difficult to isolate the core effects of diagonal versus DPLR state matrices. Most importantly, DSS relies on initializing the state matrix to a particular approximation of S4’s HiPPO matrix. While S4’s matrix has a mathematical interpretation for addressing long-range dependencies, the efficacy of the diagonal approximation to it remains theoretically unexplained.
+
+In this work, we seek to systematically understand how to train diagonal SSMs. We introduce the S4D method, a diagonal SSM which combines the best of S4’s computation and parameterization and DSS’s initialization, resulting in a method that is extremely simple, theoretically princpled, and empirically effective.
+
+• First, we describe S4D, a simple method outlined by S4 for computing diagonal instead of DPLR matrices, which is based on Vandermonde matrix multiplication and is even simpler and more efficient than the DSS. Outside of the core state matrix, we categorize different representations of the other components of SSMs, introducing flexible design choices that capture both S4 and DSS and allow different SSM parameterizations to be systematically compared (Section 3). • We provide a new mathematical analysis of DSS’s initialization, showing that the diagonal approximation of the original HiPPO matrix surprisingly produces the same dynamics as S4 when the state size goes to infinity. We propose even simpler variants of diagonal SSMs using different initializations of the state matrix (Section 4). • We perform a controlled study of these various design choices across many domains, tasks, and sequence lengths, and additionally compare diagonal (S4D) versus DPLR (S4) variants. Our best S4D methods are competitive with S4 on almost all settings, with near state-of-the-art results on image, audio, and medical time series benchmarks, and achieving $85 \%$ on the Long Range Arena benchmark (Section 5).
+
+# 2 Background
+
+Continuous State Spaces Models S4 investigated state space models (1) that are parameterized maps on signals $u ( t ) \mapsto y ( t )$ . These SSMs are linear time-invariant systems that can be represented either as a linear ODE (equation (1)) or convolution (equation (2)).
+
+$$
+\begin{array} { c c } { { x ^ { \prime } ( t ) = A x ( t ) + B u ( t ) ~ } } & { { ~ ( 1 ) ~ } } \\ { { y ( t ) = C x ( t ) ~ } } & { { ~ y ( t ) = ( K * u ) ( t ) } } \end{array}
+$$
+
+Here the parameters are the state matrix $ { \boldsymbol { A } } \in \mathbb { C } ^ { N \times N }$ and other matrices $\boldsymbol { B } \in \mathbb { C } ^ { N \times 1 }$ , $\boldsymbol { C } \in \mathbb { C } ^ { 1 \times N }$ . In the case of diagonal SSMs, $\pmb { A }$ is diagonal and we will overload notation so that $A _ { n } , B _ { n } , C _ { n }$ denotes the entries of the parameters.
+
+An intuitive way to view the convolution kernel (2) is to interpret it as a linear combination (controlled by $C$ ) of basis kernels $K _ { n } ( t )$ (controlled by $A , B )$
+
+$$
+K ( t ) = \sum _ { n = 0 } ^ { N - 1 } C _ { n } K _ { n } ( t ) \qquad K _ { n } ( t ) : = e _ { n } ^ { \top } e ^ { t A } B
+$$
+
+We denote this basis as $K ( t ) = K _ { A , B } ( t ) = e ^ { t A } B$ if necessary to disambiguate; note that it is a vector of $N$ functions. In the case of diagonal SSMs, each function $K _ { n } ( t )$ is just $e ^ { t A _ { n } } B _ { n }$ .
+
+S4: Structured State Spaces As a deep learning model, SSMs have many elegant properties with concrete empirical and computational benefits [8]. For example, the convolutional form (2) can be converted into a temporal recurrence that is substantially faster for autoregressive applications [5].
+
+However, making SSMs effective required overcoming two key challenges: choosing appropriate values for the matrices, and computing the kernel (2) efficiently.
+
+First, Gu et al. [8] showed that naive instantiations of the SSM do not perform well, and instead relied on a particular (real-valued) matrix $\pmb { A }$ called the HiPPO-LegS matrix (4).1 These matrices were derived so that the basis kernels $K _ { n } ( t )$ have closed-form formulas $L _ { n } ( e ^ { - t } )$ , where $L _ { n } ( t )$ are normalized Legendre polynomials. Consequently, the SSM has a mathematical interpretation of decomposing the input signal $u ( t )$ onto a set of infinitely-long basis functions that are orthogonal respect to an exponentially-decaying measure, giving it long-range modeling abilities [10].
+
+Second, S4 introduced a particular parameterization that decomposed this $\pmb { A }$ matrix into the sum of a normal and rank-1 matrix (5), which can be unitarily conjugated into a (complex) diagonal plus rank-1 matrix. Leveraging this structured form, they then introduced a sophisticated algorithm for efficiently computing the convolution kernel (2) for state matrices that are diagonal plus low-rank (DPLR).
+
+$$
+\begin{array} { c c } { { A _ { n k } = - \left\{ \begin{array} { l l } { { ( 2 n + 1 ) ^ { \frac { 1 } { 2 } } ( 2 k + 1 ) ^ { \frac { 1 } { 2 } } } } & { { n > k } } \\ { { n + 1 } } & { { n = k } } \end{array} \right. } } & { { A _ { n k } ^ { ( N ) } = - \left\{ \begin{array} { l l } { { ( n + \frac { 1 } { 2 } ) ^ { 1 / 2 } ( k + \frac { 1 } { 2 } ) ^ { 1 / 2 } } } & { { n > k } } \\ { { \frac { 1 } { 2 } } } & { { n = k } } \end{array} \right. } } \\ { { 0 } } & { { n < k } } & { { ( 4 ) } } \\ { { B _ { n } = ( 2 n + 1 ) ^ { \frac { 1 } { 2 } } } } & { { P _ { n } = ( n + 1 / 2 ) ^ { \frac { 1 } { 2 } } } } \end{array}
+$$
+
+DSS: Diagonal State Spaces S4 was originally motivated by searching for a diagonal state matrix, which would be even more structured and result in very simple computation of the SSM. However, the HiPPO-LegS matrix cannot be stably transformed into diagonal form [9, Lemma 3.2], and they were unable to find any diagonal matrices that performed well, resulting in the DPLR formulation.
+
+Gupta [11] made the surprising empirical observation that simply removing the low-rank portion of the DPLR form of the HiPPO-LegS matrix results in a diagonal matrix that performs comparably to the original S4 method. More precisely, their initialization is the diagonal matrix $A ^ { ( D ) }$ , or the diagonalization of $A ^ { ( N ) }$ in (5). They termed $A ^ { ( N ) }$ the skew-HiPPO matrix, which we will also call the normal-HiPPO matrix. To be more specific and disambiguate these variants, we may also call $A ^ { ( N ) }$ the HiPPO-LegS-N or HiPPO-N matrix and $A ^ { ( D ) }$ the HiPPO-LegS-D or HiPPO-D matrix.
+
+In addition to this initialization, they proposed a method for computing a diagonal SSM kernel.   
+Beyond these two core differences, several other aspects of their parameterization differ from $\mathrm { { \cal S } } 4 \mathrm { \ ' } _ { \mathrm { s } }$ .
+
+In Sections 3 and 4, we systematically study the components of DSS: we categorize different ways to parameterize and compute the diagonal state space, and explain the theoretical interpretion of this particular diagonal $\pmb { A }$ matrix.
+
+# 3 Parameterizing Diagonal State Spaces
+
+We describe various choices for the computation and parameterization of diagonal state spaces. Our categorization of these choices leads to simple variants of the core method. Both DSS and our proposed S4D can be described using a combination of these factors (Section 3.4).
+
+# 3.1 Discretization
+
+The true continuous-time SSM can be represented as a continuous convolution $y ( t ) = ( K * u ) ( t ) =$ $\begin{array} { r } { \int _ { 0 } ^ { \infty } C e ^ { s A } B u ( t - s ) d s } \end{array}$ .
+
+In discrete time, we view an input sequence $u _ { 0 } , u _ { 1 } , \ldots$ as uniformly-spaced samples from an underlying function $u ( t )$ and must approximate this integral. Standard methods for doing so that preserve the convolutional structure of the model exist. The first step is to discretize the parameters. Two simple choices that have been used in prior work include
+
+$$
+\begin{array} { r l } { | \overline { { A } } = ( I - \Delta / 2 A ) ^ { - 1 } ( I + \Delta / 2 A ) \qquad } & { ( \mathbf { Z O H } ) \overline { { A } } = \exp ( \Delta A ) } \\ { \overline { { B } } = ( I - \Delta / 2 A ) ^ { - 1 } \cdot \Delta B \qquad } & { \overline { { B } } = ( \Delta A ) ^ { - 1 } ( \exp ( \Delta \cdot A ) - I ) \cdot \Delta B . } \end{array}
+$$
+
+With these methods, the discrete-time SSM output is just
+
+$$
+y = u * { \overline { { K } } } \qquad \mathrm { w h e r e } \ { \overline { { K } } } = ( C { \overline { { B } } } , C { \overline { { A B } } } , \ldots , C { \overline { { A } } } ^ { L - 1 } { \overline { { B } } } ) .
+$$
+
+These integration rules have both been used in prior works (e.g. LMU and DSS use ZOH [26, 11] while S4 and its predecessors use bilinear [6, 8, 9]).
+
+In Section 5, we show that there is little empirical difference between them. However, we note that there is a curious phenomenon where the bilinear transform actually perfectly smooths out the kernel used in DSS to match the S4 kernel (Section 4 Fig. 2d). We additionally note that numerical integration is a rich and well-studied topic and more stable methods of approximating the convolutional integral may exist. For example, it is well-known that simple rules like the Trapezoid rule [18] can dramatically reduce numerical integration error when the function has bounded second derivative.
+
+# 3.2 Convolution Kernel
+
+The main computational difficulty of the original S4 model is computing the convolution kernel $\overline { { \kappa } }$ . This is extremely slow for general state matrices $\pmb { A }$ , and S4 introduced a complicated algorithm for DPLR state matrices. When $\pmb { A }$ is diagonal, the computation is nearly trivial. By (6),
+
+$$
+\begin{array} { r } { \overline { { \mathbf { K } } } _ { \ell } = \displaystyle \sum _ { n = 0 } ^ { N - 1 } C _ { n } \overline { { A } } _ { n } ^ { \ell } \overline { { B } } _ { n } \implies \overline { { K } } = ( \overline { { B } } ^ { \top } \circ C ) \cdot \boldsymbol { \mathcal { V } } _ { L } ( \overline { { A } } ) \qquad \mathrm { ~ w h e r e ~ } \boldsymbol { \mathcal { V } } _ { L } ( \overline { { A } } ) _ { n , \ell } = \overline { { A } } _ { n } ^ { \ell } } \end{array}
+$$
+
+where $\circ$ is Hadamard product, $\cdot$ is matrix multiplication, and $\nu$ is known as a Vandermonde matrix.
+
+Time and Space Complexity The naive way to compute (7) is by materializing the Vandermonde matrix $\mathcal { V } _ { L } ( \overline { { A } } )$ and performing a matrix multiplication, which requires $O ( N L )$ time and space.
+
+However, Vandermonde matrices are well-studied and theoretically the multiplication can be computed in $\widetilde O ( N + L )$ operations and $O ( N + L )$ space. In fact, Vandermonde matrices are closely related to Cauchy matrices, which are the computational core of S4’s DPLR algorithm, and have identical complexity [17].
+
+Proposition 1. The time and space complexity of computing the kernel of diagonal SSMs is equal to that of computing DPLR SSMs.
+
+We note that on modern parallelizable hardware such as GPUs, a simple fast algorithm is to compute (7) with naive summation (using $O ( N L )$ operations), but without materializing the Vandermonde matrix (using $O ( N + L )$ space). Just as with S4, this may require implementing a custom kernel in some modern deep learning frameworks such as PyTorch to achieve the space savings.
+
+# 3.3 Parameterization
+
+Parameterization of $\pmb { A }$ . Note that the kernel $K ( t ) = C e ^ { t A } B$ blows up to $\infty$ as $t \to \infty$ if $\pmb { A }$ has any eigenvalues with positive real part. Goel et al. [5] found that this is a serious constraint that affects the stability of the model, especially when using the SSM autoregressively. They propose to force the real part of $\pmb { A }$ to be negative, also known as the left-half plane condition in classical controls, by parameterizing the real part inside an exponential function $\pmb { \dot { A } } = - \exp ( \pmb { A } _ { R e } ) + \boldsymbol { i } \cdot \pmb { A } _ { I m }$ .
+
+We note that instead of exp, any activation function can be used as long as its range is bounded on one side, such as ReLU, softplus, etc. The original DSS does not constrain the real part of $\pmb { A }$ , which is sufficient for simple tasks involving fixed-length sequences, but could become unstable in other settings.
+
+Parameterization of $_ { B , C }$ . Another choice in the parameterization is how to represent $\textbf {  { B } }$ and $C$ . Note that the computation of the final discrete convolution kernel $\overline { { \kappa } }$ depends only on the elementwise product $B \circ C$ (equation (7)). Therefore DSS chose to parameterize this product directly, which they call $W$ , instead of $\textbf {  { B } }$ and $C$ individually.
+
+However, we observe that this is equivalent to keeping independent $\textbf {  { B } }$ and $C$ , and simply freezing $\mathbf B = \mathbf 1$ while training $C$ . Therefore, just as S4 has separate parameters $A , B$ , and $C$ and uses a fixed initialization for $\pmb { A }$ and $\textbf {  { B } }$ , S4D also proposes separate $A , B$ , and $C$ and uses fixed initializations for $\pmb { A }$ (discussed in Section 4) and $\textbf {  { B } }$ (set to 1). Then the difference between S4D and DSS is simply that DSS does not train $\textbf {  { B } }$ . In our ablations, we show that training $\textbf {  { B } }$ gives a minor but consistent improvement in performance.
+
+# 3.4 S4D: the Diagonal Version of S4
+
+A key component of our exposition is disentangling the various choices possible in representing and computing state space models. With this categorization, different choices can be mixed and matched to define variants of the core method. Table 1 compares S4, DSS, and S4D, which have a core structure and kernel computation, but have various choices of other aspects of the parameterization.
+
+Table 1: (Parameterization choices for Structured SSMs.) Aside from the core structure of $\pmb { A }$ and the computation of its convolution kernel, SSMs have several design choices which are consolidated in S4D.   
+
+<table><tr><td>Method</td><td> Structure</td><td>Kernel Computation</td><td>Discretization</td><td>Constraint (A)</td><td>Trainable B</td><td>Initialization of A</td></tr><tr><td>S4</td><td>DPLR</td><td>Cauchy</td><td>Bilinear</td><td>exp</td><td>Yes</td><td>HiPPO</td></tr><tr><td>DSS</td><td>diagonal</td><td>softmax</td><td>ZOH</td><td>id (none)</td><td>No</td><td>HiPPO-D</td></tr><tr><td>S4D</td><td>diagonal</td><td>Vandermonde</td><td>either</td><td>exp/ReLU</td><td>optional</td><td>various</td></tr></table>
+
+# 4 Initialization of Diagonal State Matrices
+
+The critical question remains: which diagonal state matrices $\pmb { A }$ are actually effective? We comment on the limitations of diagonal SSMs, and then provide three instantiations of S4D that perform well empirically.
+
+Expressivity and Limitations of Diagonal SSMs. We first present a simplified view on the expressivity of diagonal SSMs mentioned by [11]. First, it is well-known that almost all matrices diagonalize over the complex plane. Therefore it is critical to use complex-valued matrices in order to use diagonal SSMs.
+
+Proposition 2. The set $\mathcal { D } \subset \mathbb { C } ^ { N \times N }$ of diagonalizable matrices is dense in $\mathbb { C } ^ { N \times N }$ , and has full measure (i.e. its complement has measure 0).
+
+It is also well known that the state space $( A , B , C )$ is exactly equivalent to (i.e. expresses the same map $u \mapsto y$ ) the state space $( V ^ { - 1 } \bar { A } V , \dot { V } ^ { - 1 } B , C \dot { V } )$ , known in the SSM literature as a state space transformation. Therefore Proposition 2 says that (almost) all SSMs are equivalent to a diagonal SSM.
+
+However, we emphasize that Proposition 2 is about expressivity which does not guarantee strong performance of a trained model after optimization. For example, Gu et al. [9] and Gupta [11] show that parameterizing $\pmb { A }$ as a dense real matrix or diagonal complex matrix, which are both fully expressive classes, performs poorly if randomly initialized.
+
+Second, Proposition 2 does not take into account numerical representations of data, which was the original reason S4 required a low-rank correction term instead of a pure diagonalization [9, Lemma 3.2]. In Section 5.2, we also show that two different initializations with the same spectrum (i.e., are equivalent to the same diagonal $\pmb { A }$ ) can have very different performance.
+
+S4D-LegS. The HiPPO-LegS matrix has DPLR representation $A ^ { ( D ) } - P P ^ { \top }$ , and Gupta [11] showed that simply approximating it with $A ^ { ( D ) }$ works quite well (5). Our first result is providing a clean mathematical interpretation of this method. Theorem 3 shows a surprising fact that does not hold in general for DPLR matrices (Appendix A.1), and arises out of the special structure of this particular matrix.
+
+Theorem 3. Let $\pmb { A } = \pmb { A } ^ { ( N ) } - P \pmb { P } ^ { \top }$ and $\textbf {  { B } }$ be the HiPPO-LegS matrices, and $K _ { A , B } ( t )$ be its basis.   
+As the state size $N \to \infty$ , the SSM basis $K _ { A ^ { ( N ) } , B / 2 } ( t )$ limits to $K _ { A , B } ( t )$ (Fig. 2).
+
+Note that $A ^ { ( N ) }$ is then unitarily equivalent to $A ^ { ( D ) }$ , which preserves the stability and timescale [10] of the system.
+
+We define S4D-LegS to be the S4D method for this choice of diagonal $\boldsymbol { A } = \boldsymbol { A } ^ { ( D ) }$ . Theorem 3 explains the empirical results in [11] whereby this system performed quite close to S4, but was usually slightly worse. This is because DSS is a variant of S4D-LegS, which by Theorem 3 is a noisy approximation to S4-LegS. Fig. 2 illustrates this result, and also shows a curious phenomenon involving different discretization rules that is open for future work.
+
+S4D-Inv. To further simplify S4D-LegS, we analyze the structure of $A ^ { ( { D } ) } = \mathrm { d i a g } \langle { A } \rangle$ in more detail. The real part is easy to understand, which follows from the analysis in [9]: $\Re ( A ) = - { \frac { 1 } { 2 } } \mathbf { 1 }$ Let the imaginary part be sorted, i.e. ${ \mathfrak { T } } ( A ) _ { n }$ is the $n$ -th largest (positive) imaginary component. We empirically deduced the following conjecture for the asymptotics of the imaginary part.
+
+Conjecture 4. As $N \to \infty$ , $\begin{array} { r } { \mathfrak { I } ( A ) _ { 0 } \to \frac { 1 } { \pi } N ^ { 2 } + c } \end{array}$ where $c \approx 0 . 5 2 3 6$ is a constant. For a fixed $N$ , the other eigenvalues satisfy an inverse scaling in $n$ : ${ \mathfrak { I } } ( A ) _ { n } = \Theta ( n ^ { - 1 } )$ .
+
+Fig. 3 empirically supports this conjecture. Based on Conjecture 4, we propose the initialization S4D-Inv to use the following inverse-law diagonal matrix which closely approximates S4D-LegS.
+
+$$
+( \mathbf { S 4 D - I n v } ) \quad A _ { n } = - \frac { 1 } { 2 } + i \frac { N } { \pi } \left( \frac { N } { 2 n + 1 } - 1 \right)
+$$
+
+$$
+( { \bf S 4 D - L i n } ) { \cal A } _ { n } = - { \frac { 1 } { 2 } } + i \pi n
+$$
+
+S4D-Lin. While S4D-Inv can be seen as an approximation to the original S4-LegS, we propose an even simpler scaling law for the imaginary parts that can be seen as an approximation of S4-FouT ([10]), where the imaginary parts are simply the Fourier series frequencies (i.e. matches the diagonal part of the DPLR form of S4-FouT). Fig. 1 (Right) illustrates the S4D-Lin basis $e ^ { t A } B$ , which are simply damped Fourier basis functions.
+
+# 5 Experiments
+
+Our experimental study shows that S4D has strong performance in a wide variety of domains and tasks, including the well-studied Long Range Arena (LRA) benchmark where the best S4D variant is competitive with S4 on all tasks and significantly outperforms all non-SSM baselines.
+
+We begin with controlled ablations of the various representations of diagonal state space models. Sections 5.1 and 5.2 ablate the proposed methods for parameterizing, computing, and initializing diagonal SSMs from Sections 3 and 4. Section 5.3 show full results of larger models on standard benchmarks,
+
+Methodology and Datasets. In order to study the effects of different S4 and S4D variants in a controlled setting, we propose the following protocol. We focus on three datasets covering a varied range of data modalities (image pixels, biosignal time series, audio waveforms), sequence lengths (1K, 4K, 16K), and tasks (classification and regression with bidirectional and causal models).
+
+![](images/e0f425a9a6f91ef92e5888b66e9f01de7484c84ff419da63513ac97fe310637a.jpg)  
+Figure 2: (Visualization of Theorem 3). (a) The particular $( A , B )$ matrix chosen in S4 results in smooth basis functions $e ^ { t A } B$ with a closed form formula in terms of Legendre polynomials. By the HiPPO theory, convolving against these functions has a mathematical interpretation as orthogonalizing against an exponentially-decaying measure. (b, c) By special properties of this state matrix, removing the low-rank term of its NPLR representation produces the same basis functions as $N \to \infty$ , explaining the empirical effectiveness of DSS. (c) Curiously, the bilinear transform instead of ZOH smooths out the kernel to exactly match S4-LegS as $N$ grows.
+
+![](images/916b80494a8740caf35b2d9bf7b6fbcab8210e55f0455370fe8512183d9c2789.jpg)  
+Figure 3: (S4D eigenvalues.) All S4D methods have eigenvalues $- { \frac { 1 } { 2 } } + { \dot { \lambda } } _ { n } i$ . S4D-LegS theoretically approximates dynamics of the original (non-diagonal) S4 (Blue), and has eigenvalues following an inverse law $\lambda _ { n } \propto n ^ { - 1 }$ (Orange). The precise law is important: other scaling laws with the same range, including an inverse law with different constant (Purple) and a quadratic law (Red), perform empirically worse (Section 5.2). A very different linear law based on Fourier frequencies also performs well (Green).
+
+• Sequential CIFAR (sCIFAR). CIFAR-10 images are flattened into a sequence of length 1024, and a bidirectional sequence model is used to perform 10-way classification. • BIDMC Vital Signs. EKG and PPG signals of length 4000 are used to predict respiratory rate (RR), heart rate (HR), and blood oxygen saturation (SpO2). We focus on $\mathrm { S p O } 2$ in this study. • Speech Commands (SC).2 A 1-second raw audio waveform comprising 16000 samples is used for 35-way spoken word classification. We use an autoregressive (AR) model to vary the setting; this causal setting more closely imitates autoregressive speech generation, where SSMs have shown recent promise [5].
+
+We fix a simple architecture and training protocol that works generically. The architecture has 4 layers and hidden dimension $H = 1 2 8$ , resulting in $\sim 1 0 0 K$ parameters. All results are averaged over multiple seeds (full protocol and results including std. reported in Appendix B).
+
+# 5.1 Parameterization, Computation, Discretization
+
+Given the same diagonal SSM matrices $A , B$ , there are many variants of how to parameterize the matrices and compute the SSM kernel described in Section 3. We ablate the different choices described in Table 1. Results are in Table 2, and show that:
+
+(i) Computing the model with a softmax instead of Vandermonde product does not make much difference   
+(ii) Training $\textbf {  { B } }$ is consistently slightly better   
+(iii) Different discretizations (Section 3.1) do not make a noticeable difference   
+(iv) Unrestricting the real part of $\pmb { A }$ (Section 3.3) may be slightly better
+
+These ablations show that for a fixed initialization $( A , B )$ , different aspects of parameterizing SSMs make little difference overall. This justifies the parameterization and algorithm S4D uses (Section 3.4), which preserves the choices of the original S4 model and is simpler than DSS. For the remaining of the experiments in Section 5.2 and Section 5.3, we fix the S4D parameterization and algorithm described in Section 3. Note that this computes exactly the same kernel as the original S4 algorithm when the low-rank portion is set to 0, allowing controlled comparisons of the critical state matrix $\pmb { A }$ for the remainder of this section.
+
+<table><tr><td rowspan=1 colspan=1>Trainable B</td><td rowspan=1 colspan=1>Method</td><td rowspan=1 colspan=1>SCIFAR</td><td rowspan=1 colspan=1>SC (AR)</td><td rowspan=1 colspan=1>BIDMC (Sp02)</td></tr><tr><td rowspan=1 colspan=1>No</td><td rowspan=1 colspan=1>Softmax</td><td rowspan=1 colspan=1>85.04</td><td rowspan=1 colspan=1>89.80</td><td rowspan=1 colspan=1>0.1299</td></tr><tr><td rowspan=1 colspan=1>No</td><td rowspan=1 colspan=1>Vandermonde</td><td rowspan=1 colspan=1>84.78</td><td rowspan=1 colspan=1>89.62</td><td rowspan=1 colspan=1>0.1355</td></tr><tr><td rowspan=1 colspan=1>Yes</td><td rowspan=1 colspan=1>Softmax</td><td rowspan=1 colspan=1>85.37</td><td rowspan=1 colspan=1>90.06</td><td rowspan=1 colspan=1>0.1170</td></tr><tr><td rowspan=1 colspan=1>Yes</td><td rowspan=1 colspan=1>Vandermonde</td><td rowspan=1 colspan=1>85.37</td><td rowspan=1 colspan=1>90.34</td><td rowspan=1 colspan=1>0.1274</td></tr></table>
+
+Table 2: Ablations of different parameterizations of diagonal SSMs using S4D-Inv. (Left) trainability and computation; $( R i g h t )$ discretization and parameterization.   
+
+<table><tr><td rowspan=1 colspan=1>Discretization</td><td rowspan=1 colspan=1>RealpartofA</td><td rowspan=1 colspan=1>SCIFAR</td><td rowspan=1 colspan=1>SC (AR)</td><td rowspan=1 colspan=1>BIDMC (Sp02)</td></tr><tr><td rowspan=1 colspan=1>Bitinear</td><td rowspan=1 colspan=1>exp</td><td rowspan=1 colspan=1>85.20</td><td rowspan=1 colspan=1>89.52</td><td rowspan=1 colspan=1>0.1193</td></tr><tr><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>ReLU</td><td rowspan=1 colspan=1>85.06</td><td rowspan=1 colspan=1>90.22</td><td rowspan=1 colspan=1>0.1172</td></tr><tr><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>-</td><td rowspan=1 colspan=1>85.35</td><td rowspan=1 colspan=1>90.58</td><td rowspan=1 colspan=1>0.1102</td></tr><tr><td rowspan=1 colspan=1>ZOH</td><td rowspan=1 colspan=1>exp</td><td rowspan=1 colspan=1>85.02</td><td rowspan=1 colspan=1>89.93</td><td rowspan=1 colspan=1>0.1303</td></tr><tr><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>ReLU</td><td rowspan=1 colspan=1>84.98</td><td rowspan=1 colspan=1>90.03</td><td rowspan=1 colspan=1>0.1232</td></tr><tr><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>-</td><td rowspan=1 colspan=1>85.15</td><td rowspan=1 colspan=1>90.19</td><td rowspan=1 colspan=1>0.1289</td></tr></table>
+
+# 5.2 S4D Initialization Ablations
+
+The original S4 model proposed a specific formula for the $\pmb { A }$ matrix, and the first diagonal version [11] used a specific matrix based on it. Our new proposed variants S4D-Inv and S4D-Lin also define precise formulas for the initialization of the $\pmb { A }$ matrix (8). This raises the question of whether the initialization of the $\pmb { A }$ still needs to be so precise, despite the large simplifications from the original version. We perform several natural ablations on these initializations, showing that even simple variations of the precise formula can degrade performance.
+
+Imaginary part scaling factor. The scaling rules for the imaginary parts of S4D-Inv and S4D-Lin are simple polynomial laws, but how is the constant factor chosen and how important is it? These constants are based on approximations to HiPPO methods (e.g. Conjecture 4). Note that the range of imaginary components for S4D-Inv and S4D-Lin are quite different (Fig. 3); the largest imaginary part is N 2 for S4D-Inv and $\pi N$ for S4D-Lin.
+
+We consider scaling all imaginary parts by a constant factor of 0.01 or 100.0 to investigate whether the constant matters. Note that this preserves the overall shape of the basis functions (Fig. 1, dashed lines) and simply changes the frequencies, and it is not obvious that this should degrade performance. However, both changes substantially reduce the performance of S4D in all settings.
+
+Randomly initialized imaginary part. Next, we consider choosing the imaginary parts randomly. For S4D-Inv, we keep the real parts equal to $- \frac 1 2$ and set each imaginary component to $\begin{array} { r } { A _ { n } = - \frac { 1 } { 2 } + i \frac { N } { \pi } \big ( \frac { N } { 2 u + 1 } - 1 \big ) } \end{array}$ for $u \sim N { \cdot } \mathcal { U } [ 0 , 1 ]$ . Note that when $u$ is equally spaced in [0, 1] instead of uniformly random, this exactly recovers S4D-Inv (8), so this is a sensible random approximation to it.
+
+Similarly, we consider a variant of S4D-Lin that replaces the $n$ in (9) with $N \cdot \mathcal { U } [ 0 , 1 ]$ .
+
+Table 3a (Random Imag) shows that this small change causes minor degradation in performance. We additionally note that the randomly initialized imaginary ablation can be interpreted as follows. Fig. 3 shows the asymptotics of the imaginary parts of SSM matrices, where the imaginary parts of the eigenvalues correspond to y-values corresponding to uniformly spaced nodes on the $\mathbf { X }$ -axis. This ablation then replaces the uniform spacing on the $\mathbf { X }$ -axis with uniformly random $\mathbf { X }$ values.
+
+# Randomly initialized real part.
+
+We considering initializing the real part of each eigenvalue as $- \mathscr { U } [ 0 , 1 ]$ instead of fixing them to $- \frac 1 2$ . Table 3a(Left, Random Real) shows that this also causes minor but consistent degradation in performance on the ablation datasets. Finally, we also consider randomizing both real and imaginary parts, which degrades performance even further.
+
+# Ablation: Other S4D matrices.
+
+Other simple variants of initializations show that it is not just the range of the eigenvalues but the actual distribution that is important (Fig. 3). Both S4D-Inv2 and S4D-Quad have real part $- \frac 1 2$ and imaginary part satisfying the same maximum value as Conjecture 4. The S4D-Inv2 initialization uses the same formula as S4D-Inv, but replaces a $2 n + 1$ in the denominator with $n + 1$ . The S4D-Quad initialization uses a polynomial law with power 2 instead of $- 1$ (S4D-Inv) or 1 (S4D-Lin).
+
+We include two additional methods here that are not based on the proposed S4D-Inv or S4D-Lin methods. First, S4D-Rand uses a randomly initialized diagonal $\pmb { A }$ , and validates that it performs (b) Results for all S4 and S4D methods on the ablation datasets, when the $\pmb { A }$ and $_ B$ matrices are either frozen $( T o p )$ or trained (Bottom). Diagonal state matrices are highly competitive with full DPLR versions, achieving strong results on all datasets.
+
+<table><tr><td>Ablation</td><td>sCIFAR</td><td>SC (AR)</td><td>BIDMC</td></tr><tr><td>S4D-Lin</td><td>85.12</td><td>90.66</td><td>0.128</td></tr><tr><td>Scale 0.01</td><td>-7.27</td><td>-1.92</td><td>+0.040</td></tr><tr><td>Scale 100</td><td>-7.91</td><td>-4.04</td><td>+0.077</td></tr><tr><td>Random Imag</td><td>-0.42</td><td>-3.08</td><td>-0.001</td></tr><tr><td>Random Real</td><td>-0.73</td><td>-0.87</td><td>+0.011</td></tr><tr><td>Random Both</td><td>-1.28</td><td>-5.88</td><td>+0.007</td></tr></table>
+
+Table 3: (Initialization and Trainability ablations)   
+
+<table><tr><td rowspan=2 colspan=3>Frozen (A,B)</td><td rowspan=1 colspan=2>SCIFAR</td><td rowspan=1 colspan=2>SC (AR)</td><td rowspan=1 colspan=1>BIDMC</td></tr><tr><td rowspan=1 colspan=2>Acc (first) Acc (best)</td><td rowspan=1 colspan=2>Acc (first) Acc (best)</td><td rowspan=1 colspan=1>RMSE (best)</td></tr><tr><td rowspan=4 colspan=3>S4-LegSS4-LegTS4-FouTS4-LegS+FouT</td><td rowspan=1 colspan=1>53.63</td><td rowspan=1 colspan=1>86.19</td><td rowspan=1 colspan=2>33.87    85.33</td><td rowspan=1 colspan=1>0.1049</td></tr><tr><td rowspan=1 colspan=1>54.76</td><td rowspan=1 colspan=1>86.30</td><td rowspan=1 colspan=2>8.77    57.35</td><td rowspan=1 colspan=1>0.1106</td></tr><tr><td rowspan=1 colspan=1>55.28</td><td rowspan=1 colspan=1>86.05</td><td rowspan=1 colspan=1>9.27</td><td rowspan=1 colspan=1>69.57</td><td rowspan=1 colspan=1>0.1072</td></tr><tr><td rowspan=1 colspan=1>T</td><td rowspan=1 colspan=1>54.38</td><td rowspan=1 colspan=1>86.53</td><td rowspan=1 colspan=1>34.06</td><td rowspan=1 colspan=1>83.37</td><td rowspan=1 colspan=1>0.0887</td></tr><tr><td rowspan=1 colspan=2>S4D-LegS</td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>50.87</td><td rowspan=1 colspan=1>84.81</td><td rowspan=1 colspan=1>22.76</td><td rowspan=1 colspan=1>77.18</td><td rowspan=1 colspan=1>0.0960</td></tr><tr><td rowspan=1 colspan=2>S4D-Inv</td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>53.19</td><td rowspan=1 colspan=1>84.40</td><td rowspan=1 colspan=1>18.49</td><td rowspan=1 colspan=1>76.53</td><td rowspan=1 colspan=1>0.0995</td></tr><tr><td rowspan=1 colspan=3>S4D-Lin</td><td rowspan=1 colspan=1>51.75</td><td rowspan=1 colspan=1>84.96</td><td rowspan=1 colspan=1>19.09</td><td rowspan=1 colspan=1>75.58</td><td rowspan=1 colspan=1>0.0935</td></tr></table>
+
+<table><tr><td rowspan=1 colspan=1>S4D-Inv</td><td rowspan=1 colspan=1>84.79</td><td rowspan=1 colspan=1>90.27</td><td rowspan=1 colspan=1>0.114</td></tr><tr><td rowspan=1 colspan=1>Scale 0.01</td><td rowspan=1 colspan=1>-5.03</td><td rowspan=1 colspan=1>-0.08</td><td rowspan=2 colspan=1>+0.028+0.034</td></tr><tr><td rowspan=1 colspan=1>Scale 100</td><td rowspan=1 colspan=1>-7.77</td><td rowspan=1 colspan=1>-52.31</td></tr><tr><td rowspan=1 colspan=1>Random Imag</td><td rowspan=1 colspan=1>-0.29</td><td rowspan=1 colspan=1>-0.52</td><td rowspan=1 colspan=1>+0.010</td></tr><tr><td rowspan=1 colspan=1>Random Real</td><td rowspan=1 colspan=1>0.12</td><td rowspan=1 colspan=1>-2.18</td><td rowspan=2 colspan=1>+0.032+0.024</td></tr><tr><td rowspan=1 colspan=1>Random Both</td><td rowspan=1 colspan=1>-1.55</td><td rowspan=1 colspan=1>-0.55</td></tr><tr><td rowspan=1 colspan=1>S4D-Inv2</td><td rowspan=1 colspan=1>-2.62</td><td rowspan=1 colspan=1>-39.84</td><td rowspan=1 colspan=1>+0.005</td></tr><tr><td rowspan=1 colspan=1>S4D-Quad</td><td rowspan=1 colspan=1>-1.83</td><td rowspan=1 colspan=1>-0.62</td><td rowspan=1 colspan=1>+0.024</td></tr><tr><td rowspan=1 colspan=1>S4D-Random</td><td rowspan=1 colspan=1>-6.32</td><td rowspan=1 colspan=1>-1.95</td><td rowspan=1 colspan=1>+0.034</td></tr><tr><td rowspan=1 colspan=1>S4D-Real</td><td rowspan=1 colspan=1>-5.45</td><td rowspan=1 colspan=1>-10.17</td><td rowspan=1 colspan=1>+0.066</td></tr></table>
+
+(a) Ablations of the initialization of the diagonal $\pmb { A }$ matrix in S4D. Very simple changes that largely preserve the structure of the diagonal eigenvalues all degrade performance.
+
+Trainable (A, B)   
+
+<table><tr><td rowspan=4 colspan=1>S4-LegSS4-LegTS4-FouTS4-LegS+FouT</td><td rowspan=1 colspan=1>54.23</td><td rowspan=1 colspan=1>86.29</td><td rowspan=1 colspan=1>62.19</td><td rowspan=1 colspan=1>90.68</td><td rowspan=1 colspan=1>0.1033</td></tr><tr><td rowspan=1 colspan=1>55.16</td><td rowspan=1 colspan=1>86.12</td><td rowspan=1 colspan=1>55.86</td><td rowspan=1 colspan=1>90.42</td><td rowspan=1 colspan=1>0.1146</td></tr><tr><td rowspan=1 colspan=1>55.89</td><td rowspan=1 colspan=1>85.93</td><td rowspan=1 colspan=1>60.56</td><td rowspan=1 colspan=1>90.83</td><td rowspan=1 colspan=1>0.1136</td></tr><tr><td rowspan=1 colspan=1>55.00</td><td rowspan=1 colspan=1>86.18</td><td rowspan=1 colspan=1>61.76</td><td rowspan=1 colspan=1>91.01</td><td rowspan=1 colspan=1>0.0970</td></tr><tr><td rowspan=3 colspan=1>S4D-LegSS4D-InvS4D-Lin</td><td rowspan=1 colspan=1>50.41</td><td rowspan=1 colspan=1>85.64</td><td rowspan=1 colspan=1>47.54</td><td rowspan=1 colspan=1>88.47</td><td rowspan=1 colspan=1>0.1148</td></tr><tr><td rowspan=1 colspan=1>53.42</td><td rowspan=1 colspan=1>84.59</td><td rowspan=1 colspan=1>45.73</td><td rowspan=1 colspan=1>89.69</td><td rowspan=1 colspan=1>0.1132</td></tr><tr><td rowspan=1 colspan=1>52.23</td><td rowspan=1 colspan=1>85.75</td><td rowspan=1 colspan=1>47.68</td><td rowspan=1 colspan=1>89.56</td><td rowspan=1 colspan=1>0.1032</td></tr></table>
+
+poorly, in line with earlier findings [9, 11]. Second, S4D-Real uses a particular real initialization with $A _ { n } = - ( n + 1 )$ . This is the exact same spectrum as the original S4(-LegS) method, which validates that it is not just the diagonalization that matters, highlighting the limitations of Proposition 2.
+
+# 5.3 Full Comparisons of S4D and S4 Methods
+
+# Trainable $A , B$ matrices.
+
+Table 3b shows the performance of all S4D and S4 variants [10] on the ablations datasets. We observe several interesting phenomena:
+
+(i) Freezing the matrices performs comparably to training them on sCIFAR and BIDMC, but is substantially worse on SC. We hypothesize that this results from $\Delta$ being poorly initialized for SC, so that at initialization models do not have context over the entire sequence, and training $\pmb { A }$ and $\textbf {  { B } }$ helps adjust for this. As further evidence, the finite window methods S4-LegT and S4-FouT (defined in [10]) have the most limited context and suffer the most when $\pmb { A }$ is frozen.   
+(ii) The full DPLR versions are often slightly better than the diagonal version throughout the entire training curve. We report the validation accuracy after 1 epoch of training on sCIFAR and SC to illustrate this phenomenon. Note that this is not a consequence of having more parameters (Appendix B).
+
+# Large models on ablation datasets.
+
+Finally, we relax the strict requirements on model size and regularization for the ablation datasets, and show the performance of S4 and S4D variants on the test sets with a larger model (architecture and training details in Appendix B) when the model size and regularization is simply increased (Table 4). We note that results for each dataset are better than the original S4 model, which was already state-of-the-art on these datasets [8, 9].
+
+# Long Range Arena.
+
+We use the same hyperparameter setting for the state-of-the-art S4 model in [10] on the Long Range Arena benchmark for testing long dependencies in sequence models. S4D variants are highly competitive on all datasets except Path-X, and outperform the S4 variants on several of them. On Path-X using this hyperparameter setting with bidirectional models, only S4D-Inv, our simpler approximation to the original S4-LegS model, achieves above random chance, and has an average of $8 5 \%$ on the full LRA suite, more than 30 points better than the original Transformer [24].
+
+Table 4: (Ablation datasets: Full results with larger models.) For Speech Commands, we show both an autoregressive model as in the ablations, and an unconstrained bidirectional model.   
+
+<table><tr><td rowspan="3">MODEL</td><td>SCIFAR</td><td colspan="2">SC</td><td colspan="3">BIDMC</td></tr><tr><td>TEST</td><td>AR</td><td>B1.</td><td>HR</td><td>RR</td><td>SPO2</td></tr><tr><td>S4-LegS</td><td>91.80 (0.43)</td><td>93.60 (0.13)</td><td>96.08 (0.15)</td><td>0.332 (0.013)</td><td>0.247 (0.062)</td><td>0.090 (0.006)</td></tr><tr><td>S4-FouT</td><td>91.22 (0.25)</td><td>91.78 (0.10)</td><td>95.27 (0.20)</td><td>0.339 (0.020)</td><td>0.301 (0.030)</td><td>0.068 (0.003)</td></tr><tr><td>S4D-LegS</td><td>89.92 (1.69)</td><td>93.57 (0.09)</td><td>95.83 (0.14)</td><td>0.367 (0.001)</td><td>0.248 (0.036)</td><td>0.102 (0.001)</td></tr><tr><td>S4D-Inv</td><td>90.69 (0.06)</td><td>93.40 (0.67)</td><td>96.18 (0.27)</td><td>0.373 (0.024)</td><td>0.254 (0.022)</td><td>0.110 (0.001)</td></tr><tr><td>S4D-Lin</td><td>90.42 (0.03)</td><td>93.37 (0.05)</td><td>96.25 (0.03)</td><td>0.379 (0.006)</td><td>0.226 (0.008)</td><td>0.114 (0.003)</td></tr></table>
+
+Table 5: (Long Range Arena) Accuracy on full suite of LRA tasks. Hyperparameters in Appendix B.   
+
+<table><tr><td>MODEL</td><td>LISTOPS</td><td>TEXT</td><td>RETRIEVAL</td><td>IMAGE</td><td>PATHFINDER</td><td>PATH-X</td><td>AVG</td></tr><tr><td>S4-LegS</td><td>59.60 (0.07)</td><td>86.82 (0.13)</td><td>90.90 (0.15)</td><td>88.65 (0.23)</td><td>94.20 (0.25)</td><td>96.35</td><td>86.09</td></tr><tr><td>S4-FouT</td><td>57.88 (1.90)</td><td>86.34 (0.31)</td><td>89.66 (0.88)</td><td>89.07 (0.19)</td><td>94.46 (0.24)</td><td>X</td><td>77.90</td></tr><tr><td>S4D-LegS</td><td>60.47 (0.34)</td><td>86.18 (0.43)</td><td>89.46 (0.14)</td><td>88.19 (0.26)</td><td>93.06 (1.24)</td><td>91.95</td><td>84.89</td></tr><tr><td>S4D-Inv</td><td>60.18 (0.35)</td><td>87.34 (0.20)</td><td>91.09 (0.01)</td><td>87.83 (0.37)</td><td>93.78 (0.25)</td><td>92.80</td><td>85.50</td></tr><tr><td>S4D-Lin</td><td>60.52 (0.51)</td><td>86.97 (0.23)</td><td>90.96 (0.09)</td><td>87.93 (0.34)</td><td>93.96 (0.60)</td><td>X</td><td>78.39</td></tr><tr><td>S4 (original)</td><td>58.35</td><td>76.02</td><td>87.09</td><td>87.26</td><td>86.05</td><td>88.10</td><td>80.48</td></tr><tr><td>Transformer</td><td>36.37</td><td>64.27</td><td>57.46</td><td>42.44</td><td>71.40</td><td>X</td><td>53.66</td></tr></table>
+
+# 6 Conclusion
+
+State space models based on S4 are a promising family of models for modeling many types of sequential data, with particular strengths for continuous signals and long-range interactions. These models are a large departure from conventional sequence models such as RNNs, CNNs, and Transformers, with many new ideas and moving parts. This work provides a more in-depth exposition for all aspects of working with S4-style models, from their core structures and kernel computation algorithms, to miscellaneous choices in their parameterizations, to new theory and methods for their initialization. We systematically analyzed and ablated each of these components, and provide recommendations for building a state space model that is as simple as possible, while as theoretically principled and empirically effective as S4. We believe that S4D can be a strong generic sequence model for a variety of domains, that opens new directions for state space models theoretically, and is much more practical to understand and implement for practitioners.
+
+# Acknowledgments
+
+We gratefully acknowledge the support of DARPA under Nos. FA86501827865 (SDH) and FA86501827882 (ASED); NIH under No. U54EB020405 (Mobilize), NSF under Nos. CCF1763315 (Beyond Sparsity), CCF1563078 (Volume to Velocity), and 1937301 (RTML); ONR under No. N000141712266 (Unifying Weak Supervision); the Moore Foundation, NXP, Xilinx, LETI-CEA, Intel, IBM, Microsoft, NEC, Toshiba, TSMC, ARM, Hitachi, BASF, Accenture, Ericsson, Qualcomm, Analog Devices, the Okawa Foundation, American Family Insurance, Google Cloud, Swiss Re, Brown Institute for Media Innovation, Department of Defense (DoD) through the National Defense Science and Engineering Graduate Fellowship (NDSEG) Program, Fannie and John Hertz Foundation, National Science Foundation Graduate Research Fellowship Program, Texas Instruments, and members of the Stanford DAWN project: Teradata, Facebook, Google, Ant Financial, NEC, VMWare, and Infosys. The U.S. Government is authorized to reproduce and distribute reprints for Governmental purposes notwithstanding any copyright notation thereon. Any opinions, findings, and conclusions or recommendations expressed in this material are those of the authors and do not necessarily reflect the views, policies, or endorsements, either expressed or implied, of DARPA, NIH, ONR, or the U.S. Government.
+
+References   
+[1] Jimmy Lei Ba, Jamie Ryan Kiros, and Geoffrey E Hinton. Layer normalization. arXiv preprint arXiv:1607.06450, 2016.   
+[2] Shaojie Bai, J Zico Kolter, and Vladlen Koltun. Trellis networks for sequence modeling. In The International Conference on Learning Representations (ICLR), 2019.   
+[3] Yann N Dauphin, Angela Fan, Michael Auli, and David Grangier. Language modeling with gated convolutional networks. In International conference on machine learning, pages 933–941. PMLR, 2017.   
+[4] N Benjamin Erichson, Omri Azencot, Alejandro Queiruga, Liam Hodgkinson, and Michael W Mahoney. Lipschitz recurrent neural networks. In International Conference on Learning Representations, 2021.   
+[5] Karan Goel, Albert Gu, Chris Donahue, and Christopher Re. It’s raw! audio generation with ´ state-space models. In The International Conference on Machine Learning (ICML), 2022.   
+[6] Albert Gu, Tri Dao, Stefano Ermon, Atri Rudra, and Christopher Re. Hippo: Recurrent memory ´ with optimal polynomial projections. In Advances in Neural Information Processing Systems (NeurIPS), 2020.   
+[7] Albert Gu, Caglar Gulcehre, Tom Le Paine, Matt Hoffman, and Razvan Pascanu. Improving the gating mechanism of recurrent neural networks. In The International Conference on Machine Learning (ICML), 2020. [8] Albert Gu, Isys Johnson, Karan Goel, Khaled Saab, Tri Dao, Atri Rudra, and Christopher Re.´ Combining recurrent, convolutional, and continuous-time models with the structured learnable linear state space layer. In Advances in Neural Information Processing Systems (NeurIPS), 2021.   
+[9] Albert Gu, Karan Goel, and Christopher Re. Efficiently modeling long sequences with structured ´ state spaces. In The International Conference on Learning Representations (ICLR), 2022.   
+[10] Albert Gu, Isys Johnson, Aman Timalsina, Atri Rudra, and Christopher Re. How to train your ´ hippo: State space models with generalized basis projections. arXiv preprint arXiv:2206.12037, 2022.   
+[11] Ankit Gupta. Diagonal state spaces are as effective as structured state spaces. In Advances in Neural Information Processing Systems (NeurIPS), 2022.   
+[12] Sepp Hochreiter and Jurgen Schmidhuber. Long short-term memory. ¨ Neural computation, 9(8): 1735–1780, 1997.   
+[13] Sergey Ioffe and Christian Szegedy. Batch normalization: Accelerating deep network training by reducing internal covariate shift. In International conference on machine learning, pages 448–456. PMLR, 2015.   
+[14] Patrick Kidger, James Morrill, James Foster, and Terry Lyons. Neural controlled differential equations for irregular time series. arXiv preprint arXiv:2005.08926, 2020.   
+[15] James Morrill, Cristopher Salvi, Patrick Kidger, James Foster, and Terry Lyons. Neural rough differential equations for long time series. The International Conference on Machine Learning (ICML), 2021.   
+[16] Naoki Nonaka and Jun Seita. In-depth benchmarking of deep neural network architectures for ecg diagnosis. In Machine Learning for Healthcare Conference, pages 414–439. PMLR, 2021.   
+[17] Victor Pan. Structured matrices and polynomials: unified superfast algorithms. Springer Science & Business Media, 2001.   
+[18] Anthony Ralston and Philip Rabinowitz. A first course in numerical analysis. Courier Corporation, 2001.
+
+[19] David W Romero, Anna Kuzina, Erik J Bekkers, Jakub M Tomczak, and Mark Hoogendoorn. Ckconv: Continuous kernel convolution for sequential data. arXiv preprint arXiv:2102.02611, 2021.
+
+[20] David W Romero, Robert-Jan Bruintjes, Jakub M Tomczak, Erik J Bekkers, Mark Hoogendoorn, and Jan C van Gemert. Flexconv: Continuous kernel convolutions with differentiable kernel sizes. In The International Conference on Learning Representations (ICLR), 2022.
+
+[21] T Konstantin Rusch and Siddhartha Mishra. Unicornn: A recurrent model for learning very long time dependencies. The International Conference on Machine Learning (ICML), 2021.
+
+[22] Noam Shazeer. Glu variants improve transformer. arXiv preprint arXiv:2002.05202, 2020.
+
+[23] Chang Wei Tan, Christoph Bergmeir, Francois Petitjean, and Geoffrey I Webb. Time series extrinsic regression. Data Mining and Knowledge Discovery, pages 1–29, 2021. doi: https: //doi.org/10.1007/s10618-021-00745-9.
+
+[24] Yi Tay, Mostafa Dehghani, Samira Abnar, Yikang Shen, Dara Bahri, Philip Pham, Jinfeng Rao, Liu Yang, Sebastian Ruder, and Donald Metzler. Long range arena : A benchmark for efficient transformers. In International Conference on Learning Representations, 2021. URL https://openreview.net/forum?id $=$ qVyeW-grC2k.
+
+[25] Trieu H Trinh, Andrew M Dai, Minh-Thang Luong, and Quoc V Le. Learning longer-term dependencies in RNNs with auxiliary losses. In The International Conference on Machine Learning (ICML), 2018.
+
+[26] Aaron Voelker, Ivana Kajic, and Chris Eliasmith. Legendre memory units: Continuous-time ´ representation in recurrent neural networks. In Advances in Neural Information Processing Systems, pages 15544–15553, 2019.
+
+# Checklist
+
+1. For all authors...
+
+(a) Do the main claims made in the abstract and introduction accurately reflect the paper’s contributions and scope? [Yes]   
+(b) Did you describe the limitations of your work? [Yes] See Section 5, e.g. not matching the baseline S4 on Path-X.   
+(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? [Yes] (b) Did you include complete proofs of all theoretical results? [Yes] See Appendix 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] The code is a simple modification from the original S4 [9] repository and is publicly available.   
+(b) Did you specify all the training details (e.g., data splits, hyperparameters, how they were chosen)? [Yes] See Appendix B.   
+(c) Did you report error bars (e.g., with respect to the random seed after running experiments multiple times)? [Yes] See the Appendix.   
+(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] The experiment code and configs are publically available with resource and timing information reported.
+
+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? [No]   
+(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] We used standard benchmarks and synthetic 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/yJE7iQSAep/yJE7iQSAep_content_list.json

@@ -0,0 +1,1677 @@
+[
+    {
+        "type": "text",
+        "text": "On the Parameterization and Initialization of Diagonal State Space Models ",
+        "text_level": 1,
+        "bbox": [
+            227,
+            122,
+            774,
+            172
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Albert $\\mathbf { G u } ^ { \\dagger }$ , Ankit Gupta‡, Karan Goel†, Christopher Re´† ",
+        "bbox": [
+            289,
+            223,
+            691,
+            239
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "† Department of Computer Science, Stanford University ‡ IBM Research   \n{albertgu,knrg}@stanford.edu, chrismre@cs.stanford.edu ankitgupta.iitkanpur@gmail.com ",
+        "bbox": [
+            294,
+            242,
+            704,
+            296
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Abstract ",
+        "text_level": 1,
+        "bbox": [
+            462,
+            332,
+            535,
+            348
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "State space models (SSM) have recently been shown to be very effective as a deep learning layer as a promising alternative to sequence models such as RNNs, CNNs, or Transformers. The first version to show this potential was the S4 model, which is particularly effective on tasks involving long-range dependencies by using a prescribed state matrix called the HiPPO matrix. While this has an interpretable mathematical mechanism for modeling long dependencies, it introduces a custom representation and algorithm that can be difficult to implement. On the other hand, a recent variant of S4 called DSS showed that restricting the state matrix to be fully diagonal can still preserve the performance of the original model when using a specific initialization based on approximating S4’s matrix. This work seeks to systematically understand how to parameterize and initialize such diagonal state space models. While it follows from classical results that almost all SSMs have an equivalent diagonal form, we show that the initialization is critical for performance. We explain why DSS works mathematically, by showing that the diagonal restriction of S4’s matrix surprisingly recovers the same kernel in the limit of infinite state dimension. We also systematically describe various design choices in parameterizing and computing diagonal SSMs, and perform a controlled empirical study ablating the effects of these choices. Our final model S4D is a simple diagonal version of S4 whose kernel computation requires just 2 lines of code and performs comparably to S4 in almost all settings, with state-of-the-art results for image, audio, and medical time-series domains, and averaging $8 5 \\%$ on the Long Range Arena benchmark. ",
+        "bbox": [
+            233,
+            363,
+            764,
+            660
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 Introduction ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            686,
+            310,
+            703
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "A core class of models in modern deep learning are sequence models, which are parameterized mappings operating on arbitrary sequences of inputs. Recent approaches based on state space models (SSMs) have outperformed traditional deep sequence models such as recurrent neural networks (RNNs), convolutional neural networks (CNNs), and Transformers, in both computational efficiency and modeling ability. In particular, the S4 model displayed strong results on a range of sequence modeling tasks, especially on long sequences [9]. Its ability to model long-range dependencies arises from being defined with a particular state matrix called the “HiPPO matrix” [6], which allows S4 to be viewed as a convolutional model that decomposes an input onto an orthogonal system of smooth basis functions[10]. ",
+        "bbox": [
+            174,
+            717,
+            825,
+            839
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "However, beyond its theoretical interpretation, actually computing S4 as a deep learning model requires a sophisticated algorithm with many linear algebraic techniques that are difficult to understand and implement. These techniques were necessitated by parameterizing its state matrix as a diagonal plus low-rank (DPLR) matrix, which is necessary to capture HiPPO matrices. A natural question is whether simplifications of this parameterization and algorithm are possible. In particular, removing the low-rank term would result in a diagonal state space model (diagonal SSM) that is dramatically simpler to implement and understand. ",
+        "bbox": [
+            174,
+            844,
+            823,
+            898
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "image",
+        "img_path": "images/27c8f33e4d7cf53989b9f9b74e4bb545cac85e1e89d3a410409b423d17fd5b4e.jpg",
+        "image_caption": [
+            "Figure 1: S4D is a diagonal SSM which inherits the strengths of S4 while being much simpler. (Left) The diagonal structure allows it to be viewed as a collection of 1-dimensional SSMs. (Right) As a convolutional model, S4D has a simple interpretable convolution kernel which can be implemented in two lines of code. Colors denote independent 1-D SSMs; purple denotes trainable parameters. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            173,
+            88,
+            807,
+            295
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            176,
+            378,
+            820,
+            420
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Although it is known that almost all SSMs have an equivalent diagonal form—and therefore (complex) diagonal SSMs are fully expressive algebraically—they may not represent all SSMs numerically, and finding a good initialization is critical. Gu et al. [9] showed that it is difficult to find a performant diagonal SSM, and that many alternative parameterizations of the state matrix – including by random diagonal matrices – are much less effective empirically, which motivated the necessity of the more complicated HiPPO matrix. However, recently Gupta [11] made the empirical observation that a variant of S4 using a particular diagonal matrix is nearly as effective as the original S4 method. This matrix is based on the original HiPPO matrix and is defined by simply chopping off the low-rank term in the DPLR representation. ",
+        "bbox": [
+            173,
+            424,
+            825,
+            547
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "The discovery of performant diagonal state matrices opens up new possibilities for simplifying deep state space models, and consolidating models such as S4 and DSS to understand and improve them. First, the strongest version of DSS computes the SSM with a complex-valued softmax that complicates the algorithm, and is actually less efficient than S4. Additionally, DSS and S4 differ in several auxiliary aspects of parameterizing SSMs that can conflate performance effects, making it more difficult to isolate the core effects of diagonal versus DPLR state matrices. Most importantly, DSS relies on initializing the state matrix to a particular approximation of S4’s HiPPO matrix. While S4’s matrix has a mathematical interpretation for addressing long-range dependencies, the efficacy of the diagonal approximation to it remains theoretically unexplained. ",
+        "bbox": [
+            174,
+            553,
+            825,
+            674
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "In this work, we seek to systematically understand how to train diagonal SSMs. We introduce the S4D method, a diagonal SSM which combines the best of S4’s computation and parameterization and DSS’s initialization, resulting in a method that is extremely simple, theoretically princpled, and empirically effective. ",
+        "bbox": [
+            174,
+            679,
+            825,
+            734
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "• First, we describe S4D, a simple method outlined by S4 for computing diagonal instead of DPLR matrices, which is based on Vandermonde matrix multiplication and is even simpler and more efficient than the DSS. Outside of the core state matrix, we categorize different representations of the other components of SSMs, introducing flexible design choices that capture both S4 and DSS and allow different SSM parameterizations to be systematically compared (Section 3). • We provide a new mathematical analysis of DSS’s initialization, showing that the diagonal approximation of the original HiPPO matrix surprisingly produces the same dynamics as S4 when the state size goes to infinity. We propose even simpler variants of diagonal SSMs using different initializations of the state matrix (Section 4). • We perform a controlled study of these various design choices across many domains, tasks, and sequence lengths, and additionally compare diagonal (S4D) versus DPLR (S4) variants. Our best S4D methods are competitive with S4 on almost all settings, with near state-of-the-art results on image, audio, and medical time series benchmarks, and achieving $85 \\%$ on the Long Range Arena benchmark (Section 5). ",
+        "bbox": [
+            173,
+            743,
+            826,
+            911
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            183,
+            90,
+            823,
+            119
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "2 Background ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            137,
+            310,
+            155
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Continuous State Spaces Models S4 investigated state space models (1) that are parameterized maps on signals $u ( t ) \\mapsto y ( t )$ . These SSMs are linear time-invariant systems that can be represented either as a linear ODE (equation (1)) or convolution (equation (2)). ",
+        "bbox": [
+            173,
+            167,
+            826,
+            209
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/25b4f008b0317bf0dacbb33f4472b2e5d4501ba60d3cbbaa33df480b596032c1.jpg",
+        "text": "$$\n\\begin{array} { c c } { { x ^ { \\prime } ( t ) = A x ( t ) + B u ( t ) ~ } } & { { ~ ( 1 ) ~ } } \\\\ { { y ( t ) = C x ( t ) ~ } } & { { ~ y ( t ) = ( K * u ) ( t ) } } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            254,
+            213,
+            732,
+            252
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Here the parameters are the state matrix $ { \\boldsymbol { A } } \\in \\mathbb { C } ^ { N \\times N }$ and other matrices $\\boldsymbol { B } \\in \\mathbb { C } ^ { N \\times 1 }$ , $\\boldsymbol { C } \\in \\mathbb { C } ^ { 1 \\times N }$ . In the case of diagonal SSMs, $\\pmb { A }$ is diagonal and we will overload notation so that $A _ { n } , B _ { n } , C _ { n }$ denotes the entries of the parameters. ",
+        "bbox": [
+            174,
+            253,
+            826,
+            297
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "An intuitive way to view the convolution kernel (2) is to interpret it as a linear combination (controlled by $C$ ) of basis kernels $K _ { n } ( t )$ (controlled by $A , B )$ ",
+        "bbox": [
+            171,
+            301,
+            823,
+            330
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/618c93cfc589bb3a7d999b684b012775e93c3b81d3526b94e3a6188a6467c529.jpg",
+        "text": "$$\nK ( t ) = \\sum _ { n = 0 } ^ { N - 1 } C _ { n } K _ { n } ( t ) \\qquad K _ { n } ( t ) : = e _ { n } ^ { \\top } e ^ { t A } B\n$$",
+        "text_format": "latex",
+        "bbox": [
+            326,
+            337,
+            673,
+            381
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "We denote this basis as $K ( t ) = K _ { A , B } ( t ) = e ^ { t A } B$ if necessary to disambiguate; note that it is a vector of $N$ functions. In the case of diagonal SSMs, each function $K _ { n } ( t )$ is just $e ^ { t A _ { n } } B _ { n }$ . ",
+        "bbox": [
+            171,
+            388,
+            825,
+            420
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "S4: Structured State Spaces As a deep learning model, SSMs have many elegant properties with concrete empirical and computational benefits [8]. For example, the convolutional form (2) can be converted into a temporal recurrence that is substantially faster for autoregressive applications [5]. ",
+        "bbox": [
+            174,
+            433,
+            825,
+            474
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "However, making SSMs effective required overcoming two key challenges: choosing appropriate values for the matrices, and computing the kernel (2) efficiently. ",
+        "bbox": [
+            173,
+            479,
+            823,
+            507
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "First, Gu et al. [8] showed that naive instantiations of the SSM do not perform well, and instead relied on a particular (real-valued) matrix $\\pmb { A }$ called the HiPPO-LegS matrix (4).1 These matrices were derived so that the basis kernels $K _ { n } ( t )$ have closed-form formulas $L _ { n } ( e ^ { - t } )$ , where $L _ { n } ( t )$ are normalized Legendre polynomials. Consequently, the SSM has a mathematical interpretation of decomposing the input signal $u ( t )$ onto a set of infinitely-long basis functions that are orthogonal respect to an exponentially-decaying measure, giving it long-range modeling abilities [10]. ",
+        "bbox": [
+            173,
+            511,
+            825,
+            594
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Second, S4 introduced a particular parameterization that decomposed this $\\pmb { A }$ matrix into the sum of a normal and rank-1 matrix (5), which can be unitarily conjugated into a (complex) diagonal plus rank-1 matrix. Leveraging this structured form, they then introduced a sophisticated algorithm for efficiently computing the convolution kernel (2) for state matrices that are diagonal plus low-rank (DPLR). ",
+        "bbox": [
+            174,
+            598,
+            825,
+            655
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/1a54f462ad4311f57a9f78ffb4f7be470ddd85f82e1f496ab41a9ccb5b4cb6c0.jpg",
+        "text": "$$\n\\begin{array} { c c } { { A _ { n k } = - \\left\\{ \\begin{array} { l l } { { ( 2 n + 1 ) ^ { \\frac { 1 } { 2 } } ( 2 k + 1 ) ^ { \\frac { 1 } { 2 } } } } & { { n > k } } \\\\ { { n + 1 } } & { { n = k } } \\end{array} \\right. } } & { { A _ { n k } ^ { ( N ) } = - \\left\\{ \\begin{array} { l l } { { ( n + \\frac { 1 } { 2 } ) ^ { 1 / 2 } ( k + \\frac { 1 } { 2 } ) ^ { 1 / 2 } } } & { { n > k } } \\\\ { { \\frac { 1 } { 2 } } } & { { n = k } } \\end{array} \\right. } } \\\\ { { 0 } } & { { n < k } } & { { ( 4 ) } } \\\\ { { B _ { n } = ( 2 n + 1 ) ^ { \\frac { 1 } { 2 } } } } & { { P _ { n } = ( n + 1 / 2 ) ^ { \\frac { 1 } { 2 } } } } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            204,
+            665,
+            816,
+            744
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "DSS: Diagonal State Spaces S4 was originally motivated by searching for a diagonal state matrix, which would be even more structured and result in very simple computation of the SSM. However, the HiPPO-LegS matrix cannot be stably transformed into diagonal form [9, Lemma 3.2], and they were unable to find any diagonal matrices that performed well, resulting in the DPLR formulation. ",
+        "bbox": [
+            173,
+            773,
+            826,
+            829
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Gupta [11] made the surprising empirical observation that simply removing the low-rank portion of the DPLR form of the HiPPO-LegS matrix results in a diagonal matrix that performs comparably to the original S4 method. More precisely, their initialization is the diagonal matrix $A ^ { ( D ) }$ , or the diagonalization of $A ^ { ( N ) }$ in (5). They termed $A ^ { ( N ) }$ the skew-HiPPO matrix, which we will also call the normal-HiPPO matrix. To be more specific and disambiguate these variants, we may also call $A ^ { ( N ) }$ the HiPPO-LegS-N or HiPPO-N matrix and $A ^ { ( D ) }$ the HiPPO-LegS-D or HiPPO-D matrix. ",
+        "bbox": [
+            174,
+            833,
+            821,
+            862
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            90,
+            825,
+            150
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "In addition to this initialization, they proposed a method for computing a diagonal SSM kernel.   \nBeyond these two core differences, several other aspects of their parameterization differ from $\\mathrm { { \\cal S } } 4 \\mathrm { \\ ' } _ { \\mathrm { s } }$ . ",
+        "bbox": [
+            171,
+            154,
+            823,
+            183
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "In Sections 3 and 4, we systematically study the components of DSS: we categorize different ways to parameterize and compute the diagonal state space, and explain the theoretical interpretion of this particular diagonal $\\pmb { A }$ matrix. ",
+        "bbox": [
+            174,
+            186,
+            825,
+            228
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3 Parameterizing Diagonal State Spaces ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            244,
+            524,
+            263
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "We describe various choices for the computation and parameterization of diagonal state spaces. Our categorization of these choices leads to simple variants of the core method. Both DSS and our proposed S4D can be described using a combination of these factors (Section 3.4). ",
+        "bbox": [
+            173,
+            275,
+            826,
+            316
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3.1 Discretization ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            330,
+            310,
+            345
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "The true continuous-time SSM can be represented as a continuous convolution $y ( t ) = ( K * u ) ( t ) =$ $\\begin{array} { r } { \\int _ { 0 } ^ { \\infty } C e ^ { s A } B u ( t - s ) d s } \\end{array}$ . ",
+        "bbox": [
+            173,
+            354,
+            823,
+            385
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "In discrete time, we view an input sequence $u _ { 0 } , u _ { 1 } , \\ldots$ as uniformly-spaced samples from an underlying function $u ( t )$ and must approximate this integral. Standard methods for doing so that preserve the convolutional structure of the model exist. The first step is to discretize the parameters. Two simple choices that have been used in prior work include ",
+        "bbox": [
+            173,
+            388,
+            826,
+            443
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/0b083cb7a9489f1640d51327309f5bf02cbad19a31b4bf47869df237e14b52d0.jpg",
+        "text": "$$\n\\begin{array} { r l } { | \\overline { { A } } = ( I - \\Delta / 2 A ) ^ { - 1 } ( I + \\Delta / 2 A ) \\qquad } & { ( \\mathbf { Z O H } ) \\overline { { A } } = \\exp ( \\Delta A ) } \\\\ { \\overline { { B } } = ( I - \\Delta / 2 A ) ^ { - 1 } \\cdot \\Delta B \\qquad } & { \\overline { { B } } = ( \\Delta A ) ^ { - 1 } ( \\exp ( \\Delta \\cdot A ) - I ) \\cdot \\Delta B . } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            241,
+            446,
+            843,
+            489
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "With these methods, the discrete-time SSM output is just ",
+        "bbox": [
+            174,
+            496,
+            547,
+            511
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/2ca65bb395e754491188fa544955f72dcd74412d91fb178402127351508c20b0.jpg",
+        "text": "$$\ny = u * { \\overline { { K } } } \\qquad \\mathrm { w h e r e } \\ { \\overline { { K } } } = ( C { \\overline { { B } } } , C { \\overline { { A B } } } , \\ldots , C { \\overline { { A } } } ^ { L - 1 } { \\overline { { B } } } ) .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            292,
+            516,
+            704,
+            536
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "These integration rules have both been used in prior works (e.g. LMU and DSS use ZOH [26, 11] while S4 and its predecessors use bilinear [6, 8, 9]). ",
+        "bbox": [
+            173,
+            546,
+            825,
+            575
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "In Section 5, we show that there is little empirical difference between them. However, we note that there is a curious phenomenon where the bilinear transform actually perfectly smooths out the kernel used in DSS to match the S4 kernel (Section 4 Fig. 2d). We additionally note that numerical integration is a rich and well-studied topic and more stable methods of approximating the convolutional integral may exist. For example, it is well-known that simple rules like the Trapezoid rule [18] can dramatically reduce numerical integration error when the function has bounded second derivative. ",
+        "bbox": [
+            173,
+            579,
+            825,
+            661
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3.2 Convolution Kernel ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            675,
+            349,
+            690
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "The main computational difficulty of the original S4 model is computing the convolution kernel $\\overline { { \\kappa } }$ . This is extremely slow for general state matrices $\\pmb { A }$ , and S4 introduced a complicated algorithm for DPLR state matrices. When $\\pmb { A }$ is diagonal, the computation is nearly trivial. By (6), ",
+        "bbox": [
+            176,
+            699,
+            826,
+            741
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/cf29793b0ebcbc2fa41af8b714ca3312bab8051e716ceea77f4614fa3f5c023a.jpg",
+        "text": "$$\n\\begin{array} { r } { \\overline { { \\mathbf { K } } } _ { \\ell } = \\displaystyle \\sum _ { n = 0 } ^ { N - 1 } C _ { n } \\overline { { A } } _ { n } ^ { \\ell } \\overline { { B } } _ { n } \\implies \\overline { { K } } = ( \\overline { { B } } ^ { \\top } \\circ C ) \\cdot \\boldsymbol { \\mathcal { V } } _ { L } ( \\overline { { A } } ) \\qquad \\mathrm { ~ w h e r e ~ } \\boldsymbol { \\mathcal { V } } _ { L } ( \\overline { { A } } ) _ { n , \\ell } = \\overline { { A } } _ { n } ^ { \\ell } } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            200,
+            746,
+            779,
+            787
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "where $\\circ$ is Hadamard product, $\\cdot$ is matrix multiplication, and $\\nu$ is known as a Vandermonde matrix. ",
+        "bbox": [
+            176,
+            791,
+            820,
+            808
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Time and Space Complexity The naive way to compute (7) is by materializing the Vandermonde matrix $\\mathcal { V } _ { L } ( \\overline { { A } } )$ and performing a matrix multiplication, which requires $O ( N L )$ time and space. ",
+        "bbox": [
+            173,
+            818,
+            821,
+            849
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "However, Vandermonde matrices are well-studied and theoretically the multiplication can be computed in $\\widetilde O ( N + L )$ operations and $O ( N + L )$ space. In fact, Vandermonde matrices are closely related to Cauchy matrices, which are the computational core of S4’s DPLR algorithm, and have identical complexity [17]. ",
+        "bbox": [
+            174,
+            853,
+            825,
+            912
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Proposition 1. The time and space complexity of computing the kernel of diagonal SSMs is equal to that of computing DPLR SSMs. ",
+        "bbox": [
+            173,
+            92,
+            823,
+            119
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "We note that on modern parallelizable hardware such as GPUs, a simple fast algorithm is to compute (7) with naive summation (using $O ( N L )$ operations), but without materializing the Vandermonde matrix (using $O ( N + L )$ space). Just as with S4, this may require implementing a custom kernel in some modern deep learning frameworks such as PyTorch to achieve the space savings. ",
+        "bbox": [
+            174,
+            130,
+            825,
+            185
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "3.3 Parameterization ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            202,
+            333,
+            217
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Parameterization of $\\pmb { A }$ . Note that the kernel $K ( t ) = C e ^ { t A } B$ blows up to $\\infty$ as $t \\to \\infty$ if $\\pmb { A }$ has any eigenvalues with positive real part. Goel et al. [5] found that this is a serious constraint that affects the stability of the model, especially when using the SSM autoregressively. They propose to force the real part of $\\pmb { A }$ to be negative, also known as the left-half plane condition in classical controls, by parameterizing the real part inside an exponential function $\\pmb { \\dot { A } } = - \\exp ( \\pmb { A } _ { R e } ) + \\boldsymbol { i } \\cdot \\pmb { A } _ { I m }$ . ",
+        "bbox": [
+            174,
+            226,
+            825,
+            295
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "We note that instead of exp, any activation function can be used as long as its range is bounded on one side, such as ReLU, softplus, etc. The original DSS does not constrain the real part of $\\pmb { A }$ , which is sufficient for simple tasks involving fixed-length sequences, but could become unstable in other settings. ",
+        "bbox": [
+            174,
+            300,
+            825,
+            356
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Parameterization of $_ { B , C }$ . Another choice in the parameterization is how to represent $\\textbf {  { B } }$ and $C$ . Note that the computation of the final discrete convolution kernel $\\overline { { \\kappa } }$ depends only on the elementwise product $B \\circ C$ (equation (7)). Therefore DSS chose to parameterize this product directly, which they call $W$ , instead of $\\textbf {  { B } }$ and $C$ individually. ",
+        "bbox": [
+            174,
+            359,
+            825,
+            416
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "However, we observe that this is equivalent to keeping independent $\\textbf {  { B } }$ and $C$ , and simply freezing $\\mathbf B = \\mathbf 1$ while training $C$ . Therefore, just as S4 has separate parameters $A , B$ , and $C$ and uses a fixed initialization for $\\pmb { A }$ and $\\textbf {  { B } }$ , S4D also proposes separate $A , B$ , and $C$ and uses fixed initializations for $\\pmb { A }$ (discussed in Section 4) and $\\textbf {  { B } }$ (set to 1). Then the difference between S4D and DSS is simply that DSS does not train $\\textbf {  { B } }$ . In our ablations, we show that training $\\textbf {  { B } }$ gives a minor but consistent improvement in performance. ",
+        "bbox": [
+            173,
+            420,
+            825,
+            502
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "3.4 S4D: the Diagonal Version of S4 ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            518,
+            434,
+            535
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "A key component of our exposition is disentangling the various choices possible in representing and computing state space models. With this categorization, different choices can be mixed and matched to define variants of the core method. Table 1 compares S4, DSS, and S4D, which have a core structure and kernel computation, but have various choices of other aspects of the parameterization. ",
+        "bbox": [
+            174,
+            545,
+            825,
+            599
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "table",
+        "img_path": "images/ad54f6f1966108681196fba0cb082e501c7ccb5880509d5a71c820e92129349b.jpg",
+        "table_caption": [
+            "Table 1: (Parameterization choices for Structured SSMs.) Aside from the core structure of $\\pmb { A }$ and the computation of its convolution kernel, SSMs have several design choices which are consolidated in S4D. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Method</td><td> Structure</td><td>Kernel Computation</td><td>Discretization</td><td>Constraint (A)</td><td>Trainable B</td><td>Initialization of A</td></tr><tr><td>S4</td><td>DPLR</td><td>Cauchy</td><td>Bilinear</td><td>exp</td><td>Yes</td><td>HiPPO</td></tr><tr><td>DSS</td><td>diagonal</td><td>softmax</td><td>ZOH</td><td>id (none)</td><td>No</td><td>HiPPO-D</td></tr><tr><td>S4D</td><td>diagonal</td><td>Vandermonde</td><td>either</td><td>exp/ReLU</td><td>optional</td><td>various</td></tr></table>",
+        "bbox": [
+            173,
+            648,
+            838,
+            714
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "4 Initialization of Diagonal State Matrices ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            746,
+            540,
+            763
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "The critical question remains: which diagonal state matrices $\\pmb { A }$ are actually effective? We comment on the limitations of diagonal SSMs, and then provide three instantiations of S4D that perform well empirically. ",
+        "bbox": [
+            176,
+            776,
+            823,
+            819
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Expressivity and Limitations of Diagonal SSMs. We first present a simplified view on the expressivity of diagonal SSMs mentioned by [11]. First, it is well-known that almost all matrices diagonalize over the complex plane. Therefore it is critical to use complex-valued matrices in order to use diagonal SSMs. ",
+        "bbox": [
+            173,
+            823,
+            825,
+            878
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Proposition 2. The set $\\mathcal { D } \\subset \\mathbb { C } ^ { N \\times N }$ of diagonalizable matrices is dense in $\\mathbb { C } ^ { N \\times N }$ , and has full measure (i.e. its complement has measure 0). ",
+        "bbox": [
+            174,
+            881,
+            821,
+            911
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "It is also well known that the state space $( A , B , C )$ is exactly equivalent to (i.e. expresses the same map $u \\mapsto y$ ) the state space $( V ^ { - 1 } \\bar { A } V , \\dot { V } ^ { - 1 } B , C \\dot { V } )$ , known in the SSM literature as a state space transformation. Therefore Proposition 2 says that (almost) all SSMs are equivalent to a diagonal SSM. ",
+        "bbox": [
+            174,
+            90,
+            825,
+            146
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "However, we emphasize that Proposition 2 is about expressivity which does not guarantee strong performance of a trained model after optimization. For example, Gu et al. [9] and Gupta [11] show that parameterizing $\\pmb { A }$ as a dense real matrix or diagonal complex matrix, which are both fully expressive classes, performs poorly if randomly initialized. ",
+        "bbox": [
+            174,
+            150,
+            825,
+            205
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Second, Proposition 2 does not take into account numerical representations of data, which was the original reason S4 required a low-rank correction term instead of a pure diagonalization [9, Lemma 3.2]. In Section 5.2, we also show that two different initializations with the same spectrum (i.e., are equivalent to the same diagonal $\\pmb { A }$ ) can have very different performance. ",
+        "bbox": [
+            174,
+            210,
+            825,
+            265
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "S4D-LegS. The HiPPO-LegS matrix has DPLR representation $A ^ { ( D ) } - P P ^ { \\top }$ , and Gupta [11] showed that simply approximating it with $A ^ { ( D ) }$ works quite well (5). Our first result is providing a clean mathematical interpretation of this method. Theorem 3 shows a surprising fact that does not hold in general for DPLR matrices (Appendix A.1), and arises out of the special structure of this particular matrix. ",
+        "bbox": [
+            173,
+            270,
+            825,
+            329
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Theorem 3. Let $\\pmb { A } = \\pmb { A } ^ { ( N ) } - P \\pmb { P } ^ { \\top }$ and $\\textbf {  { B } }$ be the HiPPO-LegS matrices, and $K _ { A , B } ( t )$ be its basis.   \nAs the state size $N \\to \\infty$ , the SSM basis $K _ { A ^ { ( N ) } , B / 2 } ( t )$ limits to $K _ { A , B } ( t )$ (Fig. 2). ",
+        "bbox": [
+            173,
+            334,
+            821,
+            366
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Note that $A ^ { ( N ) }$ is then unitarily equivalent to $A ^ { ( D ) }$ , which preserves the stability and timescale [10] of the system. ",
+        "bbox": [
+            173,
+            377,
+            825,
+            407
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "We define S4D-LegS to be the S4D method for this choice of diagonal $\\boldsymbol { A } = \\boldsymbol { A } ^ { ( D ) }$ . Theorem 3 explains the empirical results in [11] whereby this system performed quite close to S4, but was usually slightly worse. This is because DSS is a variant of S4D-LegS, which by Theorem 3 is a noisy approximation to S4-LegS. Fig. 2 illustrates this result, and also shows a curious phenomenon involving different discretization rules that is open for future work. ",
+        "bbox": [
+            173,
+            412,
+            825,
+            483
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "S4D-Inv. To further simplify S4D-LegS, we analyze the structure of $A ^ { ( { D } ) } = \\mathrm { d i a g } \\langle { A } \\rangle$ in more detail. The real part is easy to understand, which follows from the analysis in [9]: $\\Re ( A ) = - { \\frac { 1 } { 2 } } \\mathbf { 1 }$ Let the imaginary part be sorted, i.e. ${ \\mathfrak { T } } ( A ) _ { n }$ is the $n$ -th largest (positive) imaginary component. We empirically deduced the following conjecture for the asymptotics of the imaginary part. ",
+        "bbox": [
+            173,
+            488,
+            825,
+            547
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Conjecture 4. As $N \\to \\infty$ , $\\begin{array} { r } { \\mathfrak { I } ( A ) _ { 0 } \\to \\frac { 1 } { \\pi } N ^ { 2 } + c } \\end{array}$ where $c \\approx 0 . 5 2 3 6$ is a constant. For a fixed $N$ , the other eigenvalues satisfy an inverse scaling in $n$ : ${ \\mathfrak { I } } ( A ) _ { n } = \\Theta ( n ^ { - 1 } )$ . ",
+        "bbox": [
+            169,
+            551,
+            823,
+            584
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Fig. 3 empirically supports this conjecture. Based on Conjecture 4, we propose the initialization S4D-Inv to use the following inverse-law diagonal matrix which closely approximates S4D-LegS. ",
+        "bbox": [
+            173,
+            594,
+            825,
+            623
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "equation",
+        "img_path": "images/b33b1447e58ac11a9d6fe539cc72ba870ed0f0c0ec4530c2d6706158bd78b1b5.jpg",
+        "text": "$$\n( \\mathbf { S 4 D - I n v } ) \\quad A _ { n } = - \\frac { 1 } { 2 } + i \\frac { N } { \\pi } \\left( \\frac { N } { 2 n + 1 } - 1 \\right)\n$$",
+        "text_format": "latex",
+        "bbox": [
+            214,
+            628,
+            524,
+            664
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "equation",
+        "img_path": "images/e90916b977a507abd3d66284239478c83d09ea98b10f34177c6180aae8ca59d7.jpg",
+        "text": "$$\n( { \\bf S 4 D - L i n } ) { \\cal A } _ { n } = - { \\frac { 1 } { 2 } } + i \\pi n\n$$",
+        "text_format": "latex",
+        "bbox": [
+            580,
+            635,
+            787,
+            666
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "S4D-Lin. While S4D-Inv can be seen as an approximation to the original S4-LegS, we propose an even simpler scaling law for the imaginary parts that can be seen as an approximation of S4-FouT ([10]), where the imaginary parts are simply the Fourier series frequencies (i.e. matches the diagonal part of the DPLR form of S4-FouT). Fig. 1 (Right) illustrates the S4D-Lin basis $e ^ { t A } B$ , which are simply damped Fourier basis functions. ",
+        "bbox": [
+            173,
+            667,
+            825,
+            737
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "5 Experiments ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            758,
+            312,
+            776
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Our experimental study shows that S4D has strong performance in a wide variety of domains and tasks, including the well-studied Long Range Arena (LRA) benchmark where the best S4D variant is competitive with S4 on all tasks and significantly outperforms all non-SSM baselines. ",
+        "bbox": [
+            176,
+            790,
+            823,
+            833
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "We begin with controlled ablations of the various representations of diagonal state space models. Sections 5.1 and 5.2 ablate the proposed methods for parameterizing, computing, and initializing diagonal SSMs from Sections 3 and 4. Section 5.3 show full results of larger models on standard benchmarks, ",
+        "bbox": [
+            174,
+            837,
+            825,
+            878
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Methodology and Datasets. In order to study the effects of different S4 and S4D variants in a controlled setting, we propose the following protocol. We focus on three datasets covering a varied range of data modalities (image pixels, biosignal time series, audio waveforms), sequence lengths (1K, 4K, 16K), and tasks (classification and regression with bidirectional and causal models). ",
+        "bbox": [
+            173,
+            882,
+            821,
+            911
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "image",
+        "img_path": "images/e0f425a9a6f91ef92e5888b66e9f01de7484c84ff419da63513ac97fe310637a.jpg",
+        "image_caption": [
+            "Figure 2: (Visualization of Theorem 3). (a) The particular $( A , B )$ matrix chosen in S4 results in smooth basis functions $e ^ { t A } B$ with a closed form formula in terms of Legendre polynomials. By the HiPPO theory, convolving against these functions has a mathematical interpretation as orthogonalizing against an exponentially-decaying measure. (b, c) By special properties of this state matrix, removing the low-rank term of its NPLR representation produces the same basis functions as $N \\to \\infty$ , explaining the empirical effectiveness of DSS. (c) Curiously, the bilinear transform instead of ZOH smooths out the kernel to exactly match S4-LegS as $N$ grows. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            179,
+            88,
+            820,
+            202
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/916b80494a8740caf35b2d9bf7b6fbcab8210e55f0455370fe8512183d9c2789.jpg",
+        "image_caption": [
+            "Figure 3: (S4D eigenvalues.) All S4D methods have eigenvalues $- { \\frac { 1 } { 2 } } + { \\dot { \\lambda } } _ { n } i$ . S4D-LegS theoretically approximates dynamics of the original (non-diagonal) S4 (Blue), and has eigenvalues following an inverse law $\\lambda _ { n } \\propto n ^ { - 1 }$ (Orange). The precise law is important: other scaling laws with the same range, including an inverse law with different constant (Purple) and a quadratic law (Red), perform empirically worse (Section 5.2). A very different linear law based on Fourier frequencies also performs well (Green). "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            179,
+            304,
+            436,
+            434
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            449,
+            823,
+            477
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "• Sequential CIFAR (sCIFAR). CIFAR-10 images are flattened into a sequence of length 1024, and a bidirectional sequence model is used to perform 10-way classification. • BIDMC Vital Signs. EKG and PPG signals of length 4000 are used to predict respiratory rate (RR), heart rate (HR), and blood oxygen saturation (SpO2). We focus on $\\mathrm { S p O } 2$ in this study. • Speech Commands (SC).2 A 1-second raw audio waveform comprising 16000 samples is used for 35-way spoken word classification. We use an autoregressive (AR) model to vary the setting; this causal setting more closely imitates autoregressive speech generation, where SSMs have shown recent promise [5]. ",
+        "bbox": [
+            173,
+            486,
+            826,
+            601
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "We fix a simple architecture and training protocol that works generically. The architecture has 4 layers and hidden dimension $H = 1 2 8$ , resulting in $\\sim 1 0 0 K$ parameters. All results are averaged over multiple seeds (full protocol and results including std. reported in Appendix B). ",
+        "bbox": [
+            174,
+            609,
+            825,
+            651
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "5.1 Parameterization, Computation, Discretization ",
+        "text_level": 1,
+        "bbox": [
+            178,
+            666,
+            539,
+            681
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Given the same diagonal SSM matrices $A , B$ , there are many variants of how to parameterize the matrices and compute the SSM kernel described in Section 3. We ablate the different choices described in Table 1. Results are in Table 2, and show that: ",
+        "bbox": [
+            178,
+            690,
+            823,
+            731
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "(i) Computing the model with a softmax instead of Vandermonde product does not make much difference   \n(ii) Training $\\textbf {  { B } }$ is consistently slightly better   \n(iii) Different discretizations (Section 3.1) do not make a noticeable difference   \n(iv) Unrestricting the real part of $\\pmb { A }$ (Section 3.3) may be slightly better ",
+        "bbox": [
+            184,
+            741,
+            823,
+            825
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "These ablations show that for a fixed initialization $( A , B )$ , different aspects of parameterizing SSMs make little difference overall. This justifies the parameterization and algorithm S4D uses (Section 3.4), which preserves the choices of the original S4 model and is simpler than DSS. For the remaining of the experiments in Section 5.2 and Section 5.3, we fix the S4D parameterization and algorithm described in Section 3. Note that this computes exactly the same kernel as the original S4 algorithm when the low-rank portion is set to 0, allowing controlled comparisons of the critical state matrix $\\pmb { A }$ for the remainder of this section. ",
+        "bbox": [
+            176,
+            833,
+            825,
+            876
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "table",
+        "img_path": "images/a2a3ab139b7e08a1ebaf8ea4803ff805eb92ea3f7809b6c652d201d77b738b22.jpg",
+        "table_caption": [],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=1 colspan=1>Trainable B</td><td rowspan=1 colspan=1>Method</td><td rowspan=1 colspan=1>SCIFAR</td><td rowspan=1 colspan=1>SC (AR)</td><td rowspan=1 colspan=1>BIDMC (Sp02)</td></tr><tr><td rowspan=1 colspan=1>No</td><td rowspan=1 colspan=1>Softmax</td><td rowspan=1 colspan=1>85.04</td><td rowspan=1 colspan=1>89.80</td><td rowspan=1 colspan=1>0.1299</td></tr><tr><td rowspan=1 colspan=1>No</td><td rowspan=1 colspan=1>Vandermonde</td><td rowspan=1 colspan=1>84.78</td><td rowspan=1 colspan=1>89.62</td><td rowspan=1 colspan=1>0.1355</td></tr><tr><td rowspan=1 colspan=1>Yes</td><td rowspan=1 colspan=1>Softmax</td><td rowspan=1 colspan=1>85.37</td><td rowspan=1 colspan=1>90.06</td><td rowspan=1 colspan=1>0.1170</td></tr><tr><td rowspan=1 colspan=1>Yes</td><td rowspan=1 colspan=1>Vandermonde</td><td rowspan=1 colspan=1>85.37</td><td rowspan=1 colspan=1>90.34</td><td rowspan=1 colspan=1>0.1274</td></tr></table>",
+        "bbox": [
+            176,
+            102,
+            496,
+            161
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "table",
+        "img_path": "images/f4d787852464c57ff877ca45e2df9975fdf1976ba6d350385d38d08548ec7311.jpg",
+        "table_caption": [
+            "Table 2: Ablations of different parameterizations of diagonal SSMs using S4D-Inv. (Left) trainability and computation; $( R i g h t )$ discretization and parameterization. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=1 colspan=1>Discretization</td><td rowspan=1 colspan=1>RealpartofA</td><td rowspan=1 colspan=1>SCIFAR</td><td rowspan=1 colspan=1>SC (AR)</td><td rowspan=1 colspan=1>BIDMC (Sp02)</td></tr><tr><td rowspan=1 colspan=1>Bitinear</td><td rowspan=1 colspan=1>exp</td><td rowspan=1 colspan=1>85.20</td><td rowspan=1 colspan=1>89.52</td><td rowspan=1 colspan=1>0.1193</td></tr><tr><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>ReLU</td><td rowspan=1 colspan=1>85.06</td><td rowspan=1 colspan=1>90.22</td><td rowspan=1 colspan=1>0.1172</td></tr><tr><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>-</td><td rowspan=1 colspan=1>85.35</td><td rowspan=1 colspan=1>90.58</td><td rowspan=1 colspan=1>0.1102</td></tr><tr><td rowspan=1 colspan=1>ZOH</td><td rowspan=1 colspan=1>exp</td><td rowspan=1 colspan=1>85.02</td><td rowspan=1 colspan=1>89.93</td><td rowspan=1 colspan=1>0.1303</td></tr><tr><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>ReLU</td><td rowspan=1 colspan=1>84.98</td><td rowspan=1 colspan=1>90.03</td><td rowspan=1 colspan=1>0.1232</td></tr><tr><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>-</td><td rowspan=1 colspan=1>85.15</td><td rowspan=1 colspan=1>90.19</td><td rowspan=1 colspan=1>0.1289</td></tr></table>",
+        "bbox": [
+            503,
+            90,
+            825,
+            171
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            234,
+            825,
+            290
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "5.2 S4D Initialization Ablations ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            306,
+            406,
+            321
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "The original S4 model proposed a specific formula for the $\\pmb { A }$ matrix, and the first diagonal version [11] used a specific matrix based on it. Our new proposed variants S4D-Inv and S4D-Lin also define precise formulas for the initialization of the $\\pmb { A }$ matrix (8). This raises the question of whether the initialization of the $\\pmb { A }$ still needs to be so precise, despite the large simplifications from the original version. We perform several natural ablations on these initializations, showing that even simple variations of the precise formula can degrade performance. ",
+        "bbox": [
+            174,
+            330,
+            825,
+            412
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Imaginary part scaling factor. The scaling rules for the imaginary parts of S4D-Inv and S4D-Lin are simple polynomial laws, but how is the constant factor chosen and how important is it? These constants are based on approximations to HiPPO methods (e.g. Conjecture 4). Note that the range of imaginary components for S4D-Inv and S4D-Lin are quite different (Fig. 3); the largest imaginary part is N 2 for S4D-Inv and $\\pi N$ for S4D-Lin. ",
+        "bbox": [
+            174,
+            417,
+            825,
+            489
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "We consider scaling all imaginary parts by a constant factor of 0.01 or 100.0 to investigate whether the constant matters. Note that this preserves the overall shape of the basis functions (Fig. 1, dashed lines) and simply changes the frequencies, and it is not obvious that this should degrade performance. However, both changes substantially reduce the performance of S4D in all settings. ",
+        "bbox": [
+            174,
+            494,
+            825,
+            549
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Randomly initialized imaginary part. Next, we consider choosing the imaginary parts randomly. For S4D-Inv, we keep the real parts equal to $- \\frac 1 2$ and set each imaginary component to $\\begin{array} { r } { A _ { n } = - \\frac { 1 } { 2 } + i \\frac { N } { \\pi } \\big ( \\frac { N } { 2 u + 1 } - 1 \\big ) } \\end{array}$ for $u \\sim N { \\cdot } \\mathcal { U } [ 0 , 1 ]$ . Note that when $u$ is equally spaced in [0, 1] instead of uniformly random, this exactly recovers S4D-Inv (8), so this is a sensible random approximation to it. ",
+        "bbox": [
+            174,
+            554,
+            825,
+            613
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Similarly, we consider a variant of S4D-Lin that replaces the $n$ in (9) with $N \\cdot \\mathcal { U } [ 0 , 1 ]$ . ",
+        "bbox": [
+            176,
+            617,
+            736,
+            632
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Table 3a (Random Imag) shows that this small change causes minor degradation in performance. We additionally note that the randomly initialized imaginary ablation can be interpreted as follows. Fig. 3 shows the asymptotics of the imaginary parts of SSM matrices, where the imaginary parts of the eigenvalues correspond to y-values corresponding to uniformly spaced nodes on the $\\mathbf { X }$ -axis. This ablation then replaces the uniform spacing on the $\\mathbf { X }$ -axis with uniformly random $\\mathbf { X }$ values. ",
+        "bbox": [
+            174,
+            637,
+            825,
+            707
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Randomly initialized real part. ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            710,
+            390,
+            724
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "We considering initializing the real part of each eigenvalue as $- \\mathscr { U } [ 0 , 1 ]$ instead of fixing them to $- \\frac 1 2$ . Table 3a(Left, Random Real) shows that this also causes minor but consistent degradation in performance on the ablation datasets. Finally, we also consider randomizing both real and imaginary parts, which degrades performance even further. ",
+        "bbox": [
+            174,
+            729,
+            825,
+            786
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Ablation: Other S4D matrices. ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            790,
+            388,
+            805
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Other simple variants of initializations show that it is not just the range of the eigenvalues but the actual distribution that is important (Fig. 3). Both S4D-Inv2 and S4D-Quad have real part $- \\frac 1 2$ and imaginary part satisfying the same maximum value as Conjecture 4. The S4D-Inv2 initialization uses the same formula as S4D-Inv, but replaces a $2 n + 1$ in the denominator with $n + 1$ . The S4D-Quad initialization uses a polynomial law with power 2 instead of $- 1$ (S4D-Inv) or 1 (S4D-Lin). ",
+        "bbox": [
+            174,
+            810,
+            825,
+            878
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "We include two additional methods here that are not based on the proposed S4D-Inv or S4D-Lin methods. First, S4D-Rand uses a randomly initialized diagonal $\\pmb { A }$ , and validates that it performs (b) Results for all S4 and S4D methods on the ablation datasets, when the $\\pmb { A }$ and $_ B$ matrices are either frozen $( T o p )$ or trained (Bottom). Diagonal state matrices are highly competitive with full DPLR versions, achieving strong results on all datasets. ",
+        "bbox": [
+            173,
+            883,
+            823,
+            911
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "table",
+        "img_path": "images/b00f6d82d180aaf1b2ed583e819a0f87d964d7c6bd8a99ce96ae1103d276e2fe.jpg",
+        "table_caption": [],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Ablation</td><td>sCIFAR</td><td>SC (AR)</td><td>BIDMC</td></tr><tr><td>S4D-Lin</td><td>85.12</td><td>90.66</td><td>0.128</td></tr><tr><td>Scale 0.01</td><td>-7.27</td><td>-1.92</td><td>+0.040</td></tr><tr><td>Scale 100</td><td>-7.91</td><td>-4.04</td><td>+0.077</td></tr><tr><td>Random Imag</td><td>-0.42</td><td>-3.08</td><td>-0.001</td></tr><tr><td>Random Real</td><td>-0.73</td><td>-0.87</td><td>+0.011</td></tr><tr><td>Random Both</td><td>-1.28</td><td>-5.88</td><td>+0.007</td></tr></table>",
+        "bbox": [
+            178,
+            121,
+            429,
+            205
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "table",
+        "img_path": "images/602795af2e5a0b70cfcff95da17f8b71fcec19a4f45494d65ca8de65c97bde6b.jpg",
+        "table_caption": [
+            "Table 3: (Initialization and Trainability ablations) "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=2 colspan=3>Frozen (A,B)</td><td rowspan=1 colspan=2>SCIFAR</td><td rowspan=1 colspan=2>SC (AR)</td><td rowspan=1 colspan=1>BIDMC</td></tr><tr><td rowspan=1 colspan=2>Acc (first) Acc (best)</td><td rowspan=1 colspan=2>Acc (first) Acc (best)</td><td rowspan=1 colspan=1>RMSE (best)</td></tr><tr><td rowspan=4 colspan=3>S4-LegSS4-LegTS4-FouTS4-LegS+FouT</td><td rowspan=1 colspan=1>53.63</td><td rowspan=1 colspan=1>86.19</td><td rowspan=1 colspan=2>33.87    85.33</td><td rowspan=1 colspan=1>0.1049</td></tr><tr><td rowspan=1 colspan=1>54.76</td><td rowspan=1 colspan=1>86.30</td><td rowspan=1 colspan=2>8.77    57.35</td><td rowspan=1 colspan=1>0.1106</td></tr><tr><td rowspan=1 colspan=1>55.28</td><td rowspan=1 colspan=1>86.05</td><td rowspan=1 colspan=1>9.27</td><td rowspan=1 colspan=1>69.57</td><td rowspan=1 colspan=1>0.1072</td></tr><tr><td rowspan=1 colspan=1>T</td><td rowspan=1 colspan=1>54.38</td><td rowspan=1 colspan=1>86.53</td><td rowspan=1 colspan=1>34.06</td><td rowspan=1 colspan=1>83.37</td><td rowspan=1 colspan=1>0.0887</td></tr><tr><td rowspan=1 colspan=2>S4D-LegS</td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>50.87</td><td rowspan=1 colspan=1>84.81</td><td rowspan=1 colspan=1>22.76</td><td rowspan=1 colspan=1>77.18</td><td rowspan=1 colspan=1>0.0960</td></tr><tr><td rowspan=1 colspan=2>S4D-Inv</td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>53.19</td><td rowspan=1 colspan=1>84.40</td><td rowspan=1 colspan=1>18.49</td><td rowspan=1 colspan=1>76.53</td><td rowspan=1 colspan=1>0.0995</td></tr><tr><td rowspan=1 colspan=3>S4D-Lin</td><td rowspan=1 colspan=1>51.75</td><td rowspan=1 colspan=1>84.96</td><td rowspan=1 colspan=1>19.09</td><td rowspan=1 colspan=1>75.58</td><td rowspan=1 colspan=1>0.0935</td></tr></table>",
+        "bbox": [
+            441,
+            113,
+            820,
+            234
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "table",
+        "img_path": "images/251fd3a38ba49708e8669ae12fdcfc972ca48579656f9e7040615d74529aae10.jpg",
+        "table_caption": [],
+        "table_footnote": [
+            "(a) Ablations of the initialization of the diagonal $\\pmb { A }$ matrix in S4D. Very simple changes that largely preserve the structure of the diagonal eigenvalues all degrade performance. "
+        ],
+        "table_body": "<table><tr><td rowspan=1 colspan=1>S4D-Inv</td><td rowspan=1 colspan=1>84.79</td><td rowspan=1 colspan=1>90.27</td><td rowspan=1 colspan=1>0.114</td></tr><tr><td rowspan=1 colspan=1>Scale 0.01</td><td rowspan=1 colspan=1>-5.03</td><td rowspan=1 colspan=1>-0.08</td><td rowspan=2 colspan=1>+0.028+0.034</td></tr><tr><td rowspan=1 colspan=1>Scale 100</td><td rowspan=1 colspan=1>-7.77</td><td rowspan=1 colspan=1>-52.31</td></tr><tr><td rowspan=1 colspan=1>Random Imag</td><td rowspan=1 colspan=1>-0.29</td><td rowspan=1 colspan=1>-0.52</td><td rowspan=1 colspan=1>+0.010</td></tr><tr><td rowspan=1 colspan=1>Random Real</td><td rowspan=1 colspan=1>0.12</td><td rowspan=1 colspan=1>-2.18</td><td rowspan=2 colspan=1>+0.032+0.024</td></tr><tr><td rowspan=1 colspan=1>Random Both</td><td rowspan=1 colspan=1>-1.55</td><td rowspan=1 colspan=1>-0.55</td></tr><tr><td rowspan=1 colspan=1>S4D-Inv2</td><td rowspan=1 colspan=1>-2.62</td><td rowspan=1 colspan=1>-39.84</td><td rowspan=1 colspan=1>+0.005</td></tr><tr><td rowspan=1 colspan=1>S4D-Quad</td><td rowspan=1 colspan=1>-1.83</td><td rowspan=1 colspan=1>-0.62</td><td rowspan=1 colspan=1>+0.024</td></tr><tr><td rowspan=1 colspan=1>S4D-Random</td><td rowspan=1 colspan=1>-6.32</td><td rowspan=1 colspan=1>-1.95</td><td rowspan=1 colspan=1>+0.034</td></tr><tr><td rowspan=1 colspan=1>S4D-Real</td><td rowspan=1 colspan=1>-5.45</td><td rowspan=1 colspan=1>-10.17</td><td rowspan=1 colspan=1>+0.066</td></tr></table>",
+        "bbox": [
+            178,
+            215,
+            429,
+            335
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "table",
+        "img_path": "images/6fad589f5ace9081cf0ede9367a635147ce96a47a2c3c9a291edab8f68c77f3a.jpg",
+        "table_caption": [
+            "Trainable (A, B) "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=4 colspan=1>S4-LegSS4-LegTS4-FouTS4-LegS+FouT</td><td rowspan=1 colspan=1>54.23</td><td rowspan=1 colspan=1>86.29</td><td rowspan=1 colspan=1>62.19</td><td rowspan=1 colspan=1>90.68</td><td rowspan=1 colspan=1>0.1033</td></tr><tr><td rowspan=1 colspan=1>55.16</td><td rowspan=1 colspan=1>86.12</td><td rowspan=1 colspan=1>55.86</td><td rowspan=1 colspan=1>90.42</td><td rowspan=1 colspan=1>0.1146</td></tr><tr><td rowspan=1 colspan=1>55.89</td><td rowspan=1 colspan=1>85.93</td><td rowspan=1 colspan=1>60.56</td><td rowspan=1 colspan=1>90.83</td><td rowspan=1 colspan=1>0.1136</td></tr><tr><td rowspan=1 colspan=1>55.00</td><td rowspan=1 colspan=1>86.18</td><td rowspan=1 colspan=1>61.76</td><td rowspan=1 colspan=1>91.01</td><td rowspan=1 colspan=1>0.0970</td></tr><tr><td rowspan=3 colspan=1>S4D-LegSS4D-InvS4D-Lin</td><td rowspan=1 colspan=1>50.41</td><td rowspan=1 colspan=1>85.64</td><td rowspan=1 colspan=1>47.54</td><td rowspan=1 colspan=1>88.47</td><td rowspan=1 colspan=1>0.1148</td></tr><tr><td rowspan=1 colspan=1>53.42</td><td rowspan=1 colspan=1>84.59</td><td rowspan=1 colspan=1>45.73</td><td rowspan=1 colspan=1>89.69</td><td rowspan=1 colspan=1>0.1132</td></tr><tr><td rowspan=1 colspan=1>52.23</td><td rowspan=1 colspan=1>85.75</td><td rowspan=1 colspan=1>47.68</td><td rowspan=1 colspan=1>89.56</td><td rowspan=1 colspan=1>0.1032</td></tr></table>",
+        "bbox": [
+            441,
+            246,
+            821,
+            342
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            436,
+            351,
+            826,
+            402
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "poorly, in line with earlier findings [9, 11]. Second, S4D-Real uses a particular real initialization with $A _ { n } = - ( n + 1 )$ . This is the exact same spectrum as the original S4(-LegS) method, which validates that it is not just the diagonalization that matters, highlighting the limitations of Proposition 2. ",
+        "bbox": [
+            174,
+            422,
+            825,
+            464
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "5.3 Full Comparisons of S4D and S4 Methods ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            481,
+            504,
+            496
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Trainable $A , B$ matrices. ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            506,
+            351,
+            521
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Table 3b shows the performance of all S4D and S4 variants [10] on the ablations datasets. We observe several interesting phenomena: ",
+        "bbox": [
+            176,
+            525,
+            823,
+            553
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "(i) Freezing the matrices performs comparably to training them on sCIFAR and BIDMC, but is substantially worse on SC. We hypothesize that this results from $\\Delta$ being poorly initialized for SC, so that at initialization models do not have context over the entire sequence, and training $\\pmb { A }$ and $\\textbf {  { B } }$ helps adjust for this. As further evidence, the finite window methods S4-LegT and S4-FouT (defined in [10]) have the most limited context and suffer the most when $\\pmb { A }$ is frozen.   \n(ii) The full DPLR versions are often slightly better than the diagonal version throughout the entire training curve. We report the validation accuracy after 1 epoch of training on sCIFAR and SC to illustrate this phenomenon. Note that this is not a consequence of having more parameters (Appendix B). ",
+        "bbox": [
+            205,
+            564,
+            825,
+            707
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Large models on ablation datasets. ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            718,
+            416,
+            732
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Finally, we relax the strict requirements on model size and regularization for the ablation datasets, and show the performance of S4 and S4D variants on the test sets with a larger model (architecture and training details in Appendix B) when the model size and regularization is simply increased (Table 4). We note that results for each dataset are better than the original S4 model, which was already state-of-the-art on these datasets [8, 9]. ",
+        "bbox": [
+            174,
+            737,
+            825,
+            805
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Long Range Arena. ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            810,
+            312,
+            824
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "We use the same hyperparameter setting for the state-of-the-art S4 model in [10] on the Long Range Arena benchmark for testing long dependencies in sequence models. S4D variants are highly competitive on all datasets except Path-X, and outperform the S4 variants on several of them. On Path-X using this hyperparameter setting with bidirectional models, only S4D-Inv, our simpler approximation to the original S4-LegS model, achieves above random chance, and has an average of $8 5 \\%$ on the full LRA suite, more than 30 points better than the original Transformer [24]. ",
+        "bbox": [
+            174,
+            829,
+            825,
+            911
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "table",
+        "img_path": "images/3af7319d46766ca9222695f5bf4e0b50b4e831f5d480b3c816067fe27fdebfde.jpg",
+        "table_caption": [
+            "Table 4: (Ablation datasets: Full results with larger models.) For Speech Commands, we show both an autoregressive model as in the ablations, and an unconstrained bidirectional model. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=\"3\">MODEL</td><td>SCIFAR</td><td colspan=\"2\">SC</td><td colspan=\"3\">BIDMC</td></tr><tr><td>TEST</td><td>AR</td><td>B1.</td><td>HR</td><td>RR</td><td>SPO2</td></tr><tr><td>S4-LegS</td><td>91.80 (0.43)</td><td>93.60 (0.13)</td><td>96.08 (0.15)</td><td>0.332 (0.013)</td><td>0.247 (0.062)</td><td>0.090 (0.006)</td></tr><tr><td>S4-FouT</td><td>91.22 (0.25)</td><td>91.78 (0.10)</td><td>95.27 (0.20)</td><td>0.339 (0.020)</td><td>0.301 (0.030)</td><td>0.068 (0.003)</td></tr><tr><td>S4D-LegS</td><td>89.92 (1.69)</td><td>93.57 (0.09)</td><td>95.83 (0.14)</td><td>0.367 (0.001)</td><td>0.248 (0.036)</td><td>0.102 (0.001)</td></tr><tr><td>S4D-Inv</td><td>90.69 (0.06)</td><td>93.40 (0.67)</td><td>96.18 (0.27)</td><td>0.373 (0.024)</td><td>0.254 (0.022)</td><td>0.110 (0.001)</td></tr><tr><td>S4D-Lin</td><td>90.42 (0.03)</td><td>93.37 (0.05)</td><td>96.25 (0.03)</td><td>0.379 (0.006)</td><td>0.226 (0.008)</td><td>0.114 (0.003)</td></tr></table>",
+        "bbox": [
+            191,
+            122,
+            800,
+            237
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "table",
+        "img_path": "images/ba338bcf7d0f2c5cce3d080fe0ee338575182a3ac0738408d41e06545a3a573d.jpg",
+        "table_caption": [
+            "Table 5: (Long Range Arena) Accuracy on full suite of LRA tasks. Hyperparameters in Appendix B. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>MODEL</td><td>LISTOPS</td><td>TEXT</td><td>RETRIEVAL</td><td>IMAGE</td><td>PATHFINDER</td><td>PATH-X</td><td>AVG</td></tr><tr><td>S4-LegS</td><td>59.60 (0.07)</td><td>86.82 (0.13)</td><td>90.90 (0.15)</td><td>88.65 (0.23)</td><td>94.20 (0.25)</td><td>96.35</td><td>86.09</td></tr><tr><td>S4-FouT</td><td>57.88 (1.90)</td><td>86.34 (0.31)</td><td>89.66 (0.88)</td><td>89.07 (0.19)</td><td>94.46 (0.24)</td><td>X</td><td>77.90</td></tr><tr><td>S4D-LegS</td><td>60.47 (0.34)</td><td>86.18 (0.43)</td><td>89.46 (0.14)</td><td>88.19 (0.26)</td><td>93.06 (1.24)</td><td>91.95</td><td>84.89</td></tr><tr><td>S4D-Inv</td><td>60.18 (0.35)</td><td>87.34 (0.20)</td><td>91.09 (0.01)</td><td>87.83 (0.37)</td><td>93.78 (0.25)</td><td>92.80</td><td>85.50</td></tr><tr><td>S4D-Lin</td><td>60.52 (0.51)</td><td>86.97 (0.23)</td><td>90.96 (0.09)</td><td>87.93 (0.34)</td><td>93.96 (0.60)</td><td>X</td><td>78.39</td></tr><tr><td>S4 (original)</td><td>58.35</td><td>76.02</td><td>87.09</td><td>87.26</td><td>86.05</td><td>88.10</td><td>80.48</td></tr><tr><td>Transformer</td><td>36.37</td><td>64.27</td><td>57.46</td><td>42.44</td><td>71.40</td><td>X</td><td>53.66</td></tr></table>",
+        "bbox": [
+            186,
+            272,
+            807,
+            398
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "6 Conclusion ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            421,
+            299,
+            439
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "State space models based on S4 are a promising family of models for modeling many types of sequential data, with particular strengths for continuous signals and long-range interactions. These models are a large departure from conventional sequence models such as RNNs, CNNs, and Transformers, with many new ideas and moving parts. This work provides a more in-depth exposition for all aspects of working with S4-style models, from their core structures and kernel computation algorithms, to miscellaneous choices in their parameterizations, to new theory and methods for their initialization. We systematically analyzed and ablated each of these components, and provide recommendations for building a state space model that is as simple as possible, while as theoretically principled and empirically effective as S4. We believe that S4D can be a strong generic sequence model for a variety of domains, that opens new directions for state space models theoretically, and is much more practical to understand and implement for practitioners. ",
+        "bbox": [
+            173,
+            452,
+            826,
+            602
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Acknowledgments ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            614,
+            303,
+            628
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "We gratefully acknowledge the support of DARPA under Nos. FA86501827865 (SDH) and FA86501827882 (ASED); NIH under No. U54EB020405 (Mobilize), NSF under Nos. CCF1763315 (Beyond Sparsity), CCF1563078 (Volume to Velocity), and 1937301 (RTML); ONR under No. N000141712266 (Unifying Weak Supervision); the Moore Foundation, NXP, Xilinx, LETI-CEA, Intel, IBM, Microsoft, NEC, Toshiba, TSMC, ARM, Hitachi, BASF, Accenture, Ericsson, Qualcomm, Analog Devices, the Okawa Foundation, American Family Insurance, Google Cloud, Swiss Re, Brown Institute for Media Innovation, Department of Defense (DoD) through the National Defense Science and Engineering Graduate Fellowship (NDSEG) Program, Fannie and John Hertz Foundation, National Science Foundation Graduate Research Fellowship Program, Texas Instruments, and members of the Stanford DAWN project: Teradata, Facebook, Google, Ant Financial, NEC, VMWare, and Infosys. The U.S. Government is authorized to reproduce and distribute reprints for Governmental purposes notwithstanding any copyright notation thereon. Any opinions, findings, and conclusions or recommendations expressed in this material are those of the authors and do not necessarily reflect the views, policies, or endorsements, either expressed or implied, of DARPA, NIH, ONR, or the U.S. Government. ",
+        "bbox": [
+            174,
+            636,
+            826,
+            839
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "References   \n[1] Jimmy Lei Ba, Jamie Ryan Kiros, and Geoffrey E Hinton. Layer normalization. arXiv preprint arXiv:1607.06450, 2016.   \n[2] Shaojie Bai, J Zico Kolter, and Vladlen Koltun. Trellis networks for sequence modeling. In The International Conference on Learning Representations (ICLR), 2019.   \n[3] Yann N Dauphin, Angela Fan, Michael Auli, and David Grangier. Language modeling with gated convolutional networks. In International conference on machine learning, pages 933–941. PMLR, 2017.   \n[4] N Benjamin Erichson, Omri Azencot, Alejandro Queiruga, Liam Hodgkinson, and Michael W Mahoney. Lipschitz recurrent neural networks. In International Conference on Learning Representations, 2021.   \n[5] Karan Goel, Albert Gu, Chris Donahue, and Christopher Re. It’s raw! audio generation with ´ state-space models. In The International Conference on Machine Learning (ICML), 2022.   \n[6] Albert Gu, Tri Dao, Stefano Ermon, Atri Rudra, and Christopher Re. Hippo: Recurrent memory ´ with optimal polynomial projections. In Advances in Neural Information Processing Systems (NeurIPS), 2020.   \n[7] Albert Gu, Caglar Gulcehre, Tom Le Paine, Matt Hoffman, and Razvan Pascanu. Improving the gating mechanism of recurrent neural networks. In The International Conference on Machine Learning (ICML), 2020. [8] Albert Gu, Isys Johnson, Karan Goel, Khaled Saab, Tri Dao, Atri Rudra, and Christopher Re.´ Combining recurrent, convolutional, and continuous-time models with the structured learnable linear state space layer. In Advances in Neural Information Processing Systems (NeurIPS), 2021.   \n[9] Albert Gu, Karan Goel, and Christopher Re. Efficiently modeling long sequences with structured ´ state spaces. In The International Conference on Learning Representations (ICLR), 2022.   \n[10] Albert Gu, Isys Johnson, Aman Timalsina, Atri Rudra, and Christopher Re. How to train your ´ hippo: State space models with generalized basis projections. arXiv preprint arXiv:2206.12037, 2022.   \n[11] Ankit Gupta. Diagonal state spaces are as effective as structured state spaces. In Advances in Neural Information Processing Systems (NeurIPS), 2022.   \n[12] Sepp Hochreiter and Jurgen Schmidhuber. Long short-term memory. ¨ Neural computation, 9(8): 1735–1780, 1997.   \n[13] Sergey Ioffe and Christian Szegedy. Batch normalization: Accelerating deep network training by reducing internal covariate shift. In International conference on machine learning, pages 448–456. PMLR, 2015.   \n[14] Patrick Kidger, James Morrill, James Foster, and Terry Lyons. Neural controlled differential equations for irregular time series. arXiv preprint arXiv:2005.08926, 2020.   \n[15] James Morrill, Cristopher Salvi, Patrick Kidger, James Foster, and Terry Lyons. Neural rough differential equations for long time series. The International Conference on Machine Learning (ICML), 2021.   \n[16] Naoki Nonaka and Jun Seita. In-depth benchmarking of deep neural network architectures for ecg diagnosis. In Machine Learning for Healthcare Conference, pages 414–439. PMLR, 2021.   \n[17] Victor Pan. Structured matrices and polynomials: unified superfast algorithms. Springer Science & Business Media, 2001.   \n[18] Anthony Ralston and Philip Rabinowitz. A first course in numerical analysis. Courier Corporation, 2001. ",
+        "bbox": [
+            171,
+            68,
+            828,
+            919
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "[19] David W Romero, Anna Kuzina, Erik J Bekkers, Jakub M Tomczak, and Mark Hoogendoorn. Ckconv: Continuous kernel convolution for sequential data. arXiv preprint arXiv:2102.02611, 2021. ",
+        "bbox": [
+            171,
+            92,
+            825,
+            132
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "[20] David W Romero, Robert-Jan Bruintjes, Jakub M Tomczak, Erik J Bekkers, Mark Hoogendoorn, and Jan C van Gemert. Flexconv: Continuous kernel convolutions with differentiable kernel sizes. In The International Conference on Learning Representations (ICLR), 2022. ",
+        "bbox": [
+            173,
+            142,
+            821,
+            184
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "[21] T Konstantin Rusch and Siddhartha Mishra. Unicornn: A recurrent model for learning very long time dependencies. The International Conference on Machine Learning (ICML), 2021. ",
+        "bbox": [
+            173,
+            193,
+            823,
+            222
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "[22] Noam Shazeer. Glu variants improve transformer. arXiv preprint arXiv:2002.05202, 2020. ",
+        "bbox": [
+            176,
+            231,
+            805,
+            246
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "[23] Chang Wei Tan, Christoph Bergmeir, Francois Petitjean, and Geoffrey I Webb. Time series extrinsic regression. Data Mining and Knowledge Discovery, pages 1–29, 2021. doi: https: //doi.org/10.1007/s10618-021-00745-9. ",
+        "bbox": [
+            174,
+            255,
+            821,
+            296
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "[24] Yi Tay, Mostafa Dehghani, Samira Abnar, Yikang Shen, Dara Bahri, Philip Pham, Jinfeng Rao, Liu Yang, Sebastian Ruder, and Donald Metzler. Long range arena : A benchmark for efficient transformers. In International Conference on Learning Representations, 2021. URL https://openreview.net/forum?id $=$ qVyeW-grC2k. ",
+        "bbox": [
+            171,
+            306,
+            828,
+            362
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "[25] Trieu H Trinh, Andrew M Dai, Minh-Thang Luong, and Quoc V Le. Learning longer-term dependencies in RNNs with auxiliary losses. In The International Conference on Machine Learning (ICML), 2018. ",
+        "bbox": [
+            173,
+            371,
+            821,
+            412
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "[26] Aaron Voelker, Ivana Kajic, and Chris Eliasmith. Legendre memory units: Continuous-time ´ representation in recurrent neural networks. In Advances in Neural Information Processing Systems, pages 15544–15553, 2019. ",
+        "bbox": [
+            174,
+            421,
+            825,
+            463
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Checklist ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            488,
+            254,
+            505
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "1. For all authors... ",
+        "bbox": [
+            214,
+            515,
+            341,
+            529
+        ],
+        "page_idx": 11
+    },
+    {
+        "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] See Section 5, e.g. not matching the baseline S4 on Path-X.   \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,
+            534,
+            825,
+            637
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "2. If you are including theoretical results... ",
+        "bbox": [
+            214,
+            642,
+            493,
+            656
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "(a) Did you state the full set of assumptions of all theoretical results? [Yes] (b) Did you include complete proofs of all theoretical results? [Yes] See Appendix A. ",
+        "bbox": [
+            238,
+            660,
+            800,
+            690
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "3. If you ran experiments... ",
+        "bbox": [
+            212,
+            695,
+            393,
+            709
+        ],
+        "page_idx": 11
+    },
+    {
+        "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] The code is a simple modification from the original S4 [9] repository and is publicly available.   \n(b) Did you specify all the training details (e.g., data splits, hyperparameters, how they were chosen)? [Yes] See Appendix B.   \n(c) Did you report error bars (e.g., with respect to the random seed after running experiments multiple times)? [Yes] See the Appendix.   \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] The experiment code and configs are publically available with resource and timing information reported. ",
+        "bbox": [
+            238,
+            714,
+            825,
+            858
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "4. If you are using existing assets (e.g., code, data, models) or curating/releasing new assets... ",
+        "bbox": [
+            207,
+            862,
+            823,
+            877
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "(a) If your work uses existing assets, did you cite the creators? [Yes] (b) Did you mention the license of the assets? [Yes] ",
+        "bbox": [
+            238,
+            881,
+            694,
+            911
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "(c) Did you include any new assets either in the supplemental material or as a URL? [No]   \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] We used standard benchmarks and synthetic data. ",
+        "bbox": [
+            238,
+            90,
+            825,
+            178
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "5. If you used crowdsourcing or conducted research with human subjects... ",
+        "bbox": [
+            214,
+            183,
+            705,
+            196
+        ],
+        "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,
+            200,
+            825,
+            289
+        ],
+        "page_idx": 12
+    }
+]