Upload folder using huggingface_hub (part 28)

parse/dev/XomEU3eNeSQ/XomEU3eNeSQ.md

@@ -0,0 +1,355 @@
+# CODE TRANSLATION WITH COMPILER REPRESENTATIONS
+
+Marc Szafraniec∗ Baptiste Rozière\* Patrick Labatut Gabriel Synnaeve
+
+Hugh Leather François Charton
+
+Meta AI {mszafraniec,broz}@meta.com
+
+# ABSTRACT
+
+In this paper, we leverage low-level compiler intermediate representations (IR) to improve code translation. Traditional transpilers rely on syntactic information and handcrafted rules, which limits their applicability and produces unnaturallooking code. Applying neural machine translation (NMT) approaches to code has successfully broadened the set of programs on which one can get a naturallooking translation. However, they treat the code as sequences of text tokens, and still do not differentiate well enough between similar pieces of code which have different semantics in different languages. The consequence is low quality translation, reducing the practicality of NMT, and stressing the need for an approach significantly increasing its accuracy. Here we propose to augment code translation with IRs, specifically LLVM IR, with results on the $\mathrm { C } { + } { + }$ , Java, Rust, and Go languages. Our method improves upon the state of the art for unsupervised code translation, increasing the number of correct translations by $11 \%$ on average, and up to $79 \%$ for the Java $ \mathrm { R u s t }$ pair with greedy decoding. With beam search, it increases the number of correct translations by $5 . 5 \%$ in average. We extend previous test sets for code translation, by adding hundreds of Go and Rust functions. Additionally, we train models with high performance on the problem of IR decompilation, generating programming source code from IR, and study using IRs as intermediary pivot for translation.
+
+# 1 INTRODUCTION
+
+Automatic code translation allows to port old codebases to new frameworks, or high-level (but slow) languages to low-level (and fast) ones. Current industry solutions, known as transpilers or transcompilers1, rely on handcrafted rules that are applied systematically. They produce unidiomatic translations that prove hard to read for human programmers. This is a serious limitation: the translated code should be easy to read and understand, as it will eventually be maintained by human developers.
+
+In recent years, Neural Machine Translation (NMT) was proposed as an alternative to rule-based code translation (Roziere et al., 2020; Weisz et al., 2021; 2022). These models, trained from existing human-readable code, produce idiomatic, easy to understand, translations. Unfortunately, neural transpilers are unreliable, and often fail to translate the semantics of the input program accurately. This is a serious limitation, as some of the human work saved by the transpiler has to be reinvested debugging its output.
+
+We propose to improve the reliability of NMT by leveraging information from compiler toolchains. When processing source code, compilers create Intermediary Representations (IR): language-agnostic pseudocode that describes the semantics of the program. Augmenting training data with the corresponding IR can benefit a Neural Transpiler in two ways: it helps align embeddings for different languages and improves the semantic understanding of the code. As shown in Figure 1, this can greatly improve the semantic quality of neural translations.
+
+In this work, we leverage LLVM (Lattner and Adve, 2004) to augment source code with corresponding Intermediate Representation and train models for code translation and decompilation. We compare
+
+![](images/4e5ce168677271d207a1232df7e84e1a16857d83646dab66d08821b92672e1f5.jpg)
+
+Figure 1: Improvements over TransCoder. The first example shows a translation from $\mathrm { C } { + } { + }$ to rust, where TransCoder generates code using unsigned instead of signed integers. In the second example, a translation from Java to Go, it generates a function with the wrong return type. In the third example, which is also a translation from Java to Go, the model outputs a function that looks similar to the correct solution but it confuses $>$ with $\gg$ and closes an expression with a parenthesis too early. In these cases and many others, TransCoder makes mistakes that are small in terms of edit distance, but have a large impact on the semantics of the code. Using the IR to ground the representations to the semantics often helps solving these issues.
+
+it to TransCoder, which uses only code and no IR. We also design an IR-only baseline, dubbed the pivot method, which generates a translation solely by decompiling an IR generated from the source language to a different target language. We experiment with four languages: $\mathrm { C } { + } { + }$ Java, Rust and Go, and show that utilizing both the code and the IR allows for an average relative improvement of $5 . 5 \%$ . Moreover, our method only uses the IR at training time and does not require extra computations at inference time.
+
+Our main contributions are:
+
+• We implement a new IR-augmented translation method, which leverages LLVM IRs to improve code representations. It allows us to increase the number of correct translations generated by TransCoder for $\mathrm { C } { + } { + }$ , Java, Go and Rust by $5 . 5 \%$ . Compared to our IR-only pivot method, the improvement reaches $170 \%$   
+• Our method is especially useful in the low data regime: with relative improvements reaching $2 9 . 7 \%$ when translating to Rust and $2 5 . 6 \%$ when translating from it.   
+• We extend the parallel evaluation dataset of 852 functions in $\mathrm { C } { + + }$ , Java and Python from Roziere et al. (2020) with 343 more functions in Go and 280 more in Rust, along with corresponding test cases   
+• In addition, we achieve $78 \%$ accuracy when decompiling LLVM IRs to $\mathrm { C } { + + }$
+
+# 2 INTERMEDIATE REPRESENTATIONS IN COMPILERS
+
+Compilers translate programs written in a computer language into executable code for a specific machine. Most compilers consist of a front-end taking source code as input, and a back-end which produces machine binary code. The front-end lexes (tokenizes) and parses the program. Then, it produces an abstract syntax tree (AST), and translates it into some Intermediate Representation (IR). The back-end converts the IR into machine-specific executable code.
+
+In modern compilers such as LLVM (Lattner and Adve, 2004), the IR is generic across different input languages (and thus different front-ends). It allows the application of transformations and target agnostic optimizations to the IR, in a middle-end module independent from the source language and target machine. This results in an efficient compiler structure: new languages can be implemented by rewriting the front-end, and new target machines by rewriting the back-end.
+
+![](images/a3fb548bd758d8295d507b87b8ee73f25aab1c16584606dce010463f0238d398.jpg)  
+Figure 2: A bird’s eye view of a compiler toolchain, exemplified with LLVM. The unoptimized version $( - 0 0 )$ is shown here for illustration. In practice we used the size-optimized version $( - \mathsf { O z } )$ of the IR as boxed, which does the compile time optimization of computing the addition of 26 and 16.
+
+Several IRs usually co-exist in a compiler: each stage in the toolchain (Figure 2) introduces a new representation. Early stage IRs are language-dependent (e.g. ASTs mirror the syntax of the source language). Late stage IRs replace named variables by registers and reflect the specifics of the target architecture. In this work, we are interested in middle-end IRs, which are independent from the target machine, and similar for all source languages (like dialects in natural languages).
+
+# 3 TRAINING OBJECTIVES
+
+Unsupervised machine translation consists of learning multilingual sequence embeddings, and generating sequence in any output language from these embeddings (Lample et al., 2018a). We now present the objective functions for these tasks. In section 3.1, we review the three basic objectives used by TransCoder, our baseline NMT system. In section 3.2, we introduce three new functions that leverage LLVM IRs to improve the multilingual representation of source code, and the performance of our translation models. During training, we alternate between all six objectives, running each for the same number of optimisation steps. At inference, the model is only provided with the source code, i.e. the IR is not needed.
+
+Formally, let $x = x _ { 1 } \ldots x _ { N _ { s o } }$ be the source sentence, $z ^ { ( x ) } = z _ { 1 } ^ { ( x ) } \dots z _ { N _ { i r } } ^ { ( x ) }$ the corresponding IR, and $y = y _ { 1 } \dots y _ { N _ { t a } } $ the target sentence. We write $\begin{array} { r } { \mathcal { L } _ { C E } ( \hat { y } , y ) = \sum _ { i } \ell _ { C E } ( \ddot { y } _ { i } , y _ { i } ) } \end{array}$ , with $\ell _ { C E } ( \hat { y } _ { i } , y _ { i } )$ the pairwise cross-entropy loss between $\hat { y } _ { i }$ and $y _ { i }$ . We define the machine translation loss (or seq2seq loss) from $x$ to $y$ , $\mathcal { L } _ { M T }$ as the sum of the negative log-likelihood of each token $y _ { i }$ , given $x$ and previous tokens $y _ { 0 } \ldots y _ { i - 1 }$ (note that $x$ and $y$ can have different lengths) :
+
+$$
+\mathcal { L } _ { M T } ( x , y ) = - \sum _ { i } \log \left( P ( y _ { i } | x , y _ { 1 } \ldots y _ { i - 1 } ) \right)
+$$
+
+# 3.1 COMMON OBJECTIVE FUNCTIONS
+
+TransCoder (Roziere et al., 2020) learns to translate between programming languages by leveraging three unsupervised objectives developed for natural language (Lample et al., 2018b):
+
+Masked Language Modeling (MLM) trains an encoder to predict randomly masked inputs. It is commonly used to pre-train embeddings for natural (Devlin et al., 2018; Liu et al., 2019) and programming languages (Kanade et al., 2020; Feng et al., 2020). MLM allows the model to learn the syntax and semantics of programs. Alternative objectives, have been proposed for programming languages (Guo et al., 2020; Lachaux et al., 2021; Ahmad et al., 2021; Wang et al., 2021). We do not use them here, as MLM remains effective and easy to use on a wide range of programming languages.
+
+Denoting $m a s k ( x )$ the masked version of the code sentence $x$ , and $e n c ( t )$ the encoder output, MLM uses the following loss:
+
+$$
+\mathcal { L } _ { M L M } = \mathcal { L } _ { C E } \left( e n c ( m a s k ( x ) ) , x \right) .
+$$
+
+![](images/90a5e988f3483d0037d74465b54b9b166b3ff5748a8ee26c21d112bfb591a3fc.jpg)  
+Figure 3: IR for code representation objectives. We show examples of masking (used in TLM and TAE) and IR generation used to improve code representations with IRs. The masking objective in TLM or TAE makes the model understand the relationship between code and IR. The IR generation objective helps the model to build semantic representations of the code. For instance, another $\mathrm { C } { + + }$ function computing $3 9 \ + \ 3$ would result in the same IR. A Go function that returns 42 would also have a similar LLVM IR. Therefore, the IR Generation objective encourages the model to build similar representations for these three semantically equivalent functions.
+
+Denoising Auto Encoding (AE) trains a sequence to sequence (seq2seq) model to retrieve an original sequence from a corrupted version. Corruption is done by masking spans of tokens randomly sampled from a Poisson distribution, as well as removing and shuffling tokens. It uses the following loss $( n o i s e ( x )$ denotes the corrupted version of $x$ ):
+
+$$
+\mathcal { L } _ { A E } = \mathcal { L } _ { M T } \left( n o i s e ( x ) , x \right) .
+$$
+
+Back-Translation (BT). Back-Translation (Sennrich et al., 2015) uses the model to generate a noisy translation of the input sentence, and then trains the model to recover the original input from the translation. It is a simple yet powerful objective for unsupervised machine translation (Lample et al., 2018a; Artetxe et al., 2018). In practice, it is a required loss to get competitive performance, so it is a staple of all our experiments. Formally, we use the model to translate sequence $x$ into $\hat { y }$ and train the model to reverse the translation process, using the loss:
+
+$$
+\mathcal { L } _ { B T } = \mathcal { L } _ { M T } \left( \hat { y } , x \right)
+$$
+
+# 3.2 IR FOR CODE REPRESENTATIONS
+
+Intermediate representations (IR) provide additional information about the code to be translated. We add them to the training dataset, as described in section 4.2, and leverage them by adding three new objective functions to those described in section 3.1.
+
+Translation Language Modeling (TLM), first introduced in Lample and Conneau (2019), strives at generating common representations for parallel sentences in different languages. Like the masked language modeling (MLM) objective, it trains an encoder to predict random masked inputs. However, TLM is trained on pairs of parallel sentences, concatenated together and separated by a special token. Here, we concatenate functions in their source language and their corresponding IR, using the source code and IR language embeddings, and train the encoder to predict randomly masked tokens. This allows the model to learn correspondences between the source and the IR. The corresponding loss is ( $\oplus$ denotes concatenation):
+
+$$
+\mathcal { L } _ { T L M } = \mathcal { L } _ { C E } \left( m a s k ( x \oplus z ^ { ( x ) } ) , x \oplus z ^ { ( x ) } \right)
+$$
+
+![](images/c6d5185f61ecb1d679f8470f8bb5d4104b7692dffb819bb4c91a810f5d2df200.jpg)  
+Figure 4: IR Decompilation objective. Here, we generate the IR corresponding to each function and train a model to decompile it. The IR pivot model uses this objective, as well as back-translation objectives, allowing it generalize to IRs generated from any language.
+
+Translation Auto-Encoding (TAE) amounts to transposing the TLM objective into a denoising auto-encoder. The source code and corresponding IR are corrupted and masked, and then concatenated into one sequence (using the language embeddings for code and IR, as previously). TAE is then tasked to recover the original, using the following loss:
+
+$$
+\mathcal { L } _ { T A E } = \mathcal { L } _ { M T } \left( n o i s e ( x ) \oplus n o i s e ( z ^ { ( x ) } ) , x \oplus z ^ { ( x ) } \right)
+$$
+
+IR Generation (MT) trains the model to translate the source code into the corresponding IR. This allows the encoder to learn source code representations from the semantics of the IR. The loss is:
+
+$$
+\mathcal { L } _ { I R G e n } = \mathcal { L } _ { M T } \left( x , z ^ { ( x ) } \right)
+$$
+
+These three objectives need both the source code and the corresponding IR. However, only a fraction of the functions and files in our dataset could be compiled. To mitigate this, we also train the models on the full monolingual data using the MLM and AE objectives described above. In this setup, the back-translation (BT) objective is the same as in Roziere et al. (2020), and allows our model to translate directly from source code only at inference time.
+
+# 3.3 ADDITIONAL LOSSES: IR DECOMPILATION AND PIVOT
+
+We study two alternative uses of intermediary representations: IR decompilation, and IR pivot translation. IR decompilation consists of recovering source code corresponding to a given IR. In practice, it reverses the computations performed by the compiler. IR Pivot is a translation method built upon IR decompilation. Since LLVM can compile many languages $( \mathbf { C } + +$ , Java, Rust, Go) into the same IR, an obvious approach to code translation consists of decompiling the IR generated from the source language into code in the target language. We call this method “IR pivot”. Note that, whereas the IR for code representation techniques only used IR during training, both the decompilation and pivot method also need the IR for inference.
+
+Decompilation. In this supervised task, we use LLVM to generate IR from source code, and train a language model to reverse the process, i.e. learn to predict the source code from the IR. Models are pre-trained using the MLM and AE objectives, and decompilation is learned using the machine translation loss:
+
+$$
+\mathcal { L } _ { D e c o m p } = \mathcal { L } _ { M T } \left( z ^ { ( x ) } , x \right)
+$$
+
+IR Pivot. This task leverages the IR as a pivot for code translation. For instance, to translate from Rust to $\mathrm { C } { + } { + }$ , we first use LLVM to compile a Rust program into IR and then decompile the IR to $\mathrm { C } { + } { + }$ using a neural decompiler. In practice, slight variations exists between the IR generated for different languages: the Rust-IR and $\mathrm { C } { + + }$ -IR behave like dialects of the LLVM-IR. This often leads to poor performance of the IR Pivot method. We mitigate these issues using a variety of techniques, which we describe in section C of the appendix.
+
+# 4 DATA
+
+# 4.1 TRAINING DATA
+
+Our training data was extracted with Google BigQuery, which indexes over 2.8 million open source repositories from $\mathrm { G i t H u b } ^ { 2 }$ . We selected projects whose license explicitly permits re-distribution of parts, and extracted all individual $\mathrm { C } { + } { + }$ , Java, Rust and Go functions. To learn to decompile IRs, we also used the CodeNet dataset (Puri et al., 2021), a repository of 14 million competitive programming solutions in 55 languages. Our models work at function level: this reduces compilation failures over missing dependencies, while keeping sequence lengths short.
+
+Table 1: Dataset coverage across languages, in number of standalone functions. More details can be found in Table 7 in the appendix.   
+
+<table><tr><td></td><td>C++</td><td>Go</td><td>Java</td><td>Rust</td></tr><tr><td>Monolingual data</td><td>6.6M</td><td>9.4 M</td><td>7.8M</td><td>576.3K</td></tr><tr><td>Code/IRParallel Data</td><td>344.4 K</td><td>384.4K</td><td>2.2 M</td><td>19.2 K</td></tr><tr><td>Successful IR Compilation</td><td>5.2%</td><td>4.1%</td><td>28.2%</td><td>3.3%</td></tr></table>
+
+# 4.2 GENERATING INTERMEDIATE REPRESENTATIONS
+
+While the LLVM ecosystem is large, not every language has an LLVM front-end, and not every front-end can produce LLVM IR out-of-the-box. We use $\mathsf { c } \mathtt { l a n g } + + \mathbf { \lambda } ^ { 3 }$ Lattner and Adve (2004) from the established LLVM $\mathrm { C } { + + }$ compilation toolchain, JLang4 for Java, Gollvm5 for Go and rustc Matsakis and Klock II (2014) for Rust. For the same program, written in different languages, different front-ends may produce different IR. To minimize these variations, we process the source code as follows. First, we generate the most size-optimized IR (- ${ \bf \nabla } \cdot O z$ flag), which makes the IR more uniform across languages. Second, we strip all unnecessary information (e.g. header and footer with attributes, debug information, comments). Finally, block names are canonicalized and symbol names demangled to facilitate their recovery. The functions that fail to compile at this point (e.g. because of missing dependencies) are not included in the parallel dataset, as seen in the last row of Table 1.
+
+# 4.3 EVALUATION
+
+Traditional NMT evaluation relies on metrics such as BLEU, that are based on n-gram overlaps. However, when dealing with programming languages, syntax and in particular compilation and computation outputs can differ widely despite minor changes in the code. Conversely, semantically equivalent code, that differ only in variable names or order of operations can have a low BLEU score. To take this into account, we use and enhance the computational accuracy test suite from Roziere et al. (2020), that contains 852 parallel competitive programming solutions in $\mathrm { C } { + + }$ , Java and Python. Using C2Rust, $\mathbf { \boldsymbol { C } } \mathbf { \boldsymbol { x } } \mathbf { \boldsymbol { G } } \mathbf { \boldsymbol { 0 } }$ and some manual code cleaning, we translated 280 functions and test suites in Rust and 343 in Go to measure the performance of our models in these languages. We measure our performance using the computational accuracy $\left( \mathbf { C A @ 1 } \right)$ metric (Kulal et al., 2019; Roziere et al., 2020), which considers that a translation is correct if it passes a series of unit tests.
+
+# 5 RESULTS
+
+# 5.1 EXPERIMENTAL DETAILS
+
+For TransCoder, we consider a sequence-to-sequence (seq2seq) transformer model (Vaswani et al., 2017) with attention (Bahdanau et al., 2015; Sutskever et al., 2014) and the same architecture as Roziere et al. (2020). Our model has 12 layers (6 in the encoder and 6 in the decoder), 8 attention heads, and a dimension of 1024. For the objectives that add noise and masks to the input sentence, such as MLM, TLM, AE, and TAE, we choose the masked tokens and noise randomly on the fly at each epoch. We mask $15 \%$ of the tokens in MLM and TLM. In AE and TAE, we mask $20 \%$ of the tokens. MLM is trained on streams of data, while the other objectives are trained at function level. We use the Adam optimizer (Kingma and Ba, 2015) and an inverse squared-root learning rate scheduler, with an initial learning rate of $1 0 ^ { - 5 }$ in most of our experiments. Our models are implemented in PyTorch using mixed-precision floats. The pre-trained models were trained until convergence. The translation models presented in Tables 2 and 3 were trained for a week on 32 NVIDIA V100 GPUs.
+
+Table 2: Translation performance $( \mathbf { C A } @ \mathbf { 1 } )$ , for greedy decoding and beam size 5. “To $X ^ { \ast }$ : average performance when translating to language X. “From $X ^ { \ast }$ : average performance when translating from language X. See Table 3 in the appendix for more detailed results. All these methods except for the IR pivot also use the three objectives defined in TransCoder: MLM, DAE and Back-Translation (BT). All combinations of the TLM, MT and TAE objectives improve the performance compared to TransCoder. The best results are obtained when all three are used at the same time. Beam search, using beam size 5 and returning only the top element from the beam results in improved performance. The IR Pivot method generates a translation in the target language from an IR generated from the source, and performs poorly in our setting.   
+
+<table><tr><td></td><td>from C++ to C++ from Go to Go from Java to Java from Rust to Rust</td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td>AVG</td></tr><tr><td>Greedy decoding</td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td></tr><tr><td>IR Pivot</td><td>17.4</td><td>24.0</td><td>19.9</td><td>11.5</td><td>11.9</td><td>22.2</td><td>16.3</td><td>7.8</td><td>16.4</td></tr><tr><td>TransCoder (baseline)</td><td>46.4</td><td>52.1</td><td>42.1</td><td>45.6</td><td>41.2</td><td>44.5</td><td>29.6</td><td>17.0</td><td>39.8</td></tr><tr><td>TLM</td><td>47.5</td><td>54.8</td><td>45.4</td><td>41.2</td><td>39.8</td><td>52.1</td><td>31.1</td><td>15.7</td><td>40.9</td></tr><tr><td>MLM+ TAE</td><td>47.3</td><td>53.3</td><td>47.2</td><td>44.8</td><td>41.8</td><td>45.9</td><td>25.1</td><td>17.4</td><td>40.4</td></tr><tr><td>TLM+TAE</td><td>46.9</td><td>55.9</td><td>45.0</td><td>37.9</td><td>38.5</td><td>54.5</td><td>34.9</td><td>16.8</td><td>41.3</td></tr><tr><td>MLM+MT</td><td>45.5</td><td>51.0</td><td>44.0</td><td>48.9</td><td>46.6</td><td>45.2</td><td>25.7</td><td>16.6</td><td>40.5</td></tr><tr><td>TLM + MT</td><td>45.6</td><td>51.5</td><td>45.1</td><td>47.1</td><td>46.9</td><td>45.5</td><td>24.4</td><td>17.9</td><td>40.5</td></tr><tr><td>TAE +MT</td><td>47.8</td><td>54.3</td><td>43.8</td><td>43.9</td><td>39.1</td><td>49.2</td><td>33.4</td><td>16.7</td><td>41.0</td></tr><tr><td>TLM + TAE +MT</td><td>47.8</td><td>54.3</td><td>46.6</td><td>51.6</td><td>47.1</td><td>49.6</td><td>35.3</td><td>21.4</td><td>44.2</td></tr><tr><td>Beam size 5</td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td></tr><tr><td>TransCoder (baseline)</td><td>53.8</td><td>53.4</td><td>45.2</td><td>54.4</td><td>46.1</td><td>51.5</td><td>35.9</td><td>20.9</td><td>45.3</td></tr><tr><td>TLM + TAE +MT</td><td>52.9</td><td>53.5</td><td>48.8</td><td>57.1</td><td>51.5</td><td>53.4</td><td>37.9</td><td>27.1</td><td>47.8</td></tr></table>
+
+# 5.2 IR-AUGMENTED CODE REPRESENTATIONS FOR TRANSLATION
+
+Models using combinations of the three objectives—TAE, TLM and MT—introduced to leverage IR, were trained to translate between pairs of four languages $\scriptstyle ( + +$ , Java, Rust, Go). Their average performance when translating to and from every language are presented in table 2. Additional information, including a comparison to TransCoder-ST for $\mathrm { C } { + } { + } $ Java, can be found in Table 3) in the appendix. As a baseline, we use a TransCoder (Roziere et al., 2020) model, trained with MLM on the same dataset.
+
+Using greedy decoding, the new TLM, TAE and MT objectives, which leverage the IR, improve performance for every language. The best average results are obtained when combining all of them. Compared to TransCoder, they improve performance by an average $4 . 4 \%$ point ( $1 1 \%$ relative). The largest impacts are observed in the low data regime: translations from and into Rust (a language less represented in our training set) are improved by $2 5 . 6 \%$ and $1 9 . 3 \%$ (relative). Beam search improves the results of both TransCoder and our models, using IR-augmented representation still results in better performance. Qualitatively, we observe that IRs help our model translate types when the source and target types are represented by different tokens. For instance, in the first example of Table 1, it translates the semantics of int correctly using $\pm 3 2$ instead of an unsigned integer type (usize). See Appendix H for more analysis on how our objectives improve word embeddings.
+
+Compared to IR-augmented translation models, the “obvious” IR Pivot method proves disappointing, even though it achieves non-trivial performances. It is heavily dependent on the size of the training set: the IR pivot performs relatively well when translating from low-resource to high-resource languages (e.g. from Rust), and badly when translating to low-resource languages (e.g. to Rust).
+
+# 5.3 DECOMPILATION RESULTS
+
+To compute the IR pivot, we trained a neural decompiler to retrieve source code from IRs. We tried two separate configurations for decompilation: a shared decoder with 6 layers for all language / IR pairs, or four separate decoders of with two layers each (one per language). Using a shared decoder improves the performance for all languages, and particularly when the data is scarce (e.g. Rust). See Table 5 in the appendix for more information.
+
+We compare the performance of our model to RetDec (Kˇroustek et al., 2017), a rule-based decompiler. It obtains a computational accuracy of 68.75 on our $\mathrm { C } { + + }$ dataset and a BLEU score of 8.54. In comparison, our model obtains a computational accuracy of 77.9 and a BLEU score of 63.6 in the same setting. In particular, RetDec fails to decompile LLVM files generated from $\mathrm { C } { + } { + }$ code, especially snippets leveraging the standard library structures such as unordered_map or $s t d :$ allocator. The limitations of RetDec, which was implemented by a team of 24 developers in 7 years 6, shows how difficult it is to build exhaustive rule-based decompilers, especially when the IR comes from different languages or tools.
+
+# 6 DISCUSSION
+
+Different IR and interpreted languages The four languages considered in this work have frontends that can output LLVM Intermediary Representation. LLVM presently covers more than 30 computer languages. Using IR as pivot requires that the source and destination language have front-ends that use the same IR. This rules out some widely-used languages (e.g. Python). Using the IR to improve embeddings is less restrictive: the source and destination language can be trained on different IR, and aligned with back-translation. In this paper, we focus on compiled languages, but it is important to note that Intermediary Representations are usually available for interpreted languages as well: modern interpreters translate the source code into byte-code, that can serve as an IR.
+
+Pivot vs Embedding TransCoder is an unsupervised model that learns to align code representations and translate code from one language to another. It is based solely on source code and does not use IRs. The pivot method uses automatically generated parallel sentences to learn to decompile IRs, and back-translation to adapt to different IR dialects. This method learns to translate using only IR-level similarities, and does not use the source code itself except to compute the IR. Although it underperforms other methods, it performs relatively well when little data is available for the source language, because the IR can be computed using a rule-based compiler. However, it requires to compute IRs at test time, which can be cumbersome. Instead, adding the TLM, TAE, and MT objectives to the objectives generally used for unsupervised code translation allows the model to get the best of both worlds. It can learn multilingual representations of source code from similarities in the IR and in the source code itself. As shown in Table 2, it outperforms both TransCoder and the pivot method. At the same time, this model does not require to compute IRs at test time, and is as easy to use as TransCoder.
+
+Using our model at inference time. Our self-supervised IR-augmented TLM, TAE and MT objectives are designed to improve the multilingual code representations used in translation models. However, the translation task does not require to compute these objectives. Therefore, they lead to models that are just as simple to use as TransCoder: computing the IR is not required at test time and the model generates the translation directly from the source function.
+
+# 7 RELATED WORKS
+
+Source-to-Source Translation. Many rule-based methods are available for transpilation, an inventory of which can be found online1. In particular, ${ \mathrm { C } } 2 { \mathrm { R u s t } } ^ { 7 }$ and $\mathrm { C x G o } ^ { 8 }$ , along with manual corrections, were central for us in translating evaluation tests to Go and Rust (See Section 4.3). Similarly, $2 \mathrm { t o } 3 ^ { 9 }$ , a Python library porting Python 2 code to Python 3, was used in Aggarwal et al. (2015) to create a parallel dataset and train a machine learning model.
+
+Neural Machine Translation for code is hampered by the lack of parallel data between programming languages. Indeed, apart from a few language pairs, such as Java-C# (Nguyen et al., 2013; Chen et al., 2018), and specific domains (e.g. competitive programming code), it is difficult to collect large datasets of semantically equivalent code in different languages. TransCoder (Roziere et al., 2020) bridges this gap by introducing unsupervised machine translation to programming languages. They take advantage of large monolingual code bases to learn to translate between $\mathrm { C } { + } { + }$ , Python and Java with high performance. Later, DOBF (Lachaux et al., 2021) improved the model pre-training method used in TransCoder, and Roziere et al. (2022) used automatically generated unit tests to improve translation performance between Java, $\mathrm { C } { + } { + }$ and Python. Recently, large language models trained on code, such as Codex (Chen et al., 2021) and PALM (Chowdhery et al., 2022), have been used for unsupervised code translation.
+
+Using the Transcoder model, Weisz et al. (2021) and Weisz et al. (2022) survey the links between humans and NMT methods for code translation. They view neural translation methods as aids to programmers. In this context, they demonstrate that even imperfect models can improve the quality of an engineer’s work for code translation, and plead for the improvement of human-machine interfaces.
+
+Decompilation. Like transpilation, decompilation is usually performed using rule-based methods that rely on pattern matching to parse the control flow structure of the program. RetDec, an open source decompiler created by Avast (Kˇroustek et al., 2017), can decompile an executable to C and a Python-like language via LLVM IR. Other tools exist, such as the Hex-Rays Decompiler10 and Brumley et al. (2013). A thorough review of rule-based methods can be found in papers such as Liang et al. (2021a) and Katz et al. (2019). With these methods, decompilation can fail if the code is too convoluted, or if it contains language features that were not explicitly translated. Most methods also produce unstructured programs, relying on a large number of goto statements to simulate the control flow of the lower level programming languages. This is semantically correct, but very rarely found in human-written code.
+
+A few works have studied the use of sequence-to-sequence neural networks for neural decompilation. Katz et al. (2019) uses LSTM networks to decompile LLVM IRs and assembly code to C. Their approach generates code templates based on the IR, that determine the structure of the output. Then, they fill them with correct variable assignments and numerical values. In the same vein, Fu et al. (2019) tries to address limitations of neural decompilation with two sequential phases: code sketch generation and iterative error correction. Finally, Liang et al. (2021b) use a method close to ours, and train Transformer models to translate between binary code and C.
+
+Intermediate representations are almost as old as compiler design. The first IR, UNCOL (Strong et al., 1958) was introduced in the mid-1950s, together with the idea of reusing the same compiler for several languages and machines. In 1960, NELIAC (a variant of ALGOL) (Huskey et al., 1960) was the first retargetable compiler, portable to different architectures. Feldman (1979) describes how a compiler for Fortran 77 can be added to the C compilers of Johnson (1979) and Ritchie (1979). GCC (Stallman, 2001) introduces Register Transfer Language (RTL) a low-level IR inspired by Davidson and Fraser (1980), and then GENERIC and GIMPLE (Merrill, 2003), precursors of the IR used in LLVM (Lattner and Adve, 2004).
+
+# 8 CONCLUSION
+
+In this paper, we leverage LLVM IRs to improve neural machine translation for source code. The IR provides a common semantically-rich language, into which $\mathrm { C } { + } { + }$ , Go, Java and Rust code can all be compiled. We develop three objectives, designed to leverage IRs for better multilingual representations of source code, which lead to a $5 . 5 \%$ relative average improvement for code translation. We also show that sequence-to-sequence transformers perform well for neural decompilation, and use this for pivot translation.
+
+We only worked with the LLVM IR, but our approach is broadly applicable to any pair of languages that share a common Intermediate Representation. More generally any IR can help improve the code representations by tying them to the semantics. Another limitation is the scale of our current source and target sequences. As future work, LLVM IRs could be generated at a larger scale by compiling entire projects, which would greatly improve the percentage of successful IR compilations in Table 1. More languages and IRs could be used, and those extensions could be powered by larger models.
+
+# REFERENCES
+
+Karan Aggarwal, Mohammad Salameh, and Abram Hindle. Using machine translation for converting Python 2 to Python 3 code. Technical report, PeerJ PrePrints, 2015.
+
+Wasi Ahmad, Saikat Chakraborty, Baishakhi Ray, and Kai-Wei Chang. Unified pre-training for program understanding and generation. In Proceedings of the 2021 Conference of the North American Chapter of the Association for Computational Linguistics: Human Language Technologies, pages 2655–2668, 2021.
+
+Mikel Artetxe, Gorka Labaka, and Eneko Agirre. Unsupervised statistical machine translation. In Proceedings of the 2018 Conference on Empirical Methods in Natural Language Processing, 2018.
+
+Dzmitry Bahdanau, Kyung Hyun Cho, and Yoshua Bengio. Neural machine translation by jointly learning to align and translate. In 3rd International Conference on Learning Representations, 2015.
+
+David Brumley, JongHyup Lee, Edward J Schwartz, and Maverick Woo. Native $\mathbf { \boldsymbol { x } } 8 6$ decompilation using semantics-preserving structural analysis and iterative control-flow structuring. In 22nd USENIX Security Symposium (USENIX Security 13), pages 353–368, 2013.
+
+Mark Chen, Jerry Tworek, Heewoo Jun, Qiming Yuan, Henrique Ponde, Jared Kaplan, Harri Edwards, Yura Burda, Nicholas Joseph, Greg Brockman, et al. Evaluating large language models trained on code. arXiv preprint arXiv:2107.03374, 2021.
+
+Xinyun Chen, Chang Liu, and Dawn Song. Tree-to-tree neural networks for program translation. In Advances in neural information processing systems, pages 2547–2557, 2018.
+
+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.
+
+Jack W. Davidson and Christopher W. Fraser. The design and application of a retargetable peephole optimizer. ACM Trans. Program. Lang. Syst., 2(2):191–202, apr 1980. ISSN 0164-0925.
+
+Jacob Devlin, Ming-Wei Chang, Kenton Lee, and Kristina Toutanova. BERT: Pre-training of deep bidirectional transformers for language understanding. CoRR, abs/1810.04805, 2018.
+
+Stuart I. Feldman. Implementation of a portable Fortran 77 compiler using modern tools. SIGPLAN Not., 14(8):98–106, aug 1979. ISSN 0362-1340. doi: 10.1145/872732.806959. URL https: //doi.org/10.1145/872732.806959.
+
+Zhangyin Feng, Daya Guo, Duyu Tang, Nan Duan, Xiaocheng Feng, Ming Gong, Linjun Shou, Bing Qin, Ting Liu, Daxin Jiang, et al. Codebert: A pre-trained model for programming and natural languages. In Proceedings of the 2020 Conference on Empirical Methods in Natural Language Processing: Findings, pages 1536–1547, 2020.
+
+Cheng Fu, Huili Chen, Haolan Liu, Xinyun Chen, Yuandong Tian, Farinaz Koushanfar, and Jishen Zhao. Coda: An end-to-end neural program decompiler. In Advances in Neural Information Processing Systems, pages 3703–3714, 2019.
+
+Daya Guo, Shuo Ren, Shuai Lu, Zhangyin Feng, Duyu Tang, LIU Shujie, Long Zhou, Nan Duan, Alexey Svyatkovskiy, Shengyu Fu, et al. Graphcodebert: Pre-training code representations with data flow. In International Conference on Learning Representations, 2020.
+
+Harry D. Huskey, M. H. Halstead, and R. McArthur. NELIAC — dialect of ALGOL. Commun. ACM, 3(8):463–468, aug 1960. ISSN 0001-0782. doi: 10.1145/367368.367373. URL https: //doi.org/10.1145/367368.367373.
+
+S. C. Johnson. A tour through the portable C compiler. In Unix Programmer’s Manual, 7th Edition, 2B, Section 33, 1979.
+
+Aditya Kanade, Petros Maniatis, Gogul Balakrishnan, and Kensen Shi. Learning and evaluating contextual embedding of source code. In International Conference on Machine Learning, pages 5110–5121. PMLR, 2020.
+
+Omer Katz, Yuval Olshaker, Yoav Goldberg, and Eran Yahav. Towards neural decompilation. arXiv preprint arXiv:1905.08325, 2019.
+
+Diederik Kingma and Jimmy Ba. Adam: A method for stochastic optimization. ICLR, 2015.
+
+Jakub Kˇroustek, Peter Matula, and P Zemek. RetDec: An open-source machine-code decompiler, 2017. URL https://github.com/avast/retdec.
+
+Sumith Kulal, Panupong Pasupat, Kartik Chandra, Mina Lee, Oded Padon, Alex Aiken, and Percy S Liang. Spoc: Search-based pseudocode to code. Advances in Neural Information Processing Systems, 32:11906–11917, 2019.
+
+Marie-Anne Lachaux, Baptiste Roziere, Marc Szafraniec, and Guillaume Lample. DOBF: A deobfuscation pre-training objective for programming languages. arXiv preprint arXiv:2102.07492, 2021.
+
+Guillaume Lample and Alexis Conneau. Cross-lingual language model pretraining. Advances in Neural Information Processing Systems, 32:7059–7069, 2019.
+
+Guillaume Lample, Alexis Conneau, Ludovic Denoyer, and Marc’Aurelio Ranzato. Unsupervised machine translation using monolingual corpora only. ICLR, 2018a.
+
+Guillaume Lample, Myle Ott, Alexis Conneau, Ludovic Denoyer, and Marc’Aurelio Ranzato. Phrase based & neural unsupervised machine translation. In EMNLP, 2018b.
+
+Chris Lattner and Vikram Adve. Llvm: A compilation framework for lifelong program analysis & transformation. In International Symposium on Code Generation and Optimization, 2004. CGO 2004., pages 75–86. IEEE, 2004.
+
+Ruigang Liang, Ying Cao, Peiwei Hu, and Kai Chen. Neutron: an attention-based neural decompiler. Cybersecurity, 4(1):1–13, 2021a.
+
+Ruigang Liang, Ying Cao, Peiwei Hu, Jinwen He, and Kai Chen. Semantics-recovering decompilation through neural machine translation. arXiv preprint arXiv:2112.15491, 2021b.
+
+Yinhan Liu, Myle Ott, Naman Goyal, Jingfei Du, Mandar Joshi, Danqi Chen, Omer Levy, Mike Lewis, Luke Zettlemoyer, and Veselin Stoyanov. RoBERTa: A robustly optimized BERT pretraining approach. arXiv preprint arXiv:1907.11692, 2019.
+
+Nicholas D Matsakis and Felix S Klock II. The Rust language. In ACM SIGAda Ada Letters, volume 34, pages 103–104. ACM, 2014.
+
+Jason Merrill. GENERIC and GIMPLE: A new tree representation for entire functions. In in Proc. GCC Developers Summit, 2003, pages 171–180, 2003.
+
+Anh Tuan Nguyen, Tung Thanh Nguyen, and Tien N Nguyen. Lexical statistical machine translation for language migration. In Proceedings of the 2013 9th Joint Meeting on Foundations of Software Engineering, pages 651–654, 2013.
+
+Ruchir Puri, David S. Kung, Geert Janssen, Wei Zhang, Giacomo Domeniconi, Vladimir Zolotov, Julian Dolby, Jie Chen, Mihir R. Choudhury, Lindsey Decker, Veronika Thost, Luca Buratti, Saurabh Pujar, and Ulrich Finkler. Project CodeNet: A large-scale AI for code dataset for learning a diversity of coding tasks. CoRR, abs/2105.12655, 2021. URL https://arxiv.org/abs/ 2105.12655.
+
+D.M. Ritchie. A Tour Through the UNIX C Compiler. 1979. URL https://books.google. com/books?id ${ . } = { }$ 5UvEGwAACAAJ.
+
+Baptiste Roziere, Marie-Anne Lachaux, Lowik Chanussot, and Guillaume Lample. Unsupervised translation of programming languages. Advances in Neural Information Processing Systems, 33, 2020.
+
+Baptiste Roziere, Jie M Zhang, Francois Charton, Mark Harman, Gabriel Synnaeve, and Guillaume Lample. Leveraging automated unit tests for unsupervised code translation. ICLR, 2022.
+
+Rico Sennrich, Barry Haddow, and Alexandra Birch. Improving neural machine translation models with monolingual data. In Proceedings of the 54th Annual Meeting of the Association for Computational Linguistics, pages 86–96, 2015.
+
+Richard Stallman. Using and porting the GNU Compiler Collection. M.I.T. Artificial Intelligence Laboratory, 2001.
+
+J. Strong, J. Wegstein, A. Tritter, J. Olsztyn, O. Mock, and T. Steel. The problem of programming communication with changing machines: A proposed solution. Commun. ACM, 1(8):12–18, aug 1958. ISSN 0001-0782. doi: 10.1145/368892.368915. URL https://doi.org/10.1145/ 368892.368915.
+
+Ilya Sutskever, Oriol Vinyals, and Quoc V Le. Sequence to sequence learning with neural networks In Advances in neural information processing systems, pages 3104–3112, 2014.
+
+Ashish Vaswani, Noam Shazeer, Niki Parmar, Jakob Uszkoreit, Llion Jones, Aidan N Gomez, Łukasz Kaiser, and Illia Polosukhin. Attention is all you need. In Advances in neural information processing systems, pages 5998–6008, 2017.
+
+Yue Wang, Weishi Wang, Shafiq Joty, and Steven CH Hoi. Codet5: Identifier-aware unified pretrained encoder-decoder models for code understanding and generation. In Proceedings of the 2021 Conference on Empirical Methods in Natural Language Processing, pages 8696–8708, 2021.
+
+Justin D Weisz, Michael Muller, Stephanie Houde, John Richards, Steven I Ross, Fernando Martinez, Mayank Agarwal, and Kartik Talamadupula. Perfection not required? human-ai partnerships in code translation. In 26th International Conference on Intelligent User Interfaces, pages 402–412, 2021.
+
+Justin D Weisz, Michael Muller, Steven I Ross, Fernando Martinez, Stephanie Houde, Mayank Agarwal, Kartik Talamadupula, and John T Richards. Better together? an evaluation of AIsupported code translation. In 27th International Conference on Intelligent User Interfaces, pages 369–391, 2022.
+
+# A FULL SCORES TABLE
+
+Table 3: Results on unsupervised code translation. The metric shown is the computational accuracy for a single generation $( \mathbf { C A @ 1 } )$ , measuring the translation correctness using unit tests. It is the full version of Table 2. The models were all trained with the same budget. As in Table 2, all these methods except for the IR pivot also use the three objectives defined in TransCoder: MLM, DAE and Back-Translation (BT). Although it is not the case for every language pair, TransCoder-IR, which uses the TLM, TAE, and MT objectives outperforms other methods on average. TransCoder-ST (Roziere et al., 2022) uses a parallel dataset generated with automated unit tests and outperforms other methods for $\mathbf { C } + +  \mathbf { J a v a }$ . Their method is orthogonal to ours, and we could also improve our performance with similar methods.   
+
+<table><tr><td colspan="6">C++ →Go C++→Java C++→Rust Go →C++ Go →Java Go →Rust</td></tr><tr><td>Baseline TransCoder</td><td>57.7</td><td>63.3</td><td>18.2</td><td>56.1</td><td>46.9</td><td>23.3</td></tr><tr><td>TransCoder-ST</td><td>1</td><td>68.0</td><td>1</td><td>1</td><td>1</td><td>1</td></tr><tr><td>Pivot</td><td>16.1</td><td>22.0</td><td>14.0</td><td>30.5</td><td>26.5</td><td>2.7</td></tr><tr><td>TLM</td><td>61.8</td><td>62.5</td><td>18.2</td><td>57.6</td><td>56.4</td><td>22.2</td></tr><tr><td>TAE</td><td>57.7</td><td>62.5</td><td>21.7</td><td>63.0</td><td>54.7</td><td>23.8</td></tr><tr><td>TLM+TAE</td><td>58.2</td><td>63.3</td><td>19.2</td><td>55.2</td><td>57.0</td><td>22.8</td></tr><tr><td>MT</td><td>56.8</td><td>60.6</td><td>19.2</td><td>60.3</td><td>53.8</td><td>18.0</td></tr><tr><td>TLM+MT</td><td>58.6</td><td>58.5</td><td>19.7</td><td>57.3</td><td>54.1</td><td>23.8</td></tr><tr><td>TAE+MT</td><td>61.4</td><td>60.2</td><td>21.7</td><td>55.5</td><td>53.8</td><td>22.2</td></tr><tr><td>TLM+TAE+MT</td><td>55.9</td><td>62.9</td><td>24.8</td><td>61.8</td><td>55.7</td><td>22.2</td></tr><tr><td colspan="7">Java →C++ Java→Go Java→Rust Rust →C++ Rust →Go Rust → Java</td></tr><tr><td>Baseline TransCoder</td><td>77.9</td><td>35.9</td><td>9.6</td><td>22.4</td><td>43.2</td><td>23.4</td></tr><tr><td>TransCoder-ST</td><td>84.6</td><td>1</td><td>1</td><td>-</td><td>1</td><td>1</td></tr><tr><td>Pivot</td><td>19.5</td><td>9.4</td><td>6.7</td><td>22.0</td><td>8.9</td><td>18.1</td></tr><tr><td>TLM</td><td>80.9</td><td>31.8</td><td>6.6</td><td>25.9</td><td>30.0</td><td>37.5</td></tr><tr><td>TAE</td><td>80.3</td><td>38.6</td><td>6.6</td><td>16.6</td><td>38.1</td><td>20.6</td></tr><tr><td>TLM+TAE</td><td>82.2</td><td>24.6</td><td>8.6</td><td>30.4</td><td>31.0</td><td>43.3</td></tr><tr><td>MT</td><td>76.2</td><td>50.9</td><td>12.6</td><td>16.6</td><td>39.1</td><td>21.3</td></tr><tr><td>TLM+MT</td><td>77.9</td><td>52.7</td><td>10.1</td><td>19.2</td><td>30.0</td><td>24.1</td></tr><tr><td>TAE+MT</td><td>77.5</td><td>33.6</td><td>6.1</td><td>30.0</td><td>36.6</td><td>33.7</td></tr><tr><td>TLM+TAE+MT</td><td>74.5</td><td>49.6</td><td>17.2</td><td>26.5</td><td>49.2</td><td>30.2</td></tr></table>
+
+B BEAM SIZE EVALUATION
+
+Table 4: Results on unsupervised code translation with different beam sizes. The metric shown is still the computational accuracy for a single generation $( \mathbf { C A @ 1 } )$ . BS N refers to beam search decoding with beam size N, and returning only the top element of the beam. Using beam search improves the average performance of every model. BS N means that the model is evaluated with beam size N. When the beam size is not given, we use greedy decoding. Surprisingly, beam size 5 outperforms beam size 10. Our method using intermediate representations still outperforms the baseline with beam size 5 and 10 in average. With the baseline, we obtain average $\mathrm { C A @ 1 }$ scores of 45.3 with beam size 5 and 44.0 with beam size 10. Our method yields $\mathrm { C A @ 1 }$ scores of 47.8 with beam size 5 and 46.8 with beam size 10.   
+
+<table><tr><td></td><td>C++ →Go</td><td>C++→→Java</td><td>C++→Rust</td><td>Go →C++</td><td>Go→ Java</td><td>Go →Rust</td></tr><tr><td>Baseline TransCoder</td><td>57.7</td><td>63.3</td><td>18.2</td><td>56.1</td><td>46.9</td><td>23.3</td></tr><tr><td>Baseline TransCoder (BS 5)</td><td>65.5</td><td>67.6</td><td>28.3</td><td>52.1</td><td>59.3</td><td>24.3</td></tr><tr><td>Baseline TransCoder (BS 10)</td><td>65.0</td><td>68.7</td><td>27.8</td><td>52.1</td><td>57.0</td><td>23.8</td></tr><tr><td>TLM+ TAE+ MT</td><td>55.9</td><td>62.9</td><td>24.8</td><td>61.8</td><td>55.7</td><td>22.2</td></tr><tr><td>TLM + TAE + MT (BS 5)</td><td>61.4</td><td>66.6</td><td>30.8</td><td>57.3</td><td>59.0</td><td>30.2</td></tr><tr><td>TLM + TAE + MT (BS 10)</td><td>61.4</td><td>67.4</td><td>29.3</td><td>56.4</td><td>59.0</td><td>29.1</td></tr><tr><td></td><td>Java → C++</td><td>Java →Go</td><td>Java→Rust</td><td>Rust -→ C++</td><td>Rust →Go</td><td>Rust → Java</td></tr><tr><td>Baseline TransCoder</td><td>77.9</td><td>35.9</td><td>9.6</td><td>22.4</td><td>43.2</td><td>23.4</td></tr><tr><td>Baseline TransCoder (BS 5)</td><td>82.9</td><td>45.5</td><td>10.1</td><td>25.2</td><td>54.8</td><td>27.5</td></tr><tr><td>Baseline TransCoder (BS 10)</td><td>80.9</td><td>46.4</td><td>7.6</td><td>23.6</td><td>51.8</td><td>23.0</td></tr><tr><td>TLM+ TAE + MT</td><td>74.5</td><td>49.6</td><td>17.2</td><td>26.5</td><td>49.2</td><td>30.2</td></tr><tr><td>TLM + TAE + MT (BS 5)</td><td>76.4</td><td>57.7</td><td>20.2</td><td>26.8</td><td>52.3</td><td>34.7</td></tr><tr><td>TLM + TAE + MT (BS 10)</td><td>77.7</td><td>57.3</td><td>18.2</td><td>26.2</td><td>51.8</td><td>28.2</td></tr></table>
+
+# C PIVOT METHOD DETAILS
+
+As mentioned in Section 3.3, IR generated from different languages contain slight variations and can be seen as dialects of the same language. In practice, these variations prevent us from simply using our best decompilation model to generate source code in another language than the one used to generate the IR. Although we prompt the model to generate code in the target language with language embeddings, it learns to focus on the particularities of each dialect and ignores the language embeddings. Therefore, it generates code in the source language, which results in a computational accuracy score of 0 for translation.
+
+One way to solve this issue is to use one decoder per target language. Then, the model is able to generate code in the target language. However, this method still performs poorly due to the small differences between the IR dialects. The method we tested that performed the best, and which is reported in Table 2, uses back-translation to make the model to translate from any IR dialect to any language. This model is also grounded by supervised translation steps making it generate IR from code and code from IR. In practice, we create new language embeddings for every IR dialect (i.e. $\mathrm { I R - C + + }$ , IR-Go, IR-Java, IR-Rust) for depending on the source language. At training time, we make the model generate noisy translations in the IR-Go, IR-Java and IR-Rust “languages” for every $\mathrm { C } { + } { + }$ sequence, and train it to re-generate the $\mathrm { C } { + } { + }$ sequence from the noisy translation. To allow the model to generate good training data for $\scriptstyle { \mathrm { I R - X } } \to { \mathbf { C } } + +$ , we also generate noisy translations in Go, Java, and Rust for every IR generated from $\mathrm { C } { + } { + }$ in our dataset and train the model to retrieve the IR. Using our parallel code//IR dataset, we also train the model to translate between $\mathrm { C } { + + }$ and IR- $C + +$ sequences. We do the same for every language and alternate between them.
+
+Table 5: Performance of LLVM IRs Decompilation. This table shows the computational accuracy $( \mathbf { C A @ 1 } )$ of our neural decompiler and the RetDec $\mathrm { C } { + + }$ rule-based decompiler. Our neural decompiler outperforms RedDec on $\mathrm { C } { + + }$ and is more broadly applicable.   
+
+<table><tr><td></td><td>C++</td><td>Go</td><td>Java</td><td>Rust</td></tr><tr><td>Baseline - RetDec</td><td>68.8</td><td>一</td><td></td><td></td></tr><tr><td>Separate Decoders</td><td>52.7</td><td>42.2</td><td>60.1</td><td>19.5</td></tr><tr><td>Shared Decoder</td><td>77.9</td><td>70.1</td><td>82.2</td><td>61.0</td></tr></table>
+
+![](images/15618a02a294a39479720341a03971180cec9ec86a0af942df47c057e0cd1731.jpg)  
+Figure 5: Code simplification examples with Decompilation / Pivot. Since the LLVM IR is optimized, functions that are semantically equivalent after optimization map to the same IR. In the first example, it allows to remove useless code by decompiling the generated LLVM IR. In the second example, the simplification allows to find a bug: the $\&$ operator has precedence over $= =$ in $\mathrm { C } { + } { + }$ , causing this function to always evaluate to false. It is not obvious when looking at the input code, but becomes clear with the IR and simplified $\mathrm { C } { + + }$ code. In the third example, it replaces a bitwise operation by a more straightforward multiplication. In all examples, we can run the compiler again to check that the IR of the decompiled code is exactly the same as that of the input. It guarantees that the input and simplified code have the same semantics.
+
+![](images/2e2e4baefe505e9f3ba439e931185acd8ec2f427a6d900c14eff2ed9317ba805.jpg)  
+Figure 6: Java to Rust translation examples. In the first example, the IR allows the model to understand that the Java bitwise complement operator \~ should be replaced by ! in Rust. Also, it allows the model to translate the type correctly in both examples and avoids unnecessary casts. The IR allows the model to generate the right types (e.g. i32 instead of $\mathtt { u } 3 2$ when translating int) and operator (e.g. ! instead of $\tilde { }$ in Rust).   
+Figure 7: Rust to Go translation example. This function performs binary search to find the insertion index for an element in an ordered vector. The model translates types, function definitions, variable definitions, and while loops correctly.
+
+// Rust   
+pub fn binary_search(nums: Vec<i32>, target: i32,   
+) -> i32 { if nums.is_empty() { return 0 } if target $<$ nums[0] { return 0 } let mut left $\qquad = \quad 0$ ; let mut right $=$ nums.len() - 1; while left $< =$ right { let mid $=$ left $^ +$ (right - left) / 2; if nums[mid] $= =$ target { return mid as i32; } else if nums[mid] $<$ target { left $=$ mid $^ + 1$ ; } else { right $=$ mid - 1; } } return left as i32;   
+}   
+// Go   
+func binarySearch(nums[] int, target int) int { if len(nums) $\scriptstyle = = 0$ { return 0 } if target $<$ nums[0] { return 0 } left: $\qquad = \quad 0$ right: $=$ len(nums) - 1 for left $< =$ right { mid: $=$ left $^ +$ (right - left) / 2 if nums[mid] $= =$ target { return mid } else if nums[mid] $<$ target { left $=$ mid $^ + 1$ else { right $=$ mid - 1 } } return left   
+}   
+// Go   
+func pairsInSortedRotated(arr[] int, n int, x int)   
+int { var i int for $\mathrm { ~ \\\small ~ \frac ~ { ~ i ~ } ~ } = \mathrm { ~ \small ~ 0 ~ }$ ; $\mathrm { ~ i ~ } ~ < \mathrm { ~ n ~ } ~ - ~ 1$ ; i++{ if arr[i] $\mathrm { ~ \gamma ~ > ~ } \mathrm { a r r } [ \mathrm { ~ i ~ \Gamma ~ + ~ }$ 1] { break } } var l int $= ( \frac { \mathrm { ~ i ~ \hbar ~ } } { 1 } + \mathrm { ~ 1 ~ } ) \frac { \circ } { \circ } \mathrm { ~ n ~ }$ var r int $\qquad = \quad \\\\\\\\\perp$ var cnt int $\qquad = \quad 0$ for l != r { if arr[l] $^ +$ arr[r] == x { cnt++ $\mathbf { i } \notin \mathbb { R } ^ { } 2 \ : \equiv \ : \ : ( \mathbf { r } _ { } \mathrm { ~ \ j ~ - ~ \frac ~ { ~ 1 ~ } ~ { ~ 1 ~ } ~ + ~ \eta ~ } _ { } \mathtt { n } ) \notin \mathbb { R } \ : \ : \{ \ :$ { return cnt } l = (l + 1) % n r = (r - 1 + n) % n } else if arr[l] + arr[r] < x { $1 = ( 1 + 1 ) \frac { 2 } { 0 } \pi$ } else { r = (n + r - 1) % n } } return cnt   
+}   
+// C++   
+int pairsInSortedRotated(int arr[], int n, int x)   
+{ int i; for $( \mathrm { ~ i ~ ~ } \ = \ \mathrm { ~ 0 ~ } ; \ \mathrm { ~ i ~ } \ < \ \mathrm { ~ n ~ ~ - ~ } \ \mathrm { ~ 1 ~ } ; \ \mathrm { ~ i ~ } \ + + )$ { if (arr $[ \pm ] >$ arr $[  { \mathrm { ~ i ~ \phi ~ } } +  { \mathrm { ~ 1 ~ } } ]$ ) break; } int $1 = ( \dot { \bf ~ 1 } + \dot { \bf ~ 1 } ) \frac { \ d s } { \ d s } \mathrm {  ~ n ~ } ;$ int $\mathrm { ~ \bf ~ r ~ } = \mathrm { ~ \bf ~ i ~ } ;$ ; int cnt $\qquad = \quad 0$ ; while $( \underline { { { 1 } } } \quad : = \quad \underline { { { { \bf r } } } } )$ ) { if (arr [l] + arr $[ { \boldsymbol { \textbf { r } } } ] \ \mathbf { \Sigma } = = { \boldsymbol { \textbf { x } } } )$ ) { cnt $^ { + + }$ ; $\begin{array} { c c c c c c c c c } { { \lfloor \pm } } & { { ( 1 } } & { { = = } } & { { ( \tt { r } } } & { { - } } & { { 1 } } & { { + } } & { { \tt { n } ) } } & { { \tt { \& } } } & { { \tt { n } ) } } & { { } } & { { } } \end{array}$ return cnt; $1 = ( 1 + 1 ) \frac { 2 } { 9 } \pi ;$ $\begin{array} { r c c c c l } { \texttt { r } = } & { ( \texttt { r } - } & { \texttt { l } + } & { \texttt { n } ) } & { \frac { \circ } { \circ } } & { \mathtt { n } } & { ; } \end{array}$ } else $\begin{array} { r } { \mathrm { i } \texttt { i f } \left( \mathrm { a r r } \left[ \mathrm { \texttt { l } } \right] \ + \ \mathrm { a r r } \left[ \mathrm { \texttt { r } } \right] \ < \ \textbf { x } \right) \ \mathrm { ~ \texttt { l } ~ = ~ \textbf { ( } \mathrm { 1 ~ \texttt { + } ~ 1 ~ } ) ~ \ \frac { \circ } { \circ } ~ \ n ~ } ; } \end{array}$ else $\texttt { r } = \texttt { ( n + r - l ) } \texttt { \frac { e } { s } n }$ ; } return cnt;
+
+![](images/c29b3950a88fe4f248abeed7fc389851c6a8803d4218b21d151f93ee7b37bb9f.jpg)  
+Figure 9: Rust to Go translation example. We call S1 the string n1 repeated s1 times and S2 the string n2 repeated $_ { \textrm { S 2 } }$ times. This function finds the largest number of repetitions of S2 appearing in any subset of S1. The model translates the types correctly, understands that casting vector indices to unsigned int (i.e. with as usize) is not required in Go, and correctly translates other Rust constructs to Go.
+
+# F DATASET SIZE DETAILS
+
+Table 6: Dataset details: number of tokens in our function-level dataset. This dataset contains only functions defined outside of classes and static functions.   
+
+<table><tr><td></td><td>Numberof tokens</td><td>Number of sentences</td></tr><tr><td>Monolingual data</td><td></td><td></td></tr><tr><td>C++</td><td>2.33B</td><td>6.6M</td></tr><tr><td>Go</td><td>1.9B</td><td>9.4M</td></tr><tr><td>Java</td><td>1.5B</td><td>7.8M</td></tr><tr><td>Rust</td><td>130.0M</td><td>576.3K</td></tr><tr><td>Code /IR Parallel Data</td><td></td><td></td></tr><tr><td>C++-IR</td><td>946.7M</td><td>343.9K</td></tr><tr><td>Go-IR</td><td>971.8M</td><td>384.4K</td></tr><tr><td>Java-IR</td><td>1.7B</td><td>2.2M</td></tr><tr><td>Rust-IR</td><td>77.7M</td><td>19.4K</td></tr></table>
+
+# G ADDITIONAL ABLATIONS
+
+Training on IRs with different objectives. We perform some additional ablations to determine whether our performance improvements come from training on IRs or from our TLM, TAE and MT objectives. When training a model with the three objectives of TransCoder (i.e. MLM, DAE and BT) and considering the IR as an extra language, we obtain an average computational accuracy of 37.4, which is lower than that of our baseline TransCoder. As the structure of the IR is not similar to that of any of our source languages, there is not much to gain from adding the IR as an extra language. Moreover, the model is wasting some time to compute the AE and BT objectives for the IR which can be better spent on the source languages. It confirms that our objectives are required to map IRs and their corresponding source code to similar representations in embedding space.
+
+Language ablation: no Java. As Rust and Go are more similar to Java than to $\mathrm { C } { + + }$ , we also train a baseline model on $\mathrm { C } { + } { + }$ , Go and Rust only to evaluate whether including Java hurts the translation performance. We observed similar performance for $\mathbf { C } \mathbf { + } \mathbf { + }  \mathbf { G } \mathbf { o }$ . However, we also observe a clear decrease in performance in the very low data regime (i.e. when translating to or from Rust). The computational accuracy for Rust $ \mathbf { C } + +$ goes down from $2 2 . 4 \%$ to $2 0 . 1 \%$ and it goes down from $4 3 . 1 \bar { 5 } \%$ to $3 2 . 5 \%$ for Rust $ \mathrm { G o }$ .
+
+# H WORD EMBEDDINGS
+
+We notice that our method generates improved word embeddings. It is visible when looking at the cosine similarity for embeddings of rust types and their equivalents in $\mathrm { C } { + } { + }$ . For instance, Figure 10 shows that the embedding of $\hphantom { 0 } \mathrm { { 3 2 } }$ from our model leveraging LLVM IRs is most similar to uint32 (with a cosine similarity of 0.4869). uint, which is also a correct translation, comes in $1 1 ^ { t h }$ position with a cosine similarity (0.3716). In contrast, $\hphantom { 0 } \mathrm { { 3 2 } }$ has a similarity of only 0.2828 with int. This token, which would be an incorrect translation, comes only in $2 9 ^ { t h }$ position.
+
+The baseline model, which does not use the IR, learns similar representations for rust types since they appear in similar contexts. Hence, its embedding of $\hphantom { 0 } \hphantom { 0 } \hphantom { 0 } \hphantom { 0 } \hphantom { 0 } \hphantom { 0 } \hphantom { 0 } \hphantom { 0 } \hphantom { 0 } \hphantom { 0 } \hphantom { 0 } \hphantom { 0 } \hphantom { 0 } \hphantom { 0 } \hphantom { 0 } \hphantom { 0 } \hphantom { 0 } \hphantom { 0 } \hphantom { 0 } \hphantom { 0 } \hphantom { 0 } \hphantom { 0 } \hphantom { 0 } \hphantom { 0 } \hphantom { 0 } \hphantom { 0 } \hphantom { 0 } \hphantom { 0 } \hphantom { 0 } \hphantom { 0 } \hphantom { 0 } \hphantom { 0 } \hphantom { 0 } \hphantom { 0 } \hphantom { 0 } \hphantom { 0 } \hphantom { 0 } \hphantom { 0 } \hphantom { 0 } \hphantom { 0 } \hphantom { 0 } \hphantom { 0 } \hphantom { 0 } \hphantom { 0 } \hphantom { 0 } \hphantom \hphantom { 0 } \hphantom { 0 } \hphantom \hphantom { 0 } \hphantom \hphantom { 0 } \hphantom \hphantom { 0 } \hphantom \hphantom \hphantom { 0 } \hphantom \hphantom \hphantom \hphantom { 0 } \hphantom \hphantom \hphantom \hphantom \hphantom \end \hphantom \hphantom \hphantom \hphantom  \hphantom \hphantom \hphantom \hphantom \hphantom \hphantom \hphantom \hphantom \hphantom \hphantom \hphantom \hphantom \end f$ is most similar to other rust types tokens such as $\mathtt { \small u 6 4 }$ , i32 or u16. uint32 comes only in fourth position with a cosine similarity of 0.4218. Moreover, uint and int have almost the same cosine similarities with $\hphantom { 0 } \mathrm { { 3 2 } }$ with the baseline model. It causes the model to often confuse unsigned and signed integer types, and to incorrectly translate u32 into int instead of uint.
+
+![](images/1141077b8224742da55bf418f82a47d1be7099a3d390c36e36affeca54543599.jpg)  
+Figure 10: Token similarities. Rank and token similarity with $\mathtt { u } 3 2$ for our model (right) and the baseline model (left). Our model generates embeddings that better capture token semantics.
+
+# I ANALYSIS OF ERROR TYPES
+
+Table 7: Rust error types. To validate our intuition on the usefulness of the IR representations to decrease the number of type-related errors (see Fig.1 or Fig.6), we perform an in-depth analysis of the types of errors encountered for the Java Rust direction. Here we count the total number of errors (there can be several for a single translation). We notice that the number of type-related errors (excluding E0433, E0425 and Others) decreases by $24 \%$ (609 vs. 463) and the number of mismatched types decreases by $49 \%$ .   
+
+<table><tr><td>Error Code</td><td>Error Description</td><td>Baseline (Transcoder)</td><td>TLM + TAE + MT</td></tr><tr><td>E0308</td><td>Mismatched Type</td><td>414</td><td>210</td></tr><tr><td>E0412</td><td>Type Does Not Exist</td><td>15</td><td>3</td></tr><tr><td>E0277</td><td>Type has Missing Trait</td><td>180</td><td>250</td></tr><tr><td>E0425</td><td>Undefined Variable</td><td>18</td><td>27</td></tr><tr><td>E0433</td><td>Use of Undefined Crate,Module or Type</td><td>15</td><td>32</td></tr><tr><td>丨</td><td>Others</td><td>28</td><td>33</td></tr><tr><td>TOTAL</td><td></td><td>670</td><td>555</td></tr></table>

parse/dev/XomEU3eNeSQ/XomEU3eNeSQ_content_list.json

@@ -0,0 +1,1848 @@
+[
+    {
+        "type": "text",
+        "text": "CODE TRANSLATION WITH COMPILER REPRESENTATIONS ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            98,
+            633,
+            146
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Marc Szafraniec∗ Baptiste Rozière\\* Patrick Labatut Gabriel Synnaeve ",
+        "bbox": [
+            184,
+            170,
+            439,
+            198
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Hugh Leather François Charton ",
+        "bbox": [
+            450,
+            170,
+            692,
+            199
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Meta AI {mszafraniec,broz}@meta.com ",
+        "bbox": [
+            186,
+            199,
+            392,
+            224
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "ABSTRACT ",
+        "text_level": 1,
+        "bbox": [
+            454,
+            244,
+            544,
+            260
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "In this paper, we leverage low-level compiler intermediate representations (IR) to improve code translation. Traditional transpilers rely on syntactic information and handcrafted rules, which limits their applicability and produces unnaturallooking code. Applying neural machine translation (NMT) approaches to code has successfully broadened the set of programs on which one can get a naturallooking translation. However, they treat the code as sequences of text tokens, and still do not differentiate well enough between similar pieces of code which have different semantics in different languages. The consequence is low quality translation, reducing the practicality of NMT, and stressing the need for an approach significantly increasing its accuracy. Here we propose to augment code translation with IRs, specifically LLVM IR, with results on the $\\mathrm { C } { + } { + }$ , Java, Rust, and Go languages. Our method improves upon the state of the art for unsupervised code translation, increasing the number of correct translations by $11 \\%$ on average, and up to $79 \\%$ for the Java $ \\mathrm { R u s t }$ pair with greedy decoding. With beam search, it increases the number of correct translations by $5 . 5 \\%$ in average. We extend previous test sets for code translation, by adding hundreds of Go and Rust functions. Additionally, we train models with high performance on the problem of IR decompilation, generating programming source code from IR, and study using IRs as intermediary pivot for translation. ",
+        "bbox": [
+            233,
+            277,
+            766,
+            540
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 INTRODUCTION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            568,
+            336,
+            584
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Automatic code translation allows to port old codebases to new frameworks, or high-level (but slow) languages to low-level (and fast) ones. Current industry solutions, known as transpilers or transcompilers1, rely on handcrafted rules that are applied systematically. They produce unidiomatic translations that prove hard to read for human programmers. This is a serious limitation: the translated code should be easy to read and understand, as it will eventually be maintained by human developers. ",
+        "bbox": [
+            174,
+            599,
+            825,
+            670
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "In recent years, Neural Machine Translation (NMT) was proposed as an alternative to rule-based code translation (Roziere et al., 2020; Weisz et al., 2021; 2022). These models, trained from existing human-readable code, produce idiomatic, easy to understand, translations. Unfortunately, neural transpilers are unreliable, and often fail to translate the semantics of the input program accurately. This is a serious limitation, as some of the human work saved by the transpiler has to be reinvested debugging its output. ",
+        "bbox": [
+            174,
+            676,
+            825,
+            761
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "We propose to improve the reliability of NMT by leveraging information from compiler toolchains. When processing source code, compilers create Intermediary Representations (IR): language-agnostic pseudocode that describes the semantics of the program. Augmenting training data with the corresponding IR can benefit a Neural Transpiler in two ways: it helps align embeddings for different languages and improves the semantic understanding of the code. As shown in Figure 1, this can greatly improve the semantic quality of neural translations. ",
+        "bbox": [
+            174,
+            767,
+            825,
+            851
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "In this work, we leverage LLVM (Lattner and Adve, 2004) to augment source code with corresponding Intermediate Representation and train models for code translation and decompilation. We compare ",
+        "bbox": [
+            176,
+            858,
+            821,
+            886
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "image",
+        "img_path": "images/4e5ce168677271d207a1232df7e84e1a16857d83646dab66d08821b92672e1f5.jpg",
+        "image_caption": [],
+        "image_footnote": [],
+        "bbox": [
+            179,
+            101,
+            828,
+            382
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Figure 1: Improvements over TransCoder. The first example shows a translation from $\\mathrm { C } { + } { + }$ to rust, where TransCoder generates code using unsigned instead of signed integers. In the second example, a translation from Java to Go, it generates a function with the wrong return type. In the third example, which is also a translation from Java to Go, the model outputs a function that looks similar to the correct solution but it confuses $>$ with $\\gg$ and closes an expression with a parenthesis too early. In these cases and many others, TransCoder makes mistakes that are small in terms of edit distance, but have a large impact on the semantics of the code. Using the IR to ground the representations to the semantics often helps solving these issues. ",
+        "bbox": [
+            173,
+            396,
+            825,
+            486
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "it to TransCoder, which uses only code and no IR. We also design an IR-only baseline, dubbed the pivot method, which generates a translation solely by decompiling an IR generated from the source language to a different target language. We experiment with four languages: $\\mathrm { C } { + } { + }$ Java, Rust and Go, and show that utilizing both the code and the IR allows for an average relative improvement of $5 . 5 \\%$ . Moreover, our method only uses the IR at training time and does not require extra computations at inference time. ",
+        "bbox": [
+            174,
+            492,
+            825,
+            575
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Our main contributions are: ",
+        "bbox": [
+            174,
+            583,
+            354,
+            597
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "• We implement a new IR-augmented translation method, which leverages LLVM IRs to improve code representations. It allows us to increase the number of correct translations generated by TransCoder for $\\mathrm { C } { + } { + }$ , Java, Go and Rust by $5 . 5 \\%$ . Compared to our IR-only pivot method, the improvement reaches $170 \\%$   \n• Our method is especially useful in the low data regime: with relative improvements reaching $2 9 . 7 \\%$ when translating to Rust and $2 5 . 6 \\%$ when translating from it.   \n• We extend the parallel evaluation dataset of 852 functions in $\\mathrm { C } { + + }$ , Java and Python from Roziere et al. (2020) with 343 more functions in Go and 280 more in Rust, along with corresponding test cases   \n• In addition, we achieve $78 \\%$ accuracy when decompiling LLVM IRs to $\\mathrm { C } { + + }$ ",
+        "bbox": [
+            217,
+            609,
+            825,
+            763
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2 INTERMEDIATE REPRESENTATIONS IN COMPILERS ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            789,
+            619,
+            804
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Compilers translate programs written in a computer language into executable code for a specific machine. Most compilers consist of a front-end taking source code as input, and a back-end which produces machine binary code. The front-end lexes (tokenizes) and parses the program. Then, it produces an abstract syntax tree (AST), and translates it into some Intermediate Representation (IR). The back-end converts the IR into machine-specific executable code. ",
+        "bbox": [
+            174,
+            819,
+            825,
+            888
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "In modern compilers such as LLVM (Lattner and Adve, 2004), the IR is generic across different input languages (and thus different front-ends). It allows the application of transformations and target agnostic optimizations to the IR, in a middle-end module independent from the source language and target machine. This results in an efficient compiler structure: new languages can be implemented by rewriting the front-end, and new target machines by rewriting the back-end. ",
+        "bbox": [
+            173,
+            895,
+            823,
+            924
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "image",
+        "img_path": "images/a3fb548bd758d8295d507b87b8ee73f25aab1c16584606dce010463f0238d398.jpg",
+        "image_caption": [
+            "Figure 2: A bird’s eye view of a compiler toolchain, exemplified with LLVM. The unoptimized version $( - 0 0 )$ is shown here for illustration. In practice we used the size-optimized version $( - \\mathsf { O z } )$ of the IR as boxed, which does the compile time optimization of computing the addition of 26 and 16. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            174,
+            103,
+            823,
+            208
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            304,
+            823,
+            347
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Several IRs usually co-exist in a compiler: each stage in the toolchain (Figure 2) introduces a new representation. Early stage IRs are language-dependent (e.g. ASTs mirror the syntax of the source language). Late stage IRs replace named variables by registers and reflect the specifics of the target architecture. In this work, we are interested in middle-end IRs, which are independent from the target machine, and similar for all source languages (like dialects in natural languages). ",
+        "bbox": [
+            174,
+            353,
+            825,
+            424
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3 TRAINING OBJECTIVES ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            444,
+            398,
+            460
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Unsupervised machine translation consists of learning multilingual sequence embeddings, and generating sequence in any output language from these embeddings (Lample et al., 2018a). We now present the objective functions for these tasks. In section 3.1, we review the three basic objectives used by TransCoder, our baseline NMT system. In section 3.2, we introduce three new functions that leverage LLVM IRs to improve the multilingual representation of source code, and the performance of our translation models. During training, we alternate between all six objectives, running each for the same number of optimisation steps. At inference, the model is only provided with the source code, i.e. the IR is not needed. ",
+        "bbox": [
+            173,
+            477,
+            825,
+            589
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Formally, let $x = x _ { 1 } \\ldots x _ { N _ { s o } }$ be the source sentence, $z ^ { ( x ) } = z _ { 1 } ^ { ( x ) } \\dots z _ { N _ { i r } } ^ { ( x ) }$ the corresponding IR, and $y = y _ { 1 } \\dots y _ { N _ { t a } } $ the target sentence. We write $\\begin{array} { r } { \\mathcal { L } _ { C E } ( \\hat { y } , y ) = \\sum _ { i } \\ell _ { C E } ( \\ddot { y } _ { i } , y _ { i } ) } \\end{array}$ , with $\\ell _ { C E } ( \\hat { y } _ { i } , y _ { i } )$ the pairwise cross-entropy loss between $\\hat { y } _ { i }$ and $y _ { i }$ . We define the machine translation loss (or seq2seq loss) from $x$ to $y$ , $\\mathcal { L } _ { M T }$ as the sum of the negative log-likelihood of each token $y _ { i }$ , given $x$ and previous tokens $y _ { 0 } \\ldots y _ { i - 1 }$ (note that $x$ and $y$ can have different lengths) : ",
+        "bbox": [
+            173,
+            594,
+            825,
+            670
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/67e27b13a5225e3092af07df97dfe5fc2727543895d151e9cf5e51c620a916d7.jpg",
+        "text": "$$\n\\mathcal { L } _ { M T } ( x , y ) = - \\sum _ { i } \\log \\left( P ( y _ { i } | x , y _ { 1 } \\ldots y _ { i - 1 } ) \\right)\n$$",
+        "text_format": "latex",
+        "bbox": [
+            344,
+            678,
+            651,
+            712
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3.1 COMMON OBJECTIVE FUNCTIONS",
+        "text_level": 1,
+        "bbox": [
+            176,
+            727,
+            446,
+            741
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "TransCoder (Roziere et al., 2020) learns to translate between programming languages by leveraging three unsupervised objectives developed for natural language (Lample et al., 2018b): ",
+        "bbox": [
+            171,
+            753,
+            823,
+            782
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Masked Language Modeling (MLM) trains an encoder to predict randomly masked inputs. It is commonly used to pre-train embeddings for natural (Devlin et al., 2018; Liu et al., 2019) and programming languages (Kanade et al., 2020; Feng et al., 2020). MLM allows the model to learn the syntax and semantics of programs. Alternative objectives, have been proposed for programming languages (Guo et al., 2020; Lachaux et al., 2021; Ahmad et al., 2021; Wang et al., 2021). We do not use them here, as MLM remains effective and easy to use on a wide range of programming languages. ",
+        "bbox": [
+            173,
+            787,
+            825,
+            873
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Denoting $m a s k ( x )$ the masked version of the code sentence $x$ , and $e n c ( t )$ the encoder output, MLM uses the following loss: ",
+        "bbox": [
+            169,
+            878,
+            825,
+            907
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/29fae3ff36f24cf6fe7117e7f760781374714a7347684948f7df9c71ee9548fd.jpg",
+        "text": "$$\n\\mathcal { L } _ { M L M } = \\mathcal { L } _ { C E } \\left( e n c ( m a s k ( x ) ) , x \\right) .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            377,
+            909,
+            620,
+            925
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "image",
+        "img_path": "images/90a5e988f3483d0037d74465b54b9b166b3ff5748a8ee26c21d112bfb591a3fc.jpg",
+        "image_caption": [
+            "Figure 3: IR for code representation objectives. We show examples of masking (used in TLM and TAE) and IR generation used to improve code representations with IRs. The masking objective in TLM or TAE makes the model understand the relationship between code and IR. The IR generation objective helps the model to build semantic representations of the code. For instance, another $\\mathrm { C } { + + }$ function computing $3 9 \\ + \\ 3$ would result in the same IR. A Go function that returns 42 would also have a similar LLVM IR. Therefore, the IR Generation objective encourages the model to build similar representations for these three semantically equivalent functions. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            174,
+            119,
+            825,
+            349
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Denoising Auto Encoding (AE) trains a sequence to sequence (seq2seq) model to retrieve an original sequence from a corrupted version. Corruption is done by masking spans of tokens randomly sampled from a Poisson distribution, as well as removing and shuffling tokens. It uses the following loss $( n o i s e ( x )$ denotes the corrupted version of $x$ ): ",
+        "bbox": [
+            174,
+            458,
+            825,
+            515
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/1477506c8deee4b7fbb71a998023732aef2cc9c3a8db923d0e7d2fd849eb9489.jpg",
+        "text": "$$\n\\mathcal { L } _ { A E } = \\mathcal { L } _ { M T } \\left( n o i s e ( x ) , x \\right) .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            401,
+            523,
+            596,
+            541
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Back-Translation (BT). Back-Translation (Sennrich et al., 2015) uses the model to generate a noisy translation of the input sentence, and then trains the model to recover the original input from the translation. It is a simple yet powerful objective for unsupervised machine translation (Lample et al., 2018a; Artetxe et al., 2018). In practice, it is a required loss to get competitive performance, so it is a staple of all our experiments. Formally, we use the model to translate sequence $x$ into $\\hat { y }$ and train the model to reverse the translation process, using the loss: ",
+        "bbox": [
+            173,
+            555,
+            825,
+            641
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/7e15dcea4c48b75ca7907c02567b65df35da89817d5747f2b5a9df593cc756ce.jpg",
+        "text": "$$\n\\mathcal { L } _ { B T } = \\mathcal { L } _ { M T } \\left( \\hat { y } , x \\right)\n$$",
+        "text_format": "latex",
+        "bbox": [
+            431,
+            648,
+            566,
+            666
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3.2 IR FOR CODE REPRESENTATIONS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            684,
+            441,
+            698
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Intermediate representations (IR) provide additional information about the code to be translated. We add them to the training dataset, as described in section 4.2, and leverage them by adding three new objective functions to those described in section 3.1. ",
+        "bbox": [
+            174,
+            710,
+            825,
+            753
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Translation Language Modeling (TLM), first introduced in Lample and Conneau (2019), strives at generating common representations for parallel sentences in different languages. Like the masked language modeling (MLM) objective, it trains an encoder to predict random masked inputs. However, TLM is trained on pairs of parallel sentences, concatenated together and separated by a special token. Here, we concatenate functions in their source language and their corresponding IR, using the source code and IR language embeddings, and train the encoder to predict randomly masked tokens. This allows the model to learn correspondences between the source and the IR. The corresponding loss is ( $\\oplus$ denotes concatenation): ",
+        "bbox": [
+            173,
+            770,
+            826,
+            882
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/a00ae687357974f6d98dcf75658ac3e028243c152551284da61c1deb1abdd7ae.jpg",
+        "text": "$$\n\\mathcal { L } _ { T L M } = \\mathcal { L } _ { C E } \\left( m a s k ( x \\oplus z ^ { ( x ) } ) , x \\oplus z ^ { ( x ) } \\right)\n$$",
+        "text_format": "latex",
+        "bbox": [
+            351,
+            901,
+            645,
+            929
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "image",
+        "img_path": "images/c6d5185f61ecb1d679f8470f8bb5d4104b7692dffb819bb4c91a810f5d2df200.jpg",
+        "image_caption": [
+            "Figure 4: IR Decompilation objective. Here, we generate the IR corresponding to each function and train a model to decompile it. The IR pivot model uses this objective, as well as back-translation objectives, allowing it generalize to IRs generated from any language. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            173,
+            77,
+            825,
+            174
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Translation Auto-Encoding (TAE) amounts to transposing the TLM objective into a denoising auto-encoder. The source code and corresponding IR are corrupted and masked, and then concatenated into one sequence (using the language embeddings for code and IR, as previously). TAE is then tasked to recover the original, using the following loss: ",
+        "bbox": [
+            174,
+            268,
+            825,
+            325
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/c7454aefe570e7c6e4bca1ec79ea535cba3debd650acdb8eb85ad2b88385c2be.jpg",
+        "text": "$$\n\\mathcal { L } _ { T A E } = \\mathcal { L } _ { M T } \\left( n o i s e ( x ) \\oplus n o i s e ( z ^ { ( x ) } ) , x \\oplus z ^ { ( x ) } \\right)\n$$",
+        "text_format": "latex",
+        "bbox": [
+            325,
+            337,
+            671,
+            363
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "IR Generation (MT) trains the model to translate the source code into the corresponding IR. This allows the encoder to learn source code representations from the semantics of the IR. The loss is: ",
+        "bbox": [
+            171,
+            381,
+            823,
+            410
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/44de55a84e4c90f4f2f3862fad436ccd311d8ada7b923bd3ea22062da99d4b27.jpg",
+        "text": "$$\n\\mathcal { L } _ { I R G e n } = \\mathcal { L } _ { M T } \\left( x , z ^ { ( x ) } \\right)\n$$",
+        "text_format": "latex",
+        "bbox": [
+            408,
+            433,
+            588,
+            459
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "These three objectives need both the source code and the corresponding IR. However, only a fraction of the functions and files in our dataset could be compiled. To mitigate this, we also train the models on the full monolingual data using the MLM and AE objectives described above. In this setup, the back-translation (BT) objective is the same as in Roziere et al. (2020), and allows our model to translate directly from source code only at inference time. ",
+        "bbox": [
+            173,
+            474,
+            825,
+            545
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "3.3 ADDITIONAL LOSSES: IR DECOMPILATION AND PIVOT ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            565,
+            596,
+            582
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "We study two alternative uses of intermediary representations: IR decompilation, and IR pivot translation. IR decompilation consists of recovering source code corresponding to a given IR. In practice, it reverses the computations performed by the compiler. IR Pivot is a translation method built upon IR decompilation. Since LLVM can compile many languages $( \\mathbf { C } + +$ , Java, Rust, Go) into the same IR, an obvious approach to code translation consists of decompiling the IR generated from the source language into code in the target language. We call this method “IR pivot”. Note that, whereas the IR for code representation techniques only used IR during training, both the decompilation and pivot method also need the IR for inference. ",
+        "bbox": [
+            173,
+            593,
+            825,
+            707
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Decompilation. In this supervised task, we use LLVM to generate IR from source code, and train a language model to reverse the process, i.e. learn to predict the source code from the IR. Models are pre-trained using the MLM and AE objectives, and decompilation is learned using the machine translation loss: ",
+        "bbox": [
+            173,
+            726,
+            825,
+            781
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/2ce80764eb26a8059393b072022f99d73253f0c2c863d83b95f7d1a89d55b3ef.jpg",
+        "text": "$$\n\\mathcal { L } _ { D e c o m p } = \\mathcal { L } _ { M T } \\left( z ^ { ( x ) } , x \\right)\n$$",
+        "text_format": "latex",
+        "bbox": [
+            405,
+            784,
+            591,
+            810
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "IR Pivot. This task leverages the IR as a pivot for code translation. For instance, to translate from Rust to $\\mathrm { C } { + } { + }$ , we first use LLVM to compile a Rust program into IR and then decompile the IR to $\\mathrm { C } { + } { + }$ using a neural decompiler. In practice, slight variations exists between the IR generated for different languages: the Rust-IR and $\\mathrm { C } { + + }$ -IR behave like dialects of the LLVM-IR. This often leads to poor performance of the IR Pivot method. We mitigate these issues using a variety of techniques, which we describe in section C of the appendix. ",
+        "bbox": [
+            173,
+            839,
+            825,
+            924
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "4 DATA ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            102,
+            251,
+            117
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "4.1 TRAINING DATA ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            126,
+            328,
+            140
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Our training data was extracted with Google BigQuery, which indexes over 2.8 million open source repositories from $\\mathrm { G i t H u b } ^ { 2 }$ . We selected projects whose license explicitly permits re-distribution of parts, and extracted all individual $\\mathrm { C } { + } { + }$ , Java, Rust and Go functions. To learn to decompile IRs, we also used the CodeNet dataset (Puri et al., 2021), a repository of 14 million competitive programming solutions in 55 languages. Our models work at function level: this reduces compilation failures over missing dependencies, while keeping sequence lengths short. ",
+        "bbox": [
+            173,
+            145,
+            825,
+            229
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "table",
+        "img_path": "images/5076cb2e53897509ca7243fa573292c5a46aae9242e6fb78828275446d8fd261.jpg",
+        "table_caption": [
+            "Table 1: Dataset coverage across languages, in number of standalone functions. More details can be found in Table 7 in the appendix. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td></td><td>C++</td><td>Go</td><td>Java</td><td>Rust</td></tr><tr><td>Monolingual data</td><td>6.6M</td><td>9.4 M</td><td>7.8M</td><td>576.3K</td></tr><tr><td>Code/IRParallel Data</td><td>344.4 K</td><td>384.4K</td><td>2.2 M</td><td>19.2 K</td></tr><tr><td>Successful IR Compilation</td><td>5.2%</td><td>4.1%</td><td>28.2%</td><td>3.3%</td></tr></table>",
+        "bbox": [
+            281,
+            281,
+            707,
+            344
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "4.2 GENERATING INTERMEDIATE REPRESENTATIONS ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            352,
+            555,
+            366
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "While the LLVM ecosystem is large, not every language has an LLVM front-end, and not every front-end can produce LLVM IR out-of-the-box. We use $\\mathsf { c } \\mathtt { l a n g } + + \\mathbf { \\lambda } ^ { 3 }$ Lattner and Adve (2004) from the established LLVM $\\mathrm { C } { + + }$ compilation toolchain, JLang4 for Java, Gollvm5 for Go and rustc Matsakis and Klock II (2014) for Rust. For the same program, written in different languages, different front-ends may produce different IR. To minimize these variations, we process the source code as follows. First, we generate the most size-optimized IR (- ${ \\bf \\nabla } \\cdot O z$ flag), which makes the IR more uniform across languages. Second, we strip all unnecessary information (e.g. header and footer with attributes, debug information, comments). Finally, block names are canonicalized and symbol names demangled to facilitate their recovery. The functions that fail to compile at this point (e.g. because of missing dependencies) are not included in the parallel dataset, as seen in the last row of Table 1. ",
+        "bbox": [
+            173,
+            369,
+            825,
+            508
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "4.3 EVALUATION ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            526,
+            305,
+            540
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Traditional NMT evaluation relies on metrics such as BLEU, that are based on n-gram overlaps. However, when dealing with programming languages, syntax and in particular compilation and computation outputs can differ widely despite minor changes in the code. Conversely, semantically equivalent code, that differ only in variable names or order of operations can have a low BLEU score. To take this into account, we use and enhance the computational accuracy test suite from Roziere et al. (2020), that contains 852 parallel competitive programming solutions in $\\mathrm { C } { + + }$ , Java and Python. Using C2Rust, $\\mathbf { \\boldsymbol { C } } \\mathbf { \\boldsymbol { x } } \\mathbf { \\boldsymbol { G } } \\mathbf { \\boldsymbol { 0 } }$ and some manual code cleaning, we translated 280 functions and test suites in Rust and 343 in Go to measure the performance of our models in these languages. We measure our performance using the computational accuracy $\\left( \\mathbf { C A @ 1 } \\right)$ metric (Kulal et al., 2019; Roziere et al., 2020), which considers that a translation is correct if it passes a series of unit tests. ",
+        "bbox": [
+            173,
+            545,
+            826,
+            684
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "5 RESULTS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            704,
+            281,
+            720
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "5.1 EXPERIMENTAL DETAILS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            729,
+            388,
+            743
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "For TransCoder, we consider a sequence-to-sequence (seq2seq) transformer model (Vaswani et al., 2017) with attention (Bahdanau et al., 2015; Sutskever et al., 2014) and the same architecture as Roziere et al. (2020). Our model has 12 layers (6 in the encoder and 6 in the decoder), 8 attention heads, and a dimension of 1024. For the objectives that add noise and masks to the input sentence, such as MLM, TLM, AE, and TAE, we choose the masked tokens and noise randomly on the fly at each epoch. We mask $15 \\%$ of the tokens in MLM and TLM. In AE and TAE, we mask $20 \\%$ of the tokens. MLM is trained on streams of data, while the other objectives are trained at function level. We use the Adam optimizer (Kingma and Ba, 2015) and an inverse squared-root learning rate scheduler, with an initial learning rate of $1 0 ^ { - 5 }$ in most of our experiments. Our models are implemented in PyTorch using mixed-precision floats. The pre-trained models were trained until convergence. The translation models presented in Tables 2 and 3 were trained for a week on 32 NVIDIA V100 GPUs. ",
+        "bbox": [
+            174,
+            748,
+            825,
+            845
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "table",
+        "img_path": "images/651fa4a2e3e81efd640052f4f33fcf41d8f0875c0ad82731059fb63ae694de7a.jpg",
+        "table_caption": [
+            "Table 2: Translation performance $( \\mathbf { C A } @ \\mathbf { 1 } )$ , for greedy decoding and beam size 5. “To $X ^ { \\ast }$ : average performance when translating to language X. “From $X ^ { \\ast }$ : average performance when translating from language X. See Table 3 in the appendix for more detailed results. All these methods except for the IR pivot also use the three objectives defined in TransCoder: MLM, DAE and Back-Translation (BT). All combinations of the TLM, MT and TAE objectives improve the performance compared to TransCoder. The best results are obtained when all three are used at the same time. Beam search, using beam size 5 and returning only the top element from the beam results in improved performance. The IR Pivot method generates a translation in the target language from an IR generated from the source, and performs poorly in our setting. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td></td><td>from C++ to C++ from Go to Go from Java to Java from Rust to Rust</td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td>AVG</td></tr><tr><td>Greedy decoding</td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td></tr><tr><td>IR Pivot</td><td>17.4</td><td>24.0</td><td>19.9</td><td>11.5</td><td>11.9</td><td>22.2</td><td>16.3</td><td>7.8</td><td>16.4</td></tr><tr><td>TransCoder (baseline)</td><td>46.4</td><td>52.1</td><td>42.1</td><td>45.6</td><td>41.2</td><td>44.5</td><td>29.6</td><td>17.0</td><td>39.8</td></tr><tr><td>TLM</td><td>47.5</td><td>54.8</td><td>45.4</td><td>41.2</td><td>39.8</td><td>52.1</td><td>31.1</td><td>15.7</td><td>40.9</td></tr><tr><td>MLM+ TAE</td><td>47.3</td><td>53.3</td><td>47.2</td><td>44.8</td><td>41.8</td><td>45.9</td><td>25.1</td><td>17.4</td><td>40.4</td></tr><tr><td>TLM+TAE</td><td>46.9</td><td>55.9</td><td>45.0</td><td>37.9</td><td>38.5</td><td>54.5</td><td>34.9</td><td>16.8</td><td>41.3</td></tr><tr><td>MLM+MT</td><td>45.5</td><td>51.0</td><td>44.0</td><td>48.9</td><td>46.6</td><td>45.2</td><td>25.7</td><td>16.6</td><td>40.5</td></tr><tr><td>TLM + MT</td><td>45.6</td><td>51.5</td><td>45.1</td><td>47.1</td><td>46.9</td><td>45.5</td><td>24.4</td><td>17.9</td><td>40.5</td></tr><tr><td>TAE +MT</td><td>47.8</td><td>54.3</td><td>43.8</td><td>43.9</td><td>39.1</td><td>49.2</td><td>33.4</td><td>16.7</td><td>41.0</td></tr><tr><td>TLM + TAE +MT</td><td>47.8</td><td>54.3</td><td>46.6</td><td>51.6</td><td>47.1</td><td>49.6</td><td>35.3</td><td>21.4</td><td>44.2</td></tr><tr><td>Beam size 5</td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td></tr><tr><td>TransCoder (baseline)</td><td>53.8</td><td>53.4</td><td>45.2</td><td>54.4</td><td>46.1</td><td>51.5</td><td>35.9</td><td>20.9</td><td>45.3</td></tr><tr><td>TLM + TAE +MT</td><td>52.9</td><td>53.5</td><td>48.8</td><td>57.1</td><td>51.5</td><td>53.4</td><td>37.9</td><td>27.1</td><td>47.8</td></tr></table>",
+        "bbox": [
+            169,
+            220,
+            828,
+            439
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            450,
+            825,
+            507
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "5.2 IR-AUGMENTED CODE REPRESENTATIONS FOR TRANSLATION ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            527,
+            642,
+            541
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Models using combinations of the three objectives—TAE, TLM and MT—introduced to leverage IR, were trained to translate between pairs of four languages $\\scriptstyle ( + +$ , Java, Rust, Go). Their average performance when translating to and from every language are presented in table 2. Additional information, including a comparison to TransCoder-ST for $\\mathrm { C } { + } { + } $ Java, can be found in Table 3) in the appendix. As a baseline, we use a TransCoder (Roziere et al., 2020) model, trained with MLM on the same dataset. ",
+        "bbox": [
+            174,
+            549,
+            825,
+            633
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Using greedy decoding, the new TLM, TAE and MT objectives, which leverage the IR, improve performance for every language. The best average results are obtained when combining all of them. Compared to TransCoder, they improve performance by an average $4 . 4 \\%$ point ( $1 1 \\%$ relative). The largest impacts are observed in the low data regime: translations from and into Rust (a language less represented in our training set) are improved by $2 5 . 6 \\%$ and $1 9 . 3 \\%$ (relative). Beam search improves the results of both TransCoder and our models, using IR-augmented representation still results in better performance. Qualitatively, we observe that IRs help our model translate types when the source and target types are represented by different tokens. For instance, in the first example of Table 1, it translates the semantics of int correctly using $\\pm 3 2$ instead of an unsigned integer type (usize). See Appendix H for more analysis on how our objectives improve word embeddings. ",
+        "bbox": [
+            174,
+            640,
+            825,
+            780
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Compared to IR-augmented translation models, the “obvious” IR Pivot method proves disappointing, even though it achieves non-trivial performances. It is heavily dependent on the size of the training set: the IR pivot performs relatively well when translating from low-resource to high-resource languages (e.g. from Rust), and badly when translating to low-resource languages (e.g. to Rust). ",
+        "bbox": [
+            174,
+            786,
+            825,
+            843
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "5.3 DECOMPILATION RESULTS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            862,
+            398,
+            876
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "To compute the IR pivot, we trained a neural decompiler to retrieve source code from IRs. We tried two separate configurations for decompilation: a shared decoder with 6 layers for all language / IR pairs, or four separate decoders of with two layers each (one per language). Using a shared decoder improves the performance for all languages, and particularly when the data is scarce (e.g. Rust). See Table 5 in the appendix for more information. ",
+        "bbox": [
+            176,
+            882,
+            823,
+            924
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            103,
+            823,
+            132
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "We compare the performance of our model to RetDec (Kˇroustek et al., 2017), a rule-based decompiler. It obtains a computational accuracy of 68.75 on our $\\mathrm { C } { + + }$ dataset and a BLEU score of 8.54. In comparison, our model obtains a computational accuracy of 77.9 and a BLEU score of 63.6 in the same setting. In particular, RetDec fails to decompile LLVM files generated from $\\mathrm { C } { + } { + }$ code, especially snippets leveraging the standard library structures such as unordered_map or $s t d :$ allocator. The limitations of RetDec, which was implemented by a team of 24 developers in 7 years 6, shows how difficult it is to build exhaustive rule-based decompilers, especially when the IR comes from different languages or tools. ",
+        "bbox": [
+            174,
+            138,
+            825,
+            251
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "6 DISCUSSION ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            271,
+            310,
+            287
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Different IR and interpreted languages The four languages considered in this work have frontends that can output LLVM Intermediary Representation. LLVM presently covers more than 30 computer languages. Using IR as pivot requires that the source and destination language have front-ends that use the same IR. This rules out some widely-used languages (e.g. Python). Using the IR to improve embeddings is less restrictive: the source and destination language can be trained on different IR, and aligned with back-translation. In this paper, we focus on compiled languages, but it is important to note that Intermediary Representations are usually available for interpreted languages as well: modern interpreters translate the source code into byte-code, that can serve as an IR. ",
+        "bbox": [
+            174,
+            303,
+            825,
+            414
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Pivot vs Embedding TransCoder is an unsupervised model that learns to align code representations and translate code from one language to another. It is based solely on source code and does not use IRs. The pivot method uses automatically generated parallel sentences to learn to decompile IRs, and back-translation to adapt to different IR dialects. This method learns to translate using only IR-level similarities, and does not use the source code itself except to compute the IR. Although it underperforms other methods, it performs relatively well when little data is available for the source language, because the IR can be computed using a rule-based compiler. However, it requires to compute IRs at test time, which can be cumbersome. Instead, adding the TLM, TAE, and MT objectives to the objectives generally used for unsupervised code translation allows the model to get the best of both worlds. It can learn multilingual representations of source code from similarities in the IR and in the source code itself. As shown in Table 2, it outperforms both TransCoder and the pivot method. At the same time, this model does not require to compute IRs at test time, and is as easy to use as TransCoder. ",
+        "bbox": [
+            174,
+            429,
+            825,
+            609
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Using our model at inference time. Our self-supervised IR-augmented TLM, TAE and MT objectives are designed to improve the multilingual code representations used in translation models. However, the translation task does not require to compute these objectives. Therefore, they lead to models that are just as simple to use as TransCoder: computing the IR is not required at test time and the model generates the translation directly from the source function. ",
+        "bbox": [
+            174,
+            626,
+            825,
+            695
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "7 RELATED WORKS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            715,
+            354,
+            732
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Source-to-Source Translation. Many rule-based methods are available for transpilation, an inventory of which can be found online1. In particular, ${ \\mathrm { C } } 2 { \\mathrm { R u s t } } ^ { 7 }$ and $\\mathrm { C x G o } ^ { 8 }$ , along with manual corrections, were central for us in translating evaluation tests to Go and Rust (See Section 4.3). Similarly, $2 \\mathrm { t o } 3 ^ { 9 }$ , a Python library porting Python 2 code to Python 3, was used in Aggarwal et al. (2015) to create a parallel dataset and train a machine learning model. ",
+        "bbox": [
+            174,
+            741,
+            826,
+            810
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Neural Machine Translation for code is hampered by the lack of parallel data between programming languages. Indeed, apart from a few language pairs, such as Java-C# (Nguyen et al., 2013; Chen et al., 2018), and specific domains (e.g. competitive programming code), it is difficult to collect large datasets of semantically equivalent code in different languages. TransCoder (Roziere et al., 2020) bridges this gap by introducing unsupervised machine translation to programming languages. They take advantage of large monolingual code bases to learn to translate between $\\mathrm { C } { + } { + }$ , Python and Java with high performance. Later, DOBF (Lachaux et al., 2021) improved the model pre-training method used in TransCoder, and Roziere et al. (2022) used automatically generated unit tests to improve translation performance between Java, $\\mathrm { C } { + } { + }$ and Python. Recently, large language models trained on code, such as Codex (Chen et al., 2021) and PALM (Chowdhery et al., 2022), have been used for unsupervised code translation. ",
+        "bbox": [
+            173,
+            818,
+            823,
+            847
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            103,
+            825,
+            228
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Using the Transcoder model, Weisz et al. (2021) and Weisz et al. (2022) survey the links between humans and NMT methods for code translation. They view neural translation methods as aids to programmers. In this context, they demonstrate that even imperfect models can improve the quality of an engineer’s work for code translation, and plead for the improvement of human-machine interfaces. ",
+        "bbox": [
+            174,
+            236,
+            825,
+            291
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Decompilation. Like transpilation, decompilation is usually performed using rule-based methods that rely on pattern matching to parse the control flow structure of the program. RetDec, an open source decompiler created by Avast (Kˇroustek et al., 2017), can decompile an executable to C and a Python-like language via LLVM IR. Other tools exist, such as the Hex-Rays Decompiler10 and Brumley et al. (2013). A thorough review of rule-based methods can be found in papers such as Liang et al. (2021a) and Katz et al. (2019). With these methods, decompilation can fail if the code is too convoluted, or if it contains language features that were not explicitly translated. Most methods also produce unstructured programs, relying on a large number of goto statements to simulate the control flow of the lower level programming languages. This is semantically correct, but very rarely found in human-written code. ",
+        "bbox": [
+            174,
+            297,
+            825,
+            438
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "A few works have studied the use of sequence-to-sequence neural networks for neural decompilation. Katz et al. (2019) uses LSTM networks to decompile LLVM IRs and assembly code to C. Their approach generates code templates based on the IR, that determine the structure of the output. Then, they fill them with correct variable assignments and numerical values. In the same vein, Fu et al. (2019) tries to address limitations of neural decompilation with two sequential phases: code sketch generation and iterative error correction. Finally, Liang et al. (2021b) use a method close to ours, and train Transformer models to translate between binary code and C. ",
+        "bbox": [
+            174,
+            444,
+            826,
+            541
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Intermediate representations are almost as old as compiler design. The first IR, UNCOL (Strong et al., 1958) was introduced in the mid-1950s, together with the idea of reusing the same compiler for several languages and machines. In 1960, NELIAC (a variant of ALGOL) (Huskey et al., 1960) was the first retargetable compiler, portable to different architectures. Feldman (1979) describes how a compiler for Fortran 77 can be added to the C compilers of Johnson (1979) and Ritchie (1979). GCC (Stallman, 2001) introduces Register Transfer Language (RTL) a low-level IR inspired by Davidson and Fraser (1980), and then GENERIC and GIMPLE (Merrill, 2003), precursors of the IR used in LLVM (Lattner and Adve, 2004). ",
+        "bbox": [
+            174,
+            549,
+            825,
+            660
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "8 CONCLUSION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            686,
+            318,
+            703
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "In this paper, we leverage LLVM IRs to improve neural machine translation for source code. The IR provides a common semantically-rich language, into which $\\mathrm { C } { + } { + }$ , Go, Java and Rust code can all be compiled. We develop three objectives, designed to leverage IRs for better multilingual representations of source code, which lead to a $5 . 5 \\%$ relative average improvement for code translation. We also show that sequence-to-sequence transformers perform well for neural decompilation, and use this for pivot translation. ",
+        "bbox": [
+            174,
+            714,
+            825,
+            797
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "We only worked with the LLVM IR, but our approach is broadly applicable to any pair of languages that share a common Intermediate Representation. More generally any IR can help improve the code representations by tying them to the semantics. Another limitation is the scale of our current source and target sequences. As future work, LLVM IRs could be generated at a larger scale by compiling entire projects, which would greatly improve the percentage of successful IR compilations in Table 1. More languages and IRs could be used, and those extensions could be powered by larger models. ",
+        "bbox": [
+            174,
+            805,
+            825,
+            888
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "REFERENCES ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            102,
+            287,
+            118
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Karan Aggarwal, Mohammad Salameh, and Abram Hindle. Using machine translation for converting Python 2 to Python 3 code. Technical report, PeerJ PrePrints, 2015. ",
+        "bbox": [
+            176,
+            125,
+            823,
+            154
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Wasi Ahmad, Saikat Chakraborty, Baishakhi Ray, and Kai-Wei Chang. Unified pre-training for program understanding and generation. In Proceedings of the 2021 Conference of the North American Chapter of the Association for Computational Linguistics: Human Language Technologies, pages 2655–2668, 2021. ",
+        "bbox": [
+            174,
+            161,
+            826,
+            218
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Mikel Artetxe, Gorka Labaka, and Eneko Agirre. Unsupervised statistical machine translation. In Proceedings of the 2018 Conference on Empirical Methods in Natural Language Processing, 2018. ",
+        "bbox": [
+            176,
+            227,
+            823,
+            268
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Dzmitry Bahdanau, Kyung Hyun Cho, and Yoshua Bengio. Neural machine translation by jointly learning to align and translate. In 3rd International Conference on Learning Representations, 2015. ",
+        "bbox": [
+            171,
+            277,
+            825,
+            306
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "David Brumley, JongHyup Lee, Edward J Schwartz, and Maverick Woo. Native $\\mathbf { \\boldsymbol { x } } 8 6$ decompilation using semantics-preserving structural analysis and iterative control-flow structuring. In 22nd USENIX Security Symposium (USENIX Security 13), pages 353–368, 2013. ",
+        "bbox": [
+            176,
+            314,
+            823,
+            358
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Mark Chen, Jerry Tworek, Heewoo Jun, Qiming Yuan, Henrique Ponde, Jared Kaplan, Harri Edwards, Yura Burda, Nicholas Joseph, Greg Brockman, et al. Evaluating large language models trained on code. arXiv preprint arXiv:2107.03374, 2021. ",
+        "bbox": [
+            174,
+            364,
+            823,
+            409
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Xinyun Chen, Chang Liu, and Dawn Song. Tree-to-tree neural networks for program translation. In Advances in neural information processing systems, pages 2547–2557, 2018. ",
+        "bbox": [
+            169,
+            415,
+            823,
+            445
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "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. ",
+        "bbox": [
+            174,
+            452,
+            823,
+            496
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Jack W. Davidson and Christopher W. Fraser. The design and application of a retargetable peephole optimizer. ACM Trans. Program. Lang. Syst., 2(2):191–202, apr 1980. ISSN 0164-0925. ",
+        "bbox": [
+            169,
+            503,
+            823,
+            534
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Jacob Devlin, Ming-Wei Chang, Kenton Lee, and Kristina Toutanova. BERT: Pre-training of deep bidirectional transformers for language understanding. CoRR, abs/1810.04805, 2018. ",
+        "bbox": [
+            168,
+            540,
+            823,
+            570
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Stuart I. Feldman. Implementation of a portable Fortran 77 compiler using modern tools. SIGPLAN Not., 14(8):98–106, aug 1979. ISSN 0362-1340. doi: 10.1145/872732.806959. URL https: //doi.org/10.1145/872732.806959. ",
+        "bbox": [
+            176,
+            577,
+            825,
+            619
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Zhangyin Feng, Daya Guo, Duyu Tang, Nan Duan, Xiaocheng Feng, Ming Gong, Linjun Shou, Bing Qin, Ting Liu, Daxin Jiang, et al. Codebert: A pre-trained model for programming and natural languages. In Proceedings of the 2020 Conference on Empirical Methods in Natural Language Processing: Findings, pages 1536–1547, 2020. ",
+        "bbox": [
+            173,
+            627,
+            825,
+            684
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Cheng Fu, Huili Chen, Haolan Liu, Xinyun Chen, Yuandong Tian, Farinaz Koushanfar, and Jishen Zhao. Coda: An end-to-end neural program decompiler. In Advances in Neural Information Processing Systems, pages 3703–3714, 2019. ",
+        "bbox": [
+            176,
+            693,
+            825,
+            736
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Daya Guo, Shuo Ren, Shuai Lu, Zhangyin Feng, Duyu Tang, LIU Shujie, Long Zhou, Nan Duan, Alexey Svyatkovskiy, Shengyu Fu, et al. Graphcodebert: Pre-training code representations with data flow. In International Conference on Learning Representations, 2020. ",
+        "bbox": [
+            173,
+            742,
+            826,
+            786
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Harry D. Huskey, M. H. Halstead, and R. McArthur. NELIAC — dialect of ALGOL. Commun. ACM, 3(8):463–468, aug 1960. ISSN 0001-0782. doi: 10.1145/367368.367373. URL https: //doi.org/10.1145/367368.367373. ",
+        "bbox": [
+            173,
+            794,
+            826,
+            837
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "S. C. Johnson. A tour through the portable C compiler. In Unix Programmer’s Manual, 7th Edition, 2B, Section 33, 1979. ",
+        "bbox": [
+            171,
+            844,
+            823,
+            873
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Aditya Kanade, Petros Maniatis, Gogul Balakrishnan, and Kensen Shi. Learning and evaluating contextual embedding of source code. In International Conference on Machine Learning, pages 5110–5121. PMLR, 2020. ",
+        "bbox": [
+            176,
+            882,
+            825,
+            924
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Omer Katz, Yuval Olshaker, Yoav Goldberg, and Eran Yahav. Towards neural decompilation. arXiv preprint arXiv:1905.08325, 2019. ",
+        "bbox": [
+            173,
+            103,
+            825,
+            132
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Diederik Kingma and Jimmy Ba. Adam: A method for stochastic optimization. ICLR, 2015. ",
+        "bbox": [
+            174,
+            140,
+            784,
+            157
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Jakub Kˇroustek, Peter Matula, and P Zemek. RetDec: An open-source machine-code decompiler, 2017. URL https://github.com/avast/retdec. ",
+        "bbox": [
+            169,
+            165,
+            825,
+            194
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Sumith Kulal, Panupong Pasupat, Kartik Chandra, Mina Lee, Oded Padon, Alex Aiken, and Percy S Liang. Spoc: Search-based pseudocode to code. Advances in Neural Information Processing Systems, 32:11906–11917, 2019. ",
+        "bbox": [
+            178,
+            203,
+            825,
+            246
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Marie-Anne Lachaux, Baptiste Roziere, Marc Szafraniec, and Guillaume Lample. DOBF: A deobfuscation pre-training objective for programming languages. arXiv preprint arXiv:2102.07492, 2021. ",
+        "bbox": [
+            174,
+            255,
+            825,
+            297
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Guillaume Lample and Alexis Conneau. Cross-lingual language model pretraining. Advances in Neural Information Processing Systems, 32:7059–7069, 2019. ",
+        "bbox": [
+            174,
+            306,
+            823,
+            335
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Guillaume Lample, Alexis Conneau, Ludovic Denoyer, and Marc’Aurelio Ranzato. Unsupervised machine translation using monolingual corpora only. ICLR, 2018a. ",
+        "bbox": [
+            174,
+            344,
+            821,
+            373
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Guillaume Lample, Myle Ott, Alexis Conneau, Ludovic Denoyer, and Marc’Aurelio Ranzato. Phrase based & neural unsupervised machine translation. In EMNLP, 2018b. ",
+        "bbox": [
+            173,
+            382,
+            823,
+            411
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Chris Lattner and Vikram Adve. Llvm: A compilation framework for lifelong program analysis & transformation. In International Symposium on Code Generation and Optimization, 2004. CGO 2004., pages 75–86. IEEE, 2004. ",
+        "bbox": [
+            174,
+            420,
+            825,
+            462
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Ruigang Liang, Ying Cao, Peiwei Hu, and Kai Chen. Neutron: an attention-based neural decompiler. Cybersecurity, 4(1):1–13, 2021a. ",
+        "bbox": [
+            173,
+            470,
+            823,
+            501
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Ruigang Liang, Ying Cao, Peiwei Hu, Jinwen He, and Kai Chen. Semantics-recovering decompilation through neural machine translation. arXiv preprint arXiv:2112.15491, 2021b. ",
+        "bbox": [
+            173,
+            508,
+            823,
+            539
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Yinhan Liu, Myle Ott, Naman Goyal, Jingfei Du, Mandar Joshi, Danqi Chen, Omer Levy, Mike Lewis, Luke Zettlemoyer, and Veselin Stoyanov. RoBERTa: A robustly optimized BERT pretraining approach. arXiv preprint arXiv:1907.11692, 2019. ",
+        "bbox": [
+            174,
+            546,
+            826,
+            590
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Nicholas D Matsakis and Felix S Klock II. The Rust language. In ACM SIGAda Ada Letters, volume 34, pages 103–104. ACM, 2014. ",
+        "bbox": [
+            173,
+            598,
+            825,
+            628
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Jason Merrill. GENERIC and GIMPLE: A new tree representation for entire functions. In in Proc. GCC Developers Summit, 2003, pages 171–180, 2003. ",
+        "bbox": [
+            173,
+            637,
+            825,
+            666
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Anh Tuan Nguyen, Tung Thanh Nguyen, and Tien N Nguyen. Lexical statistical machine translation for language migration. In Proceedings of the 2013 9th Joint Meeting on Foundations of Software Engineering, pages 651–654, 2013. ",
+        "bbox": [
+            174,
+            674,
+            825,
+            718
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Ruchir Puri, David S. Kung, Geert Janssen, Wei Zhang, Giacomo Domeniconi, Vladimir Zolotov, Julian Dolby, Jie Chen, Mihir R. Choudhury, Lindsey Decker, Veronika Thost, Luca Buratti, Saurabh Pujar, and Ulrich Finkler. Project CodeNet: A large-scale AI for code dataset for learning a diversity of coding tasks. CoRR, abs/2105.12655, 2021. URL https://arxiv.org/abs/ 2105.12655. ",
+        "bbox": [
+            173,
+            726,
+            826,
+            796
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "D.M. Ritchie. A Tour Through the UNIX C Compiler. 1979. URL https://books.google. com/books?id ${ . } = { }$ 5UvEGwAACAAJ. ",
+        "bbox": [
+            171,
+            805,
+            826,
+            834
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Baptiste Roziere, Marie-Anne Lachaux, Lowik Chanussot, and Guillaume Lample. Unsupervised translation of programming languages. Advances in Neural Information Processing Systems, 33, 2020. ",
+        "bbox": [
+            176,
+            843,
+            823,
+            886
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Baptiste Roziere, Jie M Zhang, Francois Charton, Mark Harman, Gabriel Synnaeve, and Guillaume Lample. Leveraging automated unit tests for unsupervised code translation. ICLR, 2022. ",
+        "bbox": [
+            176,
+            895,
+            821,
+            924
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Rico Sennrich, Barry Haddow, and Alexandra Birch. Improving neural machine translation models with monolingual data. In Proceedings of the 54th Annual Meeting of the Association for Computational Linguistics, pages 86–96, 2015. ",
+        "bbox": [
+            178,
+            103,
+            823,
+            146
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Richard Stallman. Using and porting the GNU Compiler Collection. M.I.T. Artificial Intelligence Laboratory, 2001. ",
+        "bbox": [
+            173,
+            155,
+            823,
+            184
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "J. Strong, J. Wegstein, A. Tritter, J. Olsztyn, O. Mock, and T. Steel. The problem of programming communication with changing machines: A proposed solution. Commun. ACM, 1(8):12–18, aug 1958. ISSN 0001-0782. doi: 10.1145/368892.368915. URL https://doi.org/10.1145/ 368892.368915. ",
+        "bbox": [
+            173,
+            193,
+            823,
+            248
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Ilya Sutskever, Oriol Vinyals, and Quoc V Le. Sequence to sequence learning with neural networks In Advances in neural information processing systems, pages 3104–3112, 2014. ",
+        "bbox": [
+            173,
+            257,
+            820,
+            287
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Ashish Vaswani, Noam Shazeer, Niki Parmar, Jakob Uszkoreit, Llion Jones, Aidan N Gomez, Łukasz Kaiser, and Illia Polosukhin. Attention is all you need. In Advances in neural information processing systems, pages 5998–6008, 2017. ",
+        "bbox": [
+            176,
+            295,
+            825,
+            338
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Yue Wang, Weishi Wang, Shafiq Joty, and Steven CH Hoi. Codet5: Identifier-aware unified pretrained encoder-decoder models for code understanding and generation. In Proceedings of the 2021 Conference on Empirical Methods in Natural Language Processing, pages 8696–8708, 2021. ",
+        "bbox": [
+            174,
+            347,
+            826,
+            390
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Justin D Weisz, Michael Muller, Stephanie Houde, John Richards, Steven I Ross, Fernando Martinez, Mayank Agarwal, and Kartik Talamadupula. Perfection not required? human-ai partnerships in code translation. In 26th International Conference on Intelligent User Interfaces, pages 402–412, 2021. ",
+        "bbox": [
+            173,
+            398,
+            825,
+            455
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Justin D Weisz, Michael Muller, Steven I Ross, Fernando Martinez, Stephanie Houde, Mayank Agarwal, Kartik Talamadupula, and John T Richards. Better together? an evaluation of AIsupported code translation. In 27th International Conference on Intelligent User Interfaces, pages 369–391, 2022. ",
+        "bbox": [
+            173,
+            464,
+            825,
+            520
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "A FULL SCORES TABLE ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            102,
+            390,
+            118
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "table",
+        "img_path": "images/b563baa1009fda55bb5385051fe02084c106c1ce23b52e759d38b47fdf0ff149.jpg",
+        "table_caption": [
+            "Table 3: Results on unsupervised code translation. The metric shown is the computational accuracy for a single generation $( \\mathbf { C A @ 1 } )$ , measuring the translation correctness using unit tests. It is the full version of Table 2. The models were all trained with the same budget. As in Table 2, all these methods except for the IR pivot also use the three objectives defined in TransCoder: MLM, DAE and Back-Translation (BT). Although it is not the case for every language pair, TransCoder-IR, which uses the TLM, TAE, and MT objectives outperforms other methods on average. TransCoder-ST (Roziere et al., 2022) uses a parallel dataset generated with automated unit tests and outperforms other methods for $\\mathbf { C } + +  \\mathbf { J a v a }$ . Their method is orthogonal to ours, and we could also improve our performance with similar methods. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td colspan=\"6\">C++ →Go C++→Java C++→Rust Go →C++ Go →Java Go →Rust</td></tr><tr><td>Baseline TransCoder</td><td>57.7</td><td>63.3</td><td>18.2</td><td>56.1</td><td>46.9</td><td>23.3</td></tr><tr><td>TransCoder-ST</td><td>1</td><td>68.0</td><td>1</td><td>1</td><td>1</td><td>1</td></tr><tr><td>Pivot</td><td>16.1</td><td>22.0</td><td>14.0</td><td>30.5</td><td>26.5</td><td>2.7</td></tr><tr><td>TLM</td><td>61.8</td><td>62.5</td><td>18.2</td><td>57.6</td><td>56.4</td><td>22.2</td></tr><tr><td>TAE</td><td>57.7</td><td>62.5</td><td>21.7</td><td>63.0</td><td>54.7</td><td>23.8</td></tr><tr><td>TLM+TAE</td><td>58.2</td><td>63.3</td><td>19.2</td><td>55.2</td><td>57.0</td><td>22.8</td></tr><tr><td>MT</td><td>56.8</td><td>60.6</td><td>19.2</td><td>60.3</td><td>53.8</td><td>18.0</td></tr><tr><td>TLM+MT</td><td>58.6</td><td>58.5</td><td>19.7</td><td>57.3</td><td>54.1</td><td>23.8</td></tr><tr><td>TAE+MT</td><td>61.4</td><td>60.2</td><td>21.7</td><td>55.5</td><td>53.8</td><td>22.2</td></tr><tr><td>TLM+TAE+MT</td><td>55.9</td><td>62.9</td><td>24.8</td><td>61.8</td><td>55.7</td><td>22.2</td></tr><tr><td colspan=\"7\">Java →C++ Java→Go Java→Rust Rust →C++ Rust →Go Rust → Java</td></tr><tr><td>Baseline TransCoder</td><td>77.9</td><td>35.9</td><td>9.6</td><td>22.4</td><td>43.2</td><td>23.4</td></tr><tr><td>TransCoder-ST</td><td>84.6</td><td>1</td><td>1</td><td>-</td><td>1</td><td>1</td></tr><tr><td>Pivot</td><td>19.5</td><td>9.4</td><td>6.7</td><td>22.0</td><td>8.9</td><td>18.1</td></tr><tr><td>TLM</td><td>80.9</td><td>31.8</td><td>6.6</td><td>25.9</td><td>30.0</td><td>37.5</td></tr><tr><td>TAE</td><td>80.3</td><td>38.6</td><td>6.6</td><td>16.6</td><td>38.1</td><td>20.6</td></tr><tr><td>TLM+TAE</td><td>82.2</td><td>24.6</td><td>8.6</td><td>30.4</td><td>31.0</td><td>43.3</td></tr><tr><td>MT</td><td>76.2</td><td>50.9</td><td>12.6</td><td>16.6</td><td>39.1</td><td>21.3</td></tr><tr><td>TLM+MT</td><td>77.9</td><td>52.7</td><td>10.1</td><td>19.2</td><td>30.0</td><td>24.1</td></tr><tr><td>TAE+MT</td><td>77.5</td><td>33.6</td><td>6.1</td><td>30.0</td><td>36.6</td><td>33.7</td></tr><tr><td>TLM+TAE+MT</td><td>74.5</td><td>49.6</td><td>17.2</td><td>26.5</td><td>49.2</td><td>30.2</td></tr></table>",
+        "bbox": [
+            174,
+            251,
+            825,
+            584
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "B BEAM SIZE EVALUATION ",
+        "bbox": [
+            176,
+            102,
+            415,
+            117
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "table",
+        "img_path": "images/8a089c4b019fc78f435073466a50637f17be885f415a3fa5ffeb9da9e9c26ae0.jpg",
+        "table_caption": [
+            "Table 4: Results on unsupervised code translation with different beam sizes. The metric shown is still the computational accuracy for a single generation $( \\mathbf { C A @ 1 } )$ . BS N refers to beam search decoding with beam size N, and returning only the top element of the beam. Using beam search improves the average performance of every model. BS N means that the model is evaluated with beam size N. When the beam size is not given, we use greedy decoding. Surprisingly, beam size 5 outperforms beam size 10. Our method using intermediate representations still outperforms the baseline with beam size 5 and 10 in average. With the baseline, we obtain average $\\mathrm { C A @ 1 }$ scores of 45.3 with beam size 5 and 44.0 with beam size 10. Our method yields $\\mathrm { C A @ 1 }$ scores of 47.8 with beam size 5 and 46.8 with beam size 10. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td></td><td>C++ →Go</td><td>C++→→Java</td><td>C++→Rust</td><td>Go →C++</td><td>Go→ Java</td><td>Go →Rust</td></tr><tr><td>Baseline TransCoder</td><td>57.7</td><td>63.3</td><td>18.2</td><td>56.1</td><td>46.9</td><td>23.3</td></tr><tr><td>Baseline TransCoder (BS 5)</td><td>65.5</td><td>67.6</td><td>28.3</td><td>52.1</td><td>59.3</td><td>24.3</td></tr><tr><td>Baseline TransCoder (BS 10)</td><td>65.0</td><td>68.7</td><td>27.8</td><td>52.1</td><td>57.0</td><td>23.8</td></tr><tr><td>TLM+ TAE+ MT</td><td>55.9</td><td>62.9</td><td>24.8</td><td>61.8</td><td>55.7</td><td>22.2</td></tr><tr><td>TLM + TAE + MT (BS 5)</td><td>61.4</td><td>66.6</td><td>30.8</td><td>57.3</td><td>59.0</td><td>30.2</td></tr><tr><td>TLM + TAE + MT (BS 10)</td><td>61.4</td><td>67.4</td><td>29.3</td><td>56.4</td><td>59.0</td><td>29.1</td></tr><tr><td></td><td>Java → C++</td><td>Java →Go</td><td>Java→Rust</td><td>Rust -→ C++</td><td>Rust →Go</td><td>Rust → Java</td></tr><tr><td>Baseline TransCoder</td><td>77.9</td><td>35.9</td><td>9.6</td><td>22.4</td><td>43.2</td><td>23.4</td></tr><tr><td>Baseline TransCoder (BS 5)</td><td>82.9</td><td>45.5</td><td>10.1</td><td>25.2</td><td>54.8</td><td>27.5</td></tr><tr><td>Baseline TransCoder (BS 10)</td><td>80.9</td><td>46.4</td><td>7.6</td><td>23.6</td><td>51.8</td><td>23.0</td></tr><tr><td>TLM+ TAE + MT</td><td>74.5</td><td>49.6</td><td>17.2</td><td>26.5</td><td>49.2</td><td>30.2</td></tr><tr><td>TLM + TAE + MT (BS 5)</td><td>76.4</td><td>57.7</td><td>20.2</td><td>26.8</td><td>52.3</td><td>34.7</td></tr><tr><td>TLM + TAE + MT (BS 10)</td><td>77.7</td><td>57.3</td><td>18.2</td><td>26.2</td><td>51.8</td><td>28.2</td></tr></table>",
+        "bbox": [
+            142,
+            256,
+            857,
+            484
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "C PIVOT METHOD DETAILS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            522,
+            413,
+            539
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "As mentioned in Section 3.3, IR generated from different languages contain slight variations and can be seen as dialects of the same language. In practice, these variations prevent us from simply using our best decompilation model to generate source code in another language than the one used to generate the IR. Although we prompt the model to generate code in the target language with language embeddings, it learns to focus on the particularities of each dialect and ignores the language embeddings. Therefore, it generates code in the source language, which results in a computational accuracy score of 0 for translation. ",
+        "bbox": [
+            173,
+            554,
+            825,
+            651
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "One way to solve this issue is to use one decoder per target language. Then, the model is able to generate code in the target language. However, this method still performs poorly due to the small differences between the IR dialects. The method we tested that performed the best, and which is reported in Table 2, uses back-translation to make the model to translate from any IR dialect to any language. This model is also grounded by supervised translation steps making it generate IR from code and code from IR. In practice, we create new language embeddings for every IR dialect (i.e. $\\mathrm { I R - C + + }$ , IR-Go, IR-Java, IR-Rust) for depending on the source language. At training time, we make the model generate noisy translations in the IR-Go, IR-Java and IR-Rust “languages” for every $\\mathrm { C } { + } { + }$ sequence, and train it to re-generate the $\\mathrm { C } { + } { + }$ sequence from the noisy translation. To allow the model to generate good training data for $\\scriptstyle { \\mathrm { I R - X } } \\to { \\mathbf { C } } + +$ , we also generate noisy translations in Go, Java, and Rust for every IR generated from $\\mathrm { C } { + } { + }$ in our dataset and train the model to retrieve the IR. Using our parallel code//IR dataset, we also train the model to translate between $\\mathrm { C } { + + }$ and IR- $C + +$ sequences. We do the same for every language and alternate between them. ",
+        "bbox": [
+            174,
+            659,
+            825,
+            839
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "table",
+        "img_path": "images/85abb3da4270dbbb992fa1474193e83f36d82a2bb3066c4dc5d5888fbc1bdd8a.jpg",
+        "table_caption": [
+            "Table 5: Performance of LLVM IRs Decompilation. This table shows the computational accuracy $( \\mathbf { C A @ 1 } )$ of our neural decompiler and the RetDec $\\mathrm { C } { + + }$ rule-based decompiler. Our neural decompiler outperforms RedDec on $\\mathrm { C } { + + }$ and is more broadly applicable. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td></td><td>C++</td><td>Go</td><td>Java</td><td>Rust</td></tr><tr><td>Baseline - RetDec</td><td>68.8</td><td>一</td><td></td><td></td></tr><tr><td>Separate Decoders</td><td>52.7</td><td>42.2</td><td>60.1</td><td>19.5</td></tr><tr><td>Shared Decoder</td><td>77.9</td><td>70.1</td><td>82.2</td><td>61.0</td></tr></table>",
+        "bbox": [
+            318,
+            260,
+            676,
+            333
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "image",
+        "img_path": "images/15618a02a294a39479720341a03971180cec9ec86a0af942df47c057e0cd1731.jpg",
+        "image_caption": [
+            "Figure 5: Code simplification examples with Decompilation / Pivot. Since the LLVM IR is optimized, functions that are semantically equivalent after optimization map to the same IR. In the first example, it allows to remove useless code by decompiling the generated LLVM IR. In the second example, the simplification allows to find a bug: the $\\&$ operator has precedence over $= =$ in $\\mathrm { C } { + } { + }$ , causing this function to always evaluate to false. It is not obvious when looking at the input code, but becomes clear with the IR and simplified $\\mathrm { C } { + + }$ code. In the third example, it replaces a bitwise operation by a more straightforward multiplication. In all examples, we can run the compiler again to check that the IR of the decompiled code is exactly the same as that of the input. It guarantees that the input and simplified code have the same semantics. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            179,
+            569,
+            844,
+            763
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "image",
+        "img_path": "images/2e2e4baefe505e9f3ba439e931185acd8ec2f427a6d900c14eff2ed9317ba805.jpg",
+        "image_caption": [
+            "Figure 6: Java to Rust translation examples. In the first example, the IR allows the model to understand that the Java bitwise complement operator \\~ should be replaced by ! in Rust. Also, it allows the model to translate the type correctly in both examples and avoids unnecessary casts. The IR allows the model to generate the right types (e.g. i32 instead of $\\mathtt { u } 3 2$ when translating int) and operator (e.g. ! instead of $\\tilde { }$ in Rust). ",
+            "Figure 7: Rust to Go translation example. This function performs binary search to find the insertion index for an element in an ordered vector. The model translates types, function definitions, variable definitions, and while loops correctly. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            178,
+            99,
+            826,
+            224
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "text",
+        "text": "// Rust   \npub fn binary_search(nums: Vec<i32>, target: i32,   \n) -> i32 { if nums.is_empty() { return 0 } if target $<$ nums[0] { return 0 } let mut left $\\qquad = \\quad 0$ ; let mut right $=$ nums.len() - 1; while left $< =$ right { let mid $=$ left $^ +$ (right - left) / 2; if nums[mid] $= =$ target { return mid as i32; } else if nums[mid] $<$ target { left $=$ mid $^ + 1$ ; } else { right $=$ mid - 1; } } return left as i32;   \n}   \n// Go   \nfunc binarySearch(nums[] int, target int) int { if len(nums) $\\scriptstyle = = 0$ { return 0 } if target $<$ nums[0] { return 0 } left: $\\qquad = \\quad 0$ right: $=$ len(nums) - 1 for left $< =$ right { mid: $=$ left $^ +$ (right - left) / 2 if nums[mid] $= =$ target { return mid } else if nums[mid] $<$ target { left $=$ mid $^ + 1$ else { right $=$ mid - 1 } } return left   \n}   \n// Go   \nfunc pairsInSortedRotated(arr[] int, n int, x int)   \nint { var i int for $\\mathrm { ~ \\\\\\small ~ \\frac ~ { ~ i ~ } ~ } = \\mathrm { ~ \\small ~ 0 ~ }$ ; $\\mathrm { ~ i ~ } ~ < \\mathrm { ~ n ~ } ~ - ~ 1$ ; i++{ if arr[i] $\\mathrm { ~ \\gamma ~ > ~ } \\mathrm { a r r } [ \\mathrm { ~ i ~ \\Gamma ~ + ~ }$ 1] { break } } var l int $= ( \\frac { \\mathrm { ~ i ~ \\hbar ~ } } { 1 } + \\mathrm { ~ 1 ~ } ) \\frac { \\circ } { \\circ } \\mathrm { ~ n ~ }$ var r int $\\qquad = \\quad \\\\\\\\\\\\\\\\\\perp$ var cnt int $\\qquad = \\quad 0$ for l != r { if arr[l] $^ +$ arr[r] == x { cnt++ $\\mathbf { i } \\notin \\mathbb { R } ^ { } 2 \\ : \\equiv \\ : \\ : ( \\mathbf { r } _ { } \\mathrm { ~ \\ j ~ - ~ \\frac ~ { ~ 1 ~ } ~ { ~ 1 ~ } ~ + ~ \\eta ~ } _ { } \\mathtt { n } ) \\notin \\mathbb { R } \\ : \\ : \\{ \\ :$ { return cnt } l = (l + 1) % n r = (r - 1 + n) % n } else if arr[l] + arr[r] < x { $1 = ( 1 + 1 ) \\frac { 2 } { 0 } \\pi$ } else { r = (n + r - 1) % n } } return cnt   \n}   \n// C++   \nint pairsInSortedRotated(int arr[], int n, int x)   \n{ int i; for $( \\mathrm { ~ i ~ ~ } \\ = \\ \\mathrm { ~ 0 ~ } ; \\ \\mathrm { ~ i ~ } \\ < \\ \\mathrm { ~ n ~ ~ - ~ } \\ \\mathrm { ~ 1 ~ } ; \\ \\mathrm { ~ i ~ } \\ + + )$ { if (arr $[ \\pm ] >$ arr $[  { \\mathrm { ~ i ~ \\phi ~ } } +  { \\mathrm { ~ 1 ~ } } ]$ ) break; } int $1 = ( \\dot { \\bf ~ 1 } + \\dot { \\bf ~ 1 } ) \\frac { \\ d s } { \\ d s } \\mathrm {  ~ n ~ } ;$ int $\\mathrm { ~ \\bf ~ r ~ } = \\mathrm { ~ \\bf ~ i ~ } ;$ ; int cnt $\\qquad = \\quad 0$ ; while $( \\underline { { { 1 } } } \\quad : = \\quad \\underline { { { { \\bf r } } } } )$ ) { if (arr [l] + arr $[ { \\boldsymbol { \\textbf { r } } } ] \\ \\mathbf { \\Sigma } = = { \\boldsymbol { \\textbf { x } } } )$ ) { cnt $^ { + + }$ ; $\\begin{array} { c c c c c c c c c } { { \\lfloor \\pm } } & { { ( 1 } } & { { = = } } & { { ( \\tt { r } } } & { { - } } & { { 1 } } & { { + } } & { { \\tt { n } ) } } & { { \\tt { \\& } } } & { { \\tt { n } ) } } & { { } } & { { } } \\end{array}$ return cnt; $1 = ( 1 + 1 ) \\frac { 2 } { 9 } \\pi ;$ $\\begin{array} { r c c c c l } { \\texttt { r } = } & { ( \\texttt { r } - } & { \\texttt { l } + } & { \\texttt { n } ) } & { \\frac { \\circ } { \\circ } } & { \\mathtt { n } } & { ; } \\end{array}$ } else $\\begin{array} { r } { \\mathrm { i } \\texttt { i f } \\left( \\mathrm { a r r } \\left[ \\mathrm { \\texttt { l } } \\right] \\ + \\ \\mathrm { a r r } \\left[ \\mathrm { \\texttt { r } } \\right] \\ < \\ \\textbf { x } \\right) \\ \\mathrm { ~ \\texttt { l } ~ = ~ \\textbf { ( } \\mathrm { 1 ~ \\texttt { + } ~ 1 ~ } ) ~ \\ \\frac { \\circ } { \\circ } ~ \\ n ~ } ; } \\end{array}$ else $\\texttt { r } = \\texttt { ( n + r - l ) } \\texttt { \\frac { e } { s } n }$ ; } return cnt; ",
+        "bbox": [
+            181,
+            527,
+            498,
+            779
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            506,
+            527,
+            843,
+            768
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            183,
+            354,
+            444,
+            669
+        ],
+        "page_idx": 16
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            508,
+            354,
+            867,
+            598
+        ],
+        "page_idx": 16
+    },
+    {
+        "type": "image",
+        "img_path": "images/c29b3950a88fe4f248abeed7fc389851c6a8803d4218b21d151f93ee7b37bb9f.jpg",
+        "image_caption": [
+            "Figure 9: Rust to Go translation example. We call S1 the string n1 repeated s1 times and S2 the string n2 repeated $_ { \\textrm { S 2 } }$ times. This function finds the largest number of repetitions of S2 appearing in any subset of S1. The model translates the types correctly, understands that casting vector indices to unsigned int (i.e. with as usize) is not required in Go, and correctly translates other Rust constructs to Go. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            181,
+            239,
+            821,
+            765
+        ],
+        "page_idx": 17
+    },
+    {
+        "type": "text",
+        "text": "F DATASET SIZE DETAILS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            102,
+            401,
+            117
+        ],
+        "page_idx": 18
+    },
+    {
+        "type": "table",
+        "img_path": "images/16ac3946b11f5a0903e8070d8685b1ab81c68e24e79e6bfa427f5e6b58a1b951.jpg",
+        "table_caption": [
+            "Table 6: Dataset details: number of tokens in our function-level dataset. This dataset contains only functions defined outside of classes and static functions. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td></td><td>Numberof tokens</td><td>Number of sentences</td></tr><tr><td>Monolingual data</td><td></td><td></td></tr><tr><td>C++</td><td>2.33B</td><td>6.6M</td></tr><tr><td>Go</td><td>1.9B</td><td>9.4M</td></tr><tr><td>Java</td><td>1.5B</td><td>7.8M</td></tr><tr><td>Rust</td><td>130.0M</td><td>576.3K</td></tr><tr><td>Code /IR Parallel Data</td><td></td><td></td></tr><tr><td>C++-IR</td><td>946.7M</td><td>343.9K</td></tr><tr><td>Go-IR</td><td>971.8M</td><td>384.4K</td></tr><tr><td>Java-IR</td><td>1.7B</td><td>2.2M</td></tr><tr><td>Rust-IR</td><td>77.7M</td><td>19.4K</td></tr></table>",
+        "bbox": [
+            253,
+            194,
+            735,
+            371
+        ],
+        "page_idx": 18
+    },
+    {
+        "type": "text",
+        "text": "G ADDITIONAL ABLATIONS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            410,
+            419,
+            425
+        ],
+        "page_idx": 18
+    },
+    {
+        "type": "text",
+        "text": "Training on IRs with different objectives. We perform some additional ablations to determine whether our performance improvements come from training on IRs or from our TLM, TAE and MT objectives. When training a model with the three objectives of TransCoder (i.e. MLM, DAE and BT) and considering the IR as an extra language, we obtain an average computational accuracy of 37.4, which is lower than that of our baseline TransCoder. As the structure of the IR is not similar to that of any of our source languages, there is not much to gain from adding the IR as an extra language. Moreover, the model is wasting some time to compute the AE and BT objectives for the IR which can be better spent on the source languages. It confirms that our objectives are required to map IRs and their corresponding source code to similar representations in embedding space. ",
+        "bbox": [
+            173,
+            446,
+            826,
+            571
+        ],
+        "page_idx": 18
+    },
+    {
+        "type": "text",
+        "text": "Language ablation: no Java. As Rust and Go are more similar to Java than to $\\mathrm { C } { + + }$ , we also train a baseline model on $\\mathrm { C } { + } { + }$ , Go and Rust only to evaluate whether including Java hurts the translation performance. We observed similar performance for $\\mathbf { C } \\mathbf { + } \\mathbf { + }  \\mathbf { G } \\mathbf { o }$ . However, we also observe a clear decrease in performance in the very low data regime (i.e. when translating to or from Rust). The computational accuracy for Rust $ \\mathbf { C } + +$ goes down from $2 2 . 4 \\%$ to $2 0 . 1 \\%$ and it goes down from $4 3 . 1 \\bar { 5 } \\%$ to $3 2 . 5 \\%$ for Rust $ \\mathrm { G o }$ . ",
+        "bbox": [
+            173,
+            597,
+            825,
+            681
+        ],
+        "page_idx": 18
+    },
+    {
+        "type": "text",
+        "text": "H WORD EMBEDDINGS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            712,
+            382,
+            728
+        ],
+        "page_idx": 18
+    },
+    {
+        "type": "text",
+        "text": "We notice that our method generates improved word embeddings. It is visible when looking at the cosine similarity for embeddings of rust types and their equivalents in $\\mathrm { C } { + } { + }$ . For instance, Figure 10 shows that the embedding of $\\hphantom { 0 } \\mathrm { { 3 2 } }$ from our model leveraging LLVM IRs is most similar to uint32 (with a cosine similarity of 0.4869). uint, which is also a correct translation, comes in $1 1 ^ { t h }$ position with a cosine similarity (0.3716). In contrast, $\\hphantom { 0 } \\mathrm { { 3 2 } }$ has a similarity of only 0.2828 with int. This token, which would be an incorrect translation, comes only in $2 9 ^ { t h }$ position. ",
+        "bbox": [
+            173,
+            750,
+            825,
+            833
+        ],
+        "page_idx": 18
+    },
+    {
+        "type": "text",
+        "text": "The baseline model, which does not use the IR, learns similar representations for rust types since they appear in similar contexts. Hence, its embedding of $\\hphantom { 0 } \\hphantom { 0 } \\hphantom { 0 } \\hphantom { 0 } \\hphantom { 0 } \\hphantom { 0 } \\hphantom { 0 } \\hphantom { 0 } \\hphantom { 0 } \\hphantom { 0 } \\hphantom { 0 } \\hphantom { 0 } \\hphantom { 0 } \\hphantom { 0 } \\hphantom { 0 } \\hphantom { 0 } \\hphantom { 0 } \\hphantom { 0 } \\hphantom { 0 } \\hphantom { 0 } \\hphantom { 0 } \\hphantom { 0 } \\hphantom { 0 } \\hphantom { 0 } \\hphantom { 0 } \\hphantom { 0 } \\hphantom { 0 } \\hphantom { 0 } \\hphantom { 0 } \\hphantom { 0 } \\hphantom { 0 } \\hphantom { 0 } \\hphantom { 0 } \\hphantom { 0 } \\hphantom { 0 } \\hphantom { 0 } \\hphantom { 0 } \\hphantom { 0 } \\hphantom { 0 } \\hphantom { 0 } \\hphantom { 0 } \\hphantom { 0 } \\hphantom { 0 } \\hphantom { 0 } \\hphantom { 0 } \\hphantom \\hphantom { 0 } \\hphantom { 0 } \\hphantom \\hphantom { 0 } \\hphantom \\hphantom { 0 } \\hphantom \\hphantom { 0 } \\hphantom \\hphantom \\hphantom { 0 } \\hphantom \\hphantom \\hphantom \\hphantom { 0 } \\hphantom \\hphantom \\hphantom \\hphantom \\hphantom \\end \\hphantom \\hphantom \\hphantom \\hphantom  \\hphantom \\hphantom \\hphantom \\hphantom \\hphantom \\hphantom \\hphantom \\hphantom \\hphantom \\hphantom \\hphantom \\hphantom \\end f$ is most similar to other rust types tokens such as $\\mathtt { \\small u 6 4 }$ , i32 or u16. uint32 comes only in fourth position with a cosine similarity of 0.4218. Moreover, uint and int have almost the same cosine similarities with $\\hphantom { 0 } \\mathrm { { 3 2 } }$ with the baseline model. It causes the model to often confuse unsigned and signed integer types, and to incorrectly translate u32 into int instead of uint. ",
+        "bbox": [
+            174,
+            840,
+            825,
+            922
+        ],
+        "page_idx": 18
+    },
+    {
+        "type": "image",
+        "img_path": "images/1141077b8224742da55bf418f82a47d1be7099a3d390c36e36affeca54543599.jpg",
+        "image_caption": [
+            "Figure 10: Token similarities. Rank and token similarity with $\\mathtt { u } 3 2$ for our model (right) and the baseline model (left). Our model generates embeddings that better capture token semantics. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            174,
+            97,
+            797,
+            239
+        ],
+        "page_idx": 19
+    },
+    {
+        "type": "text",
+        "text": "I ANALYSIS OF ERROR TYPES ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            304,
+            433,
+            320
+        ],
+        "page_idx": 19
+    },
+    {
+        "type": "table",
+        "img_path": "images/21633cf36021cbd4c383da38346cc2c5ad48824fa5a15dfa2d62f62c7491fbc3.jpg",
+        "table_caption": [
+            "Table 7: Rust error types. To validate our intuition on the usefulness of the IR representations to decrease the number of type-related errors (see Fig.1 or Fig.6), we perform an in-depth analysis of the types of errors encountered for the Java Rust direction. Here we count the total number of errors (there can be several for a single translation). We notice that the number of type-related errors (excluding E0433, E0425 and Others) decreases by $24 \\%$ (609 vs. 463) and the number of mismatched types decreases by $49 \\%$ . "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Error Code</td><td>Error Description</td><td>Baseline (Transcoder)</td><td>TLM + TAE + MT</td></tr><tr><td>E0308</td><td>Mismatched Type</td><td>414</td><td>210</td></tr><tr><td>E0412</td><td>Type Does Not Exist</td><td>15</td><td>3</td></tr><tr><td>E0277</td><td>Type has Missing Trait</td><td>180</td><td>250</td></tr><tr><td>E0425</td><td>Undefined Variable</td><td>18</td><td>27</td></tr><tr><td>E0433</td><td>Use of Undefined Crate,Module or Type</td><td>15</td><td>32</td></tr><tr><td>丨</td><td>Others</td><td>28</td><td>33</td></tr><tr><td>TOTAL</td><td></td><td>670</td><td>555</td></tr></table>",
+        "bbox": [
+            173,
+            421,
+            861,
+            556
+        ],
+        "page_idx": 19
+    }
+]

parse/dev/XomEU3eNeSQ/XomEU3eNeSQ_layout.pdf

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:5660baaa210cacb60ef955853384587edb376567af87dae9e117e752ae9a4180
+size 1193009

parse/dev/XomEU3eNeSQ/XomEU3eNeSQ_origin.pdf

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:7d9d0026580c9caad8960b65eb8f25e7bf08630a1768276d5e80867bc1a0b4e6
+size 928383

parse/dev/XomEU3eNeSQ/XomEU3eNeSQ_span.pdf

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:e6acf0ac9406c6a5a377504bcc19d8089b1387a2a03501a55346865f208bd562
+size 1200740

parse/dev/XrGEkCOREX2/XrGEkCOREX2.md

@@ -0,0 +1,250 @@
+# MEMO: Test Time Robustness via Adaptation and Augmentation
+
+Marvin Zhang1, Sergey Levine1, Chelsea Finn2 1UC Berkeley 2Stanford University
+
+# Abstract
+
+While deep neural networks can attain good accuracy on in-distribution test points, many applications require robustness even in the face of unexpected perturbations in the input, changes in the domain, or other sources of distribution shift. We study the problem of test time robustification, i.e., using the test input to improve model robustness. Recent prior works have proposed methods for test time adaptation, however, they each introduce additional assumptions, such as access to multiple test points, that prevent widespread adoption. In this work, we aim to study and devise methods that make no assumptions about the model training process and are broadly applicable at test time. We propose a simple approach that can be used in any test setting where the model is probabilistic and adaptable: when presented with a test example, perform different data augmentations on the data point, and then adapt (all of) the model parameters by minimizing the entropy of the model’s average, or marginal, output distribution across the augmentations. Intuitively, this objective encourages the model to make the same prediction across different augmentations, thus enforcing the invariances encoded in these augmentations, while also maintaining confidence in its predictions. In our experiments, we evaluate two baseline ResNet models, two robust ResNet-50 models, and a robust vision transformer model, and we demonstrate that this approach achieves accuracy gains of $1 \%$ over standard model evaluation and also generally outperforms prior augmentation and adaptation strategies. For the setting in which only one test point is available, we achieve state-of-the-art results on the ImageNet-C, ImageNet-R, and, among ResNet-50 models, ImageNet-A distribution shift benchmarks.
+
+# 1 Introduction
+
+Deep neural network models have achieved excellent performance on many machine learning problems, such as image classification, but are often brittle and susceptible to issues stemming from distribution shift. For example, deep image classifiers may degrade precipitously in accuracy when encountering input perturbations, such as noise or changes in lighting $[ \hat { \left| 1 2 \right| } ]$ or domain shifts which occur naturally in real world applications $\mathbb { \left| \mathbb { Z } \right\| }$ . Therefore, robustification of deep models against these test shifts is an important and active area of study.
+
+Most prior works in this area have focused on techniques for training time robustification, including utilizing larger models and datasets $\pmb { \mathbb { B 4 } }$ , various forms of adversarial training $\mathbb { B 9 } \mathbb { H 8 }$ , and aggressive data augmentation [51, 13, 24, 14]. Employing these techniques requires modifying the training process, which may not be feasible if, e.g., it involves heavy computation or non public data. Furthermore, these techniques do not rely on any information about the test points that the model must predict on, even though these test points may provide significant information for improving model robustness. Recently, several works have proposed methods for improving accuracy via adaptation after seeing the test data, typically by updating a subset of the model’s weights [44, 45, 18], normalization statistics [40], or both [46, 52]. Though effective at handling test shifts, these methods sometimes still require specialized training procedures, and they typically rely on extracting information via batches or even entire sets of test inputs, thus introducing additional assumptions.
+
+![](images/695fdc8d76523d7ae12f1252c94b960f4f9aeeee940045c10e43759d62a658f6.jpg)  
+Figure 1: Left: at test time, as detailed in $\mathsf { \overline { { S e c t i o n 3 } } } ,$ we have a single test input $\mathbf { x }$ , a set of data augmentation functions $\{ a _ { 1 } , \dotsc , a _ { M } \}$ , and a trained model that outputs a probabilistic predictive distribution and has adaptable parameters $\theta$ . We perform different augmentations on $\mathbf { x }$ and pass these augmented inputs to the model in order to estimate the marginal output distribution averaged over augmentations. Right: we perform a gradient update on the model to minimize the entropy of this marginal distribution, thus encouraging the model predictions to be invariant across different augmentations while maintaining confident predictions. The final prediction is then made on the original data point, i.e., the predictive distribution in the top right of the schematic.
+
+In this work, we focus on methods for test time robustness, in which the specific test input may be leveraged in order to improve the model’s prediction on that point. We are interested in studying and devising methods for improving model robustness that are “plug and play”, i.e., they can be readily used with a wide variety of pretrained models and test settings. We also want methods that synergize with other robustification techniques, in order to achieve greater performance than using either in isolation. With these goals in mind, we devise a novel test time robustness method based on adaptation and augmentation. As illustrated in $\mathbb { F i g u r e 1 } ,$ when presented with a test point, we adapt the model by augmenting the test point in different ways while encouraging the model to make consistent predictions, thus respecting the invariances encoded in the data augmentations. We further encourage the model to make confident predictions, thus arriving at the proposed method: minimize the marginal entropy of the model’s predictions across the augmented versions of the test point.
+
+We refer to the proposed method as marginal entropy minimization with one test point (MEMO), and this is the primary contribution of our work. MEMO makes direct use of pretrained models without any assumptions about their particular training procedure or architecture, while requiring only a single test input for adaptation. In Section 4, we demonstrate empirically that MEMO consistently improves the performance of ResNet [11] and vision transformer $\mathbb { \overline { { | \overline { { \mathbb { Z } } | } } } }$ models on several challenging ImageNet distribution shift benchmarks, achieving several new state-of-the-art results for these models in the setting in which only one test point is available. MEMO consistently outperforms non adaptive marginal distribution predictions (between $1 - 1 0 \%$ improvement) on the ImageNet-C [12] and ImageNet-R [14] test sets, indicating that adaptation plays a crucial role in improving predictive accuracy. MEMO encourages both invariance across augmentations and confident predictions, and an ablation study in Section 4 shows that both components are important for maximal performance gains. Also, MEMO is, to the best of our knowledge, the first adaptation method to improve performance (by $1 \%$ over standard model evaluation) on the ImageNet-A test set $\mathbb { \lVert 1 5 \rVert }$ .
+
+# 2 Related work
+
+Distribution shift has been studied under a number of frameworks $\pmb { \mathbb { B } } 6 \|$ , including domain adaptation [41, 6, 47], domain generalization [5, 32, 9], and distributionally robust optimization [4, 16, 39]. These frameworks typically leverage additional training or test assumptions in order to make the distribution shift problem more tractable. Largely separate from these frameworks, various empirical methods have also been proposed for dealing with shift, such as increasing the model and training dataset size or using heavy training augmentations [34, 51, 14]. The focus of this work is complementary to these efforts: MEMO is applicable to a wide range of pretrained models, including those trained via robustness methods, and can achieve further performance gains via test time adaptation.
+
+Prior test time adaptation methods generally either make significant training or test time assumptions. Some methods update the model using batches or even entire datasets of test inputs, such as by computing batch normalization (BN) statistics on the test set [25, 19, 33, 40], computing class prototypes $\mathbb { \lVert \rVert }$ , or minimizing the (conditional) entropy of model predictions across a batch of test data $\lVert \overline { { 4 6 } } \rVert$ . The latter approach is closely related to MEMO. The differences are that MEMO minimizes marginal entropy using single test points and data augmentation and adapts all of the model parameters rather than just those associated with normalization layers, thus not requiring multiple test points or specific model architectures. Other test time adaptation methods can be applied to single test points but require specific training procedures or models [44, 17, 40, 1, 3]. Test time training (TTT) $\underline { { \lVert \varPsi \ 4 \rVert } }$ requires a specialized model with a rotation prediction head and a different procedure for training this model. Schneider et al. [40] show that BN adaptation can be effective even with only one test point. As we discuss in Section 3, MEMO synergizes well with this technique of “single point” BN adaptation. Mao et al. [29] propose a test time adaptation method based on input perturbations for robustness to adversarial attacks. Concurrently with our work, Sivaprasad and Fleuret $\mathbb { \lVert \rVert 3 \rVert }$ propose a similar method for test time adaptation by encouraging invariance to data augmentations, and they test their method on the corrupted CIFAR and VisDA [35] datasets.
+
+A number of works have noted that varying forms of strong data augmentation on the training set can improve the resulting model’s robustness [51, 13, 24, 14]. Data augmentations are also sometimes used on the test data directly by averaging the model’s outputs across augmented copies of the test point $\mathbb { \left| \overline { { 2 3 } } \right| \overline { { \sharp 2 } } }$ , i.e., predicting according to the model’s marginal output distribution. When using cropping as the augmentation, this technique is often referred to as multicrop evaluation $\pmb { \mathbb { Z } } 2 \mathbf { l }$ . We instead use the term test time augmentation (TTA), as we use additional augmentations beyond cropping $\mathbb { \lVert \lambda \rVert }$ . TTA has been shown to be useful both for improving model accuracy and calibration $\pmb { \left. 2 \right. }$ as well as handling distribution shift [31]. We take this idea one step further by explicitly adapting the model such that its marginal output distribution has low entropy. This extracts an additional learning signal for improving the model, and furthermore, the adapted model can then make its final prediction on the clean test point rather than the augmented copies. We empirically show in Section 4 that these differences lead to improved performance over this non adaptive TTA baseline.
+
+# 3 Augmenting and Adapting at Test Time
+
+Data augmentations are typically used to train the model to respect certain invariances – e.g., changes in lighting or viewpoint do not change the underlying class label – but, especially when faced with distribution shift, the model is not guaranteed to obey the same invariances at test time. In this section, we introduce MEMO, a method for test time robustness that adapts the model such that it respects these invariances on the test input. We use “test time robustness” specifically to refer to techniques that operate directly on pretrained models and single test inputs – single point BN adaptation and TTA, as described in $\overline { { \mathsf { S e c t i o n 2 } } }$ are examples of prior test time robustness methods.
+
+In the test time robustness setting, we are given a trained model $f _ { \theta }$ with parameters $\theta \in \Theta$ . We do not require any special training procedure and do not make any assumptions about the model, except that $\theta$ is adaptable and that $f _ { \theta }$ produces a conditional output distribution $p _ { \boldsymbol { \theta } } ( y | \mathbf { x } )$ that is differentiable with respect to $\theta . ^ { 1 }$ All standard deep neural network models satisfy these assumptions. A single point $\mathbf { x } \in \mathcal { X }$ is presented to $f _ { \theta }$ , for which it must predict a label $\hat { y } \in \mathcal { V }$ immediately. Note that this is precisely identical to the standard test time inference procedure for regular supervised learning models – in effect, we are simply modifying how inference is done, without any additional assumptions on the training process or on test time data availability. This makes test time robustness methods a simple “slot-in” replacement for the ubiquitous and standard test time inference process. We assume sampling access to a set of augmentation functions $\mathcal { A } \triangleq \{ a _ { 1 } , \ldots , a _ { M } \}$ that can be applied to the test point $\mathbf { x }$ . We use these augmentations and the self-supervised objective detailed below to adapt the model before it predicts on $\mathbf { x }$ . When given a set of test inputs, the model adapts and predicts on each test point independently. We do not assume access to any ground truth labels.
+
+Require: trained model $f _ { \theta }$ , test point $\mathbf { x }$ , number of augmentations $B$ , learning rate $\eta$ , update rule $G$   
+1: Sample $a _ { 1 } , \dots , a _ { B } \overset { \mathrm { i . i . d . } } { \sim } \mathcal { U } ( A )$ and produce augmented points $\tilde { \mathbf { x } } _ { i } = a _ { i } ( \mathbf { x } )$ for $i \in \{ 1 , \ldots , B \}$   
+2: Compute estimate $\begin{array} { r } { \tilde { p } = \frac { 1 } { B } \sum _ { i = 1 } ^ { B } p _ { \theta } ( y | \tilde { \mathbf { x } } _ { i } ) \approx \bar { p } _ { \theta } ( y | \mathbf { x } ) } \end{array}$ and $\tilde { \ell } = H ( \tilde { p } ) \approx \ell ( \theta ; { \mathbf x } )$ , i.e., Eq. 2   
+3: Adapt parameters via update rule $\theta ^ { \prime }  G ( \theta , \eta , \tilde { \ell } )$   
+4: Predict $\hat { y } \triangleq \arg \operatorname* { m a x } _ { y } p _ { \theta ^ { \prime } } ( y | \mathbf { x } )$
+
+# 3.1 Marginal Entropy Minimization with One test point
+
+Given a test point $\mathbf { x }$ and set of augmentation functions $\mathcal { A }$ , we sample $B$ augmentations from $\mathcal { A }$ and apply them to $\mathbf { x }$ in order to produce a batch of augmented data $\tilde { \mathbf { x } } _ { 1 } , \ldots , \tilde { \mathbf { x } } _ { B }$ . The model’s average, or marginal, output distribution with respect to the augmented points is given by
+
+$$
+\bar { p } _ { \theta } ( y | \mathbf { x } ) \triangleq \mathbb { E } _ { \mathcal { U } ( \mathcal { A } ) } \left[ p _ { \theta } ( y | a ( \mathbf { x } ) ) \right] \approx \frac { 1 } { B } \sum _ { i = 1 } ^ { B } p _ { \theta } ( y | \tilde { \mathbf { x } } _ { i } ) ,
+$$
+
+where the expectation is with respect to uniformly sampled augmentations $a \sim \mathcal { U } ( A )$ .
+
+What properties do we desire from this marginal distribution? To answer this question, consider the role that data augmentation typically serves during training. For each training point $\left( { \bf x } ^ { \mathrm { t r a i n } } , y ^ { \mathrm { t r a i n } } \right)$ , the model $f _ { \theta }$ is trained using multiple augmented forms of the input $\tilde { \mathbf { x } } _ { 1 } ^ { \mathrm { t r a i n } } , \ldots , \tilde { \mathbf { x } } _ { E } ^ { \mathrm { t r a i n } }$ . $f$ is trained to obey the invariances between the augmentations and the label – no matter the augmentation on $\mathbf { x } ^ { \mathrm { t r a i n } }$ , $f$ should predict, with confidence, the same label $y ^ { \mathrm { t r a i n } }$ . We seek to devise a similar learning signal during test time, without any ground truth labels. That is, after adapting:
+
+(1) the model $f _ { \theta }$ predictions should be invariant across augmented versions of the test point, and (2) the model $f _ { \theta }$ should be confident in its predictions, even for heavily augmented versions of the test point, since all versions have the same underlying label.
+
+Optimizing the model for more confident predictions can be justified from the assumption that the true underlying decision boundaries between classes lie in low density regions of the data space $\textcircled { 8 }$ . With these two goals in mind, we propose to adapt the model using the entropy of its marginal output distribution over augmentations $\underline { { \operatorname { d } \dot { \operatorname { E q . } } \dot { 1 } ) } }$ , i.e.,
+
+$$
+\ell ( \theta ; \mathbf { x } ) \triangleq H \left( \bar { p } _ { \theta } ( \cdot | \mathbf { x } ) \right) = - \sum _ { y \in \mathcal { Y } } \bar { p } _ { \theta } ( y | \mathbf { x } ) \log \bar { p } _ { \theta } ( y | \mathbf { x } ) .
+$$
+
+Note that this objective is not the same as optimizing the average conditional entropy of the model’s predictive distributions across augmentations, i.e.,
+
+$$
+\ell _ { \mathrm { { C E } } } ( \boldsymbol { \theta } ; \mathbf { x } ) \triangleq \frac { 1 } { B } \sum _ { i = 1 } ^ { B } H ( p _ { \boldsymbol { \theta } } ( \cdot | \widetilde { \mathbf { x } } _ { i } ) ) .
+$$
+
+A model which predicts confidently but differently across augmentations would minimize $\operatorname { E q . 3 }$ but not $\boxed { \mathrm { E q . ~ } 2 }$ Optimizing $\operatorname { E q } . 2$ encourages both confidence and invariance, since the entropy of $\bar { p } _ { \theta } ( \cdot | \mathbf { x } )$ is minimized when the model outputs the same (confident) prediction regardless of the augmentation.
+
+Algorithm 1 presents the overall method MEMO for test time adaptation. Though prior test time adaptation methods must carefully choose which parameters to adapt in order to avoid degenerate solutions $\lVert \overline { { 4 6 } } \rVert$ , our adaptation procedure simply adapts all of the model’s parameters $\theta$ (line 3). Given that $p _ { \boldsymbol { \theta } } ( \boldsymbol { y } | \mathbf { x } )$ is differentiable with respect to $\theta$ , we can directly use gradient based optimization to adapt $\theta$ according to $\mathbb { E } { \mathsf { q } } . 2 \mathbb { Z }$ We use only one gradient step per test point, because empirically we found this to be sufficient for improved performance while being more computationally efficient. After this step, we use the adapted model $f _ { \theta ^ { \prime } }$ to predict on the original test input $\mathbf { x }$ (line 4).
+
+# 3.2 Composing MEMO with Prior Methods
+
+An additional benefit of MEMO is that it synergizes with other approaches for handling distribution shift. In particular, MEMO can be composed with prior methods for training robust models and adapting model statistics, thus leveraging the performance improvements of each technique.
+
+![](images/6ecb312275c8b833a76347f6c7ba3d2b80f52b0b71a12da6610da54a844f0e30.jpg)  
+Figure 2: We visualize augmentations of a randomly chosen data point from the “Gaussian Noise level 3” ImageNet-C test set. Even for a robust model trained with heavy data augmentations [14], both its predictive accuracy and confidence (as shown in the top two rows) drop sharply when encountering test shift. As shown in the bottom two rows, these drops can be remedied via MEMO adaptation.
+
+Pretrained robust models. Since MEMO makes no assumptions about, or modifications to, the model training procedure, performing adaptation on top of pretrained robust models, such as those trained with heavy data augmentations, is as simple as using any other pretrained model. Crucially, we find that, in practice, the set of test augmentations $\mathcal { A }$ does not have to match the augmentations that were used to train the model. For simplicity and efficiency, we use augmentations that can be easily sampled and are applied directly to the model input x. These properties do not hold for, e.g., data augmentation techniques based on image translation models, such as DeepAugment $\textcircled { 1 1 4 } \textcircled { 1 }$ , or feature mixing, such as moment exchange $\checkmark$ . However, we can still use models trained with these data augmentation techniques as our starting point for adaptation, thus allowing us to improve upon their state-of-the-art results. As noted above, using pretrained models is not as easily accomplished for adaptation methods which require complicated or specialized training procedures and model architectures, such as TTT $\mathbb { H } 4 4 \mathbb { I }$ or ARM $[ \bar { 1 } \bar { 5 } 2 ]$ . In our experiments, we use AugMix as our set of augmentations $\mathbb { \lVert \rVert 3 \rVert }$ , as it satisfies the above properties and still yields significant diversity when applied, as depicted in $\mathbb { F i g u r e 2 } $ Note that AugMix explicitly does not use augmentations that are similar to the corruptions in the CIFAR-10-C and ImageNet-C test sets [12, 13].
+
+Adapting BN statistics. Schneider et al. $\mathbb { \left[ \left. 4 0 \right] \right. }$ showed that, even when presented with just a single test point, partially adapting the estimated mean and variance of the activations in each batch normalization (BN) layer of the model can still be effective in some cases for handling distribution shift. In this setting, to prevent overfitting to the test point, the channelwise mean and variance $[ \mu _ { \mathrm { t e s t } } , \sigma _ { \mathrm { t e s t } } ^ { 2 } ]$ estimated from this point are mixed with the the mean and variance $[ \mu _ { \mathrm { t r a i n } } , \sigma _ { \mathrm { t r a i n } } ^ { 2 } ]$ computed during training according to a prior strength $N$ . That is, for $\pmb { \nu } \in \{ \mu , \sigma ^ { 2 } \}$ ,
+
+$$
+\pmb { \nu } \triangleq \frac { N } { N + 1 } \pmb { \nu } _ { \mathrm { t r a i n } } + \frac { 1 } { N + 1 } \pmb { \nu } _ { \mathrm { t e s t } } .
+$$
+
+This technique is also straightforward to combine with MEMO: we simply use the adapted BN statistics whenever computing the model’s output distribution. We find in our experiments that this technique never degrades, and generally improves, the performance of test time adaptation, thus we combine MEMO with this technique by default whenever applicable. Following the suggestion in Schneider et al. $\mathbb { \left[ \left| 4 0 \right| \right] }$ , we set $N = 1 6$ for all of our experiments in the next section.
+
+# 4 Experiments
+
+Our experiments aim to answer the following questions:
+
+(1) How does MEMO compare to prior methods for test time adaptation and test time robustness? (2) Can MEMO be combined with a wide range of model architectures and pretraining methods? (3) Which aspect of MEMO, the adaptation or augmentation, is the most important?
+
+We evaluate MEMO on a total of five distribution shift benchmarks. We conduct CIFAR-10 [22] experiments on the CIFAR-10-C [12] and CIFAR-10.1 [37] test sets, and we conduct ImageNet [38] experiments on the ImageNet-C [12], ImageNet-R [14], and ImageNet-A [15] test sets.
+
+To answer question (1), we compare to test time training (TTT) [44] in the CIFAR-10 experiments, for which we train ResNet-26 models following their protocol and specialized architecture. We do not compare to TTT for the ImageNet experiments due to the computational demands of training state-of-the-art models and because Sun et al. [44] do not report competitive ImageNet results. For the ImageNet experiments, we compare to Tent $[ \overline { { | 4 6 | } }$ and BN adaptation, which can be used with pretrained models but require multiple test inputs (or even the entire test set) for adaptation. We provide BN adaptation with 256 test inputs at a time and set the prior strength $N = 2 5 6$ [40].
+
+For Tent, we use test batch sizes of 64 and, for ResNet-50 models, test both “online” adaptation – where the model adapts continually through the entire evaluation – and “episodic” adaptation – where the model is reset after each test batch $\overline { { \lVert \textcircled { 4 6 } \rVert } }$ . Note that the evaluation protocols are different for these two methods: whereas MEMO is tasked with predicting on each test point immediately after adaptation, BN adaptation predicts on a batch of 256 test points after computing BN statistics on the batch, and Tent predicts on a batch of 64 inputs after adaptation but also, in the online setting, continually adapts throughout evaluation. In all experiments, we further compare to single point BN adaptation $\mathbb { \left[ \left| 4 0 \right| \right] }$ and the TTA baseline that simply predicts according to $\bar { p } _ { \boldsymbol { \theta } } ( y | \mathbf { \bar { x } } )$ (Eq. 1) [23, 2]. Full details on our experimental protocol are provided in Appendix A.
+
+To answer question (2), we apply MEMO on top of multiple pretrained models with different architectures, trained via several different procedures. For CIFAR-10, we train our own ResNet26 [11] models. For ImageNet, we use the best performing ResNet-50 robust models from prior work, which includes those trained with DeepAugment and AugMix augmentations $[ \textcircled { 1 4 } ]$ as well as those trained with moment exchange and CutMix $\pmb { \Vert 2 4 \Vert }$ . To evaluate the generality of prior test time robustness methods and MEMO, we also evaluate the small robust vision transformer $\mathrm { R V T ^ { * } }$ -small), which provides superior performance on all three ImageNet distribution shift benchmarks compared to the robust ResNet-50 models $\pmb { \mathbb { B } } \pmb { \mathrm { 0 } }$ . Finally, we evaluate ResNext-101 models [50, 28] on ImageNet-A, as these models previously achieved the strongest results for this test set [14].
+
+Finally, to answer (3), we conduct ablative studies in subsection 4.2: first to determine the relative importance of maximizing confidence (via entropy minimization) versus enforcing invariant predictions across augmented copies of each test point, second to determine the importance of the particular augmentation functions used, and third to determine the required number of augmented samples per inference. The comparison to the non adaptive TTA baseline also helps determine whether simply augmenting the test point is sufficient or if adaptation is additionally helpful. In Appendix B, we provide further experiments ablating the augmentation component specifically.
+
+# 4.1 Main Results
+
+We summarize results for CIFAR-10, CIFAR-10.1, and CIFAR-10-C in Table 1, with full CIFAR-10- C results in Appendix C. We use indentations to indicate composition, e.g., TTT is performed at test time on top of their specialized joint training procedure. Across all corruption types in CIFAR-10-C, MEMO consistently improves test error compared to the baselines, non adaptive TTA, and TTT. MEMO also provides a larger performance gain on CIFAR-10.1 compared to TTT. We find that the non adaptive TTA baseline is competitive for these relatively simple test sets, though it is worse than MEMO for CIFAR-10-C. Of these three test sets, CIFAR-10-C is the only benchmark that explicitly introduces distribution shift, which suggests that adaptation is useful when the test shifts are more prominent. Both TTA and MEMO are also effective at improving performance for the original CIFAR-10 test set where there is no distribution shift, providing further support for the widespread use of augmentations in standard evaluation protocols [23, 2].
+
+Table 1: Results for CIFAR-10, CIFAR-10.1, and CIFAR-10-C. ?Results from Sun et al. [44].   
+
+<table><tr><td></td><td>CIFAR-10 Error (%)</td><td>CIFAR-10.1 Error (%)</td><td>CIFAR-10-C Average Error (%)</td></tr><tr><td>ResNet-26 □</td><td>9.2</td><td>18.4</td><td>22.5</td></tr><tr><td>+TTA</td><td>7.3 (-1.9)</td><td>14.8 (-3.6)</td><td>19.9 (-2.6)</td></tr><tr><td>+ MEMO (ours)</td><td>7.3 (-1.9)</td><td>14.7 (-3.7)</td><td>19.6 (-2.9)</td></tr><tr><td>+ Joint training* 国</td><td>8.1</td><td>16.7</td><td>22.8</td></tr><tr><td>+ TTT* 因</td><td>7.9 (-0.2)</td><td>15.9 (-0.8)</td><td>21.5 (-1.3)</td></tr></table>
+
+Table 2: Test results for the ImageNet test sets. MEMO achieves new state-of-the-art performance on each benchmark for ResNet-50 models for the single test point setting. For $\mathbf { R V T ^ { * } }$ -small, MEMO improves performance across all benchmarks and reaches a new state of the art for ImageNet-C and ImageNet-R. Compared to prior approaches, MEMO offers more consistent improvements.   
+
+<table><tr><td></td><td>ImageNet-C mCE↓</td><td>ImageNet-R Error (%)</td><td>ImageNet-A Error (%)</td></tr><tr><td>Baseline ResNet-50 自</td><td>76.7</td><td>63.9</td><td>100.0</td></tr><tr><td>+ TTA</td><td>77.9 (+1.2)</td><td>61.3 (-2.6)</td><td>98.4 (-1.6)</td></tr><tr><td>+ Single point BN</td><td>71.4 (-5.3)</td><td>61.1 (-2.8)</td><td>99.4 (-0.6)</td></tr><tr><td>+ MEMO (ours)</td><td>69.9 (-6.8)</td><td>58.8 (-5.1)</td><td>99.1 (-0.9)</td></tr><tr><td>+ BN (N = 256,n = 256)</td><td>61.6 (-15.1)</td><td>59.7 (-4.2)</td><td>99.8 3(-0.2)</td></tr><tr><td>+ Tent (online) [ 46</td><td>54.4 (−22.3)</td><td>57.7 (-6.2)</td><td>99.8 (-0.2)</td></tr><tr><td>+ Tent (episodic)</td><td>64.7 (−12.0)</td><td>61.0 (-2.9)</td><td>99.7 ( (-0.3)</td></tr><tr><td> + DeepAugment+AugMix [14]</td><td>53.6</td><td>53.2</td><td>96.1</td></tr><tr><td>+ TTA</td><td>55.2 (+1.6)</td><td>51.0 (-2.2)</td><td>93.5 (-2.6)</td></tr><tr><td>+ Single point BN</td><td>51.3 (-2.3)</td><td>51.2 (-2.0)</td><td>95.4 (-0.7)</td></tr><tr><td>+ MEMO (ours)</td><td>49.8 (-3.8)</td><td>49.2 (-4.0)</td><td>94.8 (-1.3)</td></tr><tr><td>+ BN(N = 256,n = 256)</td><td>45.4 (−8.2)</td><td>48.8 (-4.4)</td><td>96.8 (+0.7)</td></tr><tr><td>+ Tent (online)</td><td>43.5 (-10.1)</td><td>46.9 (-6.3)</td><td>96.7 (+0.6)</td></tr><tr><td> + Tent (episodic)</td><td>47.1 (-6.5)</td><td>50.1 (-3.1)</td><td>96.6 (+0.5)</td></tr><tr><td>+ MoEx+CutMix 2</td><td>74.8</td><td>64.5</td><td>91.9</td></tr><tr><td>+ TTA</td><td>75.7 (+0.9)</td><td>62.7 (-1.8)</td><td>89.5 (-2.4)</td></tr><tr><td>+ Single point BN</td><td>71.0 (-3.8)</td><td>62.6 (−1.9)</td><td>91.1 (-0.8)</td></tr><tr><td>+ MEMO (ours)</td><td>69.1 (-5.7)</td><td>59.4 (-3.3)</td><td>89.0 (-2.9)</td></tr><tr><td>+ BN (N = 256,n = 256)</td><td>60.9 (-13.9)</td><td>61.6 (-2.9)</td><td>93.9 (+2.0)</td></tr><tr><td>+ Tent (online)</td><td>54.0 (-20.8)</td><td>58.7 (-5.8)</td><td>94.4 (+2.5)</td></tr><tr><td>+ Tent (episodic)</td><td>66.2 (-8.6)</td><td>63.9 (-0.6)</td><td>94.7 (+2.8)</td></tr><tr><td>RVT*-small □</td><td>49.4</td><td>52.3</td><td>73.9</td></tr><tr><td>+ TTA</td><td>53.0 (+3.6)</td><td>49.0 (-3.3)</td><td>68.9 (-5.0)</td></tr><tr><td>+ Single point BN</td><td>48.0 (-1.4)</td><td>51.1 (-1.2)</td><td>74.4 (+0.5)</td></tr><tr><td>+ MEMO (ours)</td><td>40.6 (-8.8)</td><td>43.8 (-8.5)</td><td>69.8 (-4.1)</td></tr><tr><td>+ BN (N = 256,n = 256)</td><td>44.3 (-5.1)</td><td>51.0 ( (-1.3)</td><td>78.3 (+4.4)</td></tr><tr><td>+ Tent (online)</td><td>46.8 (-2.6)</td><td> 50.7 (-1.6)</td><td>82.1 (+8.2)</td></tr><tr><td>+ Tent (adapt all)</td><td>44.7 (-4.7)</td><td>74.1 (+21.8)</td><td>81.1 (+7.2)</td></tr></table>
+
+We summarize results for ImageNet-C, ImageNet-R, and ImageNet-A in Table 2, with complete ImageNet-C results in $\boxed { \mathrm { A p p e n d i x ~ C } }$ We again use indentations to indicate composition, e.g., the best results on ImageNet-C for our setting are attained through a combination of starting from a model trained with DeepAugment and AugMix [14] and using MEMO on top. For both ImageNet-C and ImageNet-R, and for both the ResNet-50 and $\mathbf { R V T ^ { * } }$ -small models, combining MEMO with robust training techniques leads to new state-of-the-art performance among methods that observe only one test point at a time. We highlight in gray the methods that require multiple test points for adaptation, and we list in bold the best results from these methods which outperform the test time robustness methods. As Table 2 and prior work both show [40, 46], accessing multiple test points can be powerful for benchmarks such as ImageNet-C and ImageNet-R, in which inferred statistics from the test input distribution may aid in prediction. However, these methods do not help, and oftentimes even hurt, for ImageNet-A. Furthermore, we find that these methods are less effective with the $\mathrm { R V T ^ { * } }$ -small model, which may indicate their sensitivity to model architecture choices. Therefore, for this model, we also test a modification of Tent which adapts all parameters, and we find that this version of Tent works better for ImageNet-C but is significantly worse for ImageNet-R.
+
+MEMO also results in substantial improvement for ImageNet-A. No prior test time adaptation methods have reported improvements on ImageNet-A, and some have reported explicit negative results $\mathbb { H O }$ . As discussed, it is reasonable for adaptation methods that rely on multiple test points to achieve greater success on other benchmarks such as ImageNet-C, in which a batch of inputs provides significant information about the specific corruption that must be dealt with. In contrast, ImageNet-A does not have such obvious characteristics associated with the input distribution, as it is simply a collection of images that are difficult to classify. As MEMO instead extracts a learning signal from single test points, it is, to the best of our knowledge, the first test time adaptation method to report successful results on this testbed. We view the consistency with which MEMO outperforms the best prior methods, which change across different test sets, as a major advantage of the proposed method.
+
+TTA is the most competitive prior method for ImageNet-A, e.g., it results in larger improvements than MEMO for the $\mathbf { R V T ^ { * } }$ -small model. MEMO, however, achieves state-of-the-art performance among ResNet-50 models. To further compare MEMO to TTA, in Table 3, we evaluate whether MEMO can successfully adapt ResNext-101 models $ { \Vert 5 0 \Vert }$ and further improve performance on this challenging test set. We evaluate both a ResNext-101 (32x8d) baseline model pretrained on ImageNet, as well as the same model pretrained with weakly supervised learning (WSL) on billions of Instagram images $\bar { \left\| 2 8 \right\| }$ . For the
+
+Table 3: ImageNet-A results for the ResNext-101s.   
+
+<table><tr><td colspan="2">ImageNet-A Error (%)</td></tr><tr><td>ResNext-101 ⑤0</td><td>90.0</td></tr><tr><td>+ TTA</td><td>83.2 (-6.8)</td></tr><tr><td>+ Single point BN</td><td>88.8 (-1.2)</td></tr><tr><td>+ MEMO (ours)</td><td>84.3 (-5.7)</td></tr><tr><td>+ WSL [28]</td><td>54.9</td></tr><tr><td>+ TTA</td><td>49.1 (-5.8)</td></tr><tr><td>+ Single point BN</td><td>58.9 (+4.0)</td></tr><tr><td>+ MEMO (ours)</td><td>43.2 (−11.7)</td></tr></table>
+
+WSL model, we did not use single point BN adaptation for MEMO as we found this technique to be actually harmful to performance, and this corroborates previous findings $\mathbb { H O }$ . From the results, we can see that, although both TTA and MEMO significantly improve upon the baseline model evaluation, MEMO ultimately achieves the best accuracy by a significant margin as it is more successful at adapting the WSL model. This suggests that MEMO may synergize well with large scale pretraining, and further exploring this combination is an interesting direction for future work.
+
+# 4.2 Ablative Study
+
+MEMO uses both adaptation and augmentations. In this section, we ablate the adaptation procedure and the number of augmentations, and in Appendix B we ablate the choice of augmentations.
+
+Adaptation procedure. From the results above, we conclude that adaptation generally provides additional benefits beyond simply using TTA to predict via the marginal output distribution $\bar { p } _ { \boldsymbol { \theta } } ( y | \mathbf { x } )$ . However, we can disentangle two distinct self-supervised learning signals that may be effective for adaptation: encouraging invariant predictions across different augmentations of the test point, and encouraging confidence via entropy minimization. The marginal entropy objective in $\operatorname { \bar { E } q } . 2$ encapsulates both of these learning signals, but it cannot easily be decomposed into these pieces. We instead use two ablative adaptation methods that each only make use of one of these learning signals.
+
+First, we consider optimizing the pairwise cross entropy between each pair of augmented points, i.e.,
+
+$$
+\ell _ { \mathrm { P C E } } ( \boldsymbol { \theta } ; \mathbf { x } ) \triangleq \frac { 1 } { B \times ( B - 1 ) } \sum _ { i = 1 } ^ { B } \sum _ { j \neq i } H ( p _ { \boldsymbol { \theta } } ( \cdot | \widetilde { \mathbf { x } } _ { i } ) , p _ { \boldsymbol { \theta } } ( \cdot | \widetilde { \mathbf { x } } _ { j } ) ) ,
+$$
+
+Where $\tilde { \mathbf { x } } _ { i }$ again refers to the $i$ -th sampled augmentation applied to $\mathbf { x }$ . Intuitively, this loss function encourages the model to adapt such that it produces the same predictive distribution for all augmentations of the test point, but it does not encourage the model to produce confident predictions.
+
+Table 4: Ablating the adaptation objective to test pairwise cross entropy and conditional entropy (CE) based adaptation. MEMO generally performs the best, indicating that both encouraging invariance across augmentations and confidence are helpful in adapting the model.   
+
+<table><tr><td></td><td>CIFAR-10 Error (%)</td><td>CIFAR-10.1 Error (%)</td><td>CIFAR-10-C Average Error (%)</td></tr><tr><td>ResNet-26 []</td><td>9.2</td><td>18.4</td><td>22.5</td></tr><tr><td>+ MEMO (ours)</td><td>7.3 (-1.9)</td><td>14.7 (-3.7)</td><td>19.6 (-2.9)</td></tr><tr><td>l (Eq. 2) ）+lPCE 一</td><td>7.6 (-1.6)</td><td>15.3 (-3.1)</td><td>20.0 (-2.5)</td></tr><tr><td>Eq.2) + lcE</td><td>7.6 (-1.6)</td><td>14.7 (-3.7)</td><td>20.0 (-2.5)</td></tr><tr><td></td><td>ImageNet-C mCE↓</td><td>ImageNet-R Error (%)</td><td>ImageNet-A Error (%)</td></tr><tr><td>RVT*-small [30]</td><td>49.4</td><td>52.3</td><td>73.9</td></tr><tr><td>+ MEMO (ours)</td><td>40.6 (-8.8)</td><td>43.8 (-8.5)</td><td>69.8 (-4.1)</td></tr><tr><td>-l (Eq. 2) + lcE</td><td>41.2 (-8.2)</td><td>44.2 (−8.1)</td><td>69.7 (-4.2)</td></tr></table>
+
+![](images/5eaa7e18247da47c2425c9985f500a9780838964f166482db468111dd95d274c.jpg)  
+Figure 3: Plotting MEMO efficiency as seconds per evaluation $\mathbf { \dot { x } }$ axis) and $\%$ test error on ImageNet-R (y axis) for the ResNet-50 models (left) and $\mathrm { R V T ^ { * } }$ -small (right) while varying $B = \{ 1 , 2 , 4 , 8 , 1 6 , 3 2 , 6 4 , 1 2 8 \}$ . Note the log scale on the $\mathbf { X }$ axis.
+
+Conversely, as an objective that encourages confidence but not invariance, we also consider optimizing the conditional entropy objective detailed in Eq. 3. This ablation is effectively a version of the episodic variant of Tent $[ \overline { { | 4 6 | } }$ that produces augmented copies of a single test point rather than assuming access to a test batch. We first evaluate these ablations on the CIFAR-10 test sets. We use the same adaptation procedure and hyperparameters, with $\ell$ replaced with the above objectives.
+
+The results are presented in Table 4. We see that MEMO, i.e., marginal entropy minimization, generally performs better than adaptation with either of the alternative objectives. This supports the hypothesis that both invariance across, and confidence on, the augmentations are important learning signals for self-supervised adaptation. When faced with CIFAR-10.1, we see poor performance from the pairwise cross entropy based adaptation method. On the original CIFAR-10 test set and CIFAR-10- C, the ablations perform nearly identically and uniformly worse than MEMO. To further test the $\ell _ { \mathrm { C E } }$ ablation, which is the stronger of the two ablations, we also evaluate it on the ImageNet test sets for the $\mathrm { R V T ^ { * } }$ -small model. We find that, similarly, minimizing conditional entropy generally improves performance compared to the baseline evaluation. MEMO is more performant for ImageNet-C and ImageNet-R. Adaptation via $\ell _ { \mathrm { C E } }$ performs slightly better for ImageNet-A, though for this problem and model, TTA is still the best method. Thus, MEMO results in relatively small, but consistent, performance gains compared to only maximizing confidence on the augmentations.
+
+Number of augmentations. In Figure 3, we analyze the $\%$ test error of MEMO adaptation on ImageNet-R as a function of the efficiency of adaptation, measured in seconds per evaluation. We achieve various tradeoffs by varying the number of augmented copies $B \ =$ $\{ 1 , 2 , 4 , 8 , 1 6 , 3 2 , 6 4 , 1 2 8 \}$ . We note that small values of $B$ such as 4 and 8 can already provide significant performance gains, thus a practical tradeoff between efficiency and accuracy is possible.
+
+For large $B$ , the wall clock time is dominated by computing the augmentations. For the baseline ResNet-50 model, single point BN adaptation requires an average of 0.0252 seconds per test point. TTA and MEMO with $B = 6 4$ are much slower – 0.7742 and 0.9746 seconds, respectively, per test point – but can be made significantly more efficient by using $B = 4$ augmented samples – 0.0631 and 0.1037 seconds, respectively. In our implementation, we do not compute augmentations in parallel, though in principle this is possible for AugMix and should drastically improve efficiency overall. These experiments used four Intel Xeon Skylake 6130 CPUs and one NVIDIA TITAN RTX GPU.
+
+# 5 Discussion
+
+We presented MEMO, a method for test time robustification again distribution shift via adaptation and augmentation. MEMO does not require access or changes to the model training procedure and is thus broadly applicable for a wide range of model architectures pretrained in a number of different ways. Furthermore, MEMO adapts at test time using single test inputs, thus it does not assume access to multiple test points as in several recent methods for test time adaptation $\mathbb { H O } \mathbb { H } \mathbb { H }$ . On a range of CIFAR-10 and ImageNet distribution shift benchmarks, and for ResNet, vision transformer, and, to an extent, ResNext models, MEMO consistently improves performance at test time and achieves several new state-of-the-art results for these models in the single test point setting.
+
+Inference via MEMO is more computationally expensive than standard model inference due to its augmentation and adaptation procedure – though, as the experiments above show, more favorable tradeoffs between efficiency and accuracy are possible with smaller values of $B$ , the number of augmentations per test point. One interesting direction for future work is to develop techniques for selectively determining when to adapt the model in order to achieve more efficient inference. For example, with well calibrated models $[ \mathbb { 1 0 } ]$ , we may run simple “feedforward” inference when the prediction confidence is over a certain threshold, thus achieving better efficiency. Additionally, it would be interesting to explore MEMO in the test setting where the model is allowed to continually adapt as more test data is observed. In our preliminary experiments in this setting, MEMO tended to lead to degenerate solutions, e.g., the model predicting a constant label with maximal confidence regardless of the input. This failure mode may potentially be rectified by carefully choosing which parameters to adapt, such as only adapting the parameters in BN layers $\boxed { \boxplus 6 }$ , or regularizing the model such that it does not change too drastically from the pretrained model [26].
+
+# Acknowledgments and Disclosure of Funding
+
+We thank members of the Robotic AI and Learning Lab and Berkeley AI Research for helpful discussions and feedback. MZ was supported in part by an NDSEG fellowship. CF is a CIFAR fellow. This research was partially supported by ARL DCIST CRA W911NF-17-2-0181 and ARO W911NF-21-1-0097.
+
+# References
+
+[1] F. Alet, M. Bauza, K. Kawaguchi, N. Kuru, T. Lozano-Pérez, and L. Kaelbling. Tailoring: Encoding inductive biases by optimizing unsupervised objectives at prediction time. In Advances in Neural Information Processing Systems (NeurIPS), 2021.   
+[2] A. Ashukha, A. Lyzhov, D. Molchanov, and D. Vetrov. Pitfalls of in-domain uncertainty estimation and ensembling in deep learning. In International Conference on Learning Representations (ICLR), 2020.   
+[3] A. Bartler, A. Bühler, F. Wiewel, M. Döbler, and B. Yang. MT3: Meta test-time training for self-supervised test-time adaption. In International Conference on Artificial Intelligence and Statistics (AISTATS), 2022.   
+[4] A. Ben-Tal, D. den Hertog, A. De Waegenaere, B. Melenberg, and G. Rennen. Robust solutions of optimization problems affected by uncertain probabilities. Management Science, 2013. [5] G. Blanchard, G. Lee, and C. Scott. Generalizing from several related classification tasks to a new unlabeled sample. In Advances in Neural Information Processing Systems (NIPS), 2011. [6] G. Csurka. Domain adaptation for visual applications: A comprehensive survey. arXiv preprint arXiv:1702.05374, 2017. [7] A. Dosovitskiy, L. Beyer, A. Kolesnikov, D. Weissenborn, X. Zhai, T. Unterthiner, M. Dehghani, M. Minderer, G. Heigold, S. Gelly, J. Uszkoreit, and N. Houlsby. An image is worth 16x16 words: Transformers for image recognition at scale. In International Conference on Learning Representations (ICLR), 2021. [8] Y. Grandvalet and Y. Bengio. Semi-supervised learning by entropy minimization. In Advances in Neural Information Processing Systems (NIPS), 2005. [9] I. Gulrajani and D. Lopez-Paz. In search of lost domain generalization. In International Conference on Learning Representations (ICLR), 2021.   
+[10] C. Guo, G. Pleiss, Y. Sun, and K. Weinberger. On calibration of modern neural networks. In International Conference on Machine Learning (ICML), 2017.   
+[11] K. He, X. Zhang, S. Ren, and J. Sun. Deep residual learning for image recognition. In Conference on Computer Vision and Pattern Recognition (CVPR), 2016.   
+[12] D. Hendrycks and T. Dietterich. Benchmarking neural network robustness to common corruptions and perturbations. In International Conference on Learning Representations (ICLR), 2019.   
+[13] D. Hendrycks, N. Mu, E. Cubuk, B. Zoph, J. Gilmer, and B. Lakshminarayanan. AugMix: A simple data processing method to improve robustness and uncertainty. In International Conference on Learning Representations (ICLR), 2020.   
+[14] D. Hendrycks, S. Basart, N. Mu, S. Kadavath, F. Wang, E. Dorundo, R. Desai, T. Zhu, S. Parajuli, M. Guo, D. Song, J. Steinhardt, and J. Gilmer. The many faces of robustness: A critical analysis of out-of-distribution generalization. In IEEE International Conference on Computer Vision (ICCV), 2021.   
+[15] D. Hendrycks, K. Zhao, S. Basart, J. Steinhardt, and D. Song. Natural adversarial examples. In Conference on Computer Vision and Pattern Recognition (CVPR), 2021.   
+[16] W. Hu, G. Niu, I. Sato, and M. Sugiyama. Does distributionally robust supervised learning give robust classifiers? In International Conference on Machine Learning (ICML), 2018.   
+[17] Y. Huang, J. Gornet, S. Dai, Z. Yu, T. Nguyen, D. Tsao, and A. Anandkumar. Neural networks with recurrent generative feedback. In Advances in Neural Information Processing Systems (NeurIPS), 2020.   
+[18] Y. Iwasawa and Y. Matsuo. Test-time classifier adjustment module for model-agnostic domain generalization. In Advances in Neural Information Processing Systems (NeurIPS), 2021.   
+[19] A. Kaku, S. Mohan, A. Parnandi, H. Schambra, and C. Fernandez-Granda. Be like water: Robustness to extraneous variables via adaptive feature normalization. arXiv preprint arXiv:2002.04019, 2020.   
+[20] D. Kingma and J. Ba. Adam: A method for stochastic optimization. In International Conference on Learning Representations (ICLR), 2015.   
+[21] P. Koh, S. Sagawa, H. Marklund, S. Xie, M. Zhang, A. Balsubramani, W. Hu, M. Yasunaga, R. Phillips, I. Gao, T. Lee, E. David, I. Stavness, W. Guo, B. Earnshaw, I. Haque, S. Beery, J. Leskovec, A. Kundaje, E. Pierson, S. Levine, C. Finn, and P. Liang. WILDS: A benchmark of in-the-wild distribution shifts. In International Conference on Machine Learning (ICML), 2021.   
+[22] A. Krizhevsky. Learning multiple layers of features from tiny images. Technical report, University of Toronto, 2009.   
+[23] A. Krizhevsky, I. Sutskever, and G. Hinton. ImageNet classification with deep convolutional neural networks. In Advances in Neural Information Processing Systems (NIPS), 2012.   
+[24] B. Li, F. Wu, S. Lim, S. Belongie, and K. Weinberger. On feature normalization and data augmentation. In Conference on Computer Vision and Pattern Recognition (CVPR), 2021.   
+[25] Y. Li, N. Wang, J. Shi, J. Liu, and X. Hou. Revisiting batch normalization for practical domain adaptation. In International Conference on Learning Representations Workshop (ICLRW), 2017.   
+[26] Y. Liu, P. Kothari, B. van Delft, B. Bellot-Gurlet, T. Mordan, and A. Alahi. $\mathrm { T T T } { + } { + }$ : When does self-supervised test-time training fail or thrive? In Advances in Neural Information Processing Systems (NeurIPS), 2021.   
+[27] I. Loshchilov and F. Hutter. Decoupled weight decay regularization. In International Conference on Learning Representations (ICLR), 2019.   
+[28] D. Mahajan, R. Girshick, V. Ramanathan, K. He, M. Paluri, Y. Li, A. Bharambe, and L. van der Maaten. Exploring the limits of weakly supervised pretraining. In European Conference on Computer Vision (ECCV), 2018.   
+[29] C. Mao, M. Chiquier, H. Wang, J. Yang, and C. Vondrick. Adversarial attacks are reversible with natural supervision. In IEEE International Conference on Computer Vision (ICCV), 2021.   
+[30] X. Mao, G. Qi, Y. Chen, X. Li, R. Duan, S. Ye, Y. He, and H. Xue. Towards robust vision transformer. In Conference on Computer Vision and Pattern Recognition (CVPR), 2022.   
+[31] D. Molchanov, A. Lyzhov, Y. Molchanova, A. Ashukha, and D. Vetrov. Greedy policy search: A simple baseline for learnable test-time augmentation. In Conference on Uncertainty in Artificial Intelligence (UAI), 2020.   
+[32] K. Muandet, D. Balduzzi, and B. Schölkopf. Domain generalization via invariant feature representation. In International Conference on Machine Learning (ICML), 2013.   
+[33] Z. Nado, S. Padhy, D. Sculley, A. D’Amour, B. Lakshminarayanan, and J. Snoek. Evaluating prediction-time batch normalization for robustness under covariate shift. arXiv preprint arXiv:2006.10963, 2020.   
+[34] A. Orhan. Robustness properties of Facebook’s ResNeXt WSL models. arXiv preprint arXiv:1907.07640, 2019.   
+[35] X. Peng, B. Usman, N. Kaushik, J. Hoffman, D. Wang, and K. Saenko. VisDA: The visual domain adaptation challenge. arXiv preprint arXiv:1710.06924, 2017.   
+[36] J. Quiñonero Candela, M. Sugiyama, A. Schwaighofer, and N. Lawrence. Dataset Shift in Machine Learning. The MIT Press, 2009.   
+[37] B. Recht, R. Roelofs, L. Schmidt, and V. Shankar. Do CIFAR-10 classifiers generalize to CIFAR-10? arXiv preprint arXiv:1806.00451, 2018.   
+[38] O. Russakovsky, J. Deng, H. Su, J. Krause, S. Satheesh, S. Ma, Z. Huang, A. Karpathy, A. Khosla, M. Bernstein, A. Berg, and F. Li. Imagenet large scale visual recognition challenge. International Journal of Computer Vision (IJCV), 2015.   
+[39] S. Sagawa, P. Koh, T. Hashimoto, and P. Liang. Distributionally robust neural networks for group shifts: On the importance of regularization for worst-case generalization. In International Conference on Learning Representations (ICLR), 2020.   
+[40] S. Schneider, E. Rusak, L. Eck, O. Bringmann, W. Brendel, and M. Bethge. Improving robustness against common corruptions by covariate shift adaptation. In Advances in Neural Information Processing Systems (NeurIPS), 2020.   
+[41] H. Shimodaira. Improving predictive inference under covariate shift by weighting the loglikelihood function. Journal of Statistical Planning and Inference (JSPI), 2000.   
+[42] C. Shorten and T. Khoshgoftaar. A survey on image data augmentation for deep learning. Journal of Big Data, 2019.   
+[43] P. Sivaprasad and F. Fleuret. Test time adaptation through perturbation robustness. arXiv preprint arXiv:2110.10232, 2021.   
+[44] Y. Sun, X. Wang, Z. Liu, J. Miller, A. Efros, and M. Hardt. Test-time training with selfsupervision for generalization under distribution shifts. In International Conference on Machine Learning (ICML), 2020.   
+[45] T. Varsavsky, M. Orbes-Arteaga, C. Sudre, M. Graham, P. Nachev, and M. Cardoso. Test-time unsupervised domain adaptation. arXiv preprint arXiv:2010.01926, 2020.   
+[46] D. Wang, E. Shelhamer, S. Liu, B. Olshausen, and T. Darrell. Tent: Fully test-time adaptation by entropy minimization. In International Conference on Learning Representations (ICLR), 2021.   
+[47] G. Wilson and D. Cook. A survey of unsupervised deep domain adaptation. ACM Transactions on Intelligent Systems and Technology (TIST), 2020.   
+[48] E. Wong, L. Rice, and J. Kolter. Fast is better than free: Revisiting adversarial training. In International Conference on Learning Representations (ICLR), 2020.   
+[49] Y. Wu and K. He. Group normalization. In European Conference on Computer Vision (ECCV), 2018.   
+[50] S. Xie, R. Girshick, P. Dollár, Z. Tu, and K. He. Aggregated residual transformations for deep neural networks. In Conference on Computer Vision and Pattern Recognition (CVPR), 2017.   
+[51] D. Yin, R. Lopes, J. Shlens, E. Cubuk, and J. Gilmer. A Fourier perspective on model robustness in computer vision. In Advances in Neural Information Processing Systems (NeurIPS), 2019.   
+[52] M. Zhang, H. Marklund, A. Gupta, S. Levine, and C. Finn. Adaptive risk minimization: Learning to adapt to domain shift. In Advances in Neural Information Processing Systems (NeurIPS), 2021.
+
+# Checklist
+
+1. For all authors...
+
+(a) Do the main claims made in the abstract and introduction accurately reflect the paper’s contributions and scope? [Yes]   
+(b) Did you describe the limitations of your work? [Yes] See Section 5.   
+(c) Did you discuss any potential negative societal impacts of your work? [No]   
+(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] See supplementary material.   
+(b) Did you specify all the training details (e.g., data splits, hyperparameters, how they were chosen)? [Yes] See Appendix A.   
+(c) Did you report error bars (e.g., with respect to the random seed after running experiments multiple times)? [N/A]   
+(d) Did you include the total amount of compute and the type of resources used (e.g., type of GPUs, internal cluster, or cloud provider)? [No]
+
+4. If you are using existing assets (e.g., code, data, models) or curating/releasing new assets...
+
+(a) If your work uses existing assets, did you cite the creators? [Yes]   
+(b) Did you mention the license of the assets? [No] All assets are publicly and freely available.   
+(c) Did you include any new assets either in the supplemental material or as a URL? [No]   
+(d) Did you discuss whether and how consent was obtained from people whose data you’re using/curating? [N/A]   
+(e) Did you discuss whether the data you are using/curating contains personally identifiable information or offensive content? [N/A]
+
+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/XrGEkCOREX2/XrGEkCOREX2_content_list.json

@@ -0,0 +1,1059 @@
+[
+    {
+        "type": "text",
+        "text": "MEMO: Test Time Robustness via Adaptation and Augmentation ",
+        "text_level": 1,
+        "bbox": [
+            289,
+            122,
+            707,
+            172
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Marvin Zhang1, Sergey Levine1, Chelsea Finn2 1UC Berkeley 2Stanford University ",
+        "bbox": [
+            333,
+            224,
+            663,
+            255
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Abstract ",
+        "text_level": 1,
+        "bbox": [
+            462,
+            290,
+            535,
+            308
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "While deep neural networks can attain good accuracy on in-distribution test points, many applications require robustness even in the face of unexpected perturbations in the input, changes in the domain, or other sources of distribution shift. We study the problem of test time robustification, i.e., using the test input to improve model robustness. Recent prior works have proposed methods for test time adaptation, however, they each introduce additional assumptions, such as access to multiple test points, that prevent widespread adoption. In this work, we aim to study and devise methods that make no assumptions about the model training process and are broadly applicable at test time. We propose a simple approach that can be used in any test setting where the model is probabilistic and adaptable: when presented with a test example, perform different data augmentations on the data point, and then adapt (all of) the model parameters by minimizing the entropy of the model’s average, or marginal, output distribution across the augmentations. Intuitively, this objective encourages the model to make the same prediction across different augmentations, thus enforcing the invariances encoded in these augmentations, while also maintaining confidence in its predictions. In our experiments, we evaluate two baseline ResNet models, two robust ResNet-50 models, and a robust vision transformer model, and we demonstrate that this approach achieves accuracy gains of $1 \\%$ over standard model evaluation and also generally outperforms prior augmentation and adaptation strategies. For the setting in which only one test point is available, we achieve state-of-the-art results on the ImageNet-C, ImageNet-R, and, among ResNet-50 models, ImageNet-A distribution shift benchmarks. ",
+        "bbox": [
+            233,
+            321,
+            766,
+            627
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 Introduction ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            654,
+            310,
+            670
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Deep neural network models have achieved excellent performance on many machine learning problems, such as image classification, but are often brittle and susceptible to issues stemming from distribution shift. For example, deep image classifiers may degrade precipitously in accuracy when encountering input perturbations, such as noise or changes in lighting $[ \\hat { \\left| 1 2 \\right| } ]$ or domain shifts which occur naturally in real world applications $\\mathbb { \\left| \\mathbb { Z } \\right\\| }$ . Therefore, robustification of deep models against these test shifts is an important and active area of study. ",
+        "bbox": [
+            174,
+            685,
+            825,
+            768
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Most prior works in this area have focused on techniques for training time robustification, including utilizing larger models and datasets $\\pmb { \\mathbb { B 4 } }$ , various forms of adversarial training $\\mathbb { B 9 } \\mathbb { H 8 }$ , and aggressive data augmentation [51, 13, 24, 14]. Employing these techniques requires modifying the training process, which may not be feasible if, e.g., it involves heavy computation or non public data. Furthermore, these techniques do not rely on any information about the test points that the model must predict on, even though these test points may provide significant information for improving model robustness. Recently, several works have proposed methods for improving accuracy via adaptation after seeing the test data, typically by updating a subset of the model’s weights [44, 45, 18], normalization statistics [40], or both [46, 52]. Though effective at handling test shifts, these methods sometimes still require specialized training procedures, and they typically rely on extracting information via batches or even entire sets of test inputs, thus introducing additional assumptions. ",
+        "bbox": [
+            174,
+            775,
+            825,
+            900
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "image",
+        "img_path": "images/695fdc8d76523d7ae12f1252c94b960f4f9aeeee940045c10e43759d62a658f6.jpg",
+        "image_caption": [
+            "Figure 1: Left: at test time, as detailed in $\\mathsf { \\overline { { S e c t i o n 3 } } } ,$ we have a single test input $\\mathbf { x }$ , a set of data augmentation functions $\\{ a _ { 1 } , \\dotsc , a _ { M } \\}$ , and a trained model that outputs a probabilistic predictive distribution and has adaptable parameters $\\theta$ . We perform different augmentations on $\\mathbf { x }$ and pass these augmented inputs to the model in order to estimate the marginal output distribution averaged over augmentations. Right: we perform a gradient update on the model to minimize the entropy of this marginal distribution, thus encouraging the model predictions to be invariant across different augmentations while maintaining confident predictions. The final prediction is then made on the original data point, i.e., the predictive distribution in the top right of the schematic. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            191,
+            87,
+            808,
+            299
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            414,
+            823,
+            443
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "In this work, we focus on methods for test time robustness, in which the specific test input may be leveraged in order to improve the model’s prediction on that point. We are interested in studying and devising methods for improving model robustness that are “plug and play”, i.e., they can be readily used with a wide variety of pretrained models and test settings. We also want methods that synergize with other robustification techniques, in order to achieve greater performance than using either in isolation. With these goals in mind, we devise a novel test time robustness method based on adaptation and augmentation. As illustrated in $\\mathbb { F i g u r e 1 } ,$ when presented with a test point, we adapt the model by augmenting the test point in different ways while encouraging the model to make consistent predictions, thus respecting the invariances encoded in the data augmentations. We further encourage the model to make confident predictions, thus arriving at the proposed method: minimize the marginal entropy of the model’s predictions across the augmented versions of the test point. ",
+        "bbox": [
+            174,
+            448,
+            825,
+            601
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "We refer to the proposed method as marginal entropy minimization with one test point (MEMO), and this is the primary contribution of our work. MEMO makes direct use of pretrained models without any assumptions about their particular training procedure or architecture, while requiring only a single test input for adaptation. In Section 4, we demonstrate empirically that MEMO consistently improves the performance of ResNet [11] and vision transformer $\\mathbb { \\overline { { | \\overline { { \\mathbb { Z } } | } } } }$ models on several challenging ImageNet distribution shift benchmarks, achieving several new state-of-the-art results for these models in the setting in which only one test point is available. MEMO consistently outperforms non adaptive marginal distribution predictions (between $1 - 1 0 \\%$ improvement) on the ImageNet-C [12] and ImageNet-R [14] test sets, indicating that adaptation plays a crucial role in improving predictive accuracy. MEMO encourages both invariance across augmentations and confident predictions, and an ablation study in Section 4 shows that both components are important for maximal performance gains. Also, MEMO is, to the best of our knowledge, the first adaptation method to improve performance (by $1 \\%$ over standard model evaluation) on the ImageNet-A test set $\\mathbb { \\lVert 1 5 \\rVert }$ . ",
+        "bbox": [
+            174,
+            607,
+            825,
+            786
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2 Related work ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            809,
+            316,
+            825
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Distribution shift has been studied under a number of frameworks $\\pmb { \\mathbb { B } } 6 \\|$ , including domain adaptation [41, 6, 47], domain generalization [5, 32, 9], and distributionally robust optimization [4, 16, 39]. These frameworks typically leverage additional training or test assumptions in order to make the distribution shift problem more tractable. Largely separate from these frameworks, various empirical methods have also been proposed for dealing with shift, such as increasing the model and training dataset size or using heavy training augmentations [34, 51, 14]. The focus of this work is complementary to these efforts: MEMO is applicable to a wide range of pretrained models, including those trained via robustness methods, and can achieve further performance gains via test time adaptation. ",
+        "bbox": [
+            174,
+            842,
+            823,
+            911
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            176,
+            90,
+            823,
+            133
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Prior test time adaptation methods generally either make significant training or test time assumptions. Some methods update the model using batches or even entire datasets of test inputs, such as by computing batch normalization (BN) statistics on the test set [25, 19, 33, 40], computing class prototypes $\\mathbb { \\lVert \\rVert }$ , or minimizing the (conditional) entropy of model predictions across a batch of test data $\\lVert \\overline { { 4 6 } } \\rVert$ . The latter approach is closely related to MEMO. The differences are that MEMO minimizes marginal entropy using single test points and data augmentation and adapts all of the model parameters rather than just those associated with normalization layers, thus not requiring multiple test points or specific model architectures. Other test time adaptation methods can be applied to single test points but require specific training procedures or models [44, 17, 40, 1, 3]. Test time training (TTT) $\\underline { { \\lVert \\varPsi \\ 4 \\rVert } }$ requires a specialized model with a rotation prediction head and a different procedure for training this model. Schneider et al. [40] show that BN adaptation can be effective even with only one test point. As we discuss in Section 3, MEMO synergizes well with this technique of “single point” BN adaptation. Mao et al. [29] propose a test time adaptation method based on input perturbations for robustness to adversarial attacks. Concurrently with our work, Sivaprasad and Fleuret $\\mathbb { \\lVert \\rVert 3 \\rVert }$ propose a similar method for test time adaptation by encouraging invariance to data augmentations, and they test their method on the corrupted CIFAR and VisDA [35] datasets. ",
+        "bbox": [
+            174,
+            140,
+            825,
+            361
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "A number of works have noted that varying forms of strong data augmentation on the training set can improve the resulting model’s robustness [51, 13, 24, 14]. Data augmentations are also sometimes used on the test data directly by averaging the model’s outputs across augmented copies of the test point $\\mathbb { \\left| \\overline { { 2 3 } } \\right| \\overline { { \\sharp 2 } } }$ , i.e., predicting according to the model’s marginal output distribution. When using cropping as the augmentation, this technique is often referred to as multicrop evaluation $\\pmb { \\mathbb { Z } } 2 \\mathbf { l }$ . We instead use the term test time augmentation (TTA), as we use additional augmentations beyond cropping $\\mathbb { \\lVert \\lambda \\rVert }$ . TTA has been shown to be useful both for improving model accuracy and calibration $\\pmb { \\left. 2 \\right. }$ as well as handling distribution shift [31]. We take this idea one step further by explicitly adapting the model such that its marginal output distribution has low entropy. This extracts an additional learning signal for improving the model, and furthermore, the adapted model can then make its final prediction on the clean test point rather than the augmented copies. We empirically show in Section 4 that these differences lead to improved performance over this non adaptive TTA baseline. ",
+        "bbox": [
+            173,
+            367,
+            825,
+            532
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3 Augmenting and Adapting at Test Time ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            554,
+            534,
+            571
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Data augmentations are typically used to train the model to respect certain invariances – e.g., changes in lighting or viewpoint do not change the underlying class label – but, especially when faced with distribution shift, the model is not guaranteed to obey the same invariances at test time. In this section, we introduce MEMO, a method for test time robustness that adapts the model such that it respects these invariances on the test input. We use “test time robustness” specifically to refer to techniques that operate directly on pretrained models and single test inputs – single point BN adaptation and TTA, as described in $\\overline { { \\mathsf { S e c t i o n 2 } } }$ are examples of prior test time robustness methods. ",
+        "bbox": [
+            173,
+            587,
+            825,
+            684
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "In the test time robustness setting, we are given a trained model $f _ { \\theta }$ with parameters $\\theta \\in \\Theta$ . We do not require any special training procedure and do not make any assumptions about the model, except that $\\theta$ is adaptable and that $f _ { \\theta }$ produces a conditional output distribution $p _ { \\boldsymbol { \\theta } } ( y | \\mathbf { x } )$ that is differentiable with respect to $\\theta . ^ { 1 }$ All standard deep neural network models satisfy these assumptions. A single point $\\mathbf { x } \\in \\mathcal { X }$ is presented to $f _ { \\theta }$ , for which it must predict a label $\\hat { y } \\in \\mathcal { V }$ immediately. Note that this is precisely identical to the standard test time inference procedure for regular supervised learning models – in effect, we are simply modifying how inference is done, without any additional assumptions on the training process or on test time data availability. This makes test time robustness methods a simple “slot-in” replacement for the ubiquitous and standard test time inference process. We assume sampling access to a set of augmentation functions $\\mathcal { A } \\triangleq \\{ a _ { 1 } , \\ldots , a _ { M } \\}$ that can be applied to the test point $\\mathbf { x }$ . We use these augmentations and the self-supervised objective detailed below to adapt the model before it predicts on $\\mathbf { x }$ . When given a set of test inputs, the model adapts and predicts on each test point independently. We do not assume access to any ground truth labels. ",
+        "bbox": [
+            173,
+            689,
+            825,
+            871
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Require: trained model $f _ { \\theta }$ , test point $\\mathbf { x }$ , number of augmentations $B$ , learning rate $\\eta$ , update rule $G$   \n1: Sample $a _ { 1 } , \\dots , a _ { B } \\overset { \\mathrm { i . i . d . } } { \\sim } \\mathcal { U } ( A )$ and produce augmented points $\\tilde { \\mathbf { x } } _ { i } = a _ { i } ( \\mathbf { x } )$ for $i \\in \\{ 1 , \\ldots , B \\}$   \n2: Compute estimate $\\begin{array} { r } { \\tilde { p } = \\frac { 1 } { B } \\sum _ { i = 1 } ^ { B } p _ { \\theta } ( y | \\tilde { \\mathbf { x } } _ { i } ) \\approx \\bar { p } _ { \\theta } ( y | \\mathbf { x } ) } \\end{array}$ and $\\tilde { \\ell } = H ( \\tilde { p } ) \\approx \\ell ( \\theta ; { \\mathbf x } )$ , i.e., Eq. 2   \n3: Adapt parameters via update rule $\\theta ^ { \\prime }  G ( \\theta , \\eta , \\tilde { \\ell } )$   \n4: Predict $\\hat { y } \\triangleq \\arg \\operatorname* { m a x } _ { y } p _ { \\theta ^ { \\prime } } ( y | \\mathbf { x } )$ ",
+        "bbox": [
+            178,
+            111,
+            821,
+            196
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3.1 Marginal Entropy Minimization with One test point ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            222,
+            575,
+            238
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Given a test point $\\mathbf { x }$ and set of augmentation functions $\\mathcal { A }$ , we sample $B$ augmentations from $\\mathcal { A }$ and apply them to $\\mathbf { x }$ in order to produce a batch of augmented data $\\tilde { \\mathbf { x } } _ { 1 } , \\ldots , \\tilde { \\mathbf { x } } _ { B }$ . The model’s average, or marginal, output distribution with respect to the augmented points is given by ",
+        "bbox": [
+            174,
+            247,
+            825,
+            290
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/167b4ea9af7ac8b59f113a9ace265ae53c53372b280892f06b1650ed3db85e40.jpg",
+        "text": "$$\n\\bar { p } _ { \\theta } ( y | \\mathbf { x } ) \\triangleq \\mathbb { E } _ { \\mathcal { U } ( \\mathcal { A } ) } \\left[ p _ { \\theta } ( y | a ( \\mathbf { x } ) ) \\right] \\approx \\frac { 1 } { B } \\sum _ { i = 1 } ^ { B } p _ { \\theta } ( y | \\tilde { \\mathbf { x } } _ { i } ) ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            330,
+            292,
+            665,
+            337
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "where the expectation is with respect to uniformly sampled augmentations $a \\sim \\mathcal { U } ( A )$ . ",
+        "bbox": [
+            171,
+            339,
+            736,
+            354
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "What properties do we desire from this marginal distribution? To answer this question, consider the role that data augmentation typically serves during training. For each training point $\\left( { \\bf x } ^ { \\mathrm { t r a i n } } , y ^ { \\mathrm { t r a i n } } \\right)$ , the model $f _ { \\theta }$ is trained using multiple augmented forms of the input $\\tilde { \\mathbf { x } } _ { 1 } ^ { \\mathrm { t r a i n } } , \\ldots , \\tilde { \\mathbf { x } } _ { E } ^ { \\mathrm { t r a i n } }$ . $f$ is trained to obey the invariances between the augmentations and the label – no matter the augmentation on $\\mathbf { x } ^ { \\mathrm { t r a i n } }$ , $f$ should predict, with confidence, the same label $y ^ { \\mathrm { t r a i n } }$ . We seek to devise a similar learning signal during test time, without any ground truth labels. That is, after adapting: ",
+        "bbox": [
+            173,
+            359,
+            825,
+            446
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "(1) the model $f _ { \\theta }$ predictions should be invariant across augmented versions of the test point, and (2) the model $f _ { \\theta }$ should be confident in its predictions, even for heavily augmented versions of the test point, since all versions have the same underlying label. ",
+        "bbox": [
+            174,
+            454,
+            825,
+            500
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Optimizing the model for more confident predictions can be justified from the assumption that the true underlying decision boundaries between classes lie in low density regions of the data space $\\textcircled { 8 }$ . With these two goals in mind, we propose to adapt the model using the entropy of its marginal output distribution over augmentations $\\underline { { \\operatorname { d } \\dot { \\operatorname { E q . } } \\dot { 1 } ) } }$ , i.e., ",
+        "bbox": [
+            174,
+            508,
+            825,
+            565
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/38f79de4ec6d2f88467dca608625ef272a52c1153d3c21d395cadf8ac6b9fefe.jpg",
+        "text": "$$\n\\ell ( \\theta ; \\mathbf { x } ) \\triangleq H \\left( \\bar { p } _ { \\theta } ( \\cdot | \\mathbf { x } ) \\right) = - \\sum _ { y \\in \\mathcal { Y } } \\bar { p } _ { \\theta } ( y | \\mathbf { x } ) \\log \\bar { p } _ { \\theta } ( y | \\mathbf { x } ) .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            323,
+            568,
+            673,
+            603
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Note that this objective is not the same as optimizing the average conditional entropy of the model’s predictive distributions across augmentations, i.e., ",
+        "bbox": [
+            174,
+            606,
+            821,
+            635
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/0bc73768db961d265fc945815923b2331129333602064c177dfa5e006862b3f8.jpg",
+        "text": "$$\n\\ell _ { \\mathrm { { C E } } } ( \\boldsymbol { \\theta } ; \\mathbf { x } ) \\triangleq \\frac { 1 } { B } \\sum _ { i = 1 } ^ { B } H ( p _ { \\boldsymbol { \\theta } } ( \\cdot | \\widetilde { \\mathbf { x } } _ { i } ) ) .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            388,
+            637,
+            609,
+            681
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "A model which predicts confidently but differently across augmentations would minimize $\\operatorname { E q . 3 }$ but not $\\boxed { \\mathrm { E q . ~ } 2 }$ Optimizing $\\operatorname { E q } . 2$ encourages both confidence and invariance, since the entropy of $\\bar { p } _ { \\theta } ( \\cdot | \\mathbf { x } )$ is minimized when the model outputs the same (confident) prediction regardless of the augmentation. ",
+        "bbox": [
+            173,
+            683,
+            825,
+            724
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Algorithm 1 presents the overall method MEMO for test time adaptation. Though prior test time adaptation methods must carefully choose which parameters to adapt in order to avoid degenerate solutions $\\lVert \\overline { { 4 6 } } \\rVert$ , our adaptation procedure simply adapts all of the model’s parameters $\\theta$ (line 3). Given that $p _ { \\boldsymbol { \\theta } } ( \\boldsymbol { y } | \\mathbf { x } )$ is differentiable with respect to $\\theta$ , we can directly use gradient based optimization to adapt $\\theta$ according to $\\mathbb { E } { \\mathsf { q } } . 2 \\mathbb { Z }$ We use only one gradient step per test point, because empirically we found this to be sufficient for improved performance while being more computationally efficient. After this step, we use the adapted model $f _ { \\theta ^ { \\prime } }$ to predict on the original test input $\\mathbf { x }$ (line 4). ",
+        "bbox": [
+            173,
+            731,
+            825,
+            829
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3.2 Composing MEMO with Prior Methods ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            843,
+            491,
+            859
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "An additional benefit of MEMO is that it synergizes with other approaches for handling distribution shift. In particular, MEMO can be composed with prior methods for training robust models and adapting model statistics, thus leveraging the performance improvements of each technique. ",
+        "bbox": [
+            174,
+            868,
+            825,
+            911
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "image",
+        "img_path": "images/6ecb312275c8b833a76347f6c7ba3d2b80f52b0b71a12da6610da54a844f0e30.jpg",
+        "image_caption": [
+            "Figure 2: We visualize augmentations of a randomly chosen data point from the “Gaussian Noise level 3” ImageNet-C test set. Even for a robust model trained with heavy data augmentations [14], both its predictive accuracy and confidence (as shown in the top two rows) drop sharply when encountering test shift. As shown in the bottom two rows, these drops can be remedied via MEMO adaptation. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            222,
+            90,
+            774,
+            401
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Pretrained robust models. Since MEMO makes no assumptions about, or modifications to, the model training procedure, performing adaptation on top of pretrained robust models, such as those trained with heavy data augmentations, is as simple as using any other pretrained model. Crucially, we find that, in practice, the set of test augmentations $\\mathcal { A }$ does not have to match the augmentations that were used to train the model. For simplicity and efficiency, we use augmentations that can be easily sampled and are applied directly to the model input x. These properties do not hold for, e.g., data augmentation techniques based on image translation models, such as DeepAugment $\\textcircled { 1 1 4 } \\textcircled { 1 }$ , or feature mixing, such as moment exchange $\\checkmark$ . However, we can still use models trained with these data augmentation techniques as our starting point for adaptation, thus allowing us to improve upon their state-of-the-art results. As noted above, using pretrained models is not as easily accomplished for adaptation methods which require complicated or specialized training procedures and model architectures, such as TTT $\\mathbb { H } 4 4 \\mathbb { I }$ or ARM $[ \\bar { 1 } \\bar { 5 } 2 ]$ . In our experiments, we use AugMix as our set of augmentations $\\mathbb { \\lVert \\rVert 3 \\rVert }$ , as it satisfies the above properties and still yields significant diversity when applied, as depicted in $\\mathbb { F i g u r e 2 } $ Note that AugMix explicitly does not use augmentations that are similar to the corruptions in the CIFAR-10-C and ImageNet-C test sets [12, 13]. ",
+        "bbox": [
+            174,
+            489,
+            825,
+            698
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Adapting BN statistics. Schneider et al. $\\mathbb { \\left[ \\left. 4 0 \\right] \\right. }$ showed that, even when presented with just a single test point, partially adapting the estimated mean and variance of the activations in each batch normalization (BN) layer of the model can still be effective in some cases for handling distribution shift. In this setting, to prevent overfitting to the test point, the channelwise mean and variance $[ \\mu _ { \\mathrm { t e s t } } , \\sigma _ { \\mathrm { t e s t } } ^ { 2 } ]$ estimated from this point are mixed with the the mean and variance $[ \\mu _ { \\mathrm { t r a i n } } , \\sigma _ { \\mathrm { t r a i n } } ^ { 2 } ]$ computed during training according to a prior strength $N$ . That is, for $\\pmb { \\nu } \\in \\{ \\mu , \\sigma ^ { 2 } \\}$ , ",
+        "bbox": [
+            173,
+            712,
+            825,
+            796
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/cfb84e51768d4e96146e48039f127d2a083113d56b9205f05892affb31cf0c42.jpg",
+        "text": "$$\n\\pmb { \\nu } \\triangleq \\frac { N } { N + 1 } \\pmb { \\nu } _ { \\mathrm { t r a i n } } + \\frac { 1 } { N + 1 } \\pmb { \\nu } _ { \\mathrm { t e s t } } .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            392,
+            803,
+            606,
+            835
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "This technique is also straightforward to combine with MEMO: we simply use the adapted BN statistics whenever computing the model’s output distribution. We find in our experiments that this technique never degrades, and generally improves, the performance of test time adaptation, thus we combine MEMO with this technique by default whenever applicable. Following the suggestion in Schneider et al. $\\mathbb { \\left[ \\left| 4 0 \\right| \\right] }$ , we set $N = 1 6$ for all of our experiments in the next section. ",
+        "bbox": [
+            174,
+            842,
+            825,
+            911
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "4 Experiments ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            89,
+            312,
+            107
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Our experiments aim to answer the following questions: ",
+        "bbox": [
+            173,
+            121,
+            542,
+            136
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "(1) How does MEMO compare to prior methods for test time adaptation and test time robustness? (2) Can MEMO be combined with a wide range of model architectures and pretraining methods? (3) Which aspect of MEMO, the adaptation or augmentation, is the most important? ",
+        "bbox": [
+            173,
+            146,
+            818,
+            195
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "We evaluate MEMO on a total of five distribution shift benchmarks. We conduct CIFAR-10 [22] experiments on the CIFAR-10-C [12] and CIFAR-10.1 [37] test sets, and we conduct ImageNet [38] experiments on the ImageNet-C [12], ImageNet-R [14], and ImageNet-A [15] test sets. ",
+        "bbox": [
+            173,
+            205,
+            823,
+            248
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "To answer question (1), we compare to test time training (TTT) [44] in the CIFAR-10 experiments, for which we train ResNet-26 models following their protocol and specialized architecture. We do not compare to TTT for the ImageNet experiments due to the computational demands of training state-of-the-art models and because Sun et al. [44] do not report competitive ImageNet results. For the ImageNet experiments, we compare to Tent $[ \\overline { { | 4 6 | } }$ and BN adaptation, which can be used with pretrained models but require multiple test inputs (or even the entire test set) for adaptation. We provide BN adaptation with 256 test inputs at a time and set the prior strength $N = 2 5 6$ [40]. ",
+        "bbox": [
+            173,
+            253,
+            825,
+            352
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "For Tent, we use test batch sizes of 64 and, for ResNet-50 models, test both “online” adaptation – where the model adapts continually through the entire evaluation – and “episodic” adaptation – where the model is reset after each test batch $\\overline { { \\lVert \\textcircled { 4 6 } \\rVert } }$ . Note that the evaluation protocols are different for these two methods: whereas MEMO is tasked with predicting on each test point immediately after adaptation, BN adaptation predicts on a batch of 256 test points after computing BN statistics on the batch, and Tent predicts on a batch of 64 inputs after adaptation but also, in the online setting, continually adapts throughout evaluation. In all experiments, we further compare to single point BN adaptation $\\mathbb { \\left[ \\left| 4 0 \\right| \\right] }$ and the TTA baseline that simply predicts according to $\\bar { p } _ { \\boldsymbol { \\theta } } ( y | \\mathbf { \\bar { x } } )$ (Eq. 1) [23, 2]. Full details on our experimental protocol are provided in Appendix A. ",
+        "bbox": [
+            173,
+            357,
+            826,
+            483
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "To answer question (2), we apply MEMO on top of multiple pretrained models with different architectures, trained via several different procedures. For CIFAR-10, we train our own ResNet26 [11] models. For ImageNet, we use the best performing ResNet-50 robust models from prior work, which includes those trained with DeepAugment and AugMix augmentations $[ \\textcircled { 1 4 } ]$ as well as those trained with moment exchange and CutMix $\\pmb { \\Vert 2 4 \\Vert }$ . To evaluate the generality of prior test time robustness methods and MEMO, we also evaluate the small robust vision transformer $\\mathrm { R V T ^ { * } }$ -small), which provides superior performance on all three ImageNet distribution shift benchmarks compared to the robust ResNet-50 models $\\pmb { \\mathbb { B } } \\pmb { \\mathrm { 0 } }$ . Finally, we evaluate ResNext-101 models [50, 28] on ImageNet-A, as these models previously achieved the strongest results for this test set [14]. ",
+        "bbox": [
+            173,
+            488,
+            826,
+            613
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Finally, to answer (3), we conduct ablative studies in subsection 4.2: first to determine the relative importance of maximizing confidence (via entropy minimization) versus enforcing invariant predictions across augmented copies of each test point, second to determine the importance of the particular augmentation functions used, and third to determine the required number of augmented samples per inference. The comparison to the non adaptive TTA baseline also helps determine whether simply augmenting the test point is sufficient or if adaptation is additionally helpful. In Appendix B, we provide further experiments ablating the augmentation component specifically. ",
+        "bbox": [
+            174,
+            619,
+            825,
+            717
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "4.1 Main Results ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            733,
+            305,
+            748
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "We summarize results for CIFAR-10, CIFAR-10.1, and CIFAR-10-C in Table 1, with full CIFAR-10- C results in Appendix C. We use indentations to indicate composition, e.g., TTT is performed at test time on top of their specialized joint training procedure. Across all corruption types in CIFAR-10-C, MEMO consistently improves test error compared to the baselines, non adaptive TTA, and TTT. MEMO also provides a larger performance gain on CIFAR-10.1 compared to TTT. We find that the non adaptive TTA baseline is competitive for these relatively simple test sets, though it is worse than MEMO for CIFAR-10-C. Of these three test sets, CIFAR-10-C is the only benchmark that explicitly introduces distribution shift, which suggests that adaptation is useful when the test shifts are more prominent. Both TTA and MEMO are also effective at improving performance for the original CIFAR-10 test set where there is no distribution shift, providing further support for the widespread use of augmentations in standard evaluation protocols [23, 2]. ",
+        "bbox": [
+            174,
+            758,
+            825,
+            911
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "table",
+        "img_path": "images/99bfc676c738ea68f9e9adb000a8e2a91411abcf23411fafa5eed399df4a27ad.jpg",
+        "table_caption": [
+            "Table 1: Results for CIFAR-10, CIFAR-10.1, and CIFAR-10-C. ?Results from Sun et al. [44]. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td></td><td>CIFAR-10 Error (%)</td><td>CIFAR-10.1 Error (%)</td><td>CIFAR-10-C Average Error (%)</td></tr><tr><td>ResNet-26 □</td><td>9.2</td><td>18.4</td><td>22.5</td></tr><tr><td>+TTA</td><td>7.3 (-1.9)</td><td>14.8 (-3.6)</td><td>19.9 (-2.6)</td></tr><tr><td>+ MEMO (ours)</td><td>7.3 (-1.9)</td><td>14.7 (-3.7)</td><td>19.6 (-2.9)</td></tr><tr><td>+ Joint training* 国</td><td>8.1</td><td>16.7</td><td>22.8</td></tr><tr><td>+ TTT* 因</td><td>7.9 (-0.2)</td><td>15.9 (-0.8)</td><td>21.5 (-1.3)</td></tr></table>",
+        "bbox": [
+            251,
+            111,
+            745,
+            226
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "table",
+        "img_path": "images/e3fb13207ebb1acc9e6ea8271f8ca42c7bfd611354282adb61042ad553128b29.jpg",
+        "table_caption": [
+            "Table 2: Test results for the ImageNet test sets. MEMO achieves new state-of-the-art performance on each benchmark for ResNet-50 models for the single test point setting. For $\\mathbf { R V T ^ { * } }$ -small, MEMO improves performance across all benchmarks and reaches a new state of the art for ImageNet-C and ImageNet-R. Compared to prior approaches, MEMO offers more consistent improvements. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td></td><td>ImageNet-C mCE↓</td><td>ImageNet-R Error (%)</td><td>ImageNet-A Error (%)</td></tr><tr><td>Baseline ResNet-50 自</td><td>76.7</td><td>63.9</td><td>100.0</td></tr><tr><td>+ TTA</td><td>77.9 (+1.2)</td><td>61.3 (-2.6)</td><td>98.4 (-1.6)</td></tr><tr><td>+ Single point BN</td><td>71.4 (-5.3)</td><td>61.1 (-2.8)</td><td>99.4 (-0.6)</td></tr><tr><td>+ MEMO (ours)</td><td>69.9 (-6.8)</td><td>58.8 (-5.1)</td><td>99.1 (-0.9)</td></tr><tr><td>+ BN (N = 256,n = 256)</td><td>61.6 (-15.1)</td><td>59.7 (-4.2)</td><td>99.8 3(-0.2)</td></tr><tr><td>+ Tent (online) [ 46</td><td>54.4 (−22.3)</td><td>57.7 (-6.2)</td><td>99.8 (-0.2)</td></tr><tr><td>+ Tent (episodic)</td><td>64.7 (−12.0)</td><td>61.0 (-2.9)</td><td>99.7 ( (-0.3)</td></tr><tr><td> + DeepAugment+AugMix [14]</td><td>53.6</td><td>53.2</td><td>96.1</td></tr><tr><td>+ TTA</td><td>55.2 (+1.6)</td><td>51.0 (-2.2)</td><td>93.5 (-2.6)</td></tr><tr><td>+ Single point BN</td><td>51.3 (-2.3)</td><td>51.2 (-2.0)</td><td>95.4 (-0.7)</td></tr><tr><td>+ MEMO (ours)</td><td>49.8 (-3.8)</td><td>49.2 (-4.0)</td><td>94.8 (-1.3)</td></tr><tr><td>+ BN(N = 256,n = 256)</td><td>45.4 (−8.2)</td><td>48.8 (-4.4)</td><td>96.8 (+0.7)</td></tr><tr><td>+ Tent (online)</td><td>43.5 (-10.1)</td><td>46.9 (-6.3)</td><td>96.7 (+0.6)</td></tr><tr><td> + Tent (episodic)</td><td>47.1 (-6.5)</td><td>50.1 (-3.1)</td><td>96.6 (+0.5)</td></tr><tr><td>+ MoEx+CutMix 2</td><td>74.8</td><td>64.5</td><td>91.9</td></tr><tr><td>+ TTA</td><td>75.7 (+0.9)</td><td>62.7 (-1.8)</td><td>89.5 (-2.4)</td></tr><tr><td>+ Single point BN</td><td>71.0 (-3.8)</td><td>62.6 (−1.9)</td><td>91.1 (-0.8)</td></tr><tr><td>+ MEMO (ours)</td><td>69.1 (-5.7)</td><td>59.4 (-3.3)</td><td>89.0 (-2.9)</td></tr><tr><td>+ BN (N = 256,n = 256)</td><td>60.9 (-13.9)</td><td>61.6 (-2.9)</td><td>93.9 (+2.0)</td></tr><tr><td>+ Tent (online)</td><td>54.0 (-20.8)</td><td>58.7 (-5.8)</td><td>94.4 (+2.5)</td></tr><tr><td>+ Tent (episodic)</td><td>66.2 (-8.6)</td><td>63.9 (-0.6)</td><td>94.7 (+2.8)</td></tr><tr><td>RVT*-small □</td><td>49.4</td><td>52.3</td><td>73.9</td></tr><tr><td>+ TTA</td><td>53.0 (+3.6)</td><td>49.0 (-3.3)</td><td>68.9 (-5.0)</td></tr><tr><td>+ Single point BN</td><td>48.0 (-1.4)</td><td>51.1 (-1.2)</td><td>74.4 (+0.5)</td></tr><tr><td>+ MEMO (ours)</td><td>40.6 (-8.8)</td><td>43.8 (-8.5)</td><td>69.8 (-4.1)</td></tr><tr><td>+ BN (N = 256,n = 256)</td><td>44.3 (-5.1)</td><td>51.0 ( (-1.3)</td><td>78.3 (+4.4)</td></tr><tr><td>+ Tent (online)</td><td>46.8 (-2.6)</td><td> 50.7 (-1.6)</td><td>82.1 (+8.2)</td></tr><tr><td>+ Tent (adapt all)</td><td>44.7 (-4.7)</td><td>74.1 (+21.8)</td><td>81.1 (+7.2)</td></tr></table>",
+        "bbox": [
+            232,
+            305,
+            766,
+            743
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "We summarize results for ImageNet-C, ImageNet-R, and ImageNet-A in Table 2, with complete ImageNet-C results in $\\boxed { \\mathrm { A p p e n d i x ~ C } }$ We again use indentations to indicate composition, e.g., the best results on ImageNet-C for our setting are attained through a combination of starting from a model trained with DeepAugment and AugMix [14] and using MEMO on top. For both ImageNet-C and ImageNet-R, and for both the ResNet-50 and $\\mathbf { R V T ^ { * } }$ -small models, combining MEMO with robust training techniques leads to new state-of-the-art performance among methods that observe only one test point at a time. We highlight in gray the methods that require multiple test points for adaptation, and we list in bold the best results from these methods which outperform the test time robustness methods. As Table 2 and prior work both show [40, 46], accessing multiple test points can be powerful for benchmarks such as ImageNet-C and ImageNet-R, in which inferred statistics from the test input distribution may aid in prediction. However, these methods do not help, and oftentimes even hurt, for ImageNet-A. Furthermore, we find that these methods are less effective with the $\\mathrm { R V T ^ { * } }$ -small model, which may indicate their sensitivity to model architecture choices. Therefore, for this model, we also test a modification of Tent which adapts all parameters, and we find that this version of Tent works better for ImageNet-C but is significantly worse for ImageNet-R. ",
+        "bbox": [
+            173,
+            772,
+            825,
+            911
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            90,
+            825,
+            161
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "MEMO also results in substantial improvement for ImageNet-A. No prior test time adaptation methods have reported improvements on ImageNet-A, and some have reported explicit negative results $\\mathbb { H O }$ . As discussed, it is reasonable for adaptation methods that rely on multiple test points to achieve greater success on other benchmarks such as ImageNet-C, in which a batch of inputs provides significant information about the specific corruption that must be dealt with. In contrast, ImageNet-A does not have such obvious characteristics associated with the input distribution, as it is simply a collection of images that are difficult to classify. As MEMO instead extracts a learning signal from single test points, it is, to the best of our knowledge, the first test time adaptation method to report successful results on this testbed. We view the consistency with which MEMO outperforms the best prior methods, which change across different test sets, as a major advantage of the proposed method. ",
+        "bbox": [
+            173,
+            166,
+            825,
+            305
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "TTA is the most competitive prior method for ImageNet-A, e.g., it results in larger improvements than MEMO for the $\\mathbf { R V T ^ { * } }$ -small model. MEMO, however, achieves state-of-the-art performance among ResNet-50 models. To further compare MEMO to TTA, in Table 3, we evaluate whether MEMO can successfully adapt ResNext-101 models $ { \\Vert 5 0 \\Vert }$ and further improve performance on this challenging test set. We evaluate both a ResNext-101 (32x8d) baseline model pretrained on ImageNet, as well as the same model pretrained with weakly supervised learning (WSL) on billions of Instagram images $\\bar { \\left\\| 2 8 \\right\\| }$ . For the ",
+        "bbox": [
+            174,
+            313,
+            452,
+            518
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "table",
+        "img_path": "images/671d04f0f19b60ee1e6184c559481acaa2c5d29217b4118973764c1bb3859200.jpg",
+        "table_caption": [
+            "Table 3: ImageNet-A results for the ResNext-101s. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td colspan=\"2\">ImageNet-A Error (%)</td></tr><tr><td>ResNext-101 ⑤0</td><td>90.0</td></tr><tr><td>+ TTA</td><td>83.2 (-6.8)</td></tr><tr><td>+ Single point BN</td><td>88.8 (-1.2)</td></tr><tr><td>+ MEMO (ours)</td><td>84.3 (-5.7)</td></tr><tr><td>+ WSL [28]</td><td>54.9</td></tr><tr><td>+ TTA</td><td>49.1 (-5.8)</td></tr><tr><td>+ Single point BN</td><td>58.9 (+4.0)</td></tr><tr><td>+ MEMO (ours)</td><td>43.2 (−11.7)</td></tr></table>",
+        "bbox": [
+            480,
+            353,
+            808,
+            493
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "WSL model, we did not use single point BN adaptation for MEMO as we found this technique to be actually harmful to performance, and this corroborates previous findings $\\mathbb { H O }$ . From the results, we can see that, although both TTA and MEMO significantly improve upon the baseline model evaluation, MEMO ultimately achieves the best accuracy by a significant margin as it is more successful at adapting the WSL model. This suggests that MEMO may synergize well with large scale pretraining, and further exploring this combination is an interesting direction for future work. ",
+        "bbox": [
+            174,
+            518,
+            826,
+            602
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "4.2 Ablative Study ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            619,
+            315,
+            633
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "MEMO uses both adaptation and augmentations. In this section, we ablate the adaptation procedure and the number of augmentations, and in Appendix B we ablate the choice of augmentations. ",
+        "bbox": [
+            174,
+            645,
+            823,
+            675
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Adaptation procedure. From the results above, we conclude that adaptation generally provides additional benefits beyond simply using TTA to predict via the marginal output distribution $\\bar { p } _ { \\boldsymbol { \\theta } } ( y | \\mathbf { x } )$ . However, we can disentangle two distinct self-supervised learning signals that may be effective for adaptation: encouraging invariant predictions across different augmentations of the test point, and encouraging confidence via entropy minimization. The marginal entropy objective in $\\operatorname { \\bar { E } q } . 2$ encapsulates both of these learning signals, but it cannot easily be decomposed into these pieces. We instead use two ablative adaptation methods that each only make use of one of these learning signals. ",
+        "bbox": [
+            174,
+            690,
+            826,
+            787
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "First, we consider optimizing the pairwise cross entropy between each pair of augmented points, i.e., ",
+        "bbox": [
+            173,
+            792,
+            825,
+            809
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "equation",
+        "img_path": "images/4e2f2d61b5960a73253a81a87246f66cccb9fcc83b8277866bf56c097a3590e3.jpg",
+        "text": "$$\n\\ell _ { \\mathrm { P C E } } ( \\boldsymbol { \\theta } ; \\mathbf { x } ) \\triangleq \\frac { 1 } { B \\times ( B - 1 ) } \\sum _ { i = 1 } ^ { B } \\sum _ { j \\neq i } H ( p _ { \\boldsymbol { \\theta } } ( \\cdot | \\widetilde { \\mathbf { x } } _ { i } ) , p _ { \\boldsymbol { \\theta } } ( \\cdot | \\widetilde { \\mathbf { x } } _ { j } ) ) ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            305,
+            815,
+            691,
+            862
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Where $\\tilde { \\mathbf { x } } _ { i }$ again refers to the $i$ -th sampled augmentation applied to $\\mathbf { x }$ . Intuitively, this loss function encourages the model to adapt such that it produces the same predictive distribution for all augmentations of the test point, but it does not encourage the model to produce confident predictions. ",
+        "bbox": [
+            176,
+            869,
+            825,
+            911
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "table",
+        "img_path": "images/42bf0790beea96abab2d0fb609dac6b3c3e1e406494824382177df686e95f8f7.jpg",
+        "table_caption": [
+            "Table 4: Ablating the adaptation objective to test pairwise cross entropy and conditional entropy (CE) based adaptation. MEMO generally performs the best, indicating that both encouraging invariance across augmentations and confidence are helpful in adapting the model. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td></td><td>CIFAR-10 Error (%)</td><td>CIFAR-10.1 Error (%)</td><td>CIFAR-10-C Average Error (%)</td></tr><tr><td>ResNet-26 []</td><td>9.2</td><td>18.4</td><td>22.5</td></tr><tr><td>+ MEMO (ours)</td><td>7.3 (-1.9)</td><td>14.7 (-3.7)</td><td>19.6 (-2.9)</td></tr><tr><td>l (Eq. 2) ）+lPCE 一</td><td>7.6 (-1.6)</td><td>15.3 (-3.1)</td><td>20.0 (-2.5)</td></tr><tr><td>Eq.2) + lcE</td><td>7.6 (-1.6)</td><td>14.7 (-3.7)</td><td>20.0 (-2.5)</td></tr><tr><td></td><td>ImageNet-C mCE↓</td><td>ImageNet-R Error (%)</td><td>ImageNet-A Error (%)</td></tr><tr><td>RVT*-small [30]</td><td>49.4</td><td>52.3</td><td>73.9</td></tr><tr><td>+ MEMO (ours)</td><td>40.6 (-8.8)</td><td>43.8 (-8.5)</td><td>69.8 (-4.1)</td></tr><tr><td>-l (Eq. 2) + lcE</td><td>41.2 (-8.2)</td><td>44.2 (−8.1)</td><td>69.7 (-4.2)</td></tr></table>",
+        "bbox": [
+            240,
+            140,
+            756,
+            320
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "image",
+        "img_path": "images/5eaa7e18247da47c2425c9985f500a9780838964f166482db468111dd95d274c.jpg",
+        "image_caption": [
+            "Figure 3: Plotting MEMO efficiency as seconds per evaluation $\\mathbf { \\dot { x } }$ axis) and $\\%$ test error on ImageNet-R (y axis) for the ResNet-50 models (left) and $\\mathrm { R V T ^ { * } }$ -small (right) while varying $B = \\{ 1 , 2 , 4 , 8 , 1 6 , 3 2 , 6 4 , 1 2 8 \\}$ . Note the log scale on the $\\mathbf { X }$ axis. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            176,
+            338,
+            820,
+            523
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Conversely, as an objective that encourages confidence but not invariance, we also consider optimizing the conditional entropy objective detailed in Eq. 3. This ablation is effectively a version of the episodic variant of Tent $[ \\overline { { | 4 6 | } }$ that produces augmented copies of a single test point rather than assuming access to a test batch. We first evaluate these ablations on the CIFAR-10 test sets. We use the same adaptation procedure and hyperparameters, with $\\ell$ replaced with the above objectives. ",
+        "bbox": [
+            174,
+            607,
+            825,
+            676
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "The results are presented in Table 4. We see that MEMO, i.e., marginal entropy minimization, generally performs better than adaptation with either of the alternative objectives. This supports the hypothesis that both invariance across, and confidence on, the augmentations are important learning signals for self-supervised adaptation. When faced with CIFAR-10.1, we see poor performance from the pairwise cross entropy based adaptation method. On the original CIFAR-10 test set and CIFAR-10- C, the ablations perform nearly identically and uniformly worse than MEMO. To further test the $\\ell _ { \\mathrm { C E } }$ ablation, which is the stronger of the two ablations, we also evaluate it on the ImageNet test sets for the $\\mathrm { R V T ^ { * } }$ -small model. We find that, similarly, minimizing conditional entropy generally improves performance compared to the baseline evaluation. MEMO is more performant for ImageNet-C and ImageNet-R. Adaptation via $\\ell _ { \\mathrm { C E } }$ performs slightly better for ImageNet-A, though for this problem and model, TTA is still the best method. Thus, MEMO results in relatively small, but consistent, performance gains compared to only maximizing confidence on the augmentations. ",
+        "bbox": [
+            173,
+            683,
+            825,
+            849
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Number of augmentations. In Figure 3, we analyze the $\\%$ test error of MEMO adaptation on ImageNet-R as a function of the efficiency of adaptation, measured in seconds per evaluation. We achieve various tradeoffs by varying the number of augmented copies $B \\ =$ $\\{ 1 , 2 , 4 , 8 , 1 6 , 3 2 , 6 4 , 1 2 8 \\}$ . We note that small values of $B$ such as 4 and 8 can already provide significant performance gains, thus a practical tradeoff between efficiency and accuracy is possible. ",
+        "bbox": [
+            174,
+            869,
+            825,
+            911
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            90,
+            823,
+            119
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "For large $B$ , the wall clock time is dominated by computing the augmentations. For the baseline ResNet-50 model, single point BN adaptation requires an average of 0.0252 seconds per test point. TTA and MEMO with $B = 6 4$ are much slower – 0.7742 and 0.9746 seconds, respectively, per test point – but can be made significantly more efficient by using $B = 4$ augmented samples – 0.0631 and 0.1037 seconds, respectively. In our implementation, we do not compute augmentations in parallel, though in principle this is possible for AugMix and should drastically improve efficiency overall. These experiments used four Intel Xeon Skylake 6130 CPUs and one NVIDIA TITAN RTX GPU. ",
+        "bbox": [
+            174,
+            126,
+            825,
+            223
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "5 Discussion ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            242,
+            292,
+            260
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "We presented MEMO, a method for test time robustification again distribution shift via adaptation and augmentation. MEMO does not require access or changes to the model training procedure and is thus broadly applicable for a wide range of model architectures pretrained in a number of different ways. Furthermore, MEMO adapts at test time using single test inputs, thus it does not assume access to multiple test points as in several recent methods for test time adaptation $\\mathbb { H O } \\mathbb { H } \\mathbb { H }$ . On a range of CIFAR-10 and ImageNet distribution shift benchmarks, and for ResNet, vision transformer, and, to an extent, ResNext models, MEMO consistently improves performance at test time and achieves several new state-of-the-art results for these models in the single test point setting. ",
+        "bbox": [
+            174,
+            273,
+            825,
+            386
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Inference via MEMO is more computationally expensive than standard model inference due to its augmentation and adaptation procedure – though, as the experiments above show, more favorable tradeoffs between efficiency and accuracy are possible with smaller values of $B$ , the number of augmentations per test point. One interesting direction for future work is to develop techniques for selectively determining when to adapt the model in order to achieve more efficient inference. For example, with well calibrated models $[ \\mathbb { 1 0 } ]$ , we may run simple “feedforward” inference when the prediction confidence is over a certain threshold, thus achieving better efficiency. Additionally, it would be interesting to explore MEMO in the test setting where the model is allowed to continually adapt as more test data is observed. In our preliminary experiments in this setting, MEMO tended to lead to degenerate solutions, e.g., the model predicting a constant label with maximal confidence regardless of the input. This failure mode may potentially be rectified by carefully choosing which parameters to adapt, such as only adapting the parameters in BN layers $\\boxed { \\boxplus 6 }$ , or regularizing the model such that it does not change too drastically from the pretrained model [26]. ",
+        "bbox": [
+            174,
+            392,
+            825,
+            571
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Acknowledgments and Disclosure of Funding ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            592,
+            553,
+            608
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "We thank members of the Robotic AI and Learning Lab and Berkeley AI Research for helpful discussions and feedback. MZ was supported in part by an NDSEG fellowship. CF is a CIFAR fellow. This research was partially supported by ARL DCIST CRA W911NF-17-2-0181 and ARO W911NF-21-1-0097. ",
+        "bbox": [
+            174,
+            623,
+            825,
+            679
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "References ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            700,
+            266,
+            715
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "[1] F. Alet, M. Bauza, K. Kawaguchi, N. Kuru, T. Lozano-Pérez, and L. Kaelbling. Tailoring: Encoding inductive biases by optimizing unsupervised objectives at prediction time. In Advances in Neural Information Processing Systems (NeurIPS), 2021.   \n[2] A. Ashukha, A. Lyzhov, D. Molchanov, and D. Vetrov. Pitfalls of in-domain uncertainty estimation and ensembling in deep learning. In International Conference on Learning Representations (ICLR), 2020.   \n[3] A. Bartler, A. Bühler, F. Wiewel, M. Döbler, and B. Yang. MT3: Meta test-time training for self-supervised test-time adaption. In International Conference on Artificial Intelligence and Statistics (AISTATS), 2022.   \n[4] A. Ben-Tal, D. den Hertog, A. De Waegenaere, B. Melenberg, and G. Rennen. Robust solutions of optimization problems affected by uncertain probabilities. Management Science, 2013. [5] G. Blanchard, G. Lee, and C. Scott. Generalizing from several related classification tasks to a new unlabeled sample. In Advances in Neural Information Processing Systems (NIPS), 2011. [6] G. Csurka. Domain adaptation for visual applications: A comprehensive survey. arXiv preprint arXiv:1702.05374, 2017. [7] A. Dosovitskiy, L. Beyer, A. Kolesnikov, D. Weissenborn, X. Zhai, T. Unterthiner, M. Dehghani, M. Minderer, G. Heigold, S. Gelly, J. Uszkoreit, and N. Houlsby. An image is worth 16x16 words: Transformers for image recognition at scale. In International Conference on Learning Representations (ICLR), 2021. [8] Y. Grandvalet and Y. Bengio. Semi-supervised learning by entropy minimization. In Advances in Neural Information Processing Systems (NIPS), 2005. [9] I. Gulrajani and D. Lopez-Paz. In search of lost domain generalization. In International Conference on Learning Representations (ICLR), 2021.   \n[10] C. Guo, G. Pleiss, Y. Sun, and K. Weinberger. On calibration of modern neural networks. In International Conference on Machine Learning (ICML), 2017.   \n[11] K. He, X. Zhang, S. Ren, and J. Sun. Deep residual learning for image recognition. In Conference on Computer Vision and Pattern Recognition (CVPR), 2016.   \n[12] D. Hendrycks and T. Dietterich. Benchmarking neural network robustness to common corruptions and perturbations. In International Conference on Learning Representations (ICLR), 2019.   \n[13] D. Hendrycks, N. Mu, E. Cubuk, B. Zoph, J. Gilmer, and B. Lakshminarayanan. AugMix: A simple data processing method to improve robustness and uncertainty. In International Conference on Learning Representations (ICLR), 2020.   \n[14] D. Hendrycks, S. Basart, N. Mu, S. Kadavath, F. Wang, E. Dorundo, R. Desai, T. Zhu, S. Parajuli, M. Guo, D. Song, J. Steinhardt, and J. Gilmer. The many faces of robustness: A critical analysis of out-of-distribution generalization. In IEEE International Conference on Computer Vision (ICCV), 2021.   \n[15] D. Hendrycks, K. Zhao, S. Basart, J. Steinhardt, and D. Song. Natural adversarial examples. In Conference on Computer Vision and Pattern Recognition (CVPR), 2021.   \n[16] W. Hu, G. Niu, I. Sato, and M. Sugiyama. Does distributionally robust supervised learning give robust classifiers? In International Conference on Machine Learning (ICML), 2018.   \n[17] Y. Huang, J. Gornet, S. Dai, Z. Yu, T. Nguyen, D. Tsao, and A. Anandkumar. Neural networks with recurrent generative feedback. In Advances in Neural Information Processing Systems (NeurIPS), 2020.   \n[18] Y. Iwasawa and Y. Matsuo. Test-time classifier adjustment module for model-agnostic domain generalization. In Advances in Neural Information Processing Systems (NeurIPS), 2021.   \n[19] A. Kaku, S. Mohan, A. Parnandi, H. Schambra, and C. Fernandez-Granda. Be like water: Robustness to extraneous variables via adaptive feature normalization. arXiv preprint arXiv:2002.04019, 2020.   \n[20] D. Kingma and J. Ba. Adam: A method for stochastic optimization. In International Conference on Learning Representations (ICLR), 2015.   \n[21] P. Koh, S. Sagawa, H. Marklund, S. Xie, M. Zhang, A. Balsubramani, W. Hu, M. Yasunaga, R. Phillips, I. Gao, T. Lee, E. David, I. Stavness, W. Guo, B. Earnshaw, I. Haque, S. Beery, J. Leskovec, A. Kundaje, E. Pierson, S. Levine, C. Finn, and P. Liang. WILDS: A benchmark of in-the-wild distribution shifts. In International Conference on Machine Learning (ICML), 2021.   \n[22] A. Krizhevsky. Learning multiple layers of features from tiny images. Technical report, University of Toronto, 2009.   \n[23] A. Krizhevsky, I. Sutskever, and G. Hinton. ImageNet classification with deep convolutional neural networks. In Advances in Neural Information Processing Systems (NIPS), 2012.   \n[24] B. Li, F. Wu, S. Lim, S. Belongie, and K. Weinberger. On feature normalization and data augmentation. In Conference on Computer Vision and Pattern Recognition (CVPR), 2021.   \n[25] Y. Li, N. Wang, J. Shi, J. Liu, and X. Hou. Revisiting batch normalization for practical domain adaptation. In International Conference on Learning Representations Workshop (ICLRW), 2017.   \n[26] Y. Liu, P. Kothari, B. van Delft, B. Bellot-Gurlet, T. Mordan, and A. Alahi. $\\mathrm { T T T } { + } { + }$ : When does self-supervised test-time training fail or thrive? In Advances in Neural Information Processing Systems (NeurIPS), 2021.   \n[27] I. Loshchilov and F. Hutter. Decoupled weight decay regularization. In International Conference on Learning Representations (ICLR), 2019.   \n[28] D. Mahajan, R. Girshick, V. Ramanathan, K. He, M. Paluri, Y. Li, A. Bharambe, and L. van der Maaten. Exploring the limits of weakly supervised pretraining. In European Conference on Computer Vision (ECCV), 2018.   \n[29] C. Mao, M. Chiquier, H. Wang, J. Yang, and C. Vondrick. Adversarial attacks are reversible with natural supervision. In IEEE International Conference on Computer Vision (ICCV), 2021.   \n[30] X. Mao, G. Qi, Y. Chen, X. Li, R. Duan, S. Ye, Y. He, and H. Xue. Towards robust vision transformer. In Conference on Computer Vision and Pattern Recognition (CVPR), 2022.   \n[31] D. Molchanov, A. Lyzhov, Y. Molchanova, A. Ashukha, and D. Vetrov. Greedy policy search: A simple baseline for learnable test-time augmentation. In Conference on Uncertainty in Artificial Intelligence (UAI), 2020.   \n[32] K. Muandet, D. Balduzzi, and B. Schölkopf. Domain generalization via invariant feature representation. In International Conference on Machine Learning (ICML), 2013.   \n[33] Z. Nado, S. Padhy, D. Sculley, A. D’Amour, B. Lakshminarayanan, and J. Snoek. Evaluating prediction-time batch normalization for robustness under covariate shift. arXiv preprint arXiv:2006.10963, 2020.   \n[34] A. Orhan. Robustness properties of Facebook’s ResNeXt WSL models. arXiv preprint arXiv:1907.07640, 2019.   \n[35] X. Peng, B. Usman, N. Kaushik, J. Hoffman, D. Wang, and K. Saenko. VisDA: The visual domain adaptation challenge. arXiv preprint arXiv:1710.06924, 2017.   \n[36] J. Quiñonero Candela, M. Sugiyama, A. Schwaighofer, and N. Lawrence. Dataset Shift in Machine Learning. The MIT Press, 2009.   \n[37] B. Recht, R. Roelofs, L. Schmidt, and V. Shankar. Do CIFAR-10 classifiers generalize to CIFAR-10? arXiv preprint arXiv:1806.00451, 2018.   \n[38] O. Russakovsky, J. Deng, H. Su, J. Krause, S. Satheesh, S. Ma, Z. Huang, A. Karpathy, A. Khosla, M. Bernstein, A. Berg, and F. Li. Imagenet large scale visual recognition challenge. International Journal of Computer Vision (IJCV), 2015.   \n[39] S. Sagawa, P. Koh, T. Hashimoto, and P. Liang. Distributionally robust neural networks for group shifts: On the importance of regularization for worst-case generalization. In International Conference on Learning Representations (ICLR), 2020.   \n[40] S. Schneider, E. Rusak, L. Eck, O. Bringmann, W. Brendel, and M. Bethge. Improving robustness against common corruptions by covariate shift adaptation. In Advances in Neural Information Processing Systems (NeurIPS), 2020.   \n[41] H. Shimodaira. Improving predictive inference under covariate shift by weighting the loglikelihood function. Journal of Statistical Planning and Inference (JSPI), 2000.   \n[42] C. Shorten and T. Khoshgoftaar. A survey on image data augmentation for deep learning. Journal of Big Data, 2019.   \n[43] P. Sivaprasad and F. Fleuret. Test time adaptation through perturbation robustness. arXiv preprint arXiv:2110.10232, 2021.   \n[44] Y. Sun, X. Wang, Z. Liu, J. Miller, A. Efros, and M. Hardt. Test-time training with selfsupervision for generalization under distribution shifts. In International Conference on Machine Learning (ICML), 2020.   \n[45] T. Varsavsky, M. Orbes-Arteaga, C. Sudre, M. Graham, P. Nachev, and M. Cardoso. Test-time unsupervised domain adaptation. arXiv preprint arXiv:2010.01926, 2020.   \n[46] D. Wang, E. Shelhamer, S. Liu, B. Olshausen, and T. Darrell. Tent: Fully test-time adaptation by entropy minimization. In International Conference on Learning Representations (ICLR), 2021.   \n[47] G. Wilson and D. Cook. A survey of unsupervised deep domain adaptation. ACM Transactions on Intelligent Systems and Technology (TIST), 2020.   \n[48] E. Wong, L. Rice, and J. Kolter. Fast is better than free: Revisiting adversarial training. In International Conference on Learning Representations (ICLR), 2020.   \n[49] Y. Wu and K. He. Group normalization. In European Conference on Computer Vision (ECCV), 2018.   \n[50] S. Xie, R. Girshick, P. Dollár, Z. Tu, and K. He. Aggregated residual transformations for deep neural networks. In Conference on Computer Vision and Pattern Recognition (CVPR), 2017.   \n[51] D. Yin, R. Lopes, J. Shlens, E. Cubuk, and J. Gilmer. A Fourier perspective on model robustness in computer vision. In Advances in Neural Information Processing Systems (NeurIPS), 2019.   \n[52] M. Zhang, H. Marklund, A. Gupta, S. Levine, and C. Finn. Adaptive risk minimization: Learning to adapt to domain shift. In Advances in Neural Information Processing Systems (NeurIPS), 2021. ",
+        "bbox": [
+            178,
+            723,
+            826,
+            911
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            171,
+            64,
+            828,
+            919
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            171,
+            45,
+            828,
+            922
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            169,
+            89,
+            828,
+            541
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Checklist ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            89,
+            254,
+            106
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "1. For all authors... ",
+        "bbox": [
+            214,
+            116,
+            339,
+            131
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "(a) Do the main claims made in the abstract and introduction accurately reflect the paper’s contributions and scope? [Yes]   \n(b) Did you describe the limitations of your work? [Yes] See Section 5.   \n(c) Did you discuss any potential negative societal impacts of your work? [No]   \n(d) Have you read the ethics review guidelines and ensured that your paper conforms to them? [Yes] ",
+        "bbox": [
+            238,
+            136,
+            825,
+            227
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "2. If you are including theoretical results... ",
+        "bbox": [
+            214,
+            231,
+            493,
+            244
+        ],
+        "page_idx": 13
+    },
+    {
+        "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": 13
+    },
+    {
+        "type": "text",
+        "text": "3. If you ran experiments... ",
+        "bbox": [
+            212,
+            285,
+            393,
+            299
+        ],
+        "page_idx": 13
+    },
+    {
+        "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 supplementary material.   \n(b) Did you specify all the training details (e.g., data splits, hyperparameters, how they were chosen)? [Yes] See Appendix A.   \n(c) Did you report error bars (e.g., with respect to the random seed after running experiments multiple times)? [N/A]   \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)? [No] ",
+        "bbox": [
+            238,
+            303,
+            825,
+            435
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "4. If you are using existing assets (e.g., code, data, models) or curating/releasing new assets... ",
+        "bbox": [
+            220,
+            439,
+            823,
+            454
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "(a) If your work uses existing assets, did you cite the creators? [Yes]   \n(b) Did you mention the license of the assets? [No] All assets are publicly and freely available.   \n(c) Did you include any new assets either in the supplemental material or as a URL? [No]   \n(d) Did you discuss whether and how consent was obtained from people whose data you’re using/curating? [N/A]   \n(e) Did you discuss whether the data you are using/curating contains personally identifiable information or offensive content? [N/A] ",
+        "bbox": [
+            238,
+            458,
+            825,
+            579
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "5. If you used crowdsourcing or conducted research with human subjects... ",
+        "bbox": [
+            214,
+            583,
+            705,
+            598
+        ],
+        "page_idx": 13
+    },
+    {
+        "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": 13
+    }
+]

parse/dev/XrGEkCOREX2/XrGEkCOREX2_layout.pdf

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:e507ad49f89d639ed34b6dbea58bc1653f5720a86f2fec9da84006d4b4c59911
+size 2739022

parse/dev/XrGEkCOREX2/XrGEkCOREX2_origin.pdf

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:6c50fffae2d4e3004b92149bee4cbb8cefac8086e02202bb6823ac493bedb6fe
+size 2464375

parse/dev/XrGEkCOREX2/XrGEkCOREX2_span.pdf

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:048a06bbf56fd696de81ca6aee606112e5b9eeda7a3818b3bea5eab27314b43c
+size 2750923