Add files using upload-large-folder tool

parse/dev/-P7G-8dmSh4/-P7G-8dmSh4.md

@@ -0,0 +1,452 @@
+# FORMAL MATHEMATICS STATEMENTCURRICULUM LEARNING
+
+Stanislas Polu OpenAI
+
+Jesse Michael Han† Multi Technologies
+
+Kunhao Zheng École Polytechnique
+
+Mantas Baksys University of Cambridge
+
+Igor Babuschkin† DeepMind
+
+Ilya Sutskever OpenAI
+
+# ABSTRACT
+
+We explore the use of expert iteration in the context of language modeling applied to formal mathematics. We show that at same compute budget, expert iteration, by which we mean proof search interleaved with learning, dramatically outperforms proof search only. We also observe that when applied to a collection of formal statements of sufficiently varied difficulty, expert iteration is capable of finding and solving a curriculum of increasingly difficult problems, without the need for associated ground-truth proofs. Finally, by applying this expert iteration to a manually curated set of problem statements, we surpass previous state-of-the-art on the miniF $2 F$ benchmark, automatically solving multiple challenging problems drawn from high school olympiads.
+
+# 1 INTRODUCTION
+
+Deep learning has enjoyed spectacular success in many domains, including language (Brown et al., 2020; Devlin et al., 2019; Wu et al., 2016), vision (Radford et al., 2021; Tan & Le, 2019), and image generation (Ramesh et al., 2021; Karras et al., 2019). One domain where deep learning has not yet enjoyed a comparable success is in tasks that require extensive planning and symbolic reasoning, with the exception of two-player games (Silver et al., 2016; 2017; Berner et al., 2019; Vinyals et al., 2019). In such games, deep learning systems exhibit a considerable degree of reasoning, especially when trained with self-play combined with a search procedure such as Monte Carlo Tree Search (MCTS) (Browne et al., 2012). But the resulting reasoning abilities achieved are limited due to the relatively narrow scope of games.
+
+As such, theorem proving in interactive proof assistants, or formal mathematics, appears as an interesting game-like domain to tackle due to its increased scope. The typical tasks consist of generating a machine-checkable proof given a formal statements. Like games, formal mathematics has an automated way of determining whether a trajectory (i.e. a proof) is successful (i.e. formally correct). But the vast scope of formal mathematics means that any strong reasoning result obtained in it will be more meaningful than comparable results in games (e.g. finding proofs to mathematical conjectures), and could even be applicable to important practical problems (e.g. software verification).
+
+However, tackling formal mathematics involves two main challenges that we must address in order to continue making progress:
+
+Infinite action space Not only does formal mathematics have an extremely large search space (like Go (Silver et al., 2016) for example), it also has an infinite action space. At each step of proof search, the model must choose not from a well-behaved finite set of actions, but a complex and infinite set of tactics, potentially involving exogenous mathematical terms that have to be generated (e.g., generating a mathematical statement to be used as a witness, an object used steps such as “there exists an x ...”, or a cut, the introduction and the chaining of a lemma in the middle of a proof).
+
+No direct self-play setup In formal mathematics, a prover is not playing against an opponent but against a set of statements to prove. When faced with a statement that is just too hard, there is no obvious reframing of the formal mathematics setup that will let the prover generate intermediary easier statements to tackle first. This asymmetry prevents naive application of the symmetric self-play algorithms commonly used in 2-player games.
+
+These two differences make a naive application of reinforcement learning to formal mathematics leave a large room for improvement (Whalen, 2016; Winands et al., 2008). Past work proposed to address the infinite action space problem by sampling from a language model (Polu & Sutskever, 2020), while training such language model requires a large dataset of statements with proof. This paper focuses on this second problem and our basis for addressing it is the observation that the key role of self-play is to provide an unsupervised curriculum. We propose instead to supply auxiliary sets of problem statements (without requiring proofs) of varying difficulty. We empirically show that, when the difficulty of these auxiliary problems is varied enough, a simple expert iteration procedure is able to solve a curriculum of increasingly difficult problems, eventually generalizing to our target distribution. We show that this works with both automatically-generated and manually-curated auxiliary distributions of problems and leverage this to achieve state-of-the-art on the miniF2F benchmark. Our results suggest that continuous self-improvement in formal mathematics can potentially be reduced to the problem of generating such sets of formal statements, which we have done in part manually in this work, but could eventually be scaled in the future with more automation (such as more domain-specific statements generator or even informal to formal machine translation).
+
+miniF2F benchmark In this work, we target the miniF $2 F$ (Zheng et al., 2022) benchmark, which consists of 244 validation and 244 test formalized statements of mathematical problems from various competitions. We believe it to be a better measure of mathematical reasoning compared to a formal library-derived split. Also, the extreme scarcity in formal libraries of this type of problems makes it an ideal test-bed for the expert iteration methodology studied in this paper.
+
+# 2 RELATED WORK
+
+Our work strongly relies on, and can be seen as a natural continuation of the work presented in the original GPT-f paper (Polu & Sutskever, 2020) which studies the use of language models to generate tactics, the PACT paper (Han et al., 2022) which applies GPT-f to Lean and studies the benefits from co-training on self-supervised objectives, and the miniF2F benchmark (Zheng et al., 2022). We present additional related work in Appendix A.
+
+# 3 FORMAL ENVIRONMENT
+
+We choose Lean (de Moura et al., 2015; lea) as our formal environment. Unlike Metamath (Megill & Wheeler, 2019) , which has been studied in the original GPT-f paper (Polu & Sutskever, 2020), Lean benefits from high-level tactics which were shown to be beneficial in the context of the miniF2F benchmark. Also, Lean has recently received a lot of attention from the mathematical community, thanks to projects such as the Perfectoid Spaces (Buzzard et al., 2019) and the Liquid Tensor experiment (Scholze, 2020), and benefits from a vibrant community of hundreds of contributors to its main mathematical library called mathlib. We refer to the PACT paper’s Background section (Han et al., 2022) for a detailed introduction to Lean in the context of neural theorem proving. We refer to Appendix D for an illustration of miniF2F input and Lean environment.
+
+lean-gym In the PACT paper (Han et al., 2022), proof search is performed by the Lean runtime using the LEANSTEP environment, with a generic backend interface to models. While easy to use–one just needs to plug in their model–this approach makes it difficult to alter and iterate on the search procedure because it is programmed in Lean (which is not designed or intended for cluster-wide parallelised I/O intensive tasks), and the coupling of the search procedure with the Lean runtime introduces challenges when scaling to a large number of parallel workers.
+
+To solve these issues we implemented lean-gym1 – a simple REPL interface over the standard input/output implemented in Lean directly. We present lean-gym’s API and discuss some of its advantages and limitations in Appendix B.
+
+Proof extraction We rely on the proof extraction methodology presented in the PACT paper (Han et al., 2022) to extract human tactic proof steps from mathlib (the tactic dataset) as well as the various other proof artifacts $( \mathsf { m i x } 1$ and $\mathfrak { m i x 2 }$ datasets). We also extract mathlib-{train, valid, test}, the set of statements from mathlib along the split proposed in Han et al. (2022) (the validation and test splits of tactic, mix1, mix2 being aligned with mathlib-{valid, test} as the splits are determined by declaration name hashes (across all data sources including proof-term mining) as opposed to individual proof steps or data-points.
+
+# 4 EXPERT ITERATION
+
+Expert iteration was introduced in Silver et al. (2017) and broadly consists in iteratively training models on their previously sampled trajectories, to achieve continuous improvement. In this section we present our expert iteration methodology, including the models and pre-training strategies. We use decoder-only Transformers similar to GPT-3 (Brown et al., 2020). Throughout this paper we focus on a model with 36 layers and 774 million trainable parameters (referred to as the 700m model in the GPT-f paper (Polu & Sutskever, 2020)).
+
+# 4.1 PRE-TRAINING
+
+We pre-train our models successively on GPT-3’s post-processed version of CommonCrawl (for 300B tokens) and an updated version of WebMath (Polu & Sutskever, 2020) (for 72B tokens) whose mix is presented in Appendix C.
+
+# 4.2 TRAINING OBJECTIVES
+
+Proofstep objective The proofstep objective, introduced in Polu & Sutskever (2020), consists in generating a PROOFSTEP (a Lean tactic) given a GOAL (a Lean tactic state). We also condition this objective on the current DECLARATION (a Lean theorem name), which remains the same throughout a proof search: DECL <DECLARATION> GOAL <GOAL> PROOFSTEP <PROOFSTEP>.
+
+The rationale for conditioning on the declaration name is to hint our models on the position of the current declaration in the mathlib library. It can be considered as a weak proxy signal for the large amount of information not shown to the model (the full environment consisting of the available imports and currently open declarations such as module names, notations, declared instances, ...). The declaration name lets models at least in principle memorize and then retrieve some of that information, knowing that lean-gym errors if a theorem or definition that is not available in the environment associated with the current declaration is used by tactics generated by our models. Also note that conversely to Polu & Sutskever (2020) and like Han et al. (2022) ${ < } G O A L >$ is not necessarily a single goal but a Lean tactic state, which possibly comprises multiple goals.
+
+Proofsize objective We depart from Polu & Sutskever (2020) and use a proofsize objective to guide our proof searches, which consists in generating one token that represents a proof size estimate bucket for the current goal (Lean tactic state): DECL <DECLARATION> GOAL ${ < } G O A L >$ PROOFSIZE <PROOFSIZE_BUCKET_TOKEN>
+
+For a given goal $g$ , either the goal was proved as part of the proof search and we denote its proof size (the number of tactic applications (compounded Lean tactics counting as one)) as $p s ( g )$ , or the goal was not proved in which case we assign the goal to a bucket that virtually represents "infinite" proof sizes.
+
+We use 11 buckets $B = 0 . . . 1 0$ and compute the proofsize bucket $b ( g )$ for a goal $g$ by assigning infinite proof sizes to bucket 0, all proof sizes over 20 to bucket 1 and linearly projecting proof sizes lower than 20 on the remaining buckets $2 , . . . , 1 0$ (10 being the bucket for the shortest proof sizes). In practice, when training and sampling from the model, we map $B$ to the tokens $\therefore \mathrm { A \Omega } . . . \mathrm { K \Omega }$ .
+
+To value goals as we run proof searches, we sample the proofsize bucket token and record the probability $p _ { b } ( g )$ for each viable bucket and use them to get a weighted average with the following formula: $\begin{array} { r } { \dot { v } ( \dot { g } ) = \frac { 1 } { \# B } \sum _ { b \in B } p _ { b } ( g ) \cdot b } \end{array}$ . As an example, if the model assigns $p _ { 0 } = 1$ (hence $p _ { b \neq 0 } = 0$ ) then $v ( g ) = 0$ . Conversely if the model assigns $p _ { 1 0 } = 1$ (10 being the bucket for the shortest proof sizes) then $v ( g ) = 1$ .
+
+Table 1: Performance of $\theta _ { 0 }$ and $\theta _ { 1 }$ on mathlib-valid and miniF $_ { 2 F }$ -valid compared to PACT Lean GPT-f as reported in Han et al. (2022); Zheng et al. (2022). All models have the same architecture. $\theta _ { 0 }$ is sampled using cumulative logprob priority best-first search. $\theta _ { 1 }$ is sampled using best-first search based on the proofsize objective. We report our setup $d = 5 1 2$ expansions and $e = 8$ tactic samples per expansions) as well as the setups used in Han et al. (2022); Zheng et al. (2022) (denoted as $\theta _ { 0 } ^ { * }$ ) to control for compute. We also report the performance of $\theta _ { 1 }$ on mathlib-valid when trained using the outcome objective (denoted as $\theta _ { 1 } ^ { \prime }$ ) from Polu & Sutskever (2020) as an ablation of our proposed proofsize objective.   
+
+<table><tr><td>Model</td><td>d</td><td>e</td><td>pass@1</td><td>pass@8</td></tr><tr><td>mathlib-valid</td><td></td><td></td><td></td><td></td></tr><tr><td>PACT</td><td>512</td><td>16</td><td>48.4%</td><td></td></tr><tr><td>0</td><td>512</td><td>16</td><td>48.5%</td><td>57.6%</td></tr><tr><td>0</td><td>512</td><td>8</td><td>46.7%</td><td>57.5%</td></tr><tr><td>01</td><td>512</td><td>8</td><td>56.3%</td><td>66.3%</td></tr><tr><td>0</td><td>512</td><td>8</td><td>55.6%</td><td>65.9%</td></tr></table>
+
+<table><tr><td>Model</td><td>d</td><td>e</td><td>pass@1</td><td>pass@8</td></tr><tr><td colspan="3">miniF2F-valid</td><td></td><td></td></tr><tr><td>miniF2F</td><td>128</td><td>16</td><td>23.9%</td><td>29.3%</td></tr><tr><td></td><td>128</td><td>16</td><td>27.6%</td><td>31.8%</td></tr><tr><td>0</td><td>512</td><td>8</td><td>28.4%</td><td>33.6%</td></tr><tr><td>01</td><td>512</td><td>8</td><td>28.5%</td><td>35.5%</td></tr><tr><td>0</td><td>512</td><td>8</td><td>28.3%</td><td>34.7%</td></tr></table>
+
+The rationale for using this proofsize objective instead of the outcome objective described in Polu & Sutskever (2020) is that (i) it achieves better performance compared to the outcome objective (see Table 1), and (ii) it prioritizes goals that potentially lead to shorter proofs during proof search, creating an intrinsic incentive for the system to converge towards shorter proofs. Similarly to Polu & Sutskever (2020) we favor this token-based approach to the introduction of a separate value head to keep the overall architecture simple. This way the proofsize objective can be implemented by simply augmenting the training dataset and without any architectural change.
+
+# 4.3 BOOTSTRAPPING
+
+Bootstrapping consists in the steps required to train an initial model on both the proofstep objective and the proofsize objective.
+
+Given a pre-trained model on WebMath, we fine-tune it on the tactic dataset extracted from mathlib as well as the proof artifacts dataset mix1 as described in Han et al. (2022). This initial model, which we denote $\theta _ { 0 }$ is solely trained on the proofstep objective. We use the validation splits of the tactic and m1 datasets to early-stop training. Note that this is our only use of mathlib-valid to influence the training process throughout this paper.
+
+To generate data for the proofsize objective, we use $\theta _ { 0 }$ to sample proofs for statements from mathlibtrain. For each statement from mathlib-train (25k) we attempt $a = 1$ proof searches using the cumulative logprob priority search described in Polu & Sutskever (2020) (which does not require a trained value function) using $d = 5 1 2$ expansions and $e = 8$ samples per expansion. We denote the set of successful proof searches created in this process as $S _ { 0 }$ .
+
+Using $S _ { 0 }$ we generate dataset $D _ { 0 }$ by concatenating: (i) the initial tactic dataset (proofstep objective), (ii) a deduplicated set of proofsteps extracted from the proofs in $S _ { 0 }$ (proofstep objective) and (iii) a deduplicated set of proofsize tuples (goals and proofsize) extracted from the full proof searches in $S _ { 0 }$ (proofsize objective).
+
+Note that the full proof searches in $S _ { 0 }$ include goals that are visited but eventually remain unproved, which provides useful negative examples for the trained value function (even if these negatives may include provable goals that simply were not prioritized by the search). Also note that $S _ { 0 }$ doesn’t include failed proof searches.
+
+We fine-tune $\theta _ { 0 }$ on $D _ { 0 }$ for exactly one epoch (no use of validation data for early-stopping) to obtain our initial model $\theta _ { 1 }$ trained on both the proofstep objective and the proofsize objective. $\theta _ { 0 }$ is used in our expert iteration setup as base model to fine-tune from at each iteration, and $\theta _ { 1 }$ is our first iterated model or mathlib bootstrapped model trained on both objectives.
+
+We report in Table 1 the pass rates of $\theta _ { 0 }$ and $\theta _ { 1 }$ on mathlib-valid and miniF2F-valid and compare with previously reported pass rates for equivalent amounts of compute. As reported in Polu & Sutskever (2020), training a value function to guide search greatly improves the pass rates of $\theta _ { 1 }$ on mathlib-valid.
+
+Interestingly, the gap between $\theta _ { 0 }$ and $\theta _ { 1 }$ on miniF ${ } ^ { 7 2 F }$ -valid is not as significant, demonstrating that training a value function on proofs sampled from mathlib-train has limited transfer to miniF2F-valid. The main differences with Zheng et al. (2022), potentially explaining the gap on miniF2F-valid $( 2 7 . 6 \%$ vs $2 3 . 9 \%$ ), consists in the new pre-training described in Section 4.1 as well as the use of a more recent mathlib checkpoint for the mix1, mix2 and tactic datasets.
+
+# 4.4 ITERATED SAMPLING AND TRAINING
+
+Our expert iteration process takes as input: (i) a set of formal statements $S t$ , (ii) a function $a : S t  \mathbb { N }$ indicating the number of proof search attempts to run per statement at each iteration, (iii) a base model $\theta _ { 0 }$ to fine-tune from at each iteration, and (iv) a mathlib bootstrapped model $\theta _ { 1 }$ trained on both objectives. A high-level illustration of the iterated sampling and training is available in Appendix E.
+
+Each iteration $k$ consists in sampling proof searches for statements in $S t$ using $\theta _ { k }$ , filtering successful proof searches $S _ { k }$ to extract a new dataset $D _ { k }$ , and fine-tuning $\theta _ { 0 }$ on it to obtain $\theta _ { k + 1 }$ , on which we can iterate. To sample proof searches from $S t$ we use the best-first search described in Polu $\&$ Sutskever (2020) with the value function described in Section 4.2. We attempt $a$ proof searches for each statement $s ( s \in S t )$ with $d = 5 1 2$ expansions and $e = 8$ samples per expansion. We denote the set of successful proof searches for iteration $k$ as $S _ { k }$ .
+
+Using $S _ { k }$ we generate datasets $D _ { k }$ by concatenating: (i) the initial tactic dataset (proofstep objective), (ii) a deduplicated set of proofsteps extracted from the proofs in $\textstyle \bigcup _ { 1 \leq i \leq k } { \bar { S } } _ { k }$ (proofstep objective), and (iii) a deduplicated set of proofsize tuples (goals and proofsize) extracted from the full proof searches in $\textstyle \bigcup _ { 1 \leq i \leq k } S _ { k }$ (proofsize objective).
+
+We use a global deduplication across iterations for both proofsteps and proofsize tuples which we found to be important to maintain the stability of the expert iteration procedure. This global deduplication is somewhat equivalent for each statement to growing a unique proof tree by aggregating all the proof searches that have been run for it across iterations. This virtual proof tree accumulates a growing number of positive proof paths and visited goals that remain unproven. We use these goals as negative examples for the proofsize objective, labeling them with an infinite proofsize. Positive goals are deduplicated keeping the minimum proof sizes across proof searches.
+
+Finally $\theta _ { k }$ is obtained by fine-tuning $\theta _ { 0 }$ for exactly one epoch on $D _ { k }$ . Note that the initial tactic dataset is included in each $D _ { k }$ , despite $\theta _ { 0 }$ being already trained on it (along with mix1). We found this repetition to be beneficial overall (as it adds the mathlib extracted proofsteps to our deduplicated per statements virtual proof trees) despite it leading to a slight overfit on the tactic dataset in terms of validation loss.
+
+# 4.5 EXPERT ITERATION ON mathlib-train
+
+In this section we propose to set $S t$ to the statements in mathlib-train, run our expert iteration process with it and report performance on both mathlib-valid and miniF2F-valid. Performance is reported in terms of pass rate (percentage of successful proof searches) as a function of the number of attempts per statement, noted pass $@ k$ where $k$ is the number of attempts per statement at test time. To reduce noise in these metrics we run more than $k$ attempts at test time (generally 32 to compute pass@1 and $p a s s @ 8 )$ ), averaging across attempts as needed to obtain a smoother pass $@ k$ value.
+
+Given the large number of statements in mathlib-train (25k) we uniformly set $a = 1$ and use $\theta _ { 0 }$ and $\theta _ { 1 }$ as described in Section 4.3 and report pass $@ l$ and pass $@ 8$ across 8 iterations in Figure 1. The pass $@ l$ on mathlib-valid goes from $5 6 . 3 \%$ for $\theta _ { 1 }$ to $6 2 . 6 \%$ for $\theta _ { 9 }$ . The performance steadily improves and follows a clear logarithmic scaling law on mathlib-valid. It is also notable that, initially, transfer to out-of-distribution miniF2F-valid appears limited but eventually kicks in as we reach better performance on mathlib-valid. This demonstrates that the expert iteration process does not just overfit to mathlib but also leads to improved performance on out-of-distribution statements.
+
+We define the cumulative pass rate at iteration $k$ as the pass rate consisting of all proof searches up to iteration $k$ . Since we set $a = 1 6$ for evaluation on mathlib-valid and miniF $2 F$ -valid at each iteration, the cumulative pass rate at iteration $k$ can be seen as a noisy ensembled pass@16k (multiple models $( \theta _ { k } )$ , no averaging). In Figure 2, we report this cumulative pass rate for two iteration loops, our normal one and a sampling-only loop where we skip re-training the model between iterations and solely sample from $\theta _ { 1 }$ . This directly compares test-time compute scaling (scaling proof search attempts) to expert iteration scaling (interleaved training on new data sampled from mathlib-train) and provides a very clear visualization of the gains of expert iteration. For a fair comparison, we also report an adjusted compute line which approximates the test-time performance we would get at each iteration if we were to focus all the additional compute used by expert iteration (sampling proofs from mathlib-train as well as re-training models at each iteration) towards solely running proof searches against mathlib-valid.
+
+![](images/b3074a05d2f2dc8531883c0879a996434568be2cda8eabc704d7c13bb00cb518.jpg)  
+Figure 1: pass@1 (plain) and pass $@ 8$ (dotted) for mathlib-valid and miniF $2 F$ -valid when running 8 expert iterations with $S t$ set to be the statements in mathlib-train. The $\mathbf { X }$ -axis is logscaled. It corresponds to the indices of the $\theta _ { k }$ models and serves as a good proxy to compute (the amount of test-time and train-time compute per iteration being fixed). The y-axis is scaled linearly and simply shifted between the two graphs (spans an equal range).
+
+![](images/38941263e270ef1dee3e9ee38ec54488b4d20a21af9e25a74e35817020c58cf8.jpg)  
+Figure 2: Cumulative pass rate for our expert iteration loop as well as a sample only loop where we skip re-training the model between iterations. The adjusted compute line is computed by fitting the sample only curve and shifting it to approximate a setup where we would focus all the additional compute used by expert iteration (sampling training data from mathlib-train as well as re-training models at each iteration) towards running proof searches against mathlibvalid.
+
+As shown by Figure 2, the scaling exponent of expert iteration is substantially higher than the scaling exponent associated with solely scaling test-time compute (running more proof searches), demonstrating the clear benefit of expert iteration. We’ll denote the fully iterated model from this section as θmathlib9 .
+
+Even in the presence of ground-truth proofs for each of the statements in mathlib-train (tactic dataset), expert iteration generates data that further improves the performance of the model. The number of statements proved in mathlib-train goes from 17390 $( 6 7 . 8 \% )$ at iteration 1 to 19476 $( 7 6 . 0 \% )$ at iteration 9, while the average proof length of these statements goes from 4.8 to 4.0. We hypothesize that this continuously improving performance through expert iteration stems from two effects: (i) the model finding new original proofs for the same statements and (ii) the model closing marginally harder statements at each iteration – which in turn provides more useful training data for the next iteration. By iteration 9, the model is trained on more than $9 0 \%$ generated data. We present in Appendix I a few examples of original proofs found by our models on mathlib-train compared with their ground-truth versions.
+
+To verify our hypothesis that expert iteration is capable of closing a curriculum of increasingly difficult problems out of a set of problem statements, and that this capability is independent of having access to ground-truth proofs, we propose in the next section to study expert iteration applied to a synthetically generated set of problems for which we have fine-grained control on the difficulty of each statement.
+
+# 5 STATEMENT CURRICULUM LEARNING
+
+In this section we focus on running expert iteration on synthetic statements generated by an inequality generator. The use of synthetic statements enables us to control the difficulty of each statement to present evidence that expert iteration can hill-climb the intrinsic difficulty gradient of the resulting set
+
+of statements. In particular, we show that, at fixed compute budget, expert iteration eventually closes proofs of hard statements that remain completely out of reach of simply sampling proof searches without interleaved training.
+
+# 5.1 SYNTHETIC INEQUALITY GENERATOR
+
+We designed a synthetic inequality statement generator for Lean in the spirit of the INT (Wu et al., 2021) generator. The generator consists in generating inequalities from well known inequality theorems (AM-GM, Trivial inequality, Cauchy-Schwarz, Bernoulli, Young, Hölder) and composing them. It is driven by two difficulty parameters: $N _ { D }$ which controls depth of composition of inequalities and $N _ { S }$ which controls the complexity of the input expressions to the composed inequalities. We provide details on its implementation in Appendix F.
+
+Using this generator we generate a curriculum of 5600 inequality statements (for which we don’t have proofs), 100 for each values of $0 \le N _ { S } \le 7$ and $0 \le N _ { D } \le 6$ . We denote this set of statements as synth-ineq. To bootstrap our models capabilities on this specific task, we also generate 100 statements of low difficulty ( $N _ { D } = 1$ and $N _ { S } = 5$ ) and formalize a proof for each of these statements. We refer to this dataset as synth-ineq-train. In the rest of this paper we adjunct this training dataset to the tactic dataset used to train our models.
+
+# 5.2 EXPERT ITERATION ON SYNTHETIC INEQUALITY STATEMENTS
+
+In this section we propose to set $S t$ to the union of the statements in mathlib-train and synth-ineq. Again, we uniformly set $a = 1$ and use $\theta _ { 0 }$ and $\theta _ { 1 }$ as described in Section 4.3, except that they are now also trained on synth-ineq-train.
+
+Similarly to the previous section, we report in Figure 3 the cumulative pass rate for two loops, our standard expert iteration loop, and a proof search only loop where we do not interleave training between iterations. The pass rates are reported split by values of $N _ { D }$ (pooling together $0 \le N _ { S } \le 7$ ) which we found to be the main driver for difficulty.
+
+![](images/33f55772b311eab974522ad234fc4f4e9c0106ba9fd7089993d50b26eaa7d7d2.jpg)  
+Figure 3: Cumulative pass rate for our expert iteration loop as well as a sample only loop where we skip re-training the model between iterations. Pass rates are reported for each value of $N _ { D }$ (pooling together $0 \le N _ { S } \le 7$ ).
+
+Despite the challenging nature of these synthetic inequalities, Figure 3 demonstrates that expert iteration is capable of learning the intrinsic curriculum induced by synth-ineq. In particular, expert iteration is capable of closing 6 problems of difficulty $N _ { D } = 6$ without having been provided with any seed ground-truth proof for this difficulty level. Note that difficulty $N _ { D } = 6$ remains completely out of reach of simply scaling the number of attempts per statements (the sample only loop remaining stuck at 0 for $N _ { D } = 6$ ).
+
+This confirms on our synthetic statements dataset synth-ineq that not only expert iteration is capable of learning the curricula occurring in a set of statements, but this process also enables the emergence of new capabilities without the need for ground-truth proofs (ability to close, highly challenging, deeply composed inequalities).
+
+# 6 TARGETING miniF2F
+
+Motivated by the results from Section 5, we curated and manually formalized a set of math exercises denoted as miniF $2 F$ -curriculum to target miniF2F. miniF $2 F$ -curriculum contains 327 statements from various sources, with their provenance and analysis detailed in Appendix G.
+
+miniF $2 F$ statements being quite out of distribution compared to mathlib statements (which typically are generic theorems and lemmas), we hypothesized that if the difficulty of miniF2F-curriculum was made varied enough, expert iteration could potentially leverage it to effectively shift our models’ distribution closer to miniF $2 F$ ’s, and in turn, improve their eventual performance on it.
+
+# 6.1 TRANSFER TO miniF2F
+
+In this section we propose to set $S t$ to the union of the statements in mathlib-train, synth-ineq and miniF2F-curriculum. We uniformly set $a = 1$ on mathlib-train and synth-ineq and $a = 8$ on miniF $2 F$ -curriculum and use $\theta _ { 0 }$ and $\theta _ { 1 }$ as described in Section 5.
+
+Similarly to previous sections, we report in Figure 4 (left) the cumulative pass rate on miniF $2 F$ -valid of our full curriculum expert iteration loop and compare them with the mathlib-train only expert iteration from Section 4.5. Since more compute is deployed in our full-curriculum loop (more statements), we also report a mathlib-train only loop taking $a = 2$ . At the end of the expert iteration, 100 out of the 327 statements from miniF $2 F .$ -curriculum end up being closed, suggesting a lack of density in our manually formalized set of statement.
+
+We also report in Figure 4 (right) the pass $@ l$ and pass $@ 8$ for our full curriculum expert iteration loop. The steady improvement on miniF2F-valid shows that the expert iteration procedure we propose does not overfit on the statements that compose the curriculum it uses. Despite the potential inefficiency of our curriculum, the improved performance associated with its use demonstrates, as hypothesized, an effective transfer between miniF ${ } ^ { 7 2 F }$ -curriculum, synth-ineq and miniF2F-valid through expert iteration. We will denote the fully iterated model from this section as $\theta _ { 9 } ^ { f u l l }$ .
+
+![](images/04a8b08c5b09b13442660861e017e088784c96f4097bff3f86db3eb43c8ba58a.jpg)  
+Figure 4: Left: cumulative pass rate on miniF $2 F$ -valid for our expert iteration loop using our full curriculum (mathlib-train, synth-ineq and miniF $2 F$ -curriculum) compared to the expert iteration loop from Section 4.5. The total number of attempts per iteration in our full loop is $2 5 k + 5 . 6 k + 8 * 3 2 7 \approx$ $3 3 . 2 k$ , which means the total compute deployed is higher than in the mathlib-train only loop $( 2 5 k )$ . We therefore also report in dotted a mathlib-train only loop, taking $a = 2$ , whose total number of attempts per iteration is $\approx 5 0 k$ . Right: pass $@ l$ (plain) and pass $@ 8$ (dotted) for our expert iteration loop using our full curriculum (mathlib-train, synth-ineq and miniF $2 F$ -curriculum) compared to the expert iteration loop from Section 4.5.
+
+# 6.2 RESULTS
+
+We report in Table 2 the pass rates on mathlib-{valid, test} and miniF2F-{valid, test} for the models trained in previous sections, namely $\theta _ { 1 }$ , θmathlib9 , and $\theta _ { 9 } ^ { f u l l }$ . We achieve a $4 7 . 3 \%$ pass rate (using $a = 6 4$ attempts) on miniF $2 F .$ -valid and a $3 6 . 6 \%$ pass rate on miniF2F-test, substantially improving from the previous state-of-the-art (Zheng et al., 2022).
+
+These results include the resolution of 26 AMC12 problems, 6 AIME problems and 2 IMO-adapted problems. Out of these statements, 4 AMC12 problems (amc12b_2020_p5, amc12a_2009_p9, amc12a_2003_p24, amc12b_2003_p17), 2 AIME problems (aime_1984_p1, aime_1990_p4), and 2 IMO-adapted problems $( \mathrm { i } \mathsf { m o } _ { - } 1 9 6 1 \mathsf { \Pi } _ { - } \mathsf { p } 1 ^ { 2 }$ , imo_1964_p2) are uniquely solved by expert iterated models, the two IMO-adapted and the two AIME problems being uniquely solved by $\theta _ { 9 } ^ { \bar { f } u l l }$ .
+
+Table 2: Performance of $\theta _ { 1 }$ (value-function based search), $\theta _ { 9 } ^ { m a t h l i b }$ (expert iterated on mathlib-train) and $\theta _ { 9 } ^ { f u l l }$ (expert iterated on our full curriculum) on mathlib-{valid, test} and miniF2F-{valid, test}. All proof searches are run with $d = 5 1 2$ and $e = 8$ .   
+
+<table><tr><td>Model</td><td>pass@1</td><td>pass@8</td><td>pass@64</td><td>pass@1</td><td>pass@8</td><td>pass@64</td></tr><tr><td>mathlib-valid</td><td></td><td></td><td></td><td>mathlib-test</td><td></td><td></td></tr><tr><td>PACT (Han et al.,2022)</td><td>48.4%</td><td></td><td></td><td>=</td><td></td><td></td></tr><tr><td>01</td><td>56.3%</td><td>66.3%</td><td>72.0%</td><td>56.5%</td><td>66.9%</td><td>73.7%</td></tr><tr><td></td><td>62.6%</td><td>70.7%</td><td>75.8%</td><td>63.0%</td><td>71.5%</td><td>77.1%</td></tr><tr><td>G</td><td>61.7%</td><td>69.8%</td><td>75.3%</td><td>62.9%</td><td>71.6%</td><td>76.3%</td></tr><tr><td>miniF2F-valid</td><td></td><td></td><td></td><td>miniF2F-test</td><td></td><td></td></tr><tr><td>PACT (Zheng et al., 2022)</td><td>23.9%</td><td>29.3%</td><td></td><td>24.6%</td><td>29.2%</td><td></td></tr><tr><td>01</td><td>28.5%</td><td>35.5%</td><td>41.2%</td><td>25.9%</td><td>31.1%</td><td>33.6%</td></tr><tr><td>ggahibh</td><td>31.3%</td><td>38.3%</td><td>44.1%</td><td>27.2%</td><td>33.0%</td><td>35.2%</td></tr><tr><td></td><td>33.6%</td><td>41.2%</td><td>47.3%</td><td>29.6%</td><td>34.5%</td><td>36.6%</td></tr></table>
+
+We provide a selection of the proofs found by our models for these statements as well as a qualitative analysis of them in Appendix J. Also, we achieve a new state-of-the-art: higher than $7 5 \%$ pass rate (using $a = 6 4$ attempts) on mathlib-{valid, test}, suggesting that our models could potentially be effectively leveraged as proof assistants in the formalization efforts associated with mathlib.
+
+# 7 DISCUSSION AND LIMITATION
+
+Throughout this paper, we used a single model size ( $7 7 4 \mathrm { m }$ trainable parameters). We refer readers to Appendix H for more discussion on model size, compute budget and training time. Despite our models’ capability, as discussed in Appendix J.1, to generate cuts and witnesses, we believe that their current main limitation lies in their inability (under our proposed search procedure) to chain more than 2 or 3 non-trivial steps of mathematical reasoning, preventing them from consistently solving challenging olympiad problems. We’ve been repeatedly impressed by the complexity of some of the proofsteps generated by our models. But, proofs requiring many of such reasoning steps remain beyond our current compute horizon. Even if we solved a selection of challenging olympiad problems, our models are still far from being competitive with the brightest students in these competitions.
+
+While our models have demonstrated some capabilities to generate cuts, the cuts they generate are often shallow (they involve only a few proofsteps and don’t necessarily deeply change the structure of the proof–we refer the reader to the Cut-Elimination theorem and Carbone & Semmes (1996) for a discussion of the influence of cuts on proof size). We believe that studying language models’ ability to generate cuts, and designing search procedures that leverage that capability (related ideas can be found in Czechowski et al. (2021)), are interesting avenues of research to alleviate this limitation.
+
+# 8 CONCLUSION
+
+In this paper we presented an expert iteration procedure for GPT-f (Polu & Sutskever, 2020), demonstrating that it is capable of solving a curriculum of increasingly difficult problems out of a set of formal statements of sufficiently varied difficulty. Our results suggest that the lack of self-play in the formal mathematics setup can be effectively compensated for by automatically/manually curated sets of formal statements, which are much cheaper to formalize than full proofs. Finally, we hope that the statement curriculum learning methodology we presented in this work will help accelerate progress in automated reasoning, especially if scaled with automated generation and curation of formal statements in the future.
+
+# REFERENCES
+
+Lean theorem prover. https://leanprover.github.io/about/.
+
+Kshitij Bansal, Sarah M Loos, Markus N Rabe, and Christian Szegedy. Learning to reason in large theories without imitation. arXiv preprint arXiv:1905.10501, 2019a.
+
+Kshitij Bansal, Sarah M. Loos, Markus N. Rabe, Christian Szegedy, and Stewart Wilcox. Holist: An environment for machine learning of higher order logic theorem proving. In Kamalika Chaudhuri and Ruslan Salakhutdinov (eds.), Proceedings of the 36th International Conference on Machine Learning, ICML 2019, volume 97 of Proceedings of Machine Learning Research, pp. 454–463. PMLR, 2019b. URL http://proceedings.mlr.press/v97/bansal19a.html.
+
+Christopher Berner, Greg Brockman, Brooke Chan, Vicki Cheung, Przemysław D˛ebiak, Christy Dennison, David Farhi, Quirin Fischer, Shariq Hashme, Chris Hesse, et al. Dota 2 with large scale deep reinforcement learning. arXiv preprint arXiv:1912.06680, 2019.
+
+Tom Brown, Benjamin Mann, Nick Ryder, Melanie Subbiah, Jared D Kaplan, Prafulla Dhariwal, Arvind Neelakantan, Pranav Shyam, Girish Sastry, Amanda Askell, Sandhini Agarwal, Ariel Herbert-Voss, Gretchen Krueger, Tom Henighan, Rewon Child, Aditya Ramesh, Daniel Ziegler, Jeffrey Wu, Clemens Winter, Chris Hesse, Mark Chen, Eric Sigler, Mateusz Litwin, Scott Gray, Benjamin Chess, Jack Clark, Christopher Berner, Sam McCandlish, Alec Radford, Ilya Sutskever, and Dario Amodei. Language models are few-shot learners. In H. Larochelle, M. Ranzato, R. Hadsell, M.F. Balcan, and H. Lin (eds.), Advances in Neural Information Processing Systems, volume 33, pp. 1877–1901. Curran Associates, Inc., 2020. URL https://proceedings.neurips. cc/paper/2020/file/1457c0d6bfcb4967418bfb8ac142f64a-Paper.pdf.
+
+Cameron B Browne, Edward Powley, Daniel Whitehouse, Simon M Lucas, Peter I Cowling, Philipp Rohlfshagen, Stephen Tavener, Diego Perez, Spyridon Samothrakis, and Simon Colton. A survey of monte carlo tree search methods. IEEE Transactions on Computational Intelligence and AI in games, 4(1):1–43, 2012.
+
+Kevin Buzzard, Johan Commelin, and Patrick Massot. Lean perfectoid spaces. https:// leanprover-community.github.io/lean-perfectoid-spaces/, 2019.
+
+Alessandra Carbone and S. Semmes. Making proofs without modus ponens: An introduction to the combinatorics and complexity of cut elimination. Bulletin of the American Mathematical Society, 34:131–159, 1996.
+
+Konrad Czechowski, Tomasz Odrzygó´zd´z, Marek Zbysinski, MichałZawalski, Krzysztof Ole- ´ jnik, Yuhuai Wu, Ł ukasz Kucinski, and Piotr Mił o ´ s. Subgoal search for complex rea- ´ soning tasks. In M. Ranzato, A. Beygelzimer, Y. Dauphin, P.S. Liang, and J. Wortman Vaughan (eds.), Advances in Neural Information Processing Systems, volume 34, pp. 624–638. Curran Associates, Inc., 2021. URL https://proceedings.neurips.cc/paper/2021/file/ 05d8cccb5f47e5072f0a05b5f514941a-Paper.pdf.
+
+Leonardo de Moura, Soonho Kong, Jeremy Avigad, Floris Van Doorn, and Jakob von Raumer. The lean theorem prover (system description). In International Conference on Automated Deduction, pp. 378–388. Springer, 2015.
+
+Jacob Devlin, Ming-Wei Chang, Kenton Lee, and Kristina Toutanova. BERT: pre-training of deep bidirectional transformers for language understanding. In Jill Burstein, Christy Doran, and Thamar Solorio (eds.), Proceedings of the 2019 Conference of the North American Chapter of the Association for Computational Linguistics: Human Language Technologies, NAACL-HLT 2019, volume 1, pp. 4171–4186. Association for Computational Linguistics, 2019. doi: 10.18653/v1/ n19-1423. URL https://doi.org/10.18653/v1/n19-1423.
+
+Vlad Firoiu, Eser Aygun, Ankit Anand, Zafarali Ahmed, Xavier Glorot, Laurent Orseau, Lei Zhang, Doina Precup, and Shibl Mourad. Training a first-order theorem prover from synthetic data. arXiv preprint arXiv:2103.03798, 2021.
+
+Jesse Michael Han, Jason Rute, Yuhuai Wu, Edward Ayers, and Stanislas Polu. Proof artifact cotraining for theorem proving with language models. In International Conference on Learning Representations, 2022. URL https://openreview.net/forum?id=rpxJc9j04U.
+
+Dan Hendrycks, Collin Burns, Saurav Kadavath, Akul Arora, Steven Basart, Eric Tang, Dawn Song, and Jacob Steinhardt. Measuring mathematical problem solving with the MATH dataset. In Joaquin Vanschoren and Sai-Kit Yeung (eds.), Proceedings of the Neural Information Processing Systems Track on Datasets and Benchmarks 1, NeurIPS Datasets and Benchmarks 2021, 2021. URL https://datasets-benchmarks-proceedings.neurips.cc/paper/2021/hash/ be83ab3ecd0db773eb2dc1b0a17836a1-Abstract-round2.html.
+
+Daniel Huang, Prafulla Dhariwal, Dawn Song, and Ilya Sutskever. Gamepad: A learning environment for theorem proving. In International Conference on Learning Representations, 2019. URL https://openreview.net/forum?id=r1xwKoR9Y7.
+
+Geoffrey Irving, Christian Szegedy, Alexander A Alemi, Niklas Een, Francois Chollet, and Josef Urban. Deepmath - deep sequence models for premise selection. In D. Lee, M. Sugiyama, U. Luxburg, I. Guyon, and R. Garnett (eds.), Advances in Neural Information Processing Systems, volume 29, pp. 2235–2243. Curran Associates, Inc., 2016. URL https://proceedings.neurips. cc/paper/2016/file/f197002b9a0853eca5e046d9ca4663d5-Paper.pdf.
+
+Albert Q Jiang, Wenda Li, Szymon Tworkowski, Konrad Czechowski, Tomasz Odrzygó´zd´z, Piotr Miłos, Yuhuai Wu, and Mateja Jamnik. Thor: Wielding hammers to integrate language models ´ and automated theorem provers. arXiv preprint arXiv:2205.10893, 2022.
+
+Jared Kaplan, Sam McCandlish, Tom Henighan, Tom B Brown, Benjamin Chess, Rewon Child, Scott Gray, Alec Radford, Jeffrey Wu, and Dario Amodei. Scaling laws for neural language models. arXiv preprint arXiv:2001.08361, 2020.
+
+Tero Karras, Samuli Laine, and Timo Aila. A style-based generator architecture for generative adversarial networks. In IEEE Conference on Computer Vision and Pattern Recognition, CVPR 2019, pp. 4401–4410. Computer Vision Foundation / IEEE, 2019. doi: 10.1109/CVPR.2019.00453. URL http://openaccess.thecvf.com/content_CVPR_2019/html/Karras_A_Style-Based_ Generator_Architecture_for_Generative_Adversarial_Networks_CVPR_2019_paper. html.
+
+Guillaume Lample, Marie-Anne Lachaux, Thibaut Lavril, Xavier Martinet, Amaury Hayat, Gabriel Ebner, Aurélien Rodriguez, and Timothée Lacroix. Hypertree proof search for neural theorem proving. CoRR, abs/2205.11491, 2022. doi: 10.48550/arXiv.2205.11491. URL https://doi. org/10.48550/arXiv.2205.11491.
+
+Sandor Lehoczky and Richard Rusczyk. The Art of Problem Solving, Volume 1: the Basics, a. ISBN:978-0-9773045-6-1.
+
+Sandor Lehoczky and Richard Rusczyk. The Art of Problem Solving, Volume 2: and Beyond, b. ISBN:978-0-9773045-8-5.
+
+Wenda Li, Lei Yu, Yuhuai Wu, and Lawrence C. Paulson. Isarstep: a benchmark for high-level mathematical reasoning. In International Conference on Learning Representations, 2021. URL https://openreview.net/forum?id=Pzj6fzU6wkj.
+
+Sarah M. Loos, Geoffrey Irving, Christian Szegedy, and Cezary Kaliszyk. Deep network guided proof search. In Thomas Eiter and David Sands (eds.), 21st International Conference on Logic for Programming, Artificial Intelligence and Reasoning, LPAR-21, volume 46 of EPiC Series in Computing, pp. 85–105, 2017. doi: 10.29007/8mwc. URL https://doi.org/10.29007/8mwc.
+
+Norman D. Megill and David A. Wheeler. Metamath: A Computer Language for Pure Mathematics, 2019. URL http://us.metamath.org/downloads/metamath.pdf.
+
+Lawrence C. Paulson. Three years of experience with sledgehammer, a practical link between automatic and interactive theorem provers. In Renate A. Schmidt, Stephan Schulz, and Boris Konev (eds.), Proceedings of the 2nd Workshop on Practical Aspects of Automated Reasoning, PAAR-2010, Edinburgh, Scotland, UK, July 14, 2010, volume 9 of EPiC Series in Computing, pp. 1–10. EasyChair, 2010. doi: 10.29007/tnfd. URL https://doi.org/10.29007/tnfd.
+
+Stanislas Polu and Ilya Sutskever. Generative language modeling for automated theorem proving. arXiv preprint arXiv:2009.03393, 2020.
+
+Markus Norman Rabe, Dennis Lee, Kshitij Bansal, and Christian Szegedy. Mathematical reasoning via self-supervised skip-tree training. In International Conference on Learning Representations, 2021. URL https://openreview.net/forum?id=YmqAnY0CMEy.
+
+Alec Radford, Jong Wook Kim, Chris Hallacy, Aditya Ramesh, Gabriel Goh, Sandhini Agarwal, Girish Sastry, Amanda Askell, Pamela Mishkin, Jack Clark, Gretchen Krueger, and Ilya Sutskever. Learning transferable visual models from natural language supervision. In Marina Meila and Tong Zhang (eds.), Proceedings of the 38th International Conference on Machine Learning, ICML 2021, volume 139 of Proceedings of Machine Learning Research, pp. 8748–8763. PMLR, 2021. URL http://proceedings.mlr.press/v139/radford21a.html.
+
+Aditya Ramesh, Mikhail Pavlov, Gabriel Goh, Scott Gray, Chelsea Voss, Alec Radford, Mark Chen, and Ilya Sutskever. Zero-shot text-to-image generation. In Marina Meila and Tong Zhang (eds.), Proceedings of the 38th International Conference on Machine Learning, ICML 2021, volume 139 of Proceedings of Machine Learning Research, pp. 8821–8831. PMLR, 2021. URL http://proceedings.mlr.press/v139/ramesh21a.html.
+
+Peter Scholze. Liquid tensor experiment. https://xenaproject.wordpress.com/2020/12/05/ liquid-tensor-experiment/, 2020.
+
+Daniel Selsam, Matthew Lamm, Benedikt Bünz, Percy Liang, Leonardo de Moura, and David L. Dill. Learning a SAT solver from single-bit supervision. In International Conference on Learning Representations, 2019. URL https://openreview.net/forum?id=HJMC_iA5tm.
+
+David Silver, Aja Huang, Chris J Maddison, Arthur Guez, Laurent Sifre, George Van Den Driessche, Julian Schrittwieser, Ioannis Antonoglou, Veda Panneershelvam, Marc Lanctot, et al. Mastering the game of go with deep neural networks and tree search. nature, 529(7587):484–489, 2016.
+
+David Silver, Thomas Hubert, Julian Schrittwieser, Ioannis Antonoglou, Matthew Lai, Arthur Guez, Marc Lanctot, Laurent Sifre, Dharshan Kumaran, Thore Graepel, et al. Mastering chess and shogi by self-play with a general reinforcement learning algorithm. arXiv preprint arXiv:1712.01815, 2017.
+
+Mingxing Tan and Quoc V. Le. Efficientnet: Rethinking model scaling for convolutional neural networks. In Kamalika Chaudhuri and Ruslan Salakhutdinov (eds.), Proceedings of the 36th International Conference on Machine Learning, ICML 2019, volume 97 of Proceedings of Machine Learning Research, pp. 6105–6114. PMLR, 2019. URL http://proceedings.mlr.press/v97/ tan19a.html.
+
+Josef Urban and Jan Jakubuv. First neural conjecturing datasets and experiments. In Christoph Benzmüller and Bruce R. Miller (eds.), Intelligent Computer Mathematics - 13th International Conference, CICM 2020, volume 12236 of Lecture Notes in Computer Science, pp. 315–323. Springer, 2020. doi: 10.1007/978-3-030-53518-6\_24. URL https://doi.org/10.1007/ 978-3-030-53518-6_24.
+
+Oriol Vinyals, Igor Babuschkin, Wojciech M Czarnecki, Michaël Mathieu, Andrew Dudzik, Junyoung Chung, David H Choi, Richard Powell, Timo Ewalds, Petko Georgiev, et al. Grandmaster level in starcraft ii using multi-agent reinforcement learning. Nature, 575(7782):350–354, 2019.
+
+Mingzhe Wang, Yihe Tang, Jian Wang, and Jia Deng. Premise selection for theorem proving by deep graph embedding. In I. Guyon, U. Von Luxburg, S. Bengio, H. Wallach, R. Fergus, S. Vishwanathan, and R. Garnett (eds.), Advances in Neural Information Processing Systems, volume 30, pp. 2786– 2796. Curran Associates, Inc., 2017. URL https://proceedings.neurips.cc/paper/2017/ file/18d10dc6e666eab6de9215ae5b3d54df-Paper.pdf.
+
+Daniel Whalen. Holophrasm: a neural automated theorem prover for higher-order logic. CoRR, abs/1608.02644, 2016. URL http://arxiv.org/abs/1608.02644.
+
+Mark H. Winands, Yngvi Björnsson, and Jahn-Takeshi Saito. Monte-carlo tree search solver. In Proceedings of the 6th International Conference on Computers and Games, pp. 25–36. SpringerVerlag, 2008. doi: 10.1007/978-3-540-87608-3_3.
+
+Yonghui Wu, Mike Schuster, Zhifeng Chen, Quoc V Le, Mohammad Norouzi, Wolfgang Macherey, Maxim Krikun, Yuan Cao, Qin Gao, Klaus Macherey, et al. Google’s neural machine translation system: Bridging the gap between human and machine translation. arXiv preprint arXiv:1609.08144, 2016.
+
+Yuhuai Wu, Albert Jiang, Jimmy Ba, and Roger Baker Grosse. INT: an inequality benchmark for evaluating generalization in theorem proving. In International Conference on Learning Representations, 2021. URL https://openreview.net/forum?id=O6LPudowNQm.
+
+Yuhuai Wu, Albert Qiaochu Jiang, Wenda Li, Markus Norman Rabe, Charles E Staats, Mateja Jamnik, and Christian Szegedy. Autoformalization with large language models. In Alice H. Oh, Alekh Agarwal, Danielle Belgrave, and Kyunghyun Cho (eds.), Advances in Neural Information Processing Systems, 2022. URL https://openreview.net/forum?id=IUikebJ1Bf0.
+
+Kaiyu Yang and Jia Deng. Learning to prove theorems via interacting with proof assistants. In Kamalika Chaudhuri and Ruslan Salakhutdinov (eds.), Proceedings of the 36th International Conference on Machine Learning, ICML 2019, volume 97 of Proceedings of Machine Learning Research, pp. 6984–6994. PMLR, 2019. URL http://proceedings.mlr.press/v97/yang19a. html.
+
+Kunhao Zheng, Jesse Michael Han, and Stanislas Polu. minif2f: a cross-system benchmark for formal olympiad-level mathematics. In International Conference on Learning Representations, 2022. URL https://openreview.net/forum?id=9ZPegFuFTFv.
+
+# A RELATED WORK
+
+Deep learning applied to premise selection and proof guidance Early applications of deep learning to formal mathematics focused primarily on premise selection and proof guidance. DeepMath (Irving et al., 2016) explored the use of CNNs and RNNs to predict whether a premise is useful to demonstrate a given conjecture. Their results were later improved with FormulaNet (Wang et al., 2017) by the use of graph neural networks, reminiscent of NeuroSAT (Selsam et al., 2019). Proof guidance consists in selecting the next clause to process inside an automated theorem prover. Loos et al. (2017) investigated the use of models similar to DeepMath’s for proof guidance and demonstrated a significant uplift on the Mizar library. More recently Firoiu et al. (2021) demonstrated the potential of deep learning techniques to be competitive with E prover’s heuristics when applied to resolution calculus while training on fully synthetic data.
+
+Deep learning applied to automated theorem-proving HOList (Bansal et al., 2019b) proposes a formal environment based on HOL Light. They achieve their best performance (Bansal et al., 2019a) with a GNN model designed for premise selection and the use of exploration. The same team studied the use of a skip-tree objective with Transformers on formal statements (Rabe et al., 2021), demonstrating, along with GPT-f (Polu & Sutskever, 2020), the potential of leveraging Transformers for formal reasoning. GamePad (Huang et al., 2019) and CoqGymn/ASTactic (Yang & Deng, 2019) introduce environments based on the Coq theorem prover. ASTactic generates tactics as programs by sequentially expanding a partial abstract syntax tree. Urban & Jakubuv (2020) studied the capability of GPT-2 to produce useful conjectures for the Mizar library and IsarStep (Li et al., 2021) explored the synthesis of intermediate propositions in declarative proofs for Isabelle/HOL using Transformers.
+
+Targeting miniF2F Lample et al. (2022) designed HyperTree Proof Search (HTPS), an online training procedure targeting Lean, Metamath and hand-crafted environment named Equations. Lample et al. (2022) report $41 \%$ pass-rate on miniF $2 F$ -test and $4 2 . 5 \%$ pass-rate on miniF $2 F .$ -curriculum in Lean (de Moura et al., 2015; lea) setup. Thor (Jiang et al., 2022) combined language model and Sledgehammer (Paulson, 2010) and achieved $2 9 . 9 \%$ pass-rate on miniF $2 F$ -test in Isabelle setup, which is later improved to $3 5 . 2 \%$ by $\mathbf { W } \mathbf { u }$ et al. (2022) leveraging autoformalization and expert iteration.
+
+# B LEAN-GYM
+
+lean-gym presents the following API:
+
+• init-search: declaration tactic_state. Takes a declaration name (a theorem name from the loaded library) and initializes a search while setting the run-time environment at that particular declaration. It returns the initial tactic state along with a fresh search_id and tactic_state_id.   
+• run_tac: (tactic_state, tactic) tactic_state. Takes a search_id and a tactic_state_id to identify a tactic state, as well as a tactic string to apply to it. It returns a new tactic state and its associated tactic_state_id.
+
+Below is an example in-terminal trace demonstrating the use of lean-gym’s REPL interface:
+
+$\$ 1$ lean --run src/repl.lean   
+["init_search", ["int.prime.dvd_mul", ""]]   
+{ "error":null, "search_id":"0", "tactic_state":"⊢ ∀ {m n : Z} {p : N}, nat.prime p → ↑p | m \* n → p | m.nat_abs ∨ p | n.nat_abs", "tactic_state_id":"0"   
+}   
+["run_tac",["1","1","apply (nat.prime.dvd_mul hp).mp"]]   
+{
+
+"error":null, "search_id":"1", "tactic_state":"m n : Z, p : N, hp : nat.prime p, h : ↑p | m \* n ⊢ p | m.nat_abs $\star$ n.nat_abs", "tactic_state_id":"2" }
+
+Using lean-gym is virtually equivalent to opening a Lean editor at a specific theorem, deleting its proof and interacting with Lean to reconstruct it.
+
+Providing a REPL interface over the standard input/output makes it very easy to integrate lean-gym from any programming language. Writing a wrapper in Python, as an example, only takes a few dozen lines of code. Since lean-gym is a Lean program, managing the loaded libraries is done directly using Lean’s own infrastructure (using leanpkg.toml), making it quite straightforward to have access to both mathlib and miniF2F statements from the same lean-gym instance.
+
+Note that lean-gym is stateful, meaning that distributing proof searches on multiple lean-gym instances requires to track which instance is associated with which proof search. In practice, we were able to scale the use of lean-gym to thousands of cores running thousands of proof searches in parallel. Finally, lean-gym’s REPL interface is blocking, preventing inner-proof search parallelization, though this limitation can probably be removed in the future.
+
+# C WEBMATH
+
+Our updated WebMath pre-training dataset consists in the mix presented in table 3.
+
+Table 3: Mix and source of data involved in the updated WebMath pre-training.   
+
+<table><tr><td>Dataset</td><td>Size</td><td>Mix</td></tr><tr><td>Github Python</td><td>179 GB</td><td>25%</td></tr><tr><td>arXiv Math</td><td>10 GB</td><td>25%</td></tr><tr><td>Math StackExchange</td><td>2GB</td><td>25%</td></tr><tr><td>PACT mix2</td><td>28GB</td><td>17%</td></tr><tr><td>Math Overflow</td><td>200 M</td><td>5%</td></tr><tr><td>ProofWiki</td><td>30M</td><td>2%</td></tr><tr><td>PlanetMath</td><td>25M</td><td>1%</td></tr></table>
+
+As demonstrated in table 3, we empirically up-weighted (compared to their token size) parts of WebMath with high-quality mathematical content while making sure they don’t overfit (despite running ${ > } 1$ epochs for some of them). We also included PACT $\mathfrak { m i x } 2$ directly in the WebMath pre-training to avoid having to sequence more than two pre-training phases to prepare Lean models.
+
+# D EXAMPLE OF MINIF2F INPUT, LEAN ENVIRONMENT AND MODEL OUTPUT
+
+We illustrate an example of the interaction between Lean environment and our model. In the figure shown below, the model has 1 output for each current goal (corresponding to 1 expand budget). The model could have expand budget bigger than 1, in which case the search procedure becomes a tree.
+
+![](images/db2c66d3a90c324b1666efbcb33678a738637518c2c92073a466b625aff826d8.jpg)  
+Figure 5: Input from miniF $2 F$ consists of a mathematical statement written in formal language (here the Lean version) without proof. Lean environment parses the statement and exposes to users the goal to be proved. The model outputs a line of code (tactics and corresponding arguments). Lean environment receives the model output and transforms the previous goal to another goal to be proved. This process is repeated till all remaining goals are closed. In this case, the original statement is proved: the final proof is collected by following the trajectory of model’s output.
+
+# E ILLUSTRATION OF EXPERT ITERATION
+
+![](images/9797ed05f1f348d3cda8cf3dcbcc103be5583e5290f598625053ea3f06dfab7b.jpg)  
+Figure 6: Illustration of expert iteration. The notation in this figure corresponds to Section 4.4 in main text.
+
+# F SYNTHETIC INEQUALITIES
+
+F.1 DESIGN
+
+The generator consists of three phases:
+
+Seed expressions generation The first phase consists in generating seed expressions for which we track the sign. We start by initializing an expression set $E$ composed of tuples of expressions and sign constraints, by generating $n _ { v }$ variable names (letters) assumed strictly positive as well as $n _ { n }$ integers (for which we know the sign). For $N _ { S }$ rounds, we compose elements of $E$ using unary $( l o g ( \cdot ) , \bar { l o g } ( 1 / \cdot ) , s q r t ( \cdot ) )$ or binary operations $( + , - , \times , / , \wedge , m a x , m i n )$ for which we can deduce the sign based on the sign condition of the input expression(s) and re-inject the resulting expression and sign constraint in $E$ . This produces a set $E$ of signed seed expressions of size $n _ { v } + n _ { n } + N _ { S }$ .
+
+Inequality composition The second phase consists in generating inequalities from well known inequality theorems (AM-GM, Trivial inequality, Cauchy-Schwarz, Bernoulli, Young, Hölder) taking as input to these theorems expressions from $E$ based on the sign constraints required for each theorem. We finally compose these inequalities $N _ { D }$ times using compositions theorems detailed in F.2. The resulting inequality is a composed inequality of depth $N _ { D }$ based on $n _ { v } + n _ { n } + N _ { S }$ seed expressions.
+
+Simplification We finally post-process these inequalities so that they are parsable by Lean and run them through Lean’s simp tactic for a final simplification.
+
+$N _ { D }$ and $N _ { S }$ together control for the difficulty of the resulting inequality. $N _ { D }$ controls depth of composition, while $N _ { S }$ controls for obfuscation as it increases the complexity of the input expressions to the composed inequalities. When sampling inequalities, we $n _ { n } ~ = ~ 4$ and randomly sample $2 \leq n _ { v } \leq 8$ at each generation. We report below examples of generated inequalities for various values of $N _ { D }$ and $N _ { S }$ .
+
+# F.2 LIST OF INEQUALITY COMPOSITION THEOREMS
+
+Below is the list of theorem names from mathlib that we use to compose inequalities together. One third of the time, we only transform the current composed inequality with one of the following theorems:
+
+• neg_le_neg   
+• inv_le_inv   
+• mul_self_le_mul_self   
+• div_le_one_of_le
+
+We otherwise compose the current composed inequality with a newly generated inequality using the following theorems:
+
+• mul_le_mul   
+• add_le_add   
+• div_le_div   
+• mul_le_mul_of_nonneg   
+• le_mul_of_ratio
+
+F.3 EXAMPLES
+
+$$
+\begin{array} { c } { { N _ { D } = 0 \ N _ { S } = 0 } } \\ { { { } } } \\ { { N _ { D } = 0 \ N _ { S } = 4 } } \end{array}
+$$
+
+<table><tr><td>Compositions</td><td>AmGm a b (67:R)((1:R)/(10:R)）((1:R)/(10:R)) ((8:R)/(10:R))</td></tr><tr><td>Statement</td><td>theorem synthetic_ineq_nb_seed_var_0_depth_0_p_1 (ab:R) (h0:0&lt;a) (h1:0&lt;b): (67:R)^（(8:R)/(10:R)）*b^(10:R)-1 * a^(10:R)-1≤ (8:R)/(10:R)* (67:R) + (10:R)-1 * a+b* (10:R)-1 := sorry</td></tr></table>
+
+<table><tr><td>Compositions</td><td>Sqnonneg a ((a)+((-68:R)))</td></tr><tr><td>Statement</td><td>theorem synthetic_ineq_nb_seed_var_4_depth_0_p_4 (ab:R) (h0 :0&lt;a) (h1:0&lt;b): (2:R)*(a*（a+-(68:R))）≤ (a +-(68:R))^2 +a^2 := sorry</td></tr></table>
+
+$$
+N _ { D } = 4 N _ { S } = 4
+$$
+
+<table><tr><td>Compositions</td><td>AddLeAdd Bernoulli 99 c AddLeAdd SelfDivConst（(a）/（f)）6 LeMulOfRatio SelfDivConst c 70 DivLeDiv Cauchy（(a）/(f)）dc(log（((59:R）+ f))) Young((a)/(f)）a((3:R)/(2:R)）((3:R)/(1:R)) theorem synthetic_ineq_nb_seed_var_4_depth_4_p_13</td></tr><tr><td>Statement</td><td>(abcdef:R) (h0 :0&lt;a) (h1 :0&lt;b) (h2 :0&lt;c) (h3:0&lt;d) (h4 :0&lt;e) (h5:0&lt;f): (1:R)+(99:R)*c+(a/f/(6:R)+a*(a/f)/ （(d^2+a^2/f^2)* (real.log（(59:R）+f)^2+c^2))）≤ （(a/f）^((3:R)/(2:R)）/（(3:R)/(2:R)）+ a^3/(3:R)）/ (real.log（(59:R）+f）*d+a/ f*c)^2 * (c/(c/(70:R))）+a/f+(c+(1:R)）^99 := sorry</td></tr></table>
+
+# G MINIF2F-CURRICULUM
+
+The 327 statements of miniF2F-curriculum3 are manually formalized from:
+
+• AOPS Books (Lehoczky & Rusczyk, a;b): 302 examples and exercises. The books are classic problem solving textbooks for students in grades 7-12 preparing for contests such as AMCs and AIMEs. We skipped problems that were too challenging to formalize due to missing infrastructure in mathlib or non-suitable format for formalization (see section Formalization effort and challenges in Zheng et al. (2022)).
+
+• MATH (Hendrycks et al., 2021) dataset: 25 problems. All problems were drawn from the train split of the dataset, focusing on difficulty 5 problems (miniF2F only contains problems from the test split).
+
+We verified (based on problem provenance and manual inspection of statements) that miniF2Fcurriculum had an empty intersection with miniF2F-{test, valid}. We refer to Zheng et al. (2022) for more details on the formalization procedure and the typical time needed for it as these problems were formalized in similar conditions.
+
+# H MODEL SIZE
+
+Other than the single model size we use in the experiment reported in the main text $7 7 4 \mathrm { m }$ trainable parameters), we briefly experimented with different model sizes (not reported in this paper) and found that model size scaling is not as straightforward as in the case of unsupervised learning (Kaplan et al., 2020). We found that bigger models are better, in the sense that they consistently exhibit higher $p a s s @ { I }$ . But, they are also much more expensive to sample from. And despite their pass@1 being higher, it is often the case that for a fixed amount of compute, sampling more attempts from a smaller model leads to a better final performance.
+
+For the compute budget we had available, we estimated the model size we used to be a compelling trade-off. We leave as future work a more thorough study of these dynamics to better understand the different compute frontiers involved. Indicatively, with our $7 7 4 \mathrm { m }$ parameters model, running a full expert iteration to train $\theta _ { 9 } ^ { f u l l }$ required about $2 0 0 0 \mathrm { { A } 1 0 0 }$ days of compute. Running one full proof search $( a = 1 ~ d = 5 1 2 ~ e = 8 )$ when properly parallelised, requires on average about 0.1 A100 hour of compute.
+
+# I EXAMPLE PROOFS FROM mathlib-train
+
+We present in this section original proofs found by our models from mathlib-train, compared with their ground-truth version.
+
+comap_eq_of_inverse
+
+<table><tr><td rowspan=1 colspan=1>Statement</td><td rowspan=1 colspan=1>lemma comap_eq_of_inverse {f：filter α} {g：filter β}{Φ:α→β} (φ:β→α)(eq:γ○Φ=id)(hΦ : tendsto  f g)(hψ :tendsto 𝜑 g f):comap Φ g = f :=</td></tr><tr><td rowspan=1 colspan=1>Ground-truth</td><td rowspan=1 colspan=1>beginrefine((comap_mono $map_le_iff_le_comap.1 h).trans_).antisymm(map_le_iff_le_comap.1 hΦ),rw [comap_comap，eq，comap_id],exact le_rflend</td></tr><tr><td rowspan=1 colspan=1>Model proof</td><td rowspan=1 colspan=1>beginrefine le_antisymm _ (filter.map_le_iff_le_comap.1 h),refine 入s hs,-,rw mem_comap,use [ -1&#x27; s,h hs],rw[← preimage_comp，eq，preimage_id]end</td></tr></table>
+
+sum_range_sub_sum_range
+
+<table><tr><td rowspan=1 colspan=1>Statement</td><td rowspan=1 colspan=1>lemma sum_range_sub_sum_range {α :Type*}[add_comm_group α]{f：N→α}{nm：N}(hnm:n≤m）:∑k in range m，fk-∑kin range n，fk =∑k in (range m).filter (λk，n≤k)，f k :=</td></tr><tr><td rowspan=1 colspan=1>Ground-truth</td><td rowspan=1 colspan=1>beginrw[← sum_sdiff(@filter_subset _（λ k，n ≤k）_(range m))，sub_eq_iff_eq_add,← eq_sub_iff_add_eq，add_sub_cancel&#x27;],refine finset.sum_congr(finset.ext $入 a，&lt; h，by simp at *；finish,入 h，have ham ：a&lt;m :=lt_of_lt_of_le (mem_range.1 h）hnm,by simp * at *&gt;)(λ__，rfl)end</td></tr><tr><td rowspan=1 colspan=1>Model proof</td><td rowspan=1 colspan=1>beginrw[← sum_Ico_eq_sub_ hnm],congr,apply finset.ext,simp [Ico.mem，*],tautoend</td></tr></table>
+
+prod_inv_distrib
+
+<table><tr><td rowspan=1 colspan=1>Statement</td><td rowspan=1 colspan=1>lemma prod_inv_distrib :(II× in s，(f x)-1)=①I×in s,f x)-1 :=</td></tr><tr><td rowspan=1 colspan=1>Ground-truth</td><td rowspan=1 colspan=1>beginclassical,by_casesh:×∈s，fx=0,{simpa [prod_eq_zero_iff.mpr h，prod_eq_zero_iff]using h },{ push_neg at h,have h&#x27; := prod_ne_zero_iff.mpr h,have hf :∀x ∈ s，(f x)-1 * fx=1 :=λx hx,inv_mul_cancel (h × hx)，apply mul_right_cancel&#x27;h&#x27;,simp[h，h&#x27;，← finset.prod_mul_distrib,prod_congr rfl hf]}end</td></tr><tr><td rowspan=1 colspan=1>Model proof</td><td rowspan=1 colspan=1>beginclassical；induction s usingfinset.induction_on with a s has ih,{simp，},simp only[has，prod_insert has，mul_inv_rev&#x27;],finishend</td></tr></table>
+
+# J EXAMPLE PROOFS FROM miniF2F-{test, valid, curriculum}
+
+We present in this section proofs found by our models from miniF2F-{test, valid, curriculum}, demonstrating some of the capabilities emerging from our training procedure.
+
+# J.1 QUALITATIVE ANALYSIS OF PROOFS
+
+We provide qualitative insights in the nature of the proofs found by our models, which we believe are useful to build a better intuition of their capabilities beyond pass rate numbers. Throughout this section, we refer to statements and solutions found by our models that are presented in Appendix J along with comments describing the specificity of each proof.
+
+First, we observe that a large number of olympiad problems that are designed to be computationally challenging for humans are rendered trivial for our models through the use of Lean tactics. As an example, mathd_numbertheory_447 which is not necessarily considered straightforward for humans, can be closed in Lean by a simple refl (proof found by our models).
+
+In recent years, Lean’s mathlib community has developed high-powered tactics such as linarith/nlinarith (solves (non)linear inequalities), norm_num (normalizes numerical expressions), simp (simplifies goals and hypotheses) and ring (normalizes expressions in a ring). These tactics can be used with arguments to guide their underlying search procedure. As mentioned in Zheng et al. (2022), we confirm here that our models acquire advanced capabilities to leverage these high-level tactics by providing exogenous arguments which are not present in the current tactic state. The generation of these exogenous arguments through language modeling seems to require a non-trivial amount of mathematical intuition. imo_1964_p2, imo_1961_p1 and aime_1990_p15 are good examples of such uses.
+
+We have also observed a number of proofs that require multiple non-trivial reasoning steps through the use of lower-level tactics such as use, have, or by_cases that generally involve producing a witness or chaining implications, requiring the generation of context specific exogenous terms. These interesting reasoning steps are structurally different from simple normalization, simplification and rewriting of hypotheses or goals because they heavily rely on our models ability to generate meaningful cuts or witnesses. This capability is, in our opinion, the most exciting stepping stone towards solving more challenging mathematical problems. See, aopsbook_v2_c8_ex1, amc12b_2020_p6 and mathd_train_algebra_217 for examples of such proofs.
+
+More generally, we also observe that proofs generated by our models have a distinctive style compared to proofs formalized by humans. This stems in part from the model’s capability to leverage high-level tactics in a way that is challenging for humans as discussed in this section (e.g. one-liners such as nlinarith [sq_nonneg $( \textsf { x } \texttt { - y } )$ , sq_nonneg $( \mathsf { y } \mathrm { ~  ~ { ~ - ~ } ~ } \mathsf { z } ) ]$ where humans would generally decompose the problem in a less machine-like way). Additionally, as a result of our search procedure and despite the bias towards shorter proofs introduced by our value function, extraneous proofsteps (such as reversion/introduction of hypotheses, or no-op rewrites) are often interleaved with useful ones, which rarely happens in human formalizations.
+
+imo_1961_p1 imo_1964_p2 aime_1990_p15 mathd_train_algebra_217 amc12b_2020_p6 mathd_algebra_140 aime_1984_p1 aopsbook_v2_c8_ex1 mathd_numbertheory_447
+
+<table><tr><td rowspan=1 colspan=1>Natural language</td><td rowspan=1 colspan=1>Solve the system of equations:x+y+z=αx²+y²+2²=b²xy= x²where α and b are constants.Give the conditions that α and b must satisfy sothat x,y,z (the solutions of the system) are distinct positive numbers.Note: theformalized statement in miniF2F is a weaker problem as it focuses on the secondpart of the question, providing the actual conditions,and asking for a proof that therequirement entails them.</td></tr><tr><td rowspan=1 colspan=1>Model proof</td><td rowspan=1 colspan=1>theorem imo_1961_p1(xyzab:R)(ho:0&lt;x&gt;0&lt;y&gt;0&lt;z)(h1:×≠y)(h2 :y≠z)(h3:z≠x)(h4 :x+y+z= a)(h5 :x^2 +y^2 + z^2 = b^2)(h6 :x *y= z^2) :0&lt;a∧ b^2&lt;a^2 &gt; a^2&lt;3*b^2 :=beginrevert_all,intros,rw mul_comm,split,{nlinarith [sq_nonneg (x - y)，sq_nonneg(y- z)]，},split,{nlinarith [sq_nonneg(z - 1)]，},revert h3 h4,field_simp [mul_comm a b],rw [mul_comm，← h5],contrapose!,rw mul_comm at h6,rw mul_comm,intro h,nlinarith [sq_nonneg (x - y)，sq_nonneg (y - z)]end</td></tr><tr><td rowspan=1 colspan=1>Comments</td><td rowspan=1 colspan=1>The model is able to close this problem by spliting into cases,contraposing for thelast case and using nlinarith.It must be noted that the arguments for the first twonlinarith uses are not necessary,however the [sq_nonneg (x - y)，sq_nonneg(y- z)] argument provided on the last line is crucial to close the goal and arecompletely exogenous (present in no form in the tactic state before).</td></tr></table>
+
+<table><tr><td rowspan=1 colspan=1>Natural language</td><td rowspan=1 colspan=1>Suppose a,b,c are the sides of a triangle.Prove thata²(b+c-a)+b²(c+a-b)+c²(a+b-c)≤3abc</td></tr><tr><td rowspan=1 colspan=1>Model proof</td><td rowspan=1 colspan=1>theorem imo_1964_p2(abc:R)(ho:0&lt;a&gt;0&lt;b&gt;0&lt;c)(h1:c&lt;a+b)(h2:b&lt;a+c)(h3:a&lt;b+c):a^2*(b+c-a)+b^2*(c+a-b)+c^2*(a+b-c)≤3*a*b*c:=beginnlinarith [sq_nonneg (b - a)，sq_nonneg (c - b),sq_nonneg (a - c)，sq_nonneg (c - a)]end</td></tr><tr><td rowspan=1 colspan=1>Comments</td><td rowspan=1 colspan=1>The model is able to close an IMO problem in one-line.It correctly providesexogenous arguments to nlinarith,which are necessary to close the goal. Notethat either one of the last two arguments in the sequence [sq_nonneg (b - a),sq_nonneg(c -b)，sq_nonneg(a - c)，sq_nonneg (c- a)]can be omitted.</td></tr></table>
+
+<table><tr><td>Natural language</td><td>Find ax+ by if the real numbers a,b,x,and y satisfy the equations ax+by =3, ax²+by²=7, ax²+by³=16, ax²4 +by4 = 42. Note: the formalized statement in miniF2F provides the answer and asks for a proof of it. theorem aime_1990_p15</td></tr><tr><td>Model proof</td><td>(abxy:R) (ho:a*x+b*y=3) (h1 :a* x^2+b*y^2= 7) (h2 :a* x^3 +b*y^3= 16) (h3 :a* x^4 +b*y^4= 42) : a * x^5+b*y^5=20 := begin revert_all, intros ab ×y hg hi h2 h4, ring_nf at hi h2, rw ← sub_eq_zero at h1, nlinarith [sq_nonneg (× - y)，sq_nonneg (a + b - 2), sq_nonneg (x + y - (2:R))，sq_nonneg (a -b - 2)]</td></tr><tr><td>Comments</td><td>end The model is able to close a challenging AIME problem by providing crucial ex- ogenous arguments sq_nonneg (x - y) and sq_nonneg (x + y - (2 :R)) to nlinarith,which are required to close the goal (while the other two can be removed).</td></tr></table>
+
+<table><tr><td>Natural language</td><td>Let f(x)= Ax+B and g(x)=Bx +A,where A≠B. If f(g(x)) - g(f(x))= B-A,what is A+B? Note: the formalized statement in our curriculum provides the answer and asks for a proof of it. theorem mathd_train_algebra_217</td></tr><tr><td>Model proof</td><td>(ab:R) (fg:R→R) (ho:∀x，fx=a*x+b) (h1:∀×，fx=b*x+a) (h2 :a≠b) (h3 :∀x，f (gx)-g(f x)=b-a): a+b=0 := begin revert_all, intros a b, intros f g, contrapose!, rintro &lt;ho，&lt;hi，h2&gt;&gt;, use (0 :R), simp only[sub_eq_iff_eq_add，ho，mul_zero]at *, simp only[*，zero_add],</td></tr><tr><td>Comments</td><td>norm_num at ho end The model is able to close the goal by contraposing,supplying a witness by the use of use (O :R）and finally leveraging the simp and norm_num. This example demonstrates the model&#x27;s ability to chain multiple non-trivial steps of reasoning including the generation of witnesses.</td></tr></table>
+
+<table><tr><td rowspan="2">Natural language (A) a multiple of 4 (D) a perfect square</td><td colspan="2">For all integers n ≥ 9, the value of (n+2)!-(n+1)!</td></tr><tr><td colspan="2">n! is always which of the following? (B) a multiple of 10 (C)a prime number</td></tr><tr><td>Model proof</td><td>theorem amc12b_2020_p6 (n :N) (ho:9≤n): x :N，(x:R)^2 = (nat.factorial (n + 2) - nat.factorial (n + 1)）/ nat.factorial n := begin revert_all, intros n hn, use n + 1,</td><td>field_simp [nat.factorial_ne_zero，pow_succ&#x27;],</td></tr><tr><td>Comments</td><td>ring_exp end The model exhibits here its ability to implicitly interpret factorial expressions by guessing the correct answer with the use of use n + 1 and straightforwardly proving</td><td></td></tr></table>
+
+<table><tr><td>Natural language</td><td>The expression 24x² - 19x - 35 can be written as (Ax - 5)(2Bx + C),where A, B,and C are positive numbers.Find AB- 3C.Note: the formalized statement in miniF2F provides the answer and asks for a proof of it.</td></tr><tr><td>Model proof</td><td>theorem mathd_algebra_140 (abc:R) (ho:0&lt;a&gt;0&lt;b&gt;0&lt;c) (h1:∀×，24* ×^2-19*×-35= (((a*x)-5)*((2*(b*x))+c))）: a*b-3*c=-9:= begin revert_all, rintro abc h1, rw mul_comm, rw ←sub_eq_zero, field_simp, rw sub_eq_add_neg, rw←eq_neg_iff_add_eq_zero, rw [mul_comm，← sub_eq_add_neg，sub_eq_add_neg, ← sub_eq_add_neg], rw ←sub_eq_zero, simp only [mul_add，neg_mul_eq_neg_mul_symm，mul_comm, add_left_comm], norm_num, simp only [pow_two], intro ho, rw← sub_eq_zero, linarith [hi.2，hi.1，ho 3，ho 1，ho 2]</td></tr><tr><td>Comments</td><td>end The model mostly &quot;struggles&quot; to make progress up to the last line. There, it presents us with the idea to specialize the statement given in h1 (which became ho in the process of the proof) at three consecutive natural numbers 1,2,3 which closes the goal with nlinarith. This proof is interesting as it demonstrates the model&#x27;s ability to evaluate symbolic expressions implicitly.</td></tr></table>
+
+<table><tr><td>Natural language</td><td>Find the value of a2 +a4 +a6 +ag +...+ ag if a1,a2,a3... is an arithmetic progression with common difference 1,and a1 +a2 + a3 +...+ag8 = 137.Note: the formalized statement in miniF2F provides the answer and asks for a proof of it.</td></tr><tr><td>Model proof</td><td>theorem aime_1984_p1 (u:N→Q) (ho :∀n，u(n+1)=un+1) (hi ：∑k in finset.range 98，u k.succ = 137）: ∑ k in finset.range 49，u (2 * k.succ)= 93 := begin revert_all, simp [finset.sum_range_succ], ring, simp[pow_succ，mul_comm，add_left_comm，add_assoc], simp [two_mul], rintro p, revert p, simp [add_comm], intros p hp, simp [hp]，ring_nf, intros, nlinarith</td></tr><tr><td>Comments</td><td>end The model finds a rather short proof of the statement compared to typ- ical human formalizations (see https://gist.github.com/MantasBaksys/ 3efd5c0d42f440d16c09076db42822f2).</td></tr></table>
+
+<table><tr><td>Natural language</td><td>Consider the sequence = 1 3 ，，，. Prove that this sequence tends to 1 as n→ </td></tr><tr><td>Model proof</td><td>theorem aopsbook_v2_c8_ex1 (u:N→R) (ho:∀n，un=n/(n+1)): filter.tendsto u filter.at_top (N 1) := begin revert_all, simp [← nnreal.coe_one], norm_cast, intros, revert ho, assume h, simp [tendsto_const_nhds，← nnreal.coe_one，h], revert u, assume f, norm_num, rw tendsto_iff_norm_tendsto_zero, assume H, convert tendsto_norm_zero.comp tendsto_one_div_add_at_top_nhds_0_nat, funext n, have ho ：（((n:R）+1）:R)≠0, { norm_cast，exact n.succ_ne_zero，}, rwH, field_simp [ho，norm_neg], ring, rw [← sub_eq_zero], simp [← sub_eq_zero], simp[sub_eq_add_neg],</td></tr><tr><td>Comments</td><td>end An interesting example of a generated have statement,denoted by ho,which is introduced as a cut in order to simplify the expression containing divisions by using field_simp[ho，norm_neg] ata later step.</td></tr></table>
+
+<table><tr><td rowspan=1 colspan=1>Natural language</td><td rowspan=1 colspan=1>What is the sum of the units digits of all the multiples of 3 between O and 5O? Note:the formalized statement in miniF2F provides the answer and asks for a proof of it.</td></tr><tr><td rowspan=1 colspan=1>Model proof</td><td rowspan=1 colspan=1>theorem mathd_numbertheory_447 :∑ k in finset.filter (入 ×，3|x)(finset.erase (finset.range 50) 0)，(k % 10) = 78 :=beginreflend</td></tr><tr><td rowspan=1 colspan=1>Comments</td><td rowspan=1 colspan=1>Because the predicate 入 ×，3|× is registered as decidable over N,we can state theproblem by using finset.filter,which is computable.Hence,refl is able toclose the goal.</td></tr></table>

parse/dev/3SLW-YIw7tX/3SLW-YIw7tX_content_list.json

@@ -0,0 +1,1287 @@
+[
+    {
+        "type": "text",
+        "text": "Reinforcement Learning with Neural Radiance Fields ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            122,
+            821,
+            147
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Danny Driess∗ Ingmar Schubert∗ TU Berlin TU Berlin ",
+        "bbox": [
+            191,
+            200,
+            444,
+            228
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Pete Florence Google ",
+        "bbox": [
+            468,
+            200,
+            566,
+            229
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Yunzhu Li MIT ",
+        "bbox": [
+            591,
+            200,
+            668,
+            228
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Marc Toussaint TU Berlin ",
+        "bbox": [
+            692,
+            202,
+            805,
+            228
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Abstract ",
+        "text_level": 1,
+        "bbox": [
+            462,
+            265,
+            535,
+            281
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "It is a long-standing problem to find effective representations for training reinforcement learning (RL) agents. This paper demonstrates that learning state representations with supervision from Neural Radiance Fields (NeRFs) can improve the performance of RL compared to other learned representations or even low-dimensional, hand-engineered state information. Specifically, we propose to train an encoder that maps multiple image observations to a latent space describing the objects in the scene. The decoder built from a latent-conditioned NeRF serves as the supervision signal to learn the latent space. An RL algorithm then operates on the learned latent space as its state representation. We call this NeRF-RL. Our experiments indicate that NeRF as supervision leads to a latent space better suited for the downstream RL tasks involving robotic object manipulations like hanging mugs on hooks, pushing objects, or opening doors. ",
+        "bbox": [
+            233,
+            297,
+            766,
+            463
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Video: https://dannydriess.github.io/nerf-rl ",
+        "bbox": [
+            233,
+            463,
+            598,
+            477
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 Introduction ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            503,
+            310,
+            521
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "The sample efficiency of reinforcement learning (RL) algorithms crucially depends on the representation of the underlying system state they operate on [1, 2, 3, 4, 5, 6, 7]. Sometimes, a low-dimensional (direct) representation of the state, such as the positions of the objects in the environment, is considered to make the resulting RL problem most efficient [2]. ",
+        "bbox": [
+            174,
+            536,
+            825,
+            592
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "However, such low-dimensional, direct state representations can have several disadvantages. On the one hand, a perception module, e.g., pose estimation, is necessary in the real world to obtain the representation from raw observations, which often is difficult to achieve in practice with sufficient robustness. On the other hand, if the goal is to learn policies that generalize over different object shapes [8], using a low-dimensional state representation is often impractical. Such scenarios, while challenging for RL, are common, e.g., in robotic manipulation tasks. ",
+        "bbox": [
+            174,
+            598,
+            825,
+            681
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Therefore, there is a large history of approaches that consider RL directly from raw, high-dimensional observations like images (e.g., [9, 10]). Typically, an encoder takes the high-dimensional input and maps it to a low-dimensional latent representation of the state. The RL algorithm (e.g., the Q-function or the policy network) then operates on the latent vector as state input. This way, no separate perception module is necessary, the framework can extract information from the raw observations that are relevant for the task, and the RL agent, in principle, may generalize over challenging environments, in which, e.g., object shapes are varied. While these are advantages in principle, jointly training encoders capable of processing high-dimensional inputs from the RL signal alone is challenging. To address this, one approach is to pretrain the encoder on a different task, e.g., image reconstruction [1, 4, 11], multi-view consistency [6], or a time-constrastive task [3]. Alternatively, an auxiliary loss on the latent encoding can be added during the RL procedure [5]. ",
+        "bbox": [
+            174,
+            688,
+            825,
+            839
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "In both cases, the choice of the actual (auto-)encoder architecture and associated (auxiliary) loss function has a significant influence on the usefulness of the resulting latent space for the downstream ",
+        "bbox": [
+            176,
+            847,
+            823,
+            875
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "RL task. Especially for image data, convolutional neural networks (CNNs) are commonly used for the encoder [12]. However, 2D CNNs have a 2D (equivariance) bias, while for many RL tasks, the 3D structure of our world is essential. Architectures like Vision Transformers [13, 14] process images with no such direct 2D bias, but they often require large scale data, which might be challenging in RL applications. Additionally, although multiple uncalibrated 2D image inputs can be used with generic image encoders [15], they do not benefit from 3D inductive biases, which may help for example in resolving ambiguities in 2D images such as occlusions and object permanence. ",
+        "bbox": [
+            174,
+            92,
+            825,
+            188
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Recently, Neural Radiance Fields (NeRFs) [16] have shown great success in learning to represent scenes with a neural network that enables to render the scene from novel viewpoints, and have sparked broad interest in computer vision [17]. NeRFs exhibit a strong 3D inductive bias, leading to better scene reconstruction capabilities than methods composed of generic image encoders (e.g., [18]). ",
+        "bbox": [
+            174,
+            194,
+            825,
+            251
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "In the present work, we investigate whether incorporating these 3D inductive biases of NeRFs into learning a state representation can benefit RL. Specifically, we propose to train an encoder that maps multiple RGB image views of the scene to a latent representation through an auto-encoder structure, where a (compositional) NeRF decoder provides the self-supervision signal using an image reconstruction loss for each view. ",
+        "bbox": [
+            174,
+            256,
+            825,
+            325
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "In the experiments, we show for multiple environments that supervision from NeRF leads to a latent representation that makes the downstream RL procedure more sample efficient compared to supervision via a 2D CNN decoder, a contrastive loss on the latent space, or even hand-engineered, perfect low-level state information given as keypoints. Commonly, RL is trained on environments where the objects have the same shape. Our environments include hanging mugs on hooks, pushing objects on a table, and a door opening scenario. In all of these, the objects’ shapes are not fixed, and we require the agent to generalize over all shapes from a distribution. ",
+        "bbox": [
+            174,
+            332,
+            825,
+            429
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "To summarize our main contributions: (i) we propose to train state representations for RL with NeRF supervision, and (ii) we empirically demonstrate that an encoder trained with a latent-conditioned NeRF decoder, especially with an object-compositional NeRF decoder, leads to increased RL performance relative to standard 2D CNN auto-encoders, contrastive learning, or expert keypoints. ",
+        "bbox": [
+            176,
+            435,
+            825,
+            491
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2 Related Work ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            512,
+            321,
+            530
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Neural Scene/Object Representations in Computer Vision, and Applications. To our knowledge, the present work is the first to explore if neural scene representations like NeRFs can benefit RL. Outside of RL, however, there has been a very active research field in the area of neural scene representations, both in the representations themselves [19, 20, 21, 22] and their applications; see [23, 24, 17] for recent reviews. Within the family of NeRFs and related methods, major thrusts of research have included: improving modeling formulations [25, 26], modeling larger scenes [26, 27], addressing (re-)lighting [28, 29, 30], and an especially active area of research has been in improving speed, both of training and of inference-time rendering [31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41]. In our case, we are not constrained by inference-time computation issues, since we do not need to render images, and only have to run our latent-space encoder (with a runtime of approx. 7 ms on an RTX3090). Additionally of particular relevance, various methods have developed latent-conditioned [42, 43, 44] or compositional/object-oriented approaches for NeRFs [45, 46, 47, 48, 49, 50, 51, 52, 53], although they, nor other NeRF-style methods to our knowledge, have been applied to RL. Neural scene representations have found application across many fields (i.e., augmented reality and medical imaging [54]) and both NeRFs [55, 56, 57, 58] and other neural scene approaches [59, 60, 61, 62] have started to be used for various problems in robotics, including pose estimation [55], trajectory planning [56], visual foresight [11, 53], grasping [59, 57], and rearrangement tasks [60, 61, 58]. ",
+        "bbox": [
+            174,
+            545,
+            826,
+            781
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Learning State Representations for Reinforcement Learning. One of the key enabling factors for the success of deep RL is its ability to find effective representations of the environment from high-dimensional observation data [10, 63]. Extensive research has gone into investigating different ways to learn better state representations using various auxiliary objective functions. Contrastive learning is a common objective and has shown success in unsupervised representation learning in computer vision applications [64, 65]. Researchers built upon this success and have shown such learning objectives can lead to better performance and sample efficiency in deep RL [66, 67], where the contrasting signals could come from time alignment [68, 3], camera viewpoints [69], and different sensory modalities [70], with applications in real-world robotic tasks [6, 71]. Extensive efforts have investigated the role of representation learning in RL [72], provided a detailed analysis of the importance of different visual representation pretraining methods [73], and shown how we can improve training stability in the face of multiple auxiliary losses [74]. There is also a range of additional explorations on pretraining methods with novel objective functions (e.g., bisimulation metrics [75] and temporal cycle-consistency loss [76]) and less-explored data sources (e.g., in-thewild images [77] and action-free videos [78]). Please check the survey for more related work in this direction [79]. Our method is different in that we explicitly utilize a decoder that includes strong 3D inductive biases provided by NeRFs, which we empirically show improves RL for tasks that depend on the geometry of the objects. ",
+        "bbox": [
+            174,
+            786,
+            825,
+            911
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            90,
+            825,
+            217
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3 Background ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            234,
+            308,
+            252
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3.1 Reinforcement Learning ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            265,
+            383,
+            281
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "This work considers decision problems that can be described as discrete-time Markov Decision Processes (MDPs) $M \\ = \\ \\langle S , A , T , \\gamma , R , P _ { 0 } \\rangle$ . $s$ and $\\mathcal { A }$ are the sets of all states and actions, respectively. The transition probability (density) from $s$ to $s ^ { \\prime }$ using an action $a$ is $T ( s ^ { \\prime } \\mid s , a )$ . The agent receives a real-valued reward $R ( s , a , s ^ { \\prime } )$ after each step. The discount factor $\\gamma \\in \\ [ 0 , 1 )$ trades off immediate and future rewards. $P _ { 0 } : \\mathcal { S }  \\mathbb { R } _ { 0 } ^ { + }$ is the diswhere this w tribution of the start state. RL algorithms try to find the optimal policy $\\begin{array} { r } { \\pi ^ { * } = \\mathrm { a r g m a x } _ { \\pi } \\sum _ { t = 0 } ^ { \\infty } \\gamma ^ { t } \\mathbb { E } _ { s _ { t + 1 } \\sim T ( \\cdot | s _ { t } , a _ { t } ) , a _ { t } \\sim \\pi ( \\cdot | s _ { t } ) , s _ { 0 } \\sim P _ { 0 } } \\left[ R ( \\bar { s _ { t } } , a _ { t } , \\bar { s _ { t + 1 } } ) \\right] . } \\end{array}$ $\\pi ^ { * } : \\mathcal { S } \\times \\mathcal { A } \\to \\mathbb { R } _ { 0 } ^ { + }$ 0  Importantly, inand the shape of $\\mathrm { R L }$ $s$ the objects in the scene. We require the RL agent to generalize over all of these shapes at test time. We can therefore think of the state as a tuple $\\boldsymbol { s } = \\left( s _ { p } , s _ { s } \\right)$ , where $s _ { p }$ encodes positional information, and $s _ { s }$ encodes the shapes involved. We focus the experiments on sparse reward settings, meaning $R ( s , a , s ^ { \\prime } ) = R _ { 0 } > 0$ for $\\boldsymbol { s } ^ { \\prime } \\in \\boldsymbol { S } _ { g }$ and $R ( s , a , s ^ { \\prime } ) = { \\bar { 0 } }$ for $s \\in \\mathcal { S } \\backslash \\mathcal { S } _ { g }$ , where the volume of $\\mathcal { S } _ { g } \\subset \\bar { \\mathcal { S } }$ is much smaller than the volume of $s$ . The state space $s$ usually is low-dimensional or a minimal description of the degrees of freedom of the system. In this work, we consider that the RL algorithm has only access to a (high-dimensional) observation $y \\in \\mathcal { V }$ of the scene (e.g., RGB images). In particular, this means that the policy has observations as input $a \\sim \\pi ( \\cdot \\mid y )$ . Since we assume that the underlying state $\\boldsymbol { s } = \\left( s _ { p } , s _ { s } \\right)$ is fully observable from $y$ , we can treat $y$ like a state for an MDP. ",
+        "bbox": [
+            173,
+            290,
+            826,
+            530
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Reinforcement Learning with Learned Latent Scene Representations. The general idea of RL with learned latent scene representations is to learn an encoder $\\Omega$ that maps an observation $y \\in \\mathcal { V }$ to a $k$ -dimensional latent vector $z = \\Omega ( y ) \\in \\mathcal { Z } \\subset \\mathbb { R } ^ { k }$ of the scene. The actual RL components, e.g., the Q-function or policy, then operate on $z$ as its state description. For a policy $\\pi$ , this means that the action $a \\sim \\pi ( \\cdot \\mid \\bar { z } ) = \\bar { \\pi } ( \\cdot \\mid \\Omega ( \\bar { y } ) )$ is conditional on the latent vector $z$ instead of the observation $y$ directly. The dimension $k$ of the latent vector is typically (much) smaller than that of the observation space $\\mathcal { V }$ , but larger than that of the state space $s$ . ",
+        "bbox": [
+            173,
+            535,
+            825,
+            633
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3.2 Neural Radiance Fields (NeRFs) ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            648,
+            437,
+            662
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "The general idea of NeRF, originally proposed by [16], is to learn a function $f = ( \\sigma , c )$ that predicts the emitted RGB color value $c ( x ) \\in \\bar { \\mathbb { R } } ^ { 3 }$ and volume density $\\sigma ( x ) \\in \\mathbb { R } _ { \\geq 0 }$ at any 3D world coordinate $x \\in \\mathbb { R } ^ { 3 }$ . Based on $f$ , an image from an arbitrary view and camera parameters can be rendered by computing the color $C ( r ) \\in \\bar { \\mathbb { R } } ^ { 3 }$ of each pixel along its corresponding camera ray $r ( \\alpha ) = r ( 0 ) + \\alpha \\dot { d }$ through the volumetric rendering relation ",
+        "bbox": [
+            173,
+            674,
+            825,
+            743
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/d7db902036340cb89aea3f85a364e992d3227c677396aef129afa108dd6cc48c.jpg",
+        "text": "$$\nC ( r ) = \\int _ { \\alpha _ { n } } ^ { \\alpha _ { f } } T _ { f } ( r , \\alpha ) \\sigma ( r ( \\alpha ) ) c ( r ( \\alpha ) ) \\mathrm { d } \\alpha \\qquad \\mathrm { w i t h } \\qquad T _ { f } ( r , \\alpha ) = \\exp \\left( - \\int _ { \\alpha _ { n } } ^ { \\alpha } \\sigma ( r ( u ) ) \\mathrm { d } u \\right) .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            179,
+            748,
+            797,
+            785
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Here, $r ( 0 ) \\in \\mathbb { R } ^ { 3 }$ is the camera origin, $d \\in \\mathbb { R } ^ { 3 }$ the pixel dependent direction of the ray and $\\alpha _ { n } , \\alpha _ { f } \\in \\mathbb { R }$ the near and far bounds within which objects are expected, respectively. The camera rays are determined from the camera matrix $K$ (intrinsics and extrinsics) describing the desired view. ",
+        "bbox": [
+            173,
+            790,
+            826,
+            834
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "4 Learning State Representations for RL with NeRF Supervision ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            851,
+            730,
+            869
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "This section describes our proposed framework, in which we use a latent state space for RL that is learned from NeRF supervision. For learning the latent space, we use an encoder-decoder where the decoder is a latent-conditioned NeRF, which may either be a global [42, 43, 44] or a compositional NeRF decoder [53]. To our knowledge, no prior work has used such NeRF-derived supervision for RL. In Sec. 4.1 we describe this proposition, Sec. 4.2 provides an overview of the encoder-decoder training, Sec. 4.3 and Sec. 4.4 introduce options for the NeRF decoder and encoder, respectively. ",
+        "bbox": [
+            173,
+            882,
+            820,
+            911
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "image",
+        "img_path": "images/0f6041cbf23c978c2232942230a9a8801040ddcd96efd4a643cd03910cb0e6b5.jpg",
+        "image_caption": [
+            "Figure 1: State representation learning for RL with NeRFs. First, the encoder and NeRF decoder are trained with supervision from a multi-view reconstruction loss on an offline dataset. Then, the encoder’s weights are frozen, and the latent space is used as state input to train a policy with RL. ∗Masks of individual objects are only required for the compositional variant of our encoder. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            207,
+            90,
+            784,
+            256
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            343,
+            825,
+            400
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "4.1 Using Latent-Conditioned NeRF for RL ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            415,
+            490,
+            431
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "We propose the state representation $z$ on which an RL algorithm operates to be a latent vector produced by an encoder that maps images from multiple views to a latent $z$ , which is trained with a (compositional) latent-conditioned NeRF decoder. As will be verified in experiments, we hypothesize that this framework is beneficial for the downstream RL task, as it produces latent vectors that represent the actual 3D geometry of the objects in the scene, can handle multiple objects well, as well as fuse multiple views in a consistent way to deal with occlusions by providing shape completion, all of which is relevant to solve tasks where the geometry is important. There are two steps to our framework, as shown in Fig. 1. First, we train the encoder $^ +$ decoder from a dataset collected by random interactions with the environment, i.e., we do not yet need a trained policy. Second, we take the encoder trained in the first step, which we leave frozen, and use the latent space to train an RL policy. Note that we investigate two variants of the auto-encoder framework, a global one, where the whole scene is represented by one single latent vector, and a compositional one, where objects are represented by their own latent vector. For the latter, objects are identified by masks in the views. ",
+        "bbox": [
+            173,
+            440,
+            826,
+            621
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "4.2 Overview: Auto-Encoder with Latent-Conditioned NeRF Decoder ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            636,
+            669,
+            652
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Assume that an observation $\\boldsymbol { y } = \\left( \\boldsymbol { I } ^ { 1 : V } , \\boldsymbol { K } ^ { 1 : V } , \\boldsymbol { M } ^ { 1 : V } \\right)$ of the scene consists of RGB images $I ^ { i } \\in$ $\\mathbb { R } ^ { 3 \\times h \\times w }$ , $i = 1 , \\ldots , V$ taken from $V$ many camera views, their respective camera projection matrices $K ^ { i } \\in \\mathbb { R } ^ { 3 \\times 4 }$ (including both intrinsics and extrinsics), and per-view image masks ${ \\hat { M } } ^ { 1 : V }$ . For a global NeRF decoder, these are global non-background masks $\\dot { M } _ { \\mathrm { t o t } } ^ { i } \\in \\{ 0 , 1 \\} ^ { \\check { h } \\times w }$ , and for a compositional NeRF decoder as in [53], these are sets of binary masks $M _ { j } ^ { i } \\in \\left\\{ 0 , 1 \\right\\} ^ { h \\times w }$ that identify the objects $j = 1 , \\ldots , m$ in the scene in view $i$ . The global case is equivalent to $m = 1$ , $M _ { j = 1 } ^ { i } = M _ { \\mathrm { t o t } } ^ { i }$ . The encoder $\\Omega$ maps these posed image observations from the multiple views into a set of latent vectors $z _ { 1 : m }$ , where each $z _ { j }$ represents each object in the scene separately in the compositional case, or the single $z _ { 1 }$ all objects in the scene. This is achieved by querying $\\Omega$ on the masks $M _ { j } ^ { 1 : V }$ , i.e., ",
+        "bbox": [
+            173,
+            660,
+            825,
+            799
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/ae4fa5e355ee4403b5dec4ea966af0f50b0cf1276325b49f8087ac6f76c61b49.jpg",
+        "text": "$$\nz _ { j } = \\Omega \\left( { I } ^ { 1 : V } , { K } ^ { 1 : V } , { M } _ { j } ^ { 1 : V } \\right) \\in \\mathbb { R } ^ { k }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            383,
+            806,
+            612,
+            827
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "for object $j$ . The supervision signal to train the encoder is the image reconstruction loss ",
+        "bbox": [
+            171,
+            832,
+            746,
+            847
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/b9ce5d6cafd4d743c39b2d4ea60d1ec760df536b3a41e2a9bfec5e31f8fba2e5.jpg",
+        "text": "$$\n\\mathcal { L } ^ { i } = \\left. I ^ { i } \\circ M _ { \\mathrm { t o t } } ^ { i } - D \\left( \\Omega \\left( I ^ { 1 : V } , K ^ { 1 : V } , M _ { 1 : m } ^ { 1 : V } \\right) , K ^ { i } \\right) \\right. _ { 2 } ^ { 2 }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            320,
+            853,
+            678,
+            876
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "on the input view $i$ where the decoder $D$ renders an image $I = D ( z _ { 1 : m } , K )$ for arbitrary views specified by the camera matrix $K$ from the set of latent vectors $z _ { 1 : m }$ . Both the encoder and decoder ",
+        "bbox": [
+            174,
+            882,
+            823,
+            911
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "are trained end-to-end at the same time. The target images for the decoder are the same in both the   \nglobal and compositional case: the global-maskedthe compositional case this can be computed with $\\overline { { I ^ { i } \\circ M _ { \\mathrm { t o t } } ^ { i } } }$ is the element-wise product). In. By fusing the information from $M _ { \\mathrm { t o t } } ^ { i } = \\bigvee _ { j = 1 } ^ { m } \\bar { M } _ { j } ^ { i }$   \nthe scene from multiple views, this auto-encoder framework can learn latent vectors that represent   \nthe 3D configurations (shape and pose) of the objects in the scene. ",
+        "bbox": [
+            173,
+            90,
+            825,
+            176
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "4.3 Latent-Conditioned NeRF Decoder Details ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            193,
+            509,
+            208
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Global. The original NeRF formulation [16] learns a fully connected network $f$ that represents one single scene (Sec. 3.2). In order to create a decoder from NeRFs within an auto-encoder to learn a latent space, we condition the NeRF $f ( \\cdot , z )$ on the latent vector $z \\in \\mathbb { R } ^ { k }$ [42, 43, 44]. While approaches such as [42, 43, 44] use the latent code to represent factors such as lighting or categorylevel generalization, in our case the latent code is intended to represent the scene variation, i.e., shape and configuration of objects, such that a downstream RL agent may use this as a state representation. ",
+        "bbox": [
+            173,
+            219,
+            826,
+            304
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Compositional. In the compositional case, the encoder produces a set of latent vectors $z _ { 1 : m }$ describing each object $j = 1 , \\dots , m$ individually, this leads to $m$ many NeRFs $( \\sigma _ { j } ( x ) , c _ { j } ( x ) ) = f _ { j } ( x ) \\stackrel {  } { = }$ $f ( x , z _ { j } )$ , $j = 1 , \\dots , m$ with their associated volume density $\\sigma _ { j }$ and color value $c _ { j }$ . Note that while one could use different networks $f _ { j }$ with their own network weights for each object, we have a single network $f$ for all objects. This means that both the object’s pose as well as its shape and type are represented through the latent code $z _ { j }$ . In order to force those conditioned NeRFs to learn the 3D configuration of each object separately, we compose them into a global NeRF model with the composition formulas (proposed e.g., by [80, 81]): $\\begin{array} { r } { \\sigma ( x ) = \\sum _ { j = 1 } ^ { m } \\overline { { \\sigma } } _ { j } ( x ) } \\end{array}$ $\\begin{array} { r } { c ( x ) = \\frac { 1 } { \\sigma ( x ) } \\sum _ { j = 1 } ^ { m } \\sigma _ { j } ( x ) c _ { j } ( x ) } \\end{array}$ . As this composition happens in 3D space, the latent vectors will be learned such that they correctly represent the actual shape and pose of the objects in the scene with respect to the other objects, which we hypothesize may be useful for the downstream RL agent. ",
+        "bbox": [
+            173,
+            309,
+            825,
+            468
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "4.4 Encoder Details ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            486,
+            325,
+            501
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "The encoder $\\Omega$ operates by fusing multiple views together to estimate the latent vector for the RL task. Since the scientific question of this work is to investigate whether a decoder built from NeRFs to train the encoder end-to-end is beneficial for RL, we consider two different encoder architectures. The first one is a 2D CNN that averages feature encodings from the different views, where each encoding is additionally conditioned on the camera matrix of that view. The second one is based on a learned 3D neural vector field that incorporates 3D biases by fusing the different camera views in 3D space through 3D convolutions and camera projection. This way, we are able to distinguish between the importance of 3D priors incorporated into the encoder versus the decoder. ",
+        "bbox": [
+            173,
+            512,
+            825,
+            623
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Per-image CNN Encoder (“Image encoder”). For the global version, we utilize the network architecture from [11] as an encoder choice. In order to work with multiple objects in the compositional case, we modify the architecture from [11] by taking the object masks into account as follows. For each object $j$ , the 2D CNN encoder computes ",
+        "bbox": [
+            174,
+            628,
+            825,
+            685
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/bd5829d29b4c2935d19e7cc3e7e83598b42b344f542640b9eae7be68a6499d16.jpg",
+        "text": "$$\nz _ { j } = \\Omega _ { \\mathrm { C N N } } \\left( I ^ { 1 : V } , K ^ { 1 : V } , M _ { j } ^ { 1 : V } \\right) = h _ { \\mathrm { M L P } } \\left( \\frac { 1 } { V } \\sum _ { i = 1 } ^ { V } g _ { \\mathrm { M L P } } \\left( E _ { \\mathrm { C N N } } \\left( I ^ { i } \\circ M _ { j } ^ { i } \\right) , K ^ { i } \\right) \\right) .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            233,
+            688,
+            764,
+            731
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "$E _ { \\mathrm { C N N } }$ is a ResNet-18 [82] CNN feature extractor that determines a feature from the masked input image $I ^ { i } \\circ M _ { j } ^ { i }$ of object $j$ for each view $i$ , which is then concatenated with the (flattened) camera matrix. The output of the network $g _ { \\mathrm { M L P } }$ is hence the encoding of each view, including the camera information, which is averaged and then processed with $h _ { \\mathrm { M L P } }$ , to produce the final latent vector. Note that in the global case, we set $m = 1$ , ${ M _ { j = 1 } ^ { i } = M _ { \\mathrm { t o t } } ^ { i } }$ such that $\\Omega _ { \\mathrm { C N N } }$ produces a single latent vector. ",
+        "bbox": [
+            173,
+            738,
+            825,
+            810
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Neural Field 3D CNN Encoder (“Field encoder”). Several authors [43] have considered to incorporate 3D biases into learning an encoder by computing pixel-aligned features from queried 3D locations of the scene to fuse the information from the different camera views directly in 3D space. We utilize the encoder architecture from [53], where the idea is to learn a neural vector field $\\mathring { \\phi } \\big [ I ^ { 1 : V } , M _ { j } ^ { 1 : V } \\big ] : \\mathbb { R } ^ { 3 }  \\mathbb { R } ^ { E }$ over 3D space, conditioned on the input views and masks. The features of $\\bar { \\phi }$ are computed from projecting the query point into the camera coordinate system from the respective view. To turn $\\phi$ into a latent vector, it is queried on a workspace set $\\mathcal { X } _ { h } \\ \\backslash \\ \\backslash \\ \\mathbb { R } ^ { d _ { \\mathcal { X } } \\times h _ { \\mathcal { X } } \\times w _ { \\mathcal { X } } }$ (a 3D grid) and then processed by a 3D convolutional network, i.e., $z _ { j } = E _ { \\mathrm { 3 D C N N } } \\left( \\phi \\left[ I ^ { 1 : V } , M _ { j } ^ { 1 : V } \\right] ( \\mathcal { X } _ { h } ) \\right)$ This method differs from [43, 83, 60] by computing a latent vector from the pixel-aligned features. ",
+        "bbox": [
+            173,
+            814,
+            825,
+            911
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            90,
+            825,
+            119
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "5 Baselines / Alternative State Representations ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            140,
+            576,
+            157
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "In this section, we briefly describe alternative ways of training an encoder for RL, which we will investigate in the experiments as baselines and ablations. For details, refer to the appendix. ",
+        "bbox": [
+            176,
+            172,
+            823,
+            200
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Conv. Autoencoder. This baseline uses a standard CNN decoder based on deconvolutions instead of NeRF to reconstruct the image from the latent representation, similar to [1]. Therefore, with this baseline we investigate the influence of the NeRF decoder relative to CNN decoders. We follow the architecture of [11] for the deconvolution part for the global case. In the compositional case, single, global one. The image I = Ddeconv(gMLP( 1m Pmj=1 zj ), K) is rendered from z1:m by first averaging the latent vectors and then processing the averaged vector with a fully connected network $g _ { \\mathrm { M L P } }$ , leading to an aggregated feature. This aggregated feature is concatenated with the (flattened) camera matrix $K$ describing the desired view and then rendered into the image with $D _ { \\mathrm { d e c o n v } }$ . In the experiments, we utilize this decoder as the supervision signal to train the latent space produced by the 2D CNN encoder from Sec. 4.4. In the compositional version, the 2D CNN encoder (4) use the same object masks as the compositional NeRF-RL variant. ",
+        "bbox": [
+            174,
+            207,
+            825,
+            375
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Contrastive Learning. As an alternative to learning an encoder via a reconstruction loss, the idea of contrastive learning [84] is to define a loss function directly on the latent space that tries to pull latent vectors describing the same configurations together (called positive samples) while ones representing different system states apart (called negative samples). A popular approach to achieve this is with the InfoNCE loss [85, 64]. Let $y _ { i }$ and $\\tilde { y } _ { i }$ be two different observations of the same state. Here, ˜· denotes a i i perturbed/augmented version of the observation. For a mini-batch of observations $\\{ ( y _ { i } , \\tilde { y } _ { i } ) \\} _ { i = 1 } ^ { n }$ , after encoding those into their respective latent vectors $z _ { i } = \\Omega ( y _ { i } )$ , $\\tilde { z } _ { i } = \\Omega ( \\tilde { y } _ { i } )$ with the encoder $\\Omega$ , the loss for that batch would use $( z _ { i } , \\tilde { z } _ { i } )$ as a positive pair, and $( z _ { i } , \\tilde { z } _ { \\neq i } )$ as a negative pair, or some similar variation. A crucial question in contrastive learning is how the observation $y$ is perturbed/augmented into $\\tilde { y }$ to generate positive and negative training pairs, described in the following. ",
+        "bbox": [
+            174,
+            381,
+            825,
+            520
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "CURL. In CURL [5], the input image is randomly cropped to generate $y$ and $\\tilde { y }$ . We closely follow the hyperparameters and design of [5]. CURL operates on a single input view and we choose a view for this baseline from which the state of the environment can be inferred as best as possible (Fig. 17). ",
+        "bbox": [
+            176,
+            526,
+            821,
+            568
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Multi-View CURL. This baseline investigates if the neural field 3D encoder (Sec. 4.4) can be trained with a contrastive loss. As this encoder operates on multiple input views we double the number of available camera views. Half of the views are the same as in the other experiments, the other half are captured from sightly perturbed camera angles. We use the same loss as CURL, but with different contrastive pairs – rather than from augmentation, the contrastive style is taken from TCN [68]: the positive pairs come from different views but at the same moment in time, while negative pairs come from different times. Therefore, this baseline can be seen as a multi-view adaptation of CURL [5]. ",
+        "bbox": [
+            174,
+            574,
+            825,
+            671
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Direct State / Keypoint Representations. Finally, we also consider a direct, low-dimensional representation of the state. Since we are interested in generalizing over different object shapes, we consider multiple 3D keypoints that are attached at relevant locations of the objects by expert knowledge and observed with a perfect keypoint detector [8]. See Fig. 2b for a visualization of those keypoints. The keypoints both provide information about object shape and its pose. Furthermore, as seen in Fig. 2b, they have been chosen to reflect those locations in the environment relevant to solve the task. Additionally, we report results where the state is represented by the poses of the objects – as this cannot represent object shape, in this case we use a constant object shape for training and test. ",
+        "bbox": [
+            174,
+            676,
+            825,
+            787
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "6 Experiments ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            809,
+            312,
+            827
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "We evaluate our proposed method on different environments where the geometry of the objects in the scene is important to solve the task successfully. Please also refer to the video https://dannydriess.github.io/nerf-rl. Commonly, RL is trained and evaluated on a single environment, where only the poses are changed, but the involved object shapes are kept constant. Since latent-conditioned NeRFs have been shown to be capable of generalizing over geometry [43], we consider experiments where we require the RL agent to generalize over object shapes within some distribution. Answering the scientific question of this work requires environments with multi-view observations — and for the compositional versions object masks as well. These are not provided in standard RL benchmarks, which is the reason for choosing the environments investigated in this work. We use PPO [86] as the RL algorithm and four camera views in all experiments. Refer to the appendix for more details about our environments, parameter choices, network architectures, and training times. ",
+        "bbox": [
+            174,
+            842,
+            825,
+            911
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            92,
+            825,
+            188
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "6.1 Environments ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            210,
+            310,
+            226
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Mug on Hook. In this environment, adopted from [87] and visualized in Fig. 2b, the task is to hang a mug on a hook. Both the mug and the hook shape are randomized. The actions are small 3D translations applied to the mug. This environment is challenging as we require the RL agent to generalize over mug and hook shapes and the tolerance between the handle opening and the hook is relatively small. Further, the agent receives a sparse reward only if the mug has been hung stably. This reward is calculated by virtually simulating a mug drop after each action. If the mug does not fall onto the ground from the current state, a reward of one is assigned, otherwise zero. ",
+        "bbox": [
+            174,
+            238,
+            825,
+            337
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Planar Pushing. The task in this environment, shown in Fig. 3b, is to push yellow box-shaped objects into the left region of the table and blue objects into the right region with the red pusher that can move in the plane, i.e., the action is two dimensional. This is the same environment as in [53] with the same four different camera views. Each run contains a single object on the table (plus the pusher). If the box has been pushed inside its respective region, a sparse reward of one is received, otherwise zero. The boxes in the environment have different sizes, two colors and are randomly initialized. In this environment, we cannot use keypoints for the multi-shape setting, as the reward depends on the object color; we evaluate the keypoints baseline only in the single shape case (Appendix). ",
+        "bbox": [
+            173,
+            342,
+            825,
+            454
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Door Opening. Fig. 4b shows the door environment, where the task is to open a sliding door with the red end-effector that can be translated in 3 DoFs as the action. To solve this task, the agent has to push on the door handle. As the handle position and size is randomized, the agent has to learn to interact with the handle geometry accordingly. Interestingly, as can be seen in the video in the supplementary material, the agent often chooses to push on the handle only at the beginning, as, afterwards, it is sufficient to push the door itself at its side. The agent receives a sparse reward if the door has been opened sufficiently, otherwise, zero reward is assigned. ",
+        "bbox": [
+            174,
+            459,
+            825,
+            556
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "6.2 Results ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            579,
+            263,
+            593
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Figs 2a, 3a, 4a show success rates (averaged over 6 independent experiment repetitions and over 30 test rollouts per repetition per timestep) as a function of training steps. Also shown are the $6 8 \\%$ confidence intervals. These success rates have been evaluated using randomized object shapes and initial conditions, and therefore reflect the agent’s ability to generalize over these. ",
+        "bbox": [
+            174,
+            607,
+            825,
+            662
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "In all these experiments, a latent space trained with compositional NeRF supervision as the decoder consistently outperformed all other learned representations, both in terms of sample efficiency and asymptotic performance. Furthermore, our proposed framework with compositional NeRF even outperforms the expert keypoint representation. For the door environment, the 3D neural field encoder plus NeRF decoder (NeRF-RL comp. $^ +$ field) reaches nearly perfect success rates. For the other two environments, the compositional 2D CNN encoder plus NeRF decoder (NeRF-RL comp. $^ +$ image) was slightly better than with the neural field encoder but not significantly. This shows that the decoder built from compositional NeRF is relevant for the performance, not so much the choice of the encoder. ",
+        "bbox": [
+            174,
+            670,
+            825,
+            780
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Training the 3D neural field encoder with a contrastive loss as supervision signal for different camera views as positive/negative training pairs is not able to achieve significant learning progress in these scenarios (Multi-CURL). However, the other contrastive baseline, CURL, which has a different encoder and uses image cropping as data augmentation instead of additional camera views, is able to achieve decent performance and sample efficiency on the door environment, but not for the pushing environment. In the mug environment, CURL initially is able to make learning progress comparable to our framework, but never reaches a success rate above $59 \\%$ and then becomes unstable. Similarly, the global CNN autoencoder baseline shows decent learning progress initially on the mug and pushing scenario (not for the door), but then becomes unstable (mug) or never surpasses $50 \\%$ success rate ",
+        "bbox": [
+            174,
+            786,
+            825,
+            911
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "table",
+        "img_path": "images/12d8366b7eeeb86c161902d81a4be7f8f41470c69b1d5b4f98a24d492f95c7e4.jpg",
+        "table_caption": [],
+        "table_footnote": [],
+        "table_body": "<table><tr><td></td><td></td><td>encoder</td><td>decoder</td><td>comp.</td><td>NeRF</td><td>loss</td></tr><tr><td>NeRF- RL</td><td>comp.+field</td><td>3D CNN</td><td>comp.3D NeRF</td><td>·</td><td>√</td><td>image reconstr.: L2</td></tr><tr><td>(ours)</td><td>comp.+image global+image</td><td>2D CNN</td><td>comp.3D NeRF</td><td></td><td>！</td><td>image reconstr.: L2</td></tr><tr><td></td><td></td><td>2D CNN</td><td>global3DNeRF</td><td>X</td><td>√</td><td>image reconstr.: L2</td></tr><tr><td></td><td>Conv. Autoencoder, c</td><td>2D CNN</td><td>comp. 2D CNN</td><td></td><td>X</td><td>image reconstr.: L2</td></tr><tr><td></td><td>Conv. Autoencoder, g</td><td>2D CNN</td><td>2D CNN</td><td>&lt;xx&gt;</td><td>X</td><td>image reconstr.: L2</td></tr><tr><td></td><td>CURL</td><td>2D CNN</td><td>=</td><td></td><td>X</td><td>contrast: InfoNCE</td></tr><tr><td></td><td>Multi-CURL</td><td>3D CNN</td><td></td><td></td><td>X</td><td>contrast: InfoNCE</td></tr><tr><td>Keypoints</td><td></td><td colspan=\"5\">chosen by expert knowledge and perfect extraction</td></tr></table>",
+        "bbox": [
+            174,
+            94,
+            818,
+            222
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "image",
+        "img_path": "images/427fb0418253d91807f58566d0949d0a46f6d954a7b89526b437e24a8477e2e8.jpg",
+        "image_caption": [
+            "Table 1: Overview of the different state representation learning frameworks. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            200,
+            253,
+            488,
+            431
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "(a) Learning curve. ",
+        "bbox": [
+            289,
+            429,
+            405,
+            441
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "image",
+        "img_path": "images/0f7197ae1b39e7782caa288ae336ac227d4cde2f66f791616e524f5cfecde6e6.jpg",
+        "image_caption": [],
+        "image_footnote": [],
+        "bbox": [
+            504,
+            257,
+            802,
+            400
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "(b) Left: Blue coordinate frames denote the four camera poses. Red points are the expert keypoints. Right: NeRF renderings (different scenes). ",
+        "bbox": [
+            501,
+            402,
+            807,
+            441
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "image",
+        "img_path": "images/7e6d50f1d5dbad6e807c7343717f3c0c7d0d91e9510da19e6b6bad96efd12eef.jpg",
+        "image_caption": [
+            "Figure 2: Mug on hook environment. (b) shows an example scene and NeRF renderings "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            189,
+            474,
+            475,
+            646
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "image",
+        "img_path": "images/b139944183ef2475b94da0efb6892833cd0df8dd249757014b13d05cc40b0ca6.jpg",
+        "image_caption": [],
+        "image_footnote": [],
+        "bbox": [
+            488,
+            478,
+            812,
+            621
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "(b) Left: Blue coordinate frames denote the four camera poses. Yellow and blue areas are goal regions where the objects should be pushed to. Right: NeRF renderings. ",
+        "bbox": [
+            480,
+            623,
+            816,
+            661
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "image",
+        "img_path": "images/fa81140a6d4f2769491051398b47d5d1a71276ba377fb212d3704b8f2fbdaa06.jpg",
+        "image_caption": [
+            "Figure 3: Pushing environment. (b) shows NeRF renderings for different scenes. ",
+            "Figure 4: Door environment. (b) shows NeRF renderings for different scenes. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            187,
+            695,
+            816,
+            873
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "(a) Learning curve. ",
+        "bbox": [
+            277,
+            869,
+            393,
+            882
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "(pushing). Such variations in performance or instable learning across the different environments have not been observed with our method, which is stable in all cases. ",
+        "bbox": [
+            171,
+            92,
+            823,
+            118
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "The compositional variant (NeRF-RL comp.) of our framework achieves the highest performance. Since the conv. comp. autoencoder baseline has worse performance than its global variant, compositionality alone is not the sole reason for the better performance of our state representation. Indeed, the global NeRF-RL $^ +$ image variant in the pushing env. is also better than all other baselines. ",
+        "bbox": [
+            174,
+            126,
+            825,
+            181
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "In the appendix Sec. A.1, we find a positive correlation between NeRF reconstruction quality and RL performance. Furthermore, it turns out that the performance of our framework is not significantly affected when we pretrain the encoder with less data (Sec. A.2). In Sec. A.3, we investigate the influence of the number of input views on the RL performance. In the pushing scenario, only two or even one input view are sufficient for good performance. However, for tasks that require more 3D understanding such as the mug scenario, we observe a drop in performance when reducing the number of views from 4 to 2. ",
+        "bbox": [
+            174,
+            188,
+            825,
+            285
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "7 Discussion ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            308,
+            292,
+            325
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Why NeRF provides better supervision. The NeRF training objective (1) strongly forces each $f ( \\cdot , z _ { j } )$ to represent each object in its actual 3D configuration and relative to other objects in the scene (compositional case), including their shape. This implies that the latent vectors $z _ { j }$ have to contain this information, i.e., they are trained to determine the object type, shape and pose in the scene. In the global case, $z _ { 1 }$ has to represent the geometry of the whole secne. As the tasks we consider require policies to take the geometry of the objects into account, we hypothesize that a latent vector that is capable of parameterizing a NeRF to reconstruct the scene in the 3D space has to contain enough of the relevant 3D information of the objects also for the policy to be successful. ",
+        "bbox": [
+            174,
+            342,
+            825,
+            453
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Masks. In order for the auto-encoder framework to be compositional, it requires object masks. We believe that instance segmentation has reached a level of maturity [88] that this is a fair assumption to make. As we also utilize the individual masks for the compositional conv. autoencoder and the multi-view CURL baseline, which do not show good performance, it indicates that the masks are not the main reason that our state representation achieves higher performance. This is further supported by the fact that the global NeRF-RL variant which does not rely on individual object masks on the pushing scenario achieved a performance higher than all baselines, i.e., masks will increase the performance of NeRF-RL as they enable the compositional version, but they do not seem essential. ",
+        "bbox": [
+            174,
+            472,
+            825,
+            583
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Offline/Online. In this work, we focused on pretraining the latent representation offline from a dataset collected by random actions. During RL, the encoder is fixed and only the policy networks are learned. This has the advantage that the same representation can be used for different RL tasks and the dataset to train the representation not necessarily has to come from the same distribution. However, if a policy is needed to explore reasonable regions of the state space, collecting a dataset offline to learn a latent space that covers the state space sufficiently might be more challenging for an offline approach. This was not an issue for our experiments where data collection with random actions was sufficient. Indeed, we show generalization over different starting states of the same environment and with respect to different shapes (within distribution). Future work could investigate NeRF supervision in an online setup. Note that the reconstruction loss via NeRF is computationally more demanding than via a 2D CNN deconv. decoder or a contrastive term, making NeRF supervision as an auxiliary loss at each RL training step costly. One potential solution for this is to apply the auxiliary loss not at every RL training step, but with a lower frequency. Regarding computational efficiency, this is where contrastive learning has an advantage over our proposed NeRF-based decoder, as the encoding with CURL can be trained within half a day, whereas the NeRF auto-encoder took up to 2 days to train for our environments. However, when using the encoder for RL, there is no difference in inference time. ",
+        "bbox": [
+            174,
+            602,
+            825,
+            821
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Multi-View. The auto-encoder framework we propose can fuse the information of multiple camera views into a latent vector describing an object in the scene. This way, occlusions can be addressed and the agent can gain a better 3D understanding of the scene from the different camera angles. Having access to multiple camera views and their camera matrices is an additional assumption we make, although we believe the capability to utilize this information is an advantage of our method. ",
+        "bbox": [
+            174,
+            842,
+            825,
+            911
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "8 Conclusion ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            89,
+            299,
+            106
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "In this work, we have proposed the idea to utilize Neural Radiance Fields (NeRFs) to train latent spaces for RL. Our environments focus on tasks where the geometry of the objects in the scene is relevant for successfully solving the tasks. Training RL agents with the pretrained encoder that maps multiple views of the scene to a latent space consistently outperformed other ways of learning a state representation and even keypoints chosen by expert knowledge. Our results show that the 3D prior present in compositional NeRF as the decoder is more important than priors in the encoder. ",
+        "bbox": [
+            174,
+            121,
+            825,
+            204
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Broader Impacts. Our main contribution is a method to learn representations that improve the efficiency of vision-based RL, which could impact automation. As such, our work inherits general ethical risks of AI, like the question of how to address the potential of increased automation in society. ",
+        "bbox": [
+            174,
+            210,
+            825,
+            252
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Acknowledgments ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            271,
+            330,
+            287
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "The authors thank Russ Tedrake for initial discussions; Jonathan Tompson and Jon Barron for feedback on drafts; Vincent Vanhoucke for encouraging latent NeRFs. ",
+        "bbox": [
+            174,
+            303,
+            823,
+            330
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "This research has been supported by the Deutsche Forschungsgemeinschaft (DFG, German Research Foundation) under Germany’s Excellence Strategy – EXC 2002/1 “Science of Intelligence” – project number 390523135. Danny Driess thanks the International Max-Planck Research School for Intelligent Systems (IMPRS-IS) for the support. Ingmar Schubert acknowledges support by the German Academic Scholarship Foundation. Yunzhu Li acknowledges support by Amazon.com Services LLC, PO# #2D-06310236 and the Wistron Corporation. ",
+        "bbox": [
+            174,
+            337,
+            825,
+            420
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "References ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            440,
+            267,
+            455
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "[1] C. Finn, X. Y. Tan, Y. Duan, T. Darrell, S. Levine, and P. Abbeel. Deep spatial autoencoders for visuomotor learning. In 2016 IEEE International Conference on Robotics and Automation (ICRA), pages 512–519. IEEE, 2016.   \n[2] R. Jonschkowski, R. Hafner, J. Scholz, and M. Riedmiller. Pves: Position-velocity encoders for unsupervised learning of structured state representations. arXiv preprint arXiv:1705.09805, 2017.   \n[3] D. Dwibedi, J. Tompson, C. Lynch, and P. Sermanet. Learning actionable representations from visual observations. In 2018 IEEE/RSJ International Conference on Intelligent Robots and Systems (IROS), pages 1577–1584. IEEE, 2018.   \n[4] T. D. Kulkarni, A. Gupta, C. Ionescu, S. Borgeaud, M. Reynolds, A. Zisserman, and V. Mnih. Unsupervised learning of object keypoints for perception and control. Advances in neural information processing systems, 32, 2019.   \n[5] M. Laskin, A. Srinivas, and P. Abbeel. Curl: Contrastive unsupervised representations for reinforcement learning. In International Conference on Machine Learning, pages 5639–5650. PMLR, 2020.   \n[6] L. Manuelli, Y. Li, P. Florence, and R. Tedrake. Keypoints into the future: Self-supervised correspondence in model-based reinforcement learning. arXiv preprint arXiv:2009.05085, 2020.   \n[7] M. Vecerik, J.-B. Regli, O. Sushkov, D. Barker, R. Pevceviciute, T. Rothörl, C. Schuster, R. Hadsell, L. Agapito, and J. Scholz. S3k: Self-supervised semantic keypoints for robotic manipulation via multi-view consistency. arXiv preprint arXiv:2009.14711, 2020.   \n[8] L. Manuelli, W. Gao, P. Florence, and R. Tedrake. kpam: Keypoint affordances for categorylevel robotic manipulation. arXiv preprint arXiv:1903.06684, 2019.   \n[9] V. Mnih, K. Kavukcuoglu, D. Silver, A. Graves, I. Antonoglou, D. Wierstra, and M. Riedmiller. Playing atari with deep reinforcement learning. arXiv preprint arXiv:1312.5602, 2013.   \n[10] V. Mnih, K. Kavukcuoglu, D. Silver, A. A. Rusu, J. Veness, M. G. Bellemare, A. Graves, M. Riedmiller, A. K. Fidjeland, G. Ostrovski, et al. Human-level control through deep reinforcement learning. nature, 518(7540):529–533, 2015.   \n[11] Y. Li, S. Li, V. Sitzmann, P. Agrawal, and A. Torralba. 3d neural scene representations for visuomotor control. In Conference on Robot Learning, pages 112–123. PMLR, 2022.   \n[12] S. Lange and M. Riedmiller. Deep auto-encoder neural networks in reinforcement learning. In The 2010 International Joint Conference on Neural Networks (IJCNN), 2010.   \n[13] A. Vaswani, N. Shazeer, N. Parmar, J. Uszkoreit, L. Jones, A. N. Gomez, Ł. Kaiser, and I. Polosukhin. Attention is all you need. Advances in neural information processing systems, 30, 2017.   \n[14] A. Dosovitskiy, L. Beyer, A. Kolesnikov, D. Weissenborn, X. Zhai, T. Unterthiner, M. Dehghani, M. Minderer, G. Heigold, S. Gelly, et al. An image is worth 16x16 words: Transformers for image recognition at scale. arXiv preprint arXiv:2010.11929, 2020.   \n[15] I. Akinola, J. Varley, and D. Kalashnikov. Learning precise 3d manipulation from multiple uncalibrated cameras. In 2020 IEEE International Conference on Robotics and Automation (ICRA), pages 4616–4622. IEEE, 2020.   \n[16] B. Mildenhall, P. P. Srinivasan, M. Tancik, J. T. Barron, R. Ramamoorthi, and R. Ng. Nerf: Representing scenes as neural radiance fields for view synthesis. In European conference on computer vision, pages 405–421. Springer, 2020.   \n[17] F. Dellaert and L. Yen-Chen. Neural volume rendering: Nerf and beyond, 2021.   \n[18] S. A. Eslami, D. Jimenez Rezende, F. Besse, F. Viola, A. S. Morcos, M. Garnelo, A. Ruderman, A. A. Rusu, I. Danihelka, K. Gregor, et al. Neural scene representation and rendering. Science, 360(6394):1204–1210, 2018.   \n[19] J. J. Park, P. Florence, J. Straub, R. Newcombe, and S. Lovegrove. Deepsdf: Learning continuous signed distance functions for shape representation. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, pages 165–174, 2019.   \n[20] L. Mescheder, M. Oechsle, M. Niemeyer, S. Nowozin, and A. Geiger. Occupancy networks: Learning 3d reconstruction in function space. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, pages 4460–4470, 2019.   \n[21] Z. Chen and H. Zhang. Learning implicit fields for generative shape modeling. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, pages 5939–5948, 2019.   \n[22] V. Sitzmann, M. Zollhöfer, and G. Wetzstein. Scene representation networks: Continuous 3d-structure-aware neural scene representations. Advances in Neural Information Processing Systems, 32, 2019.   \n[23] Y. Xie, T. Takikawa, S. Saito, O. Litany, S. Yan, N. Khan, F. Tombari, J. Tompkin, V. Sitzmann, and S. Sridhar. Neural fields in visual computing and beyond. arXiv preprint arXiv:2111.11426, 2021.   \n[24] A. Tewari, J. Thies, B. Mildenhall, P. Srinivasan, E. Tretschk, Y. Wang, C. Lassner, V. Sitzmann, R. Martin-Brualla, S. Lombardi, et al. Advances in neural rendering. arXiv preprint arXiv:2111.05849, 2021.   \n[25] J. T. Barron, B. Mildenhall, M. Tancik, P. Hedman, R. Martin-Brualla, and P. P. Srinivasan. Mip-nerf: A multiscale representation for anti-aliasing neural radiance fields. In Proceedings of the IEEE/CVF International Conference on Computer Vision, pages 5855–5864, 2021.   \n[26] J. T. Barron, B. Mildenhall, D. Verbin, P. P. Srinivasan, and P. Hedman. Mip-nerf 360: Unbounded anti-aliased neural radiance fields. arXiv preprint arXiv:2111.12077, 2021.   \n[27] M. Tancik, V. Casser, X. Yan, S. Pradhan, B. Mildenhall, P. P. Srinivasan, J. T. Barron, and H. Kretzschmar. Block-nerf: Scalable large scene neural view synthesis. arXiv preprint arXiv:2202.05263, 2022.   \n[28] M. Boss, R. Braun, V. Jampani, J. T. Barron, C. Liu, and H. Lensch. NeRD: Neural reflectance decomposition from image collections. https://arxiv.org/abs/2012.03918, 2020.   \n[29] P. Srinivasan, B. Deng, X. Zhang, M. Tancik, B. Mildenhall, and J. T. Barron. NeRV: Neural reflectance and visibility fields for relighting and view synthesis. https://arxiv.org/abs/2012.03927, 2020.   \n[30] X. Zhang, P. P. Srinivasan, B. Deng, P. Debevec, W. T. Freeman, and J. T. Barron. Nerfactor: Neural factorization of shape and reflectance under an unknown illumination. https://arxiv.org/abs/2106.01970, 2021.   \n[31] L. Liu, J. Gu, K. Z. Lin, T.-S. Chua, and C. Theobalt. Neural sparse voxel fields. In Advances in Neural Information Processing Systems (NeurIPS), volume 33, 2020.   \n[32] D. Lindell, J. Martel, and G. Wetzstein. AutoInt: Automatic integration for fast neural volume rendering. https://arxiv.org/abs/2012.01714, 2020.   \n[33] D. Rebain, W. Jiang, S. Yazdani, K. Li, K. M. Yi, and A. Tagliasacchi. DeRF: Decomposed radiance fields. https://arxiv.org/abs/2011.12490, 2020.   \n[34] T. Neff, P. Stadlbauer, M. Parger, A. Kurz, J. H. Mueller, C. R. A. Chaitanya, A. S. Kaplanyan, and M. Steinberger. DONeRF: Towards Real-Time Rendering of Compact Neural Radiance Fields using Depth Oracle Networks. Computer Graphics Forum, 40(4), 2021. ISSN 1467-8659. doi: 10.1111/cgf.14340. URL https://doi.org/10.1111/cgf.14340.   \n[35] S. J. Garbin, M. Kowalski, M. Johnson, J. Shotton, and J. Valentin. Fastnerf: High-fidelity neural rendering at 200fps. https://arxiv.org/abs/2103.10380, 2021.   \n[36] C. Reiser, S. Peng, Y. Liao, and A. Geiger. Kilonerf: Speeding up neural radiance fields with thousands of tiny mlps, 2021.   \n[37] A. Yu, R. Li, M. Tancik, H. Li, R. Ng, and A. Kanazawa. Plenoctrees for real-time rendering of neural radiance fields. In arXiv, 2021.   \n[38] S. Lombardi, T. Simon, G. Schwartz, M. Zollhoefer, Y. Sheikh, and J. Saragih. Mixture of volumetric primitives for efficient neural rendering, 2021.   \n[39] A. Yu, S. Fridovich-Keil, M. Tancik, Q. Chen, B. Recht, and A. Kanazawa. Plenoxels: Radiance fields without neural networks. arXiv preprint arXiv:2112.05131, 2021.   \n[40] V. Sitzmann, S. Rezchikov, W. T. Freeman, J. B. Tenenbaum, and F. Durand. Light field networks: Neural scene representations with single-evaluation rendering. In arXiv, 2021.   \n[41] T. Müller, A. Evans, C. Schied, and A. Keller. Instant neural graphics primitives with a multiresolution hash encoding. ACM Trans. Graph., 41(4):102:1–102:15, July 2022. doi: 10.1145/3528223.3530127. URL https://doi.org/10.1145/3528223.3530127.   \n[42] R. Martin-Brualla, N. Radwan, M. S. Sajjadi, J. T. Barron, A. Dosovitskiy, and D. Duckworth. Nerf in the wild: Neural radiance fields for unconstrained photo collections. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, pages 7210–7219, 2021.   \n[43] A. Yu, V. Ye, M. Tancik, and A. Kanazawa. pixelnerf: Neural radiance fields from one or few images. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, pages 4578–4587, 2021.   \n[44] Q. Wang, Z. Wang, K. Genova, P. P. Srinivasan, H. Zhou, J. T. Barron, R. Martin-Brualla, N. Snavely, and T. Funkhouser. Ibrnet: Learning multi-view image-based rendering. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, pages 4690–4699, 2021.   \n[45] K. Zhang, G. Riegler, N. Snavely, and V. Koltun. NERF $^ { + + }$ : Analyzing and improving neural radiance fields. https://arxiv.org/abs/2010.07492, 2020.   \n[46] M. Niemeyer and A. Geiger. GIRAFFE: Representing scenes as compositional generative neural feature fields. https://arxiv.org/abs/2011.12100, 2020.   \n[47] M. Guo, A. Fathi, J. Wu, and T. Funkhouser. Object-centric neural scene rendering. https://arxiv.org/abs/2012.08503, 2020.   \n[48] W. Yuan, Z. Lv, T. Schmidt, and S. Lovegrove. Star: Self-supervised tracking and reconstruction of rigid objects in motion with neural rendering. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, pages 13144–13152, 2021.   \n[49] Z. Wang, T. Bagautdinov, S. Lombardi, T. Simon, J. Saragih, J. Hodgins, and M. Zollhöfer. Learning compositional radiance fields of dynamic human heads. https://arxiv.org/abs/2012.09955, 2020.   \n[50] J. Ost, F. Mannan, N. Thuerey, J. Knodt, and F. Heide. Neural scene graphs for dynamic scenes. https://arxiv.org/abs/2011.10379, 2020.   \n[51] H.-X. Yu, L. J. Guibas, and J. Wu. Unsupervised discovery of object radiance fields. arXiv preprint arXiv:2107.07905, 2021.   \n[52] B. Yang, Y. Zhang, Y. Xu, Y. Li, H. Zhou, H. Bao, G. Zhang, and Z. Cui. Learning objectcompositional neural radiance field for editable scene rendering. In International Conference on Computer Vision (ICCV), October 2021.   \n[53] D. Driess, Z. Huang, Y. Li, R. Tedrake, and M. Toussaint. Learning multi-object dynamics with compositional neural radiance fields. arXiv preprint arXiv:2202.11855, 2022.   \n[54] H. Zhang, R. Wang, J. Zhang, C. Li, G. Yang, P. Spincemaille, T. Nguyen, and Y. Wang. Nerd: Neural representation of distribution for medical image segmentation. arXiv preprint arXiv:2103.04020, 2021.   \n[55] L. Yen-Chen, P. Florence, J. T. Barron, A. Rodriguez, P. Isola, and T.-Y. Lin. iNeRF: Inverting neural radiance fields for pose estimation. IROS, 2021.   \n[56] M. Adamkiewicz, T. Chen, A. Caccavale, R. Gardner, P. Culbertson, J. Bohg, and M. Schwager. Vision-only robot navigation in a neural radiance world. IEEE Robotics and Automation Letters, 7(2):4606–4613, 2022.   \n[57] J. Ichnowski, Y. Avigal, J. Kerr, and K. Goldberg. Dex-nerf: Using a neural radiance field to grasp transparent objects. arXiv preprint arXiv:2110.14217, 2021.   \n[58] L. Yen-Chen, P. Florence, J. T. Barron, T.-Y. Lin, A. Rodriguez, and P. Isola. NeRF-Supervision: Learning dense object descriptors from neural radiance fields. In IEEE Conference on Robotics and Automation (ICRA), 2022.   \n[59] K. Karunratanakul, J. Yang, Y. Zhang, M. J. Black, K. Muandet, and S. Tang. Grasping field: Learning implicit representations for human grasps. In 2020 International Conference on $3 D$ Vision (3DV), pages 333–344. IEEE, 2020.   \n[60] J.-S. Ha, D. Driess, and M. Toussaint. Learning neural implicit functions as object representations for robotic manipulation. arXiv preprint arXiv:2112.04812, 2021.   \n[61] A. Simeonov, Y. Du, A. Tagliasacchi, J. B. Tenenbaum, A. Rodriguez, P. Agrawal, and V. Sitzmann. Neural descriptor fields: Se (3)-equivariant object representations for manipulation. arXiv preprint arXiv:2112.05124, 2021.   \n[62] Y. Wi, P. Florence, A. Zeng, and N. Fazeli. Virdo: Visio-tactile implicit representations of deformable objects. arXiv preprint arXiv:2202.00868, 2022.   \n[63] D. Silver, A. Huang, C. J. Maddison, A. Guez, L. Sifre, G. Van Den Driessche, J. Schrittwieser, I. Antonoglou, V. Panneershelvam, M. Lanctot, et al. Mastering the game of go with deep neural networks and tree search. nature, 529(7587):484–489, 2016.   \n[64] T. Chen, S. Kornblith, M. Norouzi, and G. Hinton. A simple framework for contrastive learning of visual representations. In International conference on machine learning, pages 1597–1607. PMLR, 2020.   \n[65] K. He, H. Fan, Y. Wu, S. Xie, and R. Girshick. Momentum contrast for unsupervised visual representation learning. In Proceedings of the IEEE/CVF conference on computer vision and pattern recognition, pages 9729–9738, 2020.   \n[66] A. Srinivas, M. Laskin, and P. Abbeel. Curl: Contrastive unsupervised representations for reinforcement learning. arXiv preprint arXiv:2004.04136, 2020.   \n[67] B. You, O. Arenz, Y. Chen, and J. Peters. Integrating contrastive learning with dynamic models for reinforcement learning from images. Neurocomputing, 2022.   \n[68] P. Sermanet, C. Lynch, Y. Chebotar, J. Hsu, E. Jang, S. Schaal, S. Levine, and G. Brain. Time-contrastive networks: Self-supervised learning from video. In 2018 IEEE International Conference on Robotics and Automation (ICRA), pages 1134–1141. IEEE, 2018.   \n[69] A. Kinose, M. Okada, R. Okumura, and T. Taniguchi. Multi-view dreaming: Multi-view world model with contrastive learning. arXiv preprint arXiv:2203.11024, 2022.   \n[70] K. Chen, Y. Lee, and H. Soh. Multi-modal mutual information (mummi) training for robust selfsupervised deep reinforcement learning. In 2021 IEEE International Conference on Robotics and Automation (ICRA), pages 4274–4280. IEEE, 2021.   \n[71] S. Nair, A. Rajeswaran, V. Kumar, C. Finn, and A. Gupta. R3m: A universal visual representation for robot manipulation. arXiv preprint arXiv:2203.12601, 2022.   \n[72] A. Stooke, K. Lee, P. Abbeel, and M. Laskin. Decoupling representation learning from reinforcement learning. In International Conference on Machine Learning, pages 9870–9879. PMLR, 2021.   \n[73] S. Parisi, A. Rajeswaran, S. Purushwalkam, and A. Gupta. The unsurprising effectiveness of pre-trained vision models for control. arXiv preprint arXiv:2203.03580, 2022.   \n[74] D. Yarats, A. Zhang, I. Kostrikov, B. Amos, J. Pineau, and R. Fergus. Improving sample efficiency in model-free reinforcement learning from images. arXiv preprint arXiv:1910.01741, 2019.   \n[75] A. Zhang, R. McAllister, R. Calandra, Y. Gal, and S. Levine. Learning invariant representations for reinforcement learning without reconstruction. arXiv preprint arXiv:2006.10742, 2020.   \n[76] K. Zakka, A. Zeng, P. Florence, J. Tompson, J. Bohg, and D. Dwibedi. Xirl: Cross-embodiment inverse reinforcement learning. In Conference on Robot Learning, pages 537–546. PMLR, 2022.   \n[77] T. Xiao, I. Radosavovic, T. Darrell, and J. Malik. Masked visual pre-training for motor control. arXiv preprint arXiv:2203.06173, 2022.   \n[78] Y. Seo, K. Lee, S. James, and P. Abbeel. Reinforcement learning with action-free pre-training from videos. arXiv preprint arXiv:2203.13880, 2022.   \n[79] T. Lesort, N. Díaz-Rodríguez, J.-F. Goudou, and D. Filliat. State representation learning for control: An overview. Neural Networks, 108:379–392, 2018.   \n[80] M. Niemeyer and A. Geiger. Giraffe: Representing scenes as compositional generative neural feature fields. In Proc. IEEE Conf. on Computer Vision and Pattern Recognition (CVPR), 2021.   \n[81] K. Stelzner, K. Kersting, and A. R. Kosiorek. Decomposing 3d scenes into objects via unsupervised volume segmentation. arXiv preprint arXiv:2104.01148, 2021.   \n[82] K. He, X. Zhang, S. Ren, and J. Sun. Deep residual learning for image recognition. In Proceedings of the IEEE conference on computer vision and pattern recognition, pages 770– 778, 2016.   \n[83] S. Saito, Z. Huang, R. Natsume, S. Morishima, A. Kanazawa, and H. Li. Pifu: Pixel-aligned implicit function for high-resolution clothed human digitization. In Proceedings of the IEEE/CVF International Conference on Computer Vision, pages 2304–2314, 2019.   \n[84] R. Hadsell, S. Chopra, and Y. LeCun. Dimensionality reduction by learning an invariant mapping. In 2006 IEEE Computer Society Conference on Computer Vision and Pattern Recognition (CVPR’06), volume 2, pages 1735–1742. IEEE, 2006.   \n[85] A. Van den Oord, Y. Li, and O. Vinyals. Representation learning with contrastive predictive coding. arXiv e-prints, pages arXiv–1807, 2018.   \n[86] J. Schulman, F. Wolski, P. Dhariwal, A. Radford, and O. Klimov. Proximal policy optimization algorithms. arXiv preprint arXiv:1707.06347, 2017.   \n[87] D. Driess, J.-S. Ha, M. Toussaint, and R. Tedrake. Learning models as functionals of signeddistance fields for manipulation planning. In Conference on Robot Learning (CoRL), 2021.   \n[88] K. He, G. Gkioxari, P. Dollár, and R. Girshick. Mask r-cnn. In Proceedings of the IEEE international conference on computer vision, pages 2961–2969, 2017.   \n[89] A. Raffin, A. Hill, M. Ernestus, A. Gleave, A. Kanervisto, and N. Dormann. Stable baselines3. https://github.com/DLR-RM/stable-baselines3, 2019. ",
+        "bbox": [
+            179,
+            457,
+            826,
+            912
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            171,
+            75,
+            828,
+            920
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            171,
+            66,
+            828,
+            912
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            171,
+            61,
+            828,
+            920
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            171,
+            88,
+            828,
+            666
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "Checklist ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            89,
+            254,
+            106
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "1. For all authors... ",
+        "bbox": [
+            214,
+            116,
+            339,
+            130
+        ],
+        "page_idx": 14
+    },
+    {
+        "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,
+            135,
+            825,
+            227
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "2. If you are including theoretical results... ",
+        "bbox": [
+            214,
+            231,
+            493,
+            244
+        ],
+        "page_idx": 14
+    },
+    {
+        "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,
+            248,
+            738,
+            280
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "3. If you ran experiments... ",
+        "bbox": [
+            212,
+            285,
+            393,
+            299
+        ],
+        "page_idx": 14
+    },
+    {
+        "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] See website.   \n(b) Did you specify all the training details (e.g., data splits, hyperparameters, how they were chosen)? [Yes] See appendix.   \n(c) Did you report error bars (e.g., with respect to the random seed after running experiments multiple times)? [Yes] See plots in main paper.   \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] See appendix. ",
+        "bbox": [
+            238,
+            303,
+            826,
+            421
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "4. If you are using existing assets (e.g., code, data, models) or curating/releasing new assets... ",
+        "bbox": [
+            214,
+            426,
+            823,
+            440
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "(a) If your work uses existing assets, did you cite the creators? [Yes] In the paper and in the code.   \n(b) Did you mention the license of the assets? [Yes] In the code.   \n(c) Did you include any new assets either in the supplemental material or as a URL? [Yes] See website.   \n(d) Did you discuss whether and how consent was obtained from people whose data you’re using/curating? [Yes] In the code.   \n(e) Did you discuss whether the data you are using/curating contains personally identifiable information or offensive content? [N/A] ",
+        "bbox": [
+            238,
+            444,
+            825,
+            579
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "5. If you used crowdsourcing or conducted research with human subjects... ",
+        "bbox": [
+            214,
+            583,
+            705,
+            598
+        ],
+        "page_idx": 14
+    },
+    {
+        "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,
+            602,
+            825,
+            691
+        ],
+        "page_idx": 14
+    }
+]

parse/dev/QUyasQGv1Nl/QUyasQGv1Nl_content_list.json

@@ -0,0 +1,1181 @@
+[
+    {
+        "type": "text",
+        "text": "Hyperbolic Contrastive Learning for Visual Representations beyond Objects ",
+        "text_level": 1,
+        "bbox": [
+            261,
+            122,
+            732,
+            172
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Anonymous Author(s)   \nAffiliation   \nAddress   \nemail ",
+        "bbox": [
+            423,
+            226,
+            578,
+            281
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Abstract ",
+        "text_level": 1,
+        "bbox": [
+            462,
+            318,
+            535,
+            334
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 Despite the rapid progress in visual representation learning driven by self-/un  \n2 supervised methods, both objects and scenes have been primarily treated using the   \n3 same lens. In this paper, we focus on learning representations for objects and scenes   \n4 explicitly in the same space. Motivated by the observation that visually similar   \n5 objects are close in the representation space, we argue that the scenes and objects   \n6 should further follow a hierarchical structure based on their compositionality. To   \n7 exploit such a structure, we propose a contrastive learning framework where a   \n8 Euclidean loss is used to learn object representations and a hyperbolic loss is used to   \n9 regularize scene representations according to the hierarchy. This novel hyperbolic   \n10 objective encourages the scene-object hypernymy among the representations by   \n11 optimizing the magnitude of their norms. We show that when pretraining on   \n12 the COCO and OpenImages datasets, the hyperbolic loss improves downstream   \n13 performance across multiple datasets and tasks, including image classification,   \n14 object detection, and semantic segmentation. We also show that the properties of   \n15 the learned representations allow us to solve various vision tasks that involve the   \n16 interaction between scenes and objects in a zero-shot way. ",
+        "bbox": [
+            148,
+            349,
+            766,
+            570
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "17 1 Introduction ",
+        "text_level": 1,
+        "bbox": [
+            148,
+            598,
+            310,
+            616
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "18 Our visual world is diverse and structured. Imagine taking a close-up of a box of cereal in the morning.   \n19 If we zoom out slightly, we may see different nearby objects such as a bowl of milk, a cup of hot   \n20 coffee, today’s newspaper, or reading glasses. Zooming out further, we will probably recognize that   \n21 these items are placed on a dining table with the kitchen as background rather than inside a bathroom.   \n22 Such scene-object structure is diverse, yet not completely random. In this paper, we aim at learning   \n23 visual representations of both the cereal box (objects) and the entire dining table (scenes) in the same   \n24 space while preserving such hierarchical structures.   \n25 Un-/self-supervised learning has become a standard method to learn visual representations [27, 12,   \n26 25, 13, 6, 7, 49]. Although these methods attain superior performance over the supervised pretraining   \n27 on object-centric datasets such as ImageNet [25, 6], inferior results are observed on images depicting   \n28 multiple objects such as OpenImages or COCO [67]. Several methods have been proposed to mitigate   \n29 this issue [67, 68, 37, 1], but all focus on learning improved object representations or dense pixel   \n30 representations, instead of explicitly modeling the representations for scene images. The object   \n31 representations learned by these methods present a natural topology [66]. That is, the objects from   \n32 visually similar classes lie close to each other in the representation space. However, it is not clear   \n33 how the representations of scene images should fit into that topology. Naively applying existing   \n34 contrastive learning results in sub-optimal topology of scenes and objects as well as unsatisfactory   \n35 performance as we will show in the experiment. To this end, we argue that a hierarchical structure   \n36 can be naturally adopted. Considering scenes as the composition of different kinds of objects, we   \n37 can construct a forest structure to describe such relationships, where the root nodes are the visually   \n38 similar objects, and the scene images consisting of them are placed as the descendants. We call this   \n39 structure the object-centric scene hierarchy.   \n40 The intermediate modeling difficulty induced by   \n41 this structure is the combinatorial explosion. A   \n42 finite number of objects can lead to exponentially   \n43 many kinds of scenes due to the composition. Hy  \n44 perbolic space is known for its provably better   \n45 capacity in modeling infinite trees compared with   \n46 Euclidean space [21, 26, 34]. Therefore, we pro  \n47 pose to employ a hyperbolic objective to regularize   \n48 the scene representations. Our framework builds   \n49 upon MoCo [27], which has been shown to learn   \n50 good object representations. To learn representa  \n51 tions of scenes, we sample the co-occurring scene  \n52 object pairs as the positive pairs, and objects that   \n53 are not part of that scene as the negative samples,   \n54 and use these pairs to compute an auxiliary hyper  \n55 bolic contrastive objective. Our model is trained   \n56 to reduce the distance between positive pairs and   \n57 push away the negative pairs in a hyperbolic space.   \n58 Contrastive learning models generally compute   \n59 their objectives on a hypersphere [27, 12]. By   \n60 discarding the norm information, these models   \n61 effectively circumvent the shortcut of minimizing   \n62 objectives by tuning the norms and obtain better   \n63 downstream performance. At the same time, they also lose control of the representative power in the   \n64 magnitude of the norm and leave the images disorganized. However, in hyperbolic space, it is the   \n65 magnitude of the norm that is used to model the hypernymy of the hierarchical structure [43, 58, 51].   \n66 When projecting the representations to the hyperbolic space, the norm information is preserved and   \n67 used to determine the Riemannian distance, which eventually affects our loss. Since the hyperbolic   \n68 space is diffeomorphic and conformal to the Euclidean, our hyperbolic contrastive loss is completely   \n69 differentiable and complementary to the original contrastive objective.   \n70 When training simultaneously with the original contrastive objective for objects and our proposed   \n71 hyperbolic contrastive objective for scenes, the resulting representation space exhibits the desired   \n72 hierarchical structure while keeping the object clustering topology intact as shown in Figure 1. We   \n73 demonstrate the effectiveness of the learned representations on several downstream tasks, from image   \n74 classification to object detection. We also show that the properties possessed by the representations   \n75 allow us to perform various vision tasks in a zero-shot way, from label uncertainty quantification to   \n76 out-of-context object detection. Our contributions are summarized below: ",
+        "bbox": [
+            147,
+            631,
+            825,
+            727
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            147,
+            734,
+            825,
+            900
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            145,
+            92,
+            828,
+            133
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            145,
+            138,
+            498,
+            388
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            145,
+            395,
+            496,
+            463
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "image",
+        "img_path": "images/96870909088416fd93a5e67bc7b1906249d2485857d3c54b0673ef7e69092e29.jpg",
+        "image_caption": [
+            "Figure 1: Illustration of the representation space learned by our models. Object images of the same class tend to gather near the center around similar directions, while the scene images are far away in these directions with larger norms. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            514,
+            138,
+            823,
+            380
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            145,
+            463,
+            826,
+            560
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            145,
+            566,
+            825,
+            665
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "1. We propose to learn representations for both object and scene images simultaneously using un-/self-supervised methods. We identify an object-centeric scene hierarchy that the representations are expected to follow. 2. We propose a framework with a novel hyperbolic contrastive loss to regularize the scene representations with positive and negative pairs sampled from the hierarchy. 3. We show that the magnitude of representation norms effectively reflect the scene-objective hypernymy, and such representations transfer better to multiple downstream tasks. ",
+        "bbox": [
+            196,
+            684,
+            825,
+            814
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "84 2 Method ",
+        "text_level": 1,
+        "bbox": [
+            147,
+            844,
+            271,
+            861
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "85 In this section, we elaborate our approach to learn visual representations of object and scene images.   \n86 We start with describing the hierarchical structure between objects and scenes.   \n88 From simple object co-occurrence statistics [20, 39] to finer object relationships [29, 31], using   \n89 hierarchical relationships between objects and scenes to understand images is not new. Previous   \n90 studies primarily work on an instance-level hierarchy by dividing an image into its lower-level   \n91 elements recursively - a scene contains multiple objects, an object has different parts, and each part   \n92 may consist of even lower-level features [47, 46, 15]. While this is intuitive, it describes a hierarchical   \n93 structure contained in the individual images. In our task, we would like to work on the structure from   \n94 the view of the entire dataset to learn a representation space shared by objects and scenes. To this   \n95 end, we argue that it is more natural to consider an object-centric hierarchy.   \n96 It is known that when training an image classifier, though not being optimized directly, the objects   \n97 from visually similar classes often lie close to each other in the representation space [66], which has   \n98 become the cornerstone of contrastive learning [27, 12]. Motivated by this observation, we believe   \n99 that the representation of each scene image should also be close to the object clusters it consists of.   \n100 However, they require a much larger volume due to the exponential number of possible compositions.   \n101 Another way to think about the object-centric hierarchy is through the generality and specificity as   \n102 often discussed in the language literature [40, 43]. An object concept is general when standing alone   \n103 in the visual world, and it will become specific when a certain context is given. For example, “a desk”   \n104 is thought to be a more general concept than “a desk in a classroom with a boy sitting on it”.   \n105 Therefore, we propose to study an object-centric hierarchy across the entire dataset. Formally,   \n106 given a set of images $\\boldsymbol { S } = \\{ \\bar { s } _ { 1 } , s _ { 2 } , \\cdots , s _ { n } \\}$ , $\\mathcal { O } _ { i } ~ = ~ \\{ o _ { i } ^ { 1 } , \\dot { o } _ { i } ^ { 2 } , \\cdot \\cdot \\cdot ~ , o _ { i } ^ { n _ { i } } \\}$ are the object bounding   \n107 boxes contained in the image $s _ { i }$ . We define the regions of scene $\\mathcal { R } _ { i } ^ { \\setminus } = \\{ r _ { i } ^ { 1 } , r _ { i } ^ { 2 } , \\cdots , r _ { i } ^ { m _ { i } } \\}$ rmi } to be   \n108 partial areas of the image $s _ { i }$ that contain multiple objects such that $r _ { i } ^ { j } ~ = ~ \\cup _ { k } o _ { i } ^ { k }$ , where $o _ { i } ^ { k } \\in$   \n109 $\\mathcal { O } _ { i }$ and object $k$ is in the region $j$ . We define the object-centric forest $T = ( V , E )$ to be that $V =$   \n110 $S \\cup \\mathcal { O } \\cup \\mathcal { R }$ , where $\\mathcal { R } = \\mathcal { R } _ { 1 } \\cup \\cdot \\cdot \\cdot \\cup \\mathcal { R } _ { n }$ and $\\mathcal { O } = \\mathcal { O } _ { 1 } \\cup \\cdots \\cup \\mathcal { O } _ { n }$ . For $u , v \\in V$ , $e = \\left( u , v \\right)$ is an edge   \n111 of $T$ if $u \\subseteq v$ or $v \\subseteq u$ . Note that the natural scene images $s$ are always put as the leaf nodes. ",
+        "bbox": [
+            150,
+            883,
+            826,
+            911
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            147,
+            117,
+            825,
+            228
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            142,
+            233,
+            826,
+            359
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            140,
+            364,
+            825,
+            465
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "112 2.2 Representation Learning beyond Objects ",
+        "text_level": 1,
+        "bbox": [
+            150,
+            483,
+            500,
+            498
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "113 To describe our proposed model that is built on this hierarchy, we begin with a brief review of   \n114 the hyperbolic space and its several properties that will be used in our model. For comprehensive   \n115 introductions to the Riemannian geometry and hyperbolic space, we refer the readers to [32, 17]. ",
+        "bbox": [
+            142,
+            508,
+            826,
+            551
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "2.2.1 Hyperbolic Space ",
+        "text_level": 1,
+        "bbox": [
+            169,
+            568,
+            348,
+            582
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "117 A hyperbolic space $( \\mathbb { H } ^ { m } , g )$ is a complete, connected Riemannian manifold with constant negative   \n118 sectional curvature. These special manifolds are all isometric to each other with the isometries   \n119 defined as $O ^ { + } ( m , 1 )$ . Among these isometries, there are five common models that previous studies   \n120 often work on [5]. In this paper, we choose the Poincaré ball $\\mathbb { D } ^ { n } : = \\left\\{ p \\in \\mathbb { R } ^ { n } \\mid \\| p \\| ^ { 2 } < r ^ { 2 } \\right\\}$ as our   \n121 basic model [43, 58, 22], where $r > 0$ is the radius of the ball. The Poincaré ball is coupled with   \n122 a Riemannian metric $\\begin{array} { r } { g _ { \\mathbb { D } } ( p ) = \\frac { 4 } { ( 1 - \\| p \\| ^ { 2 } / r ^ { 2 } ) ^ { 2 } } g _ { \\mathbb { E } } } \\end{array}$ , where $p \\in \\mathbb { D } ^ { n }$ and $g _ { \\mathbb { E } }$ is the canonical metric of the   \n123 Euclidean space. For $p , q \\in \\mathbb { D }$ , the Riemannian distance on the Poincaré ball induced by its metric $g _ { \\mathbb { D } }$   \n124 is defined as follows: ",
+        "bbox": [
+            140,
+            590,
+            825,
+            707
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/fe01db524ac0ebe29dcfed1166f392a825bf52a724104b1e7ab4dfcaa18feb5f.jpg",
+        "text": "$$\nd _ { \\mathbb { D } } ( p , q ) = 2 r \\operatorname { t a n h } ^ { - 1 } \\left( \\frac { \\lVert - p \\oplus q \\rVert } { r } \\right) ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            374,
+            704,
+            622,
+            739
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "125 where $\\oplus$ is the Möbius addition and it is clearly differentiable. In addition, the Poincaré ball can be   \n126 viewed as a natural counterpart of the hypersphere as it allows all directions, unlike the other models   \n127 such as the halfspace or hemisphere models that have constraints on the directions. The hyperbolic   \n128 space is globally differomorphic to the Euclidean space, which is stated in the theorem below:   \n29 Theorem 1. (Cartan–Hadamard). For every point $p \\in \\mathbb { H } ^ { n }$ the exponential map $\\exp _ { p } : T _ { p } \\mathbb { H } ^ { n } \\approx$   \n30 $\\mathbb { R } ^ { n } \\to \\mathbb { H } ^ { n }$ is a smooth covering map. Since $\\mathbb { H } ^ { n }$ is simply connected, it is diffeomorphic to $\\mathbb { R } ^ { n }$ . ",
+        "bbox": [
+            140,
+            742,
+            825,
+            799
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            151,
+            804,
+            823,
+            833
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Specifically, for 131 $p \\in \\mathbb { D } ^ { n }$ and $v \\in T _ { p } \\mathbb { D } ^ { n } \\approx \\mathbb { R } ^ { n }$ , the exponential map of the Poincaré ball $\\exp _ { p }$ : 132 $T _ { p } { \\mathbb { D } } ^ { n } \\to { \\mathbb { D } } ^ { n }$ is defined as ",
+        "bbox": [
+            142,
+            843,
+            826,
+            872
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/86bb3f8b883b33803a21ecb710b19e8825f63a217bebfde36694eaa183bc2664.jpg",
+        "text": "$$\n\\exp _ { p } ( v ) : = p \\oplus \\left( \\operatorname { t a n h } \\left( { \\frac { r \\| v \\| } { r ^ { 2 } - \\| p \\| ^ { 2 } } } \\right) { \\frac { r v } { \\| v \\| } } \\right) ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            346,
+            881,
+            650,
+            916
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "image",
+        "img_path": "images/5e015b8327887fcbc10904e8cf2df0d7d26edd85e0c52e41b97edbfcc0c12579.jpg",
+        "image_caption": [
+            "Figure 2: Our Hyperbolic Contrastive Learning (HCL) framework has two branches: given a scene image, two object regions are cropped to learn the object representations with a loss defined in the Euclidean space focusing on the representation directions. A scene region as well as a contained object region are used to learn the scene representations with a loss defined in the hyperbolic space that affects the representation norms. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            205,
+            93,
+            790,
+            277
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "133 The exponential map gives us a way to map the output of a network, which is in the Euclidean space,   \n134 to the Poincaré ball. In practice, to avoid numerical issues, we clip the maximal norm of $v$ with $r - \\varepsilon$   \n135 before the projection, where $\\varepsilon > 0$ . During the backpropagation, we perform RSGD [4] by scaling   \n136 the gradients with $g _ { \\mathbb { D } } ( p ) ^ { - 1 }$ . Intuitively, this forces the optimizer to take a smaller step when $p$ is   \n137 closer to the boundary. The scaling factor is lower bounded by $\\mathcal { O } ( \\varepsilon ^ { 2 } )$ .   \n138 The immediate consequence of the negative curvature is that for any point $\\pmb { p } \\in \\mathbb { H } ^ { m }$ , there are no   \n139 conjugate points along any geodesic starting from $\\pmb { p }$ . Therefore, the volume grows exponentially   \n140 faster in hyperbolic space than in Euclidean space. Such a property makes it suitable to embed the   \n141 hierarchical structure that has constant branching factors and exponential number of nodes. This is   \n142 formally stated in the theorem below: ",
+        "bbox": [
+            140,
+            386,
+            825,
+            457
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            142,
+            462,
+            825,
+            531
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Theorem 2. [21, 26] Given a Poincaré ball $\\mathbb { D } ^ { n }$ with an arbitrary dimension $n \\geq 2$ and any set of points $p _ { 1 } , \\cdot \\cdot \\cdot , p _ { m } \\in \\mathbb { D } ^ { n }$ , there exists a finite weighted tree $( T , d _ { T } )$ and an embedding $f : T \\to { \\mathbb { D } } ^ { n }$ such that for all $i , j ,$ ",
+        "bbox": [
+            171,
+            535,
+            825,
+            578
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/defdcd08a709899d61a3b521bdc44943d8976e9b313bed97c692c4098baaafa5.jpg",
+        "text": "$$\n\\left| d _ { T } \\left( f ^ { - 1 } \\left( x _ { i } \\right) , f ^ { - 1 } \\left( x _ { j } \\right) \\right) - d _ { \\mathbb { D } } \\left( x _ { i } , x _ { j } \\right) \\right| = \\mathcal { O } ( \\log ( 1 + \\sqrt { 2 } ) \\log ( m ) )\n$$",
+        "text_format": "latex",
+        "bbox": [
+            274,
+            583,
+            722,
+            603
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "143 Intuitively, the theorem states that any tree can be embedded into a Poincaré disk ${ \\it n } = 2$ ) with   \n144 low distortion. On the contrary, it is known that the Euclidean space with unbounded number of   \n145 dimensions is not able to achieve such a low distortion [34]. One useful intuition [51] to help   \n146 understand the advantage of the hyperbolic space is given two points $p , q \\in \\mathbb { D } ^ { n }$ s.t. $\\| p \\| = \\| q \\|$ , ",
+        "bbox": [
+            140,
+            613,
+            825,
+            670
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/b9d6454139291ef736453104cd1d90f7e6bc78a6ca6afa5b352a1d9222b6896a.jpg",
+        "text": "$$\n\\begin{array} { r } { d _ { \\mathbb { D } } ( p , q ) \\to d _ { \\mathbb { D } } ( p , 0 ) + d _ { \\mathbb { D } } ( 0 , q ) , ~ \\mathrm { a s } ~ \\| p \\| = \\| q \\| \\to r } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            326,
+            674,
+            671,
+            693
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "This property basically reflects the fact that the shortest path in a tree is the path through the earliest common ancestor, and it is reproduced in the Poincaré when points are both close to the boundary. ",
+        "bbox": [
+            161,
+            696,
+            826,
+            726
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "2.2.2 Hyperbolic Contrastive Learning ",
+        "text_level": 1,
+        "bbox": [
+            166,
+            738,
+            457,
+            755
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "150 With the theoretical benefits of the hyperbolic space stated above, we propose a contrastive learning   \n151 framework as shown in Figure 2. We adopt two losses to learn the object and scene representations.   \n152 First, as shown in the top branch of Figure 2, we crop two views of a jittered and slightly expanded   \n153 object region as the positive pairs and feed into the base and momentum encoders to calculate the   \n154 object representations. We denote the output after the normalization to be $\\mathbf { z } _ { \\mathrm { e u c } } ^ { 1 }$ and $\\mathbf { z } _ { \\mathrm { e u c } } ^ { 2 }$ . Considering   \n155 the computational cost of large batch sizes, we follow MoCo [27, 14] to leverage a memory bank to   \n156 store the negative representations $z _ { \\mathrm { e u c } } ^ { n }$ which are the features $\\mathbf { z } _ { \\mathrm { e u c } } ^ { 2 }$ from the previous batches. The   \n157 Euclidean loss for this image is then calculated as: ",
+        "bbox": [
+            140,
+            762,
+            826,
+            875
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/c0a7a4f8d9f1496099bc0c9ebe189ba651ce236e8cd38de2be7bada602e7c9be.jpg",
+        "text": "$$\n\\mathcal { L } _ { \\mathrm { e u c } } = - \\log \\frac { \\exp \\left( { \\bf z } _ { \\mathrm { e u c } } ^ { 1 } \\cdot { \\bf z } _ { \\mathrm { e u c } } ^ { 2 } / \\tau \\right) } { \\exp \\left( { \\bf z } _ { \\mathrm { e u c } } ^ { 1 } \\cdot { \\bf z } _ { \\mathrm { e u c } } ^ { 2 } / \\tau \\right) + \\sum _ { n } \\exp \\left( { \\bf z } _ { \\mathrm { e u c } } ^ { 1 } \\cdot { \\bf z } _ { \\mathrm { e u c } } ^ { n } / \\tau \\right) } ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            303,
+            878,
+            691,
+            916
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "158 where $\\tau$ is a temperature parameter. ",
+        "bbox": [
+            147,
+            92,
+            408,
+            106
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "159 While this loss aims at learning object representations, we also design a hyperbolic contrastive   \n160 objective to learn the representations for scene images. We sample the positive region pairs $u$ and $v$   \n161 from object-centric scene hierarchy $T$ such that $( u , \\bar { v } ) \\in E$ . In other words, as shown in the bottom   \n162 branch of Figure 2, the objects contained in one region are required to be a subset of the objects in   \n163 the other. We sample the negative samples of $u$ to be $\\mathcal { N } _ { u } = \\{ v \\bar { | } ( u , v ) \\notin E \\}$ . However, building and   \n164 sampling from the entire hierarchy explicitly is slow and memory consuming. Instead, according to   \n165 the assumption that there are exponentially more scenes than object classes in practice, given a scene   \n166 image $s$ , we always sample $u \\in { \\mathcal { R } } \\cup \\{ s \\}$ to be a scene region, $v \\in \\mathcal { O }$ to be an object that occurs in $u$   \n167 and $\\mathcal { N } _ { u }$ to be the other objects that are not in $u$ .   \n168 The pair of scene and object images are fed into the base and momentum encoders that share the   \n169 weights with the Euclidean branch. However, instead of normalizing the output of the encoders, we   \n170 use the exponential map defined in the equation (2) to project these features in the Euclidean space to   \n171 the Poincaré ball, which are denoted as $\\mathbf { \\dot { z } } _ { \\mathrm { h y p } } ^ { 1 }$ and $\\mathbf { z } _ { \\mathrm { h y p } } ^ { 2 }$ . Further, we replace the inner product in the   \n172 cross-entropy loss with the negative hyperbolic distance as defined in equation (1). We calculate the   \n173 hyperbolic contrastive loss as follows: ",
+        "bbox": [
+            140,
+            111,
+            825,
+            237
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            140,
+            242,
+            825,
+            328
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/14dc3418819319c1a77dfb0677d6061cad8cd7dfe425e3797cfd5200f8455ecc.jpg",
+        "text": "$$\n\\mathcal { L } _ { \\mathrm { h y p } } = - \\log \\frac { \\exp \\left( - d _ { \\mathbb { D } } ( \\mathbf { z } _ { \\mathrm { h y p } } ^ { 1 } , \\mathbf { z } _ { \\mathrm { h y p } } ^ { 2 } ) / \\tau \\right) } { \\exp \\left( - d _ { \\mathbb { D } } ( \\mathbf { z } _ { \\mathrm { h y p } } ^ { 1 } , \\mathbf { z } _ { \\mathrm { h y p } } ^ { 2 } ) / \\tau \\right) + \\sum _ { n } \\exp \\left( - d _ { \\mathbb { D } } ( \\mathbf { z } _ { \\mathrm { h y p } } ^ { 1 } , \\mathbf { z } _ { \\mathrm { h y p } } ^ { n } ) / \\tau \\right) } ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            254,
+            342,
+            740,
+            396
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "174 When minimizing the distances of all the positive pairs, With the intuition from Equation (3), it would   \n175 be beneficial to put the nodes near the root close to the center to achieve a overall lower loss. The   \n176 overall loss function of our model is as follows: ",
+        "bbox": [
+            142,
+            409,
+            823,
+            452
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/77029866282f7d17e3ae5d50393ea282f95c52a0d1ae37563dfe3a89934518f7.jpg",
+        "text": "$$\n\\begin{array} { r } { \\mathcal { L } = \\mathcal { L } _ { \\mathrm { e u c } } + \\lambda \\mathcal { L } _ { \\mathrm { h y p } } , } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            434,
+            467,
+            562,
+            484
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "177 where $\\lambda$ is an scaling parameter to control the trade-off between hyperbolic and Euclidean losses. ",
+        "bbox": [
+            140,
+            498,
+            808,
+            513
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "3 Experiments ",
+        "text_level": 1,
+        "bbox": [
+            166,
+            541,
+            312,
+            559
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "3.1 Implementation Details ",
+        "text_level": 1,
+        "bbox": [
+            169,
+            578,
+            375,
+            593
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "180 Pre-training phase. We pre-train our method on two datasets: COCO [33] and a subset of Open  \n181 Images [41]. Both of these datasets are multi-object datasets; OpenImages [41] ( $\\mathrm { \\sim 2 1 2 k }$ images)   \n182 contains 12 objects on average per image and COCO $( \\sim 1 1 8 \\mathbf { k } )$ contains 6 objects on average. We   \n183 experiment with both the ground truth bounding box (GT) and using selective search [60] following   \n184 the previous method [67] (SS) to acquire objects. For the optimizer setups and augmentation recipes,   \n185 we follow the standard protocol described in MoCo-v2 [14] unless denoted otherwise. We find that a   \n186 base learning rate of 0.3 works better for us as compared to 0.03. We adopt the linear learning rate   \n187 scaling receipt that $l r = 0 . 3 \\times \\mathrm { B a t c h S i z e / 2 5 6 }$ [24] and batch size of 128 by default on 4 NVIDIA   \n188 p6000 gpus. To ensure fair comparison, we also pre-train the baselines with a learning rate of 0.3.   \n189 We train our models on both datasets for 200 epochs. For the hyperparameters of our hyperbolic   \n190 objective, we use $r = 4 . 5$ , $\\lambda = 0 . 1$ , and $\\varepsilon = 1 e ^ { - 5 }$ . More details on the OpenImages dataset as well   \n191 as training setups can be found in Appendix A.   \n192 Downstream tasks. We evaluate our pre-trained models on image classification, object-detection   \n193 and semantic segmentation. For classification, we show linear evaluation (lineval) accuracy, i.e we   \n194 freeze the backbone and only train the final fc layer. We test on VOC [19], ImageNet-100 [57] and   \n195 ImageNet-1k [16] datasets. To test the discriminative capacity of the representations on both objects   \n196 and scenes, we create a dataset by mixing the ImageNet-100 and a subset of Place-205 [70] datasets,   \n197 which we refer to as the INPMix dataset. More details of this dataset can be found in Appendix A.   \n198 For object detection and semantic segmentation, we show results on the COCO and Pascal VOC   \n199 trainval2017 datasets. For VOC object detection, COCO object detection and COCO semantic   \n200 segmentation, we closely follow the common protocols listed in Detectron2 [65]. ",
+        "bbox": [
+            147,
+            611,
+            825,
+            777
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            140,
+            786,
+            825,
+            911
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "table",
+        "img_path": "images/c0161a67e6646c412ba66daa2f15eb3d5c0120056cc832116ed3d1638ff55ed9.jpg",
+        "table_caption": [
+            "Table 1: Classification results with linear evaluation. Our model improves scene-level classification on the VOC [19] and INPMix [70] datasets, and object-level classification on ImageNet-100 [57] and ImageNet-1k [16] datasets. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td></td><td>Pre-train dataset</td><td>Bbox type</td><td>vOC</td><td>IN-100</td><td>INPMix ]</td><td>IN-1k</td></tr><tr><td rowspan=\"3\">MoCo-v2 HCL/Lhyp HCL/Lhyp</td><td>COCO</td><td>1</td><td>64.79</td><td>64.84</td><td>41.83</td><td>51.17</td></tr><tr><td>COCO</td><td>SS</td><td>73.13</td><td>73.84</td><td>51.28</td><td>54.21</td></tr><tr><td>COCO</td><td>GT</td><td>75.55</td><td>76.22</td><td>51.25</td><td>54.52</td></tr><tr><td>HCL HCL</td><td>COCO CoCo</td><td>SS GT</td><td>74.19 76.51</td><td>75.16 76.74</td><td>51.35 51.63</td><td>55.03 55.63</td></tr><tr><td>MoCo-v2 HCL/Lhyp</td><td>OpenImages OpenImages</td><td>1 GT</td><td>69.95 73.79</td><td>72.80 77.36</td><td>49.59 52.96</td><td>54.12 57.57</td></tr><tr><td>HCL HCL</td><td>OpenImages OpenImages</td><td>Ss GT</td><td>74.31 75.40</td><td>78.14 79.08</td><td>53.21 53.82</td><td>58.12 58.51</td></tr></table>",
+        "bbox": [
+            168,
+            94,
+            563,
+            256
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "table",
+        "img_path": "images/082201d0df7ad19659e8e8d323b9168c24f17214435aff37b8289ba0aec26493.jpg",
+        "table_caption": [
+            "Table 2: Object detection and Semantic Segmentation results. Our model improves on both tasks on COCO [33] and VOC [19] datasets. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Detection</td><td>Dataset</td><td>AP AP50</td><td>AP75</td></tr><tr><td>MoCo-v2 HCL/Lhyp</td><td>COCO COCO</td><td>34.6 53.5 36.1 55.2</td><td>37.0 37.9</td></tr><tr><td>HCL</td><td>COCO</td><td>37.0 56.1</td><td>39.8</td></tr><tr><td>MoCo-v2 HCL - Lhyp</td><td>VOC VOC</td><td>51.5 79.4 53.7 80.5</td><td>56.1 59.4</td></tr><tr><td>HCL</td><td>VOC</td><td>54.4 81.4</td><td>60.2</td></tr><tr><td>Segmentation</td><td>Dataset</td><td>APs AP1</td><td>APm</td></tr><tr><td>MoCo-v2</td><td>COCO</td><td>30.4 50.1</td><td>32.3</td></tr><tr><td>HCL/Lhyp HCL</td><td>COCO COCO</td><td>31.5 52.0 32.5 52.9</td><td>33.8 34.6</td></tr></table>",
+        "bbox": [
+            580,
+            88,
+            841,
+            255
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "201 3.2 Main Results ",
+        "text_level": 1,
+        "bbox": [
+            142,
+            334,
+            305,
+            349
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "This section discusses our main results on the downstream image classification, object detection, and semantic segmentation tasks. As the goal of this paper is not to present another state-of-the-art self-supervised learning method, we primarily compare with the backbone model MoCo-v2 [27]. Another important baseline we consider is our model without the hyperbolic loss $\\mathcal { L } _ { \\mathrm { h y p } }$ ; therefore only the object representations are learned, which we denote as $\\mathrm { H C L } / \\mathcal { L } _ { \\mathrm { h y p } }$ . ",
+        "bbox": [
+            171,
+            359,
+            825,
+            430
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Image classification. As shown in Table 1, HCL improves image classification on both scene-level datasets (VOC and INPMix) and object-level datasets (ImageNet). When pretraining on OpenImages, HCL improves ImageNet lineval accuracy by $0 . 9 4 \\%$ and VOC lineval classification accuracy by 1.61 mAP. We observe similar improvements when pretraining on COCO. HCL improves accuracy whether we use ground truth object bounding boxes or boxes generated by selective search. In general, we observe a larger improvement of using HCL on OpenImages than COCO, which supports our observation that HCL would improve more on the dataset with more objects per images. ",
+        "bbox": [
+            173,
+            439,
+            825,
+            536
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Object detection and semantic segmentation. Table 2 reports the object detection and semantic segmentation results using Mask R-CNN, following [14]. It shows consistent improvements over the baselines on VOC object detection, COCO object detection, and COCO semantic segmentation. ",
+        "bbox": [
+            174,
+            546,
+            825,
+            588
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "3.3 Properties of Models Trained with HCL ",
+        "text_level": 1,
+        "bbox": [
+            166,
+            604,
+            490,
+            619
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "The visual representations learned by HCL have several useful properties. In this section, we evaluate the representation norm as an measure of the label uncertainty for image classification datasets, and evaluate the object-scene similarity in terms of out-of-context detection. ",
+        "bbox": [
+            174,
+            628,
+            823,
+            671
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "221 3.3.1 Label Uncertainty Quantification ",
+        "text_level": 1,
+        "bbox": [
+            147,
+            686,
+            457,
+            700
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "image",
+        "img_path": "images/29174cdbb819ae786f1da3fe1072ee6de44b437a9f463e2c5d430cda7ea3300c.jpg",
+        "image_caption": [
+            "Figure 4: Average representation norms of images with different number of labels in ImageNet-ReaL [3]. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            191,
+            709,
+            408,
+            820
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "table",
+        "img_path": "images/723e04c480a537ef67883af0d99139b924fc042c3629524c1f640a80d47d074d.jpg",
+        "table_caption": [
+            "Table 3: NDCG scores of the image rankings based on the different indicators and models, and evaluated by the the number of labels per image. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Method</td><td>Indicator</td><td>Datasets IN-Real</td><td>COCO</td></tr><tr><td>MoCo</td><td>Entropy</td><td>0.633</td><td>0.791</td></tr><tr><td>Supervised</td><td>Entropy</td><td>0.671</td><td>0.793</td></tr><tr><td>HCL</td><td>Norm</td><td>0.655</td><td>0.839</td></tr><tr><td>Ensemble</td><td>Entropy+Norm</td><td>0.717</td><td>0.823</td></tr></table>",
+        "bbox": [
+            455,
+            715,
+            808,
+            814
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "222 ImageNet [16] is an image classification dataset consisting of object-centered images, each of which   \n223 has a single label. As the performance on this dataset gradually saturated, the original labels have   \n224 been scrutinized more carefully [50, 59, 54, 3, 61]. Prevailing labeling issues in the validation set   \n225 have been recently identified [59, 54, 3], including labeling errors, multi-label images with only a   \n226 single label provided, and so on. Although Beyer et al. [3] provide reassessed labels for the entire   \n227 validation set, relabeling the entire training set can be infeasible. ",
+        "bbox": [
+            142,
+            869,
+            825,
+            911
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "image",
+        "img_path": "images/c8fe2b0a28d33e4b9a02fa4316d901a44e6461421c75f8b18f1ae24dd60ea2a5.jpg",
+        "image_caption": [
+            "Figure 3: Images from ImageNet training set. The 5 images on the left have the smallest representation norms among all the images from the same class, and the 5 on the right have the largest norms. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            174,
+            92,
+            821,
+            320
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            143,
+            388,
+            825,
+            431
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Our learned representations provide a potential automatic way to identify images with multiple labels from datasets like ImageNet. Specifically, we first show in Figure 4 that there is a strong correlation between the representation norms and the number of labels per image according to the reassessed labels. For each class of the ImageNet training set, we rank the images according to their norms. The extreme images of some classes are shown in Figure 3 and also Appendix. Images with smaller norms tend to capture a single object, while those with larger norms are likely to depict a scene. ",
+        "bbox": [
+            166,
+            438,
+            825,
+            521
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "To quantitatively evaluate this property, we report the NDCG metric on the ranked images as shown in Table 3. NDCG assesses how often the scene images are ranked at the top. As a baseline, we rank the images based on the entropy of the class probability predicted by a classifier, which is a widely adopted label uncertainty indicator [11, 45]. We use both MoCo-v2 and supervised ResNet-50 as the classifier. As shown in Table 3, using norms with HCL achieves similar rank quality as using entropy with the supervised ResNet-50 on the ImageNet-ReaL dataset. In addition, when combining two ranks using simple ensemble methods such as Borda count, the score is further improved to 0.717. This shows that the entropy and the norm might look at different aspects of the multi-label issue. For example, the entropy indicator can be affected by the bias of the model and the norm indicator can be wrong on the images with multiple objects from the same class. In addition, our method is dataset agnostic and does not need further training. To demonstrate this benefit, we report the same metric on the COCO validation, where we also have the number of labels for each image. Our method achieves much better NDCG scores than the supervised ResNet-50 as shown in Table 3. This finding can be potentially useful to guide label reassessment, or provide an extra signal for model training. ",
+        "bbox": [
+            163,
+            526,
+            825,
+            720
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "3.3.2 Out-of-Context Detection ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            736,
+            401,
+            750
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Our hyperbolic loss $\\mathcal { L } _ { \\mathrm { h y p } }$ essentially encourages the model to capture the similarity between the object and scene. We further investigate this property on detecting the out-of-context objects, which can be useful in designing data augmentation for object detection [18]. We are especially interested in the out-of-context images with conflicting backgrounds. To this end, we use the out-of-context images proposed in the SUN09 dataset [15]. We first compute the representation of each object as well as the entire scene image with that object masked out. We then calculate the hyperbolic distance between the representations mapped to the Poincaré ball. Some example images from this dataset as well as the distance of each contained object are shown in Figure 5. We find that the out-of-context objects generally have a large distance, i.e. smaller similarity, to the overall scene image. To quantify this finding, we compute the mAP of the object ranking on each image and obtain 0.61 for HCL. As a comparison, the MoCo similarity gives mAP $= 0 . 5 2$ and the random ranking gives $\\mathrm { m A P } = 0 . 4 4$ . ",
+        "bbox": [
+            173,
+            758,
+            825,
+            911
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/f42028b92989bbbf8c805aef7506a778e82534c6ac63f498867e4359a09a5ddc.jpg",
+        "image_caption": [
+            "Figure 5: Out-of-context images from the SUN09 dataset [15]. The bounding box of each object, as well as its hyperbolic distance to the scene are displayed. The regular objects are in blue and the out-of-context objects are in purple. Note that the out-of-context objects tend to have large distances. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            178,
+            90,
+            820,
+            208
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "260 4 Main Ablation Studies ",
+        "text_level": 1,
+        "bbox": [
+            142,
+            290,
+            393,
+            308
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "261 In this section, we report the results of several important ablation studies with respect to HCL.   \n262 All the models are trained on the subset of the OpenImages dataset and linearly evaluated on the   \n263 ImageNet-100 and our INPMix datasets. The top-1 accuracy is reported. ",
+        "bbox": [
+            142,
+            323,
+            825,
+            366
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "table",
+        "img_path": "images/95ee2786ad8e5e55958e9a6cff9c720d2d0164cba5617191c0060414367a9adb.jpg",
+        "table_caption": [],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Optim. 入</td><td>IN-100</td><td>IPS</td></tr><tr><td>RSGD 0.1</td><td>79.08</td><td>53.82</td></tr><tr><td>RSGD 0.5</td><td>0</td><td>0</td></tr><tr><td>SGD 0.1</td><td>70.16</td><td>48.47</td></tr><tr><td>SGD 0.5</td><td>74.18</td><td>42.75</td></tr></table>",
+        "bbox": [
+            598,
+            376,
+            816,
+            455
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "table",
+        "img_path": "images/3e6289324561c549c6068e06f5bac767748f177c21e2968d250a1a1fe840c6da.jpg",
+        "table_caption": [
+            "Table 4: Ablation on the similarity measure and hierarchy center. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Dist.</td><td>Center</td><td>IN-100</td><td>IPS</td></tr><tr><td>1</td><td>-</td><td>77.36</td><td>52.96</td></tr><tr><td>Hyp.</td><td>Scene</td><td>79.08</td><td>53.82</td></tr><tr><td>Hyp.</td><td>Object</td><td>76.96</td><td>52.74</td></tr><tr><td>Euc.</td><td>Scene</td><td>76.68</td><td>52.58</td></tr></table>",
+        "bbox": [
+            176,
+            376,
+            405,
+            455
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "table",
+        "img_path": "images/4f9aa5e8a95390259344d32ce224546d4adcc1b7ab4c5b4b3b8a47e9349864ff.jpg",
+        "table_caption": [
+            "Table 5: Ablation on the losses trade-off. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>入</td><td>IN-100</td><td>IPS</td></tr><tr><td>0.01</td><td>77.70</td><td>53.43</td></tr><tr><td>0.1</td><td>79.08</td><td>53.82</td></tr><tr><td>0.2 0.5</td><td>78.64 0</td><td>53.84 0</td></tr></table>",
+        "bbox": [
+            418,
+            376,
+            583,
+            454
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Table 6: Ablation on the RSGD versus SGD optimizers. ",
+        "bbox": [
+            596,
+            462,
+            825,
+            489
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Similarity measure and the center of the scene-object hierarchy. We propose to use the negative hyperbolic distance as the similarity measure of the scene-object pairs. As an alternative, one can use cosine similarity on the hypersphere as the measure just like the original contrastive objective. However, this is basically minimizing the similarity between a single object and multiple objects. These objects are probably from different classes and hence conflict with the original objective. As shown in Table 4, replacing the negative hyperbolic distance with the Euclidean similarity impairs downstream performance. The resulting accuracy is even worse than the model without any loss function on the scene-object pairs. In terms of the hierarchy, we also test the assumption of scenecentric hierarchy [46, 47] by sampling the negative pairs as the objects and unpaired scenes. However, we notice a significant decrease in the downstream accuracy with this modification in Table 4. ",
+        "bbox": [
+            171,
+            494,
+            825,
+            632
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Trade-off between the Euclidean and hyperbolic losses. We adopt the Euclidean loss to learn object-object similarity and the hyperbolic loss to learn object-scene similarity. A hyperparameter $\\lambda$ is used to control the trade-off between them. As shown in Table 4, we find that a smaller $\\lambda = 0 . 0 1$ leads to marginal improvement. However, we also observe that larger λs can lead to unstable and even stalled training. With careful inspection, we find that in the early stage of the training, the gradient provided by the hyperbolic loss can be inaccurate but strong, which pushes the representations to be close to the boundary. As a result, the Riemannian SGD causes the gradient to be small and the training is consequently stuck at some the early point. ",
+        "bbox": [
+            171,
+            642,
+            825,
+            753
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Optimizer. With the observation above, we ask whether RSGD is still necessary for practical usage. We replace the RSGD optimizer with SGD. To avoid the numerical issue when the representations are too close to the boundary, we increase $\\varepsilon$ from $1 e ^ { - 5 }$ to $1 e ^ { - 1 }$ . We first notice that this allows larger $\\lambda$ to be used as opposed to the RSGD. However, SGD always yields inferior performance to RSGD. Therefore, it shows that the accurate gradient provided by RSGD is still necessary. ",
+        "bbox": [
+            169,
+            763,
+            825,
+            833
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "5 Related Work ",
+        "text_level": 1,
+        "bbox": [
+            171,
+            847,
+            321,
+            863
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "88 Representation Learning with Hyperbolic Space. Representations are typically learned in Eu  \n89 clidean space. Hyperbolic space has been adopted for its expressiveness in modeling tree-like   \n290 structures existing in various domains such as language [58, 21, 51, 43, 44], graphs [2, 8, 9, 48], and   \n291 vision [30, 10, 56]. The corresponding deep neural network modules have been designed to boost the   \n292 progress of such applications [9, 22, 35, 55]. The hierarchical structure presented in the datasets can   \n293 come from multiple factors, motivating the use of hyperbolic space. 1) Generality: the hypernym  \n294 hyponym property is a natural feature of words (e.g. WordNet [40]) and the hyperbolic space is   \n295 extensively exploited to learn word embeddings that preserve that property [58, 21, 51, 43, 44].   \n296 Some image datasets also adopt the classes from WordNet for labeling, e.g. ImageNet [16], and   \n297 consequently inherits the hierarchy in its labeling system. [36, 69, 38] take advantage of hyperbolic   \n298 space to capture such information in the visual embeddings. 2) Uncertainty: Several studies have   \n299 found that applying hyperbolic neural network modules to different tasks leads to a natural modeling   \n300 of the uncertainty [23, 30, 56]. 3) Compositionality: The compositionality of different basic elements   \n301 can form a natural hierarchy. We focus on learning the representations that capture the hierarchy   \n302 between the objects and scenes. The hierarchical representations learned in the hyperbolic space have   \n303 been applied to various tasks with the aforementioned motivations such as image classification [30]   \n304 or segmentation [64, 23], zero-/few-shot learning [38, 36], action recognition [38], and video pre  \n305 diction [56]. In this paper, we aim at learning image representations for general purposes that can   \n306 transfer to various downstream tasks. ",
+        "bbox": [
+            155,
+            883,
+            825,
+            911
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            138,
+            90,
+            825,
+            325
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Self-Supervised Learning on Scenes. Self-Supervised Learning (SSL) has made great strides in closing the performance with supervised methods [12, 14] when pretrained on the object-centric datasets like ImageNet. However, recent works have shown that SSL are limited on the multiobject datasets like COCO [52, 63] and OpenImages [41]. Several works have tried to address this issue by proposing different techniques. Dense-CL [63] works on pre-average pool features and uses dense features on pixel level to show improved performance on dense tasks such as semantic segmentation. DetCon [28] uses unsupervised semantic segmentation masks to generate features for the corresponding objects in the two views. CAST [53] uses GradCAM [52] to figure out same objects across views and applies contrastive loss on these features. PixContrast [68] uses pixel-to-propagation consistency pretext task to build features for both dense downstream tasks and discriminative downstream tasks. Pixel-to-Pixel Contrast [62] uses pixel-level contrastive learning to build better features for semantic segmentation. Self-EMD [37] uses earth mover distance with BYOL [25] for pretraining on the COCO dataset. ORL [67] uses selective search to generate object proposals, then applies object-level contrastive loss to enforce object-level consistency. ContraCAM [42] removes the scene bias issue by doing self-supervised object localization and performing contrastive loss on them. One of the reasons below-par performance of SSL methods can be attributed to treating scenes and objects using similar techniques, which often results in similar representations. In our work, instead of treating them in the same functionality, we use a hyperbolic loss, which builds representation that disambiguates scenes and objects based on the norm of the embeddings. Our method not only separates scenes and objects, but also helps us in improving downstream tasks such as image classification. ",
+        "bbox": [
+            158,
+            335,
+            825,
+            627
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "6 Closing Remarks ",
+        "text_level": 1,
+        "bbox": [
+            166,
+            645,
+            349,
+            662
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Conclusion We present HCL, a contrastive learning framework that learns visual representation for both objects and scenes in the same representation space. The major novelty of our method is a hyperbolic contrastive objective built on an object-centric scene hierarchy. We show the effectiveness of HCL on several benchmarks including image classification, object detection, and semantic segmentation. We also demonstrate the useful properties of the representations under several zero-shot settings from detecting out-of-context objects to quantifying the label uncertainty in the datasets like ImageNet. More generally, we hope this paper can encourage studies towards building a more holistic visual representation space and draw attention to the non-Euclidean representation learning. ",
+        "bbox": [
+            171,
+            679,
+            825,
+            790
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Limitations Our model is shown to improve the classification performance on the ImageNet dataset, but not much on the more fine-grained classification tasks as shown in Appendix B.2. We conjecture that the largest improvement brought by our model to the object representations are modeling the context information, while most of these datasets share a general class whose contexts are more or less similar. In addition, although we provide some insights about the Riemannian optimization, its underlying mechanism in the visual representation learning is still not fully understood. We conduct more experiments on training hyperbolic linear classifiers in Appendix C.1. However, more efforts are needed to fully unleash the potential of non-Euclidean representation learning. ",
+        "bbox": [
+            165,
+            800,
+            825,
+            911
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Our work is a technical contribution and much of societal impact depends upon the models used in our work. We hope that our work will be used for betterment of the society and doesn’t have any negative impact. ",
+        "bbox": [
+            171,
+            119,
+            825,
+            160
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "References ",
+        "text_level": 1,
+        "bbox": [
+            158,
+            178,
+            266,
+            193
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "350 [1] Y. Bai, X. Chen, A. Kirillov, A. Yuille, and A. C. Berg. Point-level region contrast for object detection   \n351 pre-training. CVPR, 2022.   \n352 [2] I. Balazevic, C. Allen, and T. Hospedales. Multi-relational poincaré graph embeddings. NeurIPS, 2019.   \n353 [3] L. Beyer, O. J. Hénaff, A. Kolesnikov, X. Zhai, and A. van den Oord. Are we done with imagenet?, 2020.   \n354 [4] S. Bonnabel. Stochastic gradient descent on riemannian manifolds. IEEE Transactions on Automatic   \n355 Control, 58(9):2217–2229, 2013.   \n356 [5] J. W. Cannon, W. J. Floyd, R. Kenyon, W. R. Parry, et al. Hyperbolic geometry. Flavors of geometry,   \n357 31(59-115):2, 1997.   \n358 [6] M. Caron, I. Misra, J. Mairal, P. Goyal, P. Bojanowski, and A. Joulin. Unsupervised learning of visual   \n359 features by contrasting cluster assignments. NeurIPS, 2020.   \n360 [7] M. Caron, H. Touvron, I. Misra, H. Jégou, J. Mairal, P. Bojanowski, and A. Joulin. Emerging properties in   \n361 self-supervised vision transformers. In ICCV, 2021.   \n362 [8] I. Chami, A. Wolf, D.-C. Juan, F. Sala, S. Ravi, and C. Ré. Low-dimensional hyperbolic knowledge graph   \n363 embeddings. In ACL, 2020.   \n364 [9] I. Chami, Z. Ying, C. Ré, and J. Leskovec. Hyperbolic graph convolutional neural networks. NeurIPS,   \n365 2019.   \n366 [10] J. Chen, J. Qin, Y. Shen, L. Liu, F. Zhu, and L. Shao. Learning attentive and hierarchical representations   \n367 for 3d shape recognition. In ECCV, 2020.   \n368 [11] P. Chen, B. B. Liao, G. Chen, and S. Zhang. Understanding and utilizing deep neural networks trained   \n369 with noisy labels. In ICML, 2019.   \n370 [12] T. Chen, S. Kornblith, M. Norouzi, and G. Hinton. A simple framework for contrastive learning of visual   \n371 representations. In ICML, 2020.   \n372 [13] T. Chen, S. Kornblith, K. Swersky, M. Norouzi, and G. E. Hinton. Big self-supervised models are strong   \n373 semi-supervised learners. NeurIPS, 2020.   \n374 [14] X. Chen, H. Fan, R. Girshick, and K. He. Improved baselines with momentum contrastive learning. arXiv   \n375 preprint arXiv:2003.04297, 2020.   \n376 [15] M. J. Choi, J. J. Lim, A. Torralba, and A. S. Willsky. Exploiting hierarchical context on a large database of   \n377 object categories. In CVPR, 2010.   \n378 [16] J. Deng, W. Dong, R. Socher, L.-J. Li, K. Li, and L. Fei-Fei. Imagenet: A large-scale hierarchical image   \n379 database. In CVPR, 2009.   \n380 [17] M. P. Do Carmo and J. Flaherty Francis. Riemannian geometry, volume 6. Springer, 1992.   \n381 [18] N. Dvornik, J. Mairal, and C. Schmid. On the importance of visual context for data augmentation in scene   \n382 understanding. PAMI, 43(6):2014–2028, 2019.   \n383 [19] M. Everingham, L. Van Gool, C. K. Williams, J. Winn, and A. Zisserman. The pascal visual object classes   \n384 (voc) challenge. IJCV, 88(2):303–338, 2010.   \n385 [20] C. Galleguillos, A. Rabinovich, and S. Belongie. Object categorization using co-occurrence, location and   \n386 appearance. In CVPR, 2008.   \n387 [21] O. Ganea, G. Bécigneul, and T. Hofmann. Hyperbolic entailment cones for learning hierarchical embed  \n388 dings. In ICML, 2018.   \n389 [22] O. Ganea, G. Bécigneul, and T. Hofmann. Hyperbolic neural networks. NeurIPS, 2018.   \n390 [23] M. GhadimiAtigh, J. Schoep, E. Acar, N. van Noord, and P. Mettes. Hyperbolic image segmentation. arXiv   \n391 preprint arXiv:2203.05898, 2022.   \n392 [24] P. Goyal, P. Dollár, R. Girshick, P. Noordhuis, L. Wesolowski, A. Kyrola, A. Tulloch, Y. Jia, and K. He.   \n393 Accurate, large minibatch sgd: Training imagenet in 1 hour. arXiv preprint arXiv:1706.02677, 2017.   \n394 [25] J.-B. Grill, F. Strub, F. Altché, C. Tallec, P. Richemond, E. Buchatskaya, C. Doersch, B. Avila Pires, Z. Guo,   \n395 M. Gheshlaghi Azar, B. Piot, k. kavukcuoglu, R. Munos, and M. Valko. Bootstrap your own latent - a new   \n396 approach to self-supervised learning. In NeurIPS, 2020.   \n397 [26] M. Gromov. Hyperbolic groups. In Essays in group theory, pages 75–263. Springer, 1987.   \n398 [27] K. He, H. Fan, Y. Wu, S. Xie, and R. Girshick. Momentum contrast for unsupervised visual representation   \n399 learning. In CVPR, 2020.   \n400 [28] O. J. Hénaff, S. Koppula, J.-B. Alayrac, A. van den Oord, O. Vinyals, and J. Carreira. Efficient visual   \n401 pretraining with contrastive detection. In ICCV, pages 10086–10096, 2021.   \n402 [29] J. Johnson, R. Krishna, M. Stark, L.-J. Li, D. Shamma, M. Bernstein, and L. Fei-Fei. Image retrieval using   \n403 scene graphs. In CVPR, 2015.   \n404 [30] V. Khrulkov, L. Mirvakhabova, E. Ustinova, I. Oseledets, and V. Lempitsky. Hyperbolic image embeddings.   \n405 In CVPR, 2020.   \n406 [31] R. Krishna, Y. Zhu, O. Groth, J. Johnson, K. Hata, J. Kravitz, S. Chen, Y. Kalantidis, L.-J. Li, D. A. Shamma,   \n407 et al. Visual genome: Connecting language and vision using crowdsourced dense image annotations. IJCV,   \n408 2017.   \n409 [32] J. M. Lee. Introduction to Riemannian manifolds. Springer, 2018.   \n410 [33] T.-Y. Lin, M. Maire, S. J. Belongie, J. Hays, P. Perona, D. Ramanan, P. Dollár, and C. L. Zitnick. Microsoft   \n411 coco: Common objects in context. In ECCV, 2014.   \n412 [34] N. Linial, E. London, and Y. Rabinovich. The geometry of graphs and some of its algorithmic applications.   \n413 Combinatorica, 15(2):215–245, 1995.   \n414 [35] Q. Liu, M. Nickel, and D. Kiela. Hyperbolic graph neural networks. NeurIPS, 2019.   \n415 [36] S. Liu, J. Chen, L. Pan, C.-W. Ngo, T.-S. Chua, and Y.-G. Jiang. Hyperbolic visual embedding learning for   \n416 zero-shot recognition. In CVPR, 2020.   \n417 [37] S. Liu, Z. Li, and J. Sun. Self-emd: Self-supervised object detection without imagenet, 2021.   \n418 [38] T. Long, P. Mettes, H. T. Shen, and C. G. M. Snoek. Searching for actions on the hyperbole. In CVPR,   \n419 2020.   \n420 [39] T. Mensink, E. Gavves, and C. G. Snoek. Costa: Co-occurrence statistics for zero-shot classification. In   \n421 CVPR, 2014.   \n422 [40] G. A. Miller, R. Beckwith, C. Fellbaum, D. Gross, and K. J. Miller. Introduction to wordnet: An on-line   \n423 lexical database. International journal of lexicography, 3(4):235–244, 1990.   \n424 [41] S. K. Mishra, A. B. Shah, A. Bansal, A. N. Jagannatha, A. Sharma, D. Jacobs, and D. Krishnan. Object  \n425 aware cropping for self-supervised learning. ArXiv, abs/2112.00319, 2021.   \n426 [42] S. Mo, H. Kang, K. Sohn, C.-L. Li, and J. Shin. Object-aware contrastive learning for debiased scene   \n427 representation. In NeurIPS, 2021.   \n428 [43] M. Nickel and D. Kiela. Poincaré embeddings for learning hierarchical representations. NeurIPS, 2017.   \n429 [44] M. Nickel and D. Kiela. Learning continuous hierarchies in the lorentz model of hyperbolic geometry. In   \n430 ICML, 2018.   \n431 [45] C. Northcutt, L. Jiang, and I. Chuang. Confident learning: Estimating uncertainty in dataset labels. Journal   \n432 of Artificial Intelligence Research, 70:1373–1411, 2021.   \n433 [46] D. Parikh and T. Chen. Hierarchical semantics of objects (hsos). In ICCV, 2007.   \n434 [47] D. Parikh, C. L. Zitnick, and T. Chen. Unsupervised learning of hierarchical spatial structures in images.   \n435 In CVPR, 2009.   \n436 [48] J. Park, J. Cho, H. J. Chang, and J. Y. Choi. Unsupervised hyperbolic representation learning via message   \n437 passing auto-encoders. In CVPR, 2021.   \n438 [49] A. Radford, J. W. Kim, C. Hallacy, A. Ramesh, G. Goh, S. Agarwal, G. Sastry, A. Askell, P. Mishkin,   \n439 J. Clark, et al. Learning transferable visual models from natural language supervision. In ICML, 2021.   \n440 [50] B. Recht, R. Roelofs, L. Schmidt, and V. Shankar. Do imagenet classifiers generalize to imagenet? In   \n441 ICML, 2019.   \n442 [51] F. Sala, C. De Sa, A. Gu, and C. Ré. Representation tradeoffs for hyperbolic embeddings. In ICML, 2018.   \n443 [52] R. R. Selvaraju, M. Cogswell, A. Das, R. Vedantam, D. Parikh, and D. Batra. Grad-cam: Visual explanations   \n444 from deep networks via gradient-based localization. In ICCV, 2017.   \n445 [53] R. R. Selvaraju, K. Desai, J. Johnson, and N. Naik. Casting your model: Learning to localize improves   \n446 self-supervised representations. In CVPR, 2021.   \n447 [54] V. Shankar, R. Roelofs, H. Mania, A. Fang, B. Recht, and L. Schmidt. Evaluating machine accuracy on   \n448 imagenet. In ICML, 2020.   \n449 [55] R. Shimizu, Y. Mukuta, and T. Harada. Hyperbolic neural networks++. In ICLR, 2021.   \n450 [56] D. Surís, R. Liu, and C. Vondrick. Learning the predictability of the future. In CVPR, 2021.   \n451 [57] Y. Tian, D. Krishnan, and P. Isola. Contrastive multiview coding. In ECCV, 2020.   \n452 [58] A. Tifrea, G. Bécigneul, and O.-E. Ganea. Poincaré glove: Hyperbolic word embeddings. In ICLR.   \n453 OpenReview, 2018.   \n454 [59] D. Tsipras, S. Santurkar, L. Engstrom, A. Ilyas, and A. Madry. From imagenet to image classification:   \n455 Contextualizing progress on benchmarks. In ICML, 2020.   \n456 [60] J. R. Uijlings, K. E. Van De Sande, T. Gevers, and A. W. Smeulders. Selective search for object recognition.   \n457 IJCV, 104(2):154–171, 2013.   \n458 [61] V. Vasudevan, B. Caine, R. Gontijo-Lopes, S. Fridovich-Keil, and R. Roelofs. When does dough become a   \n459 bagel? analyzing the remaining mistakes on imagenet. arXiv preprint arXiv:2205.04596, 2022.   \n460 [62] W. Wang, T. Zhou, F. Yu, J. Dai, E. Konukoglu, and L. Van Gool. Exploring cross-image pixel contrast for   \n461 semantic segmentation. In ICCV, 2021.   \n462 [63] X. Wang, R. Zhang, C. Shen, T. Kong, and L. Li. Dense contrastive learning for self-supervised visual   \n463 pre-training. In CVPR, 2021.   \n464 [64] Z. Weng, M. G. Ogut, S. Limonchik, and S. Yeung. Unsupervised discovery of the long-tail in instance   \n465 segmentation using hierarchical self-supervision. In CVPR, 2021.   \n466 [65] Y. Wu, A. Kirillov, F. Massa, W.-Y. Lo, and R. Girshick. Detectron2. https://github.com/   \n467 facebookresearch/detectron2, 2019.   \n468 [66] Z. Wu, Y. Xiong, S. X. Yu, and D. Lin. Unsupervised feature learning via non-parametric instance   \n469 discrimination. In CVPR, 2018.   \n470 [67] J. Xie, X. Zhan, Z. Liu, Y. S. Ong, and C. C. Loy. Unsupervised object-level representation learning from   \n471 scene images. In NeurIPS, 2021.   \n472 [68] Z. Xie, Y. Lin, Z. Zhang, Y. Cao, S. Lin, and H. Hu. Propagate yourself: Exploring pixel-level consistency   \n473 for unsupervised visual representation learning. In CVPR, 2021.   \n474 [69] J. Yan, L. Luo, C. Deng, and H. Huang. Unsupervised hyperbolic metric learning. In CVPR, 2021.   \n475 [70] B. Zhou, A. Lapedriza, J. Xiao, A. Torralba, and A. Oliva. Learning deep features for scene recognition   \n476 using places database. NeurIPS, 2014. ",
+        "bbox": [
+            137,
+            195,
+            826,
+            909
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            137,
+            87,
+            828,
+            916
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            137,
+            92,
+            826,
+            507
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "1. For all authors... ",
+        "bbox": [
+            214,
+            116,
+            339,
+            131
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "(a) Do the main claims made in the abstract and introduction accurately reflect the paper’s contributions and scope? [Yes]   \n(b) Did you describe the limitations of your work? [Yes]   \n(c) Did you discuss any potential negative societal impacts of your work? [Yes]   \n(d) Have you read the ethics review guidelines and ensured that your paper conforms to them? [Yes] ",
+        "bbox": [
+            238,
+            135,
+            825,
+            227
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "2. If you are including theoretical results... ",
+        "bbox": [
+            214,
+            231,
+            493,
+            244
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "(a) Did you state the full set of assumptions of all theoretical results? [N/A] (b) Did you include complete proofs of all theoretical results? [N/A] ",
+        "bbox": [
+            236,
+            248,
+            738,
+            280
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "3. If you ran experiments... ",
+        "bbox": [
+            212,
+            285,
+            393,
+            299
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "(a) Did you include the code, data, and instructions needed to reproduce the main experimental results (either in the supplemental material or as a URL)? [Yes]   \n(b) Did you specify all the training details (e.g., data splits, hyperparameters, how they were chosen)? [Yes]   \n(c) Did you report error bars (e.g., with respect to the random seed after running experiments multiple times)? [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,
+            303,
+            826,
+            421
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "4. If you are using existing assets (e.g., code, data, models) or curating/releasing new assets... ",
+        "bbox": [
+            215,
+            426,
+            823,
+            440
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "(a) If your work uses existing assets, did you cite the creators? [N/A]   \n(b) Did you mention the license of the assets? [N/A]   \n(c) Did you include any new assets either in the supplemental material or as a URL? [N/A]   \n(d) Did you discuss whether and how consent was obtained from people whose data you’re using/curating? [N/A]   \n(e) Did you discuss whether the data you are using/curating contains personally identifiable information or offensive content? [N/A] ",
+        "bbox": [
+            238,
+            444,
+            825,
+            565
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "5. If you used crowdsourcing or conducted research with human subjects... ",
+        "bbox": [
+            214,
+            569,
+            705,
+            584
+        ],
+        "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,
+            588,
+            825,
+            678
+        ],
+        "page_idx": 12
+    }
+]

parse/dev/VwRFJi9crEH/VwRFJi9crEH.md

@@ -0,0 +1,372 @@
+# Personalized Subgraph Federated Learning
+
+Anonymous Author(s)   
+Affiliation   
+Address   
+email
+
+# Abstract
+
+1 In real-world scenarios, subgraphs of a larger global graph may be distributed   
+2 across multiple devices or institutions, and only locally accessible due to privacy re  
+3 strictions, although there may be links between them. Recently proposed subgraph   
+4 Federated Learning (FL) methods deal with those missing links across private local   
+5 subgraphs while distributively training Graph Neural Networks (GNNs) on them.   
+6 However, they have overlooked the inevitable heterogeneity among subgraphs,   
+7 caused by subgraphs comprising different parts of a global graph. For example,   
+8 a subgraph may belong to one of the communities within the larger global graph.   
+9 A naive subgraph FL in such a case will collapse incompatible knowledge from   
+10 local GNN models trained on heterogeneous graph distributions. To overcome   
+11 such a limitation, we introduce a new subgraph FL problem, personalized subgraph   
+12 FL, which focuses on the joint improvement of the interrelated local GNN models   
+13 rather than learning a single global GNN model, and propose a novel framework,   
+14 FEDerated Personalized sUBgraph learning (FED-PUB), to tackle it. A crucial   
+15 challenge in personalized subgraph FL is that the server does not know which   
+16 subgraph each client has. FED-PUB thus utilizes functional embeddings of the   
+17 local GNNs using random graphs as inputs to compute similarities between them,   
+18 and use them to perform weighted averaging for server-side aggregation. Further,   
+19 it learns a personalized sparse mask at each client to select and update only the   
+20 subgraph-relevant subset of the aggregated parameters. We validate FED-PUB for   
+21 its subgraph FL performance on six datasets, considering both non-overlapping   
+22 and overlapping subgraphs, on which ours largely outperforms relevant baselines.
+
+# 23 1 Introduction
+
+24 A graph, which defines the relationships among instances, can model a wide range of structured data   
+25 including social [7], co-purchasing [23], and collaboration networks [36]. Most of the previous works   
+26 on graph representation learning focus on a single graph, whose nodes and edges collected from   
+27 multiple sources are stored in a central server. For instance, in a social network platform, every user,   
+28 with his/her social networks, contributes to creating a giant network consisting of all users and their   
+29 connections. However, in some practical scenarios, each user/institution collects its own private graph,   
+30 which is only locally accessible due to privacy restrictions. For instance, as described in Zhang et al.   
+31 [45], each hospital may have its own patient interaction network to track their physical contacts or   
+32 co-diagnosis of a disease, however, such a graph may not be shared with others. An obvious challenge   
+33 for such a scenario is how to deal with potentially missing edges between subgraphs [42, 45] that are   
+34 not captured by individual data owners, that may carry important information (See Figure 1 (A)).   
+35 How can we then collaboratively train, without sharing actual data, a neural network with its subgraphs   
+36 distributed across multiple participants (i.e., clients) over different devices or institutions? The most   
+37 straightforward way is to perform Federated Learning (FL) with Graph Neural Networks (GNNs). In   
+38 particular, in such an FL framework, each client will individually train a local GNN on the private   
+39 local data, while a central server aggregates the locally updated GNN weights from multiple clients   
+40 into one, and then transmits it back to the clients. Recent subgraph FL methods work in such a   
+41 manner [42, 45] while additionally tackling the problem of missing edges between subgraphs. This is   
+42 done as illustrated in Figure 1 (B), where the local subgraph is expanded either by exactly augmenting   
+43 the relevant nodes from the other subgraphs at the other clients [42], or by estimating the nodes using   
+44 the node information in the other subgraphs [45]. However, such sharing of node information may   
+45 compromise data privacy and can incur high communication costs.   
+46 Also, there exists a more important challenge that has been overlooked by the existing subgraph FL   
+47 methods. We observe that they suffer from large performance degeneration (See Figure 1 right), due   
+48 to a lack of consideration of the heterogeneity among the subgraphs, which is natural since subgraphs   
+49 comprise different parts of a global graph. Notably, there could be multiple communities within   
+50 a global graph, each of which is formed by a group of densely connected subgraphs with similar   
+51 characteristics (Figure 1 (A)). For example, some of patient networks from hospitals can be grouped   
+52 by their specialized sectors according to the disease categories, namely psychiatric or ophthalmology.   
+53 Motivated by this challenge, we introduce a novel problem of personalized subgraph FL, whose goal   
+54 is the joint improvement of interrelated local models trained on the interconnected local subgraphs,   
+55 for instance, subgraphs belonging to the same community (See Figure 1 (C)), by sharing weights   
+56 among them. However, tackling personalized subgraph FL is challenging, since we do not know   
+57 which subgraph each client has, due to their local accessibility. To resolve this issue, we use functional   
+58 embeddings of GNNs on random graphs to obtain similarity scores between two local GNNs, inspired   
+59 by a work for neural network search that effectively represents entire neural networks in the vector   
+60 space [17], and then use them to perform weighted averaging of the model weights at the server.   
+61 However, the similarity scores only tell how relevant each local model from the other clients is, but   
+62 not which of the parameters are relevant. Thus we further learn and apply personalized sparse masks   
+63 on the local GNN at each client to obtain only the subnetwork, relevant for the local subgraph. We   
+64 refer to this subgraph FL framework as FEDerated Personalized sUBgraph learning (FED-PUB).   
+65 We extensively validate our FED-PUB on six different datasets with varying numbers of clients,   
+66 under both overlapping and disjoint subgraph FL scenarios. The experimental results show that ours   
+67 significantly outperforms relevant baselines. Further analysis shows that our method can discover   
+68 community structures among subgraphs, and the subgraph-specific masking localizes the knowledge   
+69 with respect to subgraphs belonging to each community. Our main contributions are as follows:
+
+![](images/ec3ba82125826eb58c6fb22d3d7f802349a6c0db9b44753f2092ca742fa2f22a.jpg)  
+Figure 1: (A) An illustration of local subgraphs distributed across multiple participants with overlapping nodes, missing edges and community structures between subgraphs. (B) Existing subgraph FL methods [42, 45] expand the local subgraphs to tackle the missing edge problem, but collapse incompatible knowledge from heterogeneous subgraphs. (C) Our personalized subgraph FL focuses on the joint improvement of local models working on interrelated subgraphs, such as ones within the same community, by selectively sharing knowledge across them. (Right:) Knowledge collapse results, where local models belonging to two small communities $\mathbf { C o m m 1 }$ and 2) suffer from large performance degeneration by existing subgraph FL (e.g., FedGNN [42] and FedSage $^ +$ [45]). A personalized FL method, FedPer [2] also underperforms ours since it only focuses on individual model’s improvement without sharing local personalization layers between similar subgraphs.
+
+• We introduce a novel problem of personalized subgraph FL, which aims at collaborative improvements of the related local models (e.g. subgraphs belonging to the same community), which has been relatively overlooked by previous works on graph and subgraph FL.
+
+• We propose a novel framework for personalized subgraph FL, which performs weighted averaging of the local model parameters based on their functional similarities obtained without accessing the data, and learns sparse masks to select only the relevant subnetworks for the given subgraphs.
+
+76 • We validate our personalized subgraph FL framework on six real-world datasets under two different   
+77 settings, demonstrating its effectiveness over existing subgraph FL baselines.
+
+# 78 2 Related Work
+
+Graph Neural Networks Graph representation learning with Graph Neural Networks (GNNs) [10, 48, 43, 18, 3], which aims to learn the representations of the nodes, the edges, and the entire graph, is an extensively studied topic. Most existing GNNs under the message passing scheme [8] iteratively represent a node by aggregating features from its neighboring nodes as well as itself. For example, Graph Convolutional Network (GCN) [22] approximates the spectral graph convolutions [12], yielding a mean aggregation over neighboring nodes. Similarly, for each node, GraphSAGE [11] aggregates the features from its neighbors to update the node representation. Such advances in GNNs have led to successes on node and link prediction tasks [22, 47]. However, they are not directly applicable to real-world systems with locally distributed graphs, where graphs from different sources are not shared across participants, which gives rise to federated learning approaches to train GNNs.
+
+Federated Learning Federated Learning (FL) [32, 41, 19, 24], aiming to learn a model by aggregating model weights trained on local data, is an essential approach for our distributed subgraph learning problem. To mention a few, FedAvg [32] locally trains a model for each client and then transmits the trained model to a server, while the server aggregates the model weights from local clients and then sends the aggregated model back to them. However, since the locally collected data from different clients may largely vary, heterogeneity is a crucial issue. To tackle this, FedProx [25] proposes the regularization term that minimizes the weight differences between local and global models, which prevents the model from diverging by overfitting to the local training data. However, when the local data is extremely heterogeneous, it is more appropriate to collaboratively train a personalized model for each client rather than learning a single global model [2, 30, 26, 46, 6]. FedPer [2] is such a personalized FL method, which shares only the base layers while having local personalized layers for each client, to keep the local knowledge. Unlike the commonly studied image and text data, graph-structured data is defined by connections between instances, and consequently introduces additional challenges: missing edges and shared nodes between private subgraphs. Note that, regarding architectures, there is literature [29, 27, 38, 49] that leverages outputs of neural networks for predicting/minimizing outputs across different client models; however, we use functional outputs of neural networks to identify interconnected subgraphs, thus ours differs from them methodologically.
+
+Graph Federated Learning Few recent studies propose to use the FL framework to collaboratively train GNNs without sharing graph data [13], which can be broadly classified into subgraph- and graph-level methods. Graph-level FL methods assume that different clients have completely disjoint graphs (e.g., molecular graphs), and recent works [44, 14] focus on the heterogeneity among non-IID graphs (i.e., difference in graph labels across various clients). In contrast to graph-level FL methods that have similar challenges to general FL scenarios, the subgraph-level FL problem we target has a unique graph-structural challenge, that there exist missing yet probable links between subgraphs, since a subgraph is a part of a larger global graph. To deal with such a missing link problem among subgraphs, existing methods [42, 45] augment the nodes by requesting the node information in the other subgraphs, and then connecting the existing nodes with the augmented ones. However, this scheme could compromise data privacy constraints, and also increases communication overhead across clients. Unlike existing subgraph FL that focuses on the problem of missing links, our subgraph FL method tackles the problem with a completely different perspective, focusing on discovering subgraph communities [35, 9, 34], which are groups of densely connected subgraphs.
+
+# 3 Personalized Subgraph Federated Learning
+
+We provide the general descriptions of Graph Neural Networks (GNNs) and Federated Learning (FL), and then define our novel problem of personalized subgraph FL lying at the intersection of them.
+
+Graph Neural Networks A graph $\mathcal { G } = ( \nu , \mathcal { E } )$ consists of a set of nodes $\nu$ with $n$ elements and a set of edges $\mathcal { E }$ with $m$ elements along with its node feature matrix $\ b { X } \in \mathbb { R } ^ { n \times d }$ , where each column represents a $d$ -dimensional feature for each node. Further, $( u , v ) \in \mathcal { E }$ represents an edge from a node $u$ to a node $v$ . Then, given the graph, Graph Neural Networks (GNNs) [8, 10] generally represent each node based on features from its neighbors as well as itself, formally defined as follows:
+
+$$
+\pmb { H } _ { v } ^ { ( l + 1 ) } = \mathrm { U P D A T E } ^ { ( l ) } \left( \pmb { H } _ { v } ^ { ( l ) } , \mathrm { A G G R E G A T E } ^ { ( l ) } \left( \left\{ \pmb { H } _ { u } ^ { ( l ) } : \forall u \in \pmb { \mathcal { N } } ( v ) \right\} \right) \right) ,
+$$
+
+128 where $\pmb { H } _ { v } ^ { ( l ) }$ is the feature matrix for node $v$ at $l$ -th layer, $\mathcal { N } ( v )$ denotes a set of adjacent nodes of   
+129 node $v$ : $\mathcal { N } ( v ) = \{ u \in \mathcal { V } \mid ( u , v ) \in \mathcal { E } \}$ , AGGREGATE aggregates the features of $v$ ’s neighbors, and   
+130 UPDATE updates the node $v$ ’s representation given its previous representation and the aggregated   
+131 representations from the neighbors. $H ^ { ( 1 ) }$ is initialized as input node features $\boldsymbol { X }$ .   
+132 Federated Learning The objective of Federated Learning (FL) is to collaboratively train a model   
+133 with local private data.accessible from others: $\mathcal { D } _ { k } = \{ \boldsymbol { X } _ { i } , \boldsymbol { y } _ { i } \} _ { i = 1 } ^ { N _ { k } }$ have , whe $K$ $X _ { i }$ rticipants with locis a data instance, $\mathbf { \nabla } _ { \mathbf { \boldsymbol { y } } _ { i } }$ collected data that is notis its corresponding class   
+135 label, and is the number of data instances at $k$ -th client. Then, for decentralized training with   
+136 local data, a popular $\mathrm { F L }$ algorithm, FedAvg [32], works as the following three steps:
+
+1. (Initialization) At the initial communication round $r = 0$ , the central server first selects $K$ clients that are available for training, and initializes their local model parameters as the global parameter $\bar { \pmb \theta }$ , represented as follows: $\bar { \pmb { \theta } _ { k } ^ { ( 0 ) } }  \bar { \pmb { \theta } } ^ { ( 0 ) } \forall k$ , where $\theta _ { k } ^ { ( 0 ) }$ is the parameters for $k$ -th client.
+
+2. (Local Updates) Each active local model performs training on private local data $\mathcal { D } _ { k }$ to minimize the task loss $\mathcal { L } ( \mathcal { D } _ { k } ; \boldsymbol { \theta } _ { k } ^ { ( 0 ) } )$ , consequently updating the parameters $\pmb { \theta } _ { k } ^ { ( 1 ) }  \pmb { \theta } _ { k } ^ { ( 0 ) } - \eta \nabla \mathcal { L }$ .
+
+3. (Global Aggregation) After local training, the server aggregates the locally learned knowledge with respect to the number of training instances, i.e., $\begin{array} { r } { \bar { \pmb { \theta } } ^ { ( 1 ) }  \frac { N _ { k } } { N } \sum _ { k = 1 } ^ { K } \pmb { \theta } _ { k } ^ { ( 1 ) } } \end{array}$ with $\begin{array} { r } { N = \sum _ { k } N _ { k } } \end{array}$ and distributes the updated global parameters $\bar { \theta } ^ { ( 1 ) }$ to the local clients selected at the next round.
+
+This $\mathrm { F L }$ algorithm iterates between Step 2 and 3 until reaching the final round $R$
+
+146 Challenges in Subgraph FL While the above FL works well on image and text data, due to the   
+147 unique structure of graphs, there exist nontrivial challenges for applying this FL scheme to graph  
+148 structured data. In particular, unlike with an image domain where each instance $X _ { i }$ is independent   
+149 from the other images, each node $v$ in a graph is always influenced by its relationships to adjacent   
+150 nodes $\mathcal { N } ( v )$ . Moreover, a local graph $G _ { i }$ could be a subgraph of a larger global graph $\mathcal { G }$ : $G _ { i } \subseteq { \mathcal { G } }$ . In   
+151 such a case, there could be missing edges between local subgraphs in two different clients: $( u , v )$   
+152 with $u \in \mathcal V _ { i }$ and $v \in \mathcal { V } _ { j }$ for clients $i$ and $j$ , respectively. To tackle this missing edge problem, few   
+153 existing subgraph FL methods [42, 45] estimate the nodes from a local subgraph $G _ { k }$ based on the   
+154 node information from the subgraphs at other clients $G _ { i } \forall i \neq k$ , and then extend the existing nodes   
+155 with the estimated ones. However, this augmentation scheme incurs high communication costs as it   
+156 requires sharing node information across clients, which may also violate data privacy constraints [1].   
+157 Yet, there exists another issue that makes subgraph $\mathrm { F L }$ even more challenging. Assume that we have   
+158 a global graph consisting of all the subgraphs. Then, there exists communities of such subgraphs [35,   
+159 9, 34], where subgraphs within the same community are more densely connected to each other   
+160 than subgraphs outside the community. Formally, a global graph $\mathcal { G }$ can be decomposed into $T$   
+161 different communities: $C _ { i } \subseteq \mathcal { G } \forall i = 1 , . . . , T$ , where $i$ -th community $C _ { i } = ( \mathcal { V } _ { i } , \mathcal { E } _ { i } )$ consists of   
+162 densely connected nodes. Then, in a subgraph FL problem, each client has a local subgraph $G _ { j }$ that   
+163 belongs to at least a single community1: $\begin{array} { r } { C _ { i } = \bigcup _ { j = 1 } ^ { J } G _ { j } } \end{array}$ . Note that, based on the theory of network   
+164 homophily [33], such connected subgraphs within the same community have similar properties, while   
+165 subgraphs in two opposite communities are not. Such distributional heterogeneity across communities   
+166 may lead a naive FL algorithm to collapse incompatible knowledge across different communities.   
+167 Personalized Subgraph FL To prevent the above knowledge collapse issue, we aim to personalize   
+168 the subgraph FL algorithm by performing weighted averaging of the local model parameters at   
+169 the server, rather than learning a single set of global parameters; thereby capturing the subgraph   
+170 community structures among interrelated subgraphs. Formally, the objective of existing subgraph   
+171 FL [42, 45, 28] is as follows: minθ $\textstyle \sum _ { G _ { i } \subseteq \mathcal { G } } { \mathcal { L } } ( G _ { i } ; \theta )$ . However, a major drawback of such a scheme   
+172 is that, since the subgraphs in two different communities with sparse connections are extremely   
+173 heterogeneous due to network homophily [33], finding a universal set of parameters (i.e., $\pmb \theta$ ) that work   
+174 on all tasks will result in finding a suboptimal parameter set. To address such limitations of existing   
+175 subgraph FL, we formulate a novel problem of personalized subgraph FL, formalized as follows:
+
+$$
+\operatorname* { m i n } _ { ( \theta _ { i } ) } \sum _ { G _ { i } \subseteq \mathcal { G } } \mathcal { L } ( G _ { i } ; \theta _ { i } ) , \theta _ { i } \gets \sum _ { j = 1 } ^ { K } \alpha _ { i j } \theta _ { j } \mathrm { ~ w i t h ~ } \alpha _ { i k } \gg \alpha _ { i l } \mathrm { ~ f o r ~ } G _ { k } \subseteq C \mathrm { ~ a n d ~ } G _ { l } \not \subseteq C ,
+$$
+
+176 where $\theta _ { i }$ is the weight for subgraph $G _ { i }$ belonging to community $C$ , and $\alpha _ { i j }$ is the coefficient for   
+177 weight aggregation which we will specify in Section 4.1. This formulation promotes the collaborative   
+178 learning across multiple local models that work on the interrelated subgraphs that belong to the same   
+179 community, by assigning larger weights on them.
+
+![](images/4fe235882529c3da4c1e71071f024078bcd919062734a34bb19dec247d66e5bc.jpg)  
+Figure 2: (A) Two communities, each of which consists of one/two subgraphs. (B) Client Similarity Matching: we forward randomly generated graphs to models $f ( \bar { G } ; \pmb { \theta } )$ , and then obtain the functional embeddings of them $\tilde { h }$ , which are then used to estimate the similarities between subgraphs. The similarities are used in the weight aggregation, resulting in the personalized model weights $\bar { \pmb \theta }$ . (C) Weight Masking: the transmitted weights from the server to clients $\bar { \pmb \theta }$ are masked and shifted by local masks for localization to the local subgraph distribution.
+
+# 4 Federated Personalized Subgraph Learning (FED-PUB) Framework
+
+Our goal of personalized subgraph FL is to jointly improve the local models trained on the interconnected local subgraphs forming the community structures. To this end, we propose to compute subgraph similarity scores for detecting communities, and to mask subgraph-irrelevant weights.
+
+# 4.1 Subgraph Similarity Estimation for Detecting Subgraph Community
+
+We aim to reflect the community structure consisting of a group of densely connected subgraphs, by sharing more weights among subgraphs in the same community, as formalized in equation 2. Due to network homophily where similar instances in the graph are more associated with each other [33], the subgraphs within the same community should have similar properties. Therefore, if one can measure the subgraph similarities, we can group the similar ones into the community. However, measuring the similarity between local subgraphs is challenging since we do not know which subgraph each client has due to local accessibility. How can we then compute subgraph similarities, without accessing them? To this end, we aim to approximate the subgraph similarity at local clients using auxiliary information obtained from the local GNN models that work on the subgraphs.
+
+Subgraph Similarity Estimation with Model Parameters For measuring the similarity between subgraphs at each client, without accessing them, we may use the model parameters as proxies, as follows: $S ( i , j ) = ( \pmb { \theta } _ { i } \cdot \pmb { \theta } _ { j } ) / ( \lVert \pmb { \theta } _ { i } \rVert \lVert \pmb { \theta } _ { j } \rVert )$ , where $\pmb \theta$ is a flattened parameter into the vector, and $S$ is a similarity measure. This may sound reasonable since the GNN model trained on the subgraph will embed its knowledge into its parameters. However, this scheme has a notable drawback that similarity measured in the high-dimensional parameter space is not meaningful due to the curse of dimensionality [4], and that the cost of calculating the similarity between parameters grows rapidly as the model size increases (See Figure 3).
+
+![](images/d3fb88075ed18909d4e7a136866bd28dca546521fdacb10f5d6ea35a2ea0c793.jpg)  
+Figure 3: Effectiveness (top) and efficiencies (bottom) of different similarity measurements.
+
+205 Subgraph Similarity Estimation with Functional Embedding To tackle the limitations of using   
+206 parameter distance, we propose to measure the functional similarity of neural networks by feeding the   
+207 same input to every local client and then calculating the similarities using their outputs, inspired by a   
+208 work for neural network search [17]. The main intuition is that we can consider the transformation   
+209 defined with a neural network as a function, and we measure the functional similarity of two networks   
+210 by the distance of their outputs for the same input. However, unlike the previous work [17] that   
+211 tackles image classification, which uses Gaussian noises as inputs, we use random graphs as inputs   
+212 as we work with GNNs. Formally, let $\tilde { G } = ( \tilde { \mathcal { V } } , \tilde { \mathcal { E } } )$ be a random community graph obtained from a   
+213 stochastic block model [15], where subgraphs within the community have more edges between them   
+214 than edges across the communities. Further, $\tilde { \nu }$ is randomly initialized from the normal distribution.   
+215 Then, the similarity between two functions defined by GNNs at clients $i$ and $j$ is defined as follows:
+
+$$
+S ( i , j ) = \frac { \tilde { h } _ { i } \cdot \tilde { h } _ { j } } { \| \tilde { h } _ { i } \| \| \tilde { h } _ { j } \| } , \quad \tilde { h } _ { i } = \mathtt { A V G } ( f ( \tilde { G } ; \theta _ { i } ) ) \mathrm { ~ a n d ~ } \tilde { h } _ { j } = \mathtt { A V G } ( f ( \tilde { G } ; \theta _ { j } ) ) ,
+$$
+
+where 216 $\tilde { h }$ is the averaged output of all node embeddings for input $\tilde { G }$ with AVG operation to reduce the 217 dimensionality of the output from $n \times d$ to $d$ , for $n$ nodes with $d$ -dimensional node features.
+
+218 Personalized Weight Aggregation based on Subgraph Similarity With equation 3, the remaining   
+219 step is then to share the model weights between models working on similar subgraphs belonging to   
+220 the same community. However, entirely ignoring the model parameters from different communities   
+221 may result in exploiting only the local objective while ignoring globally useful weights, which may   
+222 result in performance degeneration. Therefore, we perform weighted averaging of all the local models   
+223 from the other clients based on their functional (subgraph) similarities, as follows (Figure 2 (B)):
+
+$$
+\bar { \theta } _ { i }  \sum _ { j } \alpha _ { i j } \cdot \theta _ { j } , \quad \alpha _ { i j } = \frac { \exp ( \tau \cdot S ( i , j ) ) } { \sum _ { k } \exp ( \tau \cdot S ( i , k ) ) } ,
+$$
+
+224 where $\alpha _ { i j }$ is a normalized similarity between clients $i$ and $j$ , and $\tau$ is a hyperparameter for scaling   
+225 the unnormalized similarity score. Note that increasing the value of $\tau$ (e.g., 10) will result in model   
+226 averaging done almost exclusively among subgraphs detected as belonging to the same community.
+
+This personalized scheme handles two challenges in subgraph FL. First, in contrast to the global weight aggregation scheme which easily collapses the knowledge from heterogeneous communities into a single model, our subgraph $\mathrm { F L }$ allows the models belonging to different communities to obtain model weights that are beneficial for each community. Also, the missing edges between subgraphs that have been explicitly handled by previous works [42, 45] could be also implicitly considered by assigning larger weights to models within the same community (See Figure 10). This also enhances data privacy while minimizing the communication costs between probably linked subgraphs.
+
+# 4.2 Adaptive Weight Masking for Selecting Subgraph-Relevant Parameters
+
+With the previous similarity matching scheme, we can effectively group GNN models that belong to the same community, thus preventing the collapsing of irrelevant knowledge from other communities. However, the scalar weighting scheme only considers how much each local model from other clients is relevant for the subgraph task, but not which parameters are relevant. Thus we propose a scheme to select only the relevant parameters from the aggregated model weights transmitted from the server.
+
+Personalized Parameter Masking We perform selective training and updating of the aggregated parameters by modulating and shifting them, using sparse local masks. Formally, let $\pmb { \mu } _ { k }$ be a local mask for a client $k$ . Then, our local model weight is obtained by modulating the weights from the server, as follows: $\mathbf { \theta } _ { k } = \bar { \theta } _ { \underline { { k } } } \odot \mu _ { k }$ , where $\odot$ is an element-wise multiplication operation between the globally given weight $\bar { \pmb { \theta } } _ { k }$ and the local mask $\pmb { \mu } _ { k }$ . Note that the local mask is a free variable and is not shared across clients. Also, we initialize $\pmb { \mu } _ { k }$ as ones, in order to start training with the globally initialized model parameters without modification. We then further promote sparsity on the mask, which brings two key advantages. First, we can transmit only the partial parameters, that have not been sparsified at the client to the server rather than sending all parameters, thus reducing the communication costs. Moreover, if local masks are sufficiently sparse, the local models can be trained faster, given that zero-skipping operations are supported (Figure 2 (C)). To take these benefits in sparsity, we use $L _ { 1 }$ regularizer on $\pmb { \mu } _ { k }$ when performing local optimization, as shown in equation 5.
+
+Preventing Local Divergence with Proximal Term As masks are trained only with limited local data without parameter sharing, they may be easily overfitted to the training instances in each client. To alleviate this issue, we adopt the proximal term proposed in Li et al. [25] that regularizes the locally updated models $\pmb { \theta } _ { k }$ to be closer to the globally given model $\bar { \theta } _ { k }$ , therefore, preventing the model from extremely drifting to the local training distribution. To sum up, at $k$ -th client, our objective function including sparsity and proximal terms with $L _ { 1 }$ and $L _ { 2 }$ losses is denoted as follows:
+
+$$
+\begin{array} { r } { \operatorname* { m i n } _ { ( \theta _ { k } , \mu _ { k } ) } \mathcal { L } ( \mathcal { D } _ { k } ; \theta _ { k } , \mu _ { k } ) + \lambda _ { 1 } \| \pmb { \mu } _ { k } \| _ { 1 } + \lambda _ { 2 } \| \pmb { \theta } _ { k } - \bar { \pmb { \theta } } _ { k } \| _ { 2 } ^ { 2 } , } \end{array}
+$$
+
+where $\mathcal { L }$ is the conventional cross-entropy loss function, and $\lambda _ { 1 }$ and $\lambda _ { 2 }$ are scaling hyper-parameters.
+
+# 5 Experiments
+
+We now experimentally validate our FED-PUB on six different datasets under both the overlapping and disjoint subgraph scenarios with varying client numbers, with node classification tasks.
+
+# 5.1 Experimental Setups
+
+Datasets Following the setup from Zhang et al. [45], we construct the distributed subgraphs from the benchmark dataset by dividing it into the number of participants, each of which has a subgraph that is a part of an original graph. Specifically, we use six datasets: Cora, CiteSeer, Pubmed and ogbn-arxiv for citation graphs [39, 16]; Computer and Photo for product graphs [31, 40]. We then divide the original graph into multiple subgraphs using the METIS graph partitioning algorithm [20]. Note that, unlike the Louvain algorithm [5] presented in Zhang et al. [45] that requires to further merge partitioned subgraphs into particular numbers of subgraphs since it cannot specify the number of subsets (i.e., clients for FL), the METIS algorithm can specify the number of subsets, thus making more reasonable experimental settings in subgraph FL (See Section C.2 of the supplementary file). For the non-overlapping scenario where there are no duplicate nodes between subgraphs, we use the output from the METIS as it provides the non-overlapping partitions. Meanwhile, for the overlapping scenario where nodes are duplicated among subgraphs, we randomly sample the subgraphs multiple times from the partitioned graph. For more details, please see Section B of the supplementary file.
+
+![](images/e263c7ef0b664c9ea8fadbe4b7bff82da8185b938cb81675d896cfeaecca53c1.jpg)  
+Figure 4: Convergence plots for the overlapping node scenario. We visualize the test accuracy curves for all six datasets corresponding to Table 1, over 100 communication rounds with 10 clients.
+
+Baselines 1) FedAvg [32] and 2) FedProx [25]: The most popular FL baselines. 3) FedPer [2]: A personalized FL baseline without sharing personalized layers. 4) FedGNN [42] and 5) FedSage+ [45]: Subgraph FL baselines which we mainly target. 6) GCFL [44]: A graph FL baseline which learns completely disjoint graphs as in clustered FL [37], adopted for subgraph FL. 7) Local: A baseline without sharing weights with other clients. 8) FED-PUB: Our personalized subgraph FL including subgraph similarity matching and weight masking. See Section B of the supplementary file for details.
+
+Implementation Details We set the GCN [22] with two layers as the base GNN for all models. We perform federated learning over 100 communication rounds for Cora, CiteSeer and Pubmed datasets, while 200 rounds for Computer, Photo and arxiv datasets, considering the size of datasets. The local training epoch is selected in the range of $\{ 1 , 2 , 3 \}$ depending on the dataset size (e.g., Computer is three while CiteSeer is one)2. We use the Adam optimizer [21] for model optimization. We then measure the node classification accuracy on subgraphs at the client-side, and then average the performance across clients. We provide further details in Section B of the supplementary file.
+
+# 5.2 Experimental Results
+
+Main Results Table 1 shows the node classification performance under the overlapping subgraph scenario, in which our FED-PUB statistically $( p > 0 . 0 5 )$ significantly outperforms all the baselines. In particular, while FedGNN and FedSage+ are two pioneer works for the subgraph FL problem, they significantly underperform personalized FL methods including ours, especially at the larger number of clients. This is even surprising as they share node information between clients for handling the missing edge problem, yet we suppose such inferior performance comes from naive averaging of local weights without consideration of community structures. While personalized FL baselines including FedPer and GCFL show decent performance by alleviating the knowledge collapse between subgraphs with local parameters or clustering, they still largely underperform ours as they are not concerned with the aggregation between similar subgraphs that form a community (i.e., GCFL uses a bi-partitioning scheme where it iteratively divides a group of subgraphs within the same community
+
+![](images/ac068ddc412ef8fa2aa6190e1bb3cc9e0145d2e424ef07b4d6dd899eab28f30c.jpg)  
+Figure 5: Convergence plots for the non-overlapping node scenario. We visualize the test accuracy curves for all six datasets corresponding to Table 2, over 100 communication rounds with 10 clients.
+
+301 into two disjoint sets). We then further conduct the experiments on the disjoint subgraph scenarios   
+302 (non-overlapping scenario), where nodes are not overlapped between subgraphs, which makes the   
+303 subgraph FL problem more heterogeneous. As shown in Table 2, FED-PUB consistently outperforms   
+304 all existing baselines in such a challenging scenario, demonstrating the efficacy of ours.
+
+Fast Local Convergence As shown in Figure 4 and 5, our FED-PUB converges rapidly, compared against baselines including personalized FL models. We conjecture that this is because, not only ours accurately identifies subgraphs forming the community and then shares weights largely across them for promoting the joint improvement of them, but also masking subgraph-irrelevant weights received from the server for localization to local subgraphs, demonstrated in the next two paragraphs.
+
+310 Accurate Community Detection We aim to show whether FED-PUB accurately groups subgraphs   
+311 comprising a community during weight aggregation. If two different subgraphs have many missing   
+312 edges or have similar label distributions, we usually regard those two as within the same commu  
+313 nity [35, 9, 34]. Thereby, as shown in Figure 6 (a) and (b), there are four different communities by the   
+314 interval of five, and the last two communities further comprise a larger community. Then, as shown   
+315 in Figure 6 (c) and (d), FED-PUB detects obvious four communities at the first few rounds, and then   
+316 captures the larger yet somewhat less-obvious community consisting of two smaller communities.   
+317 Ablation Study To analyze the contribution of each component, we conduct the ablation studies.   
+318 As shown in Figure 7, we observe that each of our subgraph similarity matching and weight masking   
+319 significantly improves the performances from the naive FedAvg, while the performance is much   
+320 improved when using both together. However, the benefit from each component is different across   
+321 overlapping and non-overlapping scenarios. In particular, in the former scenario where a group of   
+322 highly overlapped subgraphs usually comprise a community, similarity matching for community   
+323 detection is more beneficial since capturing the community would promote the joint improvement of   
+324 subgraphs belonging to the same community. However, in the non-overlapping scenarios, subgraphs   
+325 within the same community become lesser similar, thus selectively using the aggregated model   
+326 weights from the server with personalized weight masks improves the performance a lot.   
+327 Communication Efficiency Another notable advantage of using the sparse masks is that we can   
+328 reduce the communication costs at every FL round, as well as the model size for faster training, which   
+329 we demonstrate in Table 8. In particular, Table 8 shows that existing subgraph FL methods require   
+330 more than two times larger communications costs, measured by adding both the client-to-server and   
+331 server-to-client costs, compared against the naive FedAvg, since they require to transfer additional   
+332 node information between clients for estimating the probable nodes on the subgraphs. Contrarily, our   
+333 FED-PUB has significantly lower communication costs and lower model sizes by using the sparse   
+334 masks on the model weights: transmitting and training with only the partial parameters not sparsified   
+335 at the client. Further, as shown in ours variants in Table 8, we can manage the trade-off between the   
+336 model sparsity and the performance by controlling the hyperparameter for sparsity regularization, $\lambda _ { 1 }$   
+337 Varying Local Epochs As shown in Figure 9, when we increase the number of communication   
+338 rounds and the local steps, the model diverges to the local subgraphs (i.e., overfitting), due to the   
+339 small number of training instances and the direct connection between training and test nodes: struggle   
+340 to generalize to the test instances. However, our model with the proximal term in equation 5 alleviates   
+341 this issue, therefore, maintaining the highest local performance. Notably, the performance with five   
+342 local epochs is inferior to the performance of one epoch, which indicates that increasing the local   
+343 epochs does not always bring advantages and properly tuning them is important for subgraph FL.
+
+![](images/d50d23a02a73932c5018e430df053078c834c13bc32fa335fda5ed03911737d2.jpg)  
+Figure 6: The heatmaps of the community structure on the overlap- Figure 7: Ablation studies of our FEDping node scenario with Cora (20 clients). Dark color indicates lots PUB on both the overlapping (a) and nonof missing edges between subgraphs (a) or high similarities in labels overlapping (b) subgraph scenarios, on (b). (c) and (d) are functional similarities captured by our FED-PUB. the Cora dataset.
+
+<table><tr><td>Model</td><td>Acc.[%]</td><td>Model Size[%]</td><td>Cost[%]</td></tr><tr><td>FedAvg</td><td>76.48 ± 0.36</td><td>100.00 ±0.00</td><td>100.00 ± 0.00</td></tr><tr><td>FedGNN</td><td>70.63±0.83</td><td>100.00 ± 0.00</td><td>214.94 ± 0.00</td></tr><tr><td>FedSage+</td><td>77.52 ±0.46</td><td>100.00 ±0.00</td><td>276.84 ± 0.00</td></tr><tr><td>GCFL</td><td>78.84 ±0.26</td><td>100.00 ±0.00</td><td>100.00 ±0.00</td></tr><tr><td>Ours (λ1=9e-1)</td><td>77.36± 0.99</td><td>25.13±0.34</td><td>37.70 ± 0.56</td></tr><tr><td>Ours (λi=7e-1)</td><td>79.46 ± 0.41</td><td>42.59 ± 1.33</td><td>63.89 ± 1.99</td></tr><tr><td>Ours (λ1=5e-1)</td><td>79.89 ±0.12</td><td>57.07±0.52</td><td>85.61 ±0.78</td></tr></table>
+
+![](images/d1d90d5336310f4473d0900cd248200584551f59aefa0d0859a49adea0c7e943.jpg)  
+Figure 8: Analysis on efficiencies of communication costs and model sizes.   
+Figure 9: Varying the local epochs with accuracy curves.
+
+![](images/8e16664a83a34cb86e5b057dc70e981031573146658664e253b23cde5859065f.jpg)  
+Figure 10: Performance on neighboring subgraphs.
+
+Handling Missing Edges To measure whether FED-PUB can handle the missing edge problem: information is not shared between two neighboring subgraphs due to the missing edges, we use the local model trained on the local subgraph for evaluating the performance on its neighboring subgraph, in which the local subgraph has the most missing edges to its neighboring subgraph. Specifically, in Figure 10, (Neighbor) denotes the subgraph performance evaluated by its neighbor model, while (Local) denotes the subgraph performance from its own local model. Then, the high performance on (Neighbor) measure means two associated subgraphs share meaningful knowledge without having explicit edges between them, thereby solving the missing edge problem. Note that, existing subgraph FL explicitly augments the nodes and edges for capturing the potential information flow over the missing edges between subgraphs, while ours implicitly shares weights a lot across similar subgraphs within the same community. Figure 10 shows that ours achieves the significantly superior performance on the neighboring subgraph problem against subgraph FL baselines, which confirms that ours has an advantage on the missing edge problem by meaningfully sharing knowledge between two subgraphs having potentially missing edges, without explicitly estimating them.
+
+# 6 Conclusion
+
+359 We introduced a novel problem of personalized subgraph FL, which focuses on the joint improvement   
+360 of local GNNs working on interrelated subgraphs (e.g. subgraphs belonging to the same community),   
+361 by selectively utilizing knowledge from other models. The proposed personalized subgraph FL is   
+362 highly challenging due to 1) difficulty of computing similarities between local subgraphs that are   
+363 only locally accessible, and 2) knowledge collapse among local models that work on heterogeneous   
+364 subgraphs during weight aggregation. To this end, we proposed a novel personalized subgraph FL   
+365 framework, referred to as FEDerated Personalized sUBgraph learning (FED-PUB), which computes   
+366 the similarities across subgraphs using functional embeddings of their local GNNs on random graphs,   
+367 and uses them to perform a weighted average of the local models for each client. Further, we mask out   
+368 globally given weights to focus on only the relevant subnetwork for each client (or community). We   
+369 extensively validated our framework on multiple benchmark datasets with both overlapping and non  
+370 overlapping subgraphs, on which our FED-PUB significantly outperforms relevant baselines. Further   
+371 analyses show the effectiveness of the subgraph similarity matching for detecting the community   
+372 structures, as well as the weight masking for tackling the subgraph heterogeneity. We provide the   
+373 limitations and potential societal impacts of our work in Section D of the supplementary file.
+
+374 References [1] Martin Abadi, Andy Chu, Ian Goodfellow, H Brendan McMahan, Ilya Mironov, Kunal Talwar, and Li Zhang. Deep learning with differential privacy. In Proceedings of the 2016 ACM SIGSAC conference on computer and communications security, pages 308–318, 2016. [2] Manoj Ghuhan Arivazhagan, Vinay Aggarwal, Aaditya Kumar Singh, and Sunav Choudhary. Federated learning with personalization layers, 2019. [3] Jinheon Baek, Minki Kang, and Sung Ju Hwang. Accurate learning of graph representations with graph multiset pooling. In 9th International Conference on Learning Representations, ICLR 2021, Virtual Event, Austria, May 3-7, 2021, 2021. [4] Richard Bellman. Dynamic programming. Science, 153(3731):34–37, 1966. [5] Vincent D Blondel, Jean-Loup Guillaume, Renaud Lambiotte, and Etienne Lefebvre. Fast unfolding of communities in large networks. Journal of statistical mechanics: theory and experiment, 2008(10):P10008, 2008. [6] Fengwen Chen, Guodong Longr, Zonghan Wu, Tianyi Zhou, and Jing Jiang. Personalized federated learning with structure. arXiv preprint arXiv:2203.00829, 2022. [7] Laxman Dhulipala, Igor Kabiljo, Brian Karrer, Giuseppe Ottaviano, Sergey Pupyrev, and Alon Shalita. Compressing graphs and indexes with recursive graph bisection. In Proceedings of the 22nd ACM SIGKDD International Conference on Knowledge Discovery and Data Mining, San Francisco, CA, USA, August 13-17, 2016, pages 1535–1544. ACM, 2016. [8] Justin Gilmer, Samuel S. Schoenholz, Patrick F. Riley, Oriol Vinyals, and George E. Dahl. Neural message passing for quantum chemistry. In Proceedings of the 34th International Conference on Machine Learning, ICML 2017, Sydney, NSW, Australia, 6-11 August 2017, volume 70 of Proceedings of Machine Learning Research, pages 1263–1272. PMLR, 2017. [9] M. Girvan and M. E. J. Newman. Community structure in social and biological networks. Proceedings of the National Academy of Sciences, 99(12):7821–7826, 2002. [10] William L. Hamilton. Graph representation learning. Synthesis Lectures on Artificial Intelligence and Machine Learning, 14(3):1–159. [11] William L. Hamilton, Zhitao Ying, and Jure Leskovec. Inductive representation learning on large graphs. In Advances in Neural Information Processing Systems 30: Annual Conference on Neural Information Processing Systems 2017, December 4-9, 2017, Long Beach, CA, USA, pages 1024–1034, 2017.   
+405 [12] David K. Hammond, Pierre Vandergheynst, and Rémi Gribonval. Wavelets on graphs via spectral graph theory. Applied and Computational Harmonic Analysis, 30(2):129–150, 2011. [13] Chaoyang He, Keshav Balasubramanian, Emir Ceyani, Carl Yang, Han Xie, Lichao Sun, Lifang He, Liangwei Yang, Philip S Yu, Yu Rong, et al. Fedgraphnn: A federated learning system and benchmark for graph neural networks. arXiv preprint arXiv:2104.07145, 2021. [14] Chaoyang He, Emir Ceyani, Keshav Balasubramanian, Murali Annavaram, and Salman Avestimehr. Spreadgnn: Serverless multi-task federated learning for graph neural networks. AAAI, 2022.   
+413 [15] Paul W. Holland, Kathryn Blackmond Laskey, and Samuel Leinhardt. Stochastic blockmodels: First steps. Social Networks, 5(2):109–137, 1983. ISSN 0378-8733.   
+415 [16] Weihua Hu, Matthias Fey, Marinka Zitnik, Yuxiao Dong, Hongyu Ren, Bowen Liu, Michele Catasta, and Jure Leskovec. Open graph benchmark: Datasets for machine learning on graphs. Advances in neural information processing systems, 33:22118–22133, 2020.   
+418 [17] Wonyong Jeong, Hayeon Lee, Geon Park, Eunyoung Hyung, Jinheon Baek, and Sung Ju Hwang. Task-adaptive neural network search with meta-contrastive learning. In Advances in Neural Information Processing Systems, 2021. [18] Jaehyeong Jo, Jinheon Baek, Seul Lee, Dongki Kim, Minki Kang, and Sung Ju Hwang. Edge representation learning with hypergraphs. In M. Ranzato, A. Beygelzimer, Y. Dauphin, P.S. Liang, and J. Wortman Vaughan, editors, Advances in Neural Information Processing Systems, volume 34, pages 7534–7546. Curran Associates, Inc., 2021. [19] Sai Praneeth Karimireddy, Satyen Kale, Mehryar Mohri, Sashank J. Reddi, Sebastian U. Stich, and Ananda Theertha Suresh. SCAFFOLD: stochastic controlled averaging for federated learning. In Proceedings of the 37th International Conference on Machine Learning, ICML 2020, 13-18 July 2020, Virtual Event, volume 119 of Proceedings of Machine Learning Research, pages 5132–5143. PMLR, 2020. [20] George Karypis and Vipin Kumar. Metis – unstructured graph partitioning and sparse matrix ordering system, version 2.0. Technical report, 1995. [21] Diederik P. Kingma and Jimmy Ba. Adam: A method for stochastic optimization. In 3rd International Conference on Learning Representations, ICLR 2015, San Diego, CA, USA, May 7-9, 2015, Conference Track Proceedings, 2015. [22] Thomas N. Kipf and Max Welling. Semi-supervised classification with graph convolutional networks. In 5th International Conference on Learning Representations, ICLR 2017, Toulon, France, April 24-26, 2017, Conference Track Proceedings, 2017.   
+38 [23] Jure Leskovec, Lada A. Adamic, and Bernardo A. Huberman. The dynamics of viral marketing. ACM Trans. Web, 1(1):5, 2007. [24] Qinbin Li, Bingsheng He, and Dawn Song. Model-contrastive federated learning. In IEEE Conference on Computer Vision and Pattern Recognition, CVPR 2021, virtual, June 19-25, 2021, pages 10713–10722. Computer Vision Foundation / IEEE, 2021.   
+43 [25] Tian Li, Anit Kumar Sahu, Manzil Zaheer, Maziar Sanjabi, Ameet Talwalkar, and Virginia Smith. Federated optimization in heterogeneous networks. In Proceedings of Machine Learning and Systems 2020, MLSys 2020, Austin, TX, USA, March 2-4, 2020. mlsys.org, 2020. [26] Paul Pu Liang, Terrance Liu, Liu Ziyin, Nicholas B. Allen, Randy P. Auerbach, David Brent, Ruslan Salakhutdinov, and Louis-Philippe Morency. Think locally, act globally: Federated learning with local and global representations, 2020.   
+49 [27] Tao Lin, Lingjing Kong, Sebastian U Stich, and Martin Jaggi. Ensemble distillation for robust model fusion in federated learning. Advances in Neural Information Processing Systems, 33: 2351–2363, 2020.   
+52 [28] Zhiwei Liu, Liangwei Yang, Ziwei Fan, Hao Peng, and Philip S Yu. Federated social recommendation with graph neural network. arXiv preprint arXiv:2111.10778, 2021.   
+454 [29] Disha Makhija, Xing Han, Nhat Ho, and Joydeep Ghosh. Architecture agnostic federated learning for neural networks. arXiv preprint arXiv:2202.07757, 2022. [30] Yishay Mansour, Mehryar Mohri, Jae Ro, and Ananda Theertha Suresh. Three approaches for personalization with applications to federated learning, 2020. [31] Julian McAuley, Christopher Targett, Qinfeng Shi, and Anton Van Den Hengel. Image-based recommendations on styles and substitutes. In Proceedings of the 38th international ACM SIGIR conference on research and development in information retrieval, pages 43–52, 2015. [32] H. Brendan McMahan, Eider Moore, Daniel Ramage, Seth Hampson, and Blaise Agüera y Arcas. Communication-efficient learning of deep networks from decentralized data. In AISTATS, 2017. [33] Miller McPherson, Lynn Smith-Lovin, and James M Cook. Birds of a feather: Homophily in social networks. Annual review of sociology, 27(1):415–444, 2001.   
+465 [34] Mason A Porter, Jukka-Pekka Onnela, Peter J Mucha, et al. Communities in networks. Notices of the AMS, 56(9):1082–1097, 2009.
+
+[35] Filippo Radicchi, Claudio Castellano, Federico Cecconi, Vittorio Loreto, and Domenico Parisi. Defining and identifying communities in networks. Proceedings of the national academy of sciences, 101(9):2658–2663, 2004. [36] José J. Ramasco, S. N. Dorogovtsev, and Romualdo Pastor-Satorras. Self-organization of collaboration networks. Phys. Rev. E, 70:036106, Sep 2004. [37] Felix Sattler, Klaus-Robert Müller, and Wojciech Samek. Clustered federated learning: Modelagnostic distributed multitask optimization under privacy constraints. IEEE transactions on neural networks and learning systems, 32(8):3710–3722, 2020. [38] Felix Sattler, Tim Korjakow, Roman Rischke, and Wojciech Samek. Fedaux: Leveraging unlabeled auxiliary data in federated learning. IEEE Transactions on Neural Networks and Learning Systems, 2021. [39] Prithviraj Sen, Galileo Namata, Mustafa Bilgic, Lise Getoor, Brian Galligher, and Tina EliassiRad. Collective classification in network data. AI magazine, 29(3):93–93, 2008. [40] Oleksandr Shchur, Maximilian Mumme, Aleksandar Bojchevski, and Stephan Günnemann. Pitfalls of graph neural network evaluation. arXiv preprint arXiv:1811.05868, 2018. [41] Hongyi Wang, Mikhail Yurochkin, Yuekai Sun, Dimitris Papailiopoulos, and Yasaman Khazaeni. Federated learning with matched averaging. In International Conference on Learning Representations, 2020. [42] Chuhan Wu, Fangzhao Wu, Yang Cao, Yongfeng Huang, and Xing Xie. Fedgnn: Federated graph neural network for privacy-preserving recommendation. KDD, 2021. [43] Zonghan Wu, Shirui Pan, Fengwen Chen, Guodong Long, Chengqi Zhang, and Philip S. Yu. A comprehensive survey on graph neural networks. IEEE Trans. Neural Networks Learn. Syst., 32 (1):4–24, 2021. [44] Han Xie, Jing Ma, Li Xiong, and Carl Yang. Federated graph classification over non-iid graphs. In Advances in Neural Information Processing Systems, volume 34, pages 18839–18852. Curran Associates, Inc., 2021. [45] Ke Zhang, Carl Yang, Xiaoxiao Li, Lichao Sun, and Siu Ming Yiu. Subgraph federated learning with missing neighbor generation. In Advances in Neural Information Processing Systems, volume 34, pages 6671–6682. Curran Associates, Inc., 2021. [46] Michael Zhang, Karan Sapra, Sanja Fidler, Serena Yeung, and Jose M. Alvarez. Personalized federated learning with first order model optimization. In International Conference on Learning Representations, 2021. [47] Muhan Zhang and Yixin Chen. Link prediction based on graph neural networks. In Advances in Neural Information Processing Systems 31: Annual Conference on Neural Information Processing Systems 2018, NeurIPS 2018, December 3-8, 2018, Montréal, Canada, pages 5171–5181, 2018. 503 [48] Jie Zhou, Ganqu Cui, Shengding Hu, Zhengyan Zhang, Cheng Yang, Zhiyuan Liu, Lifeng Wang, Changcheng Li, and Maosong Sun. Graph neural networks: A review of methods and applications. AI Open, 1:57–81, 2020. [49] Zhuangdi Zhu, Junyuan Hong, and Jiayu Zhou. Data-free knowledge distillation for heterogeneous federated learning. In International Conference on Machine Learning, pages 12878–12889. PMLR, 2021.
+
+1. For all authors...
+
+(a) Do the main claims made in the abstract and introduction accurately reflect the paper’s contributions and scope? [Yes]   
+(b) Did you describe the limitations of your work? [Yes] We discuss them in Section D of the supplementary file.   
+(c) Did you discuss any potential negative societal impacts of your work? [Yes] We discuss them in Section D of the supplementary file.   
+(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] We provide the code, data, and instructions in the supplementary material.   
+(b) Did you specify all the training details (e.g., data splits, hyperparameters, how they were chosen)? [Yes] We specify all the training details in Section B of the supplementary file.   
+(c) Did you report error bars (e.g., with respect to the random seed after running experiments multiple times)? [Yes] We report the main results with mean and standard deviations, with multiple runs.   
+(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] We include the computational costs and resources in Section B of the supplementary file.
+
+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? [N/A]   
+(c) Did you include any new assets either in the supplemental material or as a URL? [N/A]   
+(d) Did you discuss whether and how consent was obtained from people whose data you’re using/curating? [N/A]   
+(e) Did you discuss whether the data you are using/curating contains personally identifiable information or offensive content? [N/A]
+
+5. If you used crowdsourcing or conducted research with human subjects...
+
+(a) Did you include the full text of instructions given to participants and screenshots, if applicable? [N/A]   
+(b) Did you describe any potential participant risks, with links to Institutional Review Board (IRB) approvals, if applicable? [N/A]   
+(c) Did you include the estimated hourly wage paid to participants and the total amount spent on participant compensation? [N/A]

parse/dev/tZXaHWfsXB/tZXaHWfsXB.md

@@ -0,0 +1,376 @@
+# Transcending Scaling Laws with $0 . 1 \%$ Extra Compute
+
+Yi Tay† Jason Wei† Hyung Won Chung† Vinh Q. Tran David R. $\mathbf { S _ { 0 } } _ { } ^ { \dagger }$ Siamak Shakeri Xavier Garcia Huaixiu Steven Zheng Jinfeng Rao† Aakanksha Chowdhery Denny Zhou Donald Metzler Slav Petrov Neil Houlsby Quoc V. Le Mostafa Dehghani Google {vqtran,dehghani}@google.com
+
+# Abstract
+
+Scaling language models improves performance but comes with significant computational costs. This paper proposes UL2R, a method that substantially improves existing language models and their scaling curves with a relatively tiny amount of extra compute. The key idea is to continue training a state-of-theart large language model on a few more steps with UL2’s mixture-of-denoiser objective. We show that, with almost negligible extra computational costs and no new sources of data, we are able to substantially improve the scaling properties of large language models on downstream metrics. In this paper, we continue training a baseline language model, PaLM, with UL2R, introducing a new set of models at 8B, 62B, and 540B scale which we call UPaLM. Impressively, at 540B scale, we show an approximately 2x computational savings rate where U-PaLM achieves the same performance as the final PaLM 540B model at around half its computational budget (i.e., saving ${ \sim } 4 . 4$ million TPUv4 hours). We further show that this improved scaling curve leads to “emergent abilities” on challenging BIG-Bench tasks—for instance, U-PaLM does much better on some tasks or demonstrates better quality at much smaller scale (62B as opposed to 540B). Overall, we show that U-PaLM outperforms PaLM on many few-shot setups, including reasoning tasks with chain-of-thought (e.g., GSM8K), multilingual tasks (MGSM, TydiQA), MMLU and challenging BIG-Bench tasks.
+
+# 1 Introduction
+
+There has been significant interest in scaling of language models [Rae et al., 2021, Chowdhery et al., 2022, Brown et al., 2020]. Scaling has inspired new research across multiple fronts, e.g., scaling laws [Kaplan et al., 2020, Hoffmann et al., 2022, Tay et al., 2022a], emergent abilities [Wei et al., 2022a, Ganguli et al., 2022], reasoning capabilities [Wei et al., 2022b, Lewkowycz et al., 2022], inter alia. Generally, scaling laws predict a continued improvement in language model quality as we continue to scale up the computational budget (e.g., bigger models or more data). To date, most large language models that form the basis of scaling law research are trained almost exclusively as left-to-right causal language models [Kaplan et al., 2020, Hoffmann et al., 2022].
+
+![](images/dba9c2509b52640057f41a29191caed53155bc95d61b08546cc4068d75bdc7d9.jpg)  
+Figure 1: Compute (training flops) versus Quality (average of $^ { 2 0 + }$ NLP zero and few-shot tasks listed in Appendix 11.2). The black dotted line shows the path from initialization from a PaLM checkpoint and training further with UL2R.
+
+This paper proposes a new method to dramatically improve the scaling curves of large language models on downstream performance with a relatively tiny amount of additional computation cost. The key idea is to continue training an existing causal language model [Chowdhery et al., 2022] with a mixture of new objectives—specifically, the UL2 training objective mixture [Tay et al., 2022b]. This restoration is expected to only cost roughly $0 . 1 \%$ to $1 \%$ of the original training FLOPs and requires no new data sources, making it highly efficient and convenient. We call this approach UL2R or UL2Restore.
+
+The UL2 objective combines prefix language modeling and long-short span corruption (e.g., infilling) tasks [Raffel et al., 2019] that can be controlled at inference time using a mode switching prompt. Training a large language model with UL2 can be interpreted as teaching it to leverage bidirectional attention (i.e., PrefixLM) or leverage infilling-style pretraining that have been the foundation of language understanding (e.g., T5 [Raffel et al., 2019]). To this end, we postulate that imbuing a state-of-theart large language model such as PaLM [Chowdhery et al., 2022] with these diverse pretraining schemes as a complement to the original language model objective, enables the model to perform significantly better. Moreover, the UL2 objective enables new prompting capabilities in PaLM which allows it to perform infilling based prompting.
+
+We show that adapting PaLM with UL2R not only results in significantly better scaling laws on well-established few-shot NLP tasks, but also, in our scaling experiments on downstream few-shot tasks, we show that UL2R is two times more efficient (computation savings of approximately 2x) at 540B scale - reaching the performance of the final PaLM 540B model with only half the computation, saving up to 4.4 million TPUv4 hours.
+
+In addition to competitive performance across a range of well-established NLP [Wang et al., 2019], multilingual [Clark et al., 2020a, Shi et al., 2022], and reasoning [Cobbe et al., 2021] benchmarks, we also study the impact of UL2R on a suite of challenging BigBench tasks from Wei et al. [2022a]. Notably, a subset of tasks are described as ‘emergent‘ because PaLM’s performance remains flat up to model scale of 62B and only becomes better than non-random at 540B scale. On these set of tasks, we find that UL2R enables (1) doing significantly better at tasks that PaLM struggles at (e.g., navigate, geometric shapes, hyperbaton) and (2) elicits emergent behavior at a smaller scale such as 62B or 8B (e.g., crass ai, vitaminc fact verification). On top of that, U-PaLM strongly outperforms PaLM on some challenging BigBench tasks.
+
+Emergence within the context of large language models is a nascent research area. As the Nobel prize-winning physicist Philip Anderson put it, ‘More is different.‘ [Anderson, 1972] which describes unpredictable phenomena at different scales. In our context and with mixture-of-denoisers in UL2, we would like to think of this phenomena as ‘More is different, but different can also more’ since different pretraining objectives can improve language model quality or elicit new emergent abilities. This work shows that diversity and richer training paradigms can be key to learning new capabilities that were previously hard to acquire with only causal language modeling.
+
+Finally, in addition to emergent task performance and overall improved scaling curves, we show that U-PaLM is also practically more useful since it is equipped with a secondary mode of prompting, i.e., bidirectional infilling. Specifically, UL2R enables a secondary capability for prompting U-PaLM which can be used to fill in more than one blanks in the input prompt. Interestingly, we find that only a small amount of UL2R (e.g., $0 . 1 \%$ tokens or FLOPs) is sufficient to imbue the model with this new capability.
+
+# 2 U-PaLM
+
+This section introduces the technical details of UPaLM (i.e., $\mathbf { P a L M + U L 2 R }$ ). U-PaLM is initialized from PaLM and leverages the same architecture. This section describes the training procedures of UL2R and how they are applied to continue training PaLM. We refer the reader to Section 10 in the Appendix for a comprehensive review of related work.
+
+# 2.1 Training Data
+
+To keep things consistent, we train this model with the same data mixture as PaLM and do not rely on additional sources of data (labeled or unlabeled).
+
+There are three main reasons for this choice. Firstly, we did not want to introduce new tokens to our training process which could conflate findings. Secondly, we did not want to over-index on scaling studies that only measure impact on upstream cross entropy [Hernandez et al., 2022] which claims that repeating data in small quantities could be dis-proportionally harmful. Since the empirical results we obtained are strong, we postulate that repeating tokens could perhaps be not harmful at smaller quantities after all. This is also backed by the continued training of PaLM 62B in [Chowdhery et al., 2022] which showed that repeated data could result in small gains, albeit not as strong as fresh tokens. Thirdly, we consider our data transformation (via UL2) on the training data sufficiently unique and therefore prevents us from explicitly training on the same data with the exact objective or suffering from any memorization issues.
+
+# 2.2 Prefix Language Model Architecture
+
+We train U-PaLM using the prefix language model (PrefixLM) architecture, also sometimes known as a non-causal decoder-only model. The PrefixLM architecture keeps a non-causal mask in its prefix (or inputs) and applies bidirectional attention to input tokens.
+
+In this architecture, we use a total combined sequence length of 2048 (e.g., PaLM’s sequence length) which is then split to 1024 inputs and 1024 targets. In the original UL2 paper and infrastructure, an artifact of its preprocessing pipeline applies padding tokens first before combining inputs and targets. For decoder-only language models, this is inefficient since we would end up with a concatenation of [prefix] [prefix’s padding] [target].
+
+In this work, we optimize the Prefix padding by forcing the model to concatenate prefix and target before applying any additional padding. Packing, trimming and padding is then subsequently applied later after the prefix has been concatenated with the targets. Through this prefix optimization, we are able to improve example-level sample efficiency of the model.
+
+# 2.3 Loss Objectives
+
+This section describes the setting for the UL2 mixture-of-denoisers that we use in UL2R. The UL2 mixture-of-denoiser objective comprises of three types of denoisers.
+
+• Regular denoising whereby the noise is sampled as spans, replaced with sentinel tokens. This is also the standard span corruption task used in Raffel et al. [2019]. Spans are typically uniformly sampled with a mean of 3 and a corruption rate of $1 5 \%$ .
+
+• Extreme denoising whereby the noise is increased to relatively ‘extreme‘ amounts in either a huge percentage of the original text or being very long in nature. Spans are typically uniformly sampled with a mean length of $\mathbf { 3 2 0 R }$ a corruption rate of up to $5 0 \%$ .
+
+• Sequential denoising whereby the noise is always sampled from the start of the text to a randomly sampled point in the text. This is also known as the PrefixLM objective (not to be confused with the architecture).
+
+We kept this simple since many ablations were already explored in Tay et al. [2022b]. We kept the original 7 denoisers as the initial version but later found that a mixture of only three tasks, e.g., $5 0 \%$ PrefixLM, $2 5 \%$ Long (extreme) span corruption, and $2 5 \%$ regular span corruption to be quite simple and efficient for the setup of continued training. We kept the original mode prompting tokens in the original UL2 design. We used [S2S] for S-denoisers (PrefixLM), [NLU] for R-denosiers and [NLG] for X-denoisers. The 540B U-PaLM model was mainly trained with $50 \%$ S-denoiser (PrefixLM), $25 \%$ R-denoisers, and $2 5 \%$ X-denoisers.
+
+# 2.4 Training
+
+We train the 540B model for a total of $2 0 \mathrm { k }$ steps with a batch size of 32. We mildly ablate these settings in early experiments with 62B and 8B models but keep them capped within a certain ballpark (e.g., 128 batch size for 50k steps). As a result, this is more similar to ‘finetuning’ as compared to full pretraining. The number of additional tokens is therefore very negligible compared to the original pretraining run often coming in at around or less than $0 . 1 \%$ additional compute. The total number of extra tokens we train on for the 540B model is approximately 1.3 billion which constitutes $0 . 1 6 \%$ extra computation, as the original PaLM model was pretrained on 780B tokens. We use a cosine learning rate decay schedule that anneals the learning rate from $1 0 ^ { - 4 }$ to $1 0 ^ { - 6 }$ . Notably, we also tried a low constant learning rate and found them to perform quite identically. Our U-PaLM 8B and 62B models are trained using 64 TPUv4 chips. Training an U-PaLM 540B model only consumes 512 TPUv4 chips and finishes in about 5 days which is considered to be lightweight.
+
+# 3 Experiments
+
+# 3.1 Improved Scaling Properties on Few-shot Learning
+
+In this experiment, we show improved scaling curves from small amounts of UL2R training on top of both PaLM 8B and PaLM 540B. We use downstream metrics and few-shot evaluation since (1) this is closer to usability of these models and (2) loss with UL2 and causal language modeling is not comparable. We initialized and trained multiple U-PaLM models using different PaLM intermediate checkpoints. On the 8B model, we repeated this 7 times at different intervals. Given that the 540B model was more computationally demanding, we only managed to fit 3 points. For evaluation, we use the average score of NLU and NLG tasks from the GPT-3 suite [Brown et al., 2020]. In total we use 26 tasks (e.g., TriviaQA, NaturalQuestions, SuperGLUE, PIQA, OpenbookQA, ANLI etc). Detailed scores for Figure 2 can be found in the Appendix.
+
+![](images/af74d8103b8c8ed0e4bc33b4f832746eee305e4daccc1d0e525783b6e3590e96.jpg)  
+Figure 2: Computation cost (training flops) [Dehghani et al., 2021] versus Quality (average of $2 0 { + } \mathrm { N L P }$ zero and few-shot tasks). The dotted line shows the path from initialization from a PaLM checkpoint and training further with UL2R. These plots also present pairs of PaLM and U-PaLM models with comparable/similar performance along with the ratio of PaLM computation cost vs the corresponding U-PaLM computation cost. For example, PaLM 540B trained for $\sim 2 5 0 0$ zFLOPs (right most point) took $\sim 2 . 3 5$ times of the computation cost of U-PaLM 540B trained for $\sim 1 0 7 5$ zFLOPs, while both models are comparable in terms of performance on zero/few shot on NLP tasks.
+
+![](images/0fc73e3f4457bc5c1db632d1ff0cd54a420f6e70a8eeb9154d72e431628c7336.jpg)  
+Figure 3: Break down scores of individual zero-shot and one-shot NLP tasks for PaLM and U-PaLM 540B trained for 780B tokens. U-PaLM outperforms PaLM 540B and achieves SOTA on 21 out of 26 tasks.
+
+Figure 2 shows that U-PaLM substantially outperforms the original PaLM models both at 8B scale and 540B scale. Note that the dotted lines represent a pathway before and after UL2R training, we show that UL2R training improves the scaling curve of PaLM substantially, i.e., UL2R provides a more compute-efficient performance improvement compared to training the original PaLM models for longer with the standard causal language modeling objective.
+
+8B versus 540B Generally, UL2R consistently improves the underlying PaLM models. Nevertheless, we observe different behaviors on the 8B and 540B models. The gap seems to narrow as the performance of PaLM 8B starts to plateau, i.e., the largest gains are near to the middle of training. As for 540B, the gain continues to grow even at 780B tokens. We believe that this is due to the fact that PaLM 540B still has significant headroom beyond 780B tokens.
+
+Savings Rate At a certain stage of training, we have an option to continue training for K more steps using the standard causal language modeling objective OR applying UL2R for a small amount of steps. Here we discuss the counterfactual savings rate of choosing UL2R as opposed to continue training with caussal language modeling. For the 540B model, the saving rates at the middle checkpoint is approximately $2 \mathbf { x }$ . This is equivalent to about 4.4 million TPUv4 hours for the 540B model. For the 8B model, the saving rate tend to be lowest at both the start and convergence of the model. It seems to be higher at middle stages of training (relative to convergence) which shows that the utility of UL2R changes with respect to the amount of causal language modeling training already done. For the 540B model, since the PaLM model was not trained to convergence and the number of tokens to parameters ratio is relatively low, the savings rate could still be increasing even beyond $2 . 3 5 \mathrm { x }$ . Overall, the amount of savings is quite proportionate to the point of training and stage of convergence of the model and can probably be predicted by standard scaling laws [Kaplan et al., 2020, Hoffmann et al., 2022].
+
+Table 1: List of challenging tasks in the BigBench emergent suite (BBES) and corresponding scores of PaLM 540B and U-PaLM 540B. All results are reported with standard 5-shot prompting.   
+
+<table><tr><td>task</td><td>task /reasoning type</td><td>PaLM540B</td><td>U-PaLM540B</td></tr><tr><td>navigate</td><td>arithmetic,logical</td><td>55.3</td><td>67.0 (+21.2%)</td></tr><tr><td>strategyqa</td><td>multi-step</td><td>73.9</td><td>78.3 (+6.0%)</td></tr><tr><td>crass_ai</td><td>commonsense</td><td>97.7</td><td>100 (+2.4%)</td></tr><tr><td>logical_sequence</td><td>commonsense</td><td>92.3</td><td>86.5 (-6.7%)</td></tr><tr><td>vitaminc_fact_verification</td><td>contextual, commonsense</td><td>70.2</td><td>73.9 (+5.3%)</td></tr><tr><td>understanding_fables</td><td>commonsense</td><td>75.7</td><td>78.4 (+3.6%)</td></tr><tr><td>identify_odd_metaphor</td><td>analogical</td><td>87.2</td><td>87.5 (+0.3%)</td></tr><tr><td>hyperbaton</td><td>contextual QA</td><td>54.2</td><td>59.9 (+10.5%)</td></tr><tr><td>causal_judgment</td><td>causal and commonsense</td><td>65.3</td><td>68.4 (+4.7 %)</td></tr><tr><td>english_proverbs</td><td>commonsense,contextual QA</td><td>91.2</td><td>87.5 (-4.2%)</td></tr><tr><td>geometric_shapes</td><td>algorithmic,visual</td><td>44.0</td><td>49.3 (+12.0%)</td></tr><tr><td>physics_questions</td><td>logical, physics,math</td><td>7.6</td><td>12.5 (+64.5%)</td></tr><tr><td>snarks</td><td>commmonsense</td><td>69.1</td><td>86.1 (+24.6%)</td></tr><tr><td>analogical_similarity</td><td>analogical</td><td>36.5</td><td>37.5 (+2.7%)</td></tr><tr><td>international_phonetic_alphabet_nli</td><td>reading comprehension</td><td>65.9</td><td>68.0 (+3.2%)</td></tr><tr><td>movie_dialog_same_or_different</td><td>commonsense,reading compre.</td><td>64.8</td><td>68.8 (+6.2%)</td></tr><tr><td>timedial</td><td>commonsense,logical</td><td>78.3</td><td>81.2 (+3.7%)</td></tr><tr><td>question_selection</td><td>reading comprehension</td><td>54.8</td><td>59.8 (+9.1%)</td></tr><tr><td>logical_fallacy_detection</td><td>logical reasoning</td><td>80.3</td><td>81.4 (+1.4%)</td></tr><tr><td>unit_interpretation</td><td>arithmetic,logical</td><td>47.0</td><td>51.0 (+8.5%)</td></tr><tr><td>language_identification</td><td>multilingual</td><td>36.0</td><td>38.9 (+8.1%)</td></tr><tr><td>average (21 tasks)</td><td></td><td>64.3</td><td>67.7 (+5.3%)</td></tr></table>
+
+![](images/3b70250d3efbf549c452ca75608b8fb9108764740be2b1511ac9df5402019406.jpg)  
+Figure 4: Scaling plots on BIG-Bench emergent suite (BBES) for different sizes of PaLM, U-PaLM, Gopher, and GPT-3 as a function of training FLOPs. Scores are normalized scores where zero denotes more or less random performance. X-axis is in log-scale.
+
+Breakdown on individual tasks Figure 3 reports the individual scores on each zero and one-shot task in the mixture. We show that U-PaLM 540B outperforms PaLM 540B on 21 out of 26 tasks. Given that PaLM is the SOTA language model on these tasks, this makes U-PaLM the new state-of-the-art on these tasks.
+
+# 3.2 BigBench Emergent Suite
+
+We select a suite of challenging tasks from BigBench based on a criterion that performance on PaLM on these tasks remain relatively flat-lined at 8B and 62B scale but suddenly unlocks at 540B. We also consider tasks that are difficult for PaLM 540B to solve (near random performance). We call these suite of tasks EMERGENT suite of BigBench tasks (BBES) as inspired by the criterion set by Wei et al. [2022a]. Note that while these set of tasks overlap but are not entirely identical to BBH [Suzgun et al., 2022]. Moreover, BBES uses the default prompting and templates as BIG-Bench and do not use chain-of-thought prompting. Hence, they are not entirely comparable. BBH results can be found later in section 11.1.3.
+
+Table 2: Results on finetuning on SuperGLUE and TydiQA dev sets.   
+
+<table><tr><td></td><td>PaLM 8B</td><td>U-PaLM8B</td><td>PaLM 62B</td><td>U-PaLM 62B</td></tr><tr><td>SuperGLUE (Avg)</td><td>83.4</td><td>86.1(+3.2%)</td><td>89.5</td><td>91.4 (+2.1%)</td></tr><tr><td>TydiQA (EM/F1)</td><td>75.7/85.2</td><td>77.5 (+2.3%)/86.7(+1.7%)</td><td>78.3/87.3</td><td>78.4 (+0.1%)/88.5 (+2.1%)</td></tr></table>
+
+Table 3: Results on Massively Multi-Task Language Understanding (MMLU) test set.   
+
+<table><tr><td>Method</td><td>Accuracy</td></tr><tr><td>Random</td><td>25.0%</td></tr><tr><td>Average Human Rater</td><td>34.5%</td></tr><tr><td>GPT-3 5-shot</td><td>43.9%</td></tr><tr><td>Gopher 5-shot</td><td>60.0%</td></tr><tr><td>Chinchilla 5-shot</td><td>67.6%</td></tr><tr><td>PaLM540B 5shot U-PaLM540B 5-shot</td><td>69.3 % 70.7 % (+2.0%)</td></tr></table>
+
+# 3.2.1 BIG-Bench Results
+
+Table 1 reports the results of PaLM 540B and U-PaLM 540B on the BigBench emergent suite. We also describe the task and reasoning task for each task. Note that some tasks require a conjunction of various ‘skills’ to excel at. For example, the navigate task is a combination of spatial reasoning and arithmetic (counting).
+
+Overall results and Scaling Plots We observe that U-PaLM outperforms PaLM on 19 out of the 21 tasks at 540B scale. Moreover, the gains on certain tasks are substantial (e.g., $5 5 . 3 \% \to 6 7 . 0 \%$ ) on navigate and $6 9 . 1 \% \to 8 6 . 1 \%$ on snarks). On average, there is a $+ 5 . 4 \%$ relative quality gain on the un-normalized aggregated average across all 21 tasks which we consider to be pretty strong results. Figure 4 which shows the scaling plots of U-PaLM relative to other models. Whenever possible, we also include baselines such as GPT-3 or Gopher from the official BIG-Bench repository.
+
+UL2R unlocks emergent task performance at smaller scales Scale (e.g., scaling to 540B) is known to be one factor that results in emergent task performance [Wei et al., 2022a]. We show that UL2R is able to elicit emergent abilities at smaller scales. For example, the quality on certain tasks such as crass_ai, vitaminc, identify_odd_metaphors are tasks where performance starts to spike at 62B scale (as opposed to only at 540B with the PaLM model. In rarer occasions, the performance of U-PaLM 8B is even higher than PaLM 62B (e.g., snarks, understanding_fables). Overall, these results show that there are strong evidence that inductive bias (e.g., combinations of prefix language modeling, span corruption based pretraining in UL2) could be crucial when it comes to unraveling new abilities in large language models.
+
+# 3.2.2 MMLU Results
+
+We compare PaLM and U-PaLM on the Massively Multi-Task Language Understanding (MMLU) benchmark [Hendrycks et al., 2020]. Table 3 reports our results on MMLU’s test set. Prior results are reported from [Hoffmann et al., 2022]. Our results show that U-PaLM outperforms PaLM on this task in the 5-shot setup by $2 . 0 \%$ relative gain.
+
+# 3.3 Finetuning
+
+We conduct experiments on SuperGLUE [Wang et al., 2019] and TydiQA [Clark et al., 2020a] finetuning. We conduct experiments at 8B and 62B scale1. Fine-tuning is conducted with a constant learning rate for $1 0 0 k$ steps with a batch size of 32. Table 2 reports finetuning results. We observe that there is substantial improvement in fine-tuning especially at the 8B scale. The gains diminish slightly at 62B scale but are still modest in general. We note that PaLM’s fine-tuning performance can be generally considered weaker than expected. For instance, PaLM 8B is generally outperformed by a T5.1.1 large model on the SuperGLUE dev average. We postulate that training PaLM on UL2 and span corruption tasks in complement to causal language modeling can ameliorate some of its flaws. Our results ascertains this by showing that U-PaLM strongly improves quality especially at smaller (8B) scales.
+
+![](images/7f4b18317cb8a03354610336885d5ab9f3be72ee5201369d172de11c25f033db.jpg)  
+Figure 5: An example of a prompt that is improved by rephrasing to use U-PaLM’s infilling capabilities.
+
+# 3.4 Additional Results & Analysis
+
+We conduct additional, extensive, evaluation and analysis of our approach. Due to space constraints we refer the reader to Section 11 in the Appendix. There we provide results for zero-shot and few-shot NLP tasks including commonsense reasoning, closed book QA & reading comprehension, reasoning & chain-of-thought, and few-shot multilingual tasks. We find that the improvements from U-PaLM over PaLM generally hold across these additional tasks, with major improvements on certain tasks such as GSM8K $( + 6 . 6 \% )$ [Cobbe et al., 2021], BIG-Bench Hard $( + 1 0 . 7 \% )$ [Suzgun et al., 2022], and MGSM $( + 8 . 7 \% )$ [Shi et al., 2022]. We also include analysis of BBES performance, scaling curves for few-shot experiments, and additional discussion of our methods.
+
+in. Notably, with U-PaLM it is possible to query both the infill style and the traditional style via the usage of extra ID tokens (as it is used in denoising) or without, respectively.
+
+In Figure 5, we include example outputs for PaLM, U-PaLM with traditional prompting, as well as U-PaLM with infill prompting. We phrase this particular prompt in two ways: one as a question that is suitable for traditional prompting via PaLM and one leveraging U-PaLM’s infill capabilities. In the traditional phrasing, both PaLM and U-PaLM do not produce the correct answer. With the infill phrasing, PaLM ignores the infill token (extra ID token) as PaLM has not seen it during training, and instead produces the rest of the steps after step 4. U-PaLM correctly infills the second step in this example. Finally, a third example is included to demonstrate U-PaLM’s ability to infill multiple slots. These examples demonstrate that, with only a small amount of additional training, we are able to expand the functionality of PaLM to serve an entirely new class of queries.
+
+# 4 Qualitative Analysis: New Prompting Capabilities
+
+# 4.1 Infilling Ability
+
+Left-to-right casual language model pretraining has typically allowed models to provide meaningful continuations of prompts. With U-PaLM we observe that, by extending pretraining with a small amount of UL2 denoising steps, the model is also able to pick up infilling abilities – where the model is given a location in the middle of a prompt to fill
+
+# 4.2 Leveraging Specific Pretraining Modes
+
+Recall that via the UL2 objective, R-, X-, and S-denoisers are associated with the [NLU], [NLG], and [S2S] mode tokens respectively. S-denoisers are essentially the PrefixLM objective, while R- and X-denoisers are variations of span corruption, and thus are also associated with extra ID tokens which we can use during prompting for infill (as shown above.) Given this unique setup, we can control the mode token during inference to gain access to specific knowledge that might have been acquired in one mode but not another. This effectively provides us with more options in how to answer prompts, without the need to make any changes to the learned model or its inference algorithm.
+
+![](images/19273124304d46ecdd635cea5dd1a670fecb9344d5d8e956858e4531fbe81053.jpg)  
+Figure 6: An example of a prompt that works only when querying a specific pretraining mode.
+
+![](images/f4d4819fcf623cb3609db28699e717f8ec88e7e4122b8328a736535eeee95fec.jpg)  
+Figure 7: Querying U-PaLM for diverse outputs by using different prompt mode token and LM/infill combinations.
+
+In Figure 6, we include a challenging example where we ask the model to do zero-shot cross-lingual question answering from an English question into a Vietnamese answer. For PaLM and U-PaLM default, we pass the input as-is to the model. For the rest, we prepend one of [S2S], [NLU], or [NLG] to the beginning of the input, and in the case of [NLU] and [NLG], we add the infill token at the end of the input, as typical for these modes. Interestingly, U-PaLM in [S2S] mode is the only variant that returns the correct answer in Vietnamese. Regular PaLM produces the correct answer, but ignores the Vietnamese request, while U-PaLM with default prompting (no mode, no infill) produces a roughly correct answer but could be more specific (’xanh’ encompasses both greens and blues). This example shows how accessing specific mode tokens may work well for some prompts more so than others, giving us a powerful technique to serve a larger variety of prompts.
+
+Even though [NLU] and [NLG] modes typically coincide during pretraining with span corruption (involving extra ID tokens, infilling), we can still use [NLU] and [NLG] mode tokens with no infilling at all. Similarly we can use infilling but with no mode tokens. The variety of ways to prompt U-PaLM results in a useful technique to increase the diversity of the outputs we can get from the model, without resorting to alternative decoding techniques (e.g. sampling). This is particularly useful for more open-ended prompts.
+
+In Figure 7, we ask PaLM and all variants of querying U-PaLM to write a haiku about "a cat baking a cake on a lake" - a very random prompt that the model is unlikely to see during training, yet requires very structured output. All outputs use greedy decoding here, and surprisingly all models generate reasonable haikus about the topic, although not all follow a strict 5-7-5 syllable structure. PaLM’s haiku repeats the first and last line, which is somewhat less interesting. We can see that the different combinations of querying U-PaLM results in pleasantly varying poems.
+
+# 4.3 Improved Diversity for Open-ended Generation
+
+Beyond improving the scaling behavior of PaLM, we find that the small amount of continued training applied in UL2R is sufficient to imbue PaLM with new prompting abilities introduced by the UL2 objective. Namely, the use of denoising in UL2 allows PaLM to acquire infilling abilities. Infilling allows U-PaLM to have a second approach to tackling prompts, which we observe to be very useful. In addition, with U-PaLM we can also supply mode tokens to gain access to specific pretraining objectives. This gives us a powerful tool to control the model without making any updates to the model or its inference. In this section we provide some examples of situations where U-PaLM’s expanded prompting capabilities prove to be useful.
+
+# 8 Acknowledgements
+
+We thank Le Hou and Oliver Bousquet for their advice and feedback on the paper. We thank Barret Zoph and William Fedus for early discussions about this paper. We thank Adam Roberts for feedback on prior work.
+
+# 5 Conclusion
+
+We proposed UL2R for continued training of PaLM. We show that with only ${ \approx } 0 . 1 \%$ additional FLOPs (or compute), we are able to improve the scaling curve and properties of PaLM on many downstream tasks and metrics. Notably, UL2R enables a 4.4 million TPUv4 savings at 540B scale. The resulting model which we call U-PaLM outperforms PaLM on English NLP tasks (e.g., commonsense reasoning and closed-book question answering), reasoning tasks with chain-of-thought, multilingual reasoning, MMLU and a suite of challenging BIG-Bench tasks.
+
+# 6 Limitations
+
+In this work we show the effectiveness of continued training of a 540B PaLM model with UL2R over conditional language modeling alone. We only demonstrate this for the PaLM model and pretraining corpus. Our study is only a demonstration of what is possible with an example near state-of-the-art system, and we do not provide results on what would happen if the underlying model and pretraining corpus were to differ from the one studied here. For example, what would happen if we applied ULR2 to a model that was trained to saturation on a corpus already? Would we observe similar improvements? What would happen if we use a weaker underlying model? This paper also only studies models with $^ { 8 \mathrm { B + } }$ parameters, and does not provide insight on how UL2R would perform on smaller models and compute regions. We leave these investigations for future work, and this work should not be interpreted as a comprehensive study of continued pretraining or model reuse.
+
+# References
+
+Armen Aghajanyan, Anchit Gupta, Akshat Shrivastava, Xilun Chen, Luke Zettlemoyer, and Sonal Gupta. Muppet: Massive multi-task representations with prefinetuning. arXiv preprint arXiv:2101.11038, 2021.
+
+Philip W Anderson. More is different: broken symmetry and the nature of the hierarchical structure of science. Science, 177(4047):393–396, 1972.
+
+Vamsi Aribandi, Yi Tay, Tal Schuster, Jinfeng Rao, Huaixiu Steven Zheng, Sanket Vaibhav Mehta, Honglei Zhuang, Vinh Q. Tran, Dara Bahri, Jianmo Ni, Jai Prakash Gupta, Kai Hui, Sebastian Ruder, and Donald Metzler. Ext5: Towards extreme multi-task scaling for transfer learning. ICLR, 2022. URL https://arxiv.org/abs/2111.10952.
+
+Yonatan Bisk, Rowan Zellers, Jianfeng Gao, Yejin Choi, et al. Piqa: Reasoning about physical commonsense in natural language. In Proceedings of the AAAI conference on artificial intelligence, volume 34, pages 7432–7439, 2020.
+
+Tom B Brown, Benjamin Mann, Nick Ryder, Melanie Subbiah, Jared Kaplan, Prafulla Dhariwal, Arvind Neelakantan, Pranav Shyam, Girish Sastry, Amanda Askell, et al. Language models are few-shot learners. arXiv preprint arXiv:2005.14165, 2020.
+
+Aakanksha Chowdhery, Sharan Narang, Jacob Devlin, Maarten Bosma, Gaurav Mishra, Adam Roberts, Paul Barham, Hyung Won Chung, Charles Sutton, Sebastian Gehrmann, et al. Palm: Scaling language modeling with pathways. arXiv preprint arXiv:2204.02311, 2022.
+
+Hyung Won Chung, Longpre Shayne Hou, Le and, Barret Zoph, Yi Tay, William Fedus, and et al. Scaling instruction-finetuned language models. arXiv preprint, 2022.
+
+# 7 Ethics Statement
+
+As this work continues training PaLM, we defer discussion of ethical considerations with respect to large language models to the original PaLM paper [Chowdhery et al., 2022]. We do note though that this work presents a way of improving large language models without training from scratch, and all the different types of cost (e.g. environmental) that that might entail.
+
+Christopher Clark, Kenton Lee, Ming-Wei Chang, Tom Kwiatkowski, Michael Collins, and Kristina Toutanova. Boolq: Exploring the surprising difficulty of natural yes/no questions. In NAACL, 2019.
+
+Jonathan H Clark, Eunsol Choi, Michael Collins, Dan Garrette, Tom Kwiatkowski, Vitaly Nikolaev, and Jennimaria Palomaki. Tydi qa: A benchmark for information-seeking question answering in typologically diverse languages. Transactions of the Association for Computational Linguistics, 8: 454–470, 2020a.
+
+Kevin Clark, Minh-Thang Luong, Quoc V Le, and Christopher D Manning. Electra: Pre-training text encoders as discriminators rather than generators. arXiv preprint arXiv:2003.10555, 2020b.
+
+Karl Cobbe, Vineet Kosaraju, Mohammad Bavarian, Jacob Hilton, Reiichiro Nakano, Christopher Hesse, and John Schulman. Training verifiers to solve math word problems. arXiv preprint arXiv:2110.14168, 2021.
+
+Mostafa Dehghani, Yi Tay, Anurag Arnab, Lucas Beyer, and Ashish Vaswani. The efficiency misnomer. In International Conference on Learning Representations, 2021.
+
+Jacob Devlin, Ming-Wei Chang, Kenton Lee, and Kristina Toutanova. Bert: Pre-training of deep bidirectional transformers for language understanding. arXiv preprint arXiv:1810.04805, 2018.
+
+Andrew Drozdov, Nathanael Schärli, Ekin Akyürek, Nathan Scales, Xinying Song, Xinyun Chen, Olivier Bousquet, and Denny Zhou. Compositional semantic parsing with large language models. arXiv preprint arXiv:2209.15003, 2022.
+
+Deep Ganguli, Danny Hernandez, Liane Lovitt, Nova DasSarma, Tom Henighan, Andy Jones, Nicholas Joseph, Jackson Kernion, Ben Mann, Amanda Askell, et al. Predictability and surprise in large generative models. arXiv preprint arXiv:2202.07785, 2022. URL https://arxiv.org/abs/2202.07785.
+
+Mor Geva, Daniel Khashabi, Elad Segal, Tushar Khot, Dan Roth, and Jonathan Berant. Did aristotle use a laptop? a question answering benchmark with implicit reasoning strategies. Transactions of the Association for Computational Linguistics, 9: 346–361, 2021.
+
+Dan Hendrycks, Collin Burns, Steven Basart, Andy Zou, Mantas Mazeika, Dawn Song, and Jacob Steinhardt. Measuring massive multitask language understanding. arXiv preprint arXiv:2009.03300, 2020.
+
+Danny Hernandez, Tom Brown, Tom Conerly, Nova DasSarma, Dawn Drain, Sheer El-Showk, Nelson Elhage, Zac Hatfield-Dodds, Tom Henighan, Tristan Hume, et al. Scaling laws and interpretability of learning from repeated data. arXiv preprint arXiv:2205.10487, 2022.
+
+Jordan Hoffmann, Sebastian Borgeaud, Arthur Mensch, Elena Buchatskaya, Trevor Cai, Eliza Rutherford, Diego de Las Casas, Lisa Anne Hendricks, Johannes Welbl, Aidan Clark, et al. Training computeoptimal large language models. arXiv preprint arXiv:2203.15556, 2022.
+
+Mandar Joshi, Eunsol Choi, Daniel S Weld, and Luke Zettlemoyer. Triviaqa: A large scale distantly supervised challenge dataset for reading comprehension. arXiv preprint arXiv:1705.03551, 2017.
+
+Jared Kaplan, Sam McCandlish, Tom Henighan, Tom B Brown, Benjamin Chess, Rewon Child, Scott Gray, Alec Radford, Jeffrey Wu, and Dario Amodei. Scaling laws for neural language models. arXiv preprint arXiv:2001.08361, 2020.
+
+Tom Kwiatkowski, Jennimaria Palomaki, Olivia Redfield, Michael Collins, Ankur Parikh, Chris Alberti, Danielle Epstein, Illia Polosukhin, Matthew Kelcey, Jacob Devlin, Kenton Lee, Kristina N. Toutanova, Llion Jones, Ming-Wei Chang, Andrew Dai, Jakob Uszkoreit, Quoc Le, and Slav Petrov. Natural questions: a benchmark for question answering research. Transactions of the Association of Computational Linguistics, 2019.
+
+Brian Lester, Rami Al-Rfou, and Noah Constant. The power of scale for parameter-efficient prompt tuning. arXiv preprint arXiv:2104.08691, 2021.
+
+Aitor Lewkowycz, Anders Andreassen, David Dohan, Ethan Dyer, Henryk Michalewski, Vinay Ramasesh, Ambrose Slone, Cem Anil, Imanol Schlag, Theo Gutman-Solo, et al. Solving quantitative reasoning problems with language models. arXiv preprint arXiv:2206.14858, 2022.
+
+Long Ouyang, Jeff Wu, Xu Jiang, Diogo Almeida, Carroll L. Wainwright, Pamela Mishkin, Chong Zhang, Sandhini Agarwal, Katarina Slama, Alex Ray, et al. Training language models to follow instructions with human feedback. arXiv preprint arXiv:2203.02155, 2022. URL https://arxiv.org/abs/2203.02155.
+
+Denis Paperno, Germ’an Kruszewski, Angeliki Lazaridou, Ngoc Quan Pham, Raffaella Bernardi, Sandro Pezzelle, Marco Baroni, Gemma Boleda, and Raquel Fern’andez. The LAMBADA dataset: Word prediction requiring a broad discourse context. In Proceedings of the 54th Annual Meeting of the Association for Computational Linguistics (Volume 1: Long Papers), pages 1525–1534, Berlin, Germany, August 2016. Association for Computational Linguistics. doi: 10.18653/v1/P16-1144. URL https://www.aclweb.org/anthology/P16-1144.
+
+Jack W Rae, Sebastian Borgeaud, Trevor Cai, Katie Millican, Jordan Hoffmann, Francis Song, John Aslanides, Sarah Henderson, Roman Ring, Susannah Young, et al. Scaling language models: Methods, analysis & insights from training gopher. arXiv preprint arXiv:2112.11446, 2021.
+
+Colin Raffel, Noam Shazeer, Adam Roberts, Katherine Lee, Sharan Narang, Michael Matena, Yanqi Zhou, Wei Li, and Peter J Liu. Exploring the limits of transfer learning with a unified text-to-text transformer. arXiv preprint arXiv:1910.10683, 2019.
+
+Adam Roberts, Colin Raffel, and Noam Shazeer. How much knowledge can you pack into the parameters of a language model? arXiv preprint arXiv:2002.08910, 2020.
+
+Keisuke Sakaguchi, Ronan Le Bras, Chandra Bhagavatula, and Yejin Choi. Winogrande: An adversarial winograd schema challenge at scale. arXiv preprint arXiv:1907.10641, 2019.
+
+Victor Sanh, Albert Webson, Colin Raffel, Stephen Bach, Lintang Sutawika, Zaid Alyafeai, Antoine Chaffin, Arnaud Stiegler, Teven Le Scao, Arun Raja, et al. Multitask prompted training enables zero-shot task generalization. ICLR, 2022. URL https: //openreview.net/forum?id=9Vrb9D0WI4.
+
+Freda Shi, Mirac Suzgun, Markus Freitag, Xuezhi Wang, Suraj Srivats, Soroush Vosoughi, Hyung Won Chung, Yi Tay, Sebastian Ruder, Denny Zhou, et al. Language models are multilingual chain-of-thought reasoners. arXiv preprint arXiv:2210.03057, 2022.
+
+Aarohi Srivastava, Abhinav Rastogi, Abhishek Rao, Abu Awal Md Shoeb, Abubakar Abid, Adam Fisch, Adam R Brown, Adam Santoro, Aditya Gupta, Adrià Garriga-Alonso, et al. Beyond the imitation game: Quantifying and extrapolating the capabilities of language models. arXiv preprint arXiv:2206.04615, 2022.
+
+Jacob Steinhardt. Future ml systems will be qualitatively different, 2022. Accessed May 20, 2022.
+
+Mirac Suzgun, Nathan Scales, Nathanael Scharli, Sebastian Gehrmann, Yi Tay, Hyung Won Chung, Aakanksha Chowdhery, Quoc V. Le, Ed H. Chi, Denny Zhou, and Jason Wei. Challenging big-bench tasks and whether chain-of-thought can solve them. arXiv preprint, 2022.
+
+Alon Talmor, Jonathan Herzig, Nicholas Lourie, and Jonathan Berant. CommonsenseQA: A question answering challenge targeting commonsense knowledge. 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 4149–4158, Minneapolis, Minnesota, June 2019. Association for Computational Linguistics. doi: 10.18653/v1/N19-1421. URL https://aclanthology.org/N19-1421.
+
+Yi Tay, Mostafa Dehghani, Jinfeng Rao, William Fedus, Samira Abnar, Hyung Won Chung, Sharan Narang, Dani Yogatama, Ashish Vaswani, and Donald Metzler. Scale efficiently: Insights from pre-training and fine-tuning transformers. arXiv preprint arXiv:2109.10686, 2021.
+
+Yi Tay, Mostafa Dehghani, Samira Abnar, Hyung Won Chung, William Fedus, Jinfeng Rao, Sharan Narang, Vinh Q Tran, Dani Yogatama, and Donald Metzler. Scaling laws vs model architectures: How does inductive bias influence scaling? arXiv preprint arXiv:2207.10551, 2022a.
+
+Yi Tay, Mostafa Dehghani, Vinh Q Tran, Xavier Garcia, Dara Bahri, Tal Schuster, Huaixiu Steven
+
+Zheng, Neil Houlsby, and Donald Metzler. Unifying language learning paradigms. arXiv preprint arXiv:2205.05131, 2022b.
+
+Yi Tay, Vinh Q Tran, Mostafa Dehghani, Jianmo Ni, Dara Bahri, Harsh Mehta, Zhen Qin, Kai Hui, Zhe Zhao, Jai Gupta, et al. Transformer memory as a differentiable search index. arXiv preprint arXiv:2202.06991, 2022c.
+
+Romal Thoppilan, Daniel De Freitas, Jamie Hall, Noam Shazeer, Apoorv Kulshreshtha, Heng-Tze Cheng, Alicia Jin, Taylor Bos, Leslie Baker, Yu Du, et al. Lamda: Language models for dialog applications. arXiv preprint arXiv:2201.08239, 2022.
+
+Alex Wang, Yada Pruksachatkun, Nikita Nangia, Amanpreet Singh, Julian Michael, Felix Hill, Omer Levy, and Samuel R Bowman. Superglue: A stickier benchmark for general-purpose language understanding systems. arXiv preprint arXiv:1905.00537, 2019.
+
+Thomas Wang, Adam Roberts, Daniel Hesslow, Teven Le Scao, Hyung Won Chung, Iz Beltagy, Julien Launay, and Colin Raffel. What language model architecture and pretraining objective work best for zero-shot generalization? arXiv preprint arXiv:2204.05832, 2022a.
+
+Xuezhi Wang, Jason Wei, Dale Schuurmans, Quoc Le, Ed Chi, and Denny Zhou. Self-consistency improves chain of thought reasoning in language models. arXiv preprint arXiv:2203.11171, 2022b.
+
+Jason Wei, Maarten Bosma, Vincent Y Zhao, Kelvin Guu, Adams Wei Yu, Brian Lester, Nan Du, Andrew M Dai, and Quoc V Le. Finetuned language models are zero-shot learners. arXiv preprint arXiv:2109.01652, 2021.
+
+Jason Wei, Yi Tay, Rishi Bommasani, Colin Raffel, Barret Zoph, Sebastian Borgeaud, Dani Yogatama, Maarten Bosma, Denny Zhou, Donald Metzler, et al. Emergent abilities of large language models. Transactions on Machine Learning Research (TMLR), 2022a.
+
+Jason Wei, Xuezhi Wang, Dale Schuurmans, Maarten Bosma, Brian Ichter, Fei Xia, Ed Chi, Quoc Le, and Denny Zhou. Chain of thought prompting elicits reasoning in large language models. Conference on Neural Information Processing Systems (NeurIPS), 2022b.
+
+Zhilin Yang, Zihang Dai, Yiming Yang, Jaime Carbonell, Russ R Salakhutdinov, and Quoc V Le. Xlnet: Generalized autoregressive pretraining for language understanding. Advances in neural information processing systems, 32, 2019.
+
+Jiahui Yu, Yuanzhong Xu, Jing Yu Koh, Thang Luong, Gunjan Baid, Zirui Wang, Vijay Vasudevan, Alexander Ku, Yinfei Yang, Burcu Karagol Ayan, et al. Scaling autoregressive models for contentrich text-to-image generation. arXiv preprint arXiv:2206.10789, 2022.
+
+Rowan Zellers, Ari Holtzman, Yonatan Bisk, Ali Farhadi, and Yejin Choi. Hellaswag: Can a machine really finish your sentence? arXiv preprint arXiv:1905.07830, 2019.
+
+Denny Zhou, Nathanael Schärli, Le Hou, Jason Wei, Nathan Scales, Xuezhi Wang, Dale Schuurmans, Olivier Bousquet, Quoc Le, and Ed Chi. Least-tomost prompting enables complex reasoning in large language models. arXiv preprint arXiv:2205.10625, 2022.
+
+Barret Zoph, Irwan Bello, Sameer Kumar, Nan Du, Yanping Huang, Jeff Dean, Noam Shazeer, and William Fedus. St-moe: Designing stable and transferable sparse expert models, 2022. URL https://arxiv.org/abs/2202.08906.
+
+# 9 Appendix
+
+# 10 Related Work
+
+Large language models Scaling and improving large language models is one of the most impactful research areas in modern artificial intelligence [Chowdhery et al., 2022]. To this end, large language models not only continue to improve as we scale in terms of data or computational budget [Hoffmann et al., 2022, Kaplan et al., 2020] but also acquire new abilities [Wei et al., 2022a]. The impact of large language models has been ubiquitous and pervasive, unlocking breakthroughs across many fields, e.g., reasoning [Wei et al., 2022b, Wang et al., 2022b, Zhou et al., 2022, Drozdov et al., 2022], math [Lewkowycz et al., 2022], dialog [Thoppilan et al., 2022], multimodal applications [Yu et al., 2022], retrieval [Tay et al., 2022c] inter alia.
+
+While there have been many paradigms and self-supervision methods proposed to train these models [Devlin et al., 2018, Clark et al., 2020b, Yang et al., 2019, Raffel et al., 2019], to this date most large language models (i.e., more than 100B parameters) are trained as decoder-only casual language models. For example, flagship large language models such as GPT-3 [Brown et al., 2020], Gopher [Rae et al., 2021] and PaLM [Chowdhery et al., 2022] are all trained as causal language models. Meanwhile, bidirectional models (e.g., BERT [Devlin et al., 2018], T5 [Raffel et al., 2019], ST-MoE [Zoph et al., 2022]) have also been very popular as the goto model of choice, especially in smaller computational regimes (e.g., less than 30B parameters and often times in the ranges of hundred of millions of parameters).
+
+Scaling laws of large language models Kaplan et al. [2020] investigated scaling laws of Transformer language models and first showed the scaling laws are predictive of future performance. The authors found that model size (and not shape) correlates strongly with model quality, i.e., upstream cross entropy. Tay et al. [2021] studied the scaling properties of encoder-decoder models and their impact on upstream and downstream finetuning tasks. Generally, Tay et al. [2021] found that upstream perplexity and downstream quality does not always correlate. As a follow up, Tay et al. [2022a] studied the scaling laws of different model architectures and found that inductive bias does significantly impact the scaling behavior of the model. Finally, Hoffmann et al. [2022] proposed compute-optimal models that popularized the ‘chinchilla’ scaling laws - an approach that aims to be predictive of the optimal amount of data given the number of model parameters. In this work, we mainly consider scaling laws over downstream performance largely because this is more reflective of a language model’s usability. Since downstream performance is more important than upstream cross entropy, we advocate for future scaling studies to always incorporate downstream evaluation (and metrics) as opposed to only using cross entropy loss.
+
+Emergent Abilities New behaviors that arise due to scaling language models have been increasingly referred to as emergent abilities [Steinhardt, 2022, Ganguli et al., 2022, Wei et al., 2022a]. For instance, Wei et al. [2022a] define emergent abilities as “abilities that are not present in smaller models but as present in larger models.” For a few-shot prompted task, this would look like a flat scaling curve (random performance) until a certain critical threshold, during which performance increases to substantially above random. This type of phenomena has been observed across dozens of tasks in the BIG-Bench benchmark [Srivastava et al., 2022]. Although such emergent abilities are typically observed as a function of scale, increasing model scale to induce emergent abilities is computationally expensive. In this paper we show how UL2R unlocks emergence without increasing the number of model parameters.
+
+Continued Training of Language Models The paradigm of continue to train (or finetune) a language model on more data or tasks is commonly known as adaptation. A range of prior work has shown that finetuning language models on a collection of NLP tasks can improve downstream performance on a broad range of downstream tasks [Aghajanyan et al., 2021, Aribandi et al., 2022, Wei et al., 2021, Sanh et al., 2022, Ouyang et al., 2022, inter alia]. The majority of this prior work, however, requires additional data such as aggregating dozens or hundreds of NLP datasets [Raffel et al., 2019, Aghajanyan et al., 2021, Aribandi et al., 2022], writing additional templates of instructions [Wei et al., 2021, Sanh et al., 2022], or finetuning on human-labeled annotations [Ouyang et al., 2022]. UL2R does not require new data since it simply re-uses the pre-training data, which makes it orthogonal to continued training methods that leverage large collections of NLP datasets. Adapting a pretrained language model with a new self-supervised objective has been explored. For example, a model trained with a language modeling objective can be adapted by further training with the masked language modeling objective [Wang et al., 2022a]. The other direction is also possible; a model trained with a masked language objective can be adapted with the causal language modeling objective [Wang et al., 2022a, Lester et al., 2021]. UL2R follows a similar idea but uptrains a language model with a set of diverse and new preordaining tasks from mixture-of-denoisers, even after a vast amounts of standard pretraining and demonstrates a very rapid improvement on variety of setups and tasks.
+
+Unified language learner (UL2) The UL2 [Tay et al., 2022b] model is a state-of-the-art model that bridges both generative causal language models and bidirectional language models. UL2 proposes a mixture-of-denoiser objective that mixes prefix (non-causal) language modeling and infilling (span corruption) within the same model and leverages mode prompts to switch between modes during downstream tasks. UL2 is architecture agnostic in which the authors argue that the choice of decoderonly versus encoder-decoder models is largely an efficiency trade-off. In [Tay et al., 2022b], the final UL2 model was trained as a 20B encoder-decoder model, which achieves very compelling performance on both finetuning and in-context learning.
+
+# 11 Additional Results & Analysis
+
+# 11.0.1 Analyzing individual task performance on BIG-Bench
+
+This section dives into individual task performance and attempts to understand quality on different types of BIG-Bench tasks.
+
+Spatial or Visual Reasoning Tasks The first category of tasks that U-PaLM does extremely well on are tasks that require some form of spatial or visual reasoning (e.g., navigate or geometric_shapes). In both of these tasks, U-PaLM 8B outperforms PaLM 540B. We postulate that this is due to the prefix language model architecture and additional PrefixLM training that U-PaLM undergoes. To give a better illustration, consider the following examples from these tasks.
+
+• In the navigate task, an example is as follows: ‘Turn right. Take 1 step. Turn right. Take 6 steps. Turn right. Take 1 step. Turn right. Take 2 steps. Take 4 steps.‘ and the task is a binary classification task that determines if the agent returns to the starting point.
+
+• In the geometric_shapes task, the goal is to predict the shape given an SVG path, e.g., given ‘M $3 I , 2 9 L 3 4 , 7 6 L 8 2 , I 6 L 3 I , 2 9 ^ { \circ }$ the model should predict triangle.
+
+Here, it is worth noting that both tasks can be improved intuitively by having bidirectional attention and being trained using a PrefixLM like objective. This could explain why U-PaLM could outperform PaLM 540B even at 8B because it was given the right inductive bias.
+
+Commonsense and Knowledge Tasks A reasonable portion out of the 21 tasks require some form of commonsense or language-based knowledge in order to do well. It is worth noting that U-PaLM does not train on any new unique tokens (or new data) and therefore, has no access to no new ‘knowledge’ compared to vanilla PaLM. Hence, gains here are expected to be milder compared to tasks that rely more on algorithmic or other types of reasoning. However, we observe some relatively smaller gains in certain tasks (e.g., understanding_fables or movie_dialog_same_or_different). Amongst the tasks in this category, one exception is the snarks task which involves detecting sarcasm in natural language. It is worth noting that the only 2 out of 21 tasks where U-PaLM underperforms PaLM belongs to this category (e.g., logical_sequence and english_proverbs). We think this is reasonable since we do not completely expect UL2R to always improve upon this category of tasks given that it does not actually process new data tokens.
+
+Context Reasoning or Reading Comprehension Tasks Some tasks require some understanding of context and then requires the language model to answer questions based on this context. An example of this is the vitaminc_fact_verficiation task which tries to determine the veracity of a claim given external evidence (context). Another example is the understanding_fables task where the goal is to determine the ‘morale of the story’ given context (passage or story). It is worth noting that U-PaLM exhibits emergence at 62B scale on these two tasks even though the final 540B model performance is relatively similar. We postulate that this is due to the architectural (and pretraining) advantage of PrefixLM which aids the model in performing much better even at smaller scales. Intuitively, being able to bidirectionally reason with context (prefix) could be important in context reasoning tasks.
+
+Table 4: Results on zero-shot commonsense reasoning.   
+
+<table><tr><td>Task /Model Size FLOPS (ZFLOPS)</td><td>PaLM 62B 295.7</td><td>U-PaLM 62B 298.7</td><td>Chinchilla 70B</td><td>Gopher 280B</td><td>PaLM 540B 2527.2</td><td>U-PaLM 540B</td></tr><tr><td>BoolQ 0-shot</td><td>84.8</td><td>85.4</td><td>588 83.7</td><td>504 81.8</td><td>88.0</td><td>2529.7 88.8(+0.9%)</td></tr><tr><td>PIQA 0-shot</td><td>80.5</td><td>81.4</td><td>81.8</td><td>81.8</td><td>82.3</td><td>84.1(+2.2%)</td></tr><tr><td>HellaSwag 0-shot</td><td>79.7</td><td>79.7</td><td>80.8</td><td>79.7</td><td>83.4</td><td>84.1(+0.8%)</td></tr><tr><td>Winogrande 0-shot</td><td>77.0</td><td>76.2</td><td>74.9</td><td>70.1</td><td>81.1</td><td>82.6 (+1.8%)</td></tr><tr><td>Avg. Commonsense</td><td>80.5</td><td>80.7</td><td>80.3</td><td>78.2</td><td>83.7</td><td>84.9 (+1.4%)</td></tr></table>
+
+Multi-step Reasoning, Analogical Reasoning and Arithmetic tasks We observe that there are some performance improvements on analogical reasoning task (e.g., analogical_similarity) or multi-step reasoning tasks (strategyqa) at 540B scale. However, unlike context reasoning tasks, the performance on these class of tasks tend to follow similar scaling patterns albeit with slightly better performance. For example, based on Figure 4, we note that strategyqa follows relatively similar scaling curves to PaLM.
+
+# 11.1 Zero-shot and Few-shot NLP
+
+In this section, we evaluate our models on various well-established NLP tasks. These tasks test a spectrum of zero and few-shot abilities of U-PaLM.
+
+# 11.1.1 Commonsense Reasoning
+
+We conduct experiments on four zero-shot commonsense reasoning benchmarks. Specifically, following [Hoffmann et al., 2022], we use BoolQ [Clark et al., 2019], PIQA [Bisk et al., 2020], HellaSWAG [Zellers et al., 2019] and Winogrande [Sakaguchi et al., 2019]. Aside from PaLM 62B and PaLM 540B which we use for direct comparisons with U-PaLM, we also compare with Chinchilla 70B [Hoffmann et al., 2022] and Gopher 280B [Rae et al., 2021]. Table 4 reports the results on zero-shot commonsense reasoning.
+
+We show that U-PaLM 540B outperforms PaLM 540B on all four tasks with an average of $( + 1 . 4 \% )$ relative improvement and attains the best performance across all models.
+
+# 11.1.2 Question Answering and Reading Comprehension
+
+We evaluate zero-shot and few-shot closed book question answering (CBQA) tasks [Kwiatkowski et al., 2019, Joshi et al., 2017, Roberts et al., 2020] along with the zero-shot Lambada reading comprehension task [Paperno et al., 2016]. Table 5 reports the results of our experiments. We compare with PaLM 62B, PaLM 540B, Chinchilla 70B and
+
+Table 5: Results on closed book QA and reading comprehension.   
+
+<table><tr><td>Task/Model Size FLOPS (ZFLOPS)</td><td>PaLM 62B 295.7</td><td>U-PaLM 62B 298.7</td><td>Chinchilla 70B 588</td><td>Gopher 280B 504</td><td>PaLM 540B 2527.2</td><td>U-PaLM 540B 2529.7</td></tr><tr><td>TriviaQA 0-shot</td><td>67.3</td><td>68.3</td><td>67.0</td><td>52.8</td><td>76.9</td><td>76.4 (-0.7%)</td></tr><tr><td>TriviaQA few-shot</td><td>72.7</td><td>73.6</td><td>73.2</td><td>63.6</td><td>81.4</td><td>82.0 (+0.7%)</td></tr><tr><td>Natural Questions 0-shot</td><td>18.1</td><td>18.7</td><td>16.6</td><td>10.1</td><td>21.2</td><td>21.7 (+2.4%)</td></tr><tr><td>Natural Questions few-shot</td><td>27.6</td><td>30.5</td><td>31.5</td><td>24.5</td><td>36.0</td><td>40.1 (+11.4%)</td></tr><tr><td>Lambada 0-shot</td><td>75.4</td><td>79.7</td><td>77.2</td><td>74.5</td><td>77.9</td><td>80.5 (+3.3%)</td></tr><tr><td>Avg. QA/RC</td><td>52.2</td><td>54.3</td><td>53.0</td><td>45.1</td><td>58.7</td><td>60.1(+2.3%)</td></tr></table>
+
+Table 6: Experiment results on reasoning and chain-ofthought reasoning experiments.   
+
+<table><tr><td>Task /Model</td><td>Minerva 540B</td><td>PaLM540B</td><td>U-PaLM540B</td></tr><tr><td>GSM8K</td><td>57.8</td><td>54.9</td><td>58.5 (+6.6%)</td></tr><tr><td>BBH</td><td>37.2</td><td>44.8</td><td>49.6 (+10.7%)</td></tr><tr><td>StrategyQA</td><td>61.9</td><td>76.4</td><td>76.6(+0.2%)</td></tr><tr><td>CSQA</td><td>72.2</td><td>76.9</td><td>80.1(+4.2%)</td></tr></table>
+
+Gopher 280B. Overall, on few-shot CBQA and reading comprehension, we observe that U-PaLM 540B outperforms PaLM 540B by $+ 2 . 3 \%$ on average and up to $+ 1 1 . 4 \%$ on few-shot natural questions. Meanwhile, the gain at 62B scale is also strong (i.e., $+ 2 . 1 \%$ on average).
+
+# 11.1.3 Reasoning and Chain-of-thought Experiments
+
+We conduct experiments on reasoning and CoT and compare U-PaLM 540B with PaLM 540B and Minerva 540B. We use the GSM8K [Cobbe et al., 2021], BBH [Suzgun et al., 2022], StrategyQA [Geva et al., 2021] and CommonsenseQA [Talmor et al., 2019] benchmarks. All tasks are run with chain-of-thought (CoT) prompting. Table 6 reports results on reasoning and CoT benchmarks. U-PaLM 540B outperforms both PaLM 540B and Minverva 540B. Notably, the gains on GSM8K and BBH are relatively strong. This shows that U-PaLM does well on reasoning and is well-suited for chain-of-thought reasoning.
+
+# 11.1.4 Multilingual Few-shot Reasoning and Question Answering Tasks
+
+We conduct experiments on few-shot multilingual reasoning and question answering tasks. We use the MGSM (multilingual grade school math) benchmark proposed in [Shi et al., 2022]. For multilingual question answering, we use the well-established TydiQA [Clark et al., 2020a] benchmark. In our experiments, both PaLM 540B and U-PaLM 540B uses chain-of-thought prompting [Wei et al., 2022b]. Table 7 reports our results on MGSM and TydiQA. Our results show that U-PaLM outperform PaLM by a considerable margin $( + 3 . 2 \%$ on TydiQA and $+ 8 . 7 \%$ on MGSM).
+
+Table 7: Experiments on Multilingual GSM (MGSM) [Shi et al., 2022] and TydiQA [Clark et al., 2020a]   
+
+<table><tr><td>Task /Model</td><td>PaLM540B</td><td>U-PaLM540B</td></tr><tr><td>TydiQA</td><td>52.9</td><td>54.6(+3.2%)</td></tr><tr><td>MGSM</td><td>45.9</td><td>49.9 (+8.7%)</td></tr></table>
+
+Table 8: Results of PaLM vs U-PaLM at different FLOPs (# tokens) at 540B scale.   
+
+<table><tr><td rowspan="2">Model Task/#Tokens</td><td colspan="3">PaLM540B</td><td colspan="3">U-PaLM540B</td></tr><tr><td>182B</td><td>329B</td><td>780B</td><td>182B+</td><td>329B+</td><td>780B+</td></tr><tr><td>TriviaQA 1shot</td><td>73.4</td><td>74.4</td><td>81.4</td><td>73.3</td><td>75.6</td><td>82.0</td></tr><tr><td>NQA 1shot</td><td>23.2</td><td>25.6</td><td>29.3</td><td>24.4</td><td>28.1</td><td>30.7</td></tr><tr><td>WebQA 1shot</td><td>21.6</td><td>19.9</td><td>22.6</td><td>21.0</td><td>21.7</td><td>23.4</td></tr><tr><td>BoolQ</td><td>82.4</td><td>85.6</td><td>88.0</td><td>85.8</td><td>88.2</td><td>88.8</td></tr><tr><td>ReCORD</td><td>91.5</td><td>92.7</td><td>92.9</td><td>91.5</td><td>92.6</td><td>93.0</td></tr><tr><td>COPA</td><td>92.0</td><td>93.0</td><td>93.0</td><td>94.0</td><td>93.0</td><td>96.0</td></tr><tr><td>RTE</td><td>68.6</td><td>67.2</td><td>72.9</td><td>73.7</td><td>71.5</td><td>75.5</td></tr><tr><td>WIC</td><td>50.8</td><td>53.8</td><td>59.1</td><td>52.2</td><td>58.0</td><td>62.2</td></tr><tr><td>WSC</td><td>88.1</td><td>86.7</td><td>89.1</td><td>87.0</td><td>88.1</td><td>87.4</td></tr><tr><td>CB</td><td>57.1</td><td>48.2</td><td>51.8</td><td>69.6</td><td>71.4</td><td>69.6</td></tr><tr><td>MultiRC</td><td>76.7</td><td>81.1</td><td>83.5</td><td>78.4</td><td>81.7</td><td>83.8</td></tr><tr><td>Winogrande</td><td>89.4</td><td>88.3</td><td>90.1</td><td>87.9</td><td>89.7</td><td>88.3</td></tr><tr><td>Winograd</td><td>76.9</td><td>79.6</td><td>81.1</td><td>78.2</td><td>79.3</td><td>82.6</td></tr><tr><td>ANLIR1</td><td>44.3</td><td>49.4</td><td>48.4</td><td>50.3</td><td>50.6</td><td>55.3</td></tr><tr><td>ANLIR2</td><td>41.3</td><td>42.7</td><td>44.2</td><td>43.5</td><td>45.2</td><td>47.8</td></tr><tr><td>ANLIR3</td><td>43.8</td><td>42.8</td><td>45.7</td><td>46.7</td><td>49.3</td><td>57.0</td></tr><tr><td>PIQA</td><td>81.0</td><td>81.9</td><td>82.3</td><td>80.8</td><td>82.0</td><td>84.1</td></tr><tr><td>StoryCloze</td><td>82.7</td><td>83.9</td><td>84.6</td><td>83.7</td><td>84.2</td><td>87.0</td></tr><tr><td>HellaSwag</td><td>79.1</td><td>81.8</td><td>83.4</td><td>79.5</td><td>82.3</td><td>84.1</td></tr><tr><td>ArcE</td><td>74.8</td><td>72.8</td><td>76.6</td><td>74.6</td><td>76.3</td><td>85.9</td></tr><tr><td>ArcC</td><td>48.0</td><td>46.9</td><td>53.0</td><td>48.6</td><td>50.4</td><td>60.3</td></tr><tr><td>RaceM</td><td>63.6</td><td>67.3</td><td>68.1</td><td>63.2</td><td>67.1</td><td>67.2</td></tr><tr><td>OpenbookQA</td><td>50.2</td><td>51.2</td><td>53.4</td><td>50.2</td><td>51.2</td><td>53.6</td></tr><tr><td>RaceH</td><td>45.3</td><td>48.5</td><td>49.1</td><td>45.5</td><td>48.5</td><td>51.3</td></tr><tr><td>Lambada 1shot</td><td>75.4</td><td>77.5</td><td>81.8</td><td>74.3</td><td>79.9</td><td>80.0</td></tr><tr><td>SquadV2 1shot</td><td>70.5</td><td>71.3</td><td>78.7</td><td>71.8</td><td>70.3</td><td>78.2</td></tr><tr><td>Average</td><td>62.7</td><td>63.8</td><td>66.5</td><td>64.1</td><td>66.2</td><td>69.4</td></tr></table>
+
+# 11.2 Details of Scaling Curves for Few-shot Experiments
+
+We compute a mean aggregated score of the following tasks. We use 21 zero-shot rank classification tasks, i.e., BoolQ, Record, COPA, RTE, WiC, WSC, CB, MultiRC, Winograd, Winogrande, ANLI R1, ANLI R2, ANLI R3, PIQA, StoryCloze, HellaSwag, Arc-E, Arc-C, RaceM, RaceH, OpenbookQA. We use 5 one-shot generative tasks, i.e., TriviaQA, NaturalQuestions, WebQuestions,SQuaDV2 and Lambada. All tasks use the accuracy (or exact match) metric except MultiRC which reports f1a following [Brown et al., 2020]. In total, the aggregated metric is a mean over all 26 tasks. We list the scores that correspond to Figure 2’s 540B scaling plot below.
+
+# 11.3 Details of Vocab and Sentinel Tokens
+
+For U-PaLM, we had to train on span corruption or infilling task. We use the same setup as UL2 and T5 where we inject sentinel tokens, e.g., <extra_id_ $\smash {  { O > } }$ into the masked positions. In T5, sentinel ids are added as 100 additional vocab tokens at the end of the sentencepiece (vocab). In PaLM, since we restart from an existing PaLM checkpoints, it was quite cumbersome to initialize 100 new embeddings in the vocab. Hence, we opt to simply use the last 100 subwords as sentinel tokens. Finally, we also use eos symbols in the vocab when training the model.
+
+# 11.4 Details of Prompt Templates
+
+As stated in Section 3.2, BBES uses the default prompting and templates a BIG-Bench and do not use chain-of-thought prompting. For full BBH and MMLU results, we use the same set of prompts as [Chung et al., 2022], which we refer the reader to for more details. However, our 5-shot MMLU prompts do not use chain-of-thought, only directly stating the answer option, e.g. "Answer: (C)". Prompts for our zero-shot and few-shot NLP evaluations in Section 10.1 use the same basic templates as [Brown et al., 2020].
+
+# 11.5 Additional Discussion
+
+In this section, we delve into some additional topics and discussions.
+
+# 11.5.1 What about training from scratch?
+
+We address the elephant in the room. There are multiple perspectives to this question. The first is that UL2R can be thought as a form of ‘UL2 schedule‘ that sets a single causal language model objective from 0 to $N$ steps and then doing the UL2 mixture from $N$ to $N + \epsilon$ . In this sense, if we wanted to train from scratch, this would require modifying the mixture to have significantly more causal language modeling. The second perspective is that UL2R introduces a natural curriculum where the model spents a large fraction of training acquiring basic language modeling before moving on to tasks like infilling or learning how to leverage bidirectional receptive fields. Whether there is a taxonomy or hierarchical of pretraining tasks is still an open question which we hope to answer in future work. The third perspective is simply the practical aspect of U-PaLM. Training a PaLM 540B model from scratch is incredibly costly and we would like to reuse our existing models (or components) as much as possible to design new models for new tasks. U-PaLM is an instance of this type of research. Finally, given that many language models are trained as causal language models, we believe that UL2R presents great opportunity for improving existing models with only a small amount of compute.

parse/dev/vGQiU5sqUe3/vGQiU5sqUe3.md

@@ -0,0 +1,401 @@
+# Contrastive Learning as Goal-Conditioned Reinforcement Learning
+
+Tianjun Zhangγ Sergey Levineβ,γ Ruslan Salakhutdinovα U βGoogle Research γUC Berkeley
+
+# Abstract
+
+In reinforcement learning (RL), it is easier to solve a task if given a good representation. While deep RL should automatically acquire such good representations, prior work often finds that learning representations in an end-to-end fashion is unstable and instead equip RL algorithms with additional representation learning parts (e.g., auxiliary losses, data augmentation). How can we design RL algorithms that directly acquire good representations? In this paper, instead of adding representation learning parts to an existing RL algorithm, we show (contrastive) representation learning methods can be cast as RL algorithms in their own right. To do this, we build upon prior work and apply contrastive representation learning to action-labeled trajectories, in such a way that the (inner product of) learned representations exactly corresponds to a goal-conditioned value function. We use this idea to reinterpret a prior RL method as performing contrastive learning, and then use the idea to propose a much simpler method that achieves similar performance. Across a range of goal-conditioned RL tasks, we demonstrate that contrastive RL methods achieve higher success rates than prior non-contrastive methods, including in the offline RL setting. We also show that contrastive RL outperforms prior methods on image-based tasks, without using data augmentation or auxiliary objectives. 1
+
+# 1 Introduction
+
+Representation learning is an integral part of reinforcement learning $( \mathrm { R L } ^ { 2 } )$ algorithms. While such representations might emerge from end-to-end training [7, 79, 119, 126], prior work has found it necessary to equip RL algorithms with perception-specific loss functions [32, 44, 71, 89, 91, 101, 116, 140] or data augmentations [69, 73, 116, 118], effectively decoupling the representation learning problem from the reinforcement learning problem. Given what prior work has shown about RL in the presence of function approximation and state aliasing [2, 135, 138], it is not surprising that end-to-end learning of representations is fragile [69, 73]: an algorithm needs good representations to drive the learning of the RL algorithm, but the RL algorithm needs to drive the learning of good representations. So, can we design RL algorithms that do learn good representations without the need for auxiliary perception losses?
+
+Rather than using a reinforcement learning algorithm also to solve a representation learning problem, we will use a representation learning algorithm to also solve certain types of reinforcement learning problems, namely goal-conditioned RL. Goal-conditioned RL is widely studied [6, 15, 22, 62, 80, 120], and intriguing from a representation learning perspective because it can be done in an entirely self-supervised manner, without manually-specified reward functions. We will focus on contrastive (representation) learning methods, using observations from the same trajectory (as done in prior work [95, 109]) while also including actions as an additional input (See Fig. 1). Intuitively, contrastive learning then resembles a goal-conditioned value function: nearby states have similar representations and unreachable states have different representations. We make this connection precise, showing that sampling positive pairs using the discounted state occupancy measure results in learning representations whose inner product exactly corresponds to a value function.
+
+![](images/cd5df224f921c81048f98a3e7493620ab5683623d594ddd76acd0280121c9b97.jpg)  
+Figure 1: Reinforcement learning via contrastive learning. Our method uses contrastive learning to acquire representations of state-action pairs $( \phi ( s , a ) )$ and future states $( \psi ( s _ { f } ) )$ , so that the representations of future states are closer than the representations of random states. We prove that learned representation corresponds to a value function for a certain reward function. To select actions for reaching goal $s _ { g }$ , the policy chooses the action where $\phi ( s , a )$ is closest to $\psi ( s _ { g } )$ .
+
+In this paper, we show how contrastive representation learning can be used to perform goalconditioned RL. We formally relate the learned representations to reward maximization, showing that the inner product between representations corresponds to a value function. This framework of contrastive RL generalizes prior methods, such as C-learning [29], and suggests new goal-conditioned RL algorithms. One new method achieves performance similar to prior methods but is simpler; another method consistently outperforms the prior methods. On goal-conditioned RL tasks with image observations, contrastive RL methods outperform prior methods that employ data augmentation and auxiliary objectives, and do so without data augmentation or auxiliary objectives. In the offline setting, contrastive RL can outperform prior methods on benchmark goal-reaching tasks, sometimes by a wide margin.
+
+# 2 Related Work
+
+This paper will draw a connection between RL and contrastive representation learning, building upon a long line of contrastive learning methods in NLP and computer vision, and deep metric learning [17, 53, 54, 54, 56, 77, 84, 86, 87, 94, 95, 108, 109, 113, 122, 129, 132]. Contrastive learning methods learn representations such that similar (“positive”) examples have similar representations and dissimilar (“negative”) examples have dissimilar representations.3 While most methods generate the “positive” examples via data augmentation, some methods generate similar examples using different camera viewpoints of the same scene [109, 122], or by sampling examples that occur close in time within time series data [4, 95, 109, 118]. Our analysis will focus on this latter strategy, as the dependence on time will allow us to draw a precise relationship with the time dependence in RL.
+
+Deep RL algorithms promise to automatically learn good representations, in an end-to-end fashion. However, prior work has found it challenging to uphold this promise [7, 79, 119, 126], prompting many prior methods to employ separate objectives for representation learning and RL [32, 44, 71, 89, 91, 100, 101, 116, 118, 140, 143]. Many prior methods choose a representation learning objectives that reconstruct the input state [32, 47, 49, 50, 71, 91, 93, 141] while others use contrastive representation learning methods [89, 95, 111, 116, 118]. Unlike these prior methods, we will not use a separate representation learning objective, but instead use the same objective for both representation learning and reinforcement learning. Some prior RL methods have also used contrastive learning to acquire reward functions [14, 20, 33, 38, 63, 67, 92, 133, 134, 146], often in imitation learning settings [37, 55]. In contrast, we will use contrastive learning to directly acquire a value function, which (unlike a reward function) can be used directly to take actions, without any additional RL.
+
+This paper will focus on goal-conditioned RL problems, a problem prior work has approached using temporal difference learning [6, 29, 62, 80, 103, 106], conditional imitation learning [22, 41, 83, 105, 120], model-based methods [23, 107], hierarchical RL [90], and planning-based methods [30, 93, 105, 115]. The problems of automatically sampling goals and exploration [24, 35, 85, 98, 144] are orthogonal to this work. Like prior work, we will parametrize the value function as an inner product between learned representations [34, 58, 106]. Unlike these prior methods, we will learn a value function directly via contrastive learning, without using reward functions or TD learning.
+
+Our analysis will be most similar to prior methods [11, 15, 29, 103] that view goal-conditioned RL as a data-driven problem, rather than as a reward-maximization problem. Many of these methods employ hindsight relabeling [6, 26, 62, 78], wherein experience is relabeled with an outcome that occurred in the future. Whereas hindsight relabeling is typically viewed as a trick to add on top of an RL algorithm, this paper can roughly be interpreted as showing that the hindsight relabeling is a standalone RL algorithm. Many goal-conditioned methods learn a value function that captures the similarity between two states [29, 62, 91, 125]. Such distance functions are structurally similar to the critic function learned for contrastive learning, a connection we make precisely in Sec. 4. In fact, our analysis shows that C-learning [29] is already performing contrastive learning, and our experiments show that alternative contrastive RL methods can be much simpler and achieve higher performance.
+
+Prior work has studied how representations related to reward functions using the framework of universal value functions [12, 106] and successor features [9, 52, 81]. While these methods typically require additional supervision to drive representation learning (manually-specified reward functions or features), our method is more similar to prior work that estimates the discounted state occupancy measure as an inner product between learned representations [11, 131]. While these methods use temporal difference learning, ours is akin to Monte Carlo learning. While Monte Carlo learning is often (but not always [23]) perceived as less sampling efficient, our experiments find that our approach can be as sample efficient as TD methods. Other prior work has focused on learning representations that can be used for planning [59, 82, 104, 105, 128]. Our method will learn representations using an objective similar to prior work [105, 109], but makes the key observation that the representation already encodes a value function: no additional planning or RL is necessary to choose actions.
+
+Please see Appendix A for a discussion of how our work relates to unsupervised skill learning.
+
+# 3 Preliminaries
+
+Goal-conditioned reinforcement learning. The goal-conditioned RL problem is defined by states $s _ { t } \in S$ , actions $a _ { t }$ , an initial state distribution $p _ { 0 } \overline { { ( } } s )$ , the dynamics $p ( \boldsymbol { \dot { s } } _ { t + 1 } \mid s _ { t } , \boldsymbol { a } _ { t } )$ , a distribution over goals $p _ { g } ( s _ { g } )$ , and a reward function $r _ { g } { \left( s , \bar { a } \right) }$ for each goal. This problem is equivalent to a multi-task RL [5, 45, 121, 130, 139], where tasks correspond to reaching goals states. Following prior work [11, 15, 29, 103], we define the reward as the probability (density) of reaching the goal at the next time step:4
+
+$$
+r _ { g } ( s _ { t } , a _ { t } ) \triangleq ( 1 - \gamma ) p ( s _ { t + 1 } = s _ { g } \ | \ s _ { t } , a _ { t } ) .
+$$
+
+This reward function is appealing because it avoids the need for a human user to specify a distance metric (unlike, e.g., [6]). Even though our method will not estimate the reward function, we will still use the reward function for analysis. For a goal-conditioned policy $\pi ( \boldsymbol { a } \mid \boldsymbol { s } , \boldsymbol { s } _ { g } )$ , we use $\pi ( \tau \mid s _ { g } )$ to denote the probability of sampling an infinite-length trajectory $\tau = ( s _ { 0 } , a _ { 0 } , s _ { 1 } , a _ { 1 } , \cdot \cdot \cdot )$ . We defined the expected reward objective and Q-function as
+
+$$
+\operatorname* { m a x } _ { \pi } \mathbb { E } _ { p _ { g } ( s _ { g } ) , \pi ( \tau | s _ { g } ) } \left[ \sum _ { t = 0 } ^ { \infty } \gamma ^ { t } r _ { g } ( s _ { t } , a _ { t } ) \right] , \quad Q _ { s _ { g } } ^ { \pi } ( s , a ) \triangleq \mathbb { E } _ { \pi ( \tau | s _ { g } ) } \left[ \sum _ { t ^ { \prime } = t } ^ { \infty } \gamma ^ { t ^ { \prime } - t } r _ { g } ( s _ { t ^ { \prime } } , a _ { t ^ { \prime } } ) \mid \mathbf { \Pi } _ { a _ { t } = a } ^ { s _ { t } = s _ { t } } \right] .
+$$
+
+Intuitively, this objective corresponds to sampling a goal $s _ { g }$ and then optimizing the policy to go to that goal and stay there. Finally, we define the discounted state occupancy measure as [55, 142]
+
+$$
+p ^ { \pi ( \cdot | \cdot , s _ { g } ) } ( s _ { t + } = s ) \triangleq ( 1 - \gamma ) \sum _ { t = 0 } ^ { \infty } \gamma ^ { t } p _ { t } ^ { \pi ( \cdot | \cdot , s _ { g } ) } ( s _ { t } = s ) ,
+$$
+
+where $p _ { t } ^ { \pi } ( s )$ is the probability density over states that policy $\pi$ visits after $t$ steps. Sampling from the discounted state occupancy measure is easy: the first sample a time offset from a geometric distribution $\boldsymbol { \mathit { t } } \sim \mathbf { \mathrm { G E O M } } ( 1 - \gamma ) )$ , and then look at what state the policy visits after exactly $t$ steps. We will use $s _ { t + }$ to denote states sampled from the discounted state occupancy measure. Because our method will combine experience collected from multiple policies, we also define the average stationary distribution as $p ^ { \pi \^ { \cdot } \mid \cdot \rangle } ( s _ { t + } = s \mid s , a ) \triangleq \int p ^ { \pi ( \cdot \mid \cdot , s _ { g } ) } ( s _ { t + } = s \mid s , a ) p ^ { \pi } ( s _ { g } \mid s , a ) d \bar { s } _ { g \pi }$ where $p ^ { \pi } ( s _ { g } \mid s , a )$ is the probability of the commanded goal given the current state-action pair. This stationary distribution is equivalent to that of the policy $\begin{array} { r } { \pi ( \boldsymbol { a } \mid \boldsymbol { s } ) \triangleq \int \pi ( \boldsymbol { a } \mid \boldsymbol { s } , \boldsymbol { s } _ { g } ) p ^ { \pi } ( \boldsymbol { s } _ { g } \mid \boldsymbol { s } ) d \boldsymbol { s } _ { g } } \end{array}$ [145].
+
+Contrastive representation learning. Contrastive representation learning methods [17, 46, 53, 54, 61, 77, 84, 86, 87, 122, 124, 129] take as input pairs of positive and negative examples, and learn representations so that positive pairs have similar representations and negative pairs have dissimilar representations. We use $( u , v )$ to denote an input pair (e.g., $u$ is an image, and $v$ is an augmented version of that image). Positive examples are sampled from a joint distribution $p ( u , v )$ , while negative examples are sampled from the product of marginal distributions, $p ( u ) p ( v )$ . We will use an objective based on binary classification [77, 86, 87, 94]. Let $f ( u , v ) = \phi ( u ) ^ { T } \psi ( v )$ be the similarity between the representations of $u$ and $v$ . We will call $f$ the critic function5 and note that its range is $( - \infty , \infty )$ . We will use NCE-binary [84] objective (also known as InfoMAX [54]):
+
+$$
+\operatorname* { m a x } _ { f ( u , v ) } \mathbb { E } _ { ( u , v ^ { + } ) \sim p ( u , v ) } \biggl [ \log \sigma \bigl ( \underbrace { f ( u , v ^ { + } ) } _ { \phi ( u ) ^ { T } \psi ( v ^ { + } ) } \bigr ) + \log \bigl ( 1 - \sigma \bigl ( \underbrace { f ( u , \mathrm { ~ \xi ~ } ) } _ { \phi ( u ) ^ { T } \psi ( \mathrm { ~ \xi ~ } ) } \bigr ) \bigr ) \biggr ] .
+$$
+
+# 4 Contrastive Learning as an RL Algorithm
+
+This section shows how to use contrastive representation to directly perform goal-conditioned RL. The key idea (Lemma 4.1) is that contrastive learning estimates the Q-function for a certain policy and reward function. To prove this result, we relate the Q-function to the state occupancy measure (Sec. 4.1) and then relate the optimal critic function to the state occupancy measure (Sec. 4.2).
+
+This result allows us to propose a new algorithm for goal-conditioned RL based on contrastive learning. Unlike prior work, this algorithm is not adding contrastive learning on top of an existing RL algorithm. This framework generalizes C-learning [29], offering a cogent explanation for its good performance while also suggesting new methods that are simpler and can achieve higher performance.
+
+# 4.1 Relating the Q-function to probabilities
+
+This section sets the stage for the main results of this section by providing a probabilistic perspective goal-conditioned RL. The expected reward objective and associated Q-function in (Eq. 2) can equivalently be expressed as the probability (density) of reaching a goal in the future:
+
+Proposition 1 (rewards probabilities). The $Q$ -function for the goal-conditioned reward function $r _ { g }$ (Eq. 1) is equivalent to the probability of state $s _ { g }$ under the discounted state occupancy measure:
+
+$$
+Q _ { s _ { g } } ^ { \pi } ( s , a ) = p ^ { \pi ( \cdot | \cdot , s _ { g } ) } ( s _ { t + } = s _ { g } \mid s , a ) .
+$$
+
+The proof is in Appendix B. Translating rewards into probabilities not only makes it easier to analyze the goal-conditioned problem, but also means that any method for estimating probabilities (e.g., contrastive learning) can be turned into a method for estimating this Q-function.
+
+# 4.2 Contrastive Learning Estimates a Q-Function
+
+We will use contrastive learning to learn a value function by carefully choosing the inputs $u$ and $v$ . The first input, $u$ , will correspond to a state-action pair, $u \dot { = } ( s _ { t } , a _ { t } \dot { ) } \sim p ( s , a \dot { ) }$ . In practice, these pairs are sampled from the replay buffer. Including the actions in the input is important because it will allow us to determine which actions to take to reach a desired future state. The second variable, $v$ , is a future state, $v = s _ { f }$ . For the “positive” training pairs, the future state is sampled from the discounted state occupancy measure, $s _ { f } \sim p ^ { \pi ( \cdot | \cdot ) } ( s _ { t + } \mid s _ { t } , a _ { t } )$ . For the “negative” training pairs, we sample a future state from a random state-action pair: $\begin{array} { r } { \mathfrak { s } _ { f } \sim p ( \mathfrak { s } _ { t + } ) \underline { { \triangleq } } \int p ^ { \pi ( \cdot | \cdot ) } ( \mathfrak { s } _ { t + } \mid \mathfrak { s } , a ) p ( \mathfrak { s } , a ) d \mathfrak { s } d a } \end{array}$ . With these inputs, the contrastive learning objective (Eq. 4) can be written as
+
+$$
+\begin{array} { r l } & { \underset { f } { \operatorname* { m a x } } \mathbb { E } _ { ( s , a ) \sim p ( s , a ) , \quad \sim p ( s _ { f } ) } \left[ \mathcal { L } ( s , a , s _ { f } ^ { + } , \mathrm {  ~ \lambda ~ } ) \right] , } \\ & { \quad \quad \quad \quad s _ { f } ^ { + } \sim p ^ { \pi ( \cdot | \cdot ) } ( s _ { t + } | s _ { t } , a _ { t } ) } \\ & { \quad \quad \quad \mathrm { w h e r e } \quad \mathcal { L } ( s , a , s _ { f } ^ { + } , \mathrm {  ~ \lambda ~ } ) \triangleq \log \sigma ( \underset { \phi ( s , a ) ^ { T } \psi ( s _ { f } ^ { + } ) } { \underbrace { f ( s , a , s _ { f } ^ { + } ) } } ) + \log ( 1 - \sigma ( \underset { \phi ( s , a ) ^ { T } \psi ( \mathrm {  ~ \lambda ~ } ) } { \underbrace { f ( s , a , \mathrm {  ~ \lambda ~ } ) } } ) ) . } \end{array}
+$$
+
+Intuitively, the critic function $f ( u = ( s _ { t } , a _ { t } ) , v = s _ { f } )$ now tells us the correlation between the current state-action pair and future outcomes, analogous to a Q-function. We therefore can use the critic function in the same way as actor-critic RL algorithms [66], figuring out which actions lead to the desired outcome. Because the Bayes-optimal critic function is a function of the state occupancy measure [84], $\begin{array} { r } { f ^ { * } ( s , a , s _ { g } ) = \log \Big ( \frac { \bar { p } ^ { \pi ( \cdot | \cdot ) } \bar { ( } s _ { t + } = s _ { g } | s , a ) } { p ( s _ { g } ) } \Big ) } \end{array}$ , it can be used to express the Q-function:
+
+Lemma 4.1. The critic function that optimizes Eq. $6$ is a $Q$ -function for the goal-conditioned reward function (Eq. 1), up to a multiplicative constant p(sf ) : $\begin{array} { r } { \exp ( f ^ { * } ( s , a , s _ { f } ) ) = \frac { 1 } { p ( s _ { f } ) } \cdot Q _ { s _ { f } } ^ { \pi ( \cdot | \cdot ) } ( s , a ) } \end{array}$ .
+
+The critic function can be viewed as an unnormalized density model, where $p ( s _ { g } )$ is the partition function. Much of the appeal of contrastive learning is it avoids estimating the partition function [46], which can be challenging; in the RL setting, it will turn out that this constant can be ignored when selecting actions. Our experiments show that learning a normalized density model works well when $s _ { g }$ is low-dimensional, but struggles to solve higher-dimensional tasks.
+
+This lemma relates the critic function to $Q _ { s _ { f } } ^ { \pi ( \cdot | \cdot ) } ( s , a )$ , not $Q _ { s _ { f } } ^ { \pi ( \cdot | \cdot , s _ { f } ) } ( s , a )$ . The underlying reason is that the critic function combines together experience collected when commanding different goals. Prior goal-conditioned behavioral cloning methods [22, 41, 83, 120] perform similar sharing, but do not analyze the relationship between the learned policies and Q functions. Sec. 4.5 shows that this critic function can be used as the basis for a convergent RL algorithm under some assumptions.
+
+# 4.3 Learning the Goal-Conditioned Policy
+
+The learned critic function not only tells us the likelihood of future states, but also tells us how different actions change the likelihood of a state occurring in the future. Thus, to learn a policy for reaching a goal state, we choose the actions that make that state most likely to occur in the future:
+
+$$
+\operatorname* { m a x } _ { \pi ( a | s , s _ { g } ) } \mathbb { E } _ { \pi ( a | s , s _ { g } ) p ( s ) p ( s _ { g } ) } \left[ f ( s , a , s _ { f } = s _ { g } ) \right] \approx \mathbb { E } _ { \pi ( a | s , s _ { g } ) p ( s ) p ( s _ { g } ) } \left[ \log Q _ { s _ { g } } ^ { \pi ( \cdot | \cdot ) } ( s , a ) - \log p ( s _ { g } ) \right] .
+$$
+
+The approximation above reflects errors in learning the optimal critic, and will allow us to prove that this policy loss corresponds to policy improvement in Sec. 4.5, under some assumptions.
+
+In practice, we parametrize the goal-conditioned policy as a neural network that takes as input the state and goal and outputs a distribution over actions. The actor loss (Eq. 7) is computed by sampling states and random goals from the replay buffer, sampling actions from the policy, and then taking gradients on the policy using a reparametrization gradient. On tasks with image observations, we add an action entropy term to the policy objective.
+
+# 4.4 A Complete Goal-Conditioned RL Algorithm
+
+The complete algorithm alternates between fitting the critic function using contrastive learning, updating the policy using Eq. 7, and collecting more data. Alg. 1 provides a JAX [13] implementation of the actor and critic losses. Note that the critic is parameterized as an inner product between a representation of the state-action pair, and a representation of the goal state: $f ( s , \dot { a } , s _ { g } ) = \phi ( s , a ) ^ { T } \psi ( \dot { s } _ { g } )$ . This parameterization allows for efficient computation, as we can compute the goal representations just once, and use them both in the positive pairs and the negative pairs. While this is common practice in representation learning, it is not exploited by most goal-conditioned RL algorithms. We refer to this method as contrastive RL (NCE). In Appendix C, we derive a variant of this method (contrastive RL (CPC)) that uses the infoNCE bound on mutual information.
+
+Algorithm 1 Contrastive RL (NCE): the actor and critic losses for our method.
+
+from jax.numpy import einsum, eye   
+from optax import sigmoid_binary_cross_entropy   
+def critic_loss(states, actions, future_states): sa_repr $=$ sa_encoder(states, actions) # (batch_dim, repr_dim) g_repr $-$ g_encoder(future_states) # (batch_dim, repr_dim) logits $-$ einsum('ik,jk->ij', sa_repr, g_repr) # <sa_repr[i], g_repr[j]> for all i,j return sigmoid_binary_cross_entropy(logits $=$ logits, labels $-$ eye(batch_size))
+
+def actor_loss(states, goals): actions $=$ policy.sample(states, goal $\mathbf { \Psi } =$ goals) # (batch_size, action_dim) sa_repr $=$ sa_encoder(states, actions) # (batch_dim, repr_dim) g_repr $-$ g_encoder(goals) # (batch_dim, repr_dim) logits $=$ einsum('ik,ik->i', sa_repr, g_repr) # <sa_repr[i], g_repr[i]> return $^ { - 1 . 0 * }$ logits
+
+Contrastive RL (NCE) is an on-policy algorithm because it only estimates the Q-function for the policy that collected the data. However, in practice, we take as many gradient steps on each transition as standard off-policy RL algorithms [40, 48]. Please see Appendix E for full implementation details. We will also release an efficient implementation based on ACME [57] and JAX [13]. On a single TPUv2, training proceeds at $1 1 0 0 \frac { \mathrm { b a t c h e s } } { \mathrm { s e c } }$ for state-based tasks and $1 0 5 \frac { \mathrm { b a t c h e s } } { \mathrm { s e c } }$ for image-based tasks; for comparison, our implementation of $\mathrm { D r Q }$ on the same hardware setup runs at $2 8 \frac { \mathrm { b a t c h e s } } { \sec }$ $3 . 9 \times$ slower).6 Architectures and hyperparameters are described in Appendix E.7
+
+# 4.5 Convergence Guarantees
+
+In general, providing convergence guarantees for methods that perform relabeling is challenging. Most prior work offers no guarantees [6, 22, 23] or guarantees under only restrictive assumptions [41, 120].
+
+To prove that contrastive RL converges, we will introduce an additional filtering step into the method, throwing away some training examples. Precisely, we exclude training examples $( s , a , s _ { f } )$ if the probability of the corresponding trajectory $\tau _ { i : j } ~ = ~ ( s _ { i } , a _ { i } , s _ { i + 1 } , a _ { i + 1 } , \cdot \cdot \cdot ~ , s _ { j } , a _ { j } )$ sampled from $\pi ( \tau \mid s _ { g } )$ under the commanded goal $s _ { g }$ is very different from the trajectory’s probability under the actually-reached goal $s _ { j }$ :
+
+$$
+\mathrm { E x c L U D E T R A J } ( \tau _ { i : j } ) = \delta \left( \left| \frac { \pi ( \tau _ { i : j } \mid s _ { g } ) } { \pi ( \tau _ { i : j } \mid s _ { j } ) } - 1 \right| > \epsilon \right) .
+$$
+
+While this modification is necessary to prove convergence, ablation experiments in Appendix Fig. 13 show that the filtering step can actually hurt performance in practice, so we do not include this filtering step in the experiments in the main text. We can now prove that contrastive RL performs approximate policy improvement.
+
+Lemma 4.2 (Approximate policy improvement). Assume that states and actions are tabular and assume that the critic is Bayes-optimal. Let $\pi ^ { \prime } ( a \mid s , s _ { g } )$ be the goal-conditioned policy obtained after one iteration of contrastive $R L$ with a filtering parameter of ϵ. Then this policy achieves higher rewards than the initial goal-conditioned policy:
+
+$$
+\Sigma _ { \pi ^ { \prime } ( \tau | s _ { g } ) } \left[ \sum _ { t = 0 } ^ { \infty } \gamma ^ { t } r _ { s _ { g } } ( s _ { t } , a _ { t } ) \right] \geq \mathbb { E } _ { \pi ( \tau | s _ { g } ) } \left[ \sum _ { t = 0 } ^ { \infty } \gamma ^ { t } r _ { s _ { g } } ( s _ { t } , a _ { t } ) \right] - \frac { 2 \gamma \epsilon } { 1 - \gamma } ~ f o r a l l g o a l s ~ s _ { g } \in \left\{ s _ { g } ~ \left| ~ p _ { g } ( s _ { g } ) > 0 \right. \right\} ~ ,
+$$
+
+The proof is in Appendix B. This result shows that performing contrastive RL on static dataset results in one step of approximate policy improvement. Re-collecting data and then applying contrastive RL over and over again corresponds to approximate policy improvement (see [10, Lemma 6.2]).
+
+In summary, we have shown that applying contrastive learning to a particular choice of inputs results in an RL algorithm, one that learns a Q-function and (under some assumptions) converges to the reward-maximizing policy. Contrastive RL (NCE) is simple: it does not require multiple Q-values [40], target Q networks [88], data augmentation [69, 73], or auxiliary objectives [116, 137].
+
+![](images/1ca64a2563f82d848be02ca5d79a9b6c2d6a9a63377d212c19ae23f7a98b5dc1.jpg)  
+Figure 2: Goal-conditioned RL. Contrastive RL (NCE) outperforms prior methods on most tasks. Baselines: HER [80] is a prototypical actor-critic method that uses hindsight relabeling [6]; Goal-conditioned behavioral cloning (GCBC) [22, 41, 83, 117] performs behavior cloning on relabeled experience; model-based fits a density model to the discounted state occupancy measure, similar on [21, 23, 60].
+
+# 4.6 C-learning as Contrastive Learning
+
+C-learning [29] is a special case of contrastive RL: it learns a critic function to distinguish future goals from random goals. Compared with contrastive RL (NCE), C-learning learns the classifier using temporal difference learning.8 Viewing C-learning as a special case of contrastive RL suggests that contrastive RL algorithms might be implemented in a variety of different ways, each with relative merits. For example, contrastive RL (NCE) is much simpler than C-learning and tends to perform a bit better. Appendix D introduces another member of the contrastive RL family (contrastive RL (NCE + C-learning)) that tends to yield the best performance .
+
+# 5 Experiments
+
+Our experiments use goal-conditioned RL problems to compare contrastive RL algorithms to prior non-contrastive methods, including those that use data augmentation and auxiliary objectives. We then compare different members of the contrastive RL family, and show how contrastive RL can be effectively applied to the offline RL setting. Appendices E, F, and G contain experiments, visualizations, and failed experiments.
+
+# 5.1 Comparing to prior goal-conditioned RL methods
+
+Baselines. We compare three baselines. “HER” [80] is a goal-conditioned RL method that uses hindsight relabeling [6] with a high-performance actor-critic algorithm (TD3). This baseline is representative of a large class of prior work that uses hindsight relabeling [6, 76, 102, 106]. Like contrastive RL, this baseline does not assume access to a reward function. The second baseline is
+
+![](images/24bf4c78e2ba76c9727632380dd31f4b4da6d0eed9bfd40baba1900e44491f7a.jpg)  
+Figure 3: Environments. We show a subset of the goal-conditioned environments used in our experiments.
+
+goal-conditioned behavioral cloning (“GCBC”) [16, 22, 25, 41, 83, 96, 117, 120], which trains a policy to reach goal $s _ { g }$ by performing behavioral cloning on trajectories that reach state $s _ { g }$ . GCBC is a simple method that achieves excellent results [16, 25] and has the same inputs as our method $( ( s , a , s _ { f } )$ triplets). A third baseline is a model-based approach that fits a density model to the future state distribution $p ^ { \pi ( \cdot | \cdot ) } ( s _ { t + } \mid s , a )$ and trains a goal-conditioned policy to maximize the probability of the commanded goal. This baseline is similar to successor representations [21] and prior multi-step models [23, 60]. Both contrastive RL (Alg. 1) and this model-based approach encode the future state distribution, but the output dimension of this model-based method depends on the state dimension. We, therefore, expect this approach to excel in low-dimensional settings but struggle with image-based tasks. Where possible, we use the same hyperparameters for all methods. We will include additional representation learning baselines when studying representations in the subsequent section.
+
+![](images/0324fcf7af9daa045c58010e6953799e910ecb3fa84c8569ea4158d45379765d.jpg)  
+Figure 4: Representation learning for image-based tasks. While adding data augmentation and auxiliary representation objectives can boost the performance of the $_ { \mathrm { T D } 3 + \mathrm { H E R } }$ baseline, replacing the underlying goalconditioned RL algorithm with one that resembles contrastive representation learning (i.e., ours) yields a larger increase in success rates. Baselines: $\mathtt { D r Q }$ [69] augments images and averages the Q-values across 4 augmentations; auto encoder (AE) adds an auxiliary reconstruction loss [32, 91, 93, 137]; CURL [116] applies RL on top of representations learned via augmentation-based contrastive learning.
+
+Tasks. We compare it to a suite of goal-conditioned tasks, mostly taken from prior work. Four standard manipulation tasks include fetch reach and fetch push from Plappert et al. [97] and sawyer push and sawyer bin from Yu et al. [139]. We evaluate these tasks both with state-based observations and (unlike most prior work) image-based observations. The sawyer bin task poses an exploration challenge, as the agent must learn to pick up an object from one bin and place it at a goal location in another bin; the agent does not receive any reward shaping or demonstrations. We include two navigation tasks: point Spiral11x11 is a 2D maze task with image observations and ant umaze [36] is a 111-dimensional locomotion task that presents a challenging low-level control problem. Where possible, we use the same initial state distribution, goal distribution, observations, and definition of success as prior work. Goals have the same dimension as the states, with one exception: on the ant umaze task, we used the global $X Y$ position as the goal. We illustrate three of the tasks to the right. The agent does not have access to any ground truth reward function.
+
+We report results in Fig. 2, using five random seeds for each experiment and plotting the mean and standard deviation across those random seeds. On the state-based tasks (Fig. 2a), most methods solve the easiest task (fetch reach) while only our method solves the most challenging task (sawyer bin). Our method also outperforms all prior methods on the two pushing tasks. The model-based baseline performs best on the ant umaze task, likely because learning a model is relatively easy when the goal is lower-dimensional (just the $X Y$ location). On the image-based tasks (Fig. 2b), most methods make progress on the two easiest tasks (fetch reach and point Spiral11x11); our method outperforms the baselines on the three more challenging tasks. Of particular note is the success on sawyer push and sawyer bin: while the success rate of our method remains below $50 \%$ , no baselines make any progress on learning these tasks. These results suggest that contrastive RL (NCE) is a competitive goal-conditioned RL algorithm.
+
+# 5.2 Comparing to prior representation learning methods
+
+We hypothesize that contrastive RL may automatically learn good representations. To test this hypothesis, we compare contrastive RL (NCE) to techniques proposed by prior work for representation learning. These include data augmentation [69, 73, 136] (“DrQ”) and auxiliary objectives based on an autoencoder [32, 91, 93, 137] (“AE”) and a contrastive learning objective (“CURL”) that generates positive examples using data augmentation, similar to prior work [89, 116, 118]. Because prior work has demonstrated these techniques in combination with actor-critic RL algorithms, we will use these techniques in combination with the actor-critic baseline from the previous section $( ^ { 6 6 } \mathrm { T D } 3 + \mathrm { H E R } ^ { \prime \prime } )$ ). While contrastive RL (NCE) resembles a contrastive representation learning method, it does not include any data augmentation or auxiliary representation learning objectives.
+
+We show results in Fig. 4, with error bars again showing the mean and standard deviation across 5 random seeds. While adding the autoencoder improves the baseline on the fetch reach and adding DrQ improves the baseline on the sawyer push, contrastive RL (NCE) outperforms the prior methods on all tasks. Unlike these methods, contrastive RL does not use auxiliary objectives or additional domain knowledge in the form of image-appropriate data augmentations. These experiments do not show that representation learning is never useful, and do not show that contrastive
+
+![](images/7e580f4f14c0433f5ed7ccbf2ee289aa28efe0ce128a7053ace894649b8ff6f2.jpg)  
+Figure 5: Contrastive RL design decisions. Generalizing C-learning to a family of contrastive RL algorithms allowed us to identify algorithms that are much simpler (contrastive RL (NCE)) and that consistently achieve higher performance (contrastive RL $\mathrm { N C E } + \mathrm { C } .$ -learning)).
+
+RL cannot be improved with additional representation learning machinery. Rather, they show that designing RL algorithms that structurally resemble contrastive representation learning yields bigger improvements than simply adding representation learning tricks on top of existing RL algorithms.
+
+# 5.3 Probing the dimensions of contrastive RL
+
+Up to now, we have focused on the specific instantiation of contrastive RL spelled out in Alg. 1. However, there is a whole family of RL algorithms with contrastive characteristics. C-learning is a contrastive RL algorithm that uses temporal difference learning (Sec. 4.6). Contrastive RL (CPC) is a variant of Alg. 1 based on the infoNCE objective [95] that we derive in Appendix C Contrastive RL $\mathrm { \Delta N C E + C }$ -learning) is a variant that combines C-learning with Alg. D (see Appendix D.). The aim of these experiments are to study whether generalizing C-learning to a family of contrastive RL algorithms was useful: do the simpler methods achieve similar performance, and do other methods achieve better performance?
+
+We present results in Fig. 5, again plotting the mean and standard deviation across five random seeds. Contrastive RL (CPC) outperforms contrastive RL (NCE) on three, suggesting that swapping one mutual information estimator for another can sometimes improve performance, though both estimators can be effective. C-learning outperforms contrastive RL (NCE) on three tasks but performs worse on other tasks. Contrastive RL $\mathrm { \mathrm { N C E } } + \mathrm { C } .$ -learning) consistently ranks among the best methods. These experiments demonstrate that the prior contrastive RL method, C-learning [29], achieves good results on most tasks; generalizing C-learning to a family of contrastive RL algorithms resulting in new algorithms that achieve higher performance and can be much simpler.
+
+# 5.4 Partial Observability and Moving Cameras
+
+Many realistic robotics tasks exhibit partial observability, and have cameras that are not fixed but rather attached to moving robot parts. Our next experiment tests if contrastive RL can cope with these sorts of challenges. To study this question, we modified the sawyer push task so that the camera tracks the hand at a fixed distance, as if it were rigidly mounted to the arm. This means that, at the start of the episode, the scene is occluded by the wall at the edge of the table, so the agent cannot see the location of the puck (see Fig. 6 (left)). Nonetheless, contrastive RL (NCE) successfully handles this partial observability, achieving a success rate of around $3 5 \%$ . Fig. 6 (left) shows an example rollout and Fig. 6 (right) shows the learning curve. For comparison, the success rate when using the fixed static camera was $7 5 \%$ . Taken together, these results suggest that contrastive RL can cope with moving cameras and partial observability, while also suggesting that improved strategies (e.g., non-Markovian architectures) might achieve even better results.
+
+![](images/88f16492b8f6fb5daa983d7e7bc5f87499a49a07a960c64339e857b73a76a74a.jpg)  
+Figure 6: Partial observability and moving cameras. Contrastive RL can solve partially observed tasks.
+
+Table 1: Offline RL on D4RL AntMaze [36]. Contrastive RL outperforms all baselines in 5 out of 6 tasks.   
+
+<table><tr><td rowspan="2"></td><td colspan="5">no TD</td><td colspan="2">uses TD</td></tr><tr><td>BC</td><td>DT</td><td>GCBC</td><td>ContrastiveRL + BC 2 nets</td><td>5 nets</td><td>TD3+BC*</td><td>IQL*</td></tr><tr><td>umaze-v2</td><td>54.6</td><td>65.6</td><td>65.4</td><td>81.9 (±1.7)</td><td>79.8 (±1.4)</td><td>78.6</td><td>87.5</td></tr><tr><td>umaze-diverse-v2</td><td>45.6</td><td>51.2</td><td>60.9</td><td>75.4 (±3.5)</td><td>77.6 (±2.8)</td><td>71.4</td><td>62.2</td></tr><tr><td>medium-play-v2</td><td>0.0</td><td>1.0</td><td>58.1</td><td>71.5 (±5.2)</td><td>72.6 (±2.9)</td><td>10.6</td><td>71.2</td></tr><tr><td>medium-diverse-v2</td><td>0.0</td><td>0.6</td><td>67.3</td><td>72.5 (±2.8)</td><td>71.5 (±1.3)</td><td>3.0</td><td>70.0</td></tr><tr><td>large-play-v2</td><td>0.0</td><td>0.0</td><td>32.4</td><td>41.6 (±6.0)</td><td>48.6 (±4.4)</td><td>0.2</td><td>39.6</td></tr><tr><td>large-diverse-v2</td><td>0.0</td><td>0.2</td><td>36.9</td><td>49.3 (±6.3)</td><td>54.1 (±5.5)</td><td>0.0</td><td>47.5</td></tr><tr><td colspan="10">* While TD3+BCand IQLreport results onthe-vO tasks,the change to-v2 has anegligible effecton TD methods [8].</td></tr></table>
+
+# 5.5 Contrastive RL for Offline RL
+
+Our final experiment studies whether the benefits from contrastive RL (NCE) transfer to the offline RL setting, where the agent is prohibited from interacting with the environment. We use the benchmark AntMaze tasks from the D4RL benchmark [36], as these are goal-conditioned tasks commonly studied in the offline setting.
+
+We adapt contrastive RL (NCE) to the offline setting by adding an additional (goal-conditioned) behavioral cloning term to the policy objective (Eq. 7), using a coefficient of $\lambda$ :
+
+$$
+\operatorname* { m a x } _ { \pi ( a \mid s , s _ { g } ) } \mathbb { E } _ { \pi ( a \mid s , s _ { g } ) p ( s , a _ { \mathrm { o i g } } , s _ { g } ) } \left[ ( 1 - \lambda ) \cdot f ( s , a , s _ { f } = s _ { g } ) + \lambda \cdot \log \pi ( a _ { \mathrm { o i g } } \mid s , s _ { g } ) \right] .
+$$
+
+Note that setting $\lambda = 1$ corresponds to GCBC [16, 22, 25, 41, 83, 96, 117, 120], which we will include as a baseline. Following $\mathrm { T D } 3 { + } \mathrm { B C }$ [39], we learn multiple critic functions (2 and 5) and take the minimum when computing the actor update. We also compare to prior offline RL methods that eschew TD learning: (unconditional) behavioral cloning (BC), the implementation of GCBC from [25] (which refers to GCBC as RvS-G), and a recent method based on the transformer architecture (DT [16]). Lastly, we compare with two more complex methods that use TD learning: $\mathrm { T D } 3 { + } \mathrm { B C }$ [39] and IQL [68]. Unlike contrastive RL and GCBC, these TD learning methods do not perform goal relabeling. We use the numbers reported for these baselines in prior work [25, 68].
+
+As shown in Table 1, contrastive RL (NCE) outperforms all baselines on five of the six benchmark tasks. Of particular note are the most challenging “-large” tasks, where contrastive RL achieves a $7 \%$ to $9 \%$ absolute improvement over IQL. We note that IQL does not use goal relabeling, which is the bedrock of contrastive RL. Compared to baselines that do not use TD learning, the benefits are more pronounced, with a median (absolute) improvement over GCBC of $15 \%$ . The performance of contrastive RL improves when increasing the number of critics from 2 to 5, suggesting that the key to solving more challenging offline RL tasks may be increased capacity, rather than TD learning. Taken together, these results show the value of contrastive RL for offline goal-conditioned tasks.
+
+# 6 Conclusion
+
+In this paper, we showed how contrastive representation learning can be used for goal-conditioned RL. This connection not only lets us re-interpret a prior RL method as performing contrastive learning, but also suggests a family of contrastive RL methods, which includes simpler algorithms, as well as algorithms that attain better overall performance. While this paper might be construed to imply that RL is more or less important than representation learning [72, 75, 112, 114], we have a different takeaway: that it may be enough to build RL algorithms that look like representation learning.
+
+One limitation of this work is that it looks only at the goal-conditioned RL problems. How these methods might be applied to arbitrary RL problems remains an open problem, though we note that recent algorithms for this setting [28] already bear a resemblance to contrastive RL. Whether the rich set of ideas from contrastive learning might be used to construct even better RL algorithms likewise remains an open question.
+
+Acknowledgements. Thanks to Hubert Tsai, Martin Ma, and Simon Kornblith for discussions about contrastive learning. Thanks to Kamyar Ghasemipour, Suraj Nair, and anonymous reviewers for feedback on the paper. Thanks to Ofir Nachum, Daniel Zheng, and the JAX and Acme teams for helping to release and debug the code. This material is supported by the Fannie and John Hertz Foundation and the NSF GRFP (DGE1745016). UC Berkeley research is also supported by gifts from Alibaba, Amazon Web Services, Ant Financial, CapitalOne, Ericsson, Facebook, Futurewei, Google, Intel, Microsoft, Nvidia, Scotiabank, Splunk and VMware.
+
+References   
+[1] Achiam, J., Edwards, H., Amodei, D., and Abbeel, P. (2018). Variational option discovery algorithms. arXiv preprint arXiv:1807.10299.   
+[2] Achiam, J., Knight, E., and Abbeel, P. (2019). Towards characterizing divergence in deep Q-learning. arXiv preprint arXiv:1903.08894.   
+[3] Alain, G. and Bengio, Y. (2016). Understanding intermediate layers using linear classifier probes. arXiv preprint arXiv:1610.01644.   
+[4] Anand, A., Racah, E., Ozair, S., Bengio, Y., Côté, M.-A., and Hjelm, R. D. (2019). Unsupervised state representation learning in Atari. Advances in Neural Information Processing Systems, 32.   
+[5] Andreas, J., Klein, D., and Levine, S. (2017). Modular multitask reinforcement learning with policy sketches. In International Conference on Machine Learning, pages 166–175. PMLR.   
+[6] Andrychowicz, M., Crow, D., Ray, A., Schneider, J., Fong, R., Welinder, P., McGrew, B., Tobin, J., Abbeel, P., and Zaremba, W. (2017). Hindsight experience replay. In NeurIPS.   
+[7] Annasamy, R. M. and Sycara, K. (2019). Towards better interpretability in deep Q-networks. In Proceedings of the AAAI Conference on Artificial Intelligence, volume 33, pages 4561–4569.   
+[8] Authors, I. (2022). Private Communication.   
+[9] Barreto, A., Dabney, W., Munos, R., Hunt, J. J., Schaul, T., van Hasselt, H. P., and Silver, D. (2017). Successor features for transfer in reinforcement learning. Advances in neural information processing systems, 30.   
+[10] Bertsekas, D. P. and Tsitsiklis, J. N. (1996). Neuro-dynamic programming. Athena Scientific.   
+[11] Blier, L., Tallec, C., and Ollivier, Y. (2021). Learning successor states and goal-dependent values: A mathematical viewpoint. arXiv preprint arXiv:2101.07123.   
+[12] Borsa, D., Barreto, A., Quan, J., Mankowitz, D., Munos, R., Van Hasselt, H., Silver, D., and Schaul, T. (2018). Universal successor features approximators. arXiv preprint arXiv:1812.07626.   
+[13] Bradbury, J., Frostig, R., Hawkins, P., Johnson, M. J., Leary, C., Maclaurin, D., Necula, G., Paszke, A., VanderPlas, J., Wanderman-Milne, S., and Zhang, Q. (2018). JAX: composable transformations of Python+NumPy programs.   
+[14] Brown, D., Goo, W., Nagarajan, P., and Niekum, S. (2019). Extrapolating beyond suboptimal demonstrations via inverse reinforcement learning from observations. In International conference on machine learning, pages 783–792. PMLR.   
+[15] Chane-Sane, E., Schmid, C., and Laptev, I. (2021). Goal-conditioned reinforcement learning with imagined subgoals. In International Conference on Machine Learning, pages 1430–1440. PMLR.   
+[16] Chen, L., Lu, K., Rajeswaran, A., Lee, K., Grover, A., Laskin, M., Abbeel, P., Srinivas, A., and Mordatch, I. (2021). Decision transformer: Reinforcement learning via sequence modeling. Advances in neural information processing systems, 34.   
+[17] Chen, T., Kornblith, S., Norouzi, M., and Hinton, G. E. (2020). A simple framework for contrastive learning of visual representations. ArXiv, abs/2002.05709.   
+[18] Chen, X. and He, K. (2021). Exploring simple siamese representation learning. 2021 IEEE/CVF Conference on Computer Vision and Pattern Recognition (CVPR), pages 15745–15753.   
+[19] Choi, J., Sharma, A., Lee, H., Levine, S., and Gu, S. S. (2021). Variational empowerment as representation learning for goal-conditioned reinforcement learning. In International Conference on Machine Learning, pages 1953–1963. PMLR.   
+[20] Christiano, P., Leike, J., Brown, T. B., Martic, M., Legg, S., and Amodei, D. (2017). Deep reinforcement learning from human preferences. arXiv preprint arXiv:1706.03741.   
+[21] Dayan, P. (1993). Improving generalization for temporal difference learning: The successor representation. Neural Computation, 5(4):613–624.   
+[22] Ding, Y., Florensa, C., Abbeel, P., and Phielipp, M. (2019). Goal-conditioned imitation learning. Advances in Neural Information Processing Systems, 32:15324–15335.   
+[23] Dosovitskiy, A. and Koltun, V. (2016). Learning to act by predicting the future. arXiv preprint arXiv:1611.01779.   
+[24] Du, Y., Gan, C., and Isola, P. (2021). Curious representation learning for embodied intelligence. In Proceedings of the IEEE/CVF International Conference on Computer Vision, pages 10408–10417.   
+[25] Emmons, S., Eysenbach, B., Kostrikov, I., and Levine, S. (2021). Rvs: What is essential for offline rl via supervised learning? arXiv preprint arXiv:2112.10751.   
+[26] Eysenbach, B., Geng, X., Levine, S., and Salakhutdinov, R. (2020). Rewriting history with inverse RL: Hindsight inference for policy improvement. ArXiv, abs/2002.11089.   
+[27] Eysenbach, B., Gupta, A., Ibarz, J., and Levine, S. (2018). Diversity is all you need: Learning skills without a reward function. In International Conference on Learning Representations.   
+[28] Eysenbach, B., Levine, S., and Salakhutdinov, R. R. (2021a). Replacing rewards with examples: Examplebased policy search via recursive classification. Advances in Neural Information Processing Systems, 34.   
+[29] Eysenbach, B., Salakhutdinov, R., and Levine, S. (2021b). C-learning: Learning to achieve goals via recursive classification. ArXiv, abs/2011.08909.   
+[30] Eysenbach, B., Salakhutdinov, R. R., and Levine, S. (2019). Search on the replay buffer: Bridging planning and reinforcement learning. Advances in Neural Information Processing Systems, 32.   
+[31] Eysenbach, B., Udatha, S., Levine, S., and Salakhutdinov, R. (2022). Imitating past successes can be very suboptimal. arXiv preprint arXiv:2206.03378.   
+[32] Finn, C., Tan, X. Y., Duan, Y., Darrell, T., Levine, S., and Abbeel, P. (2016). Deep spatial autoencoders for visuomotor learning. In 2016 IEEE International Conference on Robotics and Automation (ICRA), pages 512–519. IEEE.   
+[33] Fischinger, D., Vincze, M., and Jiang, Y. (2013). Learning grasps for unknown objects in cluttered scenes. In 2013 IEEE international conference on robotics and automation, pages 609–616. IEEE.   
+[34] Florensa, C., Degrave, J., Heess, N., Springenberg, J. T., and Riedmiller, M. (2019). Self-supervised learning of image embedding for continuous control. arXiv preprint arXiv:1901.00943.   
+[35] Florensa, C., Held, D., Geng, X., and Abbeel, P. (2018). Automatic goal generation for reinforcement learning agents. In International conference on machine learning, pages 1515–1528. PMLR.   
+[36] Fu, J., Kumar, A., Nachum, O., Tucker, G., and Levine, S. (2020). D4RL: Datasets for deep data-driven reinforcement learning. arXiv preprint arXiv:2004.07219.   
+[37] Fu, J., Luo, K., and Levine, S. (2017). Learning robust rewards with adversarial inverse reinforcement learning. arXiv preprint arXiv:1710.11248.   
+[38] Fu, J., Singh, A., Ghosh, D., Yang, L., and Levine, S. (2018). Variational inverse control with events: A general framework for data-driven reward definition. In NeurIPS.   
+[39] Fujimoto, S. and Gu, S. S. (2021). A minimalist approach to offline reinforcement learning. Advances in Neural Information Processing Systems, 34.   
+[40] Fujimoto, S., Hoof, H., and Meger, D. (2018). Addressing function approximation error in actor-critic methods. In International conference on machine learning, pages 1587–1596. PMLR.   
+[41] Ghosh, D., Gupta, A., Reddy, A., Fu, J., Devin, C. M., Eysenbach, B., and Levine, S. (2020). Learning to reach goals via iterated supervised learning. In International Conference on Learning Representations.   
+[42] Gregor, K., Rezende, D. J., and Wierstra, D. (2016). Variational intrinsic control. arXiv preprint arXiv:1611.07507.   
+[43] Grill, J.-B., Strub, F., Altch’e, F., Tallec, C., Richemond, P. H., Buchatskaya, E., Doersch, C., Pires, B. Á., Guo, Z. D., Azar, M. G., Piot, B., Kavukcuoglu, K., Munos, R., and Valko, M. (2020). Bootstrap your own latent: A new approach to self-supervised learning. ArXiv, abs/2006.07733.   
+[44] Guo, Z. D., Azar, M. G., Piot, B., Pires, B. A., and Munos, R. (2018). Neural predictive belief representations. arXiv preprint arXiv:1811.06407.   
+[45] Guo, Z. D., Pires, B. A., Piot, B., Grill, J.-B., Altché, F., Munos, R., and Azar, M. G. (2020). Bootstrap latent-predictive representations for multitask reinforcement learning. In International Conference on Machine Learning, pages 3875–3886. PMLR.   
+[46] Gutmann, M. U. and Hyvärinen, A. (2012). Noise-contrastive estimation of unnormalized statistical models, with applications to natural image statistics. Journal of machine learning research, 13(2).   
+[47] Ha, D. and Schmidhuber, J. (2018). World models. arXiv preprint arXiv:1803.10122.   
+[48] Haarnoja, T., Zhou, A., Abbeel, P., and Levine, S. (2018). Soft actor-critic: Off-policy maximum entropy deep reinforcement learning with a stochastic actor. In International conference on machine learning, pages 1861–1870. PMLR.   
+[49] Hafner, D., Lillicrap, T., Ba, J., and Norouzi, M. (2019a). Dream to control: Learning behaviors by latent imagination. arXiv preprint arXiv:1912.01603.   
+[50] Hafner, D., Lillicrap, T., Fischer, I., Villegas, R., Ha, D., Lee, H., and Davidson, J. (2019b). Learning latent dynamics for planning from pixels. In International conference on machine learning, pages 2555–2565. PMLR.   
+[51] Han, T., Xie, W., and Zisserman, A. (2020). Self-supervised co-training for video representation learning. Advances in Neural Information Processing Systems, 33:5679–5690.   
+[52] Hansen, S., Dabney, W., Barreto, A., Van de Wiele, T., Warde-Farley, D., and Mnih, V. (2019). Fast task inference with variational intrinsic successor features. arXiv preprint arXiv:1906.05030.   
+[53] He, K., Fan, H., Wu, Y., Xie, S., and Girshick, R. (2020). Momentum contrast for unsupervised visual representation learning. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, pages 9729–9738.   
+[54] Hjelm, R. D., Fedorov, A., Lavoie-Marchildon, S., Grewal, K., Bachman, P., Trischler, A., and Bengio, Y. (2018). Learning deep representations by mutual information estimation and maximization. arXiv preprint arXiv:1808.06670.   
+[55] Ho, J. and Ermon, S. (2016). Generative adversarial imitation learning. Advances in neural information processing systems, 29:4565–4573.   
+[56] Hoffer, E. and Ailon, N. (2015). Deep metric learning using triplet network. In International workshop on similarity-based pattern recognition, pages 84–92. Springer.   
+[57] Hoffman, M., Shahriari, B., Aslanides, J., Barth-Maron, G., Behbahani, F., Norman, T., Abdolmaleki, A., Cassirer, A., Yang, F., Baumli, K., Henderson, S., Novikov, A., Colmenarejo, S. G., Cabi, S., Gulcehre, C., Paine, T. L., Cowie, A., Wang, Z., Piot, B., and de Freitas, N. (2020). Acme: A research framework for distributed reinforcement learning. arXiv preprint arXiv:2006.00979.   
+[58] Hong, Z.-W., Yang, G., and Agrawal, P. (2022). Bilinear value networks. arXiv preprint arXiv:2204.13695.   
+[59] Ichter, B., Sermanet, P., and Lynch, C. (2020). Broadly-exploring, local-policy trees for long-horizon task planning. arXiv preprint arXiv:2010.06491.   
+[60] Janner, M., Mordatch, I., and Levine, S. (2020). gamma-models: Generative temporal difference learning for infinite-horizon prediction. Advances in Neural Information Processing Systems, 33:1724–1735.   
+[61] Jozefowicz, R., Vinyals, O., Schuster, M., Shazeer, N., and Wu, Y. (2016). Exploring the limits of language modeling. arXiv preprint arXiv:1602.02410.   
+[62] Kaelbling, L. P. (1993). Learning to achieve goals. In IJCAI, pages 1094–1099. Citeseer.   
+[63] Kalashnikov, D., Varley, J., Chebotar, Y., Swanson, B., Jonschkowski, R., Finn, C., Levine, S., and Hausman, K. (2021). Mt-opt: Continuous multi-task robotic reinforcement learning at scale. ArXiv, abs/2104.08212.   
+[64] Kish, L. (1965). Survey sampling. John Wiley & Sons.   
+[65] Klingemann, M. (2016). Raster fairy. https://github.com/bmcfee/RasterFairy.   
+[66] Konda, V. and Tsitsiklis, J. (1999). Actor-critic algorithms. Advances in neural information processing systems, 12.   
+[67] Konyushkova, K., Zolna, K., Aytar, Y., Novikov, A., Reed, S., Cabi, S., and de Freitas, N. (2020). Semi-supervised reward learning for offline reinforcement learning. arXiv preprint arXiv:2012.06899.   
+[68] Kostrikov, I., Nair, A., and Levine, S. (2021). Offline reinforcement learning with implicit Q-learning. arXiv preprint arXiv:2110.06169.   
+[69] Kostrikov, I., Yarats, D., and Fergus, R. (2020). Image augmentation is all you need: Regularizing deep reinforcement learning from pixels. arXiv preprint arXiv:2004.13649.   
+[70] Kumar, A., Agarwal, R., Ghosh, D., and Levine, S. (2020). Implicit under-parameterization inhibits data-efficient deep reinforcement learning. arXiv preprint arXiv:2010.14498.   
+[71] Lange, S. and Riedmiller, M. (2010). Deep auto-encoder neural networks in reinforcement learning. In The 2010 International Joint Conference on Neural Networks (IJCNN), pages 1–8. IEEE.   
+[72] Langford, J. (2010). Specializations of the master problem.   
+[73] Laskin, M., Lee, K., Stooke, A., Pinto, L., Abbeel, P., and Srinivas, A. (2020). Reinforcement learning with augmented data. Advances in Neural Information Processing Systems, 33:19884–19895.   
+[74] Laskin, M., Liu, H., Peng, X. B., Yarats, D., Rajeswaran, A., and Abbeel, P. (2021). CIC: Contrastive intrinsic control for unsupervised skill discovery. In Deep RL Workshop NeurIPS 2021.   
+[75] LeCun, Y. (2016). Predictive learning. https://www.youtube.com/watch?v $=$ Ount2Y4qxQo. Keynote Talk.   
+[76] Levy, A., Konidaris, G., Platt, R., and Saenko, K. (2017). Learning multi-level hierarchies with hindsight. arXiv preprint arXiv:1712.00948.   
+[77] Levy, O. and Goldberg, Y. (2014). Neural word embedding as implicit matrix factorization. Advances in neural information processing systems, 27.   
+[78] Li, A., Pinto, L., and Abbeel, P. (2020). Generalized hindsight for reinforcement learning. Advances in neural information processing systems, 33:7754–7767.   
+[79] Liang, Y., Machado, M. C., Talvitie, E., and Bowling, M. (2015). State of the art control of Atari games using shallow reinforcement learning. arXiv preprint arXiv:1512.01563.   
+[80] Lin, X., Baweja, H. S., and Held, D. (2019). Reinforcement learning without ground-truth state. ArXiv, abs/1905.07866.   
+[81] Liu, H. and Abbeel, P. (2021). Aps: Active pretraining with successor features. In International Conference on Machine Learning, pages 6736–6747. PMLR.   
+[82] Liu, K., Kurutach, T., Tung, C., Abbeel, P., and Tamar, A. (2020). Hallucinative topological memory for zero-shot visual planning. In International Conference on Machine Learning, pages 6259–6270. PMLR.   
+[83] Lynch, C., Khansari, M., Xiao, T., Kumar, V., Tompson, J., Levine, S., and Sermanet, P. (2020). Learning latent plans from play. In Conference on Robot Learning, pages 1113–1132. PMLR.   
+[84] Ma, Z. and Collins, M. (2018). Noise contrastive estimation and negative sampling for conditional models: Consistency and statistical efficiency. In EMNLP.   
+[85] Mendonca, R., Rybkin, O., Daniilidis, K., Hafner, D., and Pathak, D. (2021). Discovering and achieving goals via world models. Advances in Neural Information Processing Systems, 34.   
+[86] Mikolov, T., Sutskever, I., Chen, K., Corrado, G. S., and Dean, J. (2013). Distributed representations of words and phrases and their compositionality. Advances in neural information processing systems, 26.   
+[87] Mnih, A. and Teh, Y. W. (2012). A fast and simple algorithm for training neural probabilistic language models. In ICML.   
+[88] Mnih, V., Kavukcuoglu, K., Silver, D., Graves, A., Antonoglou, I., Wierstra, D., and Riedmiller, M. (2013). Playing atari with deep reinforcement learning. arXiv preprint arXiv:1312.5602.   
+[89] Nachum, O., Gu, S., Lee, H., and Levine, S. (2018a). Near-optimal representation learning for hierarchical reinforcement learning. In International Conference on Learning Representations.   
+[90] Nachum, O., Gu, S. S., Lee, H., and Levine, S. (2018b). Data-efficient hierarchical reinforcement learning. Advances in neural information processing systems, 31.   
+[91] Nair, A. V., Pong, V., Dalal, M., Bahl, S., Lin, S., and Levine, S. (2018). Visual reinforcement learning with imagined goals. Advances in Neural Information Processing Systems, 31:9191–9200.   
+[92] Nair, S., Mitchell, E., Chen, K., Savarese, S., Finn, C., et al. (2022). Learning language-conditioned robot behavior from offline data and crowd-sourced annotation. In Conference on Robot Learning, pages 1303–1315. PMLR.   
+[93] Nasiriany, S., Pong, V. H., Lin, S., and Levine, S. (2019). Planning with goal-conditioned policies. In NeurIPS.   
+[94] Nowozin, S., Cseke, B., and Tomioka, R. (2016). f-GAN: Training generative neural samplers using variational divergence minimization. Advances in neural information processing systems, 29.   
+[95] Oord, A. v. d., Li, Y., and Vinyals, O. (2018). Representation learning with contrastive predictive coding. arXiv preprint arXiv:1807.03748.   
+[96] Paster, K., McIlraith, S. A., and Ba, J. (2020). Planning from pixels using inverse dynamics models. arXiv preprint arXiv:2012.02419.   
+[97] Plappert, M., Andrychowicz, M., Ray, A., McGrew, B., Baker, B., Powell, G., Schneider, J., Tobin, J., Chociej, M., Welinder, P., et al. (2018). Multi-goal reinforcement learning: Challenging robotics environments and request for research. arXiv preprint arXiv:1802.09464.   
+[98] Pong, V. H., Dalal, M., Lin, S., Nair, A., Bahl, S., and Levine, S. (2019). Skew-fit: State-covering self-supervised reinforcement learning. arXiv preprint arXiv:1903.03698.   
+[99] Poole, B., Ozair, S., Van Den Oord, A., Alemi, A., and Tucker, G. (2019). On variational bounds of mutual information. In International Conference on Machine Learning, pages 5171–5180. PMLR.   
+[100] Qiu, S., Wang, L., Bai, C., Yang, Z., and Wang, Z. (2022). Contrastive ucb: Provably efficient contrastive self-supervised learning in online reinforcement learning. In International Conference on Machine Learning, pages 18168–18210. PMLR.   
+[101] Rakelly, K., Gupta, A., Florensa, C., and Levine, S. (2021). Which mutual-information representation learning objectives are sufficient for control? ArXiv, abs/2106.07278.   
+[102] Riedmiller, M., Hafner, R., Lampe, T., Neunert, M., Degrave, J., Wiele, T., Mnih, V., Heess, N., and Springenberg, J. T. (2018). Learning by playing solving sparse reward tasks from scratch. In International conference on machine learning, pages 4344–4353. PMLR.   
+[103] Rudner, T. G., Pong, V., McAllister, R., Gal, Y., and Levine, S. (2021). Outcome-driven reinforcement learning via variational inference. Advances in Neural Information Processing Systems, 34.   
+[104] Rybkin, O., Zhu, C., Nagabandi, A., Daniilidis, K., Mordatch, I., and Levine, S. (2021). Model-based reinforcement learning via latent-space collocation. In International Conference on Machine Learning, pages 9190–9201. PMLR.   
+[105] Savinov, N., Dosovitskiy, A., and Koltun, V. (2018). Semi-parametric topological memory for navigation. In International Conference on Learning Representations.   
+[106] Schaul, T., Horgan, D., Gregor, K., and Silver, D. (2015). Universal value function approximators. In International conference on machine learning, pages 1312–1320. PMLR.   
+[107] Schmeckpeper, K., Xie, A., Rybkin, O., Tian, S., Daniilidis, K., Levine, S., and Finn, C. (2020). Learning predictive models from observation and interaction. In European Conference on Computer Vision, pages 708–725. Springer.   
+[108] Schroff, F., Kalenichenko, D., and Philbin, J. (2015). Facenet: A unified embedding for face recognition and clustering. 2015 IEEE Conference on Computer Vision and Pattern Recognition (CVPR), pages 815–823.   
+[109] Sermanet, P., Lynch, C., Chebotar, Y., Hsu, J., Jang, E., Schaal, S., Levine, S., and Brain, G. (2018). Time-contrastive networks: Self-supervised learning from video. In 2018 IEEE international conference on robotics and automation (ICRA), pages 1134–1141. IEEE.   
+[110] Sharma, A., Gu, S., Levine, S., Kumar, V., and Hausman, K. (2019). Dynamics-aware unsupervised discovery of skills. In International Conference on Learning Representations.   
+[111] Shu, R., Nguyen, T., Chow, Y., Pham, T., Than, K., Ghavamzadeh, M., Ermon, S., and Bui, H. (2020). Predictive coding for locally-linear control. In International Conference on Machine Learning, pages 8862–8871. PMLR.   
+[112] Silver, D., Singh, S., Precup, D., and Sutton, R. S. (2021). Reward is enough. Artificial Intelligence, 299:103535.   
+[113] Sohn, K. (2016). Improved deep metric learning with multi-class n-pair loss objective. In NeurIPS.   
+[114] Srinivas, A. and Abbeel, P. (2021). Unsupervised learning for reinforcement learning. Tutorial.   
+[115] Srinivas, A., Jabri, A., Abbeel, P., Levine, S., and Finn, C. (2018). Universal planning networks. ArXiv, abs/1804.00645.   
+[116] Srinivas, A., Laskin, M., and Abbeel, P. (2020). Curl: Contrastive unsupervised representations for reinforcement learning. arXiv preprint arXiv:2004.04136.   
+[117] Srivastava, R. K., Shyam, P., Mutz, F., Jaskowski, W., and Schmidhuber, J. (2019). Training agents using ´ upside-down reinforcement learning. arXiv preprint arXiv:1912.02877.   
+[118] Stooke, A., Lee, K., Abbeel, P., and Laskin, M. (2021). Decoupling representation learning from reinforcement learning. In International Conference on Machine Learning, pages 9870–9879. PMLR.   
+[119] Such, F. P., Madhavan, V., Liu, R., Wang, R., Castro, P. S., Li, Y., Zhi, J., Schubert, L., Bellemare, M. G., Clune, J., et al. (2018). An atari model zoo for analyzing, visualizing, and comparing deep reinforcement learning agents. arXiv preprint arXiv:1812.07069.   
+[120] Sun, H., Li, Z., Liu, X., Zhou, B., and Lin, D. (2019). Policy continuation with hindsight inverse dynamics. Advances in Neural Information Processing Systems, 32:10265–10275.   
+[121] Teh, Y., Bapst, V., Czarnecki, W. M., Quan, J., Kirkpatrick, J., Hadsell, R., Heess, N., and Pascanu, R. (2017). Distral: Robust multitask reinforcement learning. Advances in neural information processing systems, 30.   
+[122] Tian, Y., Krishnan, D., and Isola, P. (2020). Contrastive multiview coding. In Computer Vision–ECCV 2020: 16th European Conference, Glasgow, UK, August 23–28, 2020, Proceedings, Part XI 16, pages 776–794. Springer.   
+[123] Tsai, Y.-H., Zhao, H., Yamada, M., Morency, L.-P., and Salakhutdinov, R. (2020). Neural methods for point-wise dependency estimation. In Proceedings of the Neural Information Processing Systems Conference (Neurips).   
+[124] Tschannen, M., Djolonga, J., Rubenstein, P. K., Gelly, S., and Lucic, M. (2019). On mutual information maximization for representation learning. arXiv preprint arXiv:1907.13625.   
+[125] Venkattaramanujam, S., Crawford, E., Doan, T. V., and Precup, D. (2019). Self-supervised learning of distance functions for goal-conditioned reinforcement learning. ArXiv, abs/1907.02998.   
+[126] Wang, H., Miahi, E., White, M., Machado, M. C., Abbas, Z., Kumaraswamy, R., Liu, V., and White, A. (2022). Investigating the properties of neural network representations in reinforcement learning. arXiv preprint arXiv:2203.15955.   
+[127] Warde-Farley, D., Van de Wiele, T., Kulkarni, T., Ionescu, C., Hansen, S., and Mnih, V. (2018). Unsupervised control through non-parametric discriminative rewards. arXiv preprint arXiv:1811.11359.   
+[128] Watter, M., Springenberg, J., Boedecker, J., and Riedmiller, M. (2015). Embed to control: A locally linear latent dynamics model for control from raw images. Advances in neural information processing systems, 28.   
+[129] Weinberger, K. Q. and Saul, L. K. (2005). Distance metric learning for large margin nearest neighbor classification. In NIPS.   
+[130] Wilson, A., Fern, A., Ray, S., and Tadepalli, P. (2007). Multi-task reinforcement learning: a hierarchical bayesian approach. In Proceedings of the 24th international conference on Machine learning, pages 1015– 1022.   
+[131] Wu, Y., Tucker, G., and Nachum, O. (2018a). The Laplacian in RL: Learning representations with efficient approximations. arXiv preprint arXiv:1810.04586.   
+[132] Wu, Z., Xiong, Y., Yu, S. X., and Lin, D. (2018b). Unsupervised feature learning via non-parametric instance discrimination. 2018 IEEE/CVF Conference on Computer Vision and Pattern Recognition, pages 3733–3742.   
+[133] Xie, A., Singh, A., Levine, S., and Finn, C. (2018). Few-shot goal inference for visuomotor learning and planning. In Conference on Robot Learning, pages 40–52. PMLR.   
+[134] Xu, D. and Denil, M. (2019). Positive-unlabeled reward learning. arXiv preprint arXiv:1911.00459.   
+[135] Yang, G., Ajay, A., and Agrawal, P. (2021). Overcoming the spectral bias of neural value approximation. In International Conference on Learning Representations.   
+[136] Yarats, D., Fergus, R., Lazaric, A., and Pinto, L. (2021a). Mastering visual continuous control: Improved data-augmented reinforcement learning. arXiv preprint arXiv:2107.09645.   
+[137] Yarats, D., Zhang, A., Kostrikov, I., Amos, B., Pineau, J., and Fergus, R. (2021b). Improving sample efficiency in model-free reinforcement learning from images. In AAAI.   
+[138] Yu, T., Kumar, S., Gupta, A., Levine, S., Hausman, K., and Finn, C. (2020a). Gradient surgery for multi-task learning. Advances in Neural Information Processing Systems, 33:5824–5836.   
+[139] Yu, T., Quillen, D., He, Z., Julian, R., Hausman, K., Finn, C., and Levine, S. (2020b). Meta-world: A benchmark and evaluation for multi-task and meta reinforcement learning. In Conference on Robot Learning, pages 1094–1100. PMLR.   
+[140] Zhang, A., McAllister, R. T., Calandra, R., Gal, Y., and Levine, S. (2020a). Learning invariant representations for reinforcement learning without reconstruction. In International Conference on Learning Representations.   
+[141] Zhang, M., Vikram, S., Smith, L., Abbeel, P., Johnson, M., and Levine, S. (2019). Solar: Deep structured representations for model-based reinforcement learning. In International Conference on Machine Learning, pages 7444–7453. PMLR.   
+[142] Zhang, S., Liu, B., and Whiteson, S. (2020b). Gradientdice: Rethinking generalized offline estimation of stationary values. In International Conference on Machine Learning, pages 11194–11203. PMLR.   
+[143] Zhang, T., Ren, T., Yang, M., Gonzalez, J., Schuurmans, D., and Dai, B. (2022). Making linear mdps practical via contrastive representation learning. In International Conference on Machine Learning, pages 26447–26466. PMLR.   
+[144] Zhao, R., Sun, X., and Tresp, V. (2019). Maximum entropy-regularized multi-goal reinforcement learning. In International Conference on Machine Learning, pages 7553–7562. PMLR.   
+[145] Ziebart, B. D. (2010). Modeling purposeful adaptive behavior with the principle of maximum causal entropy. Carnegie Mellon University.   
+[146] Zolna, K., Reed, S., Novikov, A., Colmenarejo, S. G., Budden, D., Cabi, S., Denil, M., de Freitas, N., and Wang, Z. (2019). Task-relevant adversarial imitation learning. arXiv preprint arXiv:1910.01077.
+
+# 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] The main claims are that (1) contrastive learning can be used to learn a Q-function (Proof in Appendix B) and that (2) contrastive RL methods can outperform non-contrastive RL algorithms on goal-conditioned RL tasks (results in Fig. 2).   
+(b) Did you describe the limitations of your work? [Yes] See Sec. 6.   
+(c) Did you discuss any potential negative societal impacts of your work? [No] While RL broadly might be used for applications with both positive and negative outcomes, our algorithmic contributions are not tied to any particular application.   
+(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 B
+
+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] We have included all experimental details in Appendix E; code will be released upon acceptance.   
+(b) Did you specify all the training details (e.g., data splits, hyperparameters, how they were chosen)? [Yes] See Appendix E.   
+(c) Did you report error bars (e.g., with respect to the random seed after running experiments multiple times)? [Yes] All figures show 5 random seeds, witht error bars corresponding to the mean and standard deviation across these seeds.   
+(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] Sec. 4.4 describes the training speed on one TPUv2.
+
+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? [N/A]   
+(b) Did you mention the license of the assets? [N/A]   
+(c) Did you include any new assets either in the supplemental material or as a URL? [N/A]   
+(d) Did you discuss whether and how consent was obtained from people whose data you’re using/curating? [N/A]   
+(e) Did you discuss whether the data you are using/curating contains personally identifiable information or offensive content? [N/A]
+
+5. If you used crowdsourcing or conducted research with human subjects...
+
+(a) Did you include the full text of instructions given to participants and screenshots, if applicable? [N/A]   
+(b) Did you describe any potential participant risks, with links to Institutional Review Board (IRB) approvals, if applicable? [N/A]   
+(c) Did you include the estimated hourly wage paid to participants and the total amount spent on participant compensation? [N/A]