Add files using upload-large-folder tool

parse/train/QHUUrieaqai/QHUUrieaqai.md

@@ -0,0 +1,360 @@
+# LIME: LEARNING INDUCTIVE BIAS FOR PRIMITIVES OF MATHEMATICAL REASONING
+
+Anonymous authors Paper under double-blind review
+
+# ABSTRACT
+
+While designing inductive bias in neural architectures has been widely studied, we hypothesize that transformer networks are flexible enough to learn inductive bias from suitable generic tasks. Here, we replace architecture engineering by encoding inductive bias in the form of datasets. Inspired by Peirce’s view that deduction, induction, and abduction form an irreducible set of reasoning primitives, we design three synthetic tasks that are intended to require the model to have these three abilities. We specifically design these synthetic tasks in a way that they are devoid of mathematical knowledge to ensure that only the fundamental reasoning biases can be learned from these tasks. This defines a new pre-training methodology called “LIME” (Learning Inductive bias for Mathematical rEasoning). Models trained with LIME significantly outperform vanilla transformers on three very different large mathematical reasoning benchmarks. Unlike dominating the computation cost as traditional pre-training approaches, LIME requires only a small fraction of the computation cost of the typical downstream task.
+
+# 1 INTRODUCTION
+
+Inductive bias is essential for successful neural network learning. Many of the breakthroughs in machine learning are accompanied by new neural architectures with better inductive biases, such as locality bias in convolutional neural networks (LeCun et al., 1999), recurrence and memory in LSTMs (Hochreiter and Schmidhuber, 1997), and structural bias in graph neural networks (Scarselli et al., 2008). However, existing designs of inductive biases need to be explicitly encoded in neural architecture. This is sometimes difficult as one may not know the exact mechanism for an abstract ability, in order to describe the architectural bias explicitly. In particular, designing proper inductive bias for abstract concepts such as mathematical reasoning becomes an extremely challenging task. Moreover, attempts to design elaborate architectures for reasoning often fall short of the performance of more generic transformer architecture. In this work, we aim to avoid the search for new architectures and investigate whether one can learn useful inductive bias for mathematical reasoning through pretraining.
+
+Large-scale unsupervised pretraining of language models revolutionized the field of natural language processing (NLP), improving the state-of-the-art in question answering, name entity recognition, text classification, and other domains, e.g. (Radford et al., 2018; Devlin et al., 2019; Yang et al., 2019; Liu et al., 2019; Raffel et al., 2020; Brown et al., 2020). As a result, pretraining has become a common practice for modern neural network based NLP. One plausible explanation for the benefit of pretraining is that the model can learn world knowledge by memorizing the contents of the natural language corpus. This can be useful in various natural language downstream tasks, such as question answering and text classification. However, there is another potential advantage of pre-training—it may distill inductive biases into the model that are helpful for training on downstream tasks (Brown et al., 2020; Warstadt and Bowman, 2020). We focus on the latter and design pre-training tasks that are intentionally devoid of knowledge and only allow the model to learn inductive bias for reasoning.
+
+Inspired by the logician Charles Peirce (Peirce, 1992), we believe that the following three primitives are the most crucial for reasoning:
+
+1. Deduction: the ability to deduce new truths from given facts and inference rules.   
+2. Induction: the ability to induce general inference rules from a set of known facts.   
+3. Abduction: the ability to explain the relationship between the evidences and inference rules.
+
+To endow the models with an inductive bias for mathematical reasoning, we design a synthetic task for each of the three inductive biases. We hypothesize that the transformer networks are flexible enough to learn strong inductive bias from the three synthetic reasoning tasks and consequently improving the downstream tasks. Although such inductive bias may be useful in general reasoning tasks (e.g., NLP tasks), in this work, we focus on mathematical reasoning benchmarks, for which we expect to observe the largest gains. We call training on these tasks LIME – an acronym for “Learning Inductive Bias for Mathematical rEasoning”. Note that there is only a limited amount of pretraining data available for formal mathematical benchmarks, therefore the study of generic pre-training techniques is particularly important for the success of machine learning in mathematical reasoning.
+
+We demonstrate that LIME pretrained models provide significant gains across three large mathematical reasoning benchmarks: IsarStep (Li et al., 2020), HOList Skip-tree (Rabe et al., 2020) and MetaMathStep (Polu and Sutskever, 2020). Notably, on the IsarStep benchmark, pre-training improved the top-1 accuracy from $2 0 . 4 \%$ to $2 6 . 9 \%$ and top-10 accuracy from $3 3 . 1 \%$ to $4 1 . 0 \%$ . Compared to the traditional pre-training tasks, there are two major differences. First, we do not load the input embeddings or the weights in the output layer for finetuning on downstream tasks. This allows us to use the same pre-trained model for a variety of downstream tasks, which can have vastly different vocabularies due to language or tokenization differences. Also, it prevents the transfer of content knowledge from the pretraining to downstream tasks, supporting the evidence of learning inductive biases. Furthermore, pretraining on synthetic tasks require only a fraction of the computational cost of downstream tasks. With only about two hours of training on a single modern GPU, one already obtains all the benefits, in contrast to days of training on a large natural language corpus with hundreds of GPUs/TPUs.
+
+Our method can also be regarded as a form of curriculum learning, in which the model is taught basic, extremely generic but general skills before being trained on the specific problem domain.
+
+To summarize, the contributions of the paper are:
+
+1. Providing the first method to design inductive biases in the form of datasets for mathematical reasoning.   
+2. Demonstrating significant improvements in the reasoning performance of transformer models on three large mathematical reasoning benchmarks with negligible extra computation cost.   
+3. By showing how pretraining brings benefits other than learning content knowledge, disentangling the study of its working mechanism.
+
+# 2 RELATED WORK
+
+Learning Models Applied to Mathematics There has been increasing interest in applying deep learning methods to Interactive Theorem Provers (ITP) (Bansal et al.; 2019; Gauthier et al., 2020; Huang et al., 2019; Yang and Deng, 2019; Wu et al., 2020; Li et al., 2020; Polu and Sutskever, 2020). The work that is most related to ours is GPT- $f$ (Polu and Sutskever, 2020). The authors performed pretraining on several natural language corpora and showed significant improvements for an ITP system – MetaMath. Different from ours, they used GPT-style large-scale language modeling pretraining, which dominates the computation cost compared to the downstream task. We, on the other hand, propose pretraining on a few lightweight synthetic tasks costing only a minor fraction of the computation spent on the downstream task.
+
+Lample and Charton (2020) have demonstrated that transformer models can be used for symbolic mathematics by successfully predicting the integrals of formulas from a randomly generated dataset. Similar observations are made for logical problems relevant to verification: that transformer networks can learn the semantics of logics (Hahn et al., 2020). Rabe et al. (2020) have shown that mathematical reasoning can emerge from self-supervised training alone. Li et al. (2020) show that language models can learn to synthesize missing high-level intermediate propositions given a local context. Piotrowski and Urban (2020) used RNNs in automated theorem provers for first-order logic. Wang et al. (2020) explored the use of machine translation to translate between synthetically generated natural language descriptions of proofs and formally represented proofs. Urban and Jakub˚uv (2020) present initial experiments on generating mathematical conjectures with a Transformer model.
+
+Saxton et al. (2019) suggest a dataset for the analysis of mathematical reasoning skills. In contrast to the datasets considered here, their dataset is synthetic, focuses on calculation with concrete numbers, and only contains relatively few symbolic tasks.
+
+Language Model Pretraining The advent of the transformer architecture (Vaswani et al., 2017) and the BERT style pretraining (Devlin et al., 2019) represented a huge improvement in the quality of language modeling. Since then, an explosion of research activity in the area pushed the quality of language models through better pretraining tasks. Where BERT (Devlin et al., 2019) masks out a fraction of the input tokens, later works demonstrated the advantages of masking out subsequences (Song et al., 2019; Dong et al., 2019; Joshi et al., 2020; Raffel et al., 2020; Conneau and Lample, 2019) and whole sentences (Zhang et al., 2020).
+
+Besides the choice of pretraining tasks, the scale of language models is also an important factor. Language models improve in quality and develop new abilities as they grow larger while trained on the same data (Radford et al., 2018; Raffel et al., 2020; Brown et al., 2020).
+
+Inductive Biases in General There have been works studying learning inductive biases in other contexts. In particular, McCoy et al. (2020) studied whether one can learn linguistic inductive biases on synthetic datasets via meta-learning. Papadimitriou and Jurafsky (2020) shows inductive biases learned in music data can be useful for natural language. They further designed several synthetic tasks and showed similar kind of improvements for natural language tasks. From a more theoretical point of view, Xu et al. (2020) formalize an aspect of inductive (architectural) bias under the context of GNNs, with a notation called architectural alignment. The architecture is aligned when the architecture can perfectly simulates the ground truth solution. But their work is limited to showing alignment in combinatorial problems, whose ground truth solutions are known. In contrast, our work tries to learn architectural bias by relying on the flexible Transformer architecture and training on synthetic datasets.
+
+Inductive Biases for Mathematics Previous work studying inductive biases for logical reasoning has focused on encoding bias in the neural architecture. Initial works focused on encoding the tree structure of expressions using TreeRNNs (Evans et al., 2018). Graph neural networks are shown to provide a much stronger performance than tree models in premise selection (Wang et al., 2017) and theorem proving (Paliwal et al., 2020). GNNs also scale to larger formulas in SAT (Selsam et al., 2019; Selsam and Bjørner, 2019; Han, 2020), QBF (Lederman et al., 2020), and #SAT (Vaezipoor et al., 2020). Crouse et al. (2019) have shown that pooling mechanisms can have an impact on the performance of GNNs on logical formulas as well. Closely related, Hellendoorn et al. (2020) have shown that it can be helpful to hard-code the tree structure of programs in the attention mask of transformers. Schlag et al. (2019) developed an architecture for encoding relational information using tensor product representation for mathematical reasoning.
+
+# 3 METHODS
+
+In this section, we first discuss the primitives of reasoning, inspired by Peirce’s views, and design one synthetic task for each reasoning primitive.
+
+# 3.1 REASONING PRIMITIVES
+
+In Peirce’s view, there are exactly three kinds of reasoning: deduction, abduction, and induction. Deduction is known as the workhorse for mathematics. It is the process of deriving new facts by applying logical inference rules to known facts or premises. On the other hand, abduction and induction can be thought of as the inverses of deduction. If we call the premise used in deduction as Case, its logical rule as Rule, and its conclusion as Result, then abduction is equivalently the inference of a Case from a Rule and a Result, while induction may be said to be the inference of a Rule from a Case and a Result. We summarize the three reasoning primitives in the following table:
+
+<table><tr><td rowspan=1 colspan=1>Reasoning Primitives</td><td rowspan=1 colspan=1>Inference Map</td></tr><tr><td rowspan=1 colspan=1>Deduction</td><td rowspan=1 colspan=1>Rule, Case→Result</td></tr><tr><td rowspan=1 colspan=1>Abduction</td><td rowspan=1 colspan=1>Rule,Result→Case</td></tr><tr><td rowspan=1 colspan=1>Induction</td><td rowspan=1 colspan=1>Case,Result→Rule</td></tr></table>
+
+To give an example, we let Rule be “All the beans in this bag are white”, Case be “These beans are from this bag”, and Result be “These beans are white”. Deduction is to derive the fact that these beans are white (Re) from knowing all the beans from this bag are white (R) and these beans are from this bag (C). Abduction explains why the beans are white (Re) from knowing that all the beans in the bag are white (R) – because these beans must be from the bag (C). Lastly, induction aims to provide a general principle to observing the fact that the beans are white (Re) and they come from this bag (C), which is that all the beans in the bag must be white (R). We refer to Peirce (1992) and Bellucci and Pietarinen (2015) for more elaborate discussions on the primitives of reasoning.
+
+Mathematical reasoning exhibits nontrivial uses of these reasoning primitives. Deduction happens when one needs to derive new valid statements from the given premise (Case) and theorems in the library (Rule). Abduction is used to postulate conjectures from the known facts and theorems, allowing one to decompose the challenging theorem into subgoals for proof. Induction, the ability to extract general principles from known facts and theorems is also one of the major activities of mathematical reasoning. It is used when one derives theorems from special cases and proposes new definitions and general frameworks to encapsulate existing knowledge.
+
+# 3.2 LIME SYNTHETIC TASKS FOR REASONING PRIMITIVES
+
+We design three synthetic tasks inspired by the three reasoning primitives. As discussed in the previous section, all of the reasoning primitives consist of three essential elements: Rule, Case, and Result. Inspired by this, we first design a method to generate those elements. Once they are generated, we can construct tasks that predict one element from the other two. In the following, we describe one simple way to generate those three elements, though we acknowledge that there are many other possible approaches.
+
+We require two types of symbols: 1. math symbols, 2. rule symbols. In general, these symbols can take any forms (e.g., integer representations). But for the ease of discussion, we will think of math symbols as the union of those operators used in mathematics (e.g., $^ { * * } + - * = ( ) \ell \boldsymbol { \mathrm { v } } )$ and lower case letters (e.g., $a , b , c \ldots )$ , and rule symbols as upper case letters (e.g., $A , B , C \dots )$ . We now construct Rule, Case, and Result in order:
+
+1. Rule is a randomly sampled string that consists of i) rule symbols and ii) math symbols. The length of the string is randomly sampled from a range. For instance, a randomly sampled rule can be: $A * A + B = C$ with rule symbols $A , B$ , and $C$ .   
+2. Case is a dictionary that represents substitutions. For each rule symbol used in the Rule string, we sample a random string of random length that consists of math symbols. This forms a dictionary, whose keys are all rule symbols, and the values are the corresponding sampled string. To illustrate, following the previous example, for each $A$ , $B$ and $C$ , we sample a random string to form a dictionary as: $\left\{ A : a , B : b , { \bar { C } } : d + e \right\}$ .   
+3. Result is the outcome of the substitution. For each rule symbol in the Rule string, we replace it with the corresponding value stored in the Case dictionary. This gives rise to the Result string. As per the previous example, we now substitute $A$ with $a$ , $B$ with $b$ , and $C$ with $d + e$ into the Rule string, generating the Result string: $a * a + b = d + e$ .
+
+After Rule, Case, and Result are generated, we can construct three tasks for deduction, abduction, and induction respectively. We define the three synthetic tasks as follows:
+
+• Deduct: Source: Rule string and Case dictionary. Target: Result string.   
+• Abduct: Source: Rule string and Result string. Target: Case dictionary.   
+• Induct: Source: Case dictionary and Result string. Target: Rule string.
+
+We also consider a task called Mix, which is a uniform mix of three tasks. Namely, during generation, we randomly select a task and sample an example from that task. To formulate them as sequence to sequence tasks, we represent the Case dictionary also as a string, e.g., $\ ^ { * } \{ A : a , B : b , C : d + e \} ^ { , }$ . An example of Abduct using the examples of Rule, Case, and Result above is to predict the target $\{ A : a , { \bar { B } } : b , C : d + e \}$ from the source $A * A + B = C < s > a * a + b = d + e .$ .
+
+Pre-training on our synthetic tasks can be seen as a form of skip-component learning. There are three essential components: Rule, Case and Result, and we skip one of them and use the remaining two elements to reconstruct the missing one. Past work has shown that learning to predict missing words (Devlin et al., 2019), subsequences (Song et al., 2019; Raffel et al., 2020), or subtrees (Rabe et al., 2020) are strong pre-training tasks.
+
+# 3.3 SYMBOL-AGNOSTIC REPRESENTATION
+
+In order to solve the synthetic tasks, the model needs to distinguish which set of symbols can be substituted (rule symbols). As a result, the model may memorize information about the symbols that is irrelevant to the inductive biases encoded in the task. To prevent such memorization, we propose a way to make the synthetic tasks agnostic to the choice of symbols.
+
+We first note that the choice of symbols is irrelevant to our synthetic tasks. To avoid symbol-specific memorization, for each training and evaluation example, we randomly sample two sets of symbols to be used in Rules and in the rest of the example. But for the Abduct task, the model needs to know which symbols are replaced by the Rule part of the example and which symbols are in the Result language. We simply list the split of the symbols used in the example at the beginning of the input string, marked by two special symbols, ${ \mathrm { < R u l e > } }$ and <Math>. They are followed by the original source string. The target string remains unchanged. For example, the previous example in the Abduct task becomes,
+
+$$
+< \mathtt { R u l e } > A \ B \ C < \mathtt { M a t h } > * + = a b d e < \mathtt { s } > A * A + B = C < \mathtt { s } > a * a + b = d + e ^ { - }
+$$
+
+Target: $\{ A : a , B : b , C : d + e \}$
+
+In our implementation, we use integers to represent symbols. Specifically, for each example, we sample two disjoint sets of integers from the set $\{ 1 , \ldots , S \}$ to represent the math symbols and the rule symbols, where $S$ is the size of the vocabulary. In our experiments, we sample 44 math symbols and 24 rule symbols for each problem. The complete pseudo-code of generating the symbols, Rule, Case, and Result for one task example is provided in Appendix Algorithm 1.
+
+# 4 EXPERIMENTS
+
+In this section, we present results on three large mathematical reasoning tasks that are especially useful in the context of automated theorem proving. Our results show significant gains in learning inductive biases from synthetic tasks. We have selected three tasks to cover three different styles of interactive theorem provers: The HOL-Light (skip-tree) corpus was created from very high-level tactic-based proofs, but it is less interpretable than IsarStep’s declarative style corpus. We also evaluate the next proof-step prediction task on the set.mm library of MetaMath, which consists of very granular, basic proof steps. Namely, the proof steps are more predicable and average proof lengths have significantly increased.
+
+# 4.1 EXPERIMENT DETAILS
+
+LIME Pretraining We generate datasets of our synthetic tasks for pretraining: Deduct, Abduct, Induct, Mix. For pretraining of IsarStep, we used a vocabulary size $S$ of 1000. For the other two downstream tasks, we used a vocabulary size of 100. The reason we used different vocabulary sizes was that we found (cf. appendix) the discrepancy in vocabulary size affects the performance of a downstream task if it has a very large vocabulary size (IsarStep has 28K). We use 44 math symbols and 24 rule symbols. The length of the Rule string is sampled from 5 to 20, the length of the string for each substitution (the values of Case dictionary) is sampled from 2 to 8. We used word-level tokenization for all the tasks. We pretrained the model for 20K updates. For tasks with larger vocabulary size (i.e., 1000), we found the learning became more difficult. Hence we used a curriculum learning scheme: we first trained the model for 10K steps on the same task with a vocabulary size of 100, then continue training for another 10K step on vocabulary size of 1000. The pretraining was done on a single Nvidia Tesla T4 GPU with 4 CPU cores for 2 hours. We set the maximum number of tokens in a batch to 4096, and accumulate four batches of gradients for one parameter update. We used the Adam optimizer (Kingma and Ba, 2015) with learning rate $3 \cdot 1 0 ^ { - 4 }$ We used a dropout rate of 0.1 and label smoothing (Szegedy et al., 2016) with a coefficient 0.1.
+
+Table 1: Test top-1, top-10 $( \% )$ accuracy on the IsarStep task.   
+
+<table><tr><td>Model</td><td>Top-1 Acc.</td><td>Top-10 Acc.</td></tr><tr><td>No pretrain (Li et al., 2020)</td><td>20.4</td><td>33.1</td></tr><tr><td>HAT (Li et al., 2020)</td><td>22.8</td><td>35.2</td></tr><tr><td>LIME Deduct</td><td>24.7</td><td>37.7</td></tr><tr><td>LIME Abduct</td><td>26.7</td><td>41.0</td></tr><tr><td>LIMEInduct</td><td>23.9</td><td>38.8</td></tr><tr><td>LIME Mix</td><td>26.9</td><td>40.4</td></tr></table>
+
+Table 2: Test top-8 Accuracy on Skip-Tree HOList $( \% )$ .   
+
+<table><tr><td>Model</td><td>Equation completion</td><td>Hard type inference</td><td>Missing assumptions</td><td>Easy type inference</td></tr><tr><td>No pretrain (Rabe et al., 2020)</td><td>46.3</td><td>95.0</td><td>41.8</td><td>95.9</td></tr><tr><td>LIME Deduct</td><td>50.3</td><td>94.8</td><td>47.9</td><td>97.0</td></tr><tr><td>LIME Abduct</td><td>48.4</td><td>94.8</td><td>46.1</td><td>96.3</td></tr><tr><td>LIME Induct</td><td>44.8</td><td>94.9</td><td>42.6</td><td>96.4</td></tr><tr><td>LIME Mix</td><td>51.7</td><td>95.6</td><td>46.1</td><td>97.6</td></tr></table>
+
+Fine-tuning For all the downstream tasks in this section, when loading the pretrained models for fine-tuning, we do not load in the vocabulary embeddings nor the output layer weights. For the downstream task IsarStep and MetaMathStep, we used four Nvidia Tesla T4 GPU with $1 6 \mathrm { \ C P U }$ cores for training. We set the maximum number of tokens in a batch to 4096, and accumulated four batches of gradients for one parameter update. We trained the model for 200K updates. We used the Adam optimizer, and we searched over the learning rates $\{ 3 \cdot 1 0 ^ { - 4 } , 7 \cdot 1 0 ^ { - 4 } \}$ , and warmup steps $\{ 4 0 0 0 , \bar { 8 0 0 0 } \}$ . We used a dropout rate of 0.1 and label smoothing with a coefficient 0.1. For the HOList skip-tree task, we used TPUs for running the experiments. We used a batch size of 256 sequences and trained the model for 1 million updates.
+
+Architecture All experiments used the transformer base model from Vaswani et al. (2017), i.e. 512 hidden size, 2048 filter size, 8 attention heads. For the IsarStep and MetaMathStep task, we used 6 layers for both the encoder and decoder, implemented using fairseq (Ott et al., 2019). For the HOList skip-tree experiment, we used a somewhat modified transformer architecture with 8 encoder and 4 decoder layers of the same size as above in which the self-attention and attention over the encoder output were merged.
+
+Evaluation During training, we kept track of the best validation tokenized BLEU score 1, and we used the model with validation BLEU for evaluation on the test set. We report top-1 and top-10 accuracies. We consider an output sequence as correct if it matches the target sequence exactly. We performed a beam search with width 10. The top-1 accuracy is then defined as the percentage of the best output sequences that are correct. The top- $\mathbf { \nabla } \cdot n$ accuracy is defined as the percentage of target sequences appearing in the top $n$ generated sequences.
+
+# 4.2 ISARSTEP
+
+The IsarStep task is taken from Li et al. (2020). IsarStep is a task of predicting the missing intermediate propositions given surrounding propositions to bridge the gap between the goal and the current state of the proof. The dataset was mined from the public repository of formal proofs of the Isabelle proof assistant (Paulson, 1994). Unlike HOList and MetaMath, IsarStep contains mostly declarative proofs, a proof style close to humans’ prose proofs. The dataset has a broad coverage of undergraduate and research-level mathematics and computer science theorems. There are 820K, 5000, 5000 sequence pairs for the training, validation, and test sets with a maximum of 800 tokens in source sequences and 200 tokens in the target sequences. Following Li et al. (2020), during training, we use 512 as the
+
+Table 3: Test top-1, top-10 $( \% )$ accuracy on the MetaMathStep task.   
+
+<table><tr><td>Model</td><td>Top-1 Acc.</td><td>Top-10 Acc.</td></tr><tr><td>No pretrain</td><td>67.7</td><td>76.5</td></tr><tr><td>LIME Deduct</td><td>68.8</td><td>77.4</td></tr><tr><td>LIME Abduct</td><td>68.8</td><td>76.1</td></tr><tr><td>LIME Induct</td><td>69.9</td><td>78.0</td></tr><tr><td>LIME Mix</td><td>69.1</td><td>77.9</td></tr></table>
+
+maximum length for both the source and target, and truncated those that exceed the length to 512.   
+For reporting, we evaluate all 5000 test examples regardless of their lengths.
+
+The results on the IsarStep task for four pretrained models and the baseline transformer model without pretraining is shown in Table 1. We also include another baseline, HAT transformer introduced in Li et al. (2020), which is a specially designed hierarchical transformer architecture tailored to this task. We see the pretrained model achieved substantial improvement over the model trained from scratch as well as HAT. Notably, the model that was pretrained on Abduct improved the top-10 accuracy from $3 3 . 1 \%$ to $4 1 . 0 \%$ , for almost $8 \%$ absolute improvement. The model pretrained on $\mathbb { M } \mathrm { i } \times$ performed the best on top-1 accuracy, improving the baseline by $6 . 5 \%$ accuracy. We also showed the validation BLEU scores along training in Figure 1. We can see that the pretrained models learned much faster than the model trained from scratch. With around 50K steps of updates, the pretrained model already obtained better BLEU scores than the best score achieved by the un-pretrained model. Moreover, since the downstream task requires 200K steps of training with 4 GPUs, the amount of computation spent on pretraining is only $2 . 5 \%$ of the downstream task, strongly demonstrating the efficiency of the proposed pretraining method.
+
+![](images/10d71f0acfa4d0f15245d0060288c8fd8ef4d2d1a3642ee96b4096cc10a97096.jpg)  
+Figure 1: Validation BLEU along training on the IsarStep task.
+
+# 4.3 HOLIST SKIP-TREE
+
+As the second mathematical reasoning benchmark we consider the HOList skip-tree evaluation tasks by Rabe et al. (2020). These tasks include two variants of type inference, predicting under which assumptions theorems hold, and completing equalities. All source expressions for these tasks are taken from the validation set of the theorem database of the HOList proof logs (Bansal et al.). The evaluations are done on a random sample of 1000 instances from the full evaluation sets. We initialized the model parameters with the pretrained weights and then repeated the experiments by Rabe et al. (2020). That is, we trained the models for up to 1M parameter updates on the training set with batch size 256 and repeat the evaluation every 100K steps. In Table 2 we present the best result from these 10 evaluation runs. We see a significant improvement in these reasoning tasks when the models are initialized with the pretrained weights. Notably, on equation completion and missing assumptions task, we improved the beam search (with width 8) exact match rate performance from $4 6 . 3 \%$ to $5 1 . 7 \%$ and $4 1 . 8 \%$ to $4 7 . 9 \%$ . Note that this is despite the amount of pretraining compute cost being negligible: it takes less than 1 percent of the cost of the downstream task training. Pretraining used $1 / 2 0$ number of the update steps (50K vs 1M) with 8 (and 4) times smaller batches (pretraining has much shorter sequence lengths, 128 vs. 1024 and 512, respectively).
+
+# 4.4 METAMATHSTEP
+
+Compared to other ITPs, MetaMath is a low-level proving system: each proof step makes only a small step towards the goal. As such, each proof contains many more proof steps than in other ITPs: with 37, 000 theorems in the human-written theorem library, there are around 3 million proof steps.
+
+Table 4: Comparisons to other pretraining tasks on IsarStep task.   
+
+<table><tr><td>Model</td><td>Top-1 Acc.</td><td>Top-10 Acc</td></tr><tr><td>No pretrain (Li et al., 2020)</td><td>20.4</td><td>33.1</td></tr><tr><td>LIME Mix</td><td>26.9</td><td>40.4</td></tr><tr><td>Pretrain on MetaMathStep</td><td>23.1</td><td>35.7</td></tr><tr><td>Pretrain on WMT En-De</td><td>17.2</td><td>30.3</td></tr></table>
+
+We extract the proof steps and use them to construct a sequence-to-sequence task following Polu and Sutskever (2020) (their proof step training objective).
+
+In this task, the model is asked to generate PROOFSTEPS given a GOAL, namely, the GOAL string is the source input, and PROOFSTEPS is the target output. We follow Polu and Sutskever (2020) and use their string representation for the GOAL and the PROOFSTEPS. Instead of using subword tokenization in Polu and Sutskever (2020), we use a character-level representation for our task. Following Polu and Sutskever (2020), we split theorems into train/valid/test theorems of size 35K, 1K, 1K, and associate all proof steps of a theorem with that split. For each dataset, we filter examples with lengths longer than 1024. This reduced the total number of proof steps to 1.4 million. For validation and test set, we randomly sample 3000 examples out of 40K (after filtering) and perform validation and test evaluations on them. In Table 3 we present the impact of pretraining on our synthetic reasoning tasks on MetaMathStep. We also observe gains from pretraining on this dataset, with the model trained on Induct task achieving $2 . 2 \%$ top-1 and $1 . 5 \%$ top-10 test accuracy improvement. Similarly, as for the IsarStep task, the computation spent on pretraining is only $2 . 5 \%$ of the downstream task.
+
+# 5 ABLATION STUDIES
+
+In this section, we perform ablation studies. Additional ablation studies can be found in Appendix C.
+
+# 5.1 PRETRAINING ON FORMAL REASONING AND NATURAL LANGUAGE TASKS
+
+Here we investigate how LIME compares to pretraining on natural language or existing formal reasoning datasets. In this set of experiments, we pretrained three models on Mix, MetaMathStep, and on the WMT 2016 English-to-Germany (WMT En-De) translation task, and then we fine-tuned and evaluated these models on the IsarStep task. We pretrained the model on MetaMathStep and WMT EN-DE for 200K steps with 4 GPUs, which is 40 times more computation spent than on LIME. Due to the mismatch between vocabularies of the pretraining task and the downstream task, we do not load the vocabulary embeddings nor output layer weights. The results in Table 4 show that pretraining on MetaMathStep did provide gains, though significantly smaller than gains provided by LIME Mix, despite their 40 times higher computational cost. Moreover, pre-training on WMT translation had even a negative effect on the performance. We also conducted an analogous experiment with an evaluation on the MetaMathStep, which we present in Appendix C.
+
+# 5.2 DO WE NEED VOCABULARY EMBEDDINGS FOR FINE-TUNING?
+
+As mentioned earlier, we did not load in the vocabulary embeddings from the pretrained models when we switched to fine-tuning on downstream tasks. Even without loading the vocab embeddings, the pretrained models still improved the performance. In this ablation study, we investigate how much this decision has affected the results and whether vocabulary embeddings can help improve the performance even further. We performed the comparisons on IsarStep. The task contains a token vocabulary of size 28336. We generated new synthetic tasks for the same vocabulary size, such that we can load the vocabulary embeddings and output layers when initializing the model for IsarStep. Table 5 shows that this led to similar performance. This aligns with our expectation that the model should not learn content specific knowledge that is potentially stored in the vocabulary. These weights turn out to be non-essential for the final performance, supporting the evidence that the transformer learns inductive biases from the pretraining task.
+
+Table 5: Whether one needs to load vocabulary embeddings and output layer weights on IsarStep tasks.   
+
+<table><tr><td>Model</td><td>Top-1 Acc.</td><td>Top-10 Acc</td></tr><tr><td>No pretrain (Li et al., 2020)</td><td>20.4</td><td>33.1</td></tr><tr><td>LIME Mix</td><td>26.9</td><td>40.4</td></tr><tr><td>LIME Mix + Loading All Weights</td><td>26.7</td><td>40.6</td></tr></table>
+
+6 DOES LIME ENCODE INDUCTION, DEDUCTION AND ABDUCTION?
+
+Although LIME has shown to achieve substantial improvements across various benchmarks, it is not entirely clear that the specific synthetic tasks necessarily enforce the reasoning ability of induction, deduction and abduction. We would like to note that deduction, induction, and abduction are highlevel and philosophical concepts, and serve only as an inspiration for us to design the synthetic tasks. We do not expect the model will necessarily learn exactly these three capabilities. After all, we have chosen a particular implementation of "Case", "Rule" and "Result". Furthermore, we also design tasks mimic proof steps in formal theorem proving (see the rewrite task in Appendix B.1), which also achieved excellent results. Nevertheless, we believe LIME is a first step towards building reasoning inductive biases, and provides many inspirations and directions for future work.
+
+# 7 CONCLUSION
+
+In this work, we encoded inductive biases for mathematical reasoning in the form of datasets. We created three synthetic tasks inspired by three reasoning primitives of deduction, induction, and abduction. We demonstrated that pretraining on these tasks (LIME) significantly improved the performances across three mathematical reasoning benchmarks. Notably, LIME requires negligible computation compared to the downstream task, unlike being the dominating factor in previous pretraining methods. Our work naturally poses many future research questions. Could the primitive tasks provide similar gains for NLP tasks? Are there similar primitive tasks for natural language reasoning? We also look forward to disentangling the effects of pretraining between learning content knowledge and inductive bias for all downstream tasks to better understand pre-training.
+
+# REFERENCES
+
+Kshitij Bansal, Sarah M. Loos, Markus N. Rabe, Christian Szegedy, and Stewart Wilcox. HOList: An Environment for Machine Learning of Higher Order Logic Theorem Proving. In 36th International Conference on Machine Learning, ICML 2019, Long Beach, California, USA, June 9-15, 2019. URL http://proceedings.mlr.press/v97/bansal19a.html.
+
+Kshitij Bansal, Christian Szegedy, Markus N. Rabe, Sarah M. Loos, and Viktor Toman. Learning to Reason in Large Theories without Imitation. arXiv preprint arXiv:1905.10501, 2019.
+
+Francesco Bellucci and Ahti-Veikko Pietarinen. Charles Sanders Peirce: Logic. In The Internet Encyclopedia of Philosophy, 2015. URL https://iep.utm.edu/peir-log/.
+
+Tom B. Brown, Benjamin Mann, Nick Ryder, Melanie Subbiah, Jared Kaplan, Prafulla Dhariwal, Arvind Neelakantan, Pranav Shyam, Girish Sastry, Amanda Askell, Sandhini Agarwal, Ariel Herbert-Voss, Gretchen Krueger, Tom Henighan, Rewon Child, Aditya Ramesh, Daniel M. Ziegler, Jeffrey Wu, Clemens Winter, Christopher Hesse, Mark Chen, Eric Sigler, Mateusz Litwin, Scott Gray, Benjamin Chess, Jack Clark, Christopher Berner, Sam McCandlish, Alec Radford, Ilya Sutskever, and Dario Amodei. Language models are few-shot learners. CoRR, abs/2005.14165, 2020. URL https://arxiv.org/abs/2005.14165.
+
+Alexis Conneau and Guillaume Lample. Cross-lingual Language Model Pretraining. In Advances in Neural Information Processing Systems, NeurIPS 2019, Vancouver, BC, Canada, December 8-14, 2019, pages 7057–7067, 2019. URL http://papers.nips.cc/paper/ 8928-cross-lingual-language-model-pretraining.
+
+Maxwell Crouse, Ibrahim Abdelaziz, Cristina Cornelio, Veronika Thost, Lingfei Wu, Kenneth Forbus, and Achille Fokoue. Improving Graph Neural Network Representations of Logical Formulae with Subgraph Pooling. arXiv preprint arXiv:1911.06904, 2019.
+
+Jacob Devlin, Ming-Wei Chang, Kenton Lee, and Kristina Toutanova. BERT: pre-training of deep bidirectional transformers for language understanding. In Jill Burstein, Christy Doran, and Thamar Solorio, editors, Proceedings of the 2019 Conference of the North American Chapter of the Association for Computational Linguistics: Human Language Technologies, NAACL-HLT 2019, Minneapolis, MN, USA, June 2-7, 2019, Volume 1 (Long and Short Papers), pages 4171– 4186. Association for Computational Linguistics, 2019. doi: 10.18653/v1/n19-1423. URL https://doi.org/10.18653/v1/n19-1423.
+
+Li Dong, Nan Yang, Wenhui Wang, Furu Wei, Xiaodong Liu, Yu Wang, Jianfeng Gao, Ming Zhou, and Hsiao-Wuen Hon. Unified Language Model Pre-training for Natural Language Understanding and Generation. In Advances in Neural Information Processing Systems, NeurIPS 2019, Vancouver, BC, Canada, December 8-14, 2019, pages 13063–13075, 2019.
+
+Richard Evans, David Saxton, David Amos, Pushmeet Kohli, and Edward Grefenstette. Can Neural Networks Understand Logical Entailment? In International Conference on Learning Representations, 2018. URL https://openreview.net/forum?id $=$ SkZxCk-0Z.
+
+Thibault Gauthier, Cezary Kaliszyk, Josef Urban, Ramana Kumar, and Michael Norrish. TacticToe: Learning to Prove with Tactics. Journal of Automated Reasoning, pages 1–30, 2020.
+
+Christopher Hahn, Frederik Schmitt, Jens U. Kreber, Markus N. Rabe, and Bernd Finkbeiner. Transformers Generalize to the Semantics of Logics. arXiv preprint arXiv:2003.04218, 2020.
+
+Jesse Michael Han. Enhancing SAT solvers with glue variable predictions. arXiv preprint arXiv:2007.02559, 2020.
+
+Vincent J. Hellendoorn, Charles Sutton, Rishabh Singh, Petros Maniatis, and David Bieber. Global relational models of source code. In 8th International Conference on Learning Representations, ICLR 2020, Addis Ababa, Ethiopia, April 26-30, 2020. OpenReview.net, 2020. URL https: //openreview.net/forum?id=B1lnbRNtwr.
+
+Sepp Hochreiter and Jürgen Schmidhuber. Long Short-Term Memory. Neural computation, 9(8): 1735–1780, 1997.
+
+Daniel Huang, Prafulla Dhariwal, Dawn Song, and Ilya Sutskever. GamePad: A learning environment for theorem proving. In 7th International Conference on Learning Representations, ICLR 2019, New Orleans, LA, USA, May 6-9, 2019. OpenReview.net, 2019. URL https://openreview. net/forum?id $=$ r1xwKoR9Y7.
+
+Mandar Joshi, Danqi Chen, Yinhan Liu, Daniel S. Weld, Luke Zettlemoyer, and Omer Levy. Spanbert: Improving pre-training by representing and predicting spans. Transactions of the Association for Computational Linguistics, 8:64–77, 2020. doi: 10.1162/tacl\_a\_00300. URL https: //doi.org/10.1162/tacl_a_00300.
+
+Diederik P. Kingma and Jimmy Ba. Adam: A method for stochastic optimization. In Yoshua Bengio and Yann LeCun, editors, 3rd International Conference on Learning Representations, ICLR 2015, San Diego, CA, USA, May 7-9, 2015, Conference Track Proceedings, 2015. URL http://arxiv.org/abs/1412.6980.
+
+Guillaume Lample and François Charton. Deep learning for symbolic mathematics. In 8th International Conference on Learning Representations, ICLR 2020, Addis Ababa, Ethiopia, April 26-30, 2020. OpenReview.net, 2020. URL https://openreview.net/forum?id $=$ Ske31kBtPr.
+
+Yann LeCun, Patrick Haffner, Léon Bottou, and Yoshua Bengio. Object recognition with gradientbased learning. In Shape, Contour and Grouping in Computer Vision, page 319, Berlin, Heidelberg, 1999. Springer-Verlag. ISBN 3540667229.
+
+Gil Lederman, Markus Rabe, Sanjit Seshia, and Edward A Lee. Learning heuristics for quantified boolean formulas through reinforcement learning. In International Conference on Learning Representations, 2020.
+
+Wenda Li, Lei Yu, Yuhuai Wu, and Lawrence C. Paulson. Modelling High-Level Mathematical Reasoning in Mechanised Declarative Proofs. arXiv preprint arXiv:2006.09265, 2020.
+
+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. CoRR, abs/1907.11692, 2019. URL http://arxiv.org/abs/1907.11692.
+
+Thang Luong, Hieu Pham, and Christopher D. Manning. Effective approaches to attention-based neural machine translation. In Lluís Màrquez, Chris Callison-Burch, Jian Su, Daniele Pighin, and Yuval Marton, editors, Proceedings of the 2015 Conference on Empirical Methods in Natural Language Processing, EMNLP 2015, Lisbon, Portugal, September 17-21, 2015, pages 1412– 1421. The Association for Computational Linguistics, 2015. doi: 10.18653/v1/d15-1166. URL https://doi.org/10.18653/v1/d15-1166.
+
+R. Thomas McCoy, E. Grant, P. Smolensky, T. Griffiths, and Tal Linzen. Universal linguistic inductive biases via meta-learning. Proceedings of CogSci, abs/2006.16324, 2020.
+
+Myle Ott, Sergey Edunov, Alexei Baevski, Angela Fan, Sam Gross, Nathan Ng, David Grangier, and Michael Auli. fairseq: A fast, extensible toolkit for sequence modeling. In Waleed Ammar, Annie Louis, and Nasrin Mostafazadeh, editors, Proceedings of the 2019 Conference of the North American Chapter of the Association for Computational Linguistics: Human Language Technologies, NAACL-HLT 2019, Minneapolis, MN, USA, June 2-7, 2019, Demonstrations, pages 48–53. Association for Computational Linguistics, 2019. doi: 10.18653/v1/n19-4009. URL https://doi.org/10.18653/v1/n19-4009.
+
+Aditya Paliwal, Sarah M. Loos, Markus N. Rabe, Kshitij Bansal, and Christian Szegedy. Graph representations for higher-order logic and theorem proving. In The Thirty-Fourth AAAI Conference on Artificial Intelligence, AAAI 2020, The Thirty-Second Innovative Applications of Artificial Intelligence Conference, IAAI 2020, The Tenth AAAI Symposium on Educational Advances in Artificial Intelligence, EAAI 2020, New York, NY, USA, February 7-12, 2020, pages 2967–2974. AAAI Press, 2020. URL https://aaai.org/ojs/index.php/AAAI/article/view/5689.
+
+Isabel Papadimitriou and Dan Jurafsky. Learning Music Helps You Read: Using transfer to study linguistic structure in language models. In Proceedings of the 2020 Conference on Empirical Methods in Natural Language Processing (EMNLP), pages 6829–6839, Online, November 2020. Association for Computational Linguistics. URL https://www.aclweb.org/anthology/2020. emnlp-main.554.
+
+Charles Sanders Peirce. Reasoning and the logic of things: The Cambridge conferences lectures of 1898. Harvard University Press, 1992.
+
+Bartosz Piotrowski and Josef Urban. Guiding Inferences in Connection Tableau by Recurrent Neural Networks. In Christoph Benzmüller and Bruce Miller, editors, Intelligent Computer Mathematics, pages 309–314, Cham, 2020. Springer International Publishing. ISBN 978-3-030-53518-6.
+
+Stanislas Polu and Ilya Sutskever. Generative Language Modeling for Automated Theorem Proving. CoRR, abs/2009.03393, 2020. URL https://arxiv.org/abs/2009.03393.
+
+Markus N. Rabe, Dennis Lee, Kshitij Bansal, and Christian Szegedy. Mathematical Reasoning via Self-supervised Skip-tree Training. arXiv preprint arXiv:2006.04757, 2020.
+
+Alec Radford, Jeffrey Wu, Rewon Child, David Luan, Dario Amodei, and Ilya Sutskever. Language models are unsupervised multitask learners. In OpenAI Blog, 2018. URL https://d4mucfpksywv.cloudfront.net/better-language-models/ language_models_are_unsupervised_multitask_learners.pdf.
+
+Colin Raffel, Noam Shazeer, Adam Roberts, Katherine Lee, Sharan Narang, Michael Matena, Yanqi Zhou, Wei Li, and Peter J. Liu. Exploring the Limits of Transfer Learning with a Unified Text-toText Transformer. J. Mach. Learn. Res., 21:140:1–140:67, 2020. URL http://jmlr.org/ papers/v21/20-074.html.
+
+David Saxton, Edward Grefenstette, Felix Hill, and Pushmeet Kohli. Analysing mathematical reasoning abilities of neural models. In Proceedings of International Conference on Learning Representations (ICLR), 2019.
+
+Franco Scarselli, Marco Gori, Ah Chung Tsoi, Markus Hagenbuchner, and Gabriele Monfardini. The graph neural network model. IEEE Transactions on Neural Networks, 20(1):61–80, 2008.
+
+Imanol Schlag, Paul Smolensky, Roland Fernandez, Nebojsa Jojic, Jürgen Schmidhuber, and Jianfeng Gao. Enhancing the transformer with explicit relational encoding for math problem solving. CoRR, abs/1910.06611, 2019. URL http://arxiv.org/abs/1910.06611.
+
+Daniel Selsam and Nikolaj Bjørner. Guiding High-Performance SAT solvers with Unsat-Core Predictions. In International Conference on Theory and Applications of Satisfiability Testing, pages 336–353. Springer, 2019.
+
+Daniel Selsam, Matthew Lamm, Benedikt Bünz, Percy Liang, Leonardo de Moura, and David L. Dill. Learning a SAT solver from single-bit supervision. In 7th International Conference on Learning Representations, ICLR 2019, New Orleans, LA, USA, May 6-9, 2019. OpenReview.net, 2019. URL https://openreview.net/forum?id $\underline { { \underline { { \mathbf { \Pi } } } } } =$ HJMC_iA5tm.
+
+Kaitao Song, Xu Tan, Tao Qin, Jianfeng Lu, and Tie-Yan Liu. MASS: masked sequence to sequence pre-training for language generation. In 36th International Conference on Machine Learning, ICML 2019, Long Beach, California, USA, June 9-15, 2019, 2019. URL http://proceedings. mlr.press/v97/song19d.html.
+
+Christian Szegedy, Vincent Vanhoucke, Sergey Ioffe, Jon Shlens, and Zbigniew Wojna. Rethinking the inception architecture for computer vision. In Proceedings of the IEEE conference on computer vision and pattern recognition, pages 2818–2826, 2016.
+
+Josef Urban and Jan Jakub˚uv. First Neural Conjecturing Datasets and Experiments. In Christoph Benzmüller and Bruce Miller, editors, Intelligent Computer Mathematics, pages 315–323, Cham, 2020. Springer International Publishing. ISBN 978-3-030-53518-6.
+
+Pashootan Vaezipoor, Gil Lederman, Yuhuai Wu, Chris J. Maddison, Roger B. Grosse, Edward A. Lee, Sanjit A. Seshia, and Fahiem Bacchus. Learning Branching Heuristics for Propositional Model Counting. CoRR, abs/2007.03204, 2020. URL https://arxiv.org/abs/2007.03204.
+
+Ashish Vaswani, Noam Shazeer, Niki Parmar, Jakob Uszkoreit, Llion Jones, Aidan N. Gomez, Lukasz Kaiser, and Illia Polosukhin. Attention is All you Need. In Proceedings of Advances in Neural Information Processing Systems (NeurIPS), 2017.
+
+Mingzhe Wang, Yihe Tang, Jian Wang, and Jia Deng. Premise selection for theorem proving by deep graph embedding. In Advances in Neural Information Processing Systems, pages 2786–2796, 2017.
+
+Qingxiang Wang, Chad Brown, Cezary Kaliszyk, and Josef Urban. Exploration of neural machine translation in autoformalization of mathematics in mizar. Proceedings of ACM SIGPLAN International Conference on Certified Programs and Proofs, 2020.
+
+Alex Warstadt and Samuel R. Bowman. Can neural networks acquire a structural bias from raw linguistic data? Proceedings of CogSci, 2020.
+
+Yuhuai Wu, Albert Jiang, Jimmy Ba, and Roger Grosse. INT: An Inequality Benchmark for Evaluating Generalization in Theorem Proving. arXiv preprint arXiv:2007.02924, 2020.
+
+Keyulu Xu, Jingling Li, Mozhi Zhang, Simon S Du, Ken-ichi Kawarabayashi, and Stefanie Jegelka. What can neural networks reason about? In ICLR 2020, 2020.
+
+Kaiyu Yang and Jia Deng. Learning to Prove Theorems via Interacting with Proof Assistants. In Proceedings of International Conference on Machine Learning (ICML), 2019.
+
+Zhilin Yang, Zihang Dai, Yiming Yang, Jaime Carbonell, Russ R Salakhutdinov, and Quoc V Le. Xlnet: Generalized autoregressive pretraining for language understanding. In Advances in Neural Information Processing Systems, NeurIPS 2019, Vancouver, BC, Canada, December 8-14, 2019, 2019.
+
+Jingqing Zhang, Yao Zhao, Mohammad Saleh, and Peter J. Liu. PEGASUS: pre-training with extracted gap-sentences for abstractive summarization. In 37th International Conference on Machine Learning, ICML 2020, Vienna, Austria, 2020, volume 119. PMLR, 2020.
+
+# APPENDIX A SYNTHETIC TASK GENERATION PSEUDOCODE
+
+# Algorithm 1
+
+1: function GENERATE_TUPLE( Vocabulary size $S$ )   
+2: Vocabulary $\mathcal { V }  \{ 1 , 2 , \dotsc , S \}$ . . Use an integer representation of symbols.   
+3: Math symbol set $\mathcal { M }  \mathrm { S A M P L E } ( \mathcal { V } , n { = } 4 4 $ , replacement=False). $\triangleright$ Sample 44 distinct symbols.   
+4: Rule symbol set $\mathcal { R } \gets \mathtt { S A M P L E } ( \mathcal { V } \backslash \mathcal { M }$ , $n { = } 2 0$ , replacement=False). $\triangleright$ Sample 20 distinct symbols.   
+5: Rule $R  \operatorname { S A M P L E } ( \mathcal { M } \cup \mathcal { R }$ , $n { = }$ RANDOM(5,20), replacement=False). . Sample a sequence of   
+symbols of length between 5 and 20.   
+6: Case dictionary $C \gets \{ \}$ .   
+7: for $s$ in $\mathcal { R }$ do   
+8: Case dictionary $C [ s ] \gets \mathtt { S A M P L E } ( \mathcal { M } , n \mathop { = } \mathrm { R A N D C }$ M(2,8), replacement=True). . Sample a sequence   
+of symbols for each rule symbol, of length of length between 2 and 8.   
+9: end for   
+10: Result $R ^ { \prime } \gets { \sf R u l e } R$ . . Set result string $R ^ { \prime }$ to be the same as rule string $R$ .   
+11: for $s$ in $\mathcal { R }$ do   
+12: SUBSTITUTE $( R ^ { \prime } , s , C [ s ] )$ . $\triangleright$ Substitute every rule symbol $s$ in result string $R ^ { \prime }$ with previously   
+randomly sampled string $C [ s ]$ .   
+13: end for   
+14: return Math symbol set $\mathcal { M }$ , Rule symbol set $\mathcal { R }$ , Rule $R$ , Case $C$ , Result $R ^ { \prime }$ .   
+15: end function
+
+# APPENDIX B OTHER SYNTHETIC TASKS
+
+In this section, we give descriptions of other variants of the synthetic tasks we considered than the ones introduced in the main paper.
+
+APPENDIX B.1 RE W R I T E AND RE W R I T E_M U L T I S T E P
+
+We propose a rewrite task, inspired by the rewrite tactic used in interactive theorem provers. The Rewrite task requires the model to rewrite a string according to a rule transformation. One example of the task is:
+
+Source: $a + b - c < s > A + B = B + A$
+
+Target: $b + a - c$
+
+“ $\dot { \boldsymbol { A } } + \boldsymbol { B } = \boldsymbol { B } + \boldsymbol { A } ^ { \ast }$ “ is the rule transformation, which is applied to the LHS string $\mathbf { \dot { \boldsymbol { a } } } + \boldsymbol { b } - \boldsymbol { c } ^ { \flat }$ . The model needs to predict the RHS string as the result of the rule application, i.e., $b + a - c$ . Besides rule symbols and math symbols, we also require the third set of symbols, named as "string symbols". For the ease of our discussion, we we will think of math symbols as the union of those operators used in mathematics (e.g., $^ { 6 6 } + - * = ( ) \& ^ { 3 } )$ , rule symbols as upper case letters (e.g., $A , B , C \dots )$ , and string symbols as lower case letters (e.g., $a , b , c \ldots )$ . We first sample a random string as the LHS string, consisting of math symbols and string symbols (e.g., $a + b - c )$ . We sample a sub-string of the LHS string, and replace the string symbols in the sub-string with rule symbols. For example, we sample and obtain the substring $a + b$ from $a + b - c $ , and we replace $a , b$ with rule symbols $A , B$ . This then forms the LHS of the rule transformation, $A + B$ , with the substitution dictionary $\{ A : a , B : b \}$ . We then sample the RHS of the rule transformation from the union of rule symbols $A$ and $B$ , and all math symbols, e.g., $B + A$ . This gives the rule transformation $A + B = B + A$ . We substitute the value of the substitution dictionary for each rule symbol in the RHS rule, and then substitute back to the original LHS string to obtain $b + a - c$ . The task example is constructed by using the LHS string and the rule transformation as the source input, and use the result of the rule transformation as the target.
+
+We further introduce a multi-step version of the rewrite task: Rewrite_multistep. In this task, the source may contain more than one rewrite rule, and the target is the result of applying all the rewrite rules in a sequence. This task is motivated from the need to perform multi-step planning in mathematical reasoning tasks. During pre-training, for each training example, we uniformly sample the number of rewrite steps from 1 to 5.
+
+Table 6: Test top-1, top-10 $( \% )$ accuracy on the IsarStep task.   
+
+<table><tr><td>Model</td><td>Top-1 Acc.</td><td>Top-10 Acc.</td></tr><tr><td>No pretrain (Li et al., 2020)</td><td>20.4</td><td>33.1</td></tr><tr><td>HAT (Li et al., 2020)</td><td>22.8</td><td>35.2</td></tr><tr><td>LIME Deduct</td><td>24.7</td><td>37.7</td></tr><tr><td>LIME Abduct</td><td>26.7</td><td>41.0</td></tr><tr><td>LIME Induct</td><td>23.9</td><td>38.8</td></tr><tr><td>LIME Mix</td><td>26.9</td><td>40.4</td></tr><tr><td>LIME Rewrite</td><td>26.0</td><td>38.6</td></tr><tr><td>LIMERewrite_multistep</td><td>28.6</td><td>43.9</td></tr><tr><td>LIMEInduct_v2</td><td>25.6</td><td>39.8</td></tr><tr><td>LIMEInduct_v3</td><td>25.0</td><td>38.8</td></tr><tr><td>LIMEInduct_rewrite</td><td>25.8</td><td>39.5</td></tr></table>
+
+# APPENDIX B.2 OTHER VARIANTS OF IN D U C T TASK
+
+We introduce three other variants of the Induct task.
+
+1. Induct_v2: We move the Case dictionary from the source input to the target output. This makes the task significantly harder, which requires the agent to synthesize a rule and a possible explanation (Case) to explain the Result.   
+2. Induct_v3: Instead of providing the Case dictionary, we provide two Result strings, coming from the same Rule. Namely, we sample two Case dictionaries, and applying each to the Rule string to obtain two Result strings. Both Result strings are used as source, and the target is the Rule string.   
+3. Induct_rewrite: We also create a “induction” version of the Rewrite task. In this task, the source is the LHS string concatenated with the RHS string, that is the result of the rewrite. The target is the rewrite rule that is used to do the rewrite.
+
+# APPENDIX B.3 A FULL COMPARISON OF ALL SYNTHETIC TASKS
+
+In this section we present a full comparison for all synthetic tasks. We followed the training protocol in 4.1 and evaluate the method on IsarStep. The results are reported in Table 6. We can see that the Rewrite_multistep achieved the best performance across all synthetic tasks, surpassing the baseline by $8 . 2 \%$ for Top-1 accuracy and $1 0 . 8 \%$ for Top-10 accuracy. This indicates the inductive bias for long horizon reasoning encoded in Rewrite_multistep is very useful for the reasoning task.
+
+# APPENDIX C MORE ABLATION STUDIES
+
+APPENDIX C.1 DOES THE VOCABULARY SIZE MATTER?
+
+In this section, we investigate whether the vocabulary size $S$ in the synthetic task generation algorithm has an effect on the performance. We used the REWRITE task for the experiment in this section. We generated datasets of various vocabulary sizes, 100, 512, 1000, 5000, 25000. We used the same curriculum learning for pre-training as described in 4.1 on larger vocabulary sizes: first training on the Rewrite task of vocabulary size 100 for 10K steps, then training on each individual dataset for another 10K steps. We compare the performance on the downstream task Isarstep. The results are presented in Table 7. We see that when the vocabulary size is equal or larger than 512, the performance were similar. The smallest vocabulary size 100 obtained the worst performance among all, and all the other four models achieved similar BLEU scores. The model trained on the largest vocabulary achieved best performance on top-1 accuracy and top-10 accuracy. The results show there is a non-trivial effect of the vocabulary size of the synthetic task to the performance of the
+
+downstream task. Hence we use vocabulary size of 1000 for all the experiments in the main paper.   
+We leave investigations of the causes to future work.
+
+Table 7: Vocabulary sizes’ effects on the IsarStep task.   
+APPENDIX C.2 PRE-TRAINING ON ISARSTEP FOR METAMATHSTEP   
+
+<table><tr><td>Model</td><td>Top-1 Acc.</td><td>Top-10 Acc</td></tr><tr><td>No pretrain</td><td>20.4</td><td>33.1</td></tr><tr><td>LIME on Rewrite,S= 100</td><td>24.1</td><td>37.5</td></tr><tr><td>LIME on Rewrite,S= 512</td><td>25.4</td><td>38.8</td></tr><tr><td>LIME on Rewrite,S= 1000</td><td>26.0</td><td>38.6</td></tr><tr><td>LIME on Rewrite,S= 5000</td><td>25.8</td><td>38.5</td></tr><tr><td>LIME on Rewrite,S= 25000</td><td>27.4</td><td>40.9</td></tr></table>
+
+Following Section 5.1, we performed pre-training on IsarStep for MetaMathStep. The result is shown in Table 8. In contrast to MetaMath helping IsarStep, we see that pretraining on IsarStep task did not help the downstream task MetaMathStep. We hypothesize that this could be due to MetaMathStep task is closer to the LIME tasks than IsarStep, and hence providing more gains than the opposite direction. We leave investigations to the future versions.
+
+Table 8: Pretraining on IsarStep for the MetaMathStep task.   
+
+<table><tr><td>Model</td><td>Top-1 Acc.</td><td>Top-10 Acc.</td></tr><tr><td>No pretrain</td><td>67.7</td><td>76.5</td></tr><tr><td>LIME Mix</td><td>69.1</td><td>77.9</td></tr><tr><td>Pretrain on IsarStep</td><td>67.0</td><td>76.1</td></tr></table>
+
+# APPENDIX C.3 DOES LIME HELP LSTMS?
+
+In this section, we investigate if LIME also helps other architectures than transformers. In particular, we applied LIME to two LSTM based architectures: 1. vanilla LSTM, 2. LSTM with attention mechanism. The vanilla LSTM is a stacking LSTM with 4 layers, each with 1000 cells, and 1000- dimensional embeddings. The LSTM with attention architecture is taken from Luong et al. (2015), also with 4 layers, 1000 cells and 1000-dimensional embeddings. We evaluate on the IsarStep task, and compared a model trained from scratch and a model pre-trained on LIME abduct task. We used the same training protocol as described in 4.1. The results are shown in Table 9, along with the results on transformer. We observe that LIME improved LSTM as well as LSTM with attention, but the improvements were small compared to transformer. Specifically, if we compare Top-1 accuracy, we can see that LIME improved LSTM from $5 . 5 \%$ to $6 . { \dot { 9 } } \%$ , LSTM with attention from $1 2 . 3 \%$ to $1 3 . 4 \%$ , and transformer from $2 0 . 4 \%$ to $2 6 . 7 \%$ . This observation is aligned with our hypothesis that the transformer is a malleable architecture and hence it is capable of learning architectural inductive biases from datasets. This is mainly attributed to the potential of learning dynamic attention graphs in self-attention layers. We note that this still warrants further investigation as the performance of these architectures are not at the same level, and that may also lead to different improvements.
+
+Table 9: Comparing LIME’s benefits on LSTMs on the IsarStep Task   
+
+<table><tr><td>Model</td><td>Top-1 Acc.</td><td>Top-10 Acc.</td></tr><tr><td>LSTM</td><td>5.5</td><td>11.3</td></tr><tr><td>LSTM+LIME Abduct</td><td>6.9</td><td>14.3</td></tr><tr><td>LSTM+attention</td><td>12.3</td><td>22.7</td></tr><tr><td>LSTM+attention+LIME Abduct</td><td>13.4</td><td>26.3</td></tr><tr><td>Transformer</td><td>20.4</td><td>33.1</td></tr><tr><td>Transformer+LIME Abduct</td><td>26.7</td><td>41.0</td></tr></table>

parse/train/QHUUrieaqai/QHUUrieaqai_content_list.json

@@ -0,0 +1,1831 @@
+[
+    {
+        "type": "text",
+        "text": "LIME: LEARNING INDUCTIVE BIAS FOR PRIMITIVES OF MATHEMATICAL REASONING ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            98,
+            823,
+            146
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Anonymous authors Paper under double-blind review ",
+        "bbox": [
+            183,
+            170,
+            398,
+            198
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "ABSTRACT ",
+        "text_level": 1,
+        "bbox": [
+            454,
+            234,
+            544,
+            251
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "While designing inductive bias in neural architectures has been widely studied, we hypothesize that transformer networks are flexible enough to learn inductive bias from suitable generic tasks. Here, we replace architecture engineering by encoding inductive bias in the form of datasets. Inspired by Peirce’s view that deduction, induction, and abduction form an irreducible set of reasoning primitives, we design three synthetic tasks that are intended to require the model to have these three abilities. We specifically design these synthetic tasks in a way that they are devoid of mathematical knowledge to ensure that only the fundamental reasoning biases can be learned from these tasks. This defines a new pre-training methodology called “LIME” (Learning Inductive bias for Mathematical rEasoning). Models trained with LIME significantly outperform vanilla transformers on three very different large mathematical reasoning benchmarks. Unlike dominating the computation cost as traditional pre-training approaches, LIME requires only a small fraction of the computation cost of the typical downstream task. ",
+        "bbox": [
+            232,
+            265,
+            766,
+            458
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 INTRODUCTION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            483,
+            336,
+            500
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Inductive bias is essential for successful neural network learning. Many of the breakthroughs in machine learning are accompanied by new neural architectures with better inductive biases, such as locality bias in convolutional neural networks (LeCun et al., 1999), recurrence and memory in LSTMs (Hochreiter and Schmidhuber, 1997), and structural bias in graph neural networks (Scarselli et al., 2008). However, existing designs of inductive biases need to be explicitly encoded in neural architecture. This is sometimes difficult as one may not know the exact mechanism for an abstract ability, in order to describe the architectural bias explicitly. In particular, designing proper inductive bias for abstract concepts such as mathematical reasoning becomes an extremely challenging task. Moreover, attempts to design elaborate architectures for reasoning often fall short of the performance of more generic transformer architecture. In this work, we aim to avoid the search for new architectures and investigate whether one can learn useful inductive bias for mathematical reasoning through pretraining. ",
+        "bbox": [
+            174,
+            513,
+            825,
+            681
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Large-scale unsupervised pretraining of language models revolutionized the field of natural language processing (NLP), improving the state-of-the-art in question answering, name entity recognition, text classification, and other domains, e.g. (Radford et al., 2018; Devlin et al., 2019; Yang et al., 2019; Liu et al., 2019; Raffel et al., 2020; Brown et al., 2020). As a result, pretraining has become a common practice for modern neural network based NLP. One plausible explanation for the benefit of pretraining is that the model can learn world knowledge by memorizing the contents of the natural language corpus. This can be useful in various natural language downstream tasks, such as question answering and text classification. However, there is another potential advantage of pre-training—it may distill inductive biases into the model that are helpful for training on downstream tasks (Brown et al., 2020; Warstadt and Bowman, 2020). We focus on the latter and design pre-training tasks that are intentionally devoid of knowledge and only allow the model to learn inductive bias for reasoning. ",
+        "bbox": [
+            174,
+            688,
+            825,
+            840
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Inspired by the logician Charles Peirce (Peirce, 1992), we believe that the following three primitives are the most crucial for reasoning: ",
+        "bbox": [
+            173,
+            847,
+            825,
+            876
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1. Deduction: the ability to deduce new truths from given facts and inference rules.   \n2. Induction: the ability to induce general inference rules from a set of known facts.   \n3. Abduction: the ability to explain the relationship between the evidences and inference rules. ",
+        "bbox": [
+            212,
+            882,
+            825,
+            924
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "To endow the models with an inductive bias for mathematical reasoning, we design a synthetic task for each of the three inductive biases. We hypothesize that the transformer networks are flexible enough to learn strong inductive bias from the three synthetic reasoning tasks and consequently improving the downstream tasks. Although such inductive bias may be useful in general reasoning tasks (e.g., NLP tasks), in this work, we focus on mathematical reasoning benchmarks, for which we expect to observe the largest gains. We call training on these tasks LIME – an acronym for “Learning Inductive Bias for Mathematical rEasoning”. Note that there is only a limited amount of pretraining data available for formal mathematical benchmarks, therefore the study of generic pre-training techniques is particularly important for the success of machine learning in mathematical reasoning. ",
+        "bbox": [
+            173,
+            103,
+            825,
+            242
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "We demonstrate that LIME pretrained models provide significant gains across three large mathematical reasoning benchmarks: IsarStep (Li et al., 2020), HOList Skip-tree (Rabe et al., 2020) and MetaMathStep (Polu and Sutskever, 2020). Notably, on the IsarStep benchmark, pre-training improved the top-1 accuracy from $2 0 . 4 \\%$ to $2 6 . 9 \\%$ and top-10 accuracy from $3 3 . 1 \\%$ to $4 1 . 0 \\%$ . Compared to the traditional pre-training tasks, there are two major differences. First, we do not load the input embeddings or the weights in the output layer for finetuning on downstream tasks. This allows us to use the same pre-trained model for a variety of downstream tasks, which can have vastly different vocabularies due to language or tokenization differences. Also, it prevents the transfer of content knowledge from the pretraining to downstream tasks, supporting the evidence of learning inductive biases. Furthermore, pretraining on synthetic tasks require only a fraction of the computational cost of downstream tasks. With only about two hours of training on a single modern GPU, one already obtains all the benefits, in contrast to days of training on a large natural language corpus with hundreds of GPUs/TPUs. ",
+        "bbox": [
+            174,
+            250,
+            826,
+            429
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Our method can also be regarded as a form of curriculum learning, in which the model is taught basic, extremely generic but general skills before being trained on the specific problem domain. ",
+        "bbox": [
+            174,
+            436,
+            823,
+            465
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "To summarize, the contributions of the paper are: ",
+        "bbox": [
+            174,
+            472,
+            495,
+            487
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "1. Providing the first method to design inductive biases in the form of datasets for mathematical reasoning.   \n2. Demonstrating significant improvements in the reasoning performance of transformer models on three large mathematical reasoning benchmarks with negligible extra computation cost.   \n3. By showing how pretraining brings benefits other than learning content knowledge, disentangling the study of its working mechanism. ",
+        "bbox": [
+            173,
+            491,
+            826,
+            594
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2 RELATED WORK ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            618,
+            344,
+            633
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Learning Models Applied to Mathematics There has been increasing interest in applying deep learning methods to Interactive Theorem Provers (ITP) (Bansal et al.; 2019; Gauthier et al., 2020; Huang et al., 2019; Yang and Deng, 2019; Wu et al., 2020; Li et al., 2020; Polu and Sutskever, 2020). The work that is most related to ours is GPT- $f$ (Polu and Sutskever, 2020). The authors performed pretraining on several natural language corpora and showed significant improvements for an ITP system – MetaMath. Different from ours, they used GPT-style large-scale language modeling pretraining, which dominates the computation cost compared to the downstream task. We, on the other hand, propose pretraining on a few lightweight synthetic tasks costing only a minor fraction of the computation spent on the downstream task. ",
+        "bbox": [
+            173,
+            652,
+            825,
+            777
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Lample and Charton (2020) have demonstrated that transformer models can be used for symbolic mathematics by successfully predicting the integrals of formulas from a randomly generated dataset. Similar observations are made for logical problems relevant to verification: that transformer networks can learn the semantics of logics (Hahn et al., 2020). Rabe et al. (2020) have shown that mathematical reasoning can emerge from self-supervised training alone. Li et al. (2020) show that language models can learn to synthesize missing high-level intermediate propositions given a local context. Piotrowski and Urban (2020) used RNNs in automated theorem provers for first-order logic. Wang et al. (2020) explored the use of machine translation to translate between synthetically generated natural language descriptions of proofs and formally represented proofs. Urban and Jakub˚uv (2020) present initial experiments on generating mathematical conjectures with a Transformer model. ",
+        "bbox": [
+            174,
+            785,
+            825,
+            924
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Saxton et al. (2019) suggest a dataset for the analysis of mathematical reasoning skills. In contrast to the datasets considered here, their dataset is synthetic, focuses on calculation with concrete numbers, and only contains relatively few symbolic tasks. ",
+        "bbox": [
+            174,
+            103,
+            823,
+            146
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Language Model Pretraining The advent of the transformer architecture (Vaswani et al., 2017) and the BERT style pretraining (Devlin et al., 2019) represented a huge improvement in the quality of language modeling. Since then, an explosion of research activity in the area pushed the quality of language models through better pretraining tasks. Where BERT (Devlin et al., 2019) masks out a fraction of the input tokens, later works demonstrated the advantages of masking out subsequences (Song et al., 2019; Dong et al., 2019; Joshi et al., 2020; Raffel et al., 2020; Conneau and Lample, 2019) and whole sentences (Zhang et al., 2020). ",
+        "bbox": [
+            174,
+            161,
+            825,
+            260
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Besides the choice of pretraining tasks, the scale of language models is also an important factor. Language models improve in quality and develop new abilities as they grow larger while trained on the same data (Radford et al., 2018; Raffel et al., 2020; Brown et al., 2020). ",
+        "bbox": [
+            176,
+            266,
+            823,
+            309
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Inductive Biases in General There have been works studying learning inductive biases in other contexts. In particular, McCoy et al. (2020) studied whether one can learn linguistic inductive biases on synthetic datasets via meta-learning. Papadimitriou and Jurafsky (2020) shows inductive biases learned in music data can be useful for natural language. They further designed several synthetic tasks and showed similar kind of improvements for natural language tasks. From a more theoretical point of view, Xu et al. (2020) formalize an aspect of inductive (architectural) bias under the context of GNNs, with a notation called architectural alignment. The architecture is aligned when the architecture can perfectly simulates the ground truth solution. But their work is limited to showing alignment in combinatorial problems, whose ground truth solutions are known. In contrast, our work tries to learn architectural bias by relying on the flexible Transformer architecture and training on synthetic datasets. ",
+        "bbox": [
+            173,
+            324,
+            825,
+            477
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Inductive Biases for Mathematics Previous work studying inductive biases for logical reasoning has focused on encoding bias in the neural architecture. Initial works focused on encoding the tree structure of expressions using TreeRNNs (Evans et al., 2018). Graph neural networks are shown to provide a much stronger performance than tree models in premise selection (Wang et al., 2017) and theorem proving (Paliwal et al., 2020). GNNs also scale to larger formulas in SAT (Selsam et al., 2019; Selsam and Bjørner, 2019; Han, 2020), QBF (Lederman et al., 2020), and #SAT (Vaezipoor et al., 2020). Crouse et al. (2019) have shown that pooling mechanisms can have an impact on the performance of GNNs on logical formulas as well. Closely related, Hellendoorn et al. (2020) have shown that it can be helpful to hard-code the tree structure of programs in the attention mask of transformers. Schlag et al. (2019) developed an architecture for encoding relational information using tensor product representation for mathematical reasoning. ",
+        "bbox": [
+            173,
+            493,
+            825,
+            647
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3 METHODS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            659,
+            290,
+            674
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "In this section, we first discuss the primitives of reasoning, inspired by Peirce’s views, and design one synthetic task for each reasoning primitive. ",
+        "bbox": [
+            176,
+            690,
+            823,
+            718
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3.1 REASONING PRIMITIVES ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            727,
+            387,
+            742
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "In Peirce’s view, there are exactly three kinds of reasoning: deduction, abduction, and induction. Deduction is known as the workhorse for mathematics. It is the process of deriving new facts by applying logical inference rules to known facts or premises. On the other hand, abduction and induction can be thought of as the inverses of deduction. If we call the premise used in deduction as Case, its logical rule as Rule, and its conclusion as Result, then abduction is equivalently the inference of a Case from a Rule and a Result, while induction may be said to be the inference of a Rule from a Case and a Result. We summarize the three reasoning primitives in the following table: ",
+        "bbox": [
+            173,
+            752,
+            825,
+            852
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "table",
+        "img_path": "images/bbcc3f63d963c1bdb64a158cec8ae17e67d73ab26fd6cf42aff261648bdcaeeb.jpg",
+        "table_caption": [],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=1 colspan=1>Reasoning Primitives</td><td rowspan=1 colspan=1>Inference Map</td></tr><tr><td rowspan=1 colspan=1>Deduction</td><td rowspan=1 colspan=1>Rule, Case→Result</td></tr><tr><td rowspan=1 colspan=1>Abduction</td><td rowspan=1 colspan=1>Rule,Result→Case</td></tr><tr><td rowspan=1 colspan=1>Induction</td><td rowspan=1 colspan=1>Case,Result→Rule</td></tr></table>",
+        "bbox": [
+            334,
+            864,
+            663,
+            928
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "To give an example, we let Rule be “All the beans in this bag are white”, Case be “These beans are from this bag”, and Result be “These beans are white”. Deduction is to derive the fact that these beans are white (Re) from knowing all the beans from this bag are white (R) and these beans are from this bag (C). Abduction explains why the beans are white (Re) from knowing that all the beans in the bag are white (R) – because these beans must be from the bag (C). Lastly, induction aims to provide a general principle to observing the fact that the beans are white (Re) and they come from this bag (C), which is that all the beans in the bag must be white (R). We refer to Peirce (1992) and Bellucci and Pietarinen (2015) for more elaborate discussions on the primitives of reasoning. ",
+        "bbox": [
+            173,
+            103,
+            825,
+            215
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Mathematical reasoning exhibits nontrivial uses of these reasoning primitives. Deduction happens when one needs to derive new valid statements from the given premise (Case) and theorems in the library (Rule). Abduction is used to postulate conjectures from the known facts and theorems, allowing one to decompose the challenging theorem into subgoals for proof. Induction, the ability to extract general principles from known facts and theorems is also one of the major activities of mathematical reasoning. It is used when one derives theorems from special cases and proposes new definitions and general frameworks to encapsulate existing knowledge. ",
+        "bbox": [
+            174,
+            222,
+            825,
+            319
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3.2 LIME SYNTHETIC TASKS FOR REASONING PRIMITIVES ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            337,
+            602,
+            352
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "We design three synthetic tasks inspired by the three reasoning primitives. As discussed in the previous section, all of the reasoning primitives consist of three essential elements: Rule, Case, and Result. Inspired by this, we first design a method to generate those elements. Once they are generated, we can construct tasks that predict one element from the other two. In the following, we describe one simple way to generate those three elements, though we acknowledge that there are many other possible approaches. ",
+        "bbox": [
+            174,
+            363,
+            825,
+            446
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "We require two types of symbols: 1. math symbols, 2. rule symbols. In general, these symbols can take any forms (e.g., integer representations). But for the ease of discussion, we will think of math symbols as the union of those operators used in mathematics (e.g., $^ { * * } + - * = ( ) \\ell \\boldsymbol { \\mathrm { v } } )$ and lower case letters (e.g., $a , b , c \\ldots )$ , and rule symbols as upper case letters (e.g., $A , B , C \\dots )$ . We now construct Rule, Case, and Result in order: ",
+        "bbox": [
+            173,
+            454,
+            825,
+            523
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "1. Rule is a randomly sampled string that consists of i) rule symbols and ii) math symbols. The length of the string is randomly sampled from a range. For instance, a randomly sampled rule can be: $A * A + B = C$ with rule symbols $A , B$ , and $C$ .   \n2. Case is a dictionary that represents substitutions. For each rule symbol used in the Rule string, we sample a random string of random length that consists of math symbols. This forms a dictionary, whose keys are all rule symbols, and the values are the corresponding sampled string. To illustrate, following the previous example, for each $A$ , $B$ and $C$ , we sample a random string to form a dictionary as: $\\left\\{ A : a , B : b , { \\bar { C } } : d + e \\right\\}$ .   \n3. Result is the outcome of the substitution. For each rule symbol in the Rule string, we replace it with the corresponding value stored in the Case dictionary. This gives rise to the Result string. As per the previous example, we now substitute $A$ with $a$ , $B$ with $b$ , and $C$ with $d + e$ into the Rule string, generating the Result string: $a * a + b = d + e$ . ",
+        "bbox": [
+            173,
+            537,
+            826,
+            717
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "After Rule, Case, and Result are generated, we can construct three tasks for deduction, abduction, and induction respectively. We define the three synthetic tasks as follows: ",
+        "bbox": [
+            169,
+            729,
+            825,
+            758
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "• Deduct: Source: Rule string and Case dictionary. Target: Result string.   \n• Abduct: Source: Rule string and Result string. Target: Case dictionary.   \n• Induct: Source: Case dictionary and Result string. Target: Rule string. ",
+        "bbox": [
+            214,
+            762,
+            717,
+            815
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "We also consider a task called Mix, which is a uniform mix of three tasks. Namely, during generation, we randomly select a task and sample an example from that task. To formulate them as sequence to sequence tasks, we represent the Case dictionary also as a string, e.g., $\\ ^ { * } \\{ A : a , B : b , C : d + e \\} ^ { , }$ . An example of Abduct using the examples of Rule, Case, and Result above is to predict the target $\\{ A : a , { \\bar { B } } : b , C : d + e \\}$ from the source $A * A + B = C < s > a * a + b = d + e .$ . ",
+        "bbox": [
+            174,
+            819,
+            825,
+            888
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Pre-training on our synthetic tasks can be seen as a form of skip-component learning. There are three essential components: Rule, Case and Result, and we skip one of them and use the remaining two elements to reconstruct the missing one. Past work has shown that learning to predict missing words (Devlin et al., 2019), subsequences (Song et al., 2019; Raffel et al., 2020), or subtrees (Rabe et al., 2020) are strong pre-training tasks. ",
+        "bbox": [
+            173,
+            895,
+            823,
+            924
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            176,
+            103,
+            825,
+            146
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "3.3 SYMBOL-AGNOSTIC REPRESENTATION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            169,
+            483,
+            183
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "In order to solve the synthetic tasks, the model needs to distinguish which set of symbols can be substituted (rule symbols). As a result, the model may memorize information about the symbols that is irrelevant to the inductive biases encoded in the task. To prevent such memorization, we propose a way to make the synthetic tasks agnostic to the choice of symbols. ",
+        "bbox": [
+            174,
+            196,
+            825,
+            252
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "We first note that the choice of symbols is irrelevant to our synthetic tasks. To avoid symbol-specific memorization, for each training and evaluation example, we randomly sample two sets of symbols to be used in Rules and in the rest of the example. But for the Abduct task, the model needs to know which symbols are replaced by the Rule part of the example and which symbols are in the Result language. We simply list the split of the symbols used in the example at the beginning of the input string, marked by two special symbols, ${ \\mathrm { < R u l e > } }$ and <Math>. They are followed by the original source string. The target string remains unchanged. For example, the previous example in the Abduct task becomes, ",
+        "bbox": [
+            174,
+            260,
+            825,
+            372
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/13dac06d183c44371116316349d705b9dac11e5532f5e9230fb03222873cc934.jpg",
+        "text": "$$\n< \\mathtt { R u l e } > A \\ B \\ C < \\mathtt { M a t h } > * + = a b d e < \\mathtt { s } > A * A + B = C < \\mathtt { s } > a * a + b = d + e ^ { - }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            225,
+            377,
+            797,
+            393
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Target: $\\{ A : a , B : b , C : d + e \\}$ ",
+        "bbox": [
+            174,
+            398,
+            395,
+            415
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "In our implementation, we use integers to represent symbols. Specifically, for each example, we sample two disjoint sets of integers from the set $\\{ 1 , \\ldots , S \\}$ to represent the math symbols and the rule symbols, where $S$ is the size of the vocabulary. In our experiments, we sample 44 math symbols and 24 rule symbols for each problem. The complete pseudo-code of generating the symbols, Rule, Case, and Result for one task example is provided in Appendix Algorithm 1. ",
+        "bbox": [
+            174,
+            421,
+            825,
+            491
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "4 EXPERIMENTS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            517,
+            326,
+            532
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "In this section, we present results on three large mathematical reasoning tasks that are especially useful in the context of automated theorem proving. Our results show significant gains in learning inductive biases from synthetic tasks. We have selected three tasks to cover three different styles of interactive theorem provers: The HOL-Light (skip-tree) corpus was created from very high-level tactic-based proofs, but it is less interpretable than IsarStep’s declarative style corpus. We also evaluate the next proof-step prediction task on the set.mm library of MetaMath, which consists of very granular, basic proof steps. Namely, the proof steps are more predicable and average proof lengths have significantly increased. ",
+        "bbox": [
+            174,
+            553,
+            825,
+            664
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "4.1 EXPERIMENT DETAILS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            686,
+            372,
+            702
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "LIME Pretraining We generate datasets of our synthetic tasks for pretraining: Deduct, Abduct, Induct, Mix. For pretraining of IsarStep, we used a vocabulary size $S$ of 1000. For the other two downstream tasks, we used a vocabulary size of 100. The reason we used different vocabulary sizes was that we found (cf. appendix) the discrepancy in vocabulary size affects the performance of a downstream task if it has a very large vocabulary size (IsarStep has 28K). We use 44 math symbols and 24 rule symbols. The length of the Rule string is sampled from 5 to 20, the length of the string for each substitution (the values of Case dictionary) is sampled from 2 to 8. We used word-level tokenization for all the tasks. We pretrained the model for 20K updates. For tasks with larger vocabulary size (i.e., 1000), we found the learning became more difficult. Hence we used a curriculum learning scheme: we first trained the model for 10K steps on the same task with a vocabulary size of 100, then continue training for another 10K step on vocabulary size of 1000. The pretraining was done on a single Nvidia Tesla T4 GPU with 4 CPU cores for 2 hours. We set the maximum number of tokens in a batch to 4096, and accumulate four batches of gradients for one parameter update. We used the Adam optimizer (Kingma and Ba, 2015) with learning rate $3 \\cdot 1 0 ^ { - 4 }$ We used a dropout rate of 0.1 and label smoothing (Szegedy et al., 2016) with a coefficient 0.1. ",
+        "bbox": [
+            174,
+            715,
+            825,
+            924
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "table",
+        "img_path": "images/a257066bcd989cc932ff5dbf9d6b592da336a1d927552b24da18709b8d7cdf57.jpg",
+        "table_caption": [
+            "Table 1: Test top-1, top-10 $( \\% )$ accuracy on the IsarStep task. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Model</td><td>Top-1 Acc.</td><td>Top-10 Acc.</td></tr><tr><td>No pretrain (Li et al., 2020)</td><td>20.4</td><td>33.1</td></tr><tr><td>HAT (Li et al., 2020)</td><td>22.8</td><td>35.2</td></tr><tr><td>LIME Deduct</td><td>24.7</td><td>37.7</td></tr><tr><td>LIME Abduct</td><td>26.7</td><td>41.0</td></tr><tr><td>LIMEInduct</td><td>23.9</td><td>38.8</td></tr><tr><td>LIME Mix</td><td>26.9</td><td>40.4</td></tr></table>",
+        "bbox": [
+            284,
+            127,
+            709,
+            248
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "table",
+        "img_path": "images/3ce634cc7b9adbd7ca1992fecdd510a67e2b47765b40c5c74eb0f59f6baf8d75.jpg",
+        "table_caption": [
+            "Table 2: Test top-8 Accuracy on Skip-Tree HOList $( \\% )$ . "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Model</td><td>Equation completion</td><td>Hard type inference</td><td>Missing assumptions</td><td>Easy type inference</td></tr><tr><td>No pretrain (Rabe et al., 2020)</td><td>46.3</td><td>95.0</td><td>41.8</td><td>95.9</td></tr><tr><td>LIME Deduct</td><td>50.3</td><td>94.8</td><td>47.9</td><td>97.0</td></tr><tr><td>LIME Abduct</td><td>48.4</td><td>94.8</td><td>46.1</td><td>96.3</td></tr><tr><td>LIME Induct</td><td>44.8</td><td>94.9</td><td>42.6</td><td>96.4</td></tr><tr><td>LIME Mix</td><td>51.7</td><td>95.6</td><td>46.1</td><td>97.6</td></tr></table>",
+        "bbox": [
+            174,
+            301,
+            825,
+            381
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Fine-tuning For all the downstream tasks in this section, when loading the pretrained models for fine-tuning, we do not load in the vocabulary embeddings nor the output layer weights. For the downstream task IsarStep and MetaMathStep, we used four Nvidia Tesla T4 GPU with $1 6 \\mathrm { \\ C P U }$ cores for training. We set the maximum number of tokens in a batch to 4096, and accumulated four batches of gradients for one parameter update. We trained the model for 200K updates. We used the Adam optimizer, and we searched over the learning rates $\\{ 3 \\cdot 1 0 ^ { - 4 } , 7 \\cdot 1 0 ^ { - 4 } \\}$ , and warmup steps $\\{ 4 0 0 0 , \\bar { 8 0 0 0 } \\}$ . We used a dropout rate of 0.1 and label smoothing with a coefficient 0.1. For the HOList skip-tree task, we used TPUs for running the experiments. We used a batch size of 256 sequences and trained the model for 1 million updates. ",
+        "bbox": [
+            173,
+            397,
+            825,
+            522
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Architecture All experiments used the transformer base model from Vaswani et al. (2017), i.e. 512 hidden size, 2048 filter size, 8 attention heads. For the IsarStep and MetaMathStep task, we used 6 layers for both the encoder and decoder, implemented using fairseq (Ott et al., 2019). For the HOList skip-tree experiment, we used a somewhat modified transformer architecture with 8 encoder and 4 decoder layers of the same size as above in which the self-attention and attention over the encoder output were merged. ",
+        "bbox": [
+            173,
+            540,
+            825,
+            623
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Evaluation During training, we kept track of the best validation tokenized BLEU score 1, and we used the model with validation BLEU for evaluation on the test set. We report top-1 and top-10 accuracies. We consider an output sequence as correct if it matches the target sequence exactly. We performed a beam search with width 10. The top-1 accuracy is then defined as the percentage of the best output sequences that are correct. The top- $\\mathbf { \\nabla } \\cdot n$ accuracy is defined as the percentage of target sequences appearing in the top $n$ generated sequences. ",
+        "bbox": [
+            174,
+            641,
+            825,
+            726
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "4.2 ISARSTEP ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            744,
+            284,
+            758
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "The IsarStep task is taken from Li et al. (2020). IsarStep is a task of predicting the missing intermediate propositions given surrounding propositions to bridge the gap between the goal and the current state of the proof. The dataset was mined from the public repository of formal proofs of the Isabelle proof assistant (Paulson, 1994). Unlike HOList and MetaMath, IsarStep contains mostly declarative proofs, a proof style close to humans’ prose proofs. The dataset has a broad coverage of undergraduate and research-level mathematics and computer science theorems. There are 820K, 5000, 5000 sequence pairs for the training, validation, and test sets with a maximum of 800 tokens in source sequences and 200 tokens in the target sequences. Following Li et al. (2020), during training, we use 512 as the ",
+        "bbox": [
+            173,
+            771,
+            826,
+            883
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "table",
+        "img_path": "images/a680a39735a308c7dc947d18f7851d0ed8766e23120b3e9de0acea9d78a9fe97.jpg",
+        "table_caption": [
+            "Table 3: Test top-1, top-10 $( \\% )$ accuracy on the MetaMathStep task. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Model</td><td>Top-1 Acc.</td><td>Top-10 Acc.</td></tr><tr><td>No pretrain</td><td>67.7</td><td>76.5</td></tr><tr><td>LIME Deduct</td><td>68.8</td><td>77.4</td></tr><tr><td>LIME Abduct</td><td>68.8</td><td>76.1</td></tr><tr><td>LIME Induct</td><td>69.9</td><td>78.0</td></tr><tr><td>LIME Mix</td><td>69.1</td><td>77.9</td></tr></table>",
+        "bbox": [
+            331,
+            126,
+            660,
+            229
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "maximum length for both the source and target, and truncated those that exceed the length to 512.   \nFor reporting, we evaluate all 5000 test examples regardless of their lengths. ",
+        "bbox": [
+            171,
+            243,
+            825,
+            271
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "The results on the IsarStep task for four pretrained models and the baseline transformer model without pretraining is shown in Table 1. We also include another baseline, HAT transformer introduced in Li et al. (2020), which is a specially designed hierarchical transformer architecture tailored to this task. We see the pretrained model achieved substantial improvement over the model trained from scratch as well as HAT. Notably, the model that was pretrained on Abduct improved the top-10 accuracy from $3 3 . 1 \\%$ to $4 1 . 0 \\%$ , for almost $8 \\%$ absolute improvement. The model pretrained on $\\mathbb { M } \\mathrm { i } \\times$ performed the best on top-1 accuracy, improving the baseline by $6 . 5 \\%$ accuracy. We also showed the validation BLEU scores along training in Figure 1. We can see that the pretrained models learned much faster than the model trained from scratch. With around 50K steps of updates, the pretrained model already obtained better BLEU scores than the best score achieved by the un-pretrained model. Moreover, since the downstream task requires 200K steps of training with 4 GPUs, the amount of computation spent on pretraining is only $2 . 5 \\%$ of the downstream task, strongly demonstrating the efficiency of the proposed pretraining method. ",
+        "bbox": [
+            174,
+            279,
+            517,
+            498
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/10d71f0acfa4d0f15245d0060288c8fd8ef4d2d1a3642ee96b4096cc10a97096.jpg",
+        "image_caption": [
+            "Figure 1: Validation BLEU along training on the IsarStep task. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            545,
+            281,
+            797,
+            438
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            500,
+            825,
+            569
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "4.3 HOLIST SKIP-TREE ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            593,
+            354,
+            607
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "As the second mathematical reasoning benchmark we consider the HOList skip-tree evaluation tasks by Rabe et al. (2020). These tasks include two variants of type inference, predicting under which assumptions theorems hold, and completing equalities. All source expressions for these tasks are taken from the validation set of the theorem database of the HOList proof logs (Bansal et al.). The evaluations are done on a random sample of 1000 instances from the full evaluation sets. We initialized the model parameters with the pretrained weights and then repeated the experiments by Rabe et al. (2020). That is, we trained the models for up to 1M parameter updates on the training set with batch size 256 and repeat the evaluation every 100K steps. In Table 2 we present the best result from these 10 evaluation runs. We see a significant improvement in these reasoning tasks when the models are initialized with the pretrained weights. Notably, on equation completion and missing assumptions task, we improved the beam search (with width 8) exact match rate performance from $4 6 . 3 \\%$ to $5 1 . 7 \\%$ and $4 1 . 8 \\%$ to $4 7 . 9 \\%$ . Note that this is despite the amount of pretraining compute cost being negligible: it takes less than 1 percent of the cost of the downstream task training. Pretraining used $1 / 2 0$ number of the update steps (50K vs 1M) with 8 (and 4) times smaller batches (pretraining has much shorter sequence lengths, 128 vs. 1024 and 512, respectively). ",
+        "bbox": [
+            174,
+            621,
+            825,
+            829
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "4.4 METAMATHSTEP ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            853,
+            334,
+            867
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Compared to other ITPs, MetaMath is a low-level proving system: each proof step makes only a small step towards the goal. As such, each proof contains many more proof steps than in other ITPs: with 37, 000 theorems in the human-written theorem library, there are around 3 million proof steps. ",
+        "bbox": [
+            176,
+            882,
+            825,
+            922
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "table",
+        "img_path": "images/727d681430aceca8bd3de53210726587a8535060761088d0628eee6c6f59bc08.jpg",
+        "table_caption": [
+            "Table 4: Comparisons to other pretraining tasks on IsarStep task. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Model</td><td>Top-1 Acc.</td><td>Top-10 Acc</td></tr><tr><td>No pretrain (Li et al., 2020)</td><td>20.4</td><td>33.1</td></tr><tr><td>LIME Mix</td><td>26.9</td><td>40.4</td></tr><tr><td>Pretrain on MetaMathStep</td><td>23.1</td><td>35.7</td></tr><tr><td>Pretrain on WMT En-De</td><td>17.2</td><td>30.3</td></tr></table>",
+        "bbox": [
+            302,
+            127,
+            696,
+            213
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "We extract the proof steps and use them to construct a sequence-to-sequence task following Polu and Sutskever (2020) (their proof step training objective). ",
+        "bbox": [
+            174,
+            241,
+            823,
+            268
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "In this task, the model is asked to generate PROOFSTEPS given a GOAL, namely, the GOAL string is the source input, and PROOFSTEPS is the target output. We follow Polu and Sutskever (2020) and use their string representation for the GOAL and the PROOFSTEPS. Instead of using subword tokenization in Polu and Sutskever (2020), we use a character-level representation for our task. Following Polu and Sutskever (2020), we split theorems into train/valid/test theorems of size 35K, 1K, 1K, and associate all proof steps of a theorem with that split. For each dataset, we filter examples with lengths longer than 1024. This reduced the total number of proof steps to 1.4 million. For validation and test set, we randomly sample 3000 examples out of 40K (after filtering) and perform validation and test evaluations on them. In Table 3 we present the impact of pretraining on our synthetic reasoning tasks on MetaMathStep. We also observe gains from pretraining on this dataset, with the model trained on Induct task achieving $2 . 2 \\%$ top-1 and $1 . 5 \\%$ top-10 test accuracy improvement. Similarly, as for the IsarStep task, the computation spent on pretraining is only $2 . 5 \\%$ of the downstream task. ",
+        "bbox": [
+            173,
+            275,
+            825,
+            455
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "5 ABLATION STUDIES ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            478,
+            372,
+            494
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "In this section, we perform ablation studies. Additional ablation studies can be found in Appendix C. ",
+        "bbox": [
+            173,
+            511,
+            823,
+            525
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "5.1 PRETRAINING ON FORMAL REASONING AND NATURAL LANGUAGE TASKS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            545,
+            730,
+            559
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Here we investigate how LIME compares to pretraining on natural language or existing formal reasoning datasets. In this set of experiments, we pretrained three models on Mix, MetaMathStep, and on the WMT 2016 English-to-Germany (WMT En-De) translation task, and then we fine-tuned and evaluated these models on the IsarStep task. We pretrained the model on MetaMathStep and WMT EN-DE for 200K steps with 4 GPUs, which is 40 times more computation spent than on LIME. Due to the mismatch between vocabularies of the pretraining task and the downstream task, we do not load the vocabulary embeddings nor output layer weights. The results in Table 4 show that pretraining on MetaMathStep did provide gains, though significantly smaller than gains provided by LIME Mix, despite their 40 times higher computational cost. Moreover, pre-training on WMT translation had even a negative effect on the performance. We also conducted an analogous experiment with an evaluation on the MetaMathStep, which we present in Appendix C. ",
+        "bbox": [
+            174,
+            571,
+            826,
+            724
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "5.2 DO WE NEED VOCABULARY EMBEDDINGS FOR FINE-TUNING? ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            744,
+            640,
+            757
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "As mentioned earlier, we did not load in the vocabulary embeddings from the pretrained models when we switched to fine-tuning on downstream tasks. Even without loading the vocab embeddings, the pretrained models still improved the performance. In this ablation study, we investigate how much this decision has affected the results and whether vocabulary embeddings can help improve the performance even further. We performed the comparisons on IsarStep. The task contains a token vocabulary of size 28336. We generated new synthetic tasks for the same vocabulary size, such that we can load the vocabulary embeddings and output layers when initializing the model for IsarStep. Table 5 shows that this led to similar performance. This aligns with our expectation that the model should not learn content specific knowledge that is potentially stored in the vocabulary. These weights turn out to be non-essential for the final performance, supporting the evidence that the transformer learns inductive biases from the pretraining task. ",
+        "bbox": [
+            174,
+            770,
+            825,
+            924
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "table",
+        "img_path": "images/6f6ae9368dafd5838c593d2665e68bd69c9c162a0e0fa47d211539c760d567c0.jpg",
+        "table_caption": [
+            "Table 5: Whether one needs to load vocabulary embeddings and output layer weights on IsarStep tasks. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Model</td><td>Top-1 Acc.</td><td>Top-10 Acc</td></tr><tr><td>No pretrain (Li et al., 2020)</td><td>20.4</td><td>33.1</td></tr><tr><td>LIME Mix</td><td>26.9</td><td>40.4</td></tr><tr><td>LIME Mix + Loading All Weights</td><td>26.7</td><td>40.6</td></tr></table>",
+        "bbox": [
+            277,
+            141,
+            718,
+            213
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "6 DOES LIME ENCODE INDUCTION, DEDUCTION AND ABDUCTION? ",
+        "bbox": [
+            169,
+            237,
+            754,
+            253
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Although LIME has shown to achieve substantial improvements across various benchmarks, it is not entirely clear that the specific synthetic tasks necessarily enforce the reasoning ability of induction, deduction and abduction. We would like to note that deduction, induction, and abduction are highlevel and philosophical concepts, and serve only as an inspiration for us to design the synthetic tasks. We do not expect the model will necessarily learn exactly these three capabilities. After all, we have chosen a particular implementation of \"Case\", \"Rule\" and \"Result\". Furthermore, we also design tasks mimic proof steps in formal theorem proving (see the rewrite task in Appendix B.1), which also achieved excellent results. Nevertheless, we believe LIME is a first step towards building reasoning inductive biases, and provides many inspirations and directions for future work. ",
+        "bbox": [
+            173,
+            267,
+            826,
+            393
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "7 CONCLUSION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            405,
+            320,
+            420
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "In this work, we encoded inductive biases for mathematical reasoning in the form of datasets. We created three synthetic tasks inspired by three reasoning primitives of deduction, induction, and abduction. We demonstrated that pretraining on these tasks (LIME) significantly improved the performances across three mathematical reasoning benchmarks. Notably, LIME requires negligible computation compared to the downstream task, unlike being the dominating factor in previous pretraining methods. Our work naturally poses many future research questions. Could the primitive tasks provide similar gains for NLP tasks? Are there similar primitive tasks for natural language reasoning? We also look forward to disentangling the effects of pretraining between learning content knowledge and inductive bias for all downstream tasks to better understand pre-training. ",
+        "bbox": [
+            174,
+            435,
+            825,
+            561
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "REFERENCES ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            103,
+            285,
+            117
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Kshitij Bansal, Sarah M. Loos, Markus N. Rabe, Christian Szegedy, and Stewart Wilcox. HOList: An Environment for Machine Learning of Higher Order Logic Theorem Proving. In 36th International Conference on Machine Learning, ICML 2019, Long Beach, California, USA, June 9-15, 2019. URL http://proceedings.mlr.press/v97/bansal19a.html. ",
+        "bbox": [
+            174,
+            126,
+            826,
+            183
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Kshitij Bansal, Christian Szegedy, Markus N. Rabe, Sarah M. Loos, and Viktor Toman. Learning to Reason in Large Theories without Imitation. arXiv preprint arXiv:1905.10501, 2019. ",
+        "bbox": [
+            173,
+            191,
+            823,
+            220
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Francesco Bellucci and Ahti-Veikko Pietarinen. Charles Sanders Peirce: Logic. In The Internet Encyclopedia of Philosophy, 2015. URL https://iep.utm.edu/peir-log/. ",
+        "bbox": [
+            173,
+            229,
+            823,
+            258
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Tom B. Brown, Benjamin Mann, Nick Ryder, Melanie Subbiah, Jared Kaplan, Prafulla Dhariwal, Arvind Neelakantan, Pranav Shyam, Girish Sastry, Amanda Askell, Sandhini Agarwal, Ariel Herbert-Voss, Gretchen Krueger, Tom Henighan, Rewon Child, Aditya Ramesh, Daniel M. Ziegler, Jeffrey Wu, Clemens Winter, Christopher Hesse, Mark Chen, Eric Sigler, Mateusz Litwin, Scott Gray, Benjamin Chess, Jack Clark, Christopher Berner, Sam McCandlish, Alec Radford, Ilya Sutskever, and Dario Amodei. Language models are few-shot learners. CoRR, abs/2005.14165, 2020. URL https://arxiv.org/abs/2005.14165. ",
+        "bbox": [
+            174,
+            267,
+            826,
+            366
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Alexis Conneau and Guillaume Lample. Cross-lingual Language Model Pretraining. In Advances in Neural Information Processing Systems, NeurIPS 2019, Vancouver, BC, Canada, December 8-14, 2019, pages 7057–7067, 2019. URL http://papers.nips.cc/paper/ 8928-cross-lingual-language-model-pretraining. ",
+        "bbox": [
+            174,
+            375,
+            826,
+            431
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Maxwell Crouse, Ibrahim Abdelaziz, Cristina Cornelio, Veronika Thost, Lingfei Wu, Kenneth Forbus, and Achille Fokoue. Improving Graph Neural Network Representations of Logical Formulae with Subgraph Pooling. arXiv preprint arXiv:1911.06904, 2019. ",
+        "bbox": [
+            176,
+            439,
+            825,
+            483
+        ],
+        "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. In Jill Burstein, Christy Doran, and Thamar Solorio, editors, Proceedings of the 2019 Conference of the North American Chapter of the Association for Computational Linguistics: Human Language Technologies, NAACL-HLT 2019, Minneapolis, MN, USA, June 2-7, 2019, Volume 1 (Long and Short Papers), pages 4171– 4186. Association for Computational Linguistics, 2019. doi: 10.18653/v1/n19-1423. URL https://doi.org/10.18653/v1/n19-1423. ",
+        "bbox": [
+            173,
+            491,
+            826,
+            590
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Li Dong, Nan Yang, Wenhui Wang, Furu Wei, Xiaodong Liu, Yu Wang, Jianfeng Gao, Ming Zhou, and Hsiao-Wuen Hon. Unified Language Model Pre-training for Natural Language Understanding and Generation. In Advances in Neural Information Processing Systems, NeurIPS 2019, Vancouver, BC, Canada, December 8-14, 2019, pages 13063–13075, 2019. ",
+        "bbox": [
+            173,
+            598,
+            826,
+            656
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Richard Evans, David Saxton, David Amos, Pushmeet Kohli, and Edward Grefenstette. Can Neural Networks Understand Logical Entailment? In International Conference on Learning Representations, 2018. URL https://openreview.net/forum?id $=$ SkZxCk-0Z. ",
+        "bbox": [
+            174,
+            664,
+            823,
+            707
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Thibault Gauthier, Cezary Kaliszyk, Josef Urban, Ramana Kumar, and Michael Norrish. TacticToe: Learning to Prove with Tactics. Journal of Automated Reasoning, pages 1–30, 2020. ",
+        "bbox": [
+            171,
+            715,
+            825,
+            746
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Christopher Hahn, Frederik Schmitt, Jens U. Kreber, Markus N. Rabe, and Bernd Finkbeiner. Transformers Generalize to the Semantics of Logics. arXiv preprint arXiv:2003.04218, 2020. ",
+        "bbox": [
+            173,
+            753,
+            825,
+            784
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Jesse Michael Han. Enhancing SAT solvers with glue variable predictions. arXiv preprint arXiv:2007.02559, 2020. ",
+        "bbox": [
+            173,
+            791,
+            825,
+            820
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Vincent J. Hellendoorn, Charles Sutton, Rishabh Singh, Petros Maniatis, and David Bieber. Global relational models of source code. In 8th International Conference on Learning Representations, ICLR 2020, Addis Ababa, Ethiopia, April 26-30, 2020. OpenReview.net, 2020. URL https: //openreview.net/forum?id=B1lnbRNtwr. ",
+        "bbox": [
+            174,
+            829,
+            826,
+            886
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Sepp Hochreiter and Jürgen Schmidhuber. Long Short-Term Memory. Neural computation, 9(8): 1735–1780, 1997. ",
+        "bbox": [
+            174,
+            895,
+            823,
+            922
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Daniel Huang, Prafulla Dhariwal, Dawn Song, and Ilya Sutskever. GamePad: A learning environment for theorem proving. In 7th International Conference on Learning Representations, ICLR 2019, New Orleans, LA, USA, May 6-9, 2019. OpenReview.net, 2019. URL https://openreview. net/forum?id $=$ r1xwKoR9Y7. ",
+        "bbox": [
+            174,
+            103,
+            826,
+            159
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Mandar Joshi, Danqi Chen, Yinhan Liu, Daniel S. Weld, Luke Zettlemoyer, and Omer Levy. Spanbert: Improving pre-training by representing and predicting spans. Transactions of the Association for Computational Linguistics, 8:64–77, 2020. doi: 10.1162/tacl\\_a\\_00300. URL https: //doi.org/10.1162/tacl_a_00300. ",
+        "bbox": [
+            173,
+            169,
+            826,
+            227
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Diederik P. Kingma and Jimmy Ba. Adam: A method for stochastic optimization. In Yoshua Bengio and Yann LeCun, editors, 3rd International Conference on Learning Representations, ICLR 2015, San Diego, CA, USA, May 7-9, 2015, Conference Track Proceedings, 2015. URL http://arxiv.org/abs/1412.6980. ",
+        "bbox": [
+            173,
+            234,
+            825,
+            292
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Guillaume Lample and François Charton. Deep learning for symbolic mathematics. In 8th International Conference on Learning Representations, ICLR 2020, Addis Ababa, Ethiopia, April 26-30, 2020. OpenReview.net, 2020. URL https://openreview.net/forum?id $=$ Ske31kBtPr. ",
+        "bbox": [
+            173,
+            301,
+            825,
+            358
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Yann LeCun, Patrick Haffner, Léon Bottou, and Yoshua Bengio. Object recognition with gradientbased learning. In Shape, Contour and Grouping in Computer Vision, page 319, Berlin, Heidelberg, 1999. Springer-Verlag. ISBN 3540667229. ",
+        "bbox": [
+            174,
+            367,
+            823,
+            410
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Gil Lederman, Markus Rabe, Sanjit Seshia, and Edward A Lee. Learning heuristics for quantified boolean formulas through reinforcement learning. In International Conference on Learning Representations, 2020. ",
+        "bbox": [
+            174,
+            419,
+            825,
+            462
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Wenda Li, Lei Yu, Yuhuai Wu, and Lawrence C. Paulson. Modelling High-Level Mathematical Reasoning in Mechanised Declarative Proofs. arXiv preprint arXiv:2006.09265, 2020. ",
+        "bbox": [
+            173,
+            470,
+            823,
+            501
+        ],
+        "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. CoRR, abs/1907.11692, 2019. URL http://arxiv.org/abs/1907.11692. ",
+        "bbox": [
+            174,
+            508,
+            825,
+            553
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Thang Luong, Hieu Pham, and Christopher D. Manning. Effective approaches to attention-based neural machine translation. In Lluís Màrquez, Chris Callison-Burch, Jian Su, Daniele Pighin, and Yuval Marton, editors, Proceedings of the 2015 Conference on Empirical Methods in Natural Language Processing, EMNLP 2015, Lisbon, Portugal, September 17-21, 2015, pages 1412– 1421. The Association for Computational Linguistics, 2015. doi: 10.18653/v1/d15-1166. URL https://doi.org/10.18653/v1/d15-1166. ",
+        "bbox": [
+            173,
+            561,
+            826,
+            646
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "R. Thomas McCoy, E. Grant, P. Smolensky, T. Griffiths, and Tal Linzen. Universal linguistic inductive biases via meta-learning. Proceedings of CogSci, abs/2006.16324, 2020. ",
+        "bbox": [
+            171,
+            655,
+            825,
+            685
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Myle Ott, Sergey Edunov, Alexei Baevski, Angela Fan, Sam Gross, Nathan Ng, David Grangier, and Michael Auli. fairseq: A fast, extensible toolkit for sequence modeling. In Waleed Ammar, Annie Louis, and Nasrin Mostafazadeh, editors, Proceedings of the 2019 Conference of the North American Chapter of the Association for Computational Linguistics: Human Language Technologies, NAACL-HLT 2019, Minneapolis, MN, USA, June 2-7, 2019, Demonstrations, pages 48–53. Association for Computational Linguistics, 2019. doi: 10.18653/v1/n19-4009. URL https://doi.org/10.18653/v1/n19-4009. ",
+        "bbox": [
+            174,
+            694,
+            826,
+            792
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Aditya Paliwal, Sarah M. Loos, Markus N. Rabe, Kshitij Bansal, and Christian Szegedy. Graph representations for higher-order logic and theorem proving. In The Thirty-Fourth AAAI Conference on Artificial Intelligence, AAAI 2020, The Thirty-Second Innovative Applications of Artificial Intelligence Conference, IAAI 2020, The Tenth AAAI Symposium on Educational Advances in Artificial Intelligence, EAAI 2020, New York, NY, USA, February 7-12, 2020, pages 2967–2974. AAAI Press, 2020. URL https://aaai.org/ojs/index.php/AAAI/article/view/5689. ",
+        "bbox": [
+            174,
+            801,
+            825,
+            886
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Isabel Papadimitriou and Dan Jurafsky. Learning Music Helps You Read: Using transfer to study linguistic structure in language models. In Proceedings of the 2020 Conference on Empirical Methods in Natural Language Processing (EMNLP), pages 6829–6839, Online, November 2020. Association for Computational Linguistics. URL https://www.aclweb.org/anthology/2020. emnlp-main.554. ",
+        "bbox": [
+            174,
+            895,
+            825,
+            924
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            186,
+            103,
+            825,
+            145
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Charles Sanders Peirce. Reasoning and the logic of things: The Cambridge conferences lectures of 1898. Harvard University Press, 1992. ",
+        "bbox": [
+            174,
+            155,
+            826,
+            184
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Bartosz Piotrowski and Josef Urban. Guiding Inferences in Connection Tableau by Recurrent Neural Networks. In Christoph Benzmüller and Bruce Miller, editors, Intelligent Computer Mathematics, pages 309–314, Cham, 2020. Springer International Publishing. ISBN 978-3-030-53518-6. ",
+        "bbox": [
+            174,
+            193,
+            825,
+            236
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Stanislas Polu and Ilya Sutskever. Generative Language Modeling for Automated Theorem Proving. CoRR, abs/2009.03393, 2020. URL https://arxiv.org/abs/2009.03393. ",
+        "bbox": [
+            176,
+            244,
+            825,
+            273
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Markus N. Rabe, Dennis Lee, Kshitij Bansal, and Christian Szegedy. Mathematical Reasoning via Self-supervised Skip-tree Training. arXiv preprint arXiv:2006.04757, 2020. ",
+        "bbox": [
+            174,
+            282,
+            823,
+            313
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Alec Radford, Jeffrey Wu, Rewon Child, David Luan, Dario Amodei, and Ilya Sutskever. Language models are unsupervised multitask learners. In OpenAI Blog, 2018. URL https://d4mucfpksywv.cloudfront.net/better-language-models/ language_models_are_unsupervised_multitask_learners.pdf. ",
+        "bbox": [
+            174,
+            320,
+            826,
+            378
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Colin Raffel, Noam Shazeer, Adam Roberts, Katherine Lee, Sharan Narang, Michael Matena, Yanqi Zhou, Wei Li, and Peter J. Liu. Exploring the Limits of Transfer Learning with a Unified Text-toText Transformer. J. Mach. Learn. Res., 21:140:1–140:67, 2020. URL http://jmlr.org/ papers/v21/20-074.html. ",
+        "bbox": [
+            174,
+            387,
+            826,
+            443
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "David Saxton, Edward Grefenstette, Felix Hill, and Pushmeet Kohli. Analysing mathematical reasoning abilities of neural models. In Proceedings of International Conference on Learning Representations (ICLR), 2019. ",
+        "bbox": [
+            176,
+            452,
+            823,
+            494
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Franco Scarselli, Marco Gori, Ah Chung Tsoi, Markus Hagenbuchner, and Gabriele Monfardini. The graph neural network model. IEEE Transactions on Neural Networks, 20(1):61–80, 2008. ",
+        "bbox": [
+            171,
+            503,
+            823,
+            534
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Imanol Schlag, Paul Smolensky, Roland Fernandez, Nebojsa Jojic, Jürgen Schmidhuber, and Jianfeng Gao. Enhancing the transformer with explicit relational encoding for math problem solving. CoRR, abs/1910.06611, 2019. URL http://arxiv.org/abs/1910.06611. ",
+        "bbox": [
+            174,
+            541,
+            823,
+            585
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Daniel Selsam and Nikolaj Bjørner. Guiding High-Performance SAT solvers with Unsat-Core Predictions. In International Conference on Theory and Applications of Satisfiability Testing, pages 336–353. Springer, 2019. ",
+        "bbox": [
+            173,
+            593,
+            826,
+            637
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Daniel Selsam, Matthew Lamm, Benedikt Bünz, Percy Liang, Leonardo de Moura, and David L. Dill. Learning a SAT solver from single-bit supervision. In 7th International Conference on Learning Representations, ICLR 2019, New Orleans, LA, USA, May 6-9, 2019. OpenReview.net, 2019. URL https://openreview.net/forum?id $\\underline { { \\underline { { \\mathbf { \\Pi } } } } } =$ HJMC_iA5tm. ",
+        "bbox": [
+            174,
+            646,
+            826,
+            703
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Kaitao Song, Xu Tan, Tao Qin, Jianfeng Lu, and Tie-Yan Liu. MASS: masked sequence to sequence pre-training for language generation. In 36th International Conference on Machine Learning, ICML 2019, Long Beach, California, USA, June 9-15, 2019, 2019. URL http://proceedings. mlr.press/v97/song19d.html. ",
+        "bbox": [
+            173,
+            712,
+            826,
+            768
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Christian Szegedy, Vincent Vanhoucke, Sergey Ioffe, Jon Shlens, and Zbigniew Wojna. Rethinking the inception architecture for computer vision. In Proceedings of the IEEE conference on computer vision and pattern recognition, pages 2818–2826, 2016. ",
+        "bbox": [
+            173,
+            777,
+            825,
+            820
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Josef Urban and Jan Jakub˚uv. First Neural Conjecturing Datasets and Experiments. In Christoph Benzmüller and Bruce Miller, editors, Intelligent Computer Mathematics, pages 315–323, Cham, 2020. Springer International Publishing. ISBN 978-3-030-53518-6. ",
+        "bbox": [
+            173,
+            829,
+            823,
+            872
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Pashootan Vaezipoor, Gil Lederman, Yuhuai Wu, Chris J. Maddison, Roger B. Grosse, Edward A. Lee, Sanjit A. Seshia, and Fahiem Bacchus. Learning Branching Heuristics for Propositional Model Counting. CoRR, abs/2007.03204, 2020. URL https://arxiv.org/abs/2007.03204. ",
+        "bbox": [
+            176,
+            882,
+            825,
+            924
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Ashish Vaswani, Noam Shazeer, Niki Parmar, Jakob Uszkoreit, Llion Jones, Aidan N. Gomez, Lukasz Kaiser, and Illia Polosukhin. Attention is All you Need. In Proceedings of Advances in Neural Information Processing Systems (NeurIPS), 2017. ",
+        "bbox": [
+            178,
+            103,
+            823,
+            146
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Mingzhe Wang, Yihe Tang, Jian Wang, and Jia Deng. Premise selection for theorem proving by deep graph embedding. In Advances in Neural Information Processing Systems, pages 2786–2796, 2017. ",
+        "bbox": [
+            176,
+            155,
+            823,
+            196
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Qingxiang Wang, Chad Brown, Cezary Kaliszyk, and Josef Urban. Exploration of neural machine translation in autoformalization of mathematics in mizar. Proceedings of ACM SIGPLAN International Conference on Certified Programs and Proofs, 2020. ",
+        "bbox": [
+            174,
+            207,
+            823,
+            250
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Alex Warstadt and Samuel R. Bowman. Can neural networks acquire a structural bias from raw linguistic data? Proceedings of CogSci, 2020. ",
+        "bbox": [
+            173,
+            257,
+            821,
+            287
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Yuhuai Wu, Albert Jiang, Jimmy Ba, and Roger Grosse. INT: An Inequality Benchmark for Evaluating Generalization in Theorem Proving. arXiv preprint arXiv:2007.02924, 2020. ",
+        "bbox": [
+            176,
+            295,
+            823,
+            325
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Keyulu Xu, Jingling Li, Mozhi Zhang, Simon S Du, Ken-ichi Kawarabayashi, and Stefanie Jegelka. What can neural networks reason about? In ICLR 2020, 2020. ",
+        "bbox": [
+            174,
+            333,
+            821,
+            362
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Kaiyu Yang and Jia Deng. Learning to Prove Theorems via Interacting with Proof Assistants. In Proceedings of International Conference on Machine Learning (ICML), 2019. ",
+        "bbox": [
+            174,
+            371,
+            821,
+            400
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Zhilin Yang, Zihang Dai, Yiming Yang, Jaime Carbonell, Russ R Salakhutdinov, and Quoc V Le. Xlnet: Generalized autoregressive pretraining for language understanding. In Advances in Neural Information Processing Systems, NeurIPS 2019, Vancouver, BC, Canada, December 8-14, 2019, 2019. ",
+        "bbox": [
+            174,
+            409,
+            826,
+            464
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Jingqing Zhang, Yao Zhao, Mohammad Saleh, and Peter J. Liu. PEGASUS: pre-training with extracted gap-sentences for abstractive summarization. In 37th International Conference on Machine Learning, ICML 2020, Vienna, Austria, 2020, volume 119. PMLR, 2020. ",
+        "bbox": [
+            174,
+            474,
+            826,
+            517
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "APPENDIX A SYNTHETIC TASK GENERATION PSEUDOCODE ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            102,
+            687,
+            118
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "Algorithm 1 ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            138,
+            259,
+            154
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "1: function GENERATE_TUPLE( Vocabulary size $S$ )   \n2: Vocabulary $\\mathcal { V }  \\{ 1 , 2 , \\dotsc , S \\}$ . . Use an integer representation of symbols.   \n3: Math symbol set $\\mathcal { M }  \\mathrm { S A M P L E } ( \\mathcal { V } , n { = } 4 4 $ , replacement=False). $\\triangleright$ Sample 44 distinct symbols.   \n4: Rule symbol set $\\mathcal { R } \\gets \\mathtt { S A M P L E } ( \\mathcal { V } \\backslash \\mathcal { M }$ , $n { = } 2 0$ , replacement=False). $\\triangleright$ Sample 20 distinct symbols.   \n5: Rule $R  \\operatorname { S A M P L E } ( \\mathcal { M } \\cup \\mathcal { R }$ , $n { = }$ RANDOM(5,20), replacement=False). . Sample a sequence of   \nsymbols of length between 5 and 20.   \n6: Case dictionary $C \\gets \\{ \\}$ .   \n7: for $s$ in $\\mathcal { R }$ do   \n8: Case dictionary $C [ s ] \\gets \\mathtt { S A M P L E } ( \\mathcal { M } , n \\mathop { = } \\mathrm { R A N D C }$ M(2,8), replacement=True). . Sample a sequence   \nof symbols for each rule symbol, of length of length between 2 and 8.   \n9: end for   \n10: Result $R ^ { \\prime } \\gets { \\sf R u l e } R$ . . Set result string $R ^ { \\prime }$ to be the same as rule string $R$ .   \n11: for $s$ in $\\mathcal { R }$ do   \n12: SUBSTITUTE $( R ^ { \\prime } , s , C [ s ] )$ . $\\triangleright$ Substitute every rule symbol $s$ in result string $R ^ { \\prime }$ with previously   \nrandomly sampled string $C [ s ]$ .   \n13: end for   \n14: return Math symbol set $\\mathcal { M }$ , Rule symbol set $\\mathcal { R }$ , Rule $R$ , Case $C$ , Result $R ^ { \\prime }$ .   \n15: end function ",
+        "bbox": [
+            176,
+            156,
+            826,
+            441
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "APPENDIX B OTHER SYNTHETIC TASKS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            472,
+            519,
+            489
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "In this section, we give descriptions of other variants of the synthetic tasks we considered than the ones introduced in the main paper. ",
+        "bbox": [
+            171,
+            503,
+            823,
+            532
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "APPENDIX B.1 RE W R I T E AND RE W R I T E_M U L T I S T E P ",
+        "bbox": [
+            174,
+            549,
+            568,
+            563
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "We propose a rewrite task, inspired by the rewrite tactic used in interactive theorem provers. The Rewrite task requires the model to rewrite a string according to a rule transformation. One example of the task is: ",
+        "bbox": [
+            174,
+            574,
+            825,
+            616
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "Source: $a + b - c < s > A + B = B + A$ ",
+        "bbox": [
+            174,
+            623,
+            444,
+            638
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "Target: $b + a - c$ ",
+        "bbox": [
+            174,
+            645,
+            290,
+            660
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "“ $\\dot { \\boldsymbol { A } } + \\boldsymbol { B } = \\boldsymbol { B } + \\boldsymbol { A } ^ { \\ast }$ “ is the rule transformation, which is applied to the LHS string $\\mathbf { \\dot { \\boldsymbol { a } } } + \\boldsymbol { b } - \\boldsymbol { c } ^ { \\flat }$ . The model needs to predict the RHS string as the result of the rule application, i.e., $b + a - c$ . Besides rule symbols and math symbols, we also require the third set of symbols, named as \"string symbols\". For the ease of our discussion, we we will think of math symbols as the union of those operators used in mathematics (e.g., $^ { 6 6 } + - * = ( ) \\& ^ { 3 } )$ , rule symbols as upper case letters (e.g., $A , B , C \\dots )$ , and string symbols as lower case letters (e.g., $a , b , c \\ldots )$ . We first sample a random string as the LHS string, consisting of math symbols and string symbols (e.g., $a + b - c )$ . We sample a sub-string of the LHS string, and replace the string symbols in the sub-string with rule symbols. For example, we sample and obtain the substring $a + b$ from $a + b - c $ , and we replace $a , b$ with rule symbols $A , B$ . This then forms the LHS of the rule transformation, $A + B$ , with the substitution dictionary $\\{ A : a , B : b \\}$ . We then sample the RHS of the rule transformation from the union of rule symbols $A$ and $B$ , and all math symbols, e.g., $B + A$ . This gives the rule transformation $A + B = B + A$ . We substitute the value of the substitution dictionary for each rule symbol in the RHS rule, and then substitute back to the original LHS string to obtain $b + a - c$ . The task example is constructed by using the LHS string and the rule transformation as the source input, and use the result of the rule transformation as the target. ",
+        "bbox": [
+            173,
+            666,
+            825,
+            875
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "We further introduce a multi-step version of the rewrite task: Rewrite_multistep. In this task, the source may contain more than one rewrite rule, and the target is the result of applying all the rewrite rules in a sequence. This task is motivated from the need to perform multi-step planning in mathematical reasoning tasks. During pre-training, for each training example, we uniformly sample the number of rewrite steps from 1 to 5. ",
+        "bbox": [
+            176,
+            882,
+            825,
+            924
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "table",
+        "img_path": "images/e11b398f9d8ed9bb758159c2b100b291bc3e1df3f7b09c965f371eb98bdbc49b.jpg",
+        "table_caption": [
+            "Table 6: Test top-1, top-10 $( \\% )$ accuracy on the IsarStep task. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Model</td><td>Top-1 Acc.</td><td>Top-10 Acc.</td></tr><tr><td>No pretrain (Li et al., 2020)</td><td>20.4</td><td>33.1</td></tr><tr><td>HAT (Li et al., 2020)</td><td>22.8</td><td>35.2</td></tr><tr><td>LIME Deduct</td><td>24.7</td><td>37.7</td></tr><tr><td>LIME Abduct</td><td>26.7</td><td>41.0</td></tr><tr><td>LIME Induct</td><td>23.9</td><td>38.8</td></tr><tr><td>LIME Mix</td><td>26.9</td><td>40.4</td></tr><tr><td>LIME Rewrite</td><td>26.0</td><td>38.6</td></tr><tr><td>LIMERewrite_multistep</td><td>28.6</td><td>43.9</td></tr><tr><td>LIMEInduct_v2</td><td>25.6</td><td>39.8</td></tr><tr><td>LIMEInduct_v3</td><td>25.0</td><td>38.8</td></tr><tr><td>LIMEInduct_rewrite</td><td>25.8</td><td>39.5</td></tr></table>",
+        "bbox": [
+            284,
+            127,
+            709,
+            309
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            321,
+            821,
+            349
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "APPENDIX B.2 OTHER VARIANTS OF IN D U C T TASK ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            366,
+            544,
+            381
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "We introduce three other variants of the Induct task. ",
+        "bbox": [
+            173,
+            392,
+            529,
+            406
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "1. Induct_v2: We move the Case dictionary from the source input to the target output. This makes the task significantly harder, which requires the agent to synthesize a rule and a possible explanation (Case) to explain the Result.   \n2. Induct_v3: Instead of providing the Case dictionary, we provide two Result strings, coming from the same Rule. Namely, we sample two Case dictionaries, and applying each to the Rule string to obtain two Result strings. Both Result strings are used as source, and the target is the Rule string.   \n3. Induct_rewrite: We also create a “induction” version of the Rewrite task. In this task, the source is the LHS string concatenated with the RHS string, that is the result of the rewrite. The target is the rewrite rule that is used to do the rewrite. ",
+        "bbox": [
+            212,
+            417,
+            825,
+            566
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "APPENDIX B.3 A FULL COMPARISON OF ALL SYNTHETIC TASKS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            584,
+            629,
+            598
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "In this section we present a full comparison for all synthetic tasks. We followed the training protocol in 4.1 and evaluate the method on IsarStep. The results are reported in Table 6. We can see that the Rewrite_multistep achieved the best performance across all synthetic tasks, surpassing the baseline by $8 . 2 \\%$ for Top-1 accuracy and $1 0 . 8 \\%$ for Top-10 accuracy. This indicates the inductive bias for long horizon reasoning encoded in Rewrite_multistep is very useful for the reasoning task. ",
+        "bbox": [
+            174,
+            609,
+            825,
+            693
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "APPENDIX C MORE ABLATION STUDIES ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            713,
+            526,
+            729
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "APPENDIX C.1 DOES THE VOCABULARY SIZE MATTER? ",
+        "bbox": [
+            176,
+            744,
+            571,
+            758
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "In this section, we investigate whether the vocabulary size $S$ in the synthetic task generation algorithm has an effect on the performance. We used the REWRITE task for the experiment in this section. We generated datasets of various vocabulary sizes, 100, 512, 1000, 5000, 25000. We used the same curriculum learning for pre-training as described in 4.1 on larger vocabulary sizes: first training on the Rewrite task of vocabulary size 100 for 10K steps, then training on each individual dataset for another 10K steps. We compare the performance on the downstream task Isarstep. The results are presented in Table 7. We see that when the vocabulary size is equal or larger than 512, the performance were similar. The smallest vocabulary size 100 obtained the worst performance among all, and all the other four models achieved similar BLEU scores. The model trained on the largest vocabulary achieved best performance on top-1 accuracy and top-10 accuracy. The results show there is a non-trivial effect of the vocabulary size of the synthetic task to the performance of the ",
+        "bbox": [
+            174,
+            770,
+            825,
+            924
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "downstream task. Hence we use vocabulary size of 1000 for all the experiments in the main paper.   \nWe leave investigations of the causes to future work. ",
+        "bbox": [
+            169,
+            103,
+            825,
+            132
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "table",
+        "img_path": "images/03f3f0d177498d10cf96ec8e8c879d7dd94019a9731f87b8925fdc17c94029ed.jpg",
+        "table_caption": [
+            "Table 7: Vocabulary sizes’ effects on the IsarStep task. ",
+            "APPENDIX C.2 PRE-TRAINING ON ISARSTEP FOR METAMATHSTEP "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Model</td><td>Top-1 Acc.</td><td>Top-10 Acc</td></tr><tr><td>No pretrain</td><td>20.4</td><td>33.1</td></tr><tr><td>LIME on Rewrite,S= 100</td><td>24.1</td><td>37.5</td></tr><tr><td>LIME on Rewrite,S= 512</td><td>25.4</td><td>38.8</td></tr><tr><td>LIME on Rewrite,S= 1000</td><td>26.0</td><td>38.6</td></tr><tr><td>LIME on Rewrite,S= 5000</td><td>25.8</td><td>38.5</td></tr><tr><td>LIME on Rewrite,S= 25000</td><td>27.4</td><td>40.9</td></tr></table>",
+        "bbox": [
+            285,
+            170,
+            712,
+            285
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "text",
+        "text": "Following Section 5.1, we performed pre-training on IsarStep for MetaMathStep. The result is shown in Table 8. In contrast to MetaMath helping IsarStep, we see that pretraining on IsarStep task did not help the downstream task MetaMathStep. We hypothesize that this could be due to MetaMathStep task is closer to the LIME tasks than IsarStep, and hence providing more gains than the opposite direction. We leave investigations to the future versions. ",
+        "bbox": [
+            174,
+            334,
+            825,
+            405
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "table",
+        "img_path": "images/35c7f32f89a0d4ba0361b8eea1e4c508d3e67aaa0c3423776db6be433bdd9cb8.jpg",
+        "table_caption": [
+            "Table 8: Pretraining on IsarStep for the MetaMathStep task. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Model</td><td>Top-1 Acc.</td><td>Top-10 Acc.</td></tr><tr><td>No pretrain</td><td>67.7</td><td>76.5</td></tr><tr><td>LIME Mix</td><td>69.1</td><td>77.9</td></tr><tr><td>Pretrain on IsarStep</td><td>67.0</td><td>76.1</td></tr></table>",
+        "bbox": [
+            323,
+            443,
+            671,
+            516
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "text",
+        "text": "APPENDIX C.3 DOES LIME HELP LSTMS? ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            546,
+            486,
+            561
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "text",
+        "text": "In this section, we investigate if LIME also helps other architectures than transformers. In particular, we applied LIME to two LSTM based architectures: 1. vanilla LSTM, 2. LSTM with attention mechanism. The vanilla LSTM is a stacking LSTM with 4 layers, each with 1000 cells, and 1000- dimensional embeddings. The LSTM with attention architecture is taken from Luong et al. (2015), also with 4 layers, 1000 cells and 1000-dimensional embeddings. We evaluate on the IsarStep task, and compared a model trained from scratch and a model pre-trained on LIME abduct task. We used the same training protocol as described in 4.1. The results are shown in Table 9, along with the results on transformer. We observe that LIME improved LSTM as well as LSTM with attention, but the improvements were small compared to transformer. Specifically, if we compare Top-1 accuracy, we can see that LIME improved LSTM from $5 . 5 \\%$ to $6 . { \\dot { 9 } } \\%$ , LSTM with attention from $1 2 . 3 \\%$ to $1 3 . 4 \\%$ , and transformer from $2 0 . 4 \\%$ to $2 6 . 7 \\%$ . This observation is aligned with our hypothesis that the transformer is a malleable architecture and hence it is capable of learning architectural inductive biases from datasets. This is mainly attributed to the potential of learning dynamic attention graphs in self-attention layers. We note that this still warrants further investigation as the performance of these architectures are not at the same level, and that may also lead to different improvements. ",
+        "bbox": [
+            173,
+            573,
+            826,
+            781
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "table",
+        "img_path": "images/fc187f71034bd897540e52bbdb651ff4d0c19b94e71b73ffcbffba2bbaed8436.jpg",
+        "table_caption": [
+            "Table 9: Comparing LIME’s benefits on LSTMs on the IsarStep Task "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Model</td><td>Top-1 Acc.</td><td>Top-10 Acc.</td></tr><tr><td>LSTM</td><td>5.5</td><td>11.3</td></tr><tr><td>LSTM+LIME Abduct</td><td>6.9</td><td>14.3</td></tr><tr><td>LSTM+attention</td><td>12.3</td><td>22.7</td></tr><tr><td>LSTM+attention+LIME Abduct</td><td>13.4</td><td>26.3</td></tr><tr><td>Transformer</td><td>20.4</td><td>33.1</td></tr><tr><td>Transformer+LIME Abduct</td><td>26.7</td><td>41.0</td></tr></table>",
+        "bbox": [
+            267,
+            820,
+            725,
+            935
+        ],
+        "page_idx": 15
+    }
+]

parse/train/S1MB-3RcF7/S1MB-3RcF7.md

@@ -0,0 +1,427 @@
+# MULTI-OBJECTIVE TRAINING OF GENERATIVE ADVERSARIAL NETWORKS WITH MULTIPLE DISCRIMINATORS
+
+Anonymous authors Paper under double-blind review
+
+# ABSTRACT
+
+Recent literature has demonstrated promising results on the training of Generative Adversarial Networks by employing a set of discriminators, as opposed to the traditional game involving one generator against a single adversary. Those methods perform single-objective optimization on some simple consolidation of the losses, e.g. an average. In this work, we revisit the multiple-discriminator approach by framing the simultaneous minimization of losses provided by different models as a multi-objective optimization problem. Specifically, we evaluate the performance of multiple gradient descent and the hypervolume maximization algorithm on a number of different datasets. Moreover, we argue that the previously proposed methods and hypervolume maximization can all be seen as variations of multiple gradient descent in which the update direction computation can be done efficiently. Our results indicate that hypervolume maximization presents a better compromise between sample quality and diversity, and computational cost than previous methods.
+
+# 1 INTRODUCTION
+
+Generative Adversarial Networks (GANs) (Goodfellow et al., 2014) offer a new approach to generative modeling, using game-theoretic training schemes to implicitly learn a given probability density. Prior to the emergence of GAN architectures, realistic generative modeling remained elusive. When offering unparalleled realism, GAN training remains fraught with stability issues. Commonly reported shortcomings involved in the GAN game are the lack of useful gradients provided by the discriminator, and mode collapse, i.e. lack of diversity in the generator’s samples.
+
+Considerable research effort has been devoted in recent literature in order to overcome training instability 1 within the GAN framework. Some architectures such as BEGAN (Berthelot et al., 2017) have applied auto-encoders as discriminators and proposed a new loss to help stabilize training. Methods such as TTUR (Heusel et al., 2017), in turn, have attempted to define schedules for updating the generator and discriminator differently. The PacGAN algorithm (Lin et al., 2017) proposes to modify the discriminator’s architecture which will receive m concatenated samples as input, while modifications to alternate updates in SGD were introduced in (Yadav et al., 2017). These samples are jointly classified as either real or generated, and authors show that this enforces sample diversity. In SNGAN (Miyato et al., 2018), authors introduce spectral normalization on the discriminator aiming to ensure Lipschitz continuity, which is empirically shown to consistently yield high quality samples when different sets of hyperparameters are used.
+
+Recent works have proposed to tackle GANs instability issues using multiple discriminators. Neyshabur et al. (2017) propose a GAN variation in which one generator is trained against a set of discriminators, where each discriminator sees a fixed random projection of the inputs. Prior work, including GMAN (Durugkar et al., 2016) has also explored training against multiple discriminators.
+
+In this paper, we build upon Neyshabur et al.’s introduced framework and propose reformulating the average loss minimization aiming to further stabilize GAN training. Specifically, we propose treating the loss signal provided by each discriminator as an independent objective function. To achieve this, we simultaneously minimize the losses using multi-objective optimization techniques. Namely, we exploit previously introduced methods in literature such as the multiple gradient descent algorithm (MGD) (Désidéri, 2012). However, due to MGD’s prohibitively high cost in the case of large neural networks, we propose the use of more efficient alternatives such as maximization of the hypervolume of the region defined between a fixed, shared upper bound on those losses, which we will refer to as the nadir point $\eta ^ { * }$ , and each of the component losses.
+
+In contrast to Neyshabur et al. (2017)’s approach, where the average loss is minimized when training the generator, hypervolume maximization (HV) optimizes a weighted loss, and the generator’s training will adaptively assign greater importance to feedback from discriminators against which it performs poorly.
+
+Experiments performed on MNIST show that HV presents a good compromise in the computational cost-samples quality trade-off, when compared to average loss minimization or GMAN’s approach (low quality and cost), and MGD (high quality and cost). Also, the sensitivity to introduced hyperparameters is studied and results indicate that increasing the number of discriminators consequently increases the generator’s robustness along with sample quality and diversity. Experiments on CIFAR10 indicate the method described produces higher quality generator samples in terms of quantitative evaluation. Moreover, image quality and sample diversity are once more shown to consistently improve as we increase the number of discriminators.
+
+In summary, our main contributions are the following:
+
+1. We offer a new perspective on multiple-discriminator GAN training by framing it in the context of multi-objective optimization, and draw similarities between previous research in GANs variations and MGD, commonly employed as a general solver for multi-objective optimization.   
+2. We propose a new method for training multiple-discriminator GANs: Hypervolume maximization, which weighs the gradient contributions of each discriminator by its loss.
+
+The remainder of this document is organized as follows: Section 2 introduces definitions on multiobjective optimization and MGD. In Section 3 we describe prior relevant literature. Hypervolume maximization is detailed in Section 4, with experiments and results presented in Section 5. Conclusions and directions for future work are drawn in Section 6.
+
+# 2 PRELIMINARIES
+
+In this section we provide some definitions regarding multi-objective optimization literature which will be useful in the next sections. Henceforth, the boldface notation will be used to indicate vector-valued variables.
+
+Multi-objective optimization. A multi-objective optimization problem is defined as (Deb, 2001):
+
+$$
+\begin{array} { r l } & { \operatorname* { m i n } \mathbf { F } ( \mathbf { x } ) = [ f _ { 1 } ( \mathbf { x } ) , f _ { 2 } ( \mathbf { x } ) , . . . , f _ { K } ( \mathbf { x } ) ] ^ { T } , } \\ & { \quad \quad \quad \mathbf { x } \in \Omega , } \end{array}
+$$
+
+where $K$ is the number of objectives, $\Omega$ is the variables space and $\mathbf { x } = [ x _ { 1 } , x _ { 2 } , . . . , x _ { n } ] ^ { T } \in \Omega$ is a decision vector or possible solution to the problem. $\mathbf { F } : \Omega \stackrel { * } { \to } \mathbb { R } ^ { K }$ is a set of $K$ -objective functions that maps the $n$ -dimensional variables space to the $K$ -dimensional objective space.
+
+Pareto-dominance. Let $\mathbf { X } _ { 1 }$ and $\mathbf { X } _ { 2 }$ be two decision vectors. $\mathbf { X } _ { 1 }$ is said to dominate $\mathbf { X } _ { 2 }$ (denoted by $\mathbf { x } _ { 1 } \prec \mathbf { x } _ { 2 } )$ if and only if $f _ { i } ( \mathbf { x } _ { 1 } ) \leq f _ { i } ( \mathbf { x } _ { 2 } )$ for all $i \in \{ 1 , 2 , \ldots , K \}$ and $f _ { j } ( \mathbf { x } _ { 1 } ) < f _ { j } ( \mathbf { x } _ { 2 } )$ for some $j \in \{ 1 , 2 , \dots , K \}$ . If a decision vector $\mathbf { X }$ is dominated by no other vector in $\Omega$ , $\mathbf { X }$ is said to be non-dominated.
+
+Pareto-optimality. A decision vector $\mathbf { x } ^ { * } \in \Omega$ is said to be Pareto-optimal if and only if there is no $\mathbf { x } \in \Omega$ such that $\mathbf { X } \prec \mathbf { X } ^ { * }$ , i.e. $\mathbf { x } ^ { * }$ is a non-dominated solution. The Pareto-optimal Set (PS) is defined as the set of all Pareto-optimal solutions $\mathbf { x } \in \Omega$ , i.e., $P S = \{ \mathbf { x } \in \Omega | \mathbf { x }$ is Pareto optimal}. The set of all objective vectors $\mathbf { F } ( \mathbf { x } )$ such that $\mathbf { X }$ is Pareto-optimal is called Pareto front (PF), that is $P F = \{ \mathbf { F } ( \mathbf { x } ) \in \mathbf { \bar { \mathbb { R } } } ^ { K } | \mathbf { x } \in P S \}$ .
+
+Pareto-stationarity. Pareto-stationarity is a necessary condition for Pareto-optimality. For $f _ { k }$ differentiable everywhere for all $k$ , $\mathbf { F }$ is said to be Pareto-stationary at the point $\mathbf { X }$ if there exists a set of scalars $\alpha _ { k } , k \in \{ 1 , \ldots , K \}$ , such that:
+
+$$
+\sum _ { k = 1 } ^ { K } \alpha _ { k } \nabla f _ { k } = \mathbf { 0 } , \quad \sum _ { k = 1 } ^ { K } \alpha _ { k } = 1 , \quad \alpha _ { k } \geq 0 \quad \forall k .
+$$
+
+Multiple Gradient Descent. Multiple gradient descent (Désidéri, 2012; Schäffler et al., 2002; Peitz & Dellnitz, 2018) was proposed for the unconstrained case of multi-objective optimization of $\mathbf { F } ( \mathbf { x } )$ assuming a convex, continuously differentiable and smooth $f _ { k } ( { \bf x } )$ for all $k$ . MGD finds a common descent direction for all $f _ { k }$ by defining the convex hull of all $\nabla f _ { k } ( { \mathbf { x } } )$ and finding the minimum norm element within it. Consider $\mathbf { w } ^ { * }$ given by:
+
+$$
+\mathbf { w } ^ { * } = \mathrm { a r g m i n } | | \mathbf { w } | | , \quad \mathbf { w } = \sum _ { k = 1 } ^ { K } \alpha _ { k } \nabla f _ { k } ( \mathbf { x } ) , \quad \mathrm { s . t . } \quad \sum _ { k = 1 } ^ { K } \alpha _ { k } = 1 , \quad \alpha _ { k } \geq 0 \quad \forall k .
+$$
+
+$\mathbf { w } ^ { * }$ will be either 0 in which case $\mathbf { X }$ is a Pareto-stationary point, or $\mathbf { w } ^ { * } \neq \mathbf { 0 }$ and then $\mathbf { w } ^ { * }$ is a descent direction for all $f _ { i } ( \mathbf { x } )$ . Similar to gradient descent, MGD consists in finding the common steepest descent direction $\mathbf { w } _ { t } ^ { * }$ at each iteration $t$ , and then updating parameters with a learning rate $\lambda$ according to $\begin{array} { r } { \mathbf { x } _ { t + 1 } = \mathbf { x } _ { t } - \lambda \frac { \mathbf { w } _ { t } ^ { * } } { | | \mathbf { w } _ { t } ^ { * } | | } } \end{array}$ .
+
+# 3 RELATED WORK
+
+# 3.1 TRAINING GANS WITH MULTIPLE DISCRIMINATORS
+
+While we would prefer to always have strong gradients from the discriminator during training, the vanilla GAN makes this difficult to ensure, as the discriminator quickly learns to distinguish real and generated samples (Goodfellow, 2016), thus providing no meaningful error signal to improve the generator thereafter. Durugkar et al. (2016) proposed the Generative Multi-Adversarial Networks (GMAN) which consist in training the generator against a softmax weighted arithmetic average of $K$ different discriminators, according to Eq. 4.
+
+$$
+\mathcal { L } _ { G } = \sum _ { k = 1 } ^ { K } \alpha _ { k } \mathcal { L } _ { D _ { k } } ,
+$$
+
+where $\begin{array} { r } { \alpha _ { k } = \frac { e ^ { \beta \mathcal { L } _ { D _ { k } } } } { \sum _ { j = 1 } ^ { K } e ^ { \beta \mathcal { L } _ { D _ { j } } } } , \beta \ge 0 } \end{array}$ , and $\mathcal { L } _ { D _ { k } }$ is the loss of discriminator $k$ and defined as
+
+$$
+\mathcal { L } _ { D _ { k } } = - \mathbb { E } _ { { \mathbf { x } } \sim p _ { \mathrm { d a t a } } } \log D _ { k } ( { \mathbf { x } } ) - \mathbb { E } _ { { \mathbf { z } } \sim p _ { z } } \log ( 1 - D _ { k } ( G ( { \mathbf { z } } ) ) ) ,
+$$
+
+where $D _ { k } ( { \mathbf x } )$ and $G ( \mathbf { z } )$ are the outputs of the $k$ -th discriminator and the generator, respectively. The goal of using the proposed averaging scheme is to privilege worse discriminators and thus providing more useful gradients to the generator during training. Experiments were performed with $\beta = 0$ (equal weights), $\beta \to \infty$ (only worst discriminator is taken into account), $\beta = 1$ , and $\beta$ learned by the generator. Models with $K = \{ 2 , 5 \}$ were tested and evaluated using a proposed metric and the Inception score (Salimans et al., 2016). However, results showed that the simple average of discriminator’s losses provided the best values for both metrics in most of the considered cases.
+
+Opposed to GMAN, Neyshabur et al. (2017) proposed training a GAN with $K$ discriminators using the same architecture. Each discriminator $D _ { k }$ sees a different randomly projected lower-dimensional version of the input image. Random projections are defined by a randomly initialized matrix $W _ { k }$ , which remains fixed during training. Theoretical results provided show that the distribution induced by the generator $G$ will converge to the real data distribution $p _ { \mathrm { d a t a } }$ , as long as there is a sufficient number of discriminators. Moreover, discriminative tasks in the projected space are harder, i.e. real and fake samples are more alike, thus avoiding early convergence of discriminators, which leads to common stability issues in GAN training such as mode-collapse (Goodfellow, 2016). Essentially, the authors trade one hard problem for $K$ easier subproblems. The losses of each discriminator $\mathcal { L } _ { D _ { k } }$ are the same as shown in Eq. 5. However, the generator loss $\mathcal { L } _ { G }$ is defined as simply the sum of the losses provided by each discriminator, as shown in Eq. 6. This choice of $\mathcal { L } _ { G }$ does not exploit available information such as the performance of the generator with respect to each discriminator.
+
+$$
+\mathcal { L } _ { G } = - \sum _ { k = 1 } ^ { K } \mathbb { E } _ { \mathbf { z } \sim p _ { z } } \log D _ { k } ( G ( \mathbf { z } ) ) .
+$$
+
+# 3.2 HYPERVOLUME MAXIMIZATION
+
+Consider a set of solutions $S$ for a multi-objective optimization problem. The hypervolume $\mathcal { H }$ of $S$ is defined as (Fleischer, 2003): $\mathcal { H } ( S ) = \mu \big ( \cup _ { \mathbf { x } \in S } [ \mathbf { F } ( \mathbf { x } ) , \pmb { \eta } ^ { * } ] \big )$ , where $\mu$ is the Lebesgue measure and $\eta ^ { * }$ is a point dominated by all $\mathbf { x } \in S$ (i.e. $f _ { i } ( \mathbf { x } )$ is upper-bounded by $\eta$ ), referred to as nadir point. $\mathcal { H } ( S )$ can be understood as the size of the space covered by $\{ \mathbf { F } ( \mathbf { x } ) | \mathbf { x } \in S \}$ (Bader & Zitzler, 2011).
+
+The hypervolume was originally introduced as a quantitative metric for coverage and convergence of Pareto-optimal fronts obtained through population based algorithms (Beume et al., 2007). Methods based on direct maximization of $\mathcal { H }$ exhibit favorable convergence even in challenging scenarios, such as simultaneous minimization of 50 objectives (Bader & Zitzler, 2011). In the context of Machine Learning, a single-solution hypervolume maximization has been applied to neural networks as a surrogate loss for mean squared error (Miranda & Zuben, 2016), i.e. the loss provided by each example in a training batch is treated as a single cost and the multi-objective approach aims to minimize costs over all examples. Authors show that such method provides an inexpensive boosting-like training.
+
+# 4 MULTI-OBJECTIVE TRAINING OF GANS WITH MULTIPLE DISCRIMINATORS
+
+We introduce a variation of the GAN game such that the generator solves the following multi-objective problem:
+
+$$
+\operatorname* { m i n } \pmb { \mathcal { L } } _ { G } ( \mathbf { x } ) = [ l _ { 1 } ( \mathbf { z } ) , l _ { 2 } ( \mathbf { z } ) , . . . , l _ { K } ( \mathbf { z } ) ] ^ { T } ,
+$$
+
+where each $l _ { k } = - \mathbb { E } _ { z \sim p _ { z } } \log D _ { k } ( G ( z ) ) , k \in \{ 1 , . . . , K \}$ , is the loss provided by the $k$ -th discriminator. Training proceeds as the usual formulation (Goodfellow et al., 2014), i.e. with alternate updates between the discriminators and the generator. Updates of each discriminator are performed to minimize the loss described in Eq. 5.
+
+A natural choice for generator’s updates is the MGD algorithm, described in Section 2. However, computing the direction of steepest descent $\mathbf { w } ^ { * }$ before every parameter update step, as required in MGD, can be prohibitively expensive for large neural networks. Therefore, we propose an alternative scheme for multi-objective optimization and argue that both our proposal and previously published methods can all be viewed as performing computationally more efficient versions of MGD update rule without the burden of having to solve a quadratric program, i.e. computing $\mathbf { w } ^ { * }$ , every iteration.
+
+# 4.1 HYPERVOLUME MAXIMIZATION FOR TRAINING GANS
+
+Fleischer (Fleischer, 2003) has shown that maximizing $\mathcal { H }$ yields Pareto-optimal solutions. Since MGD converges to a set of Pareto-stationary points, i.e. a super-set of the Pareto-optimal solutions, hypervolume maximization yields a sub-set of the solutions obtained using MGD.
+
+We exploit the above mentioned property and define the generator loss as the negative loghypervolume, as defined in Eq. 8:
+
+$$
+\mathcal { L } _ { G } = - \mathcal { V } = - \sum _ { k = 1 } ^ { K } \log ( \eta - l _ { k } ) ,
+$$
+
+where the nadir point coordinate $\eta$ is an upper bound for all $l _ { k }$ . In Fig. 1 we provide an illustrative example for the case where $K = 2$ . The highlighted region corresponds to $e ^ { \nu }$ . Since the nadir point $\eta ^ { * }$ is fixed, $\nu$ will only be maximized, and consequently $\mathcal { L } _ { G }$ minimized, if each $l _ { k }$ is minimized.
+
+Moreover, by adapting the results shown in (Miranda & Zuben, 2016), the gradient of $\mathcal { L } _ { G }$ with respect to any generator’s parameter $\theta$ is given by:
+
+$$
+\frac { \partial \mathcal { L } _ { G } } { \partial \theta } = \sum _ { k = 1 } ^ { K } \frac { 1 } { \eta - l _ { k } } \frac { \partial l _ { k } } { \partial \theta } .
+$$
+
+![](images/aacb77deaee8d22bc2023f6efdea942a44d009defa81535cced83fdc8b765d4b.jpg)  
+Figure 1: 2D example of the objective space where the generator loss is being optimized.
+
+In other words, the gradient can be obtained by computing a weighted sum of the gradients of the losses provided by each discriminator, whose weights are defined as the inverse distance to the nadir point components. This formulation will naturally assign more importance to higher losses in the final gradient, which is another useful property of hypervolume maximization.
+
+Nadir point selection. It is evident from Eq. 9 that the selection of $\eta$ directly affects the importance assignment of gradients provided by different discriminators. Particularly, as the quantity $\mathrm { m i n } _ { k } \{ \eta - l _ { k } \}$ grows, the multi-objective GAN game approaches the one defined by the simple average of $l _ { k }$ . Previous literature has discussed in depth the effects of the selection of $\eta$ in the case of population-based methods (Auger et al., 2009; 2012). However, those results are not readily applicable for the single-solution case. As will be shown in Section 5, our experiments indicate that the choice of $\eta$ plays an important role in the final quality of samples. Nevertheless, this effect becomes less relevant as the number of discriminators increases.
+
+Nadir point adaptation. Similarly to (Miranda & Zuben, 2016), we propose an adaptive scheme for $\eta$ such that at iteration $t$ : $\eta _ { t } = \delta \operatorname* { m a x } _ { k } \{ l _ { k , t } \}$ , where $\delta > 1$ is a user-defined parameter which will be referred to as slack. This enforces $\mathrm { m i n } _ { k } \{ \eta - l _ { k } \}$ to be higher when $\operatorname* { m i x } _ { k } \{ l _ { k , t } \}$ is high and low otherwise, which induces a similar behavior as an average loss when training begins and automatically places more importance on the discriminators in which performance is worse as training progresses. Extra discussion and an illustrative example of the adaptation scheme adopted is presented in Appendix G.
+
+Comparison to average loss minimization. The upper bound proven by Neyshabur et al. (2017) assumes that the marginals of the real and generated distributions are identical along all random projections. Average loss minimization does not ensure equally good approximation between the marginals along all directions. In case of a trade-off between discriminators, i.e. if decreasing the loss on a given projection increases the loss with respect to another one, the distribution of losses can be uneven. With HV on the other hand, especially when $\eta$ is reduced throughout training, overall loss will be kept high as long as there are discriminators with high loss. This objective tends to prefer central regions of a trade-off, in which all discriminators present a roughly equally low loss.
+
+# 4.2 RELATIONSHIP BETWEEN MULTIPLE DISCRIMINATOR GANS AND MGD
+
+All methods described previously for the solution of GANs with multiple discriminators, i.e. average loss minimization (Neyshabur et al., 2017), GMAN’s weighted average (Durugkar et al., 2016) and hypervolume maximization can be defined as MGD-like two-step algorithms consisting of: Step 1 - consolidating all gradients into a single update direction (compute the set $\alpha _ { 1 , \ldots , K } )$ ; Step 2 - updating parameters in the direction returned in step 1. Definition of Step $^ { l }$ for the different methods studied here can be seen in the following:
+
+$$
+\begin{array} { r } { \alpha _ { 1 : K } = \operatorname * { a r g m i n } _ { \alpha } | | \mathbf { w } | | , \quad \mathrm { s . t . } \quad \sum _ { k = 1 } ^ { K } \alpha _ { k } = 1 , \quad \alpha _ { k } \geq 0 \forall k \in \{ 1 , . . . , K \} } \end{array}
+$$
+
+2. Average loss minimization (Neyshabur et al., 2017): $\textstyle \alpha _ { k } = { \frac { 1 } { K } }$
+
+3. GMAN (Durugkar et al., 2016): $\alpha _ { k } = \mathrm { s o f t m a x } ( l _ { 1 : K } ) _ { k }$
+
+# 5 EXPERIMENTS
+
+We performed three sets of experiments aiming to analyze the following aspects: (i) How alternative methods for training GANs with multiple discriminators perform in comparison to MGD; (ii) How alternative methods perform in comparison to each other in terms of sample quality and coverage; and (iii) Whether the behavior induced by HV improves the results with respect to the baseline methods.
+
+Firstly, we exploited the relatively low dimensionality of MNIST and used it as testbed for a comparison of MGD with the other approaches, i.e. average loss minimization (AVG), GMAN’s weighted average loss, and HV, proposed in this work. Moreover, multiple initializations and slack combinations were evaluated in order to investigate how varying the number of discriminators affects robustness to those factors.
+
+Then, experiments were performed with CIFAR-10 while increasing the number of discriminators. We evaluated HV’s performance compared to baseline methods, and the effect in samples quality. We also analyzed the impact on the diversity of generated samples by using the stacked MNIST dataset (Srivastava et al., 2017). Samples of generators trained on stacked MNIST, CIFAR-10, CelebA, and Cats dataset are shown in the Appendix.
+
+In all experiments performed, the same architecture, set of hyperparameters and initialization were used for both AVG, GMAN and our proposed method. The only different aspect is the generator loss. Unless stated otherwise, Adam (Kingma & Ba, 2014) was used to train all the models with learning rate, $\beta _ { 1 }$ and $\beta _ { 2 }$ set to 0.0002, 0.5 and 0.999, respectively. Mini-batch size was set to 64. The Fréchet Inception Distance (FID) (Heusel et al., 2017) was employed for comparison. Details on FID computation can be found in Appendix A.
+
+# 5.1 MGD COMPARED WITH ALTERNATIVE METHODS
+
+We employed MGD in our experiments with MNIST. In order to do so, a quadratic program has to be solved prior to every parameters update. For this, we used the Scipy’s implementation of the Serial Least Square Quadratic Program solver2.
+
+Three and four fully connected layers with LeakyReLU activations were used for the generator and discriminator, respectively. Dropout was also employed in the discriminator and the random projection layer was implemented as a randomly initialized norm-1 fully connected layer, reducing the vectorized dimensionality of MNIST from 784 to 512. A pretrained LeNet (LeCun et al., 1998) was used for FID computation.
+
+Experiments over 100 epochs with 8 discriminators are reported in Fig. 2 and Fig. 3. In Fig. 2, box-plots refer to 30 independent computations of FID over 10000 images sampled from the generator which achieved the minimum FID at train time. FID results are measured at train time over 1000 images and the best values are reported in Fig. 3 along with the necessary time to achieve it.
+
+MGD outperforms all tested methods. However, its cost per iteration does not allow its use in more relevant datasets other than MNIST. Hypervolume maximization, on the other hand, performs closest to MGD than the considered baselines, while introducing no relevant extra cost. In Fig. 4, we analyze convergence in the Pareto-stationarity sense by plotting the norm of the update direction for each method, given by $\begin{array} { r l } {  { \vert \vert \sum _ { k = 1 } ^ { K } \alpha _ { k } \nabla l _ { k } \vert \vert } } \end{array}$ . All methods converged to similar norms, leading to the conclusion that different Pareto-stationary solutions will perform differently in terms of quality of samples. FID as a function of wall-clock time is shown in Figure 22 (Appendix H).
+
+HV sensitivity to initialization and choice of $\delta$ . Analysis of the sensitivity of the performance with the choice of the slack parameter $\delta$ and initialization was performed under the following setting: models were trained for 50 epochs on MNIST with hypervolume maximization using 8, 16, 24 discriminators. Three independent runs (different initializations) were executed with each $\delta = \{ 1 . 0 5 , 1 . 5 , 1 . 7 5 , 2 \}$ and number of discriminators, totalizing 36 final models. Fig. 5 reports the box-plots obtained for 5 FID independent computations using 10000 images, for each of the 36 models obtained under the setting previously described. Results clearly indicate that increasing the number of discriminators yields much smaller variation in the FID obtained by the final model.
+
+![](images/91f8bfb4e8adb871263d6e323025a4c783dad769d20010cd15b7d628218b7d5b.jpg)  
+Figure 2: Box-plots corresponding to 30 independent FID computations with 10000 images. MGD performs consistently better than other methods, followed by hypervolume maximization. Models that achieved minimum FID at train time were used. Red and blue dashed lines are the FIDs of a random generator and real data, respectively.
+
+![](images/88eb180271cc6c81af41d05933f331327667091f9b43dab3e2235153c7172b67.jpg)  
+Figure 3: Time vs. best FID achieved during training for each approach. FID values are computed over 1000 generated images after every epoch. MGD performs relevantly better than others in terms of FID, followed by HV. However, MGD is approximately 7 times slower than HV. HV is well-placed in the time-quality trade-off.
+
+![](images/101d78dc77ea694a1ddfb6ed6af4102d10994c7edf3ac2f09f1acdc7fbf5b37b.jpg)  
+Figure 4: Norm of the update direction over time for each method. While Pareto-stationarity is approximately achieved by all methods, performance varies relevantly in terms of FID.
+
+![](images/40180395ead77517c512f3350f5aeebfb3e94aef7d6ca2b0d9508b79a2a80200.jpg)  
+Figure 5: Independent FID evaluations for models obtained with different runs using distinct slack parameter $\delta$ . Sensitivity reduces as the number of discriminators increases.
+
+# 5.2 HV AS AN ALTERNATIVE FOR MGD
+
+We evaluate the performance of HV compared to baseline methods using the CIFAR-10 dataset. FID was computed with a pretrained ResNet (He et al., 2016). ResNet was trained on the 10-class classification task of CIFAR-10 up to approximately $9 5 \%$ test accuracy. DCGAN (Radford et al., 2015) and WGAN-GP (Gulrajani et al., 2017) were included in the experiments for FID reference. Same architectures as in (Neyshabur et al., 2017) were employed for all multi-discriminators settings. An increasing number of discriminators was used. Inception score as well as FID computed with other models are included in Appendix C.
+
+In Fig. 6, we report the box-plots of 15 independent evaluations of FID on 10000 images for the best model obtained with each method across 3 independent runs. Results once more indicate that HV outperforms other methods in terms of quality of the generated samples. Moreover, performance clearly improves as the number of discriminators grows. Fig. 7 shows the FID at train time, i.e. measured with 1000 generated samples after each epoch, for the best models across runs. Models trained against more discriminators clearly converge to smaller values. We report the norm of the update direction $\begin{array} { r l } {  { \vert \vert \sum _ { k = 1 } ^ { K } \alpha _ { k } \nabla l _ { k } \vert \vert } } & { { } } \end{array}$ for each method in Fig. 9, Appendix C.
+
+![](images/5a7b649caf777c4a9ba5334434f3b4c2a18eb458dc2887ec713ef29ee352b7cc.jpg)  
+Figure 6: Box-plots of 15 independent FID com- Figure 7: FID estimated over 1000 generated imputations with 10000 images. Dashed lines are ages at train time. Models trained against more real data (blue) and random generator (red) FIDs. discriminators achieve lower FID.
+
+Cost under the multiple discriminator setting. We highlight that even though training with multiple discriminators may be more computationally expensive when compared to conventional approaches, such framework supports fully parallel training of the discriminators, a feature which is not trivially possible in other GAN settings. For example in WGAN, the discriminator is serially updated multiple times for each generator update. In Fig. 10 at Appendix C, we provide a comparison between the wall-clock time per iteration between all methods evaluated. Serial implementations of discriminators updates with 8 and 16 discriminators were faster than WGAN-GP.
+
+# 5.3 EFFECT OF THE NUMBER OF DISCRIMINATORS ON SAMPLE DIVERSITY
+
+We repeat the experiments in (Srivastava et al., 2017) aiming to analyze how the number of discriminators impacts the sample diversity of the corresponding generator when trained using hypervolume maximization. The stacked MNIST dataset is employed and results reported in (Lin et al., 2017) are used for comparison. HV results for 8, 16, and 24 discriminators were obtained with 10k and 26k generator images averaged over 10 runs. The number of covered modes along with the KL divergence between the generated mode distribution and test data are reported in Table 1.
+
+Table 1: Number of covered modes and reverse KL divergence for stacked MNIST.   
+
+<table><tr><td>Test samples</td><td>Model</td><td>Modes (Max 1000)</td><td>KL</td></tr><tr><td rowspan="5">26k</td><td>DCGAN (Radford etal.,2015)</td><td>99.0</td><td>3.400</td></tr><tr><td>ALI (Dumoulin et al., 2016)</td><td>16.0</td><td>5.400</td></tr><tr><td>Unrolled GAN (Metz et al., 2016)</td><td>48.7</td><td>4.320</td></tr><tr><td>VEEGAN (Srivastava et al., 2017)</td><td>150.0</td><td>2.950</td></tr><tr><td>PacDCGAN2 (Lin et al.,2017)</td><td>1000.0± 0.0</td><td>0.060 ±0.003</td></tr><tr><td rowspan="3">10k</td><td>HV-8 disc.</td><td>679.2± 5.9</td><td>1.139 ± 0.011</td></tr><tr><td>HV - 16 disc.</td><td>998.0±1.8</td><td>0.120 ± 0.004</td></tr><tr><td>HV - 24 disc.</td><td>998.3 ± 1.1</td><td>0.116 ± 0.003</td></tr><tr><td rowspan="3">26k</td><td>HV -8 disc.</td><td>776.8 ±6.4</td><td>1.115 ± 0.007</td></tr><tr><td>HV - 16 disc.</td><td>1000.0± 0.0</td><td>0.088 ±0.002</td></tr><tr><td>HV - 24 disc.</td><td>1000.0 ± 0.0</td><td>0.084 ±0.002</td></tr></table>
+
+As in previous experiments, results improved as we increased the number of discriminators. All evaluated models using HV outperformed DCGAN, ALI, Unrolled GAN and VEEGAN. Moreover, HV with 16 and 24 discriminators achieved state-of-the-art coverage values. Thus, the increase in models’ capacity via using more discriminators directly resulted in an improvement in generator’s coverage. Training details as well as architectures information are presented in Appendix B.
+
+# 6 CONCLUSION
+
+In this work we have shown that employing multiple discriminators is a practical approach allowing us to trade extra capacity, and thereby extra computational cost, for higher quality and diversity of generated samples. Such an approach is complimentary to other advances in GANs training and can be easily used together with other methods. We introduced a multi-objective optimization framework for studying multiple discriminator GANs, and showed strong similarities between previous work and the multiple gradient descent algorithm. The proposed approach was observed to consistently yield higher quality samples in terms of FID. Furthermore, increasing the number of discriminators was shown to increase sample diversity and generator robustness.
+
+Deeper analysis of the quantity that using it as a penalty term $\begin{array} { r l } {  { \vert \vert \sum _ { k = 1 } ^ { K } \alpha _ { k } \nabla l _ { k } \vert \vert } } & { { } } \end{array}$ is the subject of future investigation. We hypothesize necessity of a high number of discriminators.
+
+# REFERENCES
+
+Martin Arjovsky, Soumith Chintala, and Léon Bottou. Wasserstein GAN. arXiv preprint arXiv:1701.07875, 2017.
+
+Anne Auger, Johannes Bader, Dimo Brockhoff, and Eckart Zitzler. Theory of the hypervolume indicator: optimal $\mu$ -distributions and the choice of the reference point. In Proceedings of the tenth ACM SIGEVO workshop on Foundations of genetic algorithms, pp. 87–102. ACM, 2009.
+
+Anne Auger, Johannes Bader, Dimo Brockhoff, and Eckart Zitzler. Hypervolume-based multiobjective optimization: Theoretical foundations and practical implications. Theoretical Computer Science, 425:75–103, 2012.
+
+Johannes Bader and Eckart Zitzler. HypE: An algorithm for fast hypervolume-based many-objective optimization. Evolutionary computation, 19(1):45–76, 2011.
+
+David Berthelot, Tom Schumm, and Luke Metz. BEGAN: boundary equilibrium generative adversarial networks. CoRR, abs/1703.10717, 2017. URL http://arxiv.org/abs/1703.10717.
+
+Nicola Beume, Boris Naujoks, and Michael Emmerich. SMS-EMOA: Multiobjective selection based on dominated hypervolume. European Journal of Operational Research, 181(3):1653–1669, 2007.
+
+Kalyanmoy Deb. Multi-objective optimization using evolutionary algorithms, volume 16. John Wiley & Sons, 2001.
+
+Jean-Antoine Désidéri. Multiple-gradient descent algorithm (MGDA) for multiobjective optimization. Comptes Rendus Mathematique, 350(5-6):313–318, 2012.
+
+Vincent Dumoulin, Ishmael Belghazi, Ben Poole, Olivier Mastropietro, Alex Lamb, Martin Arjovsky, and Aaron Courville. Adversarially learned inference. arXiv preprint arXiv:1606.00704, 2016.
+
+Ishan Durugkar, Ian Gemp, and Sridhar Mahadevan. Generative multi-adversarial networks. arXiv preprint arXiv:1611.01673, 2016.
+
+Mark Fleischer. The measure of pareto optima applications to multi-objective metaheuristics. In International Conference on Evolutionary Multi-Criterion Optimization, pp. 519–533. Springer, 2003.
+
+Maurice Fréchet. Sur la distance de deux lois de probabilité. COMPTES RENDUS HEBDOMADAIRES DES SEANCES DE L ACADEMIE DES SCIENCES, 244(6):689–692, 1957.
+
+Ian Goodfellow. NIPS 2016 tutorial: Generative adversarial networks. arXiv preprint arXiv:1701.00160, 2016.
+
+Ian Goodfellow, Jean Pouget-Abadie, Mehdi Mirza, Bing Xu, David Warde-Farley, Sherjil Ozair, Aaron Courville, and Yoshua Bengio. Generative adversarial nets. In Advances in neural information processing systems, pp. 2672–2680, 2014.
+
+Ishaan Gulrajani, Faruk Ahmed, Martin Arjovsky, Vincent Dumoulin, and Aaron C Courville. Improved training of Wasserstein GANs. In Advances in Neural Information Processing Systems, pp. 5769–5779, 2017.
+
+Kaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. Deep residual learning for image recognition. In Proceedings of the IEEE conference on computer vision and pattern recognition, pp. 770–778, 2016.
+
+Martin Heusel, Hubert Ramsauer, Thomas Unterthiner, Bernhard Nessler, and Sepp Hochreiter. GANs trained by a two time-scale update rule converge to a local nash equilibrium. In Advances in Neural Information Processing Systems, pp. 6629–6640, 2017.
+
+Alexia Jolicoeur-Martineau. The relativistic discriminator: a key element missing from standard gan. arXiv preprint arXiv:1807.00734, 2018.
+
+Diederik P Kingma and Jimmy Ba. Adam: A method for stochastic optimization. arXiv preprint arXiv:1412.6980, 2014.
+
+Yann LeCun, Léon Bottou, Yoshua Bengio, and Patrick Haffner. Gradient-based learning applied to document recognition. Proceedings of the IEEE, 86(11):2278–2324, 1998.
+
+Zinan Lin, Ashish Khetan, Giulia Fanti, and Sewoong Oh. PacGAN: The power of two samples in generative adversarial networks. arXiv preprint arXiv:1712.04086, 2017.
+
+Xudong Mao, Qing Li, Haoran Xie, Raymond YK Lau, Zhen Wang, and Stephen Paul Smolley. Least squares generative adversarial networks. In Computer Vision (ICCV), 2017 IEEE International Conference on, pp. 2813–2821. IEEE, 2017.
+
+Luke Metz, Ben Poole, David Pfau, and Jascha Sohl-Dickstein. Unrolled generative adversarial networks. arXiv preprint arXiv:1611.02163, 2016.
+
+Conrado Silva Miranda and Fernando José Von Zuben. Single-solution hypervolume maximization and its use for improving generalization of neural networks. CoRR, abs/1602.01164, 2016. URL http://arxiv.org/abs/1602.01164.
+
+Takeru Miyato, Toshiki Kataoka, Masanori Koyama, and Yuichi Yoshida. Spectral normalization for generative adversarial networks. arXiv preprint arXiv:1802.05957, 2018.
+
+Behnam Neyshabur, Srinadh Bhojanapalli, and Ayan Chakrabarti. Stabilizing GAN training with multiple random projections. arXiv preprint arXiv:1705.07831, 2017.
+
+Sebastian Peitz and Michael Dellnitz. Gradient-based multiobjective optimization with uncertainties. In NEO 2016, pp. 159–182. Springer, 2018.
+
+Alec Radford, Luke Metz, and Soumith Chintala. Unsupervised representation learning with deep convolutional generative adversarial networks. arXiv preprint arXiv:1511.06434, 2015.
+
+Tim Salimans, Ian Goodfellow, Wojciech Zaremba, Vicki Cheung, Alec Radford, and Xi Chen. Improved techniques for training GANs. In Advances in Neural Information Processing Systems, pp. 2234–2242, 2016.
+
+Stefan Schäffler, Reinhart Schultz, and Klaus Weinzierl. Stochastic method for the solution of unconstrained vector optimization problems. Journal of Optimization Theory and Applications, 114(1):209–222, 2002.
+
+Akash Srivastava, Lazar Valkoz, Chris Russell, Michael U Gutmann, and Charles Sutton. VEEGAN: Reducing mode collapse in GANs using implicit variational learning. In Advances in Neural Information Processing Systems, pp. 3310–3320, 2017.
+
+Christian Szegedy, Vincent Vanhoucke, Sergey Ioffe, Jon Shlens, and Zbigniew Wojna. Rethinking the inception architecture for computer vision. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pp. 2818–2826, 2016.
+
+Abhay Yadav, Sohil Shah, Zheng Xu, David Jacobs, and Tom Goldstein. Stabilizing adversarial nets with prediction methods. arXiv preprint arXiv:1705.07364, 2017.
+
+# APPENDIX
+
+A - OBJECTIVE EVALUATION METRIC.
+
+In (Heusel et al., 2017), authors proposed to use as a quality metric the squared Fréchet distance (Fréchet, 1957) between Gaussians defined by estimates of the first and second order moments of the outputs obtained through a forward pass in a pretrained classifier of both real and generated data. They proposed the use of Inception V3 (Szegedy et al., 2016) for computation of the data representation and called the metric Fréchet Inception Distance (FID), which is defined as:
+
+$$
+\mathrm { F I D } = | | m _ { d } - m _ { g } | | ^ { 2 } + \mathrm { T r } ( \Sigma _ { d } + \Sigma _ { g } - 2 ( \Sigma _ { d } \Sigma _ { g } ) ^ { \frac { 1 } { 2 } } ) ,
+$$
+
+where $m _ { d } , \Sigma _ { d }$ and $m _ { g } , \Sigma _ { g }$ are estimates of the first and second order moments from the representations of real data distributions and generated data, respectively.
+
+We employ FID throughout our experiments for comparison of different approaches. However, for each dataset in which FID was computed, the output layer of a pretrained classifier on that particular dataset was used instead of Inception. $m _ { d }$ and $\Sigma _ { d }$ were estimated on the complete test partitions, which are not used during training.
+
+# B - EXPERIMENTAL SETUP FOR STACKED MNIST EXPERIMENTS AND GENERATOR’S SAMPLES
+
+Architectures of the generator and discriminator are detailed in Tables 2 and 3, respectively. Batch normalization was used in all intermediate convolutional and fully connected layers of both models. We employed RMSprop to train all the models with learning rate and $\alpha$ set to 0.0001 and 0.9, respectively. Mini-batch size was set to 64. The setup in (Lin et al., 2017) is employed and we build 128000 and 26000 samples for train and test sets, respectively.
+
+Table 2: Generator’s architecture.   
+
+<table><tr><td>Layer</td><td>Outputs</td><td>Kernel size</td><td>Stride</td><td>Activation</td></tr><tr><td>Input: z ~ N(0,I100)</td><td></td><td></td><td></td><td></td></tr><tr><td>Fully connected</td><td>2*2*512</td><td>4,4</td><td>2,2</td><td>ReLU</td></tr><tr><td>Transposed convolution</td><td>4*4*256</td><td>4,4</td><td>2,2</td><td>ReLU</td></tr><tr><td>Transposed convolution</td><td>8*8*128</td><td>4,4</td><td>2,2</td><td>ReLU</td></tr><tr><td>Transposed convolution</td><td>14*14*64</td><td>4,4</td><td>2,2</td><td>ReLU</td></tr><tr><td>Transposed convolution</td><td>28*28*3</td><td>4,4</td><td>2,2</td><td>Tanh</td></tr></table>
+
+Table 3: Discriminator’s architecture.   
+
+<table><tr><td>Layer</td><td>Outputs</td><td>Kernel size</td><td>Stride</td><td>Activation</td></tr><tr><td>Input</td><td>28*28*3</td><td></td><td></td><td></td></tr><tr><td>Projection</td><td>14*14*3</td><td>8,8</td><td>2,2</td><td></td></tr><tr><td>Convolution</td><td>7*7*64</td><td>4,4</td><td>2,2</td><td>LeakyReLU</td></tr><tr><td>Convolution</td><td>5*5*128</td><td>4,4</td><td>2,2</td><td>LeakyReLU</td></tr><tr><td>Convolution</td><td>2*2*256</td><td>4,4</td><td>2,2</td><td>LeakyReLU</td></tr><tr><td>Convolution</td><td>1</td><td>4,4</td><td>2,2</td><td>Sigmoid</td></tr></table>
+
+![](images/481640c8fe2e5164297573678c2a8abf1e9259ff825790a049f74bc295132419.jpg)  
+(a) HV - 8 discriminators
+
+![](images/733d26391c3ddb3857dee445d2ca098b8cc829c46fd477ef6731d12cdd9bee85.jpg)  
+(b) HV - 16 discriminators
+
+![](images/e976f9e6327545017aefbea78d5a2ac2705b64f7e354b05c12a2e90406346b51.jpg)  
+Figure 8: Stacked MNIST samples for HV trained with 8, 16, and 24 discriminators. Samples diversity increases greatly when more discriminators are employed.
+
+# (c) HV - 24 discriminators
+
+# C - EXTRA RESULTS ON CIFAR-10
+
+# C.1 - MULTIPLE DISCRIMINATORS ACROSS DIFFERENT INITIALIZATIONS AND OTHER SCORES
+
+Table 4 presents the best FID (computed with a pretrained ResNet) achieved by each approach at train time, along with the epoch in which it was achieved, for each of 3 independent runs. Train time FIDs are computed using 1000 generated images.
+
+Table 4: Best FID obtained for each approach on 3 independent runs. FID is computed on 1000 generated images after every epoch.   
+
+<table><tr><td>#D</td><td>Method</td><td>Best FID (epoch)</td></tr><tr><td rowspan="2">1</td><td>DCGAN</td><td>7.09 (68),9.09 (21),4.22 (101)</td></tr><tr><td>WGAN-GP</td><td>5.09 (117),5.69 (101) 7.13 (71)</td></tr><tr><td rowspan="3">8</td><td>AVG</td><td>3.35 (105),4.64 (141),3.00 (76)</td></tr><tr><td>GMAN</td><td>4.28 (123),4.24 (129),3.80 (133)</td></tr><tr><td>HV</td><td>3.87 (102),4.54 (82),3.20 (98)</td></tr><tr><td rowspan="3">16</td><td>AVG</td><td>3.16 (96),2.50 (91),2.77 (116)</td></tr><tr><td>GMAN</td><td>2.69 (129),2.36 (144),2.48 (120)</td></tr><tr><td>HV</td><td>2.56 (85),2.70 (97),2.68 (133)</td></tr><tr><td rowspan="3">24</td><td>AVG</td><td>2.10 (94),2.44 (132),2.43 (129)</td></tr><tr><td>GMAN</td><td>2.16 (120),2.02 (98),2.13 (130)</td></tr><tr><td>HV</td><td>2.05 (83),1.89 (97),2.23 (130)</td></tr></table>
+
+In Fig. 9, we report the norm of the update direction $\begin{array} { r l } {  { \vert \vert \sum _ { k = 1 } ^ { K } \alpha _ { k } \nabla l _ { k } \vert \vert } } & { { } } \end{array}$ of the best model obtained for Pareto-stationarity sense, i.e. the norm upon convergence is lower for models trained against more discriminators, regardless of the employed method.
+
+![](images/7ea792a59ab6686cb0ca729991fbf4a0c965f5f36cc504ae38c2d2e4138c2537.jpg)  
+Figure 9: Norm of the update direction over time for each method. Higher number of discriminators yield lower norm upon convergence.
+
+We computed extra scores using 10000 images generated by the best model reported in Table 4, i.e. the same models utilized to generate the results shown in Fig. 6. Both Inception score and FID were computed with original implementations, while FID-VGG and FID-ResNet were computed using a VGG and a ResNet we pretrained. Results are reported with respect to DCGAN’s scores.
+
+<table><tr><td></td><td>WGAN-GP</td><td>AVG-8</td><td>AVG-16</td><td>AVG-24</td><td>GMAN-8</td><td>GMAN-16</td><td>GMAN-24</td><td>HV-8</td><td>HV-16</td><td>HV-24</td></tr><tr><td>InceptionScore</td><td>1.08</td><td>1.02</td><td>1.26</td><td>1.36</td><td>0.95</td><td>1.32</td><td>1.42</td><td>1.00</td><td>1.30</td><td>1.44</td></tr><tr><td>FID</td><td>0.80</td><td>0.98</td><td>0.76</td><td>0.73</td><td>0.92</td><td>0.79</td><td>0.65</td><td>0.89</td><td>0.77</td><td>0.72</td></tr><tr><td>FID-VGG</td><td>1.29</td><td>0.91</td><td>1.03</td><td>0.85</td><td>0.87</td><td>0.78</td><td>0.73</td><td>0.78</td><td>0.75</td><td>0.64</td></tr><tr><td>FID-ResNet</td><td>1.64</td><td>0.88</td><td>0.90</td><td>0.62</td><td>0.80</td><td>0.72</td><td>0.73</td><td>0.75</td><td>0.73</td><td>0.51</td></tr></table>
+
+Table 5: Scores of different methods measure on generated CIFAR-10 samples. DCGAN scores are used as reference values, and results report are the ratio between given model and DCGAN scores. Inception score is better when high, whereas FIDs are better when low.
+
+# C.2 - COMPUTATIONAL COST
+
+In Table 6 we present a comparison of minimum FID-ResNet obtained during training, along with computation cost in terms of time and space for different GANs, with both 1 and 24 discriminators. The computational cost of training GANs under a multiple discriminator setting is higher by design, in terms of both FLOPS and memory, if compared with single discriminators settings. However, a corresponding shift in performance is the result of the additional cost. This effect was consistently observed considering 4 different well-known approaches, namely DCGAN (Radford et al., 2015), Least-square GAN (LSGAN) (Mao et al., 2017), and HingeGAN (Miyato et al., 2018). The architectures of all single discriminator models follow the DCGAN, described in (Radford et al., 2015). For the 24 discriminators models, we used the architecture described in (Neyshabur et al., 2017), which consists in removing the the normalization layers from DCGAN’s discriminator and further adding the projection layer, inline with previous experiments reported for CIFAR-10 upscaled to $6 4 \mathrm { x } 6 4$ . All models were trained with minibatch size of 64 during 150 epochs. Adam (Kingma & Ba, 2014) was used as the optimizer. Learning rate, $\beta _ { 1 }$ and $\beta _ { 2 }$ were equal to 0.0002, 0.5 and 0.999, respectively.
+
+<table><tr><td></td><td>#Discriminators</td><td>FID-ResNet</td><td>FLOPS (MAC)</td><td>Memory (Mb)</td></tr><tr><td rowspan="2">DCGAN</td><td>1</td><td>4.22</td><td>8e10</td><td>1292</td></tr><tr><td>24</td><td>1.89</td><td>5e11</td><td>5671</td></tr><tr><td rowspan="2">LSGAN</td><td>1</td><td>4.55</td><td>8e10</td><td>1303</td></tr><tr><td>24</td><td>1.91</td><td>5e11</td><td>5682</td></tr><tr><td rowspan="2">HingeGAN</td><td>1</td><td>6.17</td><td>8e10</td><td>1303</td></tr><tr><td>24</td><td>2.25</td><td>5e11</td><td>5682</td></tr></table>
+
+Table 6: Comparison between different GANs with 1 and 24 discriminators in terms of minimum FID-ResNet obtained during training, and FLOPs and memory consumption for a complete train step.
+
+Furthermore, wall-clock time per iteration for different numbers of discriminators is shown in Fig. 10 for experiments with CIFAR-10 with serial updates of discriminators. Notice that while the increase in cost in terms of FLOPS and memory is unavoidable when multiple discriminators settings is employed, wall-clock time can be made close to single discriminators cases since training with respect to different discriminators can be implemented in parallel. On the other hand, extra cost in time introduced by other frameworks such as WGAN-GP or SNGAN cannot be trivially recovered.
+
+![](images/301bfb521f36f11b23715bfd1af7df6decd71c59cec4f42cdb6f8a930e9896cd.jpg)  
+Figure 10: Time in seconds per iteration of each method for serial updates of discriminators. Multiple discriminators approaches considered do not present relevant difference in time per iteration.
+
+# C.3 - GENERATED SAMPLES
+
+In Figs. 11, 12, and 13 we show random generated samples with 8, 16, and 24 discriminators for AVG, GMAN, and HV, respectively.
+
+![](images/4f6cd9aa1191d74bb1e3643d7c57f98a2c445ecba39f5cd7da73cdcd79df8e85.jpg)  
+Figure 11: CIFAR-10 samples for AVG trained with 8, 16, and 24 discriminators.
+
+![](images/d17f7aaac2f8eedc9706144a3800e581c85826f1e890b645b9b3784df18f0138.jpg)  
+Figure 12: CIFAR-10 samples for GMAN trained with 8, 16, and 24 discriminators.
+
+![](images/44c285f9959ece1ca6354c2e221b93ff0f12fb3c777e98e2cc04a27c326df146.jpg)  
+Figure 13: CIFAR-10 samples for HV trained with 8, 16, and 24 discriminators.
+
+# C.4 - RESULTS CIFAR-10 32X32
+
+All results reported in previous sections using CIFAR-10 were obtained with an upscaled version of the dataset. Here, we thus run experiments with the dataset in its original resolution aiming to contextualize our proposed approach with respect to previously introduced methods. To do so, we repeated similar experiments as reported in Miyato et al. (2018)-Table 2, for the model referred to as standard CNN. The same architecture is employed and the spectral normalization is removed from the discriminators. Moreover, the same projection input is added in each of the discriminators.
+
+Results in terms of both FID and Inception score, evaluated on top of 5000 generated images as in (Miyato et al., 2018) as well as with 10000 images, are reported in Table 7 for our proposed approach and our implementation of (Miyato et al., 2018), along with the FID measured using a ResNet classifier trained in advance.
+
+As can be seen, the addition of the multiple discriminators setting along with hypervolume maximization yields a relevant shift in performance for the DCGAN-like generator, taking all evaluated metrics to levels of recently proposed GANs.   
+
+<table><tr><td></td><td>FID-ResNet</td><td>FID (5k)</td><td>IS (5k)</td><td>FID (10k)</td><td>IS (10k)</td></tr><tr><td>SNGAN (Miyato et al., 2018)</td><td>-</td><td>25.5</td><td>7.58±0.12</td><td>-</td><td>-</td></tr><tr><td>WGAN-GP (Miyato et al., 2018)</td><td></td><td>40.2</td><td>6.68 ± 0.06</td><td>1</td><td>-</td></tr><tr><td>DCGAN (Miyato et al., 2018)</td><td>-</td><td>-</td><td>6.64± 0.14</td><td>-</td><td>=</td></tr><tr><td>SNGAN (our implementation)</td><td>1.55</td><td>27.93</td><td>7.11 ± 0.30</td><td>25.29</td><td>7.26± 0.12</td></tr><tr><td>DCGAN + 24 Ds and HV</td><td>1.21</td><td>27.74</td><td>7.32 ± 0.26</td><td>24.90</td><td>7.45 ± 0.17</td></tr></table>
+
+Table 7: Evaluation of the effect of adding discriminators on a DCGAN-like model trained on CIFAR-10. Results reach the same level as the best reported for the given architecture when the multiple-discriminator setting is added and the normalization layers are removed from discriminators.
+
+# D - CELEBA DATASET
+
+# D.1 - COMPARING WITH OTHER MULTIPLE-DISCRIMINATORS APPROACHES
+
+Here, we present samples obtained by generators trained against 8, 16, and 24 discriminators using AVG, GMAN, and HV on the CelebA dataset rescaled to $6 4 \mathrm { x } 6 4$ . Training lasted 100 epochs and samples are shown in Figs. 14, 15, and 16 for AVG, GMAN and HV, respectively. Same architectures and hyperparameters used for experiments with CIFAR-10 presented in Section 5 were utilized.
+
+![](images/805c9d68728ee19b1eac47e5d4ed22825d4927a4045497fcf76de0a89503d251.jpg)  
+Figure 14: CelebA samples for AVG trained with 8, 16, and 24 discriminators.
+
+![](images/a96174141a86e0eaadf85353beb5db24aaf25afe0c3f891f527278df36f89827.jpg)  
+Figure 15: CelebA samples for GMAN trained with 8, 16, and 24 discriminators.
+
+![](images/ca108c2ceb1f8e89e8591e129d2689b99c0d6e3245069c86c43ab157a79e879e.jpg)  
+Figure 16: CelebA samples for HV trained with 8, 16, and 24 discriminators.
+
+# D.2 - GENERATING 128X128 IMAGES
+
+In this experiment, we verify whether the proposed multiple discriminators setting is capable of generating higher resolution images. For that, we employed the CelebA at a size of $1 2 8 \mathrm { x } 1 2 8$ . We used a similar architecture for both generator and discriminators networks as described in the previous experiments. A convolutional layer with 2048 feature maps was added to both generator and discriminators architectures due to the increase in the image size. Adam optimizer with the same set of hyperparameters as for CIFAR-10 and CelebA $6 4 \mathrm { x } 6 4$ was employed. We trained models with 6, 8, and 10 discriminators during 24 epochs. Samples from each generator are shown in Figure 17.
+
+![](images/d5427bf30474177574950cec528e2b26ea690bcdeecc69f90e8b088ac3bc03f1.jpg)  
+Figure 17: 128x128 CelebA samples for HV trained during 24 epochs with 6, 8, and 10 discriminators.
+
+# E - GENERATING 256X256 CATS
+
+We show the proposed multiple-discriminators setting scales to higher resolution even in the small dataset regime, by reproducing the experiments presented in (Jolicoeur-Martineau, 2018). We used the same architecture for the generator. For the discriminator, we removed batch normalization from all layers and used stride equal to 1 at the last convolutional layer, after adding the initial projection step. The Cats dataset 3 was employed, we followed the same pre-processing steps, which, in our case, yielded 1740 training samples with resolution of $2 5 6 \times 2 5 6$ . Our model is trained using 24 discriminators and Adam optimizer with the same hyperparameters as for CIFAR-10 and CelebA previously described experiments. In Figure 18 we show generator’s samples after 288 training epochs. One epoch corresponds to updating over 27 minibatches of size 64.
+
+![](images/c3e312a8b196aadce61e0a136ff84397e9a2647d22d888dbe6bd557b4735c5f9.jpg)  
+Figure 18: Cats generated using 24 discriminators after 288 training epochs.
+
+# F - INCREASING NUMBER OF RANDOM PROJECTIONS
+
+In this experiment we illustrate and confirm the results introduced in (Neyshabur et al., 2017), showing the effect of using an increasing number of random projections to train a GAN. We trained models using average loss minimization with 1 to 6 discriminators on the CelebA dataset for 15 epochs. Samples from the generator obtained in the last epoch are shown in Fig. 19. Generated samples are closer to real data as the number of random projections (and discriminators, consequently) increases.
+
+![](images/c7b70be0f9e460f745e9f9c8ca54464bb53510f76261cb014b44bdbbc8c4bf6a.jpg)
+
+![](images/6b589d37c928da22dfbae82afe91e2a109db7829633513ec8897d7b3e5d2ec4b.jpg)  
+Figure 19: Models trained with AVG during 15 epochs using an increasing number of random projections and discriminators.
+
+# (f) AVG - 6 discriminators
+
+# G - ILLUSTRATION OF INTERACTION BETWEEN HYPERVOLUME AND ADOPTEDNADIR POINT ADAPTATION SCHEME
+
+Consider a two-objectives problem, with $l _ { 1 } ^ { t } > 0$ and $l _ { 2 } ^ { t } > 0$ corresponding to each of the losses we want to minimize, at iteration $t$ . We present in Figures 20 and 21 an illustrative example of the effect of the adaptation scheme adopted for $\eta$ , as described in Section 4.
+
+Figure 20 describes the initialization state. Since $l _ { 1 } ^ { t }$ and $l _ { 2 } ^ { t }$ will be high at $t = 0$ , and, following the adaptation rule presented in previous sections, $\eta ^ { t } = \overline { { \delta } } \operatorname* { m a x } \{ l _ { 1 } ^ { t } , l _ { 2 } ^ { t } \}$ , for a slack $\delta > 0$ , the difference $\eta ^ { t } - \operatorname* { m a x } \{ l _ { 1 } ^ { t } , l _ { 2 } ^ { t } \}$ will be high. In contrast, after $T$ updates, as described in Figure 21, $\eta ^ { t } = \delta \operatorname* { m a x } \{ l _ { 1 } ^ { t } , l _ { 2 } ^ { t } \}$ will be smaller, since losses are now closer to 0.
+
+If no adaptation is performed and $\eta$ is kept unchanged throughout training, as represented in red in Figure 21, $\eta ^ { T } - l _ { 1 } ^ { \dot { T } } \approx \eta ^ { T } - l _ { 2 } ^ { T }$ for a large enough $T$ , which will end up assigning similar weights to gradients provided by the different losses, defeating the purpose of employing hypervolume maximization rather than optimizing for the average loss.
+
+The employed adaptation scheme thus keeps the gradient weighting relevant even when losses become low. Moreover, this effect will be more aggressive as training progresses, assigning more gradient importance to the higher losses, since $\eta ^ { T } \stackrel { \smile \smile } { - } \operatorname* { m a x } \{ l _ { 1 } ^ { T } , l _ { 2 } ^ { T } \} < \tilde { \eta ^ { 0 } } ^ { \perp } - \tilde { \operatorname* { m a x } } \{ l _ { 1 } ^ { 0 } , l _ { 2 } ^ { 0 } \}$ .
+
+![](images/5b8e84076c970a1a21cf255988d1753fc8e0f1c6ad1c536e534fc0b35348b8d0.jpg)  
+Figure 20: Losses and nadir point at beginning of training.
+
+![](images/59472b02e0b91f44394376f94dbfa92a5391f0569bc3e9d8d89e4c665f46c83e.jpg)  
+Figure 21: Losses and nadir point at $t = T$ , and nadir point at $t = 0$ (in red).
+
+# H - WALL-CLOCK TIME FOR REACHING BEST FID DURING TRAINING ON MNIST
+
+![](images/f8543d63bd2e5b7eea705799930fda13a6599947829cd03e0997c810580b1ace.jpg)  
+Figure 22: Minimum FID during training. X-axis is in minutes. The blue dot is intended to highlight the moment during training when the minimum FID was reached.

parse/train/S1MB-3RcF7/S1MB-3RcF7_content_list.json

@@ -0,0 +1,2249 @@
+[
+    {
+        "type": "text",
+        "text": "MULTI-OBJECTIVE TRAINING OF GENERATIVE ADVERSARIAL NETWORKS WITH MULTIPLE DISCRIMINATORS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            99,
+            828,
+            170
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Anonymous authors Paper under double-blind review ",
+        "bbox": [
+            183,
+            195,
+            398,
+            223
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "ABSTRACT ",
+        "text_level": 1,
+        "bbox": [
+            454,
+            261,
+            544,
+            275
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Recent literature has demonstrated promising results on the training of Generative Adversarial Networks by employing a set of discriminators, as opposed to the traditional game involving one generator against a single adversary. Those methods perform single-objective optimization on some simple consolidation of the losses, e.g. an average. In this work, we revisit the multiple-discriminator approach by framing the simultaneous minimization of losses provided by different models as a multi-objective optimization problem. Specifically, we evaluate the performance of multiple gradient descent and the hypervolume maximization algorithm on a number of different datasets. Moreover, we argue that the previously proposed methods and hypervolume maximization can all be seen as variations of multiple gradient descent in which the update direction computation can be done efficiently. Our results indicate that hypervolume maximization presents a better compromise between sample quality and diversity, and computational cost than previous methods. ",
+        "bbox": [
+            233,
+            295,
+            766,
+            488
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 INTRODUCTION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            525,
+            336,
+            541
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Generative Adversarial Networks (GANs) (Goodfellow et al., 2014) offer a new approach to generative modeling, using game-theoretic training schemes to implicitly learn a given probability density. Prior to the emergence of GAN architectures, realistic generative modeling remained elusive. When offering unparalleled realism, GAN training remains fraught with stability issues. Commonly reported shortcomings involved in the GAN game are the lack of useful gradients provided by the discriminator, and mode collapse, i.e. lack of diversity in the generator’s samples. ",
+        "bbox": [
+            174,
+            559,
+            825,
+            642
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Considerable research effort has been devoted in recent literature in order to overcome training instability 1 within the GAN framework. Some architectures such as BEGAN (Berthelot et al., 2017) have applied auto-encoders as discriminators and proposed a new loss to help stabilize training. Methods such as TTUR (Heusel et al., 2017), in turn, have attempted to define schedules for updating the generator and discriminator differently. The PacGAN algorithm (Lin et al., 2017) proposes to modify the discriminator’s architecture which will receive m concatenated samples as input, while modifications to alternate updates in SGD were introduced in (Yadav et al., 2017). These samples are jointly classified as either real or generated, and authors show that this enforces sample diversity. In SNGAN (Miyato et al., 2018), authors introduce spectral normalization on the discriminator aiming to ensure Lipschitz continuity, which is empirically shown to consistently yield high quality samples when different sets of hyperparameters are used. ",
+        "bbox": [
+            174,
+            650,
+            825,
+            803
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Recent works have proposed to tackle GANs instability issues using multiple discriminators. Neyshabur et al. (2017) propose a GAN variation in which one generator is trained against a set of discriminators, where each discriminator sees a fixed random projection of the inputs. Prior work, including GMAN (Durugkar et al., 2016) has also explored training against multiple discriminators. ",
+        "bbox": [
+            174,
+            809,
+            826,
+            864
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "In this paper, we build upon Neyshabur et al.’s introduced framework and propose reformulating the average loss minimization aiming to further stabilize GAN training. Specifically, we propose treating the loss signal provided by each discriminator as an independent objective function. To achieve this, we simultaneously minimize the losses using multi-objective optimization techniques. Namely, we exploit previously introduced methods in literature such as the multiple gradient descent algorithm (MGD) (Désidéri, 2012). However, due to MGD’s prohibitively high cost in the case of large neural networks, we propose the use of more efficient alternatives such as maximization of the hypervolume of the region defined between a fixed, shared upper bound on those losses, which we will refer to as the nadir point $\\eta ^ { * }$ , and each of the component losses. ",
+        "bbox": [
+            174,
+            103,
+            825,
+            229
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "In contrast to Neyshabur et al. (2017)’s approach, where the average loss is minimized when training the generator, hypervolume maximization (HV) optimizes a weighted loss, and the generator’s training will adaptively assign greater importance to feedback from discriminators against which it performs poorly. ",
+        "bbox": [
+            174,
+            236,
+            825,
+            291
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Experiments performed on MNIST show that HV presents a good compromise in the computational cost-samples quality trade-off, when compared to average loss minimization or GMAN’s approach (low quality and cost), and MGD (high quality and cost). Also, the sensitivity to introduced hyperparameters is studied and results indicate that increasing the number of discriminators consequently increases the generator’s robustness along with sample quality and diversity. Experiments on CIFAR10 indicate the method described produces higher quality generator samples in terms of quantitative evaluation. Moreover, image quality and sample diversity are once more shown to consistently improve as we increase the number of discriminators. ",
+        "bbox": [
+            173,
+            297,
+            825,
+            410
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "In summary, our main contributions are the following: ",
+        "bbox": [
+            178,
+            416,
+            527,
+            431
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "1. We offer a new perspective on multiple-discriminator GAN training by framing it in the context of multi-objective optimization, and draw similarities between previous research in GANs variations and MGD, commonly employed as a general solver for multi-objective optimization.   \n2. We propose a new method for training multiple-discriminator GANs: Hypervolume maximization, which weighs the gradient contributions of each discriminator by its loss. ",
+        "bbox": [
+            202,
+            444,
+            825,
+            532
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "The remainder of this document is organized as follows: Section 2 introduces definitions on multiobjective optimization and MGD. In Section 3 we describe prior relevant literature. Hypervolume maximization is detailed in Section 4, with experiments and results presented in Section 5. Conclusions and directions for future work are drawn in Section 6. ",
+        "bbox": [
+            174,
+            545,
+            826,
+            601
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2 PRELIMINARIES ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            621,
+            339,
+            637
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "In this section we provide some definitions regarding multi-objective optimization literature which will be useful in the next sections. Henceforth, the boldface notation will be used to indicate vector-valued variables. ",
+        "bbox": [
+            174,
+            651,
+            823,
+            694
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Multi-objective optimization. A multi-objective optimization problem is defined as (Deb, 2001): ",
+        "bbox": [
+            169,
+            700,
+            813,
+            717
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "equation",
+        "img_path": "images/00b5d5e838c799f702256dd0ef899f5601285757081b5ddb7de120ff4a3aa4b3.jpg",
+        "text": "$$\n\\begin{array} { r l } & { \\operatorname* { m i n } \\mathbf { F } ( \\mathbf { x } ) = [ f _ { 1 } ( \\mathbf { x } ) , f _ { 2 } ( \\mathbf { x } ) , . . . , f _ { K } ( \\mathbf { x } ) ] ^ { T } , } \\\\ & { \\quad \\quad \\quad \\mathbf { x } \\in \\Omega , } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            366,
+            739,
+            629,
+            776
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "where $K$ is the number of objectives, $\\Omega$ is the variables space and $\\mathbf { x } = [ x _ { 1 } , x _ { 2 } , . . . , x _ { n } ] ^ { T } \\in \\Omega$ is a decision vector or possible solution to the problem. $\\mathbf { F } : \\Omega \\stackrel { * } { \\to } \\mathbb { R } ^ { K }$ is a set of $K$ -objective functions that maps the $n$ -dimensional variables space to the $K$ -dimensional objective space. ",
+        "bbox": [
+            174,
+            782,
+            823,
+            827
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Pareto-dominance. Let $\\mathbf { X } _ { 1 }$ and $\\mathbf { X } _ { 2 }$ be two decision vectors. $\\mathbf { X } _ { 1 }$ is said to dominate $\\mathbf { X } _ { 2 }$ (denoted by $\\mathbf { x } _ { 1 } \\prec \\mathbf { x } _ { 2 } )$ if and only if $f _ { i } ( \\mathbf { x } _ { 1 } ) \\leq f _ { i } ( \\mathbf { x } _ { 2 } )$ for all $i \\in \\{ 1 , 2 , \\ldots , K \\}$ and $f _ { j } ( \\mathbf { x } _ { 1 } ) < f _ { j } ( \\mathbf { x } _ { 2 } )$ for some $j \\in \\{ 1 , 2 , \\dots , K \\}$ . If a decision vector $\\mathbf { X }$ is dominated by no other vector in $\\Omega$ , $\\mathbf { X }$ is said to be non-dominated. ",
+        "bbox": [
+            173,
+            832,
+            823,
+            888
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Pareto-optimality. A decision vector $\\mathbf { x } ^ { * } \\in \\Omega$ is said to be Pareto-optimal if and only if there is no $\\mathbf { x } \\in \\Omega$ such that $\\mathbf { X } \\prec \\mathbf { X } ^ { * }$ , i.e. $\\mathbf { x } ^ { * }$ is a non-dominated solution. The Pareto-optimal Set (PS) is defined as the set of all Pareto-optimal solutions $\\mathbf { x } \\in \\Omega$ , i.e., $P S = \\{ \\mathbf { x } \\in \\Omega | \\mathbf { x }$ is Pareto optimal}. The set of all objective vectors $\\mathbf { F } ( \\mathbf { x } )$ such that $\\mathbf { X }$ is Pareto-optimal is called Pareto front (PF), that is $P F = \\{ \\mathbf { F } ( \\mathbf { x } ) \\in \\mathbf { \\bar { \\mathbb { R } } } ^ { K } | \\mathbf { x } \\in P S \\}$ . ",
+        "bbox": [
+            171,
+            895,
+            823,
+            924
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            103,
+            825,
+            147
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Pareto-stationarity. Pareto-stationarity is a necessary condition for Pareto-optimality. For $f _ { k }$ differentiable everywhere for all $k$ , $\\mathbf { F }$ is said to be Pareto-stationary at the point $\\mathbf { X }$ if there exists a set of scalars $\\alpha _ { k } , k \\in \\{ 1 , \\ldots , K \\}$ , such that: ",
+        "bbox": [
+            173,
+            152,
+            825,
+            195
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/bc1687a8d347e1d86ba1a9d01fe075c637ab59bf599f2cdce395325aa738102d.jpg",
+        "text": "$$\n\\sum _ { k = 1 } ^ { K } \\alpha _ { k } \\nabla f _ { k } = \\mathbf { 0 } , \\quad \\sum _ { k = 1 } ^ { K } \\alpha _ { k } = 1 , \\quad \\alpha _ { k } \\geq 0 \\quad \\forall k .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            339,
+            212,
+            660,
+            256
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Multiple Gradient Descent. Multiple gradient descent (Désidéri, 2012; Schäffler et al., 2002; Peitz & Dellnitz, 2018) was proposed for the unconstrained case of multi-objective optimization of $\\mathbf { F } ( \\mathbf { x } )$ assuming a convex, continuously differentiable and smooth $f _ { k } ( { \\bf x } )$ for all $k$ . MGD finds a common descent direction for all $f _ { k }$ by defining the convex hull of all $\\nabla f _ { k } ( { \\mathbf { x } } )$ and finding the minimum norm element within it. Consider $\\mathbf { w } ^ { * }$ given by: ",
+        "bbox": [
+            173,
+            263,
+            825,
+            334
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/2ebc5cf25bf32b7f721e80ca8a05555d996481992e5a28fb397b695c923a3d23.jpg",
+        "text": "$$\n\\mathbf { w } ^ { * } = \\mathrm { a r g m i n } | | \\mathbf { w } | | , \\quad \\mathbf { w } = \\sum _ { k = 1 } ^ { K } \\alpha _ { k } \\nabla f _ { k } ( \\mathbf { x } ) , \\quad \\mathrm { s . t . } \\quad \\sum _ { k = 1 } ^ { K } \\alpha _ { k } = 1 , \\quad \\alpha _ { k } \\geq 0 \\quad \\forall k .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            235,
+            351,
+            761,
+            395
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "$\\mathbf { w } ^ { * }$ will be either 0 in which case $\\mathbf { X }$ is a Pareto-stationary point, or $\\mathbf { w } ^ { * } \\neq \\mathbf { 0 }$ and then $\\mathbf { w } ^ { * }$ is a descent direction for all $f _ { i } ( \\mathbf { x } )$ . Similar to gradient descent, MGD consists in finding the common steepest descent direction $\\mathbf { w } _ { t } ^ { * }$ at each iteration $t$ , and then updating parameters with a learning rate $\\lambda$ according to $\\begin{array} { r } { \\mathbf { x } _ { t + 1 } = \\mathbf { x } _ { t } - \\lambda \\frac { \\mathbf { w } _ { t } ^ { * } } { | | \\mathbf { w } _ { t } ^ { * } | | } } \\end{array}$ . ",
+        "bbox": [
+            173,
+            402,
+            823,
+            468
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3 RELATED WORK ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            483,
+            341,
+            500
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3.1 TRAINING GANS WITH MULTIPLE DISCRIMINATORS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            513,
+            576,
+            529
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "While we would prefer to always have strong gradients from the discriminator during training, the vanilla GAN makes this difficult to ensure, as the discriminator quickly learns to distinguish real and generated samples (Goodfellow, 2016), thus providing no meaningful error signal to improve the generator thereafter. Durugkar et al. (2016) proposed the Generative Multi-Adversarial Networks (GMAN) which consist in training the generator against a softmax weighted arithmetic average of $K$ different discriminators, according to Eq. 4. ",
+        "bbox": [
+            173,
+            540,
+            825,
+            625
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/82fb640b5c6182a009077f5af984690630fc57bc9f96b40a856f4539e8f82083.jpg",
+        "text": "$$\n\\mathcal { L } _ { G } = \\sum _ { k = 1 } ^ { K } \\alpha _ { k } \\mathcal { L } _ { D _ { k } } ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            434,
+            628,
+            562,
+            672
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "where $\\begin{array} { r } { \\alpha _ { k } = \\frac { e ^ { \\beta \\mathcal { L } _ { D _ { k } } } } { \\sum _ { j = 1 } ^ { K } e ^ { \\beta \\mathcal { L } _ { D _ { j } } } } , \\beta \\ge 0 } \\end{array}$ , and $\\mathcal { L } _ { D _ { k } }$ is the loss of discriminator $k$ and defined as ",
+        "bbox": [
+            173,
+            679,
+            740,
+            708
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/478da9c76d71f1bdf14c85c5369a5d452d156f4b6be30609998f1813e8cf18b3.jpg",
+        "text": "$$\n\\mathcal { L } _ { D _ { k } } = - \\mathbb { E } _ { { \\mathbf { x } } \\sim p _ { \\mathrm { d a t a } } } \\log D _ { k } ( { \\mathbf { x } } ) - \\mathbb { E } _ { { \\mathbf { z } } \\sim p _ { z } } \\log ( 1 - D _ { k } ( G ( { \\mathbf { z } } ) ) ) ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            307,
+            713,
+            689,
+            731
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "where $D _ { k } ( { \\mathbf x } )$ and $G ( \\mathbf { z } )$ are the outputs of the $k$ -th discriminator and the generator, respectively. The goal of using the proposed averaging scheme is to privilege worse discriminators and thus providing more useful gradients to the generator during training. Experiments were performed with $\\beta = 0$ (equal weights), $\\beta \\to \\infty$ (only worst discriminator is taken into account), $\\beta = 1$ , and $\\beta$ learned by the generator. Models with $K = \\{ 2 , 5 \\}$ were tested and evaluated using a proposed metric and the Inception score (Salimans et al., 2016). However, results showed that the simple average of discriminator’s losses provided the best values for both metrics in most of the considered cases. ",
+        "bbox": [
+            173,
+            734,
+            825,
+            833
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Opposed to GMAN, Neyshabur et al. (2017) proposed training a GAN with $K$ discriminators using the same architecture. Each discriminator $D _ { k }$ sees a different randomly projected lower-dimensional version of the input image. Random projections are defined by a randomly initialized matrix $W _ { k }$ , which remains fixed during training. Theoretical results provided show that the distribution induced by the generator $G$ will converge to the real data distribution $p _ { \\mathrm { d a t a } }$ , as long as there is a sufficient number of discriminators. Moreover, discriminative tasks in the projected space are harder, i.e. real and fake samples are more alike, thus avoiding early convergence of discriminators, which leads to common stability issues in GAN training such as mode-collapse (Goodfellow, 2016). Essentially, the authors trade one hard problem for $K$ easier subproblems. The losses of each discriminator $\\mathcal { L } _ { D _ { k } }$ are the same as shown in Eq. 5. However, the generator loss $\\mathcal { L } _ { G }$ is defined as simply the sum of the losses provided by each discriminator, as shown in Eq. 6. This choice of $\\mathcal { L } _ { G }$ does not exploit available information such as the performance of the generator with respect to each discriminator. ",
+        "bbox": [
+            173,
+            839,
+            825,
+            924
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            103,
+            825,
+            188
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/1382d8e893a5b0ef51b4818ea97eb480b8ff6ebc34a9cd18dd5ce10b825bddcb.jpg",
+        "text": "$$\n\\mathcal { L } _ { G } = - \\sum _ { k = 1 } ^ { K } \\mathbb { E } _ { \\mathbf { z } \\sim p _ { z } } \\log D _ { k } ( G ( \\mathbf { z } ) ) .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            383,
+            204,
+            612,
+            247
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3.2 HYPERVOLUME MAXIMIZATION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            261,
+            434,
+            276
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Consider a set of solutions $S$ for a multi-objective optimization problem. The hypervolume $\\mathcal { H }$ of $S$ is defined as (Fleischer, 2003): $\\mathcal { H } ( S ) = \\mu \\big ( \\cup _ { \\mathbf { x } \\in S } [ \\mathbf { F } ( \\mathbf { x } ) , \\pmb { \\eta } ^ { * } ] \\big )$ , where $\\mu$ is the Lebesgue measure and $\\eta ^ { * }$ is a point dominated by all $\\mathbf { x } \\in S$ (i.e. $f _ { i } ( \\mathbf { x } )$ is upper-bounded by $\\eta$ ), referred to as nadir point. $\\mathcal { H } ( S )$ can be understood as the size of the space covered by $\\{ \\mathbf { F } ( \\mathbf { x } ) | \\mathbf { x } \\in S \\}$ (Bader & Zitzler, 2011). ",
+        "bbox": [
+            174,
+            287,
+            825,
+            344
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "The hypervolume was originally introduced as a quantitative metric for coverage and convergence of Pareto-optimal fronts obtained through population based algorithms (Beume et al., 2007). Methods based on direct maximization of $\\mathcal { H }$ exhibit favorable convergence even in challenging scenarios, such as simultaneous minimization of 50 objectives (Bader & Zitzler, 2011). In the context of Machine Learning, a single-solution hypervolume maximization has been applied to neural networks as a surrogate loss for mean squared error (Miranda & Zuben, 2016), i.e. the loss provided by each example in a training batch is treated as a single cost and the multi-objective approach aims to minimize costs over all examples. Authors show that such method provides an inexpensive boosting-like training. ",
+        "bbox": [
+            173,
+            349,
+            825,
+            477
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "4 MULTI-OBJECTIVE TRAINING OF GANS WITH MULTIPLE DISCRIMINATORS ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            496,
+            821,
+            512
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "We introduce a variation of the GAN game such that the generator solves the following multi-objective problem: ",
+        "bbox": [
+            171,
+            526,
+            823,
+            556
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/24c4fa1f8a995e54f2b7f012c314441702c1819998b56ebf9c1ba9046bd3e89d.jpg",
+        "text": "$$\n\\operatorname* { m i n } \\pmb { \\mathcal { L } } _ { G } ( \\mathbf { x } ) = [ l _ { 1 } ( \\mathbf { z } ) , l _ { 2 } ( \\mathbf { z } ) , . . . , l _ { K } ( \\mathbf { z } ) ] ^ { T } ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            369,
+            573,
+            629,
+            593
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "where each $l _ { k } = - \\mathbb { E } _ { z \\sim p _ { z } } \\log D _ { k } ( G ( z ) ) , k \\in \\{ 1 , . . . , K \\}$ , is the loss provided by the $k$ -th discriminator. Training proceeds as the usual formulation (Goodfellow et al., 2014), i.e. with alternate updates between the discriminators and the generator. Updates of each discriminator are performed to minimize the loss described in Eq. 5. ",
+        "bbox": [
+            173,
+            599,
+            825,
+            657
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "A natural choice for generator’s updates is the MGD algorithm, described in Section 2. However, computing the direction of steepest descent $\\mathbf { w } ^ { * }$ before every parameter update step, as required in MGD, can be prohibitively expensive for large neural networks. Therefore, we propose an alternative scheme for multi-objective optimization and argue that both our proposal and previously published methods can all be viewed as performing computationally more efficient versions of MGD update rule without the burden of having to solve a quadratric program, i.e. computing $\\mathbf { w } ^ { * }$ , every iteration. ",
+        "bbox": [
+            173,
+            664,
+            825,
+            750
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "4.1 HYPERVOLUME MAXIMIZATION FOR TRAINING GANS ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            765,
+            589,
+            779
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Fleischer (Fleischer, 2003) has shown that maximizing $\\mathcal { H }$ yields Pareto-optimal solutions. Since MGD converges to a set of Pareto-stationary points, i.e. a super-set of the Pareto-optimal solutions, hypervolume maximization yields a sub-set of the solutions obtained using MGD. ",
+        "bbox": [
+            174,
+            790,
+            825,
+            833
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "We exploit the above mentioned property and define the generator loss as the negative loghypervolume, as defined in Eq. 8: ",
+        "bbox": [
+            171,
+            839,
+            825,
+            869
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/48fee7c9197ef60469d5a7efbe94e83a087c5fc35ae1bdc5b37f89c738188e67.jpg",
+        "text": "$$\n\\mathcal { L } _ { G } = - \\mathcal { V } = - \\sum _ { k = 1 } ^ { K } \\log ( \\eta - l _ { k } ) ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            392,
+            885,
+            606,
+            928
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "where the nadir point coordinate $\\eta$ is an upper bound for all $l _ { k }$ . In Fig. 1 we provide an illustrative example for the case where $K = 2$ . The highlighted region corresponds to $e ^ { \\nu }$ . Since the nadir point $\\eta ^ { * }$ is fixed, $\\nu$ will only be maximized, and consequently $\\mathcal { L } _ { G }$ minimized, if each $l _ { k }$ is minimized. ",
+        "bbox": [
+            173,
+            103,
+            823,
+            146
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Moreover, by adapting the results shown in (Miranda & Zuben, 2016), the gradient of $\\mathcal { L } _ { G }$ with respect to any generator’s parameter $\\theta$ is given by: ",
+        "bbox": [
+            490,
+            145,
+            823,
+            185
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/67e095e7fb0bea938c5477da9b101f059f028b4917ddbe9492fc49bf7fb11fe7.jpg",
+        "text": "$$\n\\frac { \\partial \\mathcal { L } _ { G } } { \\partial \\theta } = \\sum _ { k = 1 } ^ { K } \\frac { 1 } { \\eta - l _ { k } } \\frac { \\partial l _ { k } } { \\partial \\theta } .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            575,
+            190,
+            740,
+            234
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "image",
+        "img_path": "images/aacb77deaee8d22bc2023f6efdea942a44d009defa81535cced83fdc8b765d4b.jpg",
+        "image_caption": [
+            "Figure 1: 2D example of the objective space where the generator loss is being optimized. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            230,
+            175,
+            416,
+            301
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "In other words, the gradient can be obtained by computing a weighted sum of the gradients of the losses provided by each discriminator, whose weights are defined as the inverse distance to the nadir point components. This formulation will naturally assign more importance to higher losses in the final gradient, which is another useful property of hypervolume maximization. ",
+        "bbox": [
+            490,
+            236,
+            825,
+            347
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Nadir point selection. It is evident from Eq. 9 that the selection of $\\eta$ directly affects the importance assignment of gradients provided by different discriminators. Particularly, as the quantity $\\mathrm { m i n } _ { k } \\{ \\eta - l _ { k } \\}$ grows, the multi-objective GAN game approaches the one defined by the simple average of $l _ { k }$ . Previous literature has discussed in depth the effects of the selection of $\\eta$ in the case of population-based methods (Auger et al., 2009; 2012). However, those results are not readily applicable for the single-solution case. As will be shown in Section 5, our experiments indicate that the choice of $\\eta$ plays an important role in the final quality of samples. Nevertheless, this effect becomes less relevant as the number of discriminators increases. ",
+        "bbox": [
+            173,
+            349,
+            825,
+            462
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Nadir point adaptation. Similarly to (Miranda & Zuben, 2016), we propose an adaptive scheme for $\\eta$ such that at iteration $t$ : $\\eta _ { t } = \\delta \\operatorname* { m a x } _ { k } \\{ l _ { k , t } \\}$ , where $\\delta > 1$ is a user-defined parameter which will be referred to as slack. This enforces $\\mathrm { m i n } _ { k } \\{ \\eta - l _ { k } \\}$ to be higher when $\\operatorname* { m i x } _ { k } \\{ l _ { k , t } \\}$ is high and low otherwise, which induces a similar behavior as an average loss when training begins and automatically places more importance on the discriminators in which performance is worse as training progresses. Extra discussion and an illustrative example of the adaptation scheme adopted is presented in Appendix G. ",
+        "bbox": [
+            173,
+            468,
+            825,
+            565
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Comparison to average loss minimization. The upper bound proven by Neyshabur et al. (2017) assumes that the marginals of the real and generated distributions are identical along all random projections. Average loss minimization does not ensure equally good approximation between the marginals along all directions. In case of a trade-off between discriminators, i.e. if decreasing the loss on a given projection increases the loss with respect to another one, the distribution of losses can be uneven. With HV on the other hand, especially when $\\eta$ is reduced throughout training, overall loss will be kept high as long as there are discriminators with high loss. This objective tends to prefer central regions of a trade-off, in which all discriminators present a roughly equally low loss. ",
+        "bbox": [
+            173,
+            573,
+            825,
+            685
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "4.2 RELATIONSHIP BETWEEN MULTIPLE DISCRIMINATOR GANS AND MGD ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            705,
+            709,
+            719
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "All methods described previously for the solution of GANs with multiple discriminators, i.e. average loss minimization (Neyshabur et al., 2017), GMAN’s weighted average (Durugkar et al., 2016) and hypervolume maximization can be defined as MGD-like two-step algorithms consisting of: Step 1 - consolidating all gradients into a single update direction (compute the set $\\alpha _ { 1 , \\ldots , K } )$ ; Step 2 - updating parameters in the direction returned in step 1. Definition of Step $^ { l }$ for the different methods studied here can be seen in the following: ",
+        "bbox": [
+            174,
+            733,
+            826,
+            818
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/93c61eae5d4d802beed7ba939646bd91d6bac3de759db70c12ab7536fd441eff.jpg",
+        "text": "$$\n\\begin{array} { r } { \\alpha _ { 1 : K } = \\operatorname * { a r g m i n } _ { \\alpha } | | \\mathbf { w } | | , \\quad \\mathrm { s . t . } \\quad \\sum _ { k = 1 } ^ { K } \\alpha _ { k } = 1 , \\quad \\alpha _ { k } \\geq 0 \\forall k \\in \\{ 1 , . . . , K \\} } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            279,
+            832,
+            763,
+            853
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "2. Average loss minimization (Neyshabur et al., 2017): $\\textstyle \\alpha _ { k } = { \\frac { 1 } { K } }$ ",
+        "bbox": [
+            212,
+            859,
+            635,
+            876
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "3. GMAN (Durugkar et al., 2016): $\\alpha _ { k } = \\mathrm { s o f t m a x } ( l _ { 1 : K } ) _ { k }$ ",
+        "bbox": [
+            210,
+            882,
+            591,
+            898
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "5 EXPERIMENTS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            102,
+            326,
+            117
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "We performed three sets of experiments aiming to analyze the following aspects: (i) How alternative methods for training GANs with multiple discriminators perform in comparison to MGD; (ii) How alternative methods perform in comparison to each other in terms of sample quality and coverage; and (iii) Whether the behavior induced by HV improves the results with respect to the baseline methods. ",
+        "bbox": [
+            174,
+            136,
+            825,
+            191
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Firstly, we exploited the relatively low dimensionality of MNIST and used it as testbed for a comparison of MGD with the other approaches, i.e. average loss minimization (AVG), GMAN’s weighted average loss, and HV, proposed in this work. Moreover, multiple initializations and slack combinations were evaluated in order to investigate how varying the number of discriminators affects robustness to those factors. ",
+        "bbox": [
+            174,
+            199,
+            825,
+            268
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Then, experiments were performed with CIFAR-10 while increasing the number of discriminators. We evaluated HV’s performance compared to baseline methods, and the effect in samples quality. We also analyzed the impact on the diversity of generated samples by using the stacked MNIST dataset (Srivastava et al., 2017). Samples of generators trained on stacked MNIST, CIFAR-10, CelebA, and Cats dataset are shown in the Appendix. ",
+        "bbox": [
+            174,
+            275,
+            825,
+            345
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "In all experiments performed, the same architecture, set of hyperparameters and initialization were used for both AVG, GMAN and our proposed method. The only different aspect is the generator loss. Unless stated otherwise, Adam (Kingma & Ba, 2014) was used to train all the models with learning rate, $\\beta _ { 1 }$ and $\\beta _ { 2 }$ set to 0.0002, 0.5 and 0.999, respectively. Mini-batch size was set to 64. The Fréchet Inception Distance (FID) (Heusel et al., 2017) was employed for comparison. Details on FID computation can be found in Appendix A. ",
+        "bbox": [
+            174,
+            352,
+            825,
+            436
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "5.1 MGD COMPARED WITH ALTERNATIVE METHODS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            458,
+            552,
+            472
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "We employed MGD in our experiments with MNIST. In order to do so, a quadratic program has to be solved prior to every parameters update. For this, we used the Scipy’s implementation of the Serial Least Square Quadratic Program solver2. ",
+        "bbox": [
+            174,
+            484,
+            825,
+            526
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Three and four fully connected layers with LeakyReLU activations were used for the generator and discriminator, respectively. Dropout was also employed in the discriminator and the random projection layer was implemented as a randomly initialized norm-1 fully connected layer, reducing the vectorized dimensionality of MNIST from 784 to 512. A pretrained LeNet (LeCun et al., 1998) was used for FID computation. ",
+        "bbox": [
+            174,
+            534,
+            825,
+            603
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Experiments over 100 epochs with 8 discriminators are reported in Fig. 2 and Fig. 3. In Fig. 2, box-plots refer to 30 independent computations of FID over 10000 images sampled from the generator which achieved the minimum FID at train time. FID results are measured at train time over 1000 images and the best values are reported in Fig. 3 along with the necessary time to achieve it. ",
+        "bbox": [
+            174,
+            611,
+            825,
+            666
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "MGD outperforms all tested methods. However, its cost per iteration does not allow its use in more relevant datasets other than MNIST. Hypervolume maximization, on the other hand, performs closest to MGD than the considered baselines, while introducing no relevant extra cost. In Fig. 4, we analyze convergence in the Pareto-stationarity sense by plotting the norm of the update direction for each method, given by $\\begin{array} { r l } {  { \\vert \\vert \\sum _ { k = 1 } ^ { K } \\alpha _ { k } \\nabla l _ { k } \\vert \\vert } } \\end{array}$ . All methods converged to similar norms, leading to the conclusion that different Pareto-stationary solutions will perform differently in terms of quality of samples. FID as a function of wall-clock time is shown in Figure 22 (Appendix H). ",
+        "bbox": [
+            174,
+            674,
+            825,
+            773
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "HV sensitivity to initialization and choice of $\\delta$ . Analysis of the sensitivity of the performance with the choice of the slack parameter $\\delta$ and initialization was performed under the following setting: models were trained for 50 epochs on MNIST with hypervolume maximization using 8, 16, 24 discriminators. Three independent runs (different initializations) were executed with each $\\delta = \\{ 1 . 0 5 , 1 . 5 , 1 . 7 5 , 2 \\}$ and number of discriminators, totalizing 36 final models. Fig. 5 reports the box-plots obtained for 5 FID independent computations using 10000 images, for each of the 36 models obtained under the setting previously described. Results clearly indicate that increasing the number of discriminators yields much smaller variation in the FID obtained by the final model. ",
+        "bbox": [
+            173,
+            780,
+            825,
+            892
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "image",
+        "img_path": "images/91f8bfb4e8adb871263d6e323025a4c783dad769d20010cd15b7d628218b7d5b.jpg",
+        "image_caption": [
+            "Figure 2: Box-plots corresponding to 30 independent FID computations with 10000 images. MGD performs consistently better than other methods, followed by hypervolume maximization. Models that achieved minimum FID at train time were used. Red and blue dashed lines are the FIDs of a random generator and real data, respectively. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            189,
+            119,
+            470,
+            263
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/88eb180271cc6c81af41d05933f331327667091f9b43dab3e2235153c7172b67.jpg",
+        "image_caption": [
+            "Figure 3: Time vs. best FID achieved during training for each approach. FID values are computed over 1000 generated images after every epoch. MGD performs relevantly better than others in terms of FID, followed by HV. However, MGD is approximately 7 times slower than HV. HV is well-placed in the time-quality trade-off. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            531,
+            119,
+            781,
+            267
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/101d78dc77ea694a1ddfb6ed6af4102d10994c7edf3ac2f09f1acdc7fbf5b37b.jpg",
+        "image_caption": [
+            "Figure 4: Norm of the update direction over time for each method. While Pareto-stationarity is approximately achieved by all methods, performance varies relevantly in terms of FID. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            178,
+            409,
+            470,
+            577
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/40180395ead77517c512f3350f5aeebfb3e94aef7d6ca2b0d9508b79a2a80200.jpg",
+        "image_caption": [
+            "Figure 5: Independent FID evaluations for models obtained with different runs using distinct slack parameter $\\delta$ . Sensitivity reduces as the number of discriminators increases. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            513,
+            409,
+            799,
+            575
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "5.2 HV AS AN ALTERNATIVE FOR MGD ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            684,
+            462,
+            698
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "We evaluate the performance of HV compared to baseline methods using the CIFAR-10 dataset. FID was computed with a pretrained ResNet (He et al., 2016). ResNet was trained on the 10-class classification task of CIFAR-10 up to approximately $9 5 \\%$ test accuracy. DCGAN (Radford et al., 2015) and WGAN-GP (Gulrajani et al., 2017) were included in the experiments for FID reference. Same architectures as in (Neyshabur et al., 2017) were employed for all multi-discriminators settings. An increasing number of discriminators was used. Inception score as well as FID computed with other models are included in Appendix C. ",
+        "bbox": [
+            173,
+            719,
+            826,
+            816
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "In Fig. 6, we report the box-plots of 15 independent evaluations of FID on 10000 images for the best model obtained with each method across 3 independent runs. Results once more indicate that HV outperforms other methods in terms of quality of the generated samples. Moreover, performance clearly improves as the number of discriminators grows. Fig. 7 shows the FID at train time, i.e. measured with 1000 generated samples after each epoch, for the best models across runs. Models trained against more discriminators clearly converge to smaller values. We report the norm of the update direction $\\begin{array} { r l } {  { \\vert \\vert \\sum _ { k = 1 } ^ { K } \\alpha _ { k } \\nabla l _ { k } \\vert \\vert } } & { { } } \\end{array}$ for each method in Fig. 9, Appendix C. ",
+        "bbox": [
+            173,
+            823,
+            825,
+            925
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/5a7b649caf777c4a9ba5334434f3b4c2a18eb458dc2887ec713ef29ee352b7cc.jpg",
+        "image_caption": [
+            "Figure 6: Box-plots of 15 independent FID com- Figure 7: FID estimated over 1000 generated imputations with 10000 images. Dashed lines are ages at train time. Models trained against more real data (blue) and random generator (red) FIDs. discriminators achieve lower FID. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            199,
+            121,
+            820,
+            281
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Cost under the multiple discriminator setting. We highlight that even though training with multiple discriminators may be more computationally expensive when compared to conventional approaches, such framework supports fully parallel training of the discriminators, a feature which is not trivially possible in other GAN settings. For example in WGAN, the discriminator is serially updated multiple times for each generator update. In Fig. 10 at Appendix C, we provide a comparison between the wall-clock time per iteration between all methods evaluated. Serial implementations of discriminators updates with 8 and 16 discriminators were faster than WGAN-GP. ",
+        "bbox": [
+            174,
+            342,
+            825,
+            439
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "5.3 EFFECT OF THE NUMBER OF DISCRIMINATORS ON SAMPLE DIVERSITY ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            457,
+            696,
+            469
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "We repeat the experiments in (Srivastava et al., 2017) aiming to analyze how the number of discriminators impacts the sample diversity of the corresponding generator when trained using hypervolume maximization. The stacked MNIST dataset is employed and results reported in (Lin et al., 2017) are used for comparison. HV results for 8, 16, and 24 discriminators were obtained with 10k and 26k generator images averaged over 10 runs. The number of covered modes along with the KL divergence between the generated mode distribution and test data are reported in Table 1. ",
+        "bbox": [
+            173,
+            481,
+            826,
+            565
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "table",
+        "img_path": "images/95f1dd8ca8486910360668686567d62067d1f6a651d9c4442f0ce918d393a58e.jpg",
+        "table_caption": [
+            "Table 1: Number of covered modes and reverse KL divergence for stacked MNIST. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Test samples</td><td>Model</td><td>Modes (Max 1000)</td><td>KL</td></tr><tr><td rowspan=\"5\">26k</td><td>DCGAN (Radford etal.,2015)</td><td>99.0</td><td>3.400</td></tr><tr><td>ALI (Dumoulin et al., 2016)</td><td>16.0</td><td>5.400</td></tr><tr><td>Unrolled GAN (Metz et al., 2016)</td><td>48.7</td><td>4.320</td></tr><tr><td>VEEGAN (Srivastava et al., 2017)</td><td>150.0</td><td>2.950</td></tr><tr><td>PacDCGAN2 (Lin et al.,2017)</td><td>1000.0± 0.0</td><td>0.060 ±0.003</td></tr><tr><td rowspan=\"3\">10k</td><td>HV-8 disc.</td><td>679.2± 5.9</td><td>1.139 ± 0.011</td></tr><tr><td>HV - 16 disc.</td><td>998.0±1.8</td><td>0.120 ± 0.004</td></tr><tr><td>HV - 24 disc.</td><td>998.3 ± 1.1</td><td>0.116 ± 0.003</td></tr><tr><td rowspan=\"3\">26k</td><td>HV -8 disc.</td><td>776.8 ±6.4</td><td>1.115 ± 0.007</td></tr><tr><td>HV - 16 disc.</td><td>1000.0± 0.0</td><td>0.088 ±0.002</td></tr><tr><td>HV - 24 disc.</td><td>1000.0 ± 0.0</td><td>0.084 ±0.002</td></tr></table>",
+        "bbox": [
+            178,
+            570,
+            488,
+            685
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "As in previous experiments, results improved as we increased the number of discriminators. All evaluated models using HV outperformed DCGAN, ALI, Unrolled GAN and VEEGAN. Moreover, HV with 16 and 24 discriminators achieved state-of-the-art coverage values. Thus, the increase in models’ capacity via using more discriminators directly resulted in an improvement in generator’s coverage. Training details as well as architectures information are presented in Appendix B. ",
+        "bbox": [
+            511,
+            568,
+            825,
+            720
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "6 CONCLUSION ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            743,
+            318,
+            760
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "In this work we have shown that employing multiple discriminators is a practical approach allowing us to trade extra capacity, and thereby extra computational cost, for higher quality and diversity of generated samples. Such an approach is complimentary to other advances in GANs training and can be easily used together with other methods. We introduced a multi-objective optimization framework for studying multiple discriminator GANs, and showed strong similarities between previous work and the multiple gradient descent algorithm. The proposed approach was observed to consistently yield higher quality samples in terms of FID. Furthermore, increasing the number of discriminators was shown to increase sample diversity and generator robustness. ",
+        "bbox": [
+            173,
+            773,
+            825,
+            886
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Deeper analysis of the quantity that using it as a penalty term $\\begin{array} { r l } {  { \\vert \\vert \\sum _ { k = 1 } ^ { K } \\alpha _ { k } \\nabla l _ { k } \\vert \\vert } } & { { } } \\end{array}$ is the subject of future investigation. We hypothesize necessity of a high number of discriminators. ",
+        "bbox": [
+            173,
+            892,
+            821,
+            924
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "REFERENCES ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            102,
+            287,
+            118
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Martin Arjovsky, Soumith Chintala, and Léon Bottou. Wasserstein GAN. arXiv preprint arXiv:1701.07875, 2017. ",
+        "bbox": [
+            173,
+            126,
+            823,
+            155
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Anne Auger, Johannes Bader, Dimo Brockhoff, and Eckart Zitzler. Theory of the hypervolume indicator: optimal $\\mu$ -distributions and the choice of the reference point. In Proceedings of the tenth ACM SIGEVO workshop on Foundations of genetic algorithms, pp. 87–102. ACM, 2009. ",
+        "bbox": [
+            174,
+            162,
+            823,
+            207
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Anne Auger, Johannes Bader, Dimo Brockhoff, and Eckart Zitzler. Hypervolume-based multiobjective optimization: Theoretical foundations and practical implications. Theoretical Computer Science, 425:75–103, 2012. ",
+        "bbox": [
+            173,
+            214,
+            825,
+            257
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Johannes Bader and Eckart Zitzler. HypE: An algorithm for fast hypervolume-based many-objective optimization. Evolutionary computation, 19(1):45–76, 2011. ",
+        "bbox": [
+            169,
+            265,
+            825,
+            295
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "David Berthelot, Tom Schumm, and Luke Metz. BEGAN: boundary equilibrium generative adversarial networks. CoRR, abs/1703.10717, 2017. URL http://arxiv.org/abs/1703.10717. ",
+        "bbox": [
+            173,
+            303,
+            825,
+            332
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Nicola Beume, Boris Naujoks, and Michael Emmerich. SMS-EMOA: Multiobjective selection based on dominated hypervolume. European Journal of Operational Research, 181(3):1653–1669, 2007. ",
+        "bbox": [
+            173,
+            339,
+            825,
+            369
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Kalyanmoy Deb. Multi-objective optimization using evolutionary algorithms, volume 16. John Wiley & Sons, 2001. ",
+        "bbox": [
+            171,
+            377,
+            823,
+            406
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Jean-Antoine Désidéri. Multiple-gradient descent algorithm (MGDA) for multiobjective optimization. Comptes Rendus Mathematique, 350(5-6):313–318, 2012. ",
+        "bbox": [
+            171,
+            414,
+            825,
+            444
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Vincent Dumoulin, Ishmael Belghazi, Ben Poole, Olivier Mastropietro, Alex Lamb, Martin Arjovsky, and Aaron Courville. Adversarially learned inference. arXiv preprint arXiv:1606.00704, 2016. ",
+        "bbox": [
+            171,
+            452,
+            825,
+            482
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Ishan Durugkar, Ian Gemp, and Sridhar Mahadevan. Generative multi-adversarial networks. arXiv preprint arXiv:1611.01673, 2016. ",
+        "bbox": [
+            171,
+            489,
+            823,
+            518
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Mark Fleischer. The measure of pareto optima applications to multi-objective metaheuristics. In International Conference on Evolutionary Multi-Criterion Optimization, pp. 519–533. Springer, 2003. ",
+        "bbox": [
+            174,
+            526,
+            823,
+            569
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Maurice Fréchet. Sur la distance de deux lois de probabilité. COMPTES RENDUS HEBDOMADAIRES DES SEANCES DE L ACADEMIE DES SCIENCES, 244(6):689–692, 1957. ",
+        "bbox": [
+            171,
+            578,
+            823,
+            608
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Ian Goodfellow. NIPS 2016 tutorial: Generative adversarial networks. arXiv preprint arXiv:1701.00160, 2016. ",
+        "bbox": [
+            169,
+            614,
+            825,
+            645
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Ian Goodfellow, Jean Pouget-Abadie, Mehdi Mirza, Bing Xu, David Warde-Farley, Sherjil Ozair, Aaron Courville, and Yoshua Bengio. Generative adversarial nets. In Advances in neural information processing systems, pp. 2672–2680, 2014. ",
+        "bbox": [
+            174,
+            652,
+            825,
+            696
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Ishaan Gulrajani, Faruk Ahmed, Martin Arjovsky, Vincent Dumoulin, and Aaron C Courville. Improved training of Wasserstein GANs. In Advances in Neural Information Processing Systems, pp. 5769–5779, 2017. ",
+        "bbox": [
+            173,
+            704,
+            826,
+            747
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Kaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. Deep residual learning for image recognition. In Proceedings of the IEEE conference on computer vision and pattern recognition, pp. 770–778, 2016. ",
+        "bbox": [
+            173,
+            755,
+            825,
+            797
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Martin Heusel, Hubert Ramsauer, Thomas Unterthiner, Bernhard Nessler, and Sepp Hochreiter. GANs trained by a two time-scale update rule converge to a local nash equilibrium. In Advances in Neural Information Processing Systems, pp. 6629–6640, 2017. ",
+        "bbox": [
+            173,
+            806,
+            823,
+            849
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Alexia Jolicoeur-Martineau. The relativistic discriminator: a key element missing from standard gan. arXiv preprint arXiv:1807.00734, 2018. ",
+        "bbox": [
+            173,
+            858,
+            823,
+            887
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Diederik P Kingma and Jimmy Ba. Adam: A method for stochastic optimization. arXiv preprint arXiv:1412.6980, 2014. ",
+        "bbox": [
+            173,
+            895,
+            821,
+            924
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Yann LeCun, Léon Bottou, Yoshua Bengio, and Patrick Haffner. Gradient-based learning applied to document recognition. Proceedings of the IEEE, 86(11):2278–2324, 1998. ",
+        "bbox": [
+            171,
+            103,
+            823,
+            132
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Zinan Lin, Ashish Khetan, Giulia Fanti, and Sewoong Oh. PacGAN: The power of two samples in generative adversarial networks. arXiv preprint arXiv:1712.04086, 2017. ",
+        "bbox": [
+            173,
+            140,
+            823,
+            170
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Xudong Mao, Qing Li, Haoran Xie, Raymond YK Lau, Zhen Wang, and Stephen Paul Smolley. Least squares generative adversarial networks. In Computer Vision (ICCV), 2017 IEEE International Conference on, pp. 2813–2821. IEEE, 2017. ",
+        "bbox": [
+            178,
+            178,
+            823,
+            222
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Luke Metz, Ben Poole, David Pfau, and Jascha Sohl-Dickstein. Unrolled generative adversarial networks. arXiv preprint arXiv:1611.02163, 2016. ",
+        "bbox": [
+            171,
+            229,
+            825,
+            260
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Conrado Silva Miranda and Fernando José Von Zuben. Single-solution hypervolume maximization and its use for improving generalization of neural networks. CoRR, abs/1602.01164, 2016. URL http://arxiv.org/abs/1602.01164. ",
+        "bbox": [
+            176,
+            267,
+            823,
+            310
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Takeru Miyato, Toshiki Kataoka, Masanori Koyama, and Yuichi Yoshida. Spectral normalization for generative adversarial networks. arXiv preprint arXiv:1802.05957, 2018. ",
+        "bbox": [
+            174,
+            319,
+            825,
+            349
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Behnam Neyshabur, Srinadh Bhojanapalli, and Ayan Chakrabarti. Stabilizing GAN training with multiple random projections. arXiv preprint arXiv:1705.07831, 2017. ",
+        "bbox": [
+            174,
+            357,
+            823,
+            387
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Sebastian Peitz and Michael Dellnitz. Gradient-based multiobjective optimization with uncertainties. In NEO 2016, pp. 159–182. Springer, 2018. ",
+        "bbox": [
+            176,
+            395,
+            823,
+            425
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Alec Radford, Luke Metz, and Soumith Chintala. Unsupervised representation learning with deep convolutional generative adversarial networks. arXiv preprint arXiv:1511.06434, 2015. ",
+        "bbox": [
+            173,
+            433,
+            823,
+            462
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Tim Salimans, Ian Goodfellow, Wojciech Zaremba, Vicki Cheung, Alec Radford, and Xi Chen. Improved techniques for training GANs. In Advances in Neural Information Processing Systems, pp. 2234–2242, 2016. ",
+        "bbox": [
+            173,
+            469,
+            825,
+            513
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Stefan Schäffler, Reinhart Schultz, and Klaus Weinzierl. Stochastic method for the solution of unconstrained vector optimization problems. Journal of Optimization Theory and Applications, 114(1):209–222, 2002. ",
+        "bbox": [
+            171,
+            522,
+            825,
+            564
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Akash Srivastava, Lazar Valkoz, Chris Russell, Michael U Gutmann, and Charles Sutton. VEEGAN: Reducing mode collapse in GANs using implicit variational learning. In Advances in Neural Information Processing Systems, pp. 3310–3320, 2017. ",
+        "bbox": [
+            173,
+            573,
+            823,
+            617
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Christian Szegedy, Vincent Vanhoucke, Sergey Ioffe, Jon Shlens, and Zbigniew Wojna. Rethinking the inception architecture for computer vision. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pp. 2818–2826, 2016. ",
+        "bbox": [
+            173,
+            626,
+            823,
+            667
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Abhay Yadav, Sohil Shah, Zheng Xu, David Jacobs, and Tom Goldstein. Stabilizing adversarial nets with prediction methods. arXiv preprint arXiv:1705.07364, 2017. ",
+        "bbox": [
+            171,
+            676,
+            823,
+            705
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "APPENDIX ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            101,
+            300,
+            121
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "A - OBJECTIVE EVALUATION METRIC. ",
+        "bbox": [
+            176,
+            147,
+            486,
+            162
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "In (Heusel et al., 2017), authors proposed to use as a quality metric the squared Fréchet distance (Fréchet, 1957) between Gaussians defined by estimates of the first and second order moments of the outputs obtained through a forward pass in a pretrained classifier of both real and generated data. They proposed the use of Inception V3 (Szegedy et al., 2016) for computation of the data representation and called the metric Fréchet Inception Distance (FID), which is defined as: ",
+        "bbox": [
+            174,
+            185,
+            825,
+            257
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "equation",
+        "img_path": "images/1ddf844fe96b1e8916bc473ae392590fd308243e55ba6abc1dd7442a51a25b43.jpg",
+        "text": "$$\n\\mathrm { F I D } = | | m _ { d } - m _ { g } | | ^ { 2 } + \\mathrm { T r } ( \\Sigma _ { d } + \\Sigma _ { g } - 2 ( \\Sigma _ { d } \\Sigma _ { g } ) ^ { \\frac { 1 } { 2 } } ) ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            326,
+            292,
+            669,
+            313
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "where $m _ { d } , \\Sigma _ { d }$ and $m _ { g } , \\Sigma _ { g }$ are estimates of the first and second order moments from the representations of real data distributions and generated data, respectively. ",
+        "bbox": [
+            176,
+            334,
+            821,
+            363
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "We employ FID throughout our experiments for comparison of different approaches. However, for each dataset in which FID was computed, the output layer of a pretrained classifier on that particular dataset was used instead of Inception. $m _ { d }$ and $\\Sigma _ { d }$ were estimated on the complete test partitions, which are not used during training. ",
+        "bbox": [
+            174,
+            369,
+            825,
+            426
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "B - EXPERIMENTAL SETUP FOR STACKED MNIST EXPERIMENTS AND GENERATOR’S SAMPLES ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            459,
+            751,
+            494
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Architectures of the generator and discriminator are detailed in Tables 2 and 3, respectively. Batch normalization was used in all intermediate convolutional and fully connected layers of both models. We employed RMSprop to train all the models with learning rate and $\\alpha$ set to 0.0001 and 0.9, respectively. Mini-batch size was set to 64. The setup in (Lin et al., 2017) is employed and we build 128000 and 26000 samples for train and test sets, respectively. ",
+        "bbox": [
+            173,
+            517,
+            826,
+            588
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "table",
+        "img_path": "images/797f94207ccc708f5493203d5bc232eff9f50fa48c703d08f23c626f788e75dc.jpg",
+        "table_caption": [
+            "Table 2: Generator’s architecture. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Layer</td><td>Outputs</td><td>Kernel size</td><td>Stride</td><td>Activation</td></tr><tr><td>Input: z ~ N(0,I100)</td><td></td><td></td><td></td><td></td></tr><tr><td>Fully connected</td><td>2*2*512</td><td>4,4</td><td>2,2</td><td>ReLU</td></tr><tr><td>Transposed convolution</td><td>4*4*256</td><td>4,4</td><td>2,2</td><td>ReLU</td></tr><tr><td>Transposed convolution</td><td>8*8*128</td><td>4,4</td><td>2,2</td><td>ReLU</td></tr><tr><td>Transposed convolution</td><td>14*14*64</td><td>4,4</td><td>2,2</td><td>ReLU</td></tr><tr><td>Transposed convolution</td><td>28*28*3</td><td>4,4</td><td>2,2</td><td>Tanh</td></tr></table>",
+        "bbox": [
+            245,
+            613,
+            746,
+            715
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "table",
+        "img_path": "images/d25d4ebcbca111ad25b1ef3e8bb085f9c9c4b01d3c7901bd34bca3b4a4e60bb9.jpg",
+        "table_caption": [
+            "Table 3: Discriminator’s architecture. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Layer</td><td>Outputs</td><td>Kernel size</td><td>Stride</td><td>Activation</td></tr><tr><td>Input</td><td>28*28*3</td><td></td><td></td><td></td></tr><tr><td>Projection</td><td>14*14*3</td><td>8,8</td><td>2,2</td><td></td></tr><tr><td>Convolution</td><td>7*7*64</td><td>4,4</td><td>2,2</td><td>LeakyReLU</td></tr><tr><td>Convolution</td><td>5*5*128</td><td>4,4</td><td>2,2</td><td>LeakyReLU</td></tr><tr><td>Convolution</td><td>2*2*256</td><td>4,4</td><td>2,2</td><td>LeakyReLU</td></tr><tr><td>Convolution</td><td>1</td><td>4,4</td><td>2,2</td><td>Sigmoid</td></tr></table>",
+        "bbox": [
+            281,
+            790,
+            712,
+            892
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "image",
+        "img_path": "images/481640c8fe2e5164297573678c2a8abf1e9259ff825790a049f74bc295132419.jpg",
+        "image_caption": [
+            "(a) HV - 8 discriminators "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            303,
+            128,
+            707,
+            306
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "image",
+        "img_path": "images/733d26391c3ddb3857dee445d2ca098b8cc829c46fd477ef6731d12cdd9bee85.jpg",
+        "image_caption": [
+            "(b) HV - 16 discriminators "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            303,
+            378,
+            707,
+            556
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "image",
+        "img_path": "images/e976f9e6327545017aefbea78d5a2ac2705b64f7e354b05c12a2e90406346b51.jpg",
+        "image_caption": [
+            "Figure 8: Stacked MNIST samples for HV trained with 8, 16, and 24 discriminators. Samples diversity increases greatly when more discriminators are employed. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            303,
+            628,
+            705,
+            806
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "(c) HV - 24 discriminators ",
+        "text_level": 1,
+        "bbox": [
+            419,
+            837,
+            578,
+            851
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "C - EXTRA RESULTS ON CIFAR-10 ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            102,
+            468,
+            118
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "C.1 - MULTIPLE DISCRIMINATORS ACROSS DIFFERENT INITIALIZATIONS AND OTHER SCORES ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            135,
+            818,
+            148
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Table 4 presents the best FID (computed with a pretrained ResNet) achieved by each approach at train time, along with the epoch in which it was achieved, for each of 3 independent runs. Train time FIDs are computed using 1000 generated images. ",
+        "bbox": [
+            174,
+            159,
+            825,
+            202
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "table",
+        "img_path": "images/7ed0f3099d5b24e4a00fc6545c2afe9479c5b53c1ab0763602e656a844361f8e.jpg",
+        "table_caption": [
+            "Table 4: Best FID obtained for each approach on 3 independent runs. FID is computed on 1000 generated images after every epoch. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>#D</td><td>Method</td><td>Best FID (epoch)</td></tr><tr><td rowspan=\"2\">1</td><td>DCGAN</td><td>7.09 (68),9.09 (21),4.22 (101)</td></tr><tr><td>WGAN-GP</td><td>5.09 (117),5.69 (101) 7.13 (71)</td></tr><tr><td rowspan=\"3\">8</td><td>AVG</td><td>3.35 (105),4.64 (141),3.00 (76)</td></tr><tr><td>GMAN</td><td>4.28 (123),4.24 (129),3.80 (133)</td></tr><tr><td>HV</td><td>3.87 (102),4.54 (82),3.20 (98)</td></tr><tr><td rowspan=\"3\">16</td><td>AVG</td><td>3.16 (96),2.50 (91),2.77 (116)</td></tr><tr><td>GMAN</td><td>2.69 (129),2.36 (144),2.48 (120)</td></tr><tr><td>HV</td><td>2.56 (85),2.70 (97),2.68 (133)</td></tr><tr><td rowspan=\"3\">24</td><td>AVG</td><td>2.10 (94),2.44 (132),2.43 (129)</td></tr><tr><td>GMAN</td><td>2.16 (120),2.02 (98),2.13 (130)</td></tr><tr><td>HV</td><td>2.05 (83),1.89 (97),2.23 (130)</td></tr></table>",
+        "bbox": [
+            352,
+            213,
+            647,
+            347
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "In Fig. 9, we report the norm of the update direction $\\begin{array} { r l } {  { \\vert \\vert \\sum _ { k = 1 } ^ { K } \\alpha _ { k } \\nabla l _ { k } \\vert \\vert } } & { { } } \\end{array}$ of the best model obtained for Pareto-stationarity sense, i.e. the norm upon convergence is lower for models trained against more discriminators, regardless of the employed method. ",
+        "bbox": [
+            173,
+            401,
+            825,
+            460
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "image",
+        "img_path": "images/7ea792a59ab6686cb0ca729991fbf4a0c965f5f36cc504ae38c2d2e4138c2537.jpg",
+        "image_caption": [
+            "Figure 9: Norm of the update direction over time for each method. Higher number of discriminators yield lower norm upon convergence. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            354,
+            492,
+            629,
+            638
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "We computed extra scores using 10000 images generated by the best model reported in Table 4, i.e. the same models utilized to generate the results shown in Fig. 6. Both Inception score and FID were computed with original implementations, while FID-VGG and FID-ResNet were computed using a VGG and a ResNet we pretrained. Results are reported with respect to DCGAN’s scores. ",
+        "bbox": [
+            173,
+            707,
+            825,
+            763
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "table",
+        "img_path": "images/44a9491fb6d2e830af9362fc3cfb513f34b5499f9866cb4fdba231d14306a068.jpg",
+        "table_caption": [],
+        "table_footnote": [],
+        "table_body": "<table><tr><td></td><td>WGAN-GP</td><td>AVG-8</td><td>AVG-16</td><td>AVG-24</td><td>GMAN-8</td><td>GMAN-16</td><td>GMAN-24</td><td>HV-8</td><td>HV-16</td><td>HV-24</td></tr><tr><td>InceptionScore</td><td>1.08</td><td>1.02</td><td>1.26</td><td>1.36</td><td>0.95</td><td>1.32</td><td>1.42</td><td>1.00</td><td>1.30</td><td>1.44</td></tr><tr><td>FID</td><td>0.80</td><td>0.98</td><td>0.76</td><td>0.73</td><td>0.92</td><td>0.79</td><td>0.65</td><td>0.89</td><td>0.77</td><td>0.72</td></tr><tr><td>FID-VGG</td><td>1.29</td><td>0.91</td><td>1.03</td><td>0.85</td><td>0.87</td><td>0.78</td><td>0.73</td><td>0.78</td><td>0.75</td><td>0.64</td></tr><tr><td>FID-ResNet</td><td>1.64</td><td>0.88</td><td>0.90</td><td>0.62</td><td>0.80</td><td>0.72</td><td>0.73</td><td>0.75</td><td>0.73</td><td>0.51</td></tr></table>",
+        "bbox": [
+            176,
+            776,
+            825,
+            830
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Table 5: Scores of different methods measure on generated CIFAR-10 samples. DCGAN scores are used as reference values, and results report are the ratio between given model and DCGAN scores. Inception score is better when high, whereas FIDs are better when low. ",
+        "bbox": [
+            174,
+            842,
+            825,
+            885
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "C.2 - COMPUTATIONAL COST ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            104,
+            379,
+            117
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "In Table 6 we present a comparison of minimum FID-ResNet obtained during training, along with computation cost in terms of time and space for different GANs, with both 1 and 24 discriminators. The computational cost of training GANs under a multiple discriminator setting is higher by design, in terms of both FLOPS and memory, if compared with single discriminators settings. However, a corresponding shift in performance is the result of the additional cost. This effect was consistently observed considering 4 different well-known approaches, namely DCGAN (Radford et al., 2015), Least-square GAN (LSGAN) (Mao et al., 2017), and HingeGAN (Miyato et al., 2018). The architectures of all single discriminator models follow the DCGAN, described in (Radford et al., 2015). For the 24 discriminators models, we used the architecture described in (Neyshabur et al., 2017), which consists in removing the the normalization layers from DCGAN’s discriminator and further adding the projection layer, inline with previous experiments reported for CIFAR-10 upscaled to $6 4 \\mathrm { x } 6 4$ . All models were trained with minibatch size of 64 during 150 epochs. Adam (Kingma & Ba, 2014) was used as the optimizer. Learning rate, $\\beta _ { 1 }$ and $\\beta _ { 2 }$ were equal to 0.0002, 0.5 and 0.999, respectively. ",
+        "bbox": [
+            173,
+            128,
+            826,
+            310
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "table",
+        "img_path": "images/e0c6d80da858ff24f23c895432520bf99bff9eeb30c9aba7448159ec06eafe5a.jpg",
+        "table_caption": [],
+        "table_footnote": [],
+        "table_body": "<table><tr><td></td><td>#Discriminators</td><td>FID-ResNet</td><td>FLOPS (MAC)</td><td>Memory (Mb)</td></tr><tr><td rowspan=\"2\">DCGAN</td><td>1</td><td>4.22</td><td>8e10</td><td>1292</td></tr><tr><td>24</td><td>1.89</td><td>5e11</td><td>5671</td></tr><tr><td rowspan=\"2\">LSGAN</td><td>1</td><td>4.55</td><td>8e10</td><td>1303</td></tr><tr><td>24</td><td>1.91</td><td>5e11</td><td>5682</td></tr><tr><td rowspan=\"2\">HingeGAN</td><td>1</td><td>6.17</td><td>8e10</td><td>1303</td></tr><tr><td>24</td><td>2.25</td><td>5e11</td><td>5682</td></tr></table>",
+        "bbox": [
+            218,
+            321,
+            779,
+            425
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "Table 6: Comparison between different GANs with 1 and 24 discriminators in terms of minimum FID-ResNet obtained during training, and FLOPs and memory consumption for a complete train step. ",
+        "bbox": [
+            173,
+            434,
+            825,
+            464
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "Furthermore, wall-clock time per iteration for different numbers of discriminators is shown in Fig. 10 for experiments with CIFAR-10 with serial updates of discriminators. Notice that while the increase in cost in terms of FLOPS and memory is unavoidable when multiple discriminators settings is employed, wall-clock time can be made close to single discriminators cases since training with respect to different discriminators can be implemented in parallel. On the other hand, extra cost in time introduced by other frameworks such as WGAN-GP or SNGAN cannot be trivially recovered. ",
+        "bbox": [
+            173,
+            478,
+            825,
+            564
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "image",
+        "img_path": "images/301bfb521f36f11b23715bfd1af7df6decd71c59cec4f42cdb6f8a930e9896cd.jpg",
+        "image_caption": [
+            "Figure 10: Time in seconds per iteration of each method for serial updates of discriminators. Multiple discriminators approaches considered do not present relevant difference in time per iteration. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            250,
+            579,
+            751,
+            779
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "C.3 - GENERATED SAMPLES ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            104,
+            370,
+            117
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "In Figs. 11, 12, and 13 we show random generated samples with 8, 16, and 24 discriminators for AVG, GMAN, and HV, respectively. ",
+        "bbox": [
+            173,
+            130,
+            823,
+            159
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "image",
+        "img_path": "images/4f6cd9aa1191d74bb1e3643d7c57f98a2c445ecba39f5cd7da73cdcd79df8e85.jpg",
+        "image_caption": [
+            "Figure 11: CIFAR-10 samples for AVG trained with 8, 16, and 24 discriminators. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            200,
+            190,
+            803,
+            359
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "image",
+        "img_path": "images/d17f7aaac2f8eedc9706144a3800e581c85826f1e890b645b9b3784df18f0138.jpg",
+        "image_caption": [
+            "Figure 12: CIFAR-10 samples for GMAN trained with 8, 16, and 24 discriminators. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            199,
+            434,
+            803,
+            602
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "image",
+        "img_path": "images/44c285f9959ece1ca6354c2e221b93ff0f12fb3c777e98e2cc04a27c326df146.jpg",
+        "image_caption": [
+            "Figure 13: CIFAR-10 samples for HV trained with 8, 16, and 24 discriminators. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            202,
+            678,
+            803,
+            844
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "C.4 - RESULTS CIFAR-10 32X32 ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            103,
+            408,
+            117
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "text",
+        "text": "All results reported in previous sections using CIFAR-10 were obtained with an upscaled version of the dataset. Here, we thus run experiments with the dataset in its original resolution aiming to contextualize our proposed approach with respect to previously introduced methods. To do so, we repeated similar experiments as reported in Miyato et al. (2018)-Table 2, for the model referred to as standard CNN. The same architecture is employed and the spectral normalization is removed from the discriminators. Moreover, the same projection input is added in each of the discriminators. ",
+        "bbox": [
+            174,
+            128,
+            825,
+            213
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "text",
+        "text": "Results in terms of both FID and Inception score, evaluated on top of 5000 generated images as in (Miyato et al., 2018) as well as with 10000 images, are reported in Table 7 for our proposed approach and our implementation of (Miyato et al., 2018), along with the FID measured using a ResNet classifier trained in advance. ",
+        "bbox": [
+            174,
+            219,
+            825,
+            276
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "table",
+        "img_path": "images/6592cefbded2c49448c73251014cf03a9de472d01ca20beda901bfcfcd4a9384.jpg",
+        "table_caption": [
+            "As can be seen, the addition of the multiple discriminators setting along with hypervolume maximization yields a relevant shift in performance for the DCGAN-like generator, taking all evaluated metrics to levels of recently proposed GANs. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td></td><td>FID-ResNet</td><td>FID (5k)</td><td>IS (5k)</td><td>FID (10k)</td><td>IS (10k)</td></tr><tr><td>SNGAN (Miyato et al., 2018)</td><td>-</td><td>25.5</td><td>7.58±0.12</td><td>-</td><td>-</td></tr><tr><td>WGAN-GP (Miyato et al., 2018)</td><td></td><td>40.2</td><td>6.68 ± 0.06</td><td>1</td><td>-</td></tr><tr><td>DCGAN (Miyato et al., 2018)</td><td>-</td><td>-</td><td>6.64± 0.14</td><td>-</td><td>=</td></tr><tr><td>SNGAN (our implementation)</td><td>1.55</td><td>27.93</td><td>7.11 ± 0.30</td><td>25.29</td><td>7.26± 0.12</td></tr><tr><td>DCGAN + 24 Ds and HV</td><td>1.21</td><td>27.74</td><td>7.32 ± 0.26</td><td>24.90</td><td>7.45 ± 0.17</td></tr></table>",
+        "bbox": [
+            176,
+            338,
+            821,
+            420
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "text",
+        "text": "Table 7: Evaluation of the effect of adding discriminators on a DCGAN-like model trained on CIFAR-10. Results reach the same level as the best reported for the given architecture when the multiple-discriminator setting is added and the normalization layers are removed from discriminators. ",
+        "bbox": [
+            174,
+            429,
+            823,
+            472
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "text",
+        "text": "D - CELEBA DATASET ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            103,
+            328,
+            117
+        ],
+        "page_idx": 16
+    },
+    {
+        "type": "text",
+        "text": "D.1 - COMPARING WITH OTHER MULTIPLE-DISCRIMINATORS APPROACHES ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            131,
+            691,
+            143
+        ],
+        "page_idx": 16
+    },
+    {
+        "type": "text",
+        "text": "Here, we present samples obtained by generators trained against 8, 16, and 24 discriminators using AVG, GMAN, and HV on the CelebA dataset rescaled to $6 4 \\mathrm { x } 6 4$ . Training lasted 100 epochs and samples are shown in Figs. 14, 15, and 16 for AVG, GMAN and HV, respectively. Same architectures and hyperparameters used for experiments with CIFAR-10 presented in Section 5 were utilized. ",
+        "bbox": [
+            174,
+            154,
+            825,
+            210
+        ],
+        "page_idx": 16
+    },
+    {
+        "type": "image",
+        "img_path": "images/805c9d68728ee19b1eac47e5d4ed22825d4927a4045497fcf76de0a89503d251.jpg",
+        "image_caption": [
+            "Figure 14: CelebA samples for AVG trained with 8, 16, and 24 discriminators. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            200,
+            242,
+            803,
+            410
+        ],
+        "page_idx": 16
+    },
+    {
+        "type": "image",
+        "img_path": "images/a96174141a86e0eaadf85353beb5db24aaf25afe0c3f891f527278df36f89827.jpg",
+        "image_caption": [
+            "Figure 15: CelebA samples for GMAN trained with 8, 16, and 24 discriminators. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            199,
+            484,
+            803,
+            652
+        ],
+        "page_idx": 16
+    },
+    {
+        "type": "image",
+        "img_path": "images/ca108c2ceb1f8e89e8591e129d2689b99c0d6e3245069c86c43ab157a79e879e.jpg",
+        "image_caption": [
+            "Figure 16: CelebA samples for HV trained with 8, 16, and 24 discriminators. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            200,
+            726,
+            803,
+            893
+        ],
+        "page_idx": 16
+    },
+    {
+        "type": "text",
+        "text": "D.2 - GENERATING 128X128 IMAGES ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            103,
+            436,
+            117
+        ],
+        "page_idx": 17
+    },
+    {
+        "type": "text",
+        "text": "In this experiment, we verify whether the proposed multiple discriminators setting is capable of generating higher resolution images. For that, we employed the CelebA at a size of $1 2 8 \\mathrm { x } 1 2 8$ . We used a similar architecture for both generator and discriminators networks as described in the previous experiments. A convolutional layer with 2048 feature maps was added to both generator and discriminators architectures due to the increase in the image size. Adam optimizer with the same set of hyperparameters as for CIFAR-10 and CelebA $6 4 \\mathrm { x } 6 4$ was employed. We trained models with 6, 8, and 10 discriminators during 24 epochs. Samples from each generator are shown in Figure 17. ",
+        "bbox": [
+            173,
+            127,
+            826,
+            226
+        ],
+        "page_idx": 17
+    },
+    {
+        "type": "image",
+        "img_path": "images/d5427bf30474177574950cec528e2b26ea690bcdeecc69f90e8b088ac3bc03f1.jpg",
+        "image_caption": [
+            "Figure 17: 128x128 CelebA samples for HV trained during 24 epochs with 6, 8, and 10 discriminators. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            232,
+            234,
+            764,
+            872
+        ],
+        "page_idx": 17
+    },
+    {
+        "type": "text",
+        "text": "E - GENERATING 256X256 CATS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            102,
+            447,
+            117
+        ],
+        "page_idx": 18
+    },
+    {
+        "type": "text",
+        "text": "We show the proposed multiple-discriminators setting scales to higher resolution even in the small dataset regime, by reproducing the experiments presented in (Jolicoeur-Martineau, 2018). We used the same architecture for the generator. For the discriminator, we removed batch normalization from all layers and used stride equal to 1 at the last convolutional layer, after adding the initial projection step. The Cats dataset 3 was employed, we followed the same pre-processing steps, which, in our case, yielded 1740 training samples with resolution of $2 5 6 \\times 2 5 6$ . Our model is trained using 24 discriminators and Adam optimizer with the same hyperparameters as for CIFAR-10 and CelebA previously described experiments. In Figure 18 we show generator’s samples after 288 training epochs. One epoch corresponds to updating over 27 minibatches of size 64. ",
+        "bbox": [
+            173,
+            133,
+            825,
+            258
+        ],
+        "page_idx": 18
+    },
+    {
+        "type": "image",
+        "img_path": "images/c3e312a8b196aadce61e0a136ff84397e9a2647d22d888dbe6bd557b4735c5f9.jpg",
+        "image_caption": [
+            "Figure 18: Cats generated using 24 discriminators after 288 training epochs. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            266,
+            268,
+            732,
+            842
+        ],
+        "page_idx": 18
+    },
+    {
+        "type": "text",
+        "text": "F - INCREASING NUMBER OF RANDOM PROJECTIONS ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            103,
+            612,
+            117
+        ],
+        "page_idx": 19
+    },
+    {
+        "type": "text",
+        "text": "In this experiment we illustrate and confirm the results introduced in (Neyshabur et al., 2017), showing the effect of using an increasing number of random projections to train a GAN. We trained models using average loss minimization with 1 to 6 discriminators on the CelebA dataset for 15 epochs. Samples from the generator obtained in the last epoch are shown in Fig. 19. Generated samples are closer to real data as the number of random projections (and discriminators, consequently) increases. ",
+        "bbox": [
+            174,
+            133,
+            826,
+            204
+        ],
+        "page_idx": 19
+    },
+    {
+        "type": "image",
+        "img_path": "images/c7b70be0f9e460f745e9f9c8ca54464bb53510f76261cb014b44bdbbc8c4bf6a.jpg",
+        "image_caption": [],
+        "image_footnote": [],
+        "bbox": [
+            254,
+            226,
+            758,
+            282
+        ],
+        "page_idx": 19
+    },
+    {
+        "type": "image",
+        "img_path": "images/6b589d37c928da22dfbae82afe91e2a109db7829633513ec8897d7b3e5d2ec4b.jpg",
+        "image_caption": [
+            "Figure 19: Models trained with AVG during 15 epochs using an increasing number of random projections and discriminators. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            253,
+            256,
+            761,
+            758
+        ],
+        "page_idx": 19
+    },
+    {
+        "type": "text",
+        "text": "(f) AVG - 6 discriminators ",
+        "text_level": 1,
+        "bbox": [
+            419,
+            760,
+            576,
+            772
+        ],
+        "page_idx": 19
+    },
+    {
+        "type": "text",
+        "text": "G - ILLUSTRATION OF INTERACTION BETWEEN HYPERVOLUME AND ADOPTEDNADIR POINT ADAPTATION SCHEME",
+        "text_level": 1,
+        "bbox": [
+            174,
+            103,
+            823,
+            136
+        ],
+        "page_idx": 20
+    },
+    {
+        "type": "text",
+        "text": "Consider a two-objectives problem, with $l _ { 1 } ^ { t } > 0$ and $l _ { 2 } ^ { t } > 0$ corresponding to each of the losses we want to minimize, at iteration $t$ . We present in Figures 20 and 21 an illustrative example of the effect of the adaptation scheme adopted for $\\eta$ , as described in Section 4. ",
+        "bbox": [
+            173,
+            150,
+            825,
+            193
+        ],
+        "page_idx": 20
+    },
+    {
+        "type": "text",
+        "text": "Figure 20 describes the initialization state. Since $l _ { 1 } ^ { t }$ and $l _ { 2 } ^ { t }$ will be high at $t = 0$ , and, following the adaptation rule presented in previous sections, $\\eta ^ { t } = \\overline { { \\delta } } \\operatorname* { m a x } \\{ l _ { 1 } ^ { t } , l _ { 2 } ^ { t } \\}$ , for a slack $\\delta > 0$ , the difference $\\eta ^ { t } - \\operatorname* { m a x } \\{ l _ { 1 } ^ { t } , l _ { 2 } ^ { t } \\}$ will be high. In contrast, after $T$ updates, as described in Figure 21, $\\eta ^ { t } = \\delta \\operatorname* { m a x } \\{ l _ { 1 } ^ { t } , l _ { 2 } ^ { t } \\}$ will be smaller, since losses are now closer to 0. ",
+        "bbox": [
+            173,
+            199,
+            825,
+            256
+        ],
+        "page_idx": 20
+    },
+    {
+        "type": "text",
+        "text": "If no adaptation is performed and $\\eta$ is kept unchanged throughout training, as represented in red in Figure 21, $\\eta ^ { T } - l _ { 1 } ^ { \\dot { T } } \\approx \\eta ^ { T } - l _ { 2 } ^ { T }$ for a large enough $T$ , which will end up assigning similar weights to gradients provided by the different losses, defeating the purpose of employing hypervolume maximization rather than optimizing for the average loss. ",
+        "bbox": [
+            173,
+            263,
+            825,
+            319
+        ],
+        "page_idx": 20
+    },
+    {
+        "type": "text",
+        "text": "The employed adaptation scheme thus keeps the gradient weighting relevant even when losses become low. Moreover, this effect will be more aggressive as training progresses, assigning more gradient importance to the higher losses, since $\\eta ^ { T } \\stackrel { \\smile \\smile } { - } \\operatorname* { m a x } \\{ l _ { 1 } ^ { T } , l _ { 2 } ^ { T } \\} < \\tilde { \\eta ^ { 0 } } ^ { \\perp } - \\tilde { \\operatorname* { m a x } } \\{ l _ { 1 } ^ { 0 } , l _ { 2 } ^ { 0 } \\}$ . ",
+        "bbox": [
+            173,
+            325,
+            825,
+            369
+        ],
+        "page_idx": 20
+    },
+    {
+        "type": "image",
+        "img_path": "images/5b8e84076c970a1a21cf255988d1753fc8e0f1c6ad1c536e534fc0b35348b8d0.jpg",
+        "image_caption": [
+            "Figure 20: Losses and nadir point at beginning of training. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            178,
+            380,
+            415,
+            597
+        ],
+        "page_idx": 20
+    },
+    {
+        "type": "image",
+        "img_path": "images/59472b02e0b91f44394376f94dbfa92a5391f0569bc3e9d8d89e4c665f46c83e.jpg",
+        "image_caption": [
+            "Figure 21: Losses and nadir point at $t = T$ , and nadir point at $t = 0$ (in red). "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            545,
+            380,
+            784,
+            597
+        ],
+        "page_idx": 20
+    },
+    {
+        "type": "text",
+        "text": "H - WALL-CLOCK TIME FOR REACHING BEST FID DURING TRAINING ON MNIST ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            102,
+            776,
+            136
+        ],
+        "page_idx": 21
+    },
+    {
+        "type": "image",
+        "img_path": "images/f8543d63bd2e5b7eea705799930fda13a6599947829cd03e0997c810580b1ace.jpg",
+        "image_caption": [
+            "Figure 22: Minimum FID during training. X-axis is in minutes. The blue dot is intended to highlight the moment during training when the minimum FID was reached. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            202,
+            193,
+            763,
+            525
+        ],
+        "page_idx": 21
+    }
+]

parse/train/gl3D-xY7wLq/gl3D-xY7wLq.md

@@ -0,0 +1,394 @@
+# NOISE OR SIGNAL: THE ROLE OF IMAGE BACK-GROUNDS IN OBJECT RECOGNITION
+
+Kai Xiao, Logan Engstrom, Andrew Ilyas, Aleksander M ˛adry MIT {kaix,engstrom,ailyas,madry}@mit.edu
+
+# ABSTRACT
+
+We assess the tendency of state-of-the-art object recognition models to depend on signals from image backgrounds. We create a toolkit for disentangling foreground and background signal on ImageNet images, and find that (a) models can achieve non-trivial accuracy by relying on the background alone, (b) models often misclassify images even in the presence of correctly classified foregrounds—up to $8 8 \%$ of the time with adversarially chosen backgrounds, and (c) more accurate models tend to depend on backgrounds less. Our analysis of backgrounds brings us closer to understanding which correlations machine learning models use, and how they determine models’ out of distribution performance.
+
+# 1 INTRODUCTION
+
+Object recognition models are typically trained to minimize loss on a given dataset, and evaluated by the accuracy they attain on the corresponding test set. In this paradigm, model performance can be improved by incorporating any generalizing correlation between images and their labels into decision-making. However, the actual model reliability and robustness depend on the specific set of correlations that is used, and on how those correlations are combined. Indeed, outside of the training distribution, model predictions can deviate wildly from human expectations either due to relying on correlations that humans do not perceive (Jetley et al., 2018; Ilyas et al., 2019; Jacobsen et al., 2019), or due to overusing correlations, such as texture (Geirhos et al., 2019; Baker et al., 2018) and color (Yip & Sinha, 2002), that humans do use (but to a lesser degree). Characterizing the correlations that models depend on thus has important implications for understanding model behavior, in general.
+
+Image backgrounds are a natural source of correlation between images and their labels in object recognition. Indeed, prior work has shown that models may use backgrounds in classification (Zhang et al., 2007; Ribeiro et al., 2016; Zhu et al., 2017; Rosenfeld et al., 2018; Zech et al., 2018; Barbu et al., 2019; Shetty et al., 2019; Sagawa et al., 2020; Geirhos et al., 2020), and suggests that even human vision makes use of image context for scene and object recognition (Torralba, 2003). In this work, we aim to obtain a deeper and more holistic understanding of how current state-of-the-art image classifiers utilize image backgrounds. To this end, in contrast to most of the prior work (which tends to study relatively small and often newly-curated image datasets1), our focus is on ImageNet (Russakovsky et al., 2015)—one of the largest and most widely used datasets, with state-of-the-art training methods, architectures, and pre-trained models tuned to work well for it.
+
+Zhu et al. (2017) analyze ImageNet classification (focusing on the older, AlexNet model) to find that AlexNet achieves small but non-trivial test accuracy on a dataset consisting of only backgrounds (where foreground objects are replaced by black rectangles). While sufficient for establishing that backgrounds can be used for classification, we aim to go beyond those initial explorations to get a more fine-grained understanding of the relative importance of backgrounds and foregrounds, for newer, state-of-the-art models, and to provide a versatile toolkit for others to use. Specifically, we investigate the extent to which models rely on backgrounds, the implications of this reliance, and how models’ use of backgrounds has evolved over time. Concretely:
+
+• We create a suite of datasets that help disentangle (and control for different aspects of) the impact of foreground and background signals on classification. The code and datasets are publicly available for others to use in this repository: https://github.com/ MadryLab/backgrounds_challenge.
+
+• Using the aforementioned toolkit, we characterize models’ reliance on image backgrounds. We find that image backgrounds alone suffice for fairly successful classification and that changing background signals decreases average-case performance. In fact, we further show that by choosing backgrounds in an adversarial manner, we can make standard models misclassify $8 8 \%$ of images as the background class.   
+• We demonstrate that standard models not only use but require backgrounds for correctly classifying large portions of test sets $3 5 \%$ on our benchmark).   
+• We study the impact of backgrounds on classification for a variety of classifiers, and find that models with higher ImageNet test accuracy tend to simultaneously have higher accuracy on image backgrounds alone and have greater robustness to changes in image background.
+
+# 2 METHODOLOGY
+
+To properly gauge image backgrounds’ role in image classification, we construct a synthetic dataset for disentangling background from foreground signal: ImageNet-9.
+
+![](images/39d95c29922404808c2cd28fca51c6adf4e63af3c90e97a411d4b039c35130d2.jpg)  
+Figure 1: Variations of the synthetic dataset ImageNet-9, as described in Table 1. We label each image with its pre-trained ResNet-50 classification—green, if corresponding with the original label; red, if not. The model correctly classifies the image as “insect” when given: the original image, only the background, and two cases where the original foreground is present but the background changes. Note that, in particular, the model fails in two cases when the original foreground is present but the background changes (as in MIXED-NEXT or ONLY-FG).
+
+Base dataset: ImageNet-9. We organize a subset of ImageNet into a new dataset with nine coarse-grained classes and call it ImageNet-9 (IN-9) 2. To create it, we group together ImageNet classes sharing an ancestor in the WordNet (Miller, 1995) hierarchy. We use coarse-grained classes because there are not enough images with annotated bounding boxes (which we need to disentangle backgrounds and foregrounds) to use the standard labels. The resulting IN-9 dataset is class-balanced and has 45405 training images and 4050 testing images. While we can (and do) apply our methods on the full ImageNet dataset as well, we choose to focus on this coarse-grained version of ImageNet because of its higher-fidelity images. We describe the dataset creation process in detail and discuss the advantages of focusing on IN-9 in Appendix A.
+
+Variations of ImageNet-9 From this base set of images, which we call the ORIGINAL version of IN-9, we create seven other synthetic variations designed to understand the impact of backgrounds. We use both rectangular bounding boxes and the foreground segmentation algorithm GrabCut (Rother et al., 2004), as implemented in OpenCV, to disentangle backgrounds and foregrounds. We visualize these variations in Figure 1, and provide a detailed reference in Table 1. These subdatasets of IN-9 differ only in how they process the foregrounds and backgrounds of each constituent image.
+
+Larger dataset: IN-9L We finally create a dataset called IN-9L that consists of all the images in ImageNet corresponding to the classes in ORIGINAL (rather than just the images that have associated bounding boxes). This dataset has about 180k training images in total. We leverage this larger dataset to train better generalizing models, and prefer to analyze models trained on IN-9L whenever possible.
+
+Table 1: The 8 modified subdatasets created from ImageNet-9, which are visualized in Figure 1. The foreground detection method refers to how the pixels corresponding to the foreground are found. GrabCut refers to the foreground segmentation algorithm implemented in OpenCV. Random backgrounds in the last three datasets are taken from ONLY-BG-T. For more details see Appendix A.   
+
+<table><tr><td>Name</td><td>Foreground</td><td>Background</td><td>Foreground Detection Method</td></tr><tr><td>ORIGINAL</td><td>Unmodified</td><td>Unmodified</td><td></td></tr><tr><td>ONLY-BG-B</td><td>Black</td><td>Unmodified</td><td>Bounding Box</td></tr><tr><td>ONLY-BG-T</td><td>Tiled background</td><td>Unmodified</td><td>Bounding Box</td></tr><tr><td>No-FG</td><td>Black</td><td>Unmodified</td><td>GrabCut</td></tr><tr><td>ONLY-FG</td><td>Unmodified</td><td>Black</td><td>GrabCut</td></tr><tr><td>MIXED-SAME</td><td>Unmodified</td><td>Random BG of the same class</td><td>GrabCut</td></tr><tr><td>MIXED-RAND</td><td>Unmodified</td><td>Random BG of a random class</td><td>GrabCut</td></tr><tr><td>MIXED-NEXT</td><td>Unmodified</td><td>Random BG of the next class</td><td>GrabCut</td></tr></table>
+
+# 3 QUANTIFYING RELIANCE ON BACKGROUND SIGNALS
+
+With ImageNet-9 in hand, we now assess the role of image backgrounds in classification.
+
+![](images/613a6a063be1a86e6a68d45f5a949f7e0b8fc3cffea5584830b9bb53b2c52362.jpg)  
+Figure 2: We train models on each of the “background-only” datasets, then evaluate each on its corresponding test set as well as the ORIGINAL test set. Even though the model only learns from background signal, it achieves (much) better than random performance on both the corresponding test set and ORIGINAL. Here, random guessing would give $1 1 . 1 1 \%$ (the dotted line).
+
+Backgrounds suffice for classification. Prior work has found that models are able to make accurate predictions based on backgrounds alone; we begin by directly quantifying this ability. Looking at the ONLY-BG-T, ONLY-BG-B, and NO-FG datasets, we find (cf. Figure 2) that models trained on these background-only training sets generalize reasonably well to both their corresponding test sets and to unmodified images from the ORIGINAL test set (around $40 { - } 5 0 \%$ for every model, far above the
+
+Table 2: Performance of state-of-the-art computer vision models on selected test sets of ImageNet9. We include both pre-trained ImageNet models and models of different architectures that we train on IN-9L. The BG-GAP is defined as the difference in test accuracy between MIXED-SAME and MIXED-RAND and helps assess the tendency of such models to rely on background signal. Architectures are sorted by their test accuracies on ImageNet and ORIGINAL for pre-trained and IN-9L-trained models, respectively. Shaded in grey are the two architectures that can be directly compared across datasets (ResNet-50 and Wide-ResNet-50x2).
+
+<table><tr><td></td><td colspan="4">Pre-trained on ImageNet</td><td colspan="5">Trained on IN-9L</td></tr><tr><td>Test dataset</td><td>MobileNet-v3</td><td>EfficientNet-b0</td><td>ResNet-50</td><td>WRN-50x2 DPN-92</td><td>AlexNet</td><td>ShufleNet</td><td>ResNet-50</td><td>WRN-50x2</td><td>VGG16-BN</td></tr><tr><td>ImageNet</td><td>67.9%</td><td>77.2%</td><td>77.6%</td><td>78.5% 80.0%</td><td></td><td></td><td></td><td></td><td></td></tr><tr><td>ORIGINAL</td><td>95.5%</td><td>96.1%</td><td>96.9%</td><td>96.6% 97.2%</td><td>86.7%</td><td>95.7%</td><td>96.3%</td><td>97.2%</td><td>97.6%</td></tr><tr><td>ONLY-BG-T</td><td>16.3%</td><td>16.5%</td><td>17.4%</td><td>18.8% 17.6%</td><td></td><td>41.5% 43.6%</td><td>43.6%</td><td>45.1%</td><td>45.7%</td></tr><tr><td>MIXED-SAME</td><td>84.0%</td><td>86.2%</td><td>91.0%</td><td>88.3%</td><td>90.5%</td><td>76.2% 86.7%</td><td>89.9%</td><td>90.6%</td><td>91.0%</td></tr><tr><td>MIXED-RAND</td><td>73.2%</td><td>76.3%</td><td>84.3%</td><td>81.4%</td><td>86.1%</td><td>54.2% 69.4%</td><td>75.6%</td><td>78.0%</td><td>78.0%</td></tr><tr><td>BG-gap</td><td>10.8%</td><td>9.9%</td><td>6.7%</td><td>6.9%</td><td>4.4%</td><td>22.0% 17.3%</td><td>14.3%</td><td>12.6%</td><td>13.0%</td></tr></table>
+
+baseline of $11 \%$ representing random classification). Our results confirm that image backgrounds contain signal that models can accurately classify standard images with.
+
+Models exploit background signal for classification. We discover that models can misclassify due to background signal, especially when the background class does not match that of the foreground. As a demonstration, we study model accuracies on the MIXED-RAND dataset, where image backgrounds are randomized and thus provide no information about the correct label. By comparing test accuracies on MIXED-RAND and MIXED-SAME 3, where images have class-consistent backgrounds, we can measure classifiers’ dependence on the correct background. We denote the resulting accuracy gap between MIXED-SAME and MIXED-RAND as the BG-GAP; this difference represents the drop in model accuracy due to changing the class signal from the background. In Table 2, we observe a BG-GAP of $1 3 \mathrm { - } 2 2 \%$ and $4 \%$ for models trained on IN-9L and ImageNet, respectively, suggesting that backgrounds often mislead state-of-the-art models even when the correct foreground is present.
+
+More Training Data can reduce the BG-GAP. Our results indicate that ImageNet-trained models are less dependent on backgrounds than their IN-9L-trained counterparts—they have a smaller (but still significant) BG-GAP, and perform worse when predicting solely based on backgrounds (i.e., on the ONLY-BG-T dataset). We explore two ways that ImageNet differs from IN-9L to understand this phenomena—ImageNet has (a) more datapoints than IN-9L, and (b) a more fine-grained class structure. Figure 3 shows that more training data reduces the BG-GAP, particularly when the training dataset size approaches the size of ImageNet. This indicates that training on much more data (and thus, more backgrounds) can reduce (but not eliminate) the effect of backgrounds on model predictions. An ablation study of ImageNet’s more fine-grained class structure does not find strong evidence supporting its helpfulness (cf. Appendix B).
+
+Models are vulnerable to adversarial backgrounds. To understand how worst-case backgrounds impact models’ performance, we evaluate model robustness to adversarially chosen backgrounds. We find that $8 8 \%$ of foregrounds are susceptible to such backgrounds; that is, for these foregrounds, there is a background that causes the classifier to classify the resulting foreground-background combination as the background class. For a finer grained look, we also evaluate image backgrounds based on their attack success rate (ASR), i.e., how frequently they cause models to predict the (background) class in the presence of a conflicting foreground class. As an example, Figure 4 shows the five backgrounds with the highest ASR for the insect class—these backgrounds (extracted from insect images in ORIGINAL) fool a IN-9L-trained ResNet-50 model into predicting insect on up to $52 \%$ of non-insect foregrounds. We plot a histogram of ASR over all insect backgrounds in Figure 24 of the Appendix—it has a long tail. Similar results are observed for other classes as well (cf. Appendix G).
+
+![](images/291dcfe5536b4ddad86b4b4803c4e99cc32ebfb4c2bf6152f83be2e530cf3ecb.jpg)  
+Figure 3: We compare test accuracies on MIXED-SAME and MIXED-RAND and observe that training with more data reduces the BG-GAP (BG-GAP measures the effect of backgrounds on model predictions). While this trend is true for models trained on both IN-9 and ImageNet, the trend is most noticeable for models trained on the largest training set, the full ImageNet dataset—this is shown on the far right side of the graph.
+
+![](images/0c11dbe95ae025b2429111a819209f084a7a7408c92576bdc1a0f1f806ea0e7f.jpg)  
+Figure 4: The adversarial backgrounds that most frequently fool IN-9L-trained models into classifying a given foreground as insect, ordered by the percentage of foregrounds fooled. The total portion of images that can be fooled (by any background from this class) is $6 6 . 5 5 \%$ .
+
+Training on MIXED-RAND reduces background dependence. Next, we explore how to reduce models’ dependence on background. To this end, we train models on MIXED-RAND, a synthetic dataset where background signals are decorrelated from class labels. As we would expect, MIXEDRAND-trained models extract less signal from backgrounds: evaluation results show that MIXEDRAND models perform poorly ( $15 \%$ accuracy—barely higher than random) on datasets with only backgrounds and no foregrounds, (ONLY-BG-T or ONLY-BG-B).
+
+Indeed, such models are also more accurate on datasets where backgrounds do not match foregrounds. In Figure 5, we observe that a MIXED-RAND-trained model has $1 7 . 3 \%$ higher accuracy than its ORIGINAL-trained counterpart on MIXED-RAND, and $2 2 . 3 \%$ higher accuracy on MIXED-NEXT, a dataset where background signals class-consistently mismatch foregrounds. (Recall that MIXEDNEXT images have foregrounds from class $y$ mixed with backgrounds from class $y + 1$ , labeled as class $y$ .) The MIXED-RAND-trained model also has little variation (at most $3 . 8 \%$ ) in accuracy across all five test sets that contain the correct foreground.
+
+Qualitatively, the MIXED-RAND-trained model also appears to place more relative importance on foreground pixels than the ORIGINAL-trained model; the saliency maps of the two models in Figure 6 show that the MIXED-RAND-trained model’s saliency maps highlight more foreground pixels than those of ORIGINAL-trained models.
+
+A fine grained look at dependence on backgrounds. We now analyze models’ reliance on backgrounds at an image-by-image level and ask: for which images does introducing backgrounds help or hurt classifiers’ performance? To this end, for each image in ORIGINAL, we decompose how models use foreground and background signals by examining classifiers’ predictions on the corresponding image in MIXED-RAND and ONLY-BG-T. Here, we use the MIXED-RAND and ONLY-BG-T predictions as a proxy for which class the foreground and background signals (alone) point towards, respectively. We categorize each image based on how its background and foreground signals impact classification; we list the categories in Table 3 and show the counts for each category as a histogram per classifier in Figure 7. Our results show that while few backgrounds induce misclassification (see Appendix H for examples), a large fraction of images require backgrounds for correct classification—approximately $3 5 \%$ on the ORIGINAL trained classifiers, as calculated by combining the “BG Required” and “BG+FG Required” categories.
+
+![](images/6f8c132f39029a8914d3aa9e2073e4be02a6f6588edbe4958fcd363d05ab0264.jpg)  
+Figure 5: We compare the test performance of a model trained on the synthetic MIXED-RAND dataset with a model trained on ORIGINAL. We evaluate these models on variants of IN-9 that contain identical foregrounds. For the ORIGINAL-trained model, test performance decreases significantly when the background signal is modified during testing. However, the MIXED-RAND-trained model is robust to background changes, albeit at the cost of lower accuracy on images from ORIGINAL.
+
+![](images/9835ef84b01fb95331d73d20bc8002e80e79cffeb016286548601e1a40fc9048.jpg)  
+Figure 6: Saliency maps for the the ORIGINAL and MIXED-RAND models on two images. As expected, the MIXED-RAND model appears to place more importance on foreground pixels.
+
+Further insights derived from IN-9 are discussed in the Appendix D. We focus on key findings in this section, but also include more comprehensive results and examples of other questions that can be explored by using the toolkit of IN-9 in the Appendix.
+
+# 4 BENCHMARK PROGRESS AND BACKGROUND DEPENDENCE
+
+In the previous sections, we demonstrated that standard image classification models exploit signals from backgrounds. Considering that these models result from progress on standard computer vision benchmarks, a natural question is: to what extent have improvements on image classification benchmarks resulted from exploiting background correlations? And relatedly, how has model robustness to misleading background signals evolved over time?
+
+As a first step towards answering these questions, we study the progress made by ImageNet models on our synthetic IN-9 dataset variations. In Figure 8 we plot accuracy on our synthetic datasets against ImageNet accuracy for each of the architectures considered. As evidenced by the lines of best fit in Figure 8, accuracy increases on the original ImageNet benchmark generally correspond to accuracy increases on all of the synthetic datasets. This includes the ONLY-BG datasets—indicating that models do improve at extracting correlations from image backgrounds.
+
+![](images/9e51cfaf6aa1a725c74c20a8a666d750f928b3308269432f717b0065f1057111.jpg)
+
+Indeed, the ONLY-BG trend observed in Figure 8 suggests that either (a) image classification models can only attain their reported accuracies in the presence of background signals; or (b) these models carry an implicit bias towards features in the background, as a result of optimization technique, model class, etc.—in this case, we may need explicit regularization (e.g., through distributionally robust optimization (Sagawa et al., 2020) or related techniques) to obtain models invariant to these background features. The ONLY-BG trend does not indicate that models are failing per se; it could also indicate that models learn to depend on backgrounds because they are necessary for correctly classifying certain images due to quirks in the ImageNet dataset.
+
+Still, models’ relative improvement in accuracy across dataset variants is promising—models improve on classifying ONLY-BG-T at a slower (absolute) rate than MIXED-RAND, MIXED-SAME and MIXED-NEXT. Furthermore, the performance gap between the MIXED datasets and the others (most notably, between MIXED-RAND and MIXED-SAME; between MIXED-NEXT and MIXED-RAND; and consequently between MIXED-NEXT and MIXED-SAME) trends towards closing, indicating that models not only are becoming better at using foreground features, but also are becoming more robust to misleading background features (MIXED-RAND and MIXED-NEXT). Finally, models also improve in accuracy faster on NO-FG (which has foreground shape but no texture) than on ONLY-BG-T, which implies that better models are using foreground shape features more effectively.
+
+Overall, the accuracy trends observed from testing ImageNet models on our synthetic datasets reveal that better models (a) are capable of exploiting background correlations, but (b) are increasingly robust to changes in background, suggesting that invariance to background features may not necessarily come at the cost of benchmark accuracy.
+
+# 5 RELATED WORK
+
+Prior works on contextual bias from image backgrounds4 show that background correlations can be predictive (Torralba, 2003) and can influence model decisions. Zhang et al. (2007) find that (a) a bagof-features object detection algorithm depends on image backgrounds in the PASCAL dataset and (b) using this algorithm on a training set with varying backgrounds leads to better generalization. Beery et al. (2018) and Barbu et al. (2019) collect new test datasets of animals and objects, respectively. Barbu et al. (2019) focus on object classes that also exist in ImageNet, and their new test set contains objects photographed in front of unconventional backgrounds and in unfamiliar orientations. Both works show that computer vision models experience significant accuracy drops when trained on data with one set of backgrounds and tested on data with another. Sagawa et al. (2020) create a synthetic dataset of Waterbirds, where waterbirds and landbirds from one dataset are combined with water and land backgrounds from another. They show that a model’s reliance on spurious correlations with the background can be harmful for small subgroups of data where those spurious correlations no longer hold (e.g. landbirds on water backgrounds). Rosenfeld et al. (2018) analyze background dependence for object detection (as opposed to classification) models on the MS-COCO dataset. They transplant an object from one image to another image, and find that object detection models may detect the transplanted object differently depending on its location, and that the transplanted object may also cause mispredictions on other objects in the image. Zech et al. (2018) study medical imaging and show that a model learned to detect a hospital-specific metal token on medical scans. The model then used each hospital’s pneumonia prevalence rate to predict pneumonia fairly well (without learning much about actually detecting pneumonia).
+
+![](images/ad6ec1fefc8a0fbf9a08aa03a777bd6af4bc89f9438443a0ce8a3c5c2dab9ebd.jpg)  
+Figure 7: We categorize each test set image based on how a model classifies the full image, the background alone, and the foreground alone (cf. Table 3). The model trained on ORIGINAL needs the background for correct classification on $3 5 \%$ of images (measured by adding “BG Required” and $\mathrm { \Delta ^ { 6 } G + F G }$ Required), while a model trained on MIXED-RAND is much less reliant on background. The model trained on ONLY-BG-T requires the background most, as expected; however, the model often misclassifies both the full image and the background, so the “BG Irrelevant” subset is still sizable.
+
+![](images/5478c12e299f6c05895d1f9bd465f955a594fb3ef14ddb5371cca7fb5f896667.jpg)  
+Figure 8: Measuring progress on each of the synthetic ImageNet-9 datasets with respect to progress on the standard ImageNet test set. Higher accuracy on ImageNet generally corresponds to higher accuracy on each of the constructed datasets, but the rate at which accuracy grows varies based on the types of features present in each dataset. Each pre-trained model corresponds to a vertical line on the plot—we mark ResNet-50 and MobileNet-v3s models for reference.
+
+The only work that, similarly to us, studies a large-scale dataset in this context is Zhu et al. (2017), who analyze ImageNet and show that AlexNet can achieve nontrivial accuracy on a dataset similar to our ONLY-BG-B dataset. While sufficient for establishing that backgrounds can be used for classification, this dataset also introduces biases by adding large black rectangular patches to all of the images (which our ONLY-BG-T dataset fixes). In comparison to Zhu et al. (2017) and the other prior works, we: (a) properly segment foregrounds and backgrounds using the GrabCut algorithm instead of relying on rectangular bounding boxes; (b) create dataset variations that allow us to measure not just model performance without foregrounds, but also the relative influence of foregrounds and backgrounds on model predictions; (c) control for the effect of image artifacts by focusing on comparisons between the MIXED-SAME and MIXED-RAND datasets; (d) study model robustness to adversarial backgrounds; (e) study a larger and more recent set of classifiers (He et al., 2016; Zagoruyko & Komodakis, 2016; Tan & Le, 2019); (f) show how improvements they give on ImageNet relate to background dependence; and (g) make our benchmarking toolkit publicly accessible for others to use and build on.
+
+# 6 DISCUSSION AND CONCLUSION
+
+In this work, we study the extent to which classifiers rely on image backgrounds. To this end, we create a toolkit for measuring the precise role of background and foreground signal that involves constructing new test datasets that contain different amounts of each. Through these datasets we establish both the usefulness of background signal and the tendency of our models to depend on backgrounds, even when relevant foreground features are present. Our results show that our models are not robust to changes in the background, either in the adversarial case, or in the average case.
+
+As most ImageNet images have human-recognizable foreground objects, our models appear to rely on background more than humans on that dataset. The fact that models can be fooled by adversarial background changes on $8 8 \%$ of all images highlights how poorly computer vision models may perform in an out-of-distribution setting. However, contextual information like the background can still be useful in certain settings. After all, humans do use backgrounds as context in visual processing, and the background may be necessary if the foreground is blurry or distorted (Torralba, 2003). Therefore, reliance on background is a nuanced question that merits further study.
+
+On one hand, our findings provide evidence that models succeed by using background correlations, which may be undesirable in some applications. On the other hand, we find that advances in classifiers have given rise to models that use foregrounds more effectively and are more robust to changes in the background. To obtain even more robust models, we may want to draw inspiration from successes in training on the MIXED-RAND dataset (a dataset designed to neutralize background signal—cf. Table 1), related data-augmentation techniques (Shetty et al., 2019), and training algorithms like distributionally robust optimization (Sagawa et al., 2020) and model-based robust learning (Robey et al., 2020). Overall, the toolkit and findings in this work help us to better understand models and to monitor our progress toward the goal of reliable machine learning.
+
+# REFERENCES
+
+Nicholas Baker, Hongjing Lu, Gennady Erlikhman, and Philip J. Kellman. Deep convolutional networks do not classify based on global object shape. In PLOS Computational Biology, 2018.
+
+Andrei Barbu, David Mayo, Julian Alverio, William Luo, C Wang, Dan Gutfreund, Josh Tenenbaum, and Boris Katz. Objectnet: A large-scale bias-controlled dataset for pushing the limits of object recognition models. In Neural Information Processing Systems, 2019.
+
+Sara Beery, Grant van Horn, and Pietro Perona. Recognition in terra incognita. In European Conference on Computer Vision (ECCV), 2018.
+
+Antonio Criminisi, Patrick Pérez, and Kentaro Toyama. Region filling and object removal by exemplar-based image inpainting. In IEEE Transactions on Image Processing, 2004.
+
+Robert Geirhos, Patricia Rubisch, Claudio Michaelis, Matthias Bethge, Felix A. Wichmann, and Wieland Brendel. Imagenet-trained CNNs are biased towards texture; increasing shape bias improves accuracy and robustness. In International Conference on Learning Representations, 2019.
+
+Robert Geirhos, Jörn-Henrik Jacobsen, Claudio Michaelis, Richard Zemel, Wieland Brendel, Matthias Bethge, and Felix A. Wichmann. Shortcut learning in deep neural networks. In arXiv preprint arXiv:2004.07780, 2020.
+
+Michael Harville, Gaile Gordon, and John Woodfill. Foreground segmentation using adaptive mixture models in color and depth. In IEEE Workshop on Detection and Recognition of Events in Video, 2001.
+
+Kaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. Deep residual learning for image recognition. In Conference on Computer Vision and Pattern Recognition (CVPR), 2016.
+
+Andrew Ilyas, Shibani Santurkar, Logan Engstrom, Dimitris Tsipras, Brandon Tran, and Aleksander Madry. Adversarial examples are not bugs, they are features. In Neural Information Processing Systems (NeurIPS), 2019.
+
+Jorn-Henrik Jacobsen, Jens Behrmann, Richard Zemel, and Matthias Bethge. Excessive invariance causes adversarial vulnerability. In International Contemporary on Learning Representations (ICLR), 2019.
+
+Saumya Jetley, Nicholas Lord, and Philip Torr. With friends like these, who needs adversaries? In Advances in Neural Information Processing Systems (NeurIPS), 2018.
+
+Aditya Khosla, Tinghui Zhou, Tomasz Malisiewicz, Alexei A. Efros, and Antonio Torralba. Undoing the damage of dataset bias. In European Conference on Computer Vision (ECCV), 2012.
+
+George Miller. Wordnet: a lexical database for english. In Communications of the ACM, 1995.
+
+Choi Myung Jin, Antonio Torralba, and Alan S. Willsky. Context models and out-of-context objects. In Pattern Recognition Letters, 2012.
+
+Marco Tulio Ribeiro, Sameer Singh, and Carlos Guestrin. “why should i trust you?”: Explaining the predictions of any classifier. In International Conference on Knowledge Discovery and Data Mining, 2016.
+
+Alexander Robey, Hamed Hassani, and George J. Pappas. Model-based robust deep learning. In arXiv preprint arXiv:2005.10247, 2020.
+
+Amir Rosenfeld, Richard S. Zemel, and John K. Tsotsos. The elephant in the room. In arXiv preprint arXiv:1808.03305, 2018.
+
+Carsten Rother, Vladimir Kolmogorov, and Andrew Blake. Grabcut: Interactive foreground extraction using iterated graph cuts. In ACM Transactions on Graphics, 2004.
+
+Olga Russakovsky, Jia Deng, Hao Su, Jonathan Krause, Sanjeev Satheesh, Sean Ma, Zhiheng Huang, Andrej Karpathy, Aditya Khosla, Michael Bernstein, Alexander C. Berg, and Li Fei-Fei. Imagenet large scale visual recognition challenge. In International Journal of Computer Vision (IJCV), 2015.
+
+Shiori Sagawa, Pang Wei Koh, Tatsunori B. Hashimoto, and Percy Liang. Distributionally robust neural networks for group shifts: On the importance of regularization for worst-case generalization. In International Conference on Learning Representations, 2020.
+
+Rakshith Shetty, Mario Fritz, and Bernt Schiele. Adversarial scene editing: Automatic object removal from weak supervision. In Neural Information Processing Systems (NeurIPS), 2018.
+
+Rakshith Shetty, Bernt Schiele, and Mario Fritz. Not using the car to see the sidewalk–quantifying and controlling the effects of context in classification and segmentation. In Conference on Computer Vision and Pattern Recognition (CVPR), 2019.
+
+Mingxing Tan and Quoc V. Le. Efficientnet: Rethinking model scaling for convolutional neural networks. In International Conference on Machine Learning (ICML), 2019.
+
+Antonio Torralba. Contextual priming for object detection. In International Journal of Computer Vision (IJCV), 2003.
+
+Andrew W. Yip and Pawan Sinha. Contribution of color to face recognition. In Perception, 2002.
+
+Jiahui Yu, Zhe Lin, Jimei Yang, Xiaohui Shen, Xin Lu, and Thomas S. Huang. Generative image inpainting with contextual attention. In Conference on Computer Vision and Pattern Recognition (CVPR), 2018.
+
+Sergey Zagoruyko and Nikos Komodakis. Wide residual networks. In British Machine Vision Conference (BMVC), 2016.
+
+John R. Zech, Marcus A. Badgeley, Manway Liu, Anthony B. Costa, Joseph J. Titano, and Eric Karl Oermann. Variable generalization performance of a deep learning model to detect pneumonia in chest radiographs: A cross-sectional study. In PLoS Medicine, 2018.
+
+Jianguo Zhang, Marcin Marszalek, Svetlana Lazebnik, and Cordelia Schmid. Local features and kernels for classification of texture and object categories: A comprehensive study. In International Journal of Computer Vision (IJCV), 2007.
+
+Zhuotun Zhu, Lingxi Xie, and Alan Yuille. Object recognition without and without objects. In International Joint Conference on Artificial Intelligence, 2017.
+
+# A DATASETS DETAILS
+
+We choose the following 9 high-level classes.
+
+Table 4: The 9 classes of ImageNet-9.   
+
+<table><tr><td>Class</td><td>WordNet ID</td><td>Number of sub-classes</td></tr><tr><td>Dog</td><td>n02084071</td><td>116</td></tr><tr><td>Bird</td><td>n01503061</td><td>52</td></tr><tr><td>Vehicle</td><td>n04576211</td><td>42</td></tr><tr><td>Reptile</td><td>n01661091</td><td>36</td></tr><tr><td>Carnivore</td><td>n02075296</td><td>35</td></tr><tr><td>Insect</td><td>n02159955</td><td>27</td></tr><tr><td>Instrument</td><td>n03800933</td><td>26</td></tr><tr><td>Primate</td><td>n02469914</td><td>20</td></tr><tr><td>Fish</td><td>n02512053</td><td>16</td></tr></table>
+
+All datasets used in the paper are balanced by randomly removing images from classes that are over-represented. We only keep as many images as the smallest post-modification synthetic dataset, so all synthetic datasets (except IN-9L) have the same number of images. We also use a custom GUI to manually process the test set to improve data quality. For IN-9L, the only difference from using the corresponding classes in the original ImageNet dataset is that we balance the dataset.
+
+For all images: we apply the following filters before adding each image to our datasets.
+
+• The image must have bounding box annotations.   
+• For simplicity, each image must have exactly one bounding box. A large majority of images that have bounding box annotations satisfy this.
+
+For images needing a properly segmented foreground: This includes the 3 MIXED datasets, ONLY-FG, and NO-FG. We filter out images based on the following criteria.
+
+• Because images are cropped before they are fed into models, we require that less than $50 \%$ of the bounding box is removed by the crop, to ensure that the foreground still exists. Almost all images pass this filter. The OpenCV foreground segmentation function cv2.grabCut (used to extract the foreground shape) must work on the image. We remove images where it fails. For the test set only, we manually remove images with foreground segmentations that retain a significant portion of the background signal. For the test set only, we manually remove foreground segmentations that are very bad (e.g. the segmentation selects part of the image, and that part doesn’t contain the foreground object).
+
+For images needing only background signal: This includes ONLY-BG-B and ONLY-BG-T. In this case, we apply the following criteria:
+
+• The bounding box must not be too big (more than $90 \%$ of the image). The intent here is to avoid ONLY-BG-B images being just a large black rectangle.   
+• For the test set only, we manually remove ONLY-BG images that still have an instance of the class even after removing the bounding box. This occurs when the bounding boxes are imperfect or incomplete (e.g. only one of two dogs in an image is labeled with a bounding box).
+
+Creating the ONLY-BG-T dataset: We first make a “tiled” version of the background by finding the largest rectangular strip (horizontal or vertical) outside the bounding box, and tiling the entire image with that strip. We then replace the removed foreground with the tiled background. A visual example is provided in Figure 9. We purposefully choose not to use deep-learning-based inpainting techniques such as (Shetty et al., 2018) to replace the removed foreground, as such methods could lead to biases that the inpainting model has learned from the data. For example, an inpainting model may learn that the best way to inpaint a missing chunk of a flower is to place an insect there, which is something we want to avoid.
+
+![](images/02750bdf680ae94d36d8b368cc4f6893b2746d020b49b0f32582e96fca4ca0bb.jpg)  
+Figure 9: Visualization of how ONLY-BG-T is created.
+
+Motivation for each IN-9 variation: We create ONLY-BG-B and ONLY-BG-T to remove the foreground completely, including the shape of the foreground object. We intend for ONLY-BG-B to be directly comparable to the prior work of Zhu et al. (2017) that uses similar methodology to evaluate older AlexNet models, while ONLY-BG-T is a more natural-looking background that avoids black rectangles introduced in ONLY-BG-B.
+
+The NO-FG dataset is created to retain the foreground shape, but not the texture. We can use it to assess the relative importance of foreground shape compared to foreground texture.
+
+Finally, we create four datasets that have identical foregrounds but each have distinct background signals. ONLY-FG has a pure black background to go with the foreground. MIXED-SAME has background signal from the same class as the foreground. MIXED-RAND has background signal from a random class, so it can be thought of as having neutral background signal. MIXED-NEXT has background signal from the next class, which will always be in conflict with the foreground . Any artifacts in the foreground that result from our image processing pipeline are equally present in all four datasets. Thus, these datasets help to isolate how much backgrounds alone influence model predictions when the correct foreground exists in the image.
+
+Full-ImageNet version of each synthetic variation: We also apply the same methodology for disentangling foreground and background signal to the entire ImageNet validation set, creating Full-ImageNet (Full-IN) versions of each of our 7 dataset variations.
+
+We evaluate a pre-trained ResNet-50 on Full-IN for comparison in Table 5, and observe similar trends to ImageNet-9 that lead to similar conclusions on model background reliance. We choose to focus on ImageNet-9 results in the main paper because of the following shortcomings of Full-IN.
+
+1. Individual classes are quite small, as some classes have very few (or even zero) images that make it through our filters due to lack of proper annotated bounding boxes.   
+2. When bounding boxes do exist, their quality is often lower than those in the IN-9 classes. For example, many images of fruit contain multiple fruit, but only one will be properly annotated with a bounding box.   
+3. When creating the MIXED-NEXT equivalent for Full-IN, the next class is often similar to the previous one. For example, many dog breeds occur consecutively in ImageNet. Thus, Full-IN’s MIXED-NEXT frequently has backgrounds that are similar to backgrounds from the foreground class.
+
+# B EXPLAINING THE DECREASED BG-GAP OF PRE-TRAINED IMAGENET MODELS
+
+We investigate two possible explanations for why pre-trained ImageNet models have a smaller BGGAP than models trained on ImageNet-9. Understanding this phenomenon can help inform how models should be trained to be more background-robust. We find slight improvements to backgroundrobustness from training on more fine-grained classes. We find that training on larger datasets helps only slightly when the training dataset set size is smaller than IN-9L, but larger improvements occur when the training dataset size is bigger. Thus, we encourage training on larger datasets if reduced background robustness is the goal.
+
+# B.1 THE EFFECT OF FINE-GRAINEDNESS ON THE BG-GAP
+
+One possible explanation is that training models to distinguish between finer-grained classes forces them to focus more on the foreground, which contains relevant features for making those fine-grained distinctions, than the background, which may be fairly similar across sub-classes of a high-level class. This suggests that asking models to solve more fine-grained tasks could improve model robustness to background changes.
+
+To test the effect of fine-grainedness on ImageNet-9, we make a related dataset called IN-9LB that uses the same 9 high-level classes and can be cleanly modified into more fine-grained versions. Specifically, for IN-9LB we choose exactly 16 sub-classes for each high-level class, for a total of 144 ImageNet classes. To create successively more fine-grained versions of the IN-9LB dataset, we group every $n$ sub-classes together into a higher-level class, for $n \in \{ 1 , 2 , 4 , 8 , 1 6 \}$ . Here, $n = 1$ corresponds to keeping all 144 ImageNet classes as they are, while $n = 1 6$ corresponds to only having 9 high-level classes, like ImageNet-9. Because we keep all images from those original ImageNet classes, this dataset is the same size as IN-9L.
+
+We train models on IN-9LB at different levels of fine-grainedness and evaluate the BG-GAP of those models in Figure 10. We find that fine-grained models have a smaller BG-GAP as well as better performance on MIXED-NEXT, but the improvement is very slight and also comes at the cost of decreased accuracy on ORIGINAL. The BG-GAP of the most fine-grained classifier is $2 . 3 \%$ smaller than the BG-GAP of the most coarse-grained classifier, showing that fine-grainedness does improve background-robustness. However, the improvement is still small compared to the size of the BG-GAP (which is $1 3 . 3 \%$ for the fine-grained classifier).
+
+# B.2 THE EFFECT OF LARGER DATASET SIZE ON THE BG-GAP
+
+A second possible explanation for why pre-trained ImageNet models have a smaller BG-GAP is that training on larger datasets is important for background-robustness. To evaluate this possibility, we train models on different-sized subsets of IN-9LB. The largest dataset we train on is the full IN-9LB dataset, which is 4 times as large as IN-9, and the smallest is 1/4 as large as IN-9. Figure 11 shows that increasing the dataset size does increase overall performance but only slightly decreases the BG-GAP.
+
+Next, we train models on different-sized subsets of ImageNet; we use the pre-trained ResNet-50 ImageNet model for full-sized ImageNet, and we train new ResNet-50 models on subsets that are 1/2, 1/4, 1/8, 1/16, and 1/32 as large as ImageNet. In these cases, we observe in Figure 12 that training on more data does not help significantly when the training dataset sizes are still small, but it does help more noticeably for models trained on $1 / 2$ of ImageNet and all of ImageNet.
+
+It is possible that having both a fine-grained class structure and more training data simultaneously is important for background-robustness. Furthermore, more training data (from other classes that are not in IN-9L) may also be the cause of the increased background-robustness of pre-trained ImageNet models.
+
+# B.3 SUMMARY OF METHODS INVESTIGATED TO REDUCE THE BG-GAP
+
+In Figure 13, we compare the BG-GAP of ResNet-50 models trained on different datasets and with different methods to a ResNet-50 pre-trained on ImageNet. We explore $\ell _ { p }$ -robust training, increasing dataset size, and making the classification task more fine-grained, and find that none of these methods reduces the BG-GAP as much as pre-training on ImageNet. The only method that reduces the BG-GAP significantly more is training on MIXED-RAND. Furthermore, the same trends hold true if we measure the difference between MIXED-SAME and MIXED-NEXT as opposed to the BG-GAP (the difference between MIXED-SAME and MIXED-RAND).
+
+![](images/016bb24b63fa3298d195117c9d6a9788565b3f7dbe82b00e7b47189f3314c63c.jpg)  
+Figure 10: We train models on IN-9LB at different levels of fine-grainedness (more training classes is more fine-grained). The BG-GAP, or the difference between the test accuracies on MIXED-SAME and MIXED-RAND, decreases as we make the classification task more fine-grained, but the decrease is small compared to the size of the BG-GAP.
+
+![](images/265fbe3f78498cc560496ef38ce52ead5f21923775b58fbd2419079d9be8c0c4.jpg)  
+Figure 11: We train models on different-sized subsets of IN-9LB. The largest training set we use is the full IN-9LB dataset, which is 4 times larger than ImageNet-9. While performance on all test datasets improves as the amount of training data increases, the BG-GAP has almost the same size regardless of the amount of training data used.
+
+![](images/c31e2c14dc6cbce259c9b4de5db5d8a4d8d7ab98e6844b17808bccb3d56d6b65.jpg)  
+Figure 12: We train models on different-sized subsets of ImageNet. We use a pre-trained ResNet-50 for the rightmost datapoints corresponding to training on the full ImageNet dataset, which is about 30 times larger than ImageNet-9. The BG-GAP begins to decrease when the training dataset set size is sufficiently large.
+
+![](images/77fb8acd18b0401a966745975e93b2c823a86bcb9bf2ccdb343c0252d8ff8d8d.jpg)  
+Mixed-Same vs. Mixed-Rand Accuracy for Different Models   
+Figure 13: We compare various different methods of training models and measure their BG-GAP, or the difference between MIXED-SAME and MIXED-RAND test accuracy. We find that (1) Pretrained IN models have surprisingly small BG-GAP. (2) Increasing fine-grainedness (IN-9LB Coarse vs. IN-9LB Fine) and dataset size (IN-9 vs. IN-9L) decreases the BG-GAP only slightly. (3) $\ell _ { p }$ -robust training does not help. (4) Training on MIXED-RAND (cf. Section 3 appears to be the most effective strategy for reducing the BG-GAP. For such a model, the MIXED-SAME and MIXED-RAND accuracies are nearly identical.
+
+# C TRAINING AND EVALUATION DETAILS
+
+For all models, we use fairly standard training settings for ImageNet-style models. We train for 200 epochs using SGD with a batch size of 256, a learning rate of 0.1 (with learning rate drops every 50 epochs), a momentum parameter of 0.9, a weight decay of 1e−4, and data augmentation (random resized crop, random horizontal flip, and color jitter). Unless specified, we always use a standard ResNet-50 architecture (He et al., 2016). For the experiment depicted in Figure 11, we found that using a smaller learning rate of 0.01 was necessary for training to converge on the smallest training sets. Thus, we used that same learning rate for all models in Figure 11.
+
+When evaluating ImageNet classifiers on IN-9, we map all ImageNet predictions to their corresponding coarse-grained class in IN-9. For example, we map both giant schnauzer and Irish terrier to dog, and both goldfish and tiger shark to FISH. If an ImageNet classifier outputs a class that has no corresponding coarse-grained class in IN-9, we consider the prediction incorrect.
+
+# D ADDITIONAL EVALUATION RESULTS
+
+We include full results of training models on every synthetic IN-9 variation and then testing them on every synthetic IN-9 variation in Table 5. In addition to being more comprehensive, this table and these IN-9 variations can help answer a variety of questions, of which we provide three examples here. Finally, we also evaluate a pre-trained model on Full-ImageNet (Full-IN) versions of each synthetic IN-9 variation for comparison.
+
+# How does more training data affect model performance with and without object shape?
+
+We already show closely related results on the effect of more training data on the BG-GAP in Figure 11. Here, we compare model test performance on the NO-FG and ONLY-BG-B test sets. Both replace the foreground with black, but only NO-FG retains the foreground shape.
+
+By comparing the models trained on ORIGINAL and IN-9L (4x more training data), we find that
+
+1. The ORIGINAL-trained model performs about $9 \%$ better on NO-FG than ONLY-BG-B, indicating that it can slightly improve accuracy by using object shape. 2. The IN-9L-trained model performs about $22 \%$ better on NO-FG than ONLY-BG-B, showing that it can improve accuracy far more by using object shape.
+
+Furthermore, both models perform very similarly on ONLY-BG-B. Thus, this suggests that more training data may allow models to learn to use object shape more effectively. Understanding this phenomena further could help inform model training and dataset collection if the goal is to train models that are able to leverage shape effectively.
+
+# How much information is leaked from the size of the foreground bounding box?
+
+The scale of an object already gives signal correlated with the object class (Torralba, 2003). Even though they are designed to avoid having foreground signal, the background-only datasets ONLYBG-B and ONLY-BG-T may inadvertently leak information about object scale due to the bounding box sizes being recognizable.
+
+To gauge the extent of this leakage, we can measure how models trained on datasets where only the foreground signal has useful correlation (MIXED-RAND or ONLY-FG) perform on the backgroundonly test sets. We find that there is small signal leakage from bounding box size alone—a model trained on ONLY-FG achieves about $23 \%$ background-only test accuracy, suggesting that it is able to exploit the signal leakage to some degree. A model trained on MIXED-RAND achieves about $15 \%$ background-only test accuracy, just slightly better than random, perhaps because it is harder for models to measure (and thus, make use of) object scale when training on MIXED-RAND.
+
+The existence of a small amount of information leakage in this case shows the importance of comparing MIXED-SAME (as opposed to just ORIGINAL) with MIXED-RAND and MIXED-NEXT when assessing model dependence on backgrounds. Indeed, the MIXED datasets may contain (1) image processing artifacts, such as rough edges from the foreground processing, and (2) small traces of the original background. This makes it important to control for both factors when measuring how models react to varying background signal.
+
+![](images/ec5f8124f05ad3b2dff8ae50a7db2b018ace3067938b5cf55443fafd5933dbb4.jpg)  
+Figure 14: Comparing model accuracy on ONLY-BG-T across different foreground object bounding box sizes. We observe that the model is more likely to succeed when shown only image backgrounds if the removed foreground objects have smaller bounding boxes. The dotted line represents the overall accuracy of the model on ONLY-BG-T (averaged over all bounding box sizes).
+
+# How does foreground bounding box size affect accuracy on ONLY-BG-T?
+
+We further find that models are more able to predict accurately using the background signal alone when the foreground object is smaller—this is visualized in Figure 14. Intuitively this result makes sense, as most state-of-the-art models are trained with cropping-based data augmentation, which can remove small foreground objects from training images. Thus, models are actually trained to succeed when small foreground objects are cropped out, and our toolkit confirms that this is indeed the case.
+
+<table><tr><td rowspan="2">Trained on</td><td colspan="7">Test Dataset</td><td rowspan="2"></td><td rowspan="2">IN-9L</td></tr><tr><td>MIXED-NEXT</td><td>MIXED-RAND</td><td>MIXED-SAME</td><td>No-FG</td><td>ONLY-BG-B</td><td>ONLY-BG-T</td><td>ONLY-FG ORIGINAL</td></tr><tr><td>MIXED-NEXT</td><td>78.07</td><td>53.28</td><td>48.49</td><td>16.20</td><td>11.19</td><td>8.22</td><td>59.60</td><td>52.32</td><td>46.44</td></tr><tr><td>MIXED-RAND</td><td>71.09</td><td>71.53</td><td>71.33</td><td>26.72</td><td>15.33</td><td>14.62</td><td>74.89</td><td>73.23</td><td>67.53</td></tr><tr><td>MIXED-SAME</td><td>45.41</td><td>51.36</td><td>74.40</td><td>39.85</td><td>35.19</td><td>41.58</td><td>61.65</td><td>75.01</td><td>69.21</td></tr><tr><td>No-FG</td><td>13.70</td><td>18.74</td><td>42.79</td><td>70.91</td><td>36.79</td><td>42.52</td><td>31.48</td><td>48.94</td><td>47.62</td></tr><tr><td>ONLY-BG-B</td><td>10.35</td><td>15.41</td><td>38.37</td><td>37.85</td><td>54.30</td><td>42.54</td><td>21.38</td><td>42.10</td><td>41.01</td></tr><tr><td>ONLY-BG-T</td><td>11.48</td><td>17.09</td><td>45.80</td><td>40.84</td><td>38.49</td><td>50.25</td><td>19.19</td><td>49.06</td><td>47.94</td></tr><tr><td>ONLY-FG</td><td>33.04</td><td>35.88</td><td>47.63</td><td>27.90</td><td>23.58</td><td>22.59</td><td>84.20</td><td>54.62</td><td>51.50</td></tr><tr><td>ORIGINAL</td><td>48.77</td><td>53.58</td><td>73.80</td><td>42.22</td><td>32.94</td><td>40.54</td><td>63.23</td><td>85.95</td><td>80.38</td></tr><tr><td>IN-9L</td><td>71.21</td><td>75.60</td><td>89.90</td><td>55.78</td><td>34.02</td><td>43.60</td><td>84.12</td><td>96.32</td><td>94.61</td></tr><tr><td>ImageNet</td><td>82.99</td><td>84.32</td><td>90.99</td><td>52.69</td><td>12.69</td><td>17.36</td><td>90.17</td><td>96.89</td><td>95.33</td></tr><tr><td>ImageNet (Full-IN)</td><td>51.47</td><td>48.69</td><td>64.34</td><td>21.70</td><td>7.98</td><td>9.51</td><td>59.19</td><td>76.07</td><td>-</td></tr></table>
+
+Table 5: The test accuracies, in percentages, of ResNet-50 models trained on all variants of ImageNet9, and a pre-trained ImageNet ResNet-50. The bottom row and the second-to-last-row test the same pre-trained ImageNet model; however, the bottom row tests the model on the Full-IN version of each dataset variation. Testing on Full-IN shows similar trends as testing on ImageNet-9. Note that the MIXED-NEXT test accuracy is actually higher than the MIXED-RAND test accuracy in the bottom row because the next class is often very similar to the previous class in Full-IN.
+
+# What about other ways of modifying the background signal?
+
+One can modify the background in various other ways—for example, instead of replacing the background with black as in ONLY-FG, the background can be blurred as in the BG-BLURRED image of Figure 15. As expected, blurred backgrounds are still slightly correlated with the correct class. Thus, test accuracies for standard models on this dataset are higher than on ONLY-FG, but lower than on MIXED-SAME (which has signal from random class-aligned backgrounds that are not blurred). While we do not investigate all possible methods of modifying background signal, we believe that the variations we do examine in ImageNet-9 already improve our understanding of how background signals matter. Investigating other variations could provide an even more nuanced understanding of what parts of the background are most important.
+
+![](images/1f3caf29239940996696ea65f147de7240e4a9c9c745dd4b1418d9e99de3285b.jpg)  
+Figure 15: Backgrounds can also be modified in other ways; for example, it can be blurred. Our evaluations on this dataset show similar results.
+
+# E ADDITIONAL RELATED WORKS AND EXPLICIT COMPARISONS
+
+There has been prior work on mitigating contextual bias in image classification, the influence of background signals on various datasets, and techniques like foreground segmentation that we leverage.
+
+Mitigating Contextual Bias: (Khosla et al., 2012) focuses on mitigating dataset-specific contextual bias and proposes learning SVMs with both general weights and dataset-specific weights, while (Myung Jin et al., 2012) creates an out-of-context detection task with 209 out-of-context images and suggests using graphical models to solve it. (Shetty et al., 2019) focuses on the role of cooccurring objects as context in the MS-COCO dataset, and uses object removal to show that (a) models can still predict a removed object when only co-occurring objects are shown, and (b) special data-augmentation can mitigate this.
+
+Explicit Comparison to Prior Works Studying the Influence of Backgrounds: In comparison to prior works on the influence of image backgrounds (described in Section 5), our work contributes the following.
+
+• We develop a toolkit for analyzing the background dependence of ImageNet classifiers, the most common benchmark for computer vision progress. Only (Zhu et al., 2017), which we compare to in Section 5, also focuses on ImageNet. The test datasets we create separate and mix foreground and background signals in various ways (cf. Table 1), allowing us to study the sensitivity of models to these signals in a more fine-grained manner. Our toolkit for separating foreground and background can be applied without humanannotated foreground segmentation, which prior works on MS-COCO and Waterbirds rely on. This is important because foreground segmentation annotations are hard to collect and do not exist for ImageNet.   
+• We study the extent of background dependence in the extreme case of adversarial backgrounds.   
+• We focus on better vision models, including ResNet (He et al., 2016), Wide ResNet(Zagoruyko & Komodakis, 2016), and EfficientNet (Tan & Le, 2019).   
+• We evaluate how improvements on the ImageNet benchmark have affected background dependence (cf. Section 4). We will publicly release our toolkit (code and datasets) for benchmarking background dependence so that others can also use it to better understand their own models. Our toolkit is compatible with any ImageNet-trained model.
+
+Foreground Segmentation and Image Inpainting: In order to create IN-9 and its variants, we rely on OpenCV’s implementation of the foreground segmentation algorithm GrabCut (Rother et al.,
+
+2004). Foreground segmentation is a branch of computer vision that seeks to automatically extract the foreground from an image (Harville et al., 2001). After finding the foreground, we remove it and simply replace the foreground with copies of parts of the background. Other works solve this problem, called image inpainting, either using exemplar-based methods (Criminisi et al., 2004) or using deep learning Yu et al. (2018); Shetty et al. (2018). (Shetty et al., 2018) both detects the foreground for removal and inpaints the removed region. However, more advanced inpaintings techniques can be slow and inaccurate when the region that must be inpainted is relatively large (Shetty et al., 2018), which is the case for many ImageNet images. Exploring better ways of segementing the foreground and inpainting the removed foreground could improve our analysis toolkit further.
+
+# F ADDITIONAL EXAMPLES OF SYNTHETIC DATASETS
+
+We randomly sample an image from each class, and display all synthetic variations of that image, as well as the predictions of a pre-trained ResNet-50 (trained on IN-9L) on each variant.
+
+![](images/c924a9c55b3e6bd07b49e111a60b770e6e386cc276796c073fbc614d8f679fb4.jpg)  
+Figure 16: ImageNet-9 variations—Dog.
+
+![](images/cf3f7eb68c748c80aa4c4a3b669f21fcfd02f69892bc6e20394e9bab603ae1da.jpg)  
+Figure 17: ImageNet-9 variations—Bird.
+
+![](images/9b2aef1d6412ea678772268879d1d934d1a97652bfb61acbdc72d12069ff2786.jpg)  
+Figure 18: ImageNet-9 variations—Vehicle.
+
+![](images/6ade084d43d689ccaa03e1e9f38bfb8208cc10fec44f78afb4a08878d054fd5e.jpg)  
+Figure 19: ImageNet-9 variations—Reptile.
+
+![](images/c1eb336dc22ff03a50ba457584d78b7e8695369b313a7152ef183fadbca43966.jpg)  
+Figure 20: ImageNet-9 variations—Carnivore.
+
+![](images/9f449cc64fe3338fb1951947b0892df6ddc81a2d1a8c8cd4893a31174c021af5.jpg)  
+Figure 21: ImageNet-9 variations—Instrument.
+
+![](images/7b8077c01878794251e63ce6a8989a6077de391d35554b2d95522f8459bf4cfd.jpg)  
+Figure 22: ImageNet-9 variations—Primate.
+
+![](images/c09596a8ea723dca937a7dffcb38c7fa1b58d53f4c673815f69bd04c885b96e3.jpg)  
+Figure 23: ImageNet-9 variations—Fish.
+
+![](images/edf8af1e23a124aee3888c17bbdeed2d3c46db7a0da8bbe4dc7399fa5c411a5d.jpg)  
+Figure 24: Histogram of insect backgrounds grouped by how often they cause (non-insect) foregrounds to be classified as insect by a IN-9L-trained model. We visualize the five backgrounds that fool the classifier on the largest percentage of images in Figure 4.
+
+# G ADVERSARIAL BACKGROUNDS
+
+We compute the adversarial background attack success rate for 4 models in Table 6. While the MIXED-RAND model is more adversarially background robust than the ORIGINAL model, it is less adversarially background robust than the IN-9L model. The model trained on all of ImageNet is the most adversarially background robust of all models. This suggests that increasing training dataset size (IN-9L) has a bigger effect on adversarial background robustness than randomizing backgrounds during training (MIXED-RAND). On the other hand, the MIXED-RAND model has a much lower BG-GAP than the IN-9L model, indicating that models with a smaller BG-GAP are not necessarily robust to adversarial backgrounds, and vice versa.
+
+<table><tr><td>Training Dataset |ORIGINAL</td><td></td><td>MIXED-RAND</td><td>IN-9L</td><td>ImageNet</td></tr><tr><td>Attack Success Rate</td><td>99.0%</td><td>93.5%</td><td>88.0%</td><td>77.7%</td></tr></table>
+
+Table 6: Adversarial backgrounds attack success rates for 4 models analyzed in this paper. The ORIGINAL and the MIXED-RAND are trained on equally small datasets, IN-9L is trained on $4 \mathbf { x }$ more data, and the ImageNet model is trained on the most data.
+
+Next, we visualize the attack success rate distribution of the different backgrounds from the insect class in Figure 24. The long tail of the distribution indicates that many backgrounds are especially capable of fooling models.
+
+Finally, we include the 5 most fooling backgrounds for all classes, the fool rate for each of those 5 backgrounds, and the total fool rate across all backgrounds from that class (on the left of each row) below.
+
+![](images/4f07b5a203b6ce76cf0662fa6875b387c2fd5b722b2aa4c9e52031760b9cfcc9.jpg)  
+Figure 25: Most adversarial backgrounds—Dog.
+
+![](images/b3db98680e9d06fb8e11ff829208e14e474e255f2bb437fa3961b7b6cdf20df0.jpg)  
+Figure 26: Most adversarial backgrounds—Bird.
+
+![](images/85f64cb15f5d4c38ab1d1b25dd4b585a0dff59ef3614be337885294cd7de7332.jpg)  
+Figure 27: Most adversarial backgrounds—Vehicle.
+
+![](images/892f1f1b94579f96e557ab1e8efea7a276d17bf96b6cd9673e7a5bdd3f939d4a.jpg)  
+Figure 28: Most adversarial backgrounds—Reptile.
+
+![](images/e641edd9f6e185e5c2839c43667d7e244346fd2bc78e33a175f9a713e7509abf.jpg)  
+Figure 29: Most adversarial backgrounds—Carnivore.
+
+![](images/c4275d2c278c4f0d83f40fd9ae95d97c0f5e7db66d759b623cbd343e7a677d98.jpg)  
+Figure 30: Most adversarial backgrounds—Instrument.
+
+![](images/bdd1a0fdf417684f6d28119cc5ace1c358fa962a6eb904d5a2683a744923f7ea.jpg)  
+Figure 31: Most adversarial backgrounds—Primate.
+
+![](images/7fc4839c382e661cb531f173ef2da7ce7085fd249bd9504acee3fcec107beff4.jpg)  
+Figure 32: Most adversarial backgrounds—Fish.
+
+# H EXAMPLES OF FOOLING BACKGROUNDS IN UNMODIFIED IMAGES
+
+We visualize examples of images where the background of the full original image actually fools models in Figure 33. For these images, models classify the foreground alone correctly, but they predict the same wrong class on the full image and the background. We denote these images as “BG Fools” in Table 3 and Figure 7. While this category is relatively rare (accounting for just $3 \%$ of the ORIGINAL-trained model’s predictions), they reveal a subset of original images where background signal hurts classifier performance. Qualitatively, we observe that these images all have confusing or misleading backgrounds.
+
+![](images/c5ea85335c3fbbb759e04732674002f24dfd57524653bd705592cc50d7948a8c.jpg)  
+Figure 33: Images that are incorrectly classified (as the class on the top row, which is the same class that their background alone from ONLY-BG-T is classified as), but are correctly classified (as the class on the bottom row) when the background is randomized. Note that these images have confusing backgrounds that could be associated with another class.

parse/train/roNqYL0_XP/roNqYL0_XP.md

@@ -0,0 +1,354 @@
+# LEARNING MESH-BASED SIMULATION WITH GRAPH NETWORKS
+
+Tobias Pfaff∗, Meire Fortunato∗, Alvaro Sanchez-Gonzalez∗, Peter W. Battaglia Deepmind, London, UK {tpfaff,meirefortunato,alvarosg,peterbattaglia}@google.com
+
+# ABSTRACT
+
+Mesh-based simulations are central to modeling complex physical systems in many disciplines across science and engineering. Mesh representations support powerful numerical integration methods and their resolution can be adapted to strike favorable trade-offs between accuracy and efficiency. However, highdimensional scientific simulations are very expensive to run, and solvers and parameters must often be tuned individually to each system studied. Here we introduce MESHGRAPHNETS, a framework for learning mesh-based simulations using graph neural networks. Our model can be trained to pass messages on a mesh graph and to adapt the mesh discretization during forward simulation. Our results show it can accurately predict the dynamics of a wide range of physical systems, including aerodynamics, structural mechanics, and cloth. The model’s adaptivity supports learning resolution-independent dynamics and can scale to more complex state spaces at test time. Our method is also highly efficient, running 1-2 orders of magnitude faster than the simulation on which it is trained. Our approach broadens the range of problems on which neural network simulators can operate and promises to improve the efficiency of complex, scientific modeling tasks.
+
+# 1 INTRODUCTION
+
+State-of-the art modeling of complex physical systems, such as deforming surfaces and volumes, often employs mesh representations to solve the underlying partial differential equations (PDEs). Mesh-based finite element simulations underpin popular methods in structural mechanics [31, 48], aerodynamics [13, 34], electromagnetics [32], geophysics [35, 39], and acoustics [26]. Meshes also support adaptive representations, which enables optimal use of the resource budget by allocating greater resolution to regions of the simulation domain where strong gradients are expected or more accuracy is required, such as the tip of an airfoil in an aerodynamics simulation. Adaptive meshing enables running simulations at accuracy and resolution levels impossible with regular discretization schemes [8, 27] (Figure 3b).
+
+Despite their advantages, mesh representations have received relatively little attention in machine learning. While meshes are sometimes used for learned geometry processing [9] and generative models of shapes [15, 29], most work on predicting high-dimensional physical systems focuses on grids, owing to the popularity and hardware support for CNN architectures [19]. We introduce a method for predicting dynamics of physical systems, which capitalizes on the advantages of adaptive mesh representations. Our method works by encoding the simulation state into a graph, and performing computations in two separate spaces: the mesh-space, spanned by the simulation mesh, and the Euclidean world-space in which the simulation manifold is embedded (see Figure 3a). By passing messages in mesh-space, we can approximate differential operators that underpin the internal dynamics of most physical systems. Message-passing in world-space can estimate external dynamics, not captured by the mesh-space interactions, such as contact and collision. Unstructured irregular meshes, as opposed to regular grids, support learning dynamics which are independent of resolution, allowing variable resolution and scale at runtime. By learning a map of desired resolution over the mesh (sizing field), together with a local remesher, our method can even adaptively change the discretization during rollouts, budgeting greater computational resources for important regions of the simulation domain.
+
+![](images/9bf83b12b8da5451859bf6bddc7ff6a957771840f9ae98c5ca7bf37ad778f210.jpg)  
+Figure 1: Diagram of MESHGRAPHNETS operating on our SPHEREDYNAMIC domain (video). The model uses an Encode-Process-Decode architecture trained with one-step supervision, and can be applied iteratively to generate long trajectories at inference time. The encoder transforms the input mesh $M ^ { t }$ into a graph, adding extra world-space edges. The processor performs several rounds of message passing along mesh edges and world edges, updating all node and edge embeddings. The decoder extracts the acceleration for each node, which is used to update the mesh to produce $\cdot M ^ { t + 1 }$ .
+
+Together, our method allows us to learn the dynamics of vastly different physical systems, from cloth simulation over structural mechanics to fluid dynamics directly from data, providing only very general biases such as spatial equivariance. We demonstrate that by using mesh-space computation we can reliably model materials with a rest state such as elastics, which are challenging for meshfree prediction models [37]. MESHGRAPHNETS outperform particle- and grid-based baselines, and can generalize to more complex dynamics than those on which it was trained.
+
+# 2 RELATED WORK
+
+Modelling high-dimensional physics problems with deep learning algorithms has become an area of great research interest in fields such as computational fluid dynamics. High resolution simulations are often very slow, and learned models can provide faster predictions, reducing turnaround time for workflows in engineering and science [16, 6, 49, 20, 1]. Short run times are also a desirable property for fluid simulation in visualization and graphics [46, 41, 47]. Learned simulations can be useful for real-world predictions where the physical model, parameters or boundary conditions are not fully known [12]. Conversely, the accuracy of predictions can be increased by including specialized knowledge about the system modelled in the form of loss terms [43, 23], or by physics-informed feature normalization [40].
+
+The methods mentioned above are based on convolutional architectures on regular grids. Although this is by far the most widespread architecture for learning high-dimensional physical systems, recently there has been an increased interest in particle-based representations, which are particularly attractive for modelling the dynamics of free-surface liquids and granular materials. Ladicky et al. [22] use random forests to speed up liquid simulations. Various works [24, 42, 37] use graph neural networks (GNNs) [38, 4] to model particle-based granular materials and fluids, as well as glassy dynamics [3]. Learned methods can improve certain aspects of classical FEM simulations, e.g. more accurate handling of strongly nonlinear displacements [25] or learned elements which directly map between forces and displacements [10]. Finally, dynamics of high dimensional systems can be learned in reduced spaces. Holden et al. [18] performs PCA decomposition on cloth data, and learns a correction model to improve accuracy of subspace simulation. These models are however very domain-specific, and the expression range is limited due to the use of the linear subspace.
+
+![](images/56e2e90affdedb4c72754b4015b1e2d06f178cc64d1ff10fb604c0f67430b4eb.jpg)  
+Figure 2: Our model can predict dynamics of vastly different physical systems, from structural mechanics over cloth to fluid dynamics. We demonstrate this by simulating (a) a flag waving in the wind, (b) a deforming plate, (c) flow of water around a cylinder obstacle, and (d) the dynamics of air around the cross-section of an aircraft wing (videos). The color map shows the von-Mises stress in (b), and the $\mathbf { X }$ -component of the velocity field in (c),(d).
+
+There is increased attention in using meshes for learned geometry and shape processing [9, 29, 17]. But despite mesh-based simulations being the tool of choice in mechanical engineering and related disciplines, adaptive mesh representations have not seen much use in machine learning for physics prediction, with a few notable exceptions [5, 2]. Belbute-Peres et al. [5] embed a differentiable aerodynamics solver in a graph convolution (GCN) [21] prediction pipeline for super-resolution in aerodynamics predictions. Our method has similarities, but without a solver in the loop, which potentially makes it easier to use and adapt to new systems. In Section 5 we show that MESHGRAPHNETS are better suited for dynamical prediction than GCN-based architectures. Finally, Graph Element Networks [2] uses meshes over 2D grid domains to more efficiently compute predictions and scene representations. Notably they use small planar systems $\mathit { \Theta } _ { \mathrm { ~ < ~ } 5 0 }$ nodes), while we show how to scale mesh-based predictions to complex 3D systems with thousands of nodes.
+
+# 3 MODEL
+
+We describe the state of the system at time $t$ using a simulation mesh $M ^ { t } = ( V , E ^ { M } )$ with nodes $V$ connected by mesh edges $\cdot _ { E ^ { M } }$ . Each node $i \in V$ is associated with a reference mesh-space coordinate $\mathbf { u } _ { i }$ which spans the simulation mesh, and additional dynamical quantities $\mathbf { q } _ { i }$ that we want to model. Eulerian systems (Figure 2c,d) model the evolution of continuous fields such as velocity over a fixed mesh, and $\mathbf { q } _ { i }$ sample these fields at the mesh nodes. In Lagrangian systems, the mesh represents a moving and deforming surface or volume (e.g. Figure 2a,b), and contains an extra world-space coordinate $\mathbf { x } _ { i }$ describing the dynamic state of the mesh in 3D space, in addition to the fixed mesh-space coordinate $\mathbf { u } _ { i }$ (Figure 3a).
+
+# 3.1 LEARNING FORWARD DYNAMICS
+
+The task is to learn a forward model of the dynamic quantities of the mesh at time $t { + } 1$ given the current mesh $M ^ { t }$ and (optionally) a history of previous meshes $\{ M ^ { t - 1 } , . . . , M ^ { t - h } \}$ . We propose MESHGRAPHNETS, a graph neural network model with an Encode-Process-Decode architecture [4, 37], followed by an integrator. Figure 1 shows a visual scheme of the MESHGRAPHNETS architecture. Domain specific information on the encoding and integration can be found in Section 4.
+
+Encoder The encoder encodes the current mesh $M ^ { t }$ into a multigraph $G = ( V , E _ { . . } ^ { M } , E ^ { W } )$ . Mesh nodes become graph nodes $V$ , and mesh edges become bidirectional mesh-edges $E ^ { M }$ in the graph. This serves to compute the internal dynamics of the mesh. For Lagrangian systems, we add world edges $E ^ { W }$ to the graph, to enable learning external dynamics such as (self-) collision and contact, which are non-local in mesh-space.1 World-space edges are created by spatial proximity: that is, given a fixed-radius $r _ { W }$ on the order of the smallest mesh edge lengths, we add a world edge between nodes $i$ and $j$ if $\left| { \bf x } _ { i } - { \bf x } _ { j } \right| < r _ { W }$ , excluding node pairs already connected in the mesh. This encourages using world edges to pass information between nodes that are spatially close, but distant in mesh space (Figure 3a).
+
+![](images/9652e89452ab4bddaa7a1ad15ee2212c62c9e21528aac5cc1f68fef6939fdf06.jpg)  
+Figure 3: Simulation of a cloth interacting with a sphere. (a) In red, we highlight two nodes which are close in world-space but far in mesh-space, between which a world edge may be created. (b) With the same number of nodes, adaptive remeshing enables significantly more accurate simulations than a regular mesh with the same number of nodes.
+
+Next, we encode features into graph nodes and edges. To achieve spatial equivariance, positional features are provided as relative edge features. We encode the relative displacement vector in mesh space uij = ui −uj and its norm |uij | into the mesh edges eMij ∈ EM . Then, we encode the relative world-space displacement vector $\mathbf { x } _ { i j }$ and its norm $\left| { { \bf { x } } _ { i j } } \right|$ into both mesh edges ${ \mathbf e } _ { i j } ^ { M } \in E ^ { M }$ and world edges type, ${ \mathbf { e } } _ { i j } ^ { W } \in E ^ { W }$ . All remaining dynd as node features in ical features . $\mathbf { q } _ { i }$ , as well as a one-hot vector indicating node $\mathbf { v } _ { i }$
+
+Finally, the concatenated features and edge, using the encoder MLPs $\epsilon ^ { M } , \epsilon ^ { W } , \epsilon ^ { V }$ ncoded into a latfor mesh edges ${ \mathbf { e } } _ { i j } ^ { M }$ vector of size, world edges $\mathbf { e } _ { i j } ^ { W }$ 8 at each no, and nodes $\mathbf { v } _ { i }$ respectively. See sections 4 and A.1 for more details on input encoding.
+
+Processor The processor consists of $L$ identical message passing blocks, which generalize GraphNet blocks [36] to multiple edge sets. Each block contains a separate set of network parameters, and is applied in sequence to the output of the previous block, updating the mesh edge $\mathbf { \bar { e } } _ { i j } ^ { M }$ , world edge ${ \mathbf { e } } _ { i j } ^ { W }$ , and node $\mathbf { v } _ { i }$ embeddings to ${ \mathbf e } _ { i j } ^ { \prime M } , { \mathbf e } _ { i j } ^ { \prime W }$ $\mathbf { v } _ { \ i } ^ { \prime }$ respectively by
+
+$$
+\mathbf { e } ^ { \prime M } \gets f ^ { M } ( \mathbf { e } _ { i j } ^ { M } , \mathbf { v } _ { i } , \mathbf { v } _ { j } ) , \quad \mathbf { e } _ { i j } ^ { \prime W } \gets f ^ { W } ( \mathbf { e } _ { i j } ^ { W } , \mathbf { v } _ { i } , \mathbf { v } _ { j } ) , \quad \mathbf { v } _ { i } ^ { \prime } \gets f ^ { V } ( \mathbf { v } _ { i } , \sum _ { j } \mathbf { e } _ { i j } ^ { \prime M } , \sum _ { j } \mathbf { e } _ { i j } ^ { \prime W } )
+$$
+
+where $f ^ { M } , f ^ { W } , f ^ { V }$ are implemented using MLPs with a residual connection.
+
+Decoder and state updater For predicting the time $t { + } 1$ state from the time $t$ input, the decoder uses an MLP $\delta ^ { V }$ to transform the latent node features $\mathbf { v } _ { i }$ after the final processing step into one or more output features $\mathbf { p } _ { i }$ .
+
+We can interpret the output features $\mathbf { p } _ { i }$ as (higher-order) derivatives of $\mathbf { q } _ { i }$ , and integrate them using a forward-Euler integrator with $\Delta t = 1$ to compute the next-step dynamical quantity $\mathbf { q } _ { i } ^ { t + 1 }$ . For firstorder systems the output $\mathbf { p } _ { i }$ is integrated once to update $\mathbf { q } _ { i } ^ { t + 1 } = \mathbf { p } _ { i } + \mathbf { q } _ { i } ^ { t }$ , while for second-order integration happens twice: $\mathbf { q } _ { i } ^ { t + 1 } = \mathbf { p } _ { i } + 2 \mathbf { q } _ { i } ^ { t } - \mathbf { q } ^ { t - 1 }$ . Additional output features $\mathbf { p } _ { i }$ are also used to make direct predictions of auxiliary quantities such as pressure or stress. For domain-specific details on decoding, see Section 4. Finally, the output mesh nodes $V$ are updated using $\mathbf { q } _ { i } ^ { \mathsf { ^ { t + 1 } } }$ to produce $M ^ { t + 1 }$ . For some systems, we dynamically adapt the mesh after each prediction step; this is explained in the following section.
+
+# 3.2 ADAPTIVE REMESHING
+
+Adaptive remeshing algorithms generally consist of two parts: identifying which regions of the simulation domain need coarse or fine resolution, and adapting the nodes and their connections to this target resolution. Only the first part requires domain knowledge of the type of physical system, which usually comes in the form of heuristics. For instance, in cloth simulation, one common heuristic is the refinement of areas with high curvature to ensure smooth bending dynamics (Figure 3b), while in computational fluid dynamics, it is common to refine around wall boundaries where high gradients of the velocity field are expected.
+
+In this work we adopt the sizing field methodology [27]. The sizing field tensor $\mathbf { S } ( \mathbf { u } ) \in \mathbb { R } ^ { 2 \times 2 }$ specifies the desired local resolution by encoding the maximally allowed oriented, edge lengths in the simulation mesh. An edge $\mathbf { u } _ { i j }$ is valid if and only if $\mathbf { u } _ { i j } ^ { \mathrm { T } } \mathbf { S } _ { i } \mathbf { u } _ { i j } \leq 1$ , otherwise it is too long, and needs to be split2. Given the sizing field, a generic local remeshing algorithm can simply split all invalid edges to refine the mesh, and collapse as many edges as possible, without creating new invalid edges, to coarsen the mesh. We denote this remeshing process as $M ^ { \prime } = \mathcal { R } ( M , \mathbf { S } )$ .
+
+Learned remeshing To leverage the advantages in efficiency and accuracy of dynamic remeshing, we need to be able to adapt the mesh at test time. Since remeshing requires domain knowledge, we would however need to call the specific remesher used to generate the training data at each step during the model rollout, reducing the benefits of learning the model. Instead, we learn a model of the sizing field (the only domain-specific part of remeshing) using the same architecture as in Section 3.1 and train a decoder output $\mathbf { p } _ { i }$ to produce a sizing tensor for each node. At test time, for each time step we predict both the next simulation state and the sizing field, and use a generic, domainindependent remesher $\mathcal { R }$ to compute the adapted next-step mesh as $M ^ { t + 1 } = \mathcal { R } ( \bar { \hat { M } } ^ { t + 1 } , \hat { \mathbf { S } } ^ { t + 1 } )$ . We demonstrate this on triangular meshes, Section A.3 describes the simple generic remesher that we use for this purpose. While the sizing field is agnostic to the mesh type, other mesh types may require different local remeshers; for tetrahedral meshes a method such as Wicke et al. [45] could be used, while quad meshes can simply be split into triangular meshes.
+
+# 3.3 MODEL TRAINING
+
+We trained our dynamics model by supervising on the per-node output features $\mathbf { p } _ { i }$ produced by the decoder using a $L _ { 2 }$ loss between $\mathbf { p } _ { i }$ and the corresponding ground truth values $\bar { \bf p } _ { i }$ . Similarly, the sizing field model is trained with an $L _ { 2 }$ loss on the ground truth sizing field. If sizing information is not available in the training data, e.g. not exposed by the ground truth simulator, we can still estimate a compatible sizing field from samples of simulator meshes, and use this estimate as labels (details in Section A.3.1).
+
+# 4 EXPERIMENTAL DOMAINS
+
+We evaluated our method on a variety of systems with different underlying PDEs, including cloth, structural mechanics, incompressible and compressible fluids (Figure 2). Training and test data was produced by a different simulator for each domain. The simulation meshes range from regular to highly irregular: the edge lengths of dataset AIRFOIL range between $2 \cdot 1 0 ^ { - 4 } \mathrm { m }$ to $3 . 5 \mathrm { m }$ , and we also simulate meshes which dynamically change resolution over the course of a trajectory. Full details on the datasets can be found in Section A.1.
+
+Our structural mechanics experiments involve a hyper-elastic plate, deformed by a kinematic actuator, simulated with a quasi-static simulator (DEFORMINGPLATE). Both actuator and plate are part of the Lagrangian tetrahedral mesh, and are distinguished by a one-hot vector for the corresponding node type ${ \bf n } _ { i }$ . We encode the node quantities $\mathbf { u } _ { i } , \mathbf { x } _ { i } , \mathbf { n } _ { i }$ in the mesh, and predict the Lagrangian velocity $\dot { \mathbf { x } } _ { i }$ , which is integrated once to form the next position $\mathbf { x } _ { i } ^ { t + 1 }$ . As a second output, the model predicts the von-Mises stress $\sigma _ { i }$ at each node.
+
+Our cloth experiments involve a flag blowing in the wind (FLAGDYNAMIC) and a piece of cloth interacting with a kinematic sphere (SPHEREDYNAMIC) on an adaptive triangular mesh, which changes resolution at each time step. The dataset FLAGSIMPLE shares the setup of FLAGDYNAMIC, but uses a static mesh and ignores collisions. The node type ${ \bf n } _ { i }$ distinguishes cloth and obstacle/boundary nodes, and we encode inputs $\mathbf { u } _ { i } , \mathbf { x } _ { i } , \mathbf { n } _ { i }$ as above, but since this is a fully dynamic second order system, we additionally provide $h = 1$ steps of history, by including the velocity estimate $\dot { \mathbf { x } } _ { i } ^ { t } = \mathbf { x } _ { i } ^ { \dot { t } } - \mathbf { x } _ { i } ^ { t - 1 }$ as a node feature. The decoder outputs acceleration $\ddot { \mathbf { x } } _ { i }$ which is integrated twice.
+
+![](images/7481159f50fa36d34484f4276a339780c74c3f7fb1c696a8e48d70245dbec013.jpg)  
+Figure 4: (a) Rollout of our model versus ground truth on dataset AIRFOIL. Adaptive meshing allows us to accurately predict dynamics at large and small scales. The grid-based U-Net baseline is capable of making good predictions at large scales, but it cannot resolve the smaller scales, despite using four times more cells than our model (video). (b) At inference time, our model can be scaled up to significantly larger and more complex setups than seen during training (video).
+
+Our incompressible fluid experiments use the CYLINDERFLOW dataset, which simulates the flow of water around a cylinder on a fixed 2D Eulerian mesh. The mesh contains the node quantities $\mathbf { u } _ { i } , \mathbf { n } _ { i } , \mathbf { w } _ { i }$ , where $\mathbf { w } _ { i }$ is a sample of the momentum field at the mesh nodes. In all fluid domains, the node type distinguishes fluid nodes, wall nodes and inflow/outflow boundary nodes. The network predicts change in momentum $\dot { \mathbf { w } } _ { i }$ , which is integrated once, and a direct prediction of the pressure field $p$ .
+
+Our compressible fluid experiments use the AIRFOIL dataset, which simulates the aerodynamics around the cross-section of an airfoil wing. We model the evolution of momentum3 w and density $\rho$ fields, and hence the 2D Eulerian mesh encodes the quantities $\mathbf { u } _ { i } , \mathbf { n } _ { i } , \mathbf { w } _ { i } , \rho _ { i }$ . We treat this as a first order system and predict change in momentum $\dot { \mathbf { w } } _ { i }$ and density $\dot { \rho } _ { i }$ , as well as pressure $p _ { i }$ .
+
+# 5 RESULTS
+
+We tested our MESHGRAPHNETS model on our four experimental domains (Section 4), and compared it to three different baseline models. Our main findings are that MESHGRAPHNETS are able to produce high-quality rollouts on all domains, outperforming particle- and grid-based baselines, while being significantly faster than the ground truth simulator, and generalizing to much larger and more complex settings at test time.
+
+Videos of rollouts, as well as comparisons, can be found at https://sites.google.com/view/ meshgraphnets. Visually the dynamics remain plausible and faithful to the ground truth. Table 1 shows 1-step prediction and rollout errors in all of our datasets, while qualitative and quantitative comparisons are provided in Figure 4 and Figure 5. Even though our model was trained on next-step predictions, model rollouts remain stable for thousands of steps. This video shows a model trained on trajectories of 400 steps rolled out for 40000 steps.
+
+Learned remeshing We trained both a dynamics and a sizing field model to perform learned dynamic remeshing during rollout on FLAGDYNAMIC and SPHEREDYNAMIC. We compare learned remeshing variants with sizing model learned from labeled sizing data, as in Section 3.2, as well as from estimated targets, as in Section A.3.1. As a baseline, we ran our forward model on the ground truth mesh sequence. As observed in the video, all learned remeshing variants are able to shift the resolution to the new folds as they appear in the cloth, yield equally plausible dynamics, and are on $\mathrm { p a r } ^ { 4 }$ in terms of quantitative performance (Figure 5c). Thus, our learned remeshing method provides the benefits of adaptive remeshing, which can be substantive in some domains, without requiring a domain-specific remesher in the loop.
+
+![](images/17a069fe13c279d0e08381548bce8ad1205a7093897fbfb79c690d0a5bad8d8a.jpg)  
+Figure 5: (a) Our model outperforms GCN and CNN-based baselines. (b) GNS diverges on cloth datasets; providing mesh-space positions (GNS+mesh-pos) helps, but still fails on dynamic meshes. (c) Remeshing with learned or estimated sizing fields produces accurate rollouts. (d) Taking sufficient message passing steps is crucial for good performance, and limiting history size increases accuracy by preventing overfitting.
+
+Computational efficiency Our approach is consistently faster than ground truth solvers by one to two orders of magnitude on all domains (Table 1). We believe this is due to our model being able to take much larger timesteps than classical solvers, and avoiding performance bottlenecks. Additionally, classical general-purpose solvers on irregular domains, such as those studied in this paper, often do not scale well on hardware accelerators, while our model is built from neural network building blocks, highly suitable for hardware acceleration. A more detailed breakdown of performance on e.g. hardware setup is available in the appendix (section A.5.1). Our model’s strong efficiency advantage means it may be applicable in situations where computing costs are otherwise prohibitive.
+
+Generalization Our MESHGRAPHNETS model generalizes well outside of the training distribution, with respect to underlying system parameters, mesh shapes, and mesh size. This is because the architectural choice of using relative encoding on graphs has shown to be very conducive to
+
+<table><tr><td rowspan=1 colspan=1>Dataset</td><td rowspan=1 colspan=1># nodes(avg.)</td><td rowspan=1 colspan=1>#steps</td><td rowspan=1 colspan=1>tmodelms/step</td><td rowspan=1 colspan=1>tfullms/step</td><td rowspan=1 colspan=1>tGTms/step</td><td rowspan=1 colspan=1>RMSE1-step×10-3</td><td rowspan=1 colspan=1>RMSErollout-50×10-3</td><td rowspan=1 colspan=1>RMSErollout-all×10-3</td></tr><tr><td rowspan=1 colspan=1>FLAGSIMPLE</td><td rowspan=1 colspan=1>1579</td><td rowspan=1 colspan=1>400</td><td rowspan=1 colspan=1>19</td><td rowspan=1 colspan=1>19</td><td rowspan=1 colspan=1>4166</td><td rowspan=1 colspan=1>1.08 ± 0.02</td><td rowspan=1 colspan=1>92.6±5.0</td><td rowspan=1 colspan=1>139.0 ± 2.7</td></tr><tr><td rowspan=1 colspan=1>FLAGDYNAMIC</td><td rowspan=1 colspan=1>2767</td><td rowspan=1 colspan=1>250</td><td rowspan=1 colspan=1>43</td><td rowspan=1 colspan=1>837</td><td rowspan=1 colspan=1>26199</td><td rowspan=1 colspan=1>1.57 ± 0.02</td><td rowspan=1 colspan=1>72.4± 4.3</td><td rowspan=1 colspan=1>151.1 ± 5.3</td></tr><tr><td rowspan=1 colspan=1>SPHEREDYNAMIC</td><td rowspan=1 colspan=1>1373</td><td rowspan=1 colspan=1>500</td><td rowspan=1 colspan=1>32</td><td rowspan=1 colspan=1>140</td><td rowspan=1 colspan=1>1610</td><td rowspan=1 colspan=1>0.292±0.005</td><td rowspan=1 colspan=1>11.5± 0.9</td><td rowspan=1 colspan=1>28.3± 2.6</td></tr><tr><td rowspan=1 colspan=1>DEFORMINGPLATE</td><td rowspan=1 colspan=1>1271</td><td rowspan=1 colspan=1>400</td><td rowspan=1 colspan=1>24</td><td rowspan=1 colspan=1>33</td><td rowspan=1 colspan=1>2893</td><td rowspan=1 colspan=1>0.25±0.05</td><td rowspan=1 colspan=1>1.8 ± 0.5</td><td rowspan=1 colspan=1>15.1 ± 4.0</td></tr><tr><td rowspan=1 colspan=1>CYLINDERFLOW</td><td rowspan=1 colspan=1>1885</td><td rowspan=1 colspan=1>600</td><td rowspan=1 colspan=1>21</td><td rowspan=1 colspan=1>23</td><td rowspan=1 colspan=1>820</td><td rowspan=1 colspan=1>2.34 ± 0.12</td><td rowspan=1 colspan=1>6.3±0.7</td><td rowspan=1 colspan=1>40.88±7.2</td></tr><tr><td rowspan=1 colspan=1>AIRFOIL</td><td rowspan=1 colspan=1>5233</td><td rowspan=1 colspan=1>600</td><td rowspan=1 colspan=1>37</td><td rowspan=1 colspan=1>38</td><td rowspan=1 colspan=1>11015</td><td rowspan=1 colspan=1>314±36</td><td rowspan=1 colspan=1>582 ±37</td><td rowspan=1 colspan=1>11529 ± 1203</td></tr></table>
+
+Table 1: Left: Inference timings of our model per step on a single GPU, for pure neural network inference $\bf ( t _ { m o d e l } )$ and including remeshing and graph recomputation $\mathbf { \Pi } ( \mathbf { t } _ { \mathbf { f u l l } } )$ . Our model has a significantly lower running cost compared to the ground truth simulation $\mathbf { \Gamma } ( \mathbf { t } _ { \mathbf { G T } } )$ . A more detailed breakdown can be found in the section A.5.1. Right: Errors of our methods for a single prediction step (1-step), 50-step rollouts, and rollout of the whole trajectory.
+
+generalization [37]. Also, by forcing the network to make predictions on very irregularly-shaped and dynamically changing meshes, we encourage learning resolution-independent physics.
+
+In AIRFOIL, we evaluate the model on steeper angles $( - 3 5 ^ { \circ } . . . 3 5 ^ { \circ }$ vs $- 2 5 ^ { \circ } . . . 2 5 ^ { \circ }$ in training) and higher inflow speeds (Mach number 0.7...0.9 vs 0.2...0.7 in training). In both cases, the behavior remains plausible (video) and RMSE raises only slightly from 11.5 at training to 12.4 for steeper angles and 13.1 for higher inflow speeds. We also trained a model on a FLAGDYNAMIC variant with wind speed and directions varying between trajectories, but constant within each trajectory. At inference time, we can then vary wind speed and direction freely (video). This shows that the local physical laws our models learns can extrapolate to untrained parameter ranges.
+
+We also trained a model in the FLAGDYNAMIC domain containing only simple rectangular cloth, and tested its performance on three disconnected fish-shaped flags (video). Both the learned dynamics model and the learned remesher generalized to the new shape, and the predicted dynamics were visually similar to the ground truth sequence. In a more extreme version of this experiment, we test that same model on a windsock with tassels (Figure 4b, video). Not only has the model never seen a non-flat starting state during training, but the dimensions are also much larger — the mesh averages at $2 0 \mathrm { k }$ nodes, an order of magnitude more than seen in training. This result shows the strength of learning resolution and scale-independent models: we do not necessarily need to train on costly high-resolution simulation data; we may be able to learn to simulate large systems that would be too slow on conventional simulators, by training on smaller examples and scaling up at inference time. A more in-depth analysis on scaling can be found in the appendix A.5.3.
+
+Comparison to mesh-free GNS model We compared our method to the particle-based method GNS [37] on the fixed-mesh dataset FLAGSIMPLE to study the importance of mesh-space embedding and message-passing. As in GNS, the encoder builds a graph with fixed radius connectivity (10-20 neighbors per node), and relative world-space position embedded as edge features. As GNS lacks the notion of cloth’s resting state, error accumulates dramatically and the simulation becomes unstable, with slight improvements if providing 5 steps of history (Figure 5b).
+
+We also explored a hybrid method (GNS $+$ mesh-pos) which adds a mesh-space relative position feature $\mathbf { u } _ { i j }$ to the GNS edges. This yields rollout errors on par with our method (flattening after 50 steps due to decoherence in both cases), however, it tends to develop artifacts such as entangled triangles, which indicate a lack of reliable understanding of the mesh surface (video). On irregularly spaced meshes (FLAGSIMPLE), GNS+mesh-pos was not able to produce stable rollouts at all. A fixed connectivity radius will always oversample high-res regions, and undersample low-res regions of the mesh, leading to instabilities and high rollout errors (Figure 5b, right). We conclude that both having access to mesh-space positions as well as passing messages along the mesh edges are crucial for making predictions on irregularly spaced meshes.
+
+Conversely, we found that passing message purely in mesh-space, without any world-space edges, also produces substandard results. On FLAGDYNAMIC and SPHEREDYNAMIC we observe an increase in rollout RMSE of $5 1 \%$ and $9 2 \%$ respectively, as (self-)collisions are harder to predict without world edges. In the latter case this is particularly easy to see: the obstacle mesh and cloth mesh are not connected, so without world edges, the model cannot compute their interaction at all.
+
+Comparison to GCNs To study the role of the graph network architecture, we tested our model against GCNs [21], which do not compute messages on edges. We adopted the GCN architecture from Belbute-Peres et al. [5] (without the super-resolution component) and trained it in the same setup as in our approach, including e.g. training noise and integration. We replicated results on the aerodynamical steady-state prediction task it was designed for (see Section A.4.2). On the much richer AIRFOIL task, however, GCN was unable to obtain stable rollouts. This is not simply a question of capacity; we created a hybrid (GCN-MLP) with our model (linear layers replaced by 2-hidden-layer MLPs $^ +$ LayerNorm; 15 GCN blocks instead of 6), but the rollout quality was still poor (Figure 5a, video). We also ran an ablation of MESHGRAPHNETS without relative encoding in edges, for which absolute positional values are used as node features. This version performed much worse than our main model, yielding visual artifacts in the rollouts, and a rollout RMSE of 26.5 in AIRFOIL. This is consistent with our hypothesis that the GCN performs worse due to the lack of relative encoding and message computing, which makes the GCN less likely to learn local physical laws and more prone to overfitting.
+
+Comparison to grid-based methods (CNNs) Arguably the most popular methods for predicting physical systems are grid-based convolutional architectures. It is fundamentally hard to simulate Lagrangian deforming meshes with such methods, but we can compare to grid-based methods on the Eulerian 2D domains CYLINDERFLOW and AIRFOIL, by interpolating the ROI onto a $1 2 8 \times 1 2 8$ grid. We implemented the UNet architecture from Thurey et al. [ ¨ 40], and found that on both datasets, MESHGRAPHNETS outperforms the UNet in terms of RMSE (Figure 5a). While the UNet was able to make reasonable predictions on larger scales on AIRFOIL, it undersampled the important wake region around the wingtip (Figure 4a), even while using four times more cells to span a region 16 times smaller than our method (Figure A.1). We observe similar behavior around the obstacle in CYLINDERFLOW. Additionally, as seen in the video, the UNet tends to develop fluctuations during rollout. This indicates that predictions over meshes presents advantages even in flat 2D domains.
+
+Key hyperparameters We tested several architecture variants and found our method is not very sensitive to many choices, such as latent vector width, number of MLP layers and their sizes. Nonetheless we identified two key parameters which influence performance (Figure 5d). Increasing the number of graph net blocks (message passing steps) generally improves performance, but it incurs a higher computational cost. We found that a value of 15 provides a good efficiency/accuracy trade-off for all the systems considered. Second, the model performs best given the shortest possible history $\mathrm { h } { = } 1$ to estimate $\dot { \mathbf { x } }$ in cloth experiments, $\scriptstyle \mathrm { h = } 0$ otherwise), with any extra history leading to overfitting. This differs from GNS [37], which used $h \in 2 . . . 5$ for best performance.
+
+# 6 CONCLUSION
+
+MESHGRAPHNETS are a general-purpose mesh-based method which can accurately and efficiently model a wide range of physical systems, generalizes well, and can be scaled up at inference time. Our method may allow more efficient simulations than traditional simulators, and because it is differentiable, it may be useful for design optimization or optimal control tasks. Variants tailored to specific physical domains, with physics-based auxiliary loss terms, or energy-conserving integration schemes have the potential to increase the performance further. Finally, learning predictions on meshes opens the door for further work on resolution-adaptivity. For example, instead of learning adaptive meshing from ground truth data, we could learn a discretization which directly optimizes for prediction accuracy, or even performance on a downstream task. This work represents an important step forward in learnable simulation, and offers key advantages for modeling complex systems in science and engineering.
+
+# ACKNOWLEDGMENTS
+
+We would like to thank Danilo Rezende, Jonathan Godwin, Charlie Nash, Oriol Vinyals, Matt Hoffman, Kimberly Stachenfeld, Jessica Hamrick, Piotr Trochim, Emre Karagozler and our reviewers for valuable discussions, implementation help and feedback on the work and manuscript.
+
+# REFERENCES
+
+[1] MS Albergo, G Kanwar, and PE Shanahan. Flow-based generative models for markov chain monte carlo in lattice field theory. Physical Review D, 100(3):034515, 2019.   
+[2] Ferran Alet, Adarsh Keshav Jeewajee, Maria Bauza Villalonga, Alberto Rodriguez, Tomas Lozano-Perez, and Leslie Kaelbling. Graph element networks: adaptive, structured computation and memory. In International Conference on Machine Learning, pp. 212–222, 2019.   
+[3] V Bapst, T Keck, A Grabska-Barwinska, C Donner, ED Cubuk, SS Schoenholz, A Obika, AWR Nelson, T Back, D Hassabis, et al. Unveiling the predictive power of static structure in glassy systems (vol 16, pg 448, 2020). NATURE PHYSICS, 16(6):702–702, 2020.   
+[4] Peter W Battaglia, Jessica B Hamrick, Victor Bapst, Alvaro Sanchez-Gonzalez, Vinicius Zambaldi, Mateusz Malinowski, Andrea Tacchetti, David Raposo, Adam Santoro, Ryan Faulkner, et al. Relational inductive biases, deep learning, and graph networks. arXiv preprint arXiv:1806.01261, 2018.
+
+[5] Filipe de Avila Belbute-Peres, Thomas D. Economon, and J. Zico Kolter. Combining differentiable PDE solvers and graph neural networks for fluid flow prediction. In Proceedings of the 37th International Conference on Machine Learning ICML 2020, 2020.
+
+[6] Saakaar Bhatnagar, Yaser Afshar, Shaowu Pan, Karthik Duraisamy, and Shailendra Kaushik. Prediction of aerodynamic flow fields using convolutional neural networks. Computational Mechanics, 64(2):525–545, 2019.
+
+[7] Frank J Bossen and Paul S Heckbert. A pliant method for anisotropic mesh generation. In 5th Intl. Meshing Roundtable, pp. 63–74. Citeseer, 1996.
+
+[8] Ricardo Branco, FV Antunes, and JD Costa. A review on 3d-fe adaptive remeshing techniques for crack growth modelling. Engineering Fracture Mechanics, 141:170–195, 2015.
+
+[9] Michael M. Bronstein, Joan Bruna, Yann LeCun, Arthur Szlam, and Pierre Vandergheynst. Geometric deep learning: going beyond euclidean data. CoRR, abs/1611.08097, 2016.
+
+[10] German Capuano and Julian J Rimoli. Smart finite elements: A novel machine learning application. Computer Methods in Applied Mechanics and Engineering, 345:363–381, 2019.
+
+[11] Comsol. Comsol multiphysics $\textsuperscript { \textregistered }$ v. 5.4. http://comsol.com, 2020.
+
+[12] Emmanuel de Bezenac, Arthur Pajot, and Patrick Gallinari. Deep learning for physical processes: Incorporating prior scientific knowledge. Journal of Statistical Mechanics: Theory and Experiment, 2019(12):124009, 2019.
+
+[13] Thomas D Economon, Francisco Palacios, Sean R Copeland, Trent W Lukaczyk, and Juan J Alonso. Su2: An open-source suite for multiphysics simulation and design. Aiaa Journal, 54 (3):828–846, 2016.
+
+[14] Exxact. ANSYS Mechanical GPU Benchmarks. https://blog.exxactcorp.com/ ansys-mechanical-benchmarks-comparing-nvidia-rtx-6000-vs-tesla-v100s-gpu-vs-cpu-only, 2020.
+
+[15] Thibault Groueix, Matthew Fisher, Vladimir G Kim, Bryan C Russell, and Mathieu Aubry. A papier-mach ˆ e approach to learning 3d surface generation. In ´ Proceedings of the IEEE conference on computer vision and pattern recognition, pp. 216–224, 2018.
+
+[16] Xiaoxiao Guo, Wei Li, and Francesco Iorio. Convolutional neural networks for steady flow approximation. In Proceedings of the 22nd ACM SIGKDD international conference on knowledge discovery and data mining, pp. 481–490, 2016.
+
+[17] Rana Hanocka, Amir Hertz, Noa Fish, Raja Giryes, Shachar Fleishman, and Daniel Cohen-Or. Meshcnn: a network with an edge. ACM Transactions on Graphics (TOG), 38(4):1–12, 2019.
+
+[18] Daniel Holden, Bang Chi Duong, Sayantan Datta, and Derek Nowrouzezahrai. Subspace neural physics: Fast data-driven interactive simulation. In Proceedings of the 18th annual ACM SIGGRAPH/Eurographics Symposium on Computer Animation, pp. 1–12, 2019.
+
+[19] Sara Hooker. The hardware lottery. arXiv preprint arXiv:2009.06489, 2020.
+
+[20] Gurtej Kanwar, Michael S. Albergo, Denis Boyda, Kyle Cranmer, Daniel C. Hackett, Sebastien ´ Racaniere, Danilo Jimenez Rezende, and Phiala E. Shanahan. Equivariant flow-based sampling \` for lattice gauge theory. Phys. Rev. Lett., 125:121601, Sep 2020. doi: 10.1103/PhysRevLett. 125.121601.
+
+[21] Thomas N. Kipf and Max Welling. Semi-supervised classification with graph convolutional networks. In 5th International Conference on Learning Representations, ICLR 2017, Toulon, France, April 24-26, 2017, Conference Track Proceedings. OpenReview.net, 2017.
+
+[22] L’ubor Ladicky, SoHyeon Jeong, Barbara Solenthaler, Marc Pollefeys, and Markus Gross. \` Data-driven fluid simulations using regression forests. ACM Transactions on Graphics (TOG), 34(6):1–9, 2015.
+
+[23] Sangseung Lee and Donghyun You. Data-driven prediction of unsteady flow over a circular cylinder using deep learning. Journal of Fluid Mechanics, 879:217–254, 2019. doi: 10.1017/ jfm.2019.700.
+
+[24] Yunzhu Li, Jiajun Wu, Russ Tedrake, Joshua B. Tenenbaum, and Antonio Torralba. Learning particle dynamics for manipulating rigid bodies, deformable objects, and fluids. In International Conference on Learning Representations, 2019.
+
+[25] Ran Luo, Tianjia Shao, Huamin Wang, Weiwei Xu, Xiang Chen, Kun Zhou, and Yin Yang. Nnwarp: Neural network-based nonlinear deformation. IEEE transactions on visualization and computer graphics, 2018.
+
+[26] Steffen Marburg and Bodo Nolte. Computational acoustics of noise propagation in fluids: finite and boundary element methods, volume 578. Springer, 2008.
+
+[27] Rahul Narain, Armin Samii, and James F. O’Brien. Adaptive anisotropic remeshing for cloth simulation. ACM Trans. Graph., 31(6), 2012.
+
+[28] Rahul Narain, Tobias Pfaff, and James F. O’Brien. Folding and crumpling adaptive sheets. ACM Trans. Graph., 32(4), 2013.
+
+[29] Charlie Nash, Yaroslav Ganin, SM Eslami, and Peter W Battaglia. Polygen: An autoregressive generative model of 3d meshes. In International Conference on Machine Learning, 2020.
+
+[30] nVidia. GPU-accelerated ANSYS FLUENT. https://www.nvidia.com/en-us/data-center/ gpu-accelerated-applications/ansys-fluent, 2019.
+
+[31] SK Panthi, N Ramakrishnan, KK Pathak, and JS Chouhan. An analysis of springback in sheet metal bending using finite element method (fem). Journal of Materials Processing Technology, 186(1-3):120–124, 2007.
+
+[32] D Pardo, L Demkowicz, C Torres-Verdin, and M Paszynski. A self-adaptive goal-oriented hpfinite element method with electromagnetic applications. part ii: Electrodynamics. Computer methods in applied mechanics and engineering, 196(37-40):3585–3597, 2007.
+
+[33] Tobias Pfaff, Rahul Narain, Juan Miguel De Joya, and James F O’Brien. Adaptive tearing and cracking of thin sheets. ACM Transactions on Graphics (TOG), 33(4):1–9, 2014.
+
+[34] Ravi Ramamurti and William Sandberg. Simulation of flow about flapping airfoils using finite element incompressible flow solver. AIAA journal, 39(2):253–260, 2001.
+
+[35] Zhengyong Ren and Jingtian Tang. 3d direct current resistivity modeling with unstructured mesh by adaptive finite-element method. Geophysics, 75(1):H7–H17, 2010.
+
+[36] Alvaro Sanchez-Gonzalez, Nicolas Heess, Jost Tobias Springenberg, Josh Merel, Martin Riedmiller, Raia Hadsell, and Peter Battaglia. Graph networks as learnable physics engines for inference and control. In Proceedings of the 35th International Conference on Machine Learning, ICML, pp. 4467–4476, 2018.
+
+[37] Alvaro Sanchez-Gonzalez, Jonathan Godwin, Tobias Pfaff, Rex Ying, Jure Leskovec, and Peter W. Battaglia. Learning to simulate complex physics with graph networks. In Proceedings of the 37th International Conference on Machine Learning ICML 2020, 2020.
+
+[38] Franco Scarselli, Marco Gori, Ah Chung Tsoi, Markus Hagenbuchner, and Gabriele Monfardini. The graph neural network model. IEEE Transactions on Neural Networks, 20(1):61–80, 2008.
+
+[39] Christoph Schwarzbach, Ralph-Uwe Borner, and Klaus Spitzer. Three-dimensional adap- ¨ tive higher order finite element simulation for geo-electromagnetics—a marine csem example. Geophysical Journal International, 187(1):63–74, 2011.
+
+[40] Nils Thuerey, Konstantin Weißenow, Lukas Prantl, and Xiangyu Hu. Deep learning methods for reynolds-averaged navier–stokes simulations of airfoil flows. AIAA Journal, 58(1):25–36, 2020.
+
+[41] Kiwon Um, Xiangyu Hu, and Nils Thuerey. Liquid splash modeling with neural networks. In Computer Graphics Forum, volume 37, pp. 171–182. Wiley Online Library, 2018.
+
+[42] Benjamin Ummenhofer, Lukas Prantl, Nils Thurey, and Vladlen Koltun. Lagrangian fluid ¨ simulation with continuous convolutions. In International Conference on Learning Representations, 2020.
+
+[43] Rui Wang, Karthik Kashinath, Mustafa Mustafa, Adrian Albert, and Rose Yu. Towards physics-informed deep learning for turbulent flow prediction. In ACM SIGKDD international conference on knowledge discovery and data mining, 2020.
+
+[44] Emo Welzl. Smallest enclosing disks (balls and ellipsoids). In New results and new trends in computer science, pp. 359–370. Springer, 1991.
+
+[45] Martin Wicke, Daniel Ritchie, Bryan M. Klingner, Sebastian Burke, Jonathan R. Shewchuk, and James F. O’Brien. Dynamic local remeshing for elastoplastic simulation. ACM Trans. Graph., 29(4), 2010.
+
+[46] Steffen Wiewel, Moritz Becher, and Nils Thuerey. Latent space physics: Towards learning the temporal evolution of fluid flow. In Computer Graphics Forum, pp. 71–82. Wiley Online Library, 2019.
+
+[47] You Xie, Erik Franz, Mengyu Chu, and Nils Thuerey. Tempogan: A temporally coherent, volumetric gan for super-resolution fluid flow. ACM Trans. Graph., 37(4), July 2018.
+
+[48] Abdelaziz Yazid, Nabbou Abdelkader, and Hamouine Abdelmadjid. A state-of-the-art review of the $\mathbf { X }$ -fem for computational fracture mechanics. Applied Mathematical Modelling, 33(12): 4269–4282, 2009.
+
+[49] Yao Zhang, Woong Je Sung, and Dimitri N Mavris. Application of convolutional neural network to predict airfoil lift coefficient. In 2018 AIAA/ASCE/AHS/ASC Structures, Structural Dynamics, and Materials Conference, pp. 1903, 2018.
+
+A APPENDIX
+
+![](images/a8d2cd718ae0b32e7e5b63772038d2629112de5c78281c3c5a8a45350b333e73.jpg)  
+Figure A.1: Many of our datasets have highly irregular meshing, which allows us to predict dynamics at several scales. With only $5 \mathrm { k }$ nodes, the dataset AIRFOIL spans a large region around the wing (left: entire simulation domain), while still providing high resolution around the airfoil (middle: ROI for visual comparison and RMSE computation), down to sub-millimeter details around the wing tip (right).
+
+# A.1 DATASET DETAILS
+
+Below we list details for all of our datasets. “System” describes the underlying PDE: cloth, hyperelasticity or compressible and incompressible Navier-Stokes flow. We used ArcSim [27] for simulating the cloth datasets, SU2 [13] for compressible flows, and COMSOL [11] for incompressible flow and hyperelastic simulations. Hyper-elasticity and cloth are simulated using linear elements. Each dataset consists of 1000 training, 100 validation and 100 test trajectories, each containing 250- 600 time steps. Meshing can be either regular, i.e. all edges having similar length, irregular, i.e. edge lengths vary strongly in different regions of the mesh or dynamic, i.e. change at each step of the simulation trajectory. For Lagrangian systems, the world edge radius $r _ { W }$ is provided. Our model operates on the simulation time step $\Delta t$ listed below. However, for each output time step, the solvers compute several internal time steps (16 for ArcSim, 100 for SU2, adaptive for COMSOL). As a quasi-static simulation, DEFORMINGPLATE does not have a time step.
+
+<table><tr><td rowspan=1 colspan=1>Dataset</td><td rowspan=1 colspan=1>System</td><td rowspan=1 colspan=1>Solver</td><td rowspan=1 colspan=1>Mesh type</td><td rowspan=1 colspan=1>Meshing</td><td rowspan=1 colspan=1># steps</td><td rowspan=1 colspan=1>△tS</td><td rowspan=1 colspan=1>rw</td></tr><tr><td rowspan=1 colspan=1>FLAGSIMPLE</td><td rowspan=1 colspan=1>cloth</td><td rowspan=1 colspan=1>ArcSim</td><td rowspan=1 colspan=1>triangle 3D</td><td rowspan=1 colspan=1>regular</td><td rowspan=1 colspan=1>400</td><td rowspan=1 colspan=1>0.02</td><td rowspan=1 colspan=1>二</td></tr><tr><td rowspan=1 colspan=1>FLAGDYNAMIC</td><td rowspan=1 colspan=1>cloth</td><td rowspan=1 colspan=1>ArcSim</td><td rowspan=1 colspan=1>triangle 3D</td><td rowspan=1 colspan=1>dynamic</td><td rowspan=1 colspan=1>250</td><td rowspan=1 colspan=1>0.02</td><td rowspan=1 colspan=1>0.05</td></tr><tr><td rowspan=1 colspan=1>SPHEREDYNAMIC</td><td rowspan=1 colspan=1>cloth</td><td rowspan=1 colspan=1>ArcSim</td><td rowspan=1 colspan=1>triangle 3D</td><td rowspan=1 colspan=1>dynamic</td><td rowspan=1 colspan=1>500</td><td rowspan=1 colspan=1>0.01</td><td rowspan=1 colspan=1>0.05</td></tr><tr><td rowspan=1 colspan=1>DEFORMINGPLATE</td><td rowspan=1 colspan=1>hyper-el.</td><td rowspan=1 colspan=1>COMSOL</td><td rowspan=1 colspan=1>tetrahedral 3D</td><td rowspan=1 colspan=1>irregular</td><td rowspan=1 colspan=1>400</td><td rowspan=1 colspan=1>二</td><td rowspan=1 colspan=1>0.03</td></tr><tr><td rowspan=1 colspan=1>CYLINDERFLOW</td><td rowspan=1 colspan=1>incompr. NS</td><td rowspan=1 colspan=1>COMSOL</td><td rowspan=1 colspan=1>triangle 2D</td><td rowspan=1 colspan=1>irregular</td><td rowspan=1 colspan=1>600</td><td rowspan=1 colspan=1>0.01</td><td rowspan=1 colspan=1>二</td></tr><tr><td rowspan=1 colspan=1>AIRFOIL</td><td rowspan=1 colspan=1>compr. NS</td><td rowspan=1 colspan=1>SU2</td><td rowspan=1 colspan=1>triangle 2D</td><td rowspan=1 colspan=1>irregular</td><td rowspan=1 colspan=1>600</td><td rowspan=1 colspan=1>0.008</td><td rowspan=1 colspan=1>一</td></tr></table>
+
+Next, we list input encoding for mesh edges ${ \mathbf { e } } _ { i j } ^ { M }$ , world edges ${ \bf e } _ { i j } ^ { W }$ and nodes $\mathbf { v } _ { i }$ , as well as the predicted output for each system.
+
+<table><tr><td rowspan=1 colspan=1>System</td><td rowspan=1 colspan=1>Type</td><td rowspan=1 colspan=5>inputse</td><td rowspan=1 colspan=2>inputse</td><td rowspan=1 colspan=1>inputsVi</td><td rowspan=1 colspan=1> outputsPi</td><td rowspan=1 colspan=1>historyh</td></tr><tr><td rowspan=1 colspan=1>Cloth</td><td rowspan=1 colspan=1>Lagrangian</td><td rowspan=1 colspan=1>uij，</td><td rowspan=1 colspan=1>uij</td><td rowspan=1 colspan=2>uijl Xij，</td><td rowspan=1 colspan=1>|xijl</td><td rowspan=1 colspan=1>Xij，|Xijl</td><td></td><td rowspan=1 colspan=1>n，（x-x-1)</td><td rowspan=1 colspan=1>X</td><td rowspan=1 colspan=1>1</td></tr><tr><td rowspan=1 colspan=1>Hyper-El.</td><td rowspan=1 colspan=1>Lagrangian</td><td rowspan=1 colspan=1>uij，</td><td rowspan=1 colspan=1>uijl</td><td rowspan=1 colspan=2>，Xij，</td><td rowspan=1 colspan=1>xij</td><td rowspan=1 colspan=1>Xij，Xij</td><td></td><td rowspan=1 colspan=1>ni</td><td rowspan=1 colspan=1>文i，Oi</td><td rowspan=1 colspan=1>0</td></tr><tr><td rowspan=1 colspan=1>Incomp. NS</td><td rowspan=1 colspan=1>Eulerian</td><td rowspan=1 colspan=2>uij，</td><td rowspan=1 colspan=1>uij</td><td rowspan=1 colspan=2></td><td rowspan=1 colspan=2></td><td rowspan=1 colspan=1>ni,Wi</td><td rowspan=1 colspan=1>Wi，Pi</td><td rowspan=1 colspan=1>0</td></tr><tr><td rowspan=1 colspan=1>Compr. NS</td><td rowspan=1 colspan=1>Eulerian</td><td rowspan=1 colspan=2>uij，uij</td><td rowspan=1 colspan=1>Uij</td><td rowspan=1 colspan=2></td><td rowspan=1 colspan=2></td><td rowspan=1 colspan=1>ni,Wi, pi</td><td rowspan=1 colspan=1>Wi,pi,Pi</td><td rowspan=1 colspan=1>0</td></tr></table>
+
+![](images/97144ad8761bc40c1b3b666df69674875983262003fca4b90ce6a483c2c1418e.jpg)  
+Figure A.2: Beside output quantities such as position or momentum, which are integrated and fed back into the model as an input during rollout, we can also predict auxiliary output quantities, such as pressure or stress. These quantities can be useful for further analyzing the dynamics of the system. Here, we show a snapshot of auxiliary predictions of the pressure field in CYLINDERFLOW.
+
+All second-derivative output quantities $( \ddot { \bigcirc } )$ are integrated twice, while first derivative outputs $( \dot { \bigtriangledown } )$ are integrated once as described in Section 3.1; all other outputs are direct predictions, and are not integrated. The one-hot node type vector ${ \bf n } _ { i }$ allows the model to distinguish between normal and kinematic nodes. Normal nodes are simulated, while kinematic either remain fixed in space (such as the two nodes which keep the cloth from falling), or follow scripted motion (as the actuator in DEFORMINGPLATE). For scripted kinematic nodes, we additionally provide the next-step worldspace velocity $\mathbf { x } _ { i } ^ { t + 1 } - \mathbf { x } _ { i } ^ { t }$ as input; this allows the model to predict next-step positions which are consistent with the movement of the actuator. In the variant of FLAGDYNAMIC with varying wind speeds (generalization experiment in Section 5), the wind speed vector is appended to the node features.
+
+In the dynamically meshed datasets (FLAGDYNAMIC, SPHEREDYANMIC), the mesh changes between steps, and there is no 1:1 correspondence between nodes. In this case, we interpolate dynamical quantities from previous meshes $\mathbf { \bar { \boldsymbol { M } } } ^ { t - 1 } , . . . , \boldsymbol { M } ^ { t - h }$ as well as $M ^ { t + 1 }$ into the current mesh $M ^ { t }$ using barycentric interpolation in mesh-space, in order to provide history and targets for each node.
+
+# A.2 ADDITIONAL MODEL DETAILS
+
+# A.2.1 ARCHITECTURE AND TRAINING
+
+The MLPs of the Encoder $\epsilon ^ { M }$ , $\epsilon ^ { W }$ , $\epsilon ^ { V }$ , the Processor $f ^ { M } , \ f ^ { W } , \ j$ $f ^ { V }$ , and Decoder $\delta ^ { V }$ are ReLUactivated two-hidden-layer MLPs with layer and output size of 128, except for $\delta ^ { V }$ whose output size matches the prediction $\mathbf { p } _ { i }$ . All MLPs outputs except $\delta ^ { V }$ are normalized by a LayerNorm. All input and target features are normalized to zero-mean, unit variance, using dataset statistics.
+
+For training, we only supervise on the next step in sequence; to make our model robust to rollouts of hundreds of steps we use training noise (see Section A.2.2). Models are trained on a single v100 GPU with the Adam optimizer for 10M training steps, using an exponential learning rate decay from $1 0 ^ { - 4 }$ to $1 0 ^ { - 6 }$ over 5M steps.
+
+# A.2.2 TRAINING NOISE
+
+We used the same training noise strategy as in GNS [37] to make our model robust to rollouts of hundreds of steps. We add random normal noise of zero mean and fixed variance to the most recent value of the corresponding dynamical variable (Section A.2.3). When choosing how much noise to add, we looked at the one-step model error (usually related to the standard deviation of the targets in the dataset) and scanned the noise magnitude around that value on a logarithmic scale using two values for each factor of 10. For the exact numbers for each dataset, see Table A.2.3.
+
+In the cases where the dataset is modelled as a first-order system (all, except cloth domains); we adjust the targets according to the noise, so that the model decoder produces an output that after integration would have corrected the noise at the inputs. For example, in DEFORMINGPLATE, assume the current position of a node is $x _ { i } ^ { t } = 2$ , and $\hat { x } _ { i } ^ { t } = 2 . 1$ after adding noise. If the next position is $x _ { i } ^ { t + 1 } = 3$ , the target velocity for the decoder ${ \dot { x } } _ { i } = 1$ will be adjusted to $\tilde { \dot { x } } _ { i } = 0 . 9$ , so that after integration, the model output $\tilde { x } _ { i } ^ { t + 1 }$ matches the next step $\boldsymbol { x } _ { i } ^ { t + 1 }$ effectively correcting for the added noise, i.e. : $\tilde { x } _ { i } ^ { t + 1 } = \tilde { x } _ { i } ^ { t } + \tilde { \dot { x } } _ { i } = \dot { 3 } \equiv x _ { i } ^ { t + 1 }$ .
+
+In the second-order domains (cloth), the model decoder outputs acceleration ${ \ddot { x } } _ { i }$ from the input position $\boldsymbol { x } _ { i } ^ { t }$ and velocity $\dot { x } _ { i } ^ { t } = \dot { x } _ { i } ^ { t } - \dot { x } _ { i } ^ { t - 1 }$ (as in GNS). As with other systems, we add noise to the position $\boldsymbol { x } _ { i } ^ { t }$ , which indirectly results on a noisy derivative $\dot { x } _ { i } ^ { t }$ estimate. In this case, due to the strong dependency between position and velocity, it is impossible to adjust the targets to simultaneously correct for noise in both values. For instance, assume $x _ { i } ^ { t - 1 } = \bar { 1 . 4 } , x _ { i } ^ { t } = 2 , x _ { i } ^ { t + 1 } = 3$ , which implies $\dot { x } _ { i } ^ { t } = 0 . 6 , \dot { x } _ { i } ^ { t + 1 } = 1$ , and ground truth acceleration $\ddot { x } _ { i } = 0 . 4$ . After adding 0.1 of noise the inputs are $\tilde { x } _ { i } ^ { t } = 2 . 1 \Rightarrow \tilde { \dot { x } } _ { i } ^ { t } = 0 . 7 $ . At this point, we could use a modified acceleration target of $\tilde { \ddot { x } } _ { i } ^ { P } = 0 . 2$ , so that after integration, the next velocity is $\tilde { \dot { x } } _ { i } ^ { t + 1 } = \tilde { \dot { x } } _ { i } ^ { t } + \tilde { \dot { x } } ^ { P } = 0 . 9$ , and the next position $\tilde { x } _ { i } ^ { t + 1 } = \tilde { x } _ { i } ^ { t } + \tilde { { x } } _ { i } ^ { t + 1 } = 3 \equiv x _ { i } ^ { t + 1 }$ , effectively correcting for the noise added to the position. However, note that in this case the predicted next step velocity x˜˙ t+1i = 0.9 does not match the ground truth $\dot { x } _ { i } ^ { t + 1 } = 1$ . Similarly, if we chose a modified target acceleration of $\tilde { \ddot { x } } _ { i } ^ { V } = 0 . 3$ , the next step velocity $\tilde { \dot { x } } _ { i } ^ { t + 1 } = 1$ would match the ground truth, correcting the noise in velocity, but the same would not be true for the next step position $\tilde { x } _ { i } ^ { t + 1 } = 3 . 1$ . Empirically, we treated how to correct the noise for cloth simulation as a hyperparameter $\gamma \in [ 0 , 1 ]$ which parametrizes a weighted average between the two options: $\tilde { \ddot { x } } _ { i } = \gamma \tilde { \dot { x } } _ { i } ^ { P } + ( 1 - \gamma ) \tilde { \dot { x } } _ { i } ^ { V }$ . Best performance was achieved with $\gamma = 0 . 1$ .
+
+Finally, when the model takes more than one step of history $( h > 1 )$ (e.g. in the ablation from Figure 5d on FLAGDYNAMIC), the noise is added in a random walk manner with a per-step variance such as the variance at the last step matches the target variance (in accordance with GNS [37]).
+
+# A.2.3 HYPERPARAMETERS
+
+Table 2: Training noise parameters and batch size.   
+
+<table><tr><td rowspan=1 colspan=1>Dataset</td><td rowspan=1 colspan=1>Batch size</td><td rowspan=1 colspan=1>Noise scale</td></tr><tr><td rowspan=1 colspan=1>FLAGSIMPLE</td><td rowspan=1 colspan=1>1</td><td rowspan=1 colspan=1>pos: 1e-3</td></tr><tr><td rowspan=1 colspan=1>FLAGDYNAMIC</td><td rowspan=1 colspan=1>1</td><td rowspan=1 colspan=1>pos: 3e-3</td></tr><tr><td rowspan=1 colspan=1>SPHEREDYNAMIC</td><td rowspan=1 colspan=1>1</td><td rowspan=1 colspan=1>pos:1e-3</td></tr><tr><td rowspan=1 colspan=1>DEFORMINGPLATE</td><td rowspan=1 colspan=1>2</td><td rowspan=1 colspan=1>pos: 3e-3</td></tr><tr><td rowspan=1 colspan=1>CYLINDERFLOW</td><td rowspan=1 colspan=1>2</td><td rowspan=1 colspan=1>momentum:2e-2</td></tr><tr><td rowspan=1 colspan=1>AIRFOIL</td><td rowspan=1 colspan=1>2</td><td rowspan=1 colspan=1>momentum: le1, density:1e-2</td></tr></table>
+
+# A.3 A DOMAIN-INVARIANT LOCAL REMESHER FOR TRIANGULAR MESHES
+
+A local remesher [27, 28, 33] changes the mesh by iteratively applying one of three fundamental operations: splitting an edge to refine the mesh, collapsing an edge to coarsen it, and flipping an edge to change orientation and to preserve a sensible aspect ratio of its elements. Edge splits create a new node whose attributes (position, etc.), as well as the associated sizing tensor, are obtained by averaging values of the two nodes forming the split edge. Collapsing removes a node from the mesh, while edge flips leave nodes unaffected.
+
+![](images/165bcda690eacc57dc849a018227f739c111e93dd88d46cb1fc9986672513003.jpg)
+
+Given the sizing field tensor $\mathbf { S } _ { i }$ at each node $i$ , we can define the following conditions for performing edge operations:
+
+• An edge connecting node $i$ and $j$ should be split if it is invalid, i.e. $\mathbf { u } _ { i j } ^ { \mathrm { T } } \mathbf { S } _ { i j } \mathbf { u } _ { i j } > 1$ with the averaged sizing tensor $\begin{array} { r } { { \bf S } _ { i j } = \frac { 1 } { 2 } ( { \bf S } _ { i } + { \bf S } _ { j } ) } \end{array}$ .
+
+• An edge should be collapsed, if the collapsing operation does not create any new invalid edges.
+
+• An edge should be flipped if the an-isotropic Delaunay criterion [7]
+
+$$
+( \mathbf { u } _ { j k } \times \mathbf { u } _ { i k } ) \mathbf { u } _ { i l } ^ { T } \mathbf { S } _ { A } \mathbf { u } _ { j l } < \mathbf { u } _ { j k } ^ { T } \mathbf { S } _ { A } \mathbf { u } _ { i k } ( \mathbf { u } _ { i l } \times \mathbf { u } _ { j l } ) , \qquad \mathbf { S } _ { A } = \frac { 1 } { 4 } ( \mathbf { S } _ { i } + \mathbf { S } _ { j } + \mathbf { S } _ { k } + \mathbf { S } _ { l } )
+$$
+
+is satisfied. This optimizes the directional aspect ratio of the mesh elements.
+
+We can now implement a simple local remesher by applying these operations in sequence. First, we split all possible mesh edges to refine the mesh (in descending order of the metric $\mathbf { \dot { u } } _ { i j } ^ { \mathrm { T } } \mathbf { S } _ { i j } \mathbf { u } _ { i j } )$ , then flip all edges which should be flipped. Next, we collapse all edges we can collapse (in ascending order of the metric $\mathbf { u } _ { i j } ^ { \mathrm { T } } \mathbf { S } _ { i j } \mathbf { u } _ { i j } )$ to coarsen the mesh as much as possible, and finally again flip all possible edges to improve mesh quality.
+
+# A.3.1 ESTIMATING SIZING FIELD TARGETS
+
+If no sizing field is available to train the sizing model, we can estimate it from a sequence of meshes. That is, for two consecutive meshes $M ^ { t }$ , $M ^ { \tilde { t } + 1 }$ we want to find the sizing field $\mathbf { S }$ that would have induced this transition with a local remesher, i.e. $M ^ { t + 1 } = \mathcal { R } ( M ( t ) , \mathbf { S } )$ . To do this, we assume that the remesher is near-optimal, that is, all resulting edges are valid, yet maximum-length under the metric S. For each $\mathbf { S } _ { i }$ associated with the node $i$ , this can be expressed as:
+
+$$
+\mathbf { S } _ { i } = \mathrm { a r g m a x } \sum _ { j \in \mathcal { N } _ { i } } \mathbf { u } _ { i j } ^ { \mathrm { T } } \mathbf { S } _ { i } \mathbf { u } _ { i j } , \quad s . t . \forall j \in \mathcal { N } _ { i } : \mathbf { u } _ { i j } ^ { \mathrm { T } } \mathbf { S } _ { i } \mathbf { u } _ { i j } \leq 1
+$$
+
+This problem corresponds to finding the minimum-area, zero-centred ellipse containing the points $\mathbf { u } _ { i j }$ , and can be solved efficiently using the MINIDISK algorithm [44].
+
+# A.4 ADDITIONAL BASELINE DETAILS
+
+# A.4.1 BASELINE TRAINING
+
+Baseline architectures were trained within our general training framework, sharing the same normalization, noise and state-update strategies. We optimized the training hyperparameters separately in each case.
+
+# A.4.2 GCN BASELINE
+
+We re-implemented the base GCN architecture (without the super-resolution component) from Belbute-Peres et al. [5]. To replicate the results, and ensure correctness of our implementation of the baseline, we created a dataset AIRFOILSTEADY which matches the dataset studied in their work. It uses the same solver and a similar setup as our dataset AIRFOIL, except that it has a narrower range of angle of attack $( - 1 0 ^ { \circ } . . . 1 0 ^ { \circ }$ vs $- 2 5 ^ { \circ } . . . 2 5 ^ { \circ }$ in AIRFOIL). The biggest difference is that the prediction task studied in their paper is not a dynamical simulation as our experiments, but a steady-state prediction task. That is, instead of unrolling a dynamics model for hundreds of time steps, this task consists of directly predicting the final steady-state momentum, density and pressure fields, given only two scalars (Mach number $m$ , angle of attack $\alpha$ ) as well as the target mesh positions $\mathbf { u } _ { i }$ — essentially learning a parametrized distribution.
+
+In AIRFOILSTEADY, the GCN predictions are visually indistinguishable to the ground truth, and qualitatively match the results reported in Belbute-Peres et al. [5] for their ”interpolation regime” experiments. We also trained our model in AIRFOILSTEADY, as a one-step direct prediction model (without an integrator), with encoding like in AIRFOIL (see Section A.1), but where each node is conditioned on the global Mach number $m$ and angle of attack $\alpha$ ), instead of density and momentum. Again, results are visually indistinguishable from the ground truth (video), and our model outperforms GCN in terms of RMSE (ours 0.116 vs GCN 0.159). This is remarkable, as our models’ spatial equivariance bias works against this task of directly predicting a global field. This speaks of the flexibility of our architecture, and indicates that it can be used for tasks beyond learning local physical laws for which it was designed.
+
+# A.4.3 GRID (CNN) BASELINE
+
+We re-implemented the UNet architecture of Thurey et al. [40] to exactly match their open-sourced version of the code. We used a batch size of 10. The noise parameters from Section A.2.3 are absolute noise scale on momentum 6e-2 for CYLINDERFLOW, and 1e1 on momentum and 1.5e-2 on density in the AIRFOIL dataset.
+
+# A.5 ADDITIONAL ANALYSIS
+
+# A.5.1 PERFORMANCE
+
+In the table below, we show a detailed breakdown of per-step timings of our model run on CPU (8-core workstation) or a single v100 GPU. tmodel measures inference time of the graph neural network, while $\mathbf { t } _ { \mathbf { f u l l } }$ measures the complete rollout, including remeshing and graph recomputation. The ground truth simulation $\mathbf { \Gamma } ( \mathbf { t } _ { \mathbf { G T } } )$ was run on the same 8-core workstation CPU. On our datasets, inference uses between 1-2.5GB of memory, including model variables and system overhead.
+
+<table><tr><td rowspan=1 colspan=1>Dataset</td><td rowspan=1 colspan=1>CPUtmodelms/step</td><td rowspan=1 colspan=1>CPUtfullms/step</td><td rowspan=1 colspan=1>GPUtmodelms/step</td><td rowspan=1 colspan=1>GPUtfullms/step</td><td rowspan=1 colspan=1>tGTms/step</td><td rowspan=1 colspan=1>CPUspeedup</td><td rowspan=1 colspan=1>GPUspeedup</td></tr><tr><td rowspan=1 colspan=1>FLAGSIMPLE</td><td rowspan=1 colspan=1>186</td><td rowspan=1 colspan=1>187</td><td rowspan=1 colspan=1>19</td><td rowspan=1 colspan=1>19</td><td rowspan=1 colspan=1>4166</td><td rowspan=1 colspan=1>22.3</td><td rowspan=1 colspan=1>214.7</td></tr><tr><td rowspan=1 colspan=1>FLAGDYNAMIC</td><td rowspan=1 colspan=1>534</td><td rowspan=1 colspan=1>1593</td><td rowspan=1 colspan=1>43</td><td rowspan=1 colspan=1>837</td><td rowspan=1 colspan=1>26199</td><td rowspan=1 colspan=1>16.4</td><td rowspan=1 colspan=1>31.3</td></tr><tr><td rowspan=1 colspan=1>SPHEREDYNAMIC</td><td rowspan=1 colspan=1>221</td><td rowspan=1 colspan=1>402</td><td rowspan=1 colspan=1>32</td><td rowspan=1 colspan=1>140</td><td rowspan=1 colspan=1>1610</td><td rowspan=1 colspan=1>4.0</td><td rowspan=1 colspan=1>11.5</td></tr><tr><td rowspan=1 colspan=1>DEFORMINGPLATE</td><td rowspan=1 colspan=1>172</td><td rowspan=1 colspan=1>174</td><td rowspan=1 colspan=1>24</td><td rowspan=1 colspan=1>33</td><td rowspan=1 colspan=1>2893</td><td rowspan=1 colspan=1>16.6</td><td rowspan=1 colspan=1>89.0</td></tr><tr><td rowspan=1 colspan=1>CYLINDERFLOW</td><td rowspan=1 colspan=1>166</td><td rowspan=1 colspan=1>168</td><td rowspan=1 colspan=1>21</td><td rowspan=1 colspan=1>23</td><td rowspan=1 colspan=1>820</td><td rowspan=1 colspan=1>4.9</td><td rowspan=1 colspan=1>35.3</td></tr><tr><td rowspan=1 colspan=1>AIRFOIL</td><td rowspan=1 colspan=1>497</td><td rowspan=1 colspan=1>499</td><td rowspan=1 colspan=1>37</td><td rowspan=1 colspan=1>38</td><td rowspan=1 colspan=1>11015</td><td rowspan=1 colspan=1>22.1</td><td rowspan=1 colspan=1>289.1</td></tr></table>
+
+The NN bulding blocks used in our model are highly optimized for hardware acceleration. However, our ground truth solvers (ArcSim, COMSOL and SU2) do not support GPUs; and more broadly, solvers have varying levels of optimization for different hardware, so we find it hard to provide a ’true’ hardware-agnostic performance comparison. We do note a few trends.
+
+In the simulation regime studied in this paper (i.e. general-purpose simulations on complex, irregular domains) classical GPU solvers tend to be comparably hard to implement and they do not scale very well, thus many packages do not provide such support. As an example of a general-purpose solver with partial GPU support, ANSYS shows limited speedups of $2 \mathbf { X } ^ { - 4 } \mathbf { X }$ on GPU, even under optimal conditions [30, 14]. On the other hand, evaluating our model on the same CPU hardware as the ground truth solvers, it still achieves speedups between $4 \mathrm { x } - 2 2 \mathrm { x }$ , even in this setting which is suboptimal for NN models.
+
+In practice, using a single GPU, we see speedups of $1 1 \mathrm { x } \mathrm { - } 2 9 0 \mathrm { x }$ compared to ArcSim, COMSOL and SU2, and users of such simulators with access to a GPU could benefit from these speedups.
+
+# A.5.2 ERROR METRICS
+
+Rollout RMSE is calculated as the root mean squared error of the position in the Lagrangian systems and of the momentum in the Eulerian systems, taking the mean for all spatial coordinates, all mesh nodes, all steps in each trajectory, and all 100 trajectories in the test dataset. The error bounds in Table 1 and the error bars in Figure 5(a-c) indicate standard error of the RMSE across 100 trajectories. Error bars in Figure 5(d) correspond to min/median/max performance across 3 seeds.
+
+In FLAGSIMPLE and FLAGDYNAMIC, we observed decoherence after the first 50 steps (Figure 5b), due to the chaotic nature of cloth simulation. Since the dynamics of these domains are stationary, we use the rollout error in the first 50 steps of the trajectory for the comparison shown in the bar plots, as a more discerning metric for result quality. However, the reported trends also hold when measured over the whole trajectory.
+
+In AIRFOIL, we compute the RMSE in a region of interest around the wing (Figure A.1 middle), which corresponds to the region shown in figures and videos. For comparisons with grid-based methods, we map the predictions on the grid to the ground truth mesh to compute the error.
+
+![](images/b18abd206c638bf0da4080d97fc3337d50a2cc05882c9fa863ba07c54d90beed.jpg)  
+Figure A.3: A model trained on the regular-sized FLAGDYNAMIC domain was run on variants of FLAGDYNAMIC, WINDSOCK, FISHFLAG with different scale and resolutions. We show the RMSE for 50-step (left) and full-trajectory rollout (right) as a function of the simulation node count.
+
+# A.5.3 ADDITIONAL ANALYSIS ON GENERALIZATION AND SCALING
+
+We ran inference of our model trained on the FLAGDYNAMIC domain (with learned remeshing), on several scaled-up and scaled-down versions of FLAGDYNAMIC, and the generalization experiment WINDSOCK and FISHFLAG (see Section 5). In Figure A.3, we report the error compared to the respective ground-truth simulations.
+
+When evaluating the 50-step RMSE rollout error in FLAGDYNAMIC we do not observe systematic trends of the error as function of the simulation size, indicating that the model performs similarly well on larger and smaller systems. The error when generalizing to new shapes (WINDSOCK, FISHFLAG) is slightly higher, but comparable.
+
+The RMSE rollout error evaluated on the full trajectory shows a stronger correlation with the system size. However, we believe this simply tracks the systematic positional error incurred due to decoherence (e.g. a small angle perturbation due to decoherence incurs a higher positional error at the tip of the flag the larger the flag is), and as shown in Figure 5b, decoherence becomes the main source of error after the first 50 steps of the simulation in this domain.

parse/train/zkHlu_3sJYU/zkHlu_3sJYU.md

@@ -0,0 +1,250 @@
+# SWAD: Domain Generalization by Seeking Flat Minima
+
+Junbum Cha1† Sanghyuk Chun2∗ Kyungjae Lee3∗ Han-Cheol Cho4 Seunghyun Park4 Yunsung Lee5 Sungrae Park6†
+
+1 Kakao Brain 2 NAVER AI Lab 3 Chung-Ang University   
+4 NAVER Clova 5 Korea University 6 Upstage AI Research
+
+# Abstract
+
+Domain generalization (DG) methods aim to achieve generalizability to an unseen target domain by using only training data from the source domains. Although a variety of DG methods have been proposed, a recent study shows that under a fair evaluation protocol, called DomainBed, the simple empirical risk minimization (ERM) approach works comparable to or even outperforms previous methods. Unfortunately, simply solving ERM on a complex, non-convex loss function can easily lead to sub-optimal generalizability by seeking sharp minima. In this paper, we theoretically show that finding flat minima results in a smaller domain generalization gap. We also propose a simple yet effective method, named Stochastic Weight Averaging Densely (SWAD), to find flat minima. SWAD finds flatter minima and suffers less from overfitting than does the vanilla SWA by a dense and overfit-aware stochastic weight sampling strategy. SWAD shows state-of-the-art performances on five DG benchmarks, namely PACS, VLCS, OfficeHome, TerraIncognita, and DomainNet, with consistent and large margins of $+ 1 . 6 \%$ averagely on outof-domain accuracy. We also compare SWAD with conventional generalization methods, such as data augmentation and consistency regularization methods, to verify that the remarkable performance improvements are originated from by seeking flat minima, not from better in-domain generalizability. Last but not least, SWAD is readily adaptable to existing DG methods without modification; the combination of SWAD and an existing DG method further improves DG performances. Source code is available at https://github.com/khanrc/swad.
+
+# 1 Introduction
+
+Independent and identically distributed (i.i.d.) condition is the underlying assumption of machine learning experiments. However, this assumption may not hold in real-world scenarios, i.e., the training and the test data distribution may differ significantly by distribution shifts. For example, a self-driving car should adapt to adverse weather or day-to-night shifts [1, 2]. Even in a simple image recognition scenario, systems rely on wrong cues for their prediction, e.g., geographic distribution [3], demographic statistics [4], texture [5], or backgrounds [6]. Consequently, a practical system should require generalizability to distribution shift, which is yet often failed by traditional approaches.
+
+Domain generalization (DG) aims to address domain shift simulated by training and evaluating on different domains. DG tasks assume that both task labels and domain labels are accessible. For example, PACS dataset [7] has seven task labels (e.g., “dog”, “horse”) and four domain labels (e.g., “photo”, “sketch”). Previous approaches explicitly reduced domain gaps in the latent space $[ 8 -$
+
+Table 1: Comparisons with SOTA. The proposed SWAD outperforms other state-of-the-art DG methods on five different DG benchmarks with significant gaps $( + 1 . 6 \mathrm { p p }$ in the average).   
+
+<table><tr><td></td><td>PACS</td><td>VLCS</td><td>OfficeHome</td><td>TerraInc</td><td>DomainNet</td><td>Avg.</td></tr><tr><td>ERM [29]</td><td>85.5</td><td>77.5</td><td>66.5</td><td>46.1</td><td>40.9</td><td>63.3</td></tr><tr><td>Best SOTA competitor</td><td>86.6 [30]</td><td>78.8 [31]</td><td>68.7 [31]</td><td>48.6 [32]</td><td>43.6[15,33]</td><td>65.3</td></tr><tr><td>SWAD (proposed)</td><td>88.1</td><td>79.1</td><td>70.6</td><td>50.0</td><td>46.5</td><td>66.9</td></tr><tr><td>Previous SOTA [31] + SWAD</td><td>88.3</td><td>78.9</td><td>71.3</td><td>51.0</td><td>46.8</td><td>67.3</td></tr></table>
+
+12], obtained well-transferable model parameters by the meta-learning framework [13–16], data augmentation [17–19], or capturing causal relation [20, 21]. Despite numerous previous attempts for a decade, Gulrajani and Lopez-Paz [22] showed that a simple empirical risk minimization (ERM) approach works comparably or even outperforms the previous attempts on diverse DG benchmarks under a fair evaluation protocol, called “DomainBed”.
+
+Unfortunately, although ERM showed surprising empirical success on DomainBed, simply minimizing the empirical loss on a complex and non-convex loss landscape is typically not sufficient to arrive at a good generalization [23–26]. In particular, the connection between the generalization gap and the flatness of loss landscapes has been actively discussed under the i.i.d. condition [23–28]. Izmailov et al. [25] argued that seeking flat minima will lead to robustness against the loss landscape shift between training and test datasets, while a simple ERM converges to the boundary of a wide flat minimum and achieves insufficient generalization. In the DG scenario, because training and test loss landscapes differ more drastically due to the domain shift, we conjecture that the generalization gap between flat and sharp minima is larger than expected in the i.i.d. scenario.
+
+To show that flatter minima generalize better to unseen domains, we formulate a robust risk minimization (RRM) problem defined by the worst-case empirical risks within neighborhoods in parameter space [26, 34]. We theoretically show that the generalization gap of DG, i.e., the error on the target domain, is upper bounded by RRM, i.e., a flat optimal solution. Based on our theoretical observation, we modify stochastic weight averaging (SWA) [25], one of the popular existing flatness-aware solvers, by introducing a dense and overfit-aware stochastic weight sampling strategy. First, we suggest to sample weights densely, i.e., for every iteration. Also, we search the start and end iterations for averaging by considering the validation loss to avoid overfitting. We empirically show that the proposed Stochastic Weight Averaging Densely (SWAD) finds flatter minima than the vanilla SWA does, resulting in better generalization to unseen domains.
+
+Contribution. Our main contribution is introducing flatness into DG, and showing remarkably outperforming performances against existing DG methods. As shown in Table 1, our SWAD improves the average DG performances by 3.6pp against the ERM baseline and $1 . 6 \mathrm { p p }$ against the existing best methods. Furthermore, by combining SWAD and previous SOTA [31], we even achieve $0 . 4 \mathrm { p p }$ improvements against the vanilla SWAD results. We also empirically show that while popular indomain generalization methods without considering flatness, e.g., Mixup [35] or CutMix [36], are not effective to out-of-domain generalization (Table 3), flatness-aware methods, e.g., SWA [25] or SAM [26], are only effective methods to both in-domain and out-of-domain generalization.
+
+# 2 A Theoretical Relationship between Flatness and Domain Generalization
+
+Let $\mathcal { D } : = \{ \mathcal { D } _ { i } \} _ { i } ^ { I }$ be a set of training domains, where $\mathcal { D } _ { i }$ is a distribution over input space $\mathcal { X }$ , and $I$ is the total number of domains. From each domain, we observe $n$ training data points which consist of input $x$ and target label $y$ , $( \boldsymbol { x } _ { j } ^ { i } , \boldsymbol { y } _ { j } ^ { i } ) _ { j = 1 } ^ { n } \sim \mathcal { D } _ { i }$ . We also define a set of target domain $\mathcal { T } : = \left\{ \mathcal { T } _ { i } \right\} _ { i } ^ { T }$ similarly, where the number of target domains is usually set to one. For the sake of simplicity, unlike Ben-David et al. [37], we assume that there exists a global labeling function $h ( x )$ that generates target label for multiple domains, i.e., $y _ { j } ^ { i } = h ( x _ { j } ^ { i } )$ for all $i$ and $j$ . Domain generalization (DG) aims to find a model parameter $\theta \in \Theta$ which generalizes well over both multiple training domains $\mathcal { D }$ and unseen target domain $\tau$ . More specifically, let us consider a bounded instance loss function $\ell : \mathcal { V } \times \mathcal { V }  \mathbf { \bar { \mu } } [ 0 , c ]$ , such that $\ell ( y _ { 1 } , y _ { 2 } ) = 0$ holds if and only if $y _ { 1 } ~ = ~ y _ { 2 }$ where $\mathcal { V }$ is a set of labels. For simplicity, we set $c$ to one in our proofs, but we note that $\ell ( \cdot , \cdot )$ can be generalized for any bounded loss function. Then, we can define a population loss over multiple domains by $\begin{array} { r } { \mathcal { E } _ { \mathcal { D } } ( \theta ) { \bf \tilde { \theta } } = \frac { 1 } { I } \sum _ { i = 1 } ^ { I } \mathbb { E } _ { x ^ { i } \sim \mathcal { D } _ { i } } [ \ell ( f ( x ^ { i } ; \theta ) , y ^ { i } ) ) ] } \end{array}$ , where $f ( \cdot ; \theta )$ is a model parameterized by $\theta$ . Formally, the goal of DG is to find a model which minimizes both $\mathcal { E } _ { \mathcal { D } } ( { \boldsymbol { \theta } } )$ and ${ \mathcal { E } } _ { T } ( \theta )$ by only minimizing an empirical risk $\begin{array} { r } { \hat { \mathcal { E } } _ { \mathcal { D } } ( \boldsymbol { \theta } ) : = \frac { 1 } { I n } \sum _ { i = 1 } ^ { I } \sum _ { j = 1 } ^ { n } \ell ( f ( x ^ { i } ; \boldsymbol { \theta } ) , y ^ { i } ) ) } \end{array}$ over training domains $\mathcal { D }$ .
+
+In practice, ERM, i.e., $\mathrm { a r g m i n } _ { \theta } \hat { \mathcal { E } } _ { \mathcal { D } } ( \theta )$ , can have multiple solutions that provide similar values of the training losses but significantly different generalizability on $\mathcal { E } _ { \mathcal { D } } ( { \boldsymbol { \theta } } )$ and ${ \mathcal { E } } _ { T } ( \theta )$ . Unfortunately, the typical optimization methods, such as SGD and Adam [38], often lead sub-optimal generalizability as finding sharp and narrow minima even under the i.i.d. assumption [23–28]. In the DG scenario, the generalization gap between empirical loss and target domain loss becomes even worse due to domain shift. Here, we provide a theoretical interpretation of the relationship between finding a flat minimum and minimizing the domain generalization gap, inspired by previous studies [23–28].
+
+We consider a robust empirical loss function defined by the worst-case loss within neighborhoods in the parameter space as $\begin{array} { r } { \hat { \mathcal { E } } _ { \mathcal { D } } ^ { \gamma } ( \theta ) : = \operatorname* { m a x } _ { \| \Delta \| \leq \gamma } \hat { \mathcal { E } } _ { \mathcal { D } } ( \theta + \Delta ) } \end{array}$ , where $\| \cdot \|$ denotes the L2 norm and $\gamma$ is a radius which defines neighborhoods of $\theta$ . Intuitively, if $\gamma$ is sufficiently larger than the “radius” of a sharp optimum $\theta _ { s }$ of $\hat { \mathcal { E } } _ { \mathcal { D } } ( \theta )$ , $\theta _ { s }$ is no longer an optimum of $\hat { \mathcal { E } } _ { \mathcal { D } } ^ { \gamma } ( \theta )$ as well as its neighborhoods within the $\gamma$ -ball. On the other hand, if an optimum $\theta _ { f }$ has larger “radius” than $\gamma$ , there exists a local optimum within $\gamma$ -ball – See Figure 1. Hence, solving the robust risk minimization (RRM), i.e., $\arg \operatorname* { m i n } _ { \theta } \hat { \mathcal { E } } _ { \mathcal { D } } ^ { \gamma } ( \theta )$ , will find a near solution of a flat optimum showing better generalizability [26, 34]. However, as domain shift worsen the generalization gap by breaking the i.i.d. assumption, it is not trivial that RRM will find an optimum with better DG performance. To answer the question, we first show the generalization bound between $\hat { \mathcal { E } } _ { \mathcal { D } } ^ { \gamma }$ and $\mathcal { E } _ { T }$ as follows:
+
+![](images/0c298f89243367a5caeaf75d1a922847cc8cf15d5cc0345d520d5a5ecd0c8065.jpg)  
+Figure 1: Robust risk minimization (RRM) and flat minima. With proper $\gamma$ , RRM will find flat minima.
+
+Theorem 1. Consider a set of $N$ covers $\{ \Theta _ { k } \} _ { k = 1 } ^ { N }$ such that the parameter space $\Theta \subset \cup _ { k } ^ { N } \Theta _ { k }$ where $\begin{array} { r } { d i a m ( \Theta ) : = \operatorname* { s u p } _ { \theta , \theta ^ { \prime } \in \Theta } \| \theta - \theta ^ { \prime } \| _ { 2 } , N : = \Big \lceil ( d i a m ( \Theta ) / \gamma ) ^ { d } \Big \rceil } \end{array}$ and $d$ is dimension of $\Theta$ . Let $v _ { k }$ be a $V C$ dimension of each $\Theta _ { k }$ . Then, for any $\theta \in \Theta$ , the following bound holds with probability at least $1 - \delta$
+
+$$
+\mathcal { E } _ { \mathcal { T } } ( \theta ) < \hat { \mathcal { E } } _ { \mathcal { D } } ^ { \gamma } ( \theta ) + \frac { 1 } { 2 I } \sum _ { i = 1 } ^ { I } \mathbf { D i v } ( \mathcal { D } _ { i } , \mathcal { T } ) + \operatorname* { m a x } _ { k \in [ 1 , N ] } \sqrt { \frac { v _ { k } \ln \left( m / v _ { k } \right) + \ln \left( N / \delta \right) } { m } } ,
+$$
+
+where $m = n I$ is the number of the training samples and $\begin{array} { r } { \mathbf { D i v } ( \mathcal { D } _ { i } , \mathcal { T } ) : = 2 \operatorname* { s u p } _ { A } \left| \mathbb { P } _ { \mathcal { D } _ { i } } ( A ) - \mathbb { P } _ { \mathcal { T } } ( A ) \right| } \end{array}$ is a divergence between two distributions.
+
+Proof can be done similarly as [37] and [34]. In Theorem 1, the test loss ${ \mathcal { E } } _ { T } ( \theta )$ is bounded by three terms: (1) the robust empirical loss $\hat { \mathcal { E } } _ { \mathcal { D } } ^ { \gamma } ( \theta )$ , (2) the discrepancy between training distribution and test distribution, i.e., the quantity of domain shift, and (3) a confidence bound related to the radius $\gamma$ and the number of the training samples $m$ . Our theorem is similar to Ben-David et al. [37], while our theorem does not have the term related to the difference in labeling functions across the domains. It is because we simply assume there is no difference between labeling functions for each domain for simplicity. If one assumes a different labeling function, the dissimilarity term can be derived easily because it is independent and compatible with our main proof. More details of Theorem 1, including proof and discussions on the confidence bound, are in Appendix C.1 and C.2.
+
+From Theorem 1, one can conjure that minimizing the robust empirical loss is directly related to the generalization performances on the target distribution. We show that the domain generalization gap on the target domain $\tau$ by the optimal solution of RRM, ${ \hat { \theta } } ^ { \gamma }$ , is upper bounded as follows:
+
+Theorem 2. Let $\hat { \theta } ^ { \gamma }$ denote the optimal solution of the RRM, i.e., $\begin{array} { r } { \hat { \theta } ^ { \gamma } : = \arg \operatorname* { m i n } _ { \theta } \hat { \mathcal { E } } _ { \mathcal { D } } ^ { \gamma } ( \theta ) . } \end{array}$ , and let v be a VC dimension of the parameter space $\Theta$ . Then, the gap between the optimal test loss, minθ0 $\mathcal { E } \tau \left( \theta ^ { \prime } \right)$ , and the test loss of ${ \hat { \theta } } ^ { \gamma }$ , $\mathcal { E } _ { \mathcal { T } } ( \hat { \theta } ^ { \gamma } )$ , has the following bound with probability at least $1 - \delta$ .
+
+$$
+\begin{array} { r c l } { \mathcal { E } _ { \mathcal { T } } ( \hat { \theta } ^ { \gamma } ) - \underset { \theta ^ { \prime } } { \operatorname* { m i n } } \ \mathcal { E } _ { \mathcal { T } } \left( \theta ^ { \prime } \right) } & { \leq } & { \displaystyle \hat { \mathcal { E } } _ { \mathcal { D } } ^ { \gamma } ( \hat { \theta } ^ { \gamma } ) - \underset { \theta ^ { \prime \prime } } { \operatorname* { m i n } } \ \hat { \mathcal { E } } _ { \mathcal { D } } ( \theta ^ { \prime \prime } ) + \frac { 1 } { I } \sum _ { i = 1 } ^ { I } \mathbf { D i v } ( \mathcal { D } _ { i } , \mathcal { T } ) } \\ & { + \underset { k \in \left[ 1 , N \right] } { \operatorname* { m a x } } \ \sqrt { \frac { v _ { k } \ln \left( m / v _ { k } \right) + \ln \left( 2 N / \delta \right) } { m } } + \sqrt { \frac { v \ln \left( m / v \right) + \ln \left( 2 / \delta \right) } { m } } } \end{array}
+$$
+
+![](images/5be2415e2dfae8eeafe9efa1dafa3882628cb0216856667b76b7a5ebfcb20a08.jpg)  
+Figure 2: Comparison between SWA and SWAD. (a) SWA collects stochastic weights for every $K$ epochs from the pre-defined $K _ { 0 }$ epochs to the final epoch. (b) Our SWAD collects stochastic weights densely, i.e., for every iteration, to obtain sufficiently many weights. SWAD collects the weights from the start iteration $t _ { s }$ to the end iteration $t _ { e }$ , where $t _ { s }$ and $t _ { e }$ are obtained by monitoring the validation loss (overfit-aware scheduling).
+
+Proof is in Appendix C.3. It implies that if we find the optimal solution of the RRM $( i . e . , \hat { \theta } ^ { \gamma } )$ , then the generalization gap in the test domain (i.e., $\mathcal { E } _ { T } ( \hat { \theta } ^ { \gamma } ) - \mathrm { m i n } _ { \theta ^ { \prime } } \mathcal { E } _ { T } ( \theta ^ { \prime } ) )$ is upper bounded by the gap between the RRM and ERM (i.e., $\hat { \mathcal { E } } _ { \mathcal { D } } ^ { \gamma } ( \hat { \theta } ^ { \gamma } ) - \operatorname* { m i n } _ { \theta ^ { \prime \prime } } \hat { \mathcal { E } } _ { \mathcal { D } } ( \theta ^ { \prime \prime } ) )$ . Other terms in Theorem 2 are the discrepancy between the train domains $\mathcal { D }$ and the target domain $\tau$ , and the confidence bounds caused by sample means. We remark that if we choose a proper $\gamma$ , the optimal solution of the RRM will find a point near a flat optimum of ERM as shown in Figure 1. Hence, Theorem 2 and the intuition from Figure 1 imply that seeking a flat minimum of ERM will lead to a better domain generalization gap.
+
+# 3 SWAD: Domain Generalization by Seeking Flat Minima
+
+We have shown that flat minima will bring a better domain generalization. In this section, we propose Stochastic Weight Averaging Densely (SWAD) algorithm, and provide empirical quantitative and qualitative analyses on SWAD and flatness to understand why SWAD works better than ERM.
+
+# 3.1 A baseline method: stochastic weight averaging
+
+Since the importance of flatness in loss landscapes has emerged [23–28], several methods have been proposed to find flat minima [25, 26, 39]. We select stochastic weight averaging (SWA) [25] as a baseline, which finds flat minima by a weight ensemble approach. More specifically, SWA updates a pretrained model (namely, a model trained with sufficiently enough training epochs, $K _ { 0 }$ ) with a cyclical [40] or high constant learning rate scheduling. SWA gathers model parameters for every $K$ epochs during the update and averages them for the model ensemble. SWA finds an ensembled solution of different local optima found by a sufficiently large learning rate to escape a local minimum. Izmailov et al. [25] empirically showed that SWA finds flatter minima than ERM. We also considered sharpness-aware minimization (SAM) [26], which is another popular flatness-aware solver, but SWA finds flatter minima than SAM (See Figure 3). We illustrate an overview of SWA in Figure 2a.
+
+# 3.2 Dense and overfit-aware stochastic weight sampling strategy
+
+Despite its advantages, directly applying SWA to DG task has two problems. First, SWA averages a few weights (usually less than ten) by sampling weights for every $K$ epochs, results in an inaccurate approximation of flat minima on a high-dimensional parameter space (e.g., 23M for ResNet-50 [41]). Furthermore, a common DG benchmark protocol uses relatively small training epochs (e.g., Gulrajani and Lopez-Paz [22] trained with less than two epochs for DomainNet benchmark), resulting in insufficient stochastic weights for SWA. From this motivation, we propose a “dense” sampling strategy for gathering sufficiently enough stochastic weights.
+
+In addition, widely used DG datasets, such as PACS $\approx 1 0 \mathrm { K }$ images, 7 classes) and VLCS $( \approx 1 1 \mathsf { K }$ images, 5 classes), are relatively smaller than large-scale datasets, such as ImageNet [42] $( \approx 1 . 2 \mathrm { M }$ images, 1K classes). In this case, we observe that a simple ERM approach is rapidly reached to a local optimum only within a few epochs, and easily suffers from the overfitting issue, i.e., the validation loss is increased after a few training epochs. It implies that directly applying the vanilla SWA will suffer from the overfitting issue by averaging sub-optimal solutions (i.e., overfitted parameters). Hence, we need an “overfit-aware” sampling scheduling to omit the sub-optimal solutions for SWA.
+
+![](images/6b80552c0af4a15dca897acbebf0ff96cc58d66aa2fda81b9bdb8e56e9209211.jpg)  
+Figure 3: Local flatness comparisons. We plot the local flatness via loss gap, i.e., $\begin{array} { r l } { { \mathcal F } _ { \gamma } ( \theta ) } & { { } = } \end{array}$ $\mathbb { E } _ { \| \theta ^ { \prime } \| = \| \theta \| + \gamma } [ \mathcal { E } ( \theta ^ { \prime } ) - \mathcal { E } ( \theta ) ]$ , of ERM, SAM, SWA, and SWAD by varying radius $\gamma$ on different domains of PACS dataset. For each figure, Y-axis indicates the flatness ${ \mathcal { F } } _ { \gamma } ( \theta )$ and X-axis indicates the radius $\gamma$ . We measure the train flatness $\mathcal { F } _ { \gamma } ^ { \mathcal { D } } ( \theta )$ on seen domains and the test flatness $\mathcal { F } _ { \gamma } ^ { \mathcal { T } } ( \theta )$ on unseen domain. Each point is computed by Monte-Carlo approximation with 100 random samples. This comparisons show SWAD finds flatter minima than not only ERM but also SAM and SWA.
+
+The main idea of Stochastic Weight Averaging Densely (SWAD) is a dense and overfit-aware stochastic weight gathering strategy. First, instead of collecting weights for every $K$ epochs, SWAD collects weights for every iteration. This dense sampling strategy easily collects sufficiently many weights than the sparse one. We also employ overfit-aware sampling scheduling by considering traces of the validation loss. Instead of sampling weights from $K _ { 0 }$ pretraining epochs to the final epoch, we search the start iteration (when the validation loss achieves a local optimum for the first time) and the end iteration (when the validation loss is no longer decreased, but keep increasing). More specifically, we introduce three parameters: an optimum patient parameter $N _ { s }$ , an overfitting patient parameter $N _ { e }$ , and the tolerance rate $r$ for searching the start iteration $t _ { s }$ and the end iteration $t _ { e }$ . First, we search ts which satisfies mini∈[0,...,Ns−1] $\bar { \mathcal { E } } _ { \mathrm { v a l } } ^ { ( t _ { s } + i ) } = \mathcal { E } _ { \mathrm { v a l } } ^ { ( t _ { s } ) }$ E (ts)val , where $\mathcal { E } _ { \mathrm { v a l } } ^ { ( i ) }$ denotes the validation loss at iteration iterationfirst itera $i$ . Simply,  Then, weon where $t _ { s }$ isnd e v e first iterasatisfying dation loss g.g ecreased duther words, iterations. ng is $N _ { s }$ s. fi te mini∈[0,1,...,Ne−1] E (teval $\begin{array} { r } { \operatorname* { m i n } _ { i \in [ 0 , 1 , \dots , N _ { e } - 1 ] } \mathcal { E } _ { \mathrm { v a l } } ^ { ( t _ { e } + i ) } > r \mathcal { E } _ { \mathrm { v a l } } ^ { ( t _ { s } ) } } \end{array}$ $t _ { e }$ ti th ali values exceed the tolerance $r$ durin $N _ { e }$
+
+We illustrate the overview of SWAD and the comparison of SWAD to SWA in Figure 2. Detailed pseudo code is provided in Appendix B.4. We compare SWAD with other possible SWA strategies in $\ S 4 . 3$ and show that our design choice works better for DG tasks.
+
+# 3.3 Empirical analysis of SWAD and flatness
+
+Here, we analyze solutions found by SWAD in terms of flatness. We first verify that the SWAD solution is flatter than those of ERM, SWA, and SAM. Our loss surface visualization shows that the SWAD solution is located on the center of the flat region, while ERM finds a boundary solution. Finally, we show that the sharp boundary solutions by ERM are not generalized well, resulting in sensitivity to the model selection. All following empirical analyses are conducted on PACS dataset, validating by all four domains (art painting, cartoon, photo, and sketch).
+
+Local flatness anaylsis. To begin with, we quantify the local flatness of a model parameter $\theta$ by assuming that flat minima will have smaller changes of loss value within its neighborhoods than sharp minima. For the given model parameter $\theta$ , we compute the expected loss value changes between $\theta$ and parameters on the sphere surrounding $\theta$ with radius $\gamma$ , i.e., $\mathcal { \bar { F } } _ { \gamma } ( \theta ) = \mathbb { E } _ { \| \theta ^ { \prime } \| = \| \theta \| + \gamma } [ \mathcal { \bar { E } } ( \theta ^ { \prime } ) - \mathcal { E } ( \theta ) ]$ . In practice, ${ \mathcal { F } } _ { \gamma } ( \theta )$ is approximated by Monte-Carlo sampling with 100 samples. Note that the proposed local flatness ${ \mathcal { F } } _ { \gamma } ( \theta )$ is computationally efficient than measuring curvature using the Hessian-based quantities. Also, ${ \mathcal { F } } _ { \gamma } ( \theta )$ has an unbiased finite sample estimator, while the worst-case loss value, i.e., $\operatorname* { m a x } _ { \| \theta ^ { \prime } \| = \| \theta \| + \gamma } [ { \mathcal { E } } ( \theta ^ { \prime } ) - { \mathcal { E } } ( \theta ) ]$ has no unbiased finite sample estimator.
+
+![](images/754f10657b9f14284a8fe1a62243c0a45d0fff540230864084447d0ccbd8e4be.jpg)  
+Figure 4: Loss surfaces on model parameters in PACS dataset for each target domain. The three triangles indicate model weights chosen at the end of training phase with equal intervals. Each plane is defined by the three weights and losses upon the plane are visualized with contours. The center cross mark is averaged point of the three weights. The first and second rows show the averaged training loss and the test loss surfaces, respectively.
+
+![](images/1556786cc200b405880ee4ae90530162a87adce971d22c005304ed2740cab5b6.jpg)  
+Figure 5: Validation accuracies for in-domains. The $X \mathrm { - }$ and Y-axis indicate the training iterations and accuracy, respectively, about the validation domains (legend) and the test domain (caption). The vertical dot lines represent start and end iterations, $t _ { s }$ and $t _ { e }$ , identified by the overfit-aware sampling strategy of SWAD.
+
+In Figure 3, we compare ${ \mathcal { F } } _ { \gamma } ( \theta )$ of ERM, SAM, SWA with cyclic learning rate, SWA with constant learning rate, and SWAD by varying radius $\gamma$ . SAM and SWA find the solutions with lower local flatness than ERM on average. SWAD finds the most flat minimum in every experiment.
+
+Loss surface visualization. We visualize the loss landscapes by choosing three model weights on the optimization trajectory $( \theta _ { 1 } , \theta _ { 2 } , \theta _ { 3 } ) ^ { 2 }$ , and computing the loss values by linear combinations of $\theta _ { 1 } , \theta _ { 2 } , \theta _ { 3 } { } ^ { 3 }$ as [25]. More details are in Appendix B.5. In Figure 4, we observe that for all cases, ERM solutions are located at the boundary of a flat minimum of training loss, resulting in poor generalizability in test domains, that is aligned with our theoretical analysis and empirical flatness analysis. Since ERM solutions are located on the boundary of a flat loss surface, we observe that ERM solutions are very sensitive to model selection. In Figure 5, we illustrate the validation accuracies for each train-test domain combination of PACS by ERM, over training iterations (one epoch is equivalent to 83 iterations). We first observe that ERM rapidly reaches the best accuracy within only a few training epochs, namely less than 6 epochs. Furthermore, the ERM validation accuracies fluctuate a lot, and the final performance is very sensitive to the model selection criterion.
+
+On the other hand, we observe that SWA solutions are located on the center of the training loss surfaces as well as of the test loss surfaces (Figure 4). Also, our overfit-aware stochastic weight gathering strategy (denoted as the vertical dot lines in Figure 5) prevents the ensembled weight from overfitting and makes SWAD model selection-free.
+
+Table 2: Comparison with domain generalization methods and SWAD. Out-of-domain accuracies on five domain generalization benchmarks are shown. We highlight the best results and the second best results. Note that ERM (reproduced), Mixstyle are reproduced numbers, and other numbers are from the original literature and Gulrajani and Lopez-Paz [22] (denoted with †). Our experiments are repeated three times.   
+
+<table><tr><td>Algorithm</td><td>PACS</td><td>VLCS</td><td>OfficeHome</td><td>TerraInc</td><td>DomainNet</td><td>Avg.</td></tr><tr><td>MASF[14]</td><td>82.7</td><td>=</td><td></td><td></td><td></td><td>=</td></tr><tr><td>DMG [33]</td><td>83.4</td><td>=</td><td></td><td></td><td>43.6</td><td>=</td></tr><tr><td>MetaReg [15]</td><td>83.6</td><td>=</td><td></td><td></td><td>43.6</td><td></td></tr><tr><td>ER[12]</td><td>85.3</td><td></td><td>=</td><td></td><td>-</td><td>=</td></tr><tr><td>pAdaIN [47]</td><td>85.4</td><td>=</td><td></td><td></td><td>=</td><td></td></tr><tr><td>EISNet [48]</td><td>85.8</td><td></td><td></td><td></td><td></td><td></td></tr><tr><td>DSON [30]</td><td>86.6</td><td>=</td><td></td><td>=</td><td>=</td><td>=</td></tr><tr><td>ERM+ [29]</td><td>85.5</td><td>77.5</td><td>66.5</td><td>46.1</td><td>40.9</td><td>63.3</td></tr><tr><td>ERM (reproduced)</td><td>84.2</td><td>77.3</td><td>67.6</td><td>47.8</td><td>44.0</td><td>64.2</td></tr><tr><td>IRM+ [20]</td><td>83.5</td><td>78.6</td><td>64.3</td><td>47.6</td><td>33.9</td><td>61.6</td></tr><tr><td>GroupDRO+ [49]</td><td>84.4</td><td>76.7</td><td>66.0</td><td>43.2</td><td>33.3</td><td>60.7</td></tr><tr><td>I-Mixup† [50-52]</td><td>84.6</td><td>77.4</td><td>68.1</td><td>47.9</td><td>39.2</td><td>63.4</td></tr><tr><td>MLDG+ [13]</td><td>84.9</td><td>77.2</td><td>66.8</td><td>47.8</td><td>41.2</td><td>63.6</td></tr><tr><td>CORAL† [31]</td><td>86.2</td><td>78.8</td><td>68.7</td><td>47.7</td><td>41.5</td><td>64.5</td></tr><tr><td>MMD† [53]</td><td>84.7</td><td>77.5</td><td>66.4</td><td>42.2</td><td>23.4</td><td>58.8</td></tr><tr><td>DANN+ [9]</td><td>83.7</td><td>78.6</td><td>65.9</td><td>46.7</td><td>38.3</td><td>62.6</td></tr><tr><td>CDANN† [10]</td><td>82.6</td><td>77.5</td><td>65.7</td><td>45.8</td><td>38.3</td><td>62.0</td></tr><tr><td>MTL+ [54]</td><td>84.6</td><td>77.2</td><td>66.4</td><td>45.6</td><td>40.6</td><td>62.9</td></tr><tr><td>SagNet† [32]</td><td>86.3</td><td>77.8</td><td>68.1</td><td>48.6</td><td>40.3</td><td>64.2</td></tr><tr><td>ARM+ [16]</td><td>85.1</td><td>77.6</td><td>64.8</td><td>45.5</td><td>35.5</td><td>61.7</td></tr><tr><td>VREx+ [21]</td><td>84.9</td><td>78.3</td><td>66.4</td><td>46.4</td><td>33.6</td><td>61.9</td></tr><tr><td>RSC+ [55]</td><td>85.2</td><td>77.1</td><td>65.5</td><td>46.6</td><td>38.9</td><td>62.7</td></tr><tr><td>Mixstyle [17]</td><td>85.2</td><td>77.9</td><td>60.4</td><td>44.0</td><td>34.0</td><td>60.3</td></tr><tr><td>SWAD (ours)</td><td>88.1 (±0.1)</td><td>79.1 (±0.1)</td><td>70.6 (±0.2)</td><td>50.0 (±0.3)</td><td>46.5 (±0.1)</td><td>66.9</td></tr></table>
+
+# 4 Experiments
+
+# 4.1 Evaluation protocols
+
+Dataset and optimization protocol. Following Gulrajani and Lopez-Paz [22], we exhaustively evaluate our method and comparison methods on various benchmarks: PACS [7] (9,991 images, 7 classes, and 4 domains), VLCS [43] (10,729 images, 5 classes, and 4 domains), OfficeHome [44] (15,588 images, 65 classes, and 4 domains), TerraIncognita [45] (24,788 images, 10 classes, and 4 domains), and DomainNet [46] (586,575 images, 345 classes, and 6 domains).
+
+For a fair comparison, we follow training and evaluation protocol by Gulrajani and Lopez-Paz [22], including the dataset splits, hyperparameter (HP) search and model selection (while SWAD does not need it) on the validation set, and optimizer HP, except the HP search space and the number of iterations for DomainNet. We use a reduced HP search space to reduce the computational costs. We also tripled the number of iterations for DomainNet from 5,000 to 15,000 because we observe that 5,000 is not sufficient to convergence. We re-evaluate ERM with 15,000 iterations, and observe $3 . 1 \mathrm { p p }$ average performance improvement $( 4 0 . 9 \%  4 4 . 0 \% )$ ) in DomainNet. For training, we choose a domain as the target domain and use the remaining domains as the training domain where $20 \%$ samples are used for validation and model selection. ImageNet [42] trained ResNet-50 [41] is employed as the initial weight, and optimized by Adam [38] optimizer with a learning rate of 5e-5. We construct a mini-batch containing all domains where each domain has 32 images. We set SWAD HPs $N _ { s }$ to 3, $N _ { e }$ to 6, and $r$ to 1.2 for VLCS and 1.3 for the others by HP search on the validation sets. Additional implementation details, such as other HPs, are given in Appendix B.
+
+Evaluation metrics. We report out-of-domain accuracies for each domain and their average, i.e., a model is trained and validated on training domains and evaluated on the unseen target domain. Each out-of-domain performance is an average of three different runs with different train-validation splits.
+
+Comparison with domain generalization methods. We report the full out-of-domain performances on five DG benchmarks in Table 2. The full tables including outof-domain accuracies for each domain are in Appendix E. In all experiments, our SWAD achieves significant performance gain against ERM as well as the previous best results: $+ 2 . 6 \mathrm { p p }$ in PACS, $+ 0 . 3 \mathrm { p p }$ in VLCS, $+ 1 . 4 \mathrm { p p }$ in TerraIncognita, $+ 1 . 9 \mathrm { p p }$ in OfficeHome, and $+ 2 . 9 \mathrm { p p }$ in DomainNet comparing to the previous best results. We observe that SWAD provides two practical advantages comparing to previous methods. First, SWAD does not need any modification on training objectives or model architecture, i.e., it is universally applicable to any other methods. As an example, we show that SWAD actually improves the performances of other DG methods, such as CORAL [31] in Table 4. Moreover, as we discussed before, SWAD is free to the model selection, resulting in stable performances (i.e., small standard errors) on various benchmarks. Note that we only compare results with ResNet-50 backbone for a fair comparison. We describe the implementation details of each comparison method and the hyperparameter search protocol in Appendix B.
+
+Table 3: Comparison between generalization methods on PACS. The scores are averaged over all settings using different target domains. $( \uparrow )$ and $\cdot$ indicate statistically significant improvement and degradation from ERM.   
+
+<table><tr><td colspan="2">Out-of-domain In-domain</td></tr><tr><td>ERM</td><td>85.3±0.4 96.6±0.0 85.5±0.4(-) 97.0±0.1(↑)</td></tr><tr><td>EMA SAM</td><td>85.5±0.1(-) 97.4±0.1(↑)</td></tr><tr><td>Mixup</td><td>84.8±0.3(-) 97.3±0.1(1)</td></tr><tr><td>CutMix</td><td>83.8±0.4(↓) 97.6±0.1(↑)</td></tr><tr><td>VAT</td><td>85.4±0.6(-) 96.9±0.2(↑)</td></tr><tr><td>II-model</td><td>83.5±0.5(↓) 96.8±0.2(1)</td></tr><tr><td>SWA SWAD</td><td>85.9±0.1(↑) 97.1±0.1(↑) 87.1±0.2(↑) 97.7±0.1(↑)</td></tr></table>
+
+Comparison with conventional generalization methods. We also compare SWAD with other conventional generalization methods to show that the remarkable domain generalization gaps by SWAD is not achieved by better generalization, but by seeking flat minima. The comparison methods include flatness-aware optimization methods, such as SAM [26], ensemble methods, such as EMA [56], data augmentation methods, such as Mixup [35] and CutMix [36], and consistency regularization methods, such as VAT [57] and $\Pi$ -model [58]. We also split in-domain datasets into training $( 6 0 \% )$ , validation $( 2 0 \% )$ , and test $( 2 0 \% )$ splits, while no in-domain test set used for Table 2. Every experiment is repeated three times.
+
+The results are shown in Table 3. We observe that all conventional methods helps in-domain generalization, i.e., performing better than ERM on in-domain test set. However, their out-of-domain performances are similar to or even worse than ERM. For example, CutMix and Π-model improve in-domain performances by $1 . 0 \mathrm { p p }$ and $0 . 2 \mathrm { p p }$ but degrade out-of-domain performances by $1 . 5 \mathrm { p p }$ and $1 . 8 \mathrm { p p }$ . SAM, another method for seeking flat minima, slightly increases both in-domain and out-of-domain performances but the out-of-domain performance is not statistically significant. We will discuss performances of SAM in other benchmarks later. In contrast, the vanilla SWA and our SWAD significantly improve both in-domain and out-of-domain performances. SWAD improves the performances by SWA with statistically significantly gaps: $1 . 2 \mathrm { p p }$ on the out-of-domain and $0 . 6 \mathrm { p p }$ on the in-domain. Further comparison between SWA and SWAD is provided in $\ S 4 . 3$ .
+
+Table 4: Combination of SWAD and other methods. The scores are averaged over every target domain case. The performances of ERM, CORAL, and SAM are optimized by HP searches of DomainBed. In contrast, for the SWAD combination cases, CORAL and SAM use default HPs without additional HP search. We additionally compare SWAD to $\mathrm { S W A } _ { \mathrm { w / c o n s t } }$ . Note that $\mathrm { E R M + S W A D }$ is same as “SWAD” in Table 2.   
+
+<table><tr><td></td><td>PACS</td><td>VLCS</td><td>OfficeHome</td><td>TerraInc</td><td>DomainNet</td><td>Avg. (△)</td></tr><tr><td>ERM</td><td>85.5 ±0.2</td><td>77.5 ±0.4</td><td>66.5 ±0.3</td><td>46.1 ±1.8</td><td>40.9 ±0.1</td><td>63.3</td></tr><tr><td>ERM + SWAw/ const</td><td>86.9 ±0.2</td><td>76.6 ±0.1</td><td>69.3 ±0.3</td><td>49.2 ±1.2</td><td>45.9 ±0.0</td><td>65.6 (+2.3)</td></tr><tr><td>ERM + SWAD</td><td>88.1 ±0.1</td><td>79.1 ±0.1</td><td>70.6 ±0.2</td><td>50.0±0.3</td><td>46.5 ±0.1</td><td>66.9 (+3.6)</td></tr><tr><td>CORAL</td><td>86.2 ±0.3</td><td>78.8 ±0.6</td><td>68.7 ±0.3</td><td>47.6 ±1.0</td><td>41.5 ±0.1</td><td>64.5</td></tr><tr><td>CORAL + SWAD</td><td>88.3 ±0.1</td><td>78.9 ±0.1</td><td>71.3 ±0.1</td><td>51.0 ±0.1</td><td>46.8 ±0.0</td><td>67.3 (+2.8)</td></tr><tr><td>SAM</td><td>85.8 ±0.2</td><td>79.4 ±0.1</td><td>69.6 ±0.1</td><td>43.3 ±0.7</td><td>44.3 ±0.0</td><td>64.5</td></tr><tr><td> SAM + SWAD</td><td>87.1 ±0.2</td><td>78.5 ±0.2</td><td>69.9 ±0.1</td><td>45.3 ±0.9</td><td>46.5 ±0.1</td><td>65.5 (+1.0)</td></tr></table>
+
+Combinations with other methods. Since SWAD does not require any modification on training procedures and model architectures, SWAD is universally applicable to any other methods. Here, we combine SWAD with ERM, CORAL [31], and SAM [26]. Results are shown in Table 4. Both CORAL and SAM solely show better performances than ERM with $+ 1 . 2 \mathrm { p p }$ average out-of-domain accuracy gap. Note that SAM is not a DG method but a sharpness-aware optimization method to find flat minima. It supports our theoretical motivation: DG can be achieved by seeking flat minima.
+
+By applying SWAD on the baselines, the performances are consistently improved by 3.6pp on ERM, $2 . 8 \mathrm { p p }$ on CORAL, and $1 . 0 \mathrm { p p }$ on SAM. Interestingly, $\mathrm { C O R A L } + \mathrm { S W A D }$ show the best performances with both incorporating different advantages of utilizing domain labels and seeking flat minima. We also observe that $\mathrm { S A M + S W A D }$ shows worse performance than $\mathrm { E R M + S W A D }$ , while SAM performs better than ERM. We conjecture that it is because the objective control by SAM restricts the model parameter diversity durinig training, reducing the diversity for SWA ensemble. However, applying SWAD on SAM still leads to better performances than the sole SAM. The results demonstrate that the application of SWAD on other baselines is a simple yet effective method for DG.
+
+# 4.3 Ablation study
+
+Table 5: Ablation studies of the stochastic weights selection strategies on PACS and VLCS. In the configuration, $^ { 6 * } t _ { s } { } ^ { , 3 } , ^ { 6 * } t _ { e } { } ^ { , 3 } ,$ , “lr”, and “interval” indicate start and end iterations of sampling, a learning rate schedule, and a stochastic weight sampling interval, respectively. “Opt” and “Overfit” indicate the start and end iterations identified by our overfit-aware sampling strategy, and “Val” means the start and end iterations whose averaging shows the best accuracy on the validation set. “Cyclic” and “Const” represent cyclic and constant learning rate schedules. All experiments are repeated three times.   
+
+<table><tr><td rowspan="2"></td><td colspan="4">Configuration</td><td colspan="3">Out-of-domain</td><td colspan="3">In-domain</td></tr><tr><td>ts</td><td>te</td><td>lr</td><td>interval</td><td>PACS</td><td>VLCS</td><td>Avg.</td><td>PACS</td><td>VLCS</td><td>Avg.</td></tr><tr><td>SWAw/ cyclic</td><td>4000</td><td>5000</td><td>Cyclic</td><td>100</td><td>85.9 ±0.1</td><td>76.6 ±0.1</td><td>81.2</td><td>97.1 ±0.1</td><td>85.0 ±0.2</td><td>91.0</td></tr><tr><td>SWAw/ const</td><td>4000</td><td>5000</td><td>Const</td><td>100</td><td>86.5 ±0.3</td><td>76.7 ±0.2</td><td>81.6</td><td>97.3 ±0.1</td><td>85.0 ±0.2</td><td>91.1</td></tr><tr><td>S WADw/o Dense</td><td>Opt</td><td>Overfit</td><td>Const</td><td>100</td><td>86.5 ±0.4</td><td>78.0 ±0.7</td><td>82.2</td><td>97.6±0.1</td><td>85.8 ±0.4</td><td>91.7</td></tr><tr><td>S WADw/o Opt-Overfit</td><td>4000</td><td>5000</td><td>Const</td><td>1</td><td>86.6 ±0.6</td><td>76.9 ±0.3</td><td>81.7</td><td>97.5 ±0.1</td><td>85.2 ±0.1</td><td>91.3</td></tr><tr><td>SWADw/o Overfit</td><td>Opt</td><td>5000</td><td>Const</td><td>1</td><td>87.1 ±0.3</td><td>77.6 ±0.1</td><td>82.4</td><td>97.7 ±0.1</td><td>85.8±0.3</td><td>91.8</td></tr><tr><td>S WADfit-on-val</td><td>Val</td><td>Val</td><td>Const</td><td>1</td><td>86.2 ±0.2</td><td>78.6 ±0.1</td><td>82.4</td><td>97.5 ±0.2</td><td>85.8 ±0.3</td><td>91.7</td></tr><tr><td>SWAD (proposed)</td><td>Opt</td><td>Overfit</td><td>Const</td><td>1</td><td>87.1 ±0.2</td><td>78.9 ±0.2</td><td>83.0</td><td>97.7 ±0.1</td><td>86.1 ±0.5</td><td>91.9</td></tr></table>
+
+Table 5 provides ablative studies on the starting and ending iterations for averaging, the learning rate schedule, and the sampling interval. SWAw/ cyclic (SWA in Table 3) and $\operatorname { S W A } _ { \mathrm { w } / }$ constant are vanilla SWAs with fixed sampling positions. We also report SWAD by eliminating three factors: the dense sampling strategy, and searching the start iteration, searching the end iteration. The dense sampling strategy lets SWAD estimate a more accurate approximation of flat minima: showing $0 . 8 \mathrm { p p }$ degeneration in the average out-of-domain accuracy $( \mathrm { S W A D _ { w / o D e n s e } } )$ . When we take an average from $t _ { s }$ to the final iteration, the out-of-domain performance degrades by $0 . 6 \mathrm { p p }$ $\mathrm { \Delta S W A D _ { w / o } }$ Overfit). Similarly, a fixed scheduling without the overfit-aware scheduling only shows very marginal improvements from the vanilla SWA (SWADw/o Opt-Overfit). We also evaluate $\mathbf { S W A D _ { f i t - o n - v a l } }$ that uses the range achieving the best performances on the validation set, but it becomes overfitted to the validation, results in lower performances than SWAD. The results demonstrate the benefits of combining “dense” and “overfit-aware” sampling strategies of SWAD.
+
+# 4.4 Exploring the other applications: ImageNet robustness
+
+Table 6: ImageNet robustness benchmarks. We show the ImageNet generalization performances on ImageNet-C, background challenge (BGC), and ImageNet-R.   
+
+<table><tr><td>Method</td><td>ImageNet (%) ↑</td><td>ImageNet-C (mCE)↓</td><td>BGC (%) ↑</td><td>ImageNet-R(%) ↑</td></tr><tr><td>ERM</td><td>76.5</td><td>57.6</td><td>8.7</td><td>36.7</td></tr><tr><td>SWA</td><td>76.9</td><td>56.8</td><td>10.9</td><td>37.5</td></tr><tr><td>SWAD (ours)</td><td>77.0</td><td>55.7</td><td>11.8</td><td>38.8</td></tr></table>
+
+Since SWAD does not rely on domain labels, it can be applied to other robustness tasks not containing domain labels. Table 6 show the generalizability of SWAD on ImageNet [42] and its shifted benchmarks, namely, ImageNet-C [59], ImageNet-R [60], and background challenge (BGC) [61]. SWAD consistently improves robustness performances against the ERM baseline and the SWA baseline. These results support that our method is robustly and widely applicable to improve both in-domain and out-of-domain generalizability. The detailed setup is provided in Appendix B.6.
+
+# 5 Discussion and Limitations
+
+Despite many benefits from SWAD, such as the significant performance improvements, model selection-free property, working plug-and-play manner for various methods, there are some potential limitations. Here, we discuss the limitations of SWAD for further improvements.
+
+Confidence error in Theorem 1. While the confidence error in Theorem 1 tells the effect of $\gamma$ on generalization error bound, there exists a limitation in that the confidence error term shows improper behavior with respect to $\gamma$ if $\gamma$ is close to zero. The behavior we expect is that the confidence error of RRM converges to the confidence error of ERM as $\gamma$ decreases to zero, however, the current theorem does not show such tendency since the confidence bound diverges to infinity when $\gamma$ goes to zero. However, we would like to note that this limitation is not a drawback of RRM, but it is caused by the looseness of the union bound which is a mathematical technique used to derive the confidence error of RRM. Our RRM formulation has a similarity to previous works [26, 34] and we note that the counter-intuitive behavior of the confidence bound and $\gamma$ also appears in Foret et al. [26].
+
+SWAD is not a perfect flatness-aware optimization method. Note that SWAD is not a perfect and theoretically guaranteed solver for flat minima, but a heuristic approximation with empirical benefits. However, even if a better flatness-aware optimization method is proposed, our theoretical contribution still holds: showing the relationship between flat minima and DG.
+
+SWAD does not strongly utilize domain-specific information. In Theorem 2, the domain generalization gap is bounded by three factors: flat minima, domain discrepancy, and confidence bound. Most of the existing approaches focus on domain discrepancy, reducing the difference between the source domains and the target domain by domain invariant learning [8–12]. SWAD focuses on the first factor, the flat minima. While the domain labels are used to construct a mini-batch, SWAD does not strongly utilize domain-specific information. It implies that if one can consider both flatness and domain discrepancy, better domain generalization can be achievable. Table 4 gives us a clue: the combination of CORAL (utilizing domain-specific information) and SWAD (seeking flat minima) shows the best performance among all comparison methods. As a future research direction, we encourage studying a method that can achieve both flat optima and small domain discrepancy.
+
+# 6 Concluding Remarks
+
+In this paper, we theoretically and empirically demonstrate that domain generalization (DG) is achievable by seeking flat minima. We propose SWAD that captures flatter minima than the vanilla SWA does. The extensive experiments on five DG benchmarks show superior performances of SWAD compared with existing DG methods. In addition, combinations of SWAD and existing DG methods even show better performances than the vanilla SWAD. We theoretically and empirically observe that seeking flat minima can achieve better generalizability to both in-domain and out-of-domain, while strong in-domain generalization methods without consideration of flatness, e.g., Mixup or CutMix, cannot guarantee to achieve out-of-domain generalizability in both theory and practice. This study first brings the concept of flatness into DG tasks, and shows strong empirical performances not only in DG but also in ImageNet benchmarks. We hope that this study promotes a new research direction of seeking flat minima for domain generalization and other robustness tasks.
+
+# Acknowledgments and Disclosure of Funding
+
+NAVER Smart Machine Learning (NSML) [62] and Kakao Brain Cloud platform have been used in experiments. This work was supported by IITP grant funded by the Korea government (MSIT) (No. 2021-0-01341, AI Graduate School Program, CAU).
+
+References   
+[1] Dengxin Dai and Luc Van Gool. Dark model adaptation: Semantic image segmentation from daytime to nighttime. In 2018 21st International Conference on Intelligent Transportation Systems (ITSC), pages 3819–3824. IEEE, 2018.   
+[2] Claudio Michaelis, Benjamin Mitzkus, Robert Geirhos, Evgenia Rusak, Oliver Bringmann, Alexander S Ecker, Matthias Bethge, and Wieland Brendel. Benchmarking robustness in object detection: Autonomous driving when winter is coming. arXiv preprint arXiv:1907.07484, 2019.   
+[3] Terrance de Vries, Ishan Misra, Changhan Wang, and Laurens van der Maaten. Does object recognition work for everyone? In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition Workshops, pages 52–59, 2019.   
+[4] Kaiyu Yang, Klint Qinami, Li Fei-Fei, Jia Deng, and Olga Russakovsky. Towards fairer datasets: Filtering and balancing the distribution of the people subtree in the imagenet hierarchy. In Proceedings of the 2020 Conference on Fairness, Accountability, and Transparency, pages 547–558, 2020.   
+[5] Robert Geirhos, Patricia Rubisch, Claudio Michaelis, Matthias Bethge, Felix A. Wichmann, and Wieland Brendel. Imagenet-trained cnns are biased towards texture; increasing shape bias improves accuracy and robustness. In International Conference on Learning Representations, 2019.   
+[6] Sara Beery, Grant Van Horn, and Pietro Perona. Recognition in terra incognita. In Proceedings of the European Conference on Computer Vision (ECCV), pages 456–473, 2018.   
+[7] Da Li, Yongxin Yang, Yi-Zhe Song, and Timothy M Hospedales. Deeper, broader and artier domain generalization. In IEEE International Conference on Computer Vision, pages 5542– 5550, 2017.   
+[8] Krikamol Muandet, David Balduzzi, and Bernhard Schölkopf. Domain generalization via invariant feature representation. In International Conference on Machine Learning, pages 10–18. PMLR, 2013.   
+[9] Yaroslav Ganin, Evgeniya Ustinova, Hana Ajakan, Pascal Germain, Hugo Larochelle, François Laviolette, Mario Marchand, and Victor Lempitsky. Domain-adversarial training of neural networks. Journal of machine learning research, 17(1):2096–2030, 2016.   
+[10] Ya Li, Mingming Gong, Xinmei Tian, Tongliang Liu, and Dacheng Tao. Domain generalization via conditional invariant representations. In AAAI Conference on Artificial Intelligence, volume 32, 2018.   
+[11] Hyojin Bahng, Sanghyuk Chun, Sangdoo Yun, Jaegul Choo, and Seong Joon Oh. Learning de-biased representations with biased representations. In International Conference on Machine Learning (ICML), 2020.   
+[12] Shanshan Zhao, Mingming Gong, Tongliang Liu, Huan Fu, and Dacheng Tao. Domain generalization via entropy regularization. Neural Information Processing Systems, 33, 2020.   
+[13] Da Li, Yongxin Yang, Yi-Zhe Song, and Timothy Hospedales. Learning to generalize: Metalearning for domain generalization. In AAAI Conference on Artificial Intelligence, volume 32, 2018.   
+[14] Qi Dou, Daniel C Castro, Konstantinos Kamnitsas, and Ben Glocker. Domain generalization via model-agnostic learning of semantic features. Neural Information Processing System, 2019.   
+[15] Yogesh Balaji, Swami Sankaranarayanan, and Rama Chellappa. Metareg: Towards domain generalization using meta-regularization. Neural Information Processing Systems, 31:998–1008, 2018.   
+[16] Marvin Zhang, Henrik Marklund, Abhishek Gupta, Sergey Levine, and Chelsea Finn. Adaptive risk minimization: A meta-learning approach for tackling group shift. arXiv preprint arXiv:2007.02931, 2020.
+
+[17] Kaiyang Zhou, Yongxin Yang, Yu Qiao, and Tao Xiang. Domain generalization with mixstyle. In International Conference on Learning Representations, 2021.
+
+[18] Shiv Shankar, Vihari Piratla, Soumen Chakrabarti, Siddhartha Chaudhuri, Preethi Jyothi, and Sunita Sarawagi. Generalizing across domains via cross-gradient training. In International Conference on Learning Representations, 2018.
+
+[19] Fabio M Carlucci, Antonio D’Innocente, Silvia Bucci, Barbara Caputo, and Tatiana Tommasi. Domain generalization by solving jigsaw puzzles. In IEEE/CVF Conference on Computer Vision and Pattern Recognition, pages 2229–2238, 2019.
+
+[20] Martin Arjovsky, Léon Bottou, Ishaan Gulrajani, and David Lopez-Paz. Invariant risk minimization. arXiv preprint arXiv:1907.02893, 2019.
+
+[21] David Krueger, Ethan Caballero, Joern-Henrik Jacobsen, Amy Zhang, Jonathan Binas, Remi Le Priol, and Aaron Courville. Out-of-distribution generalization via risk extrapolation (rex). arXiv preprint arXiv:2003.00688, 2020.
+
+[22] Ishaan Gulrajani and David Lopez-Paz. In search of lost domain generalization. In International Conference on Learning Representations, 2021.
+
+[23] Nitish Shirish Keskar, Dheevatsa Mudigere, Jorge Nocedal, Mikhail Smelyanskiy, and Ping Tak Peter Tang. On large-batch training for deep learning: Generalization gap and sharp minima. In International Conference on Learning Representations, 2017.
+
+[24] Timur Garipov, Pavel Izmailov, Dmitrii Podoprikhin, Dmitry P Vetrov, and Andrew Gordon Wilson. Loss surfaces, mode connectivity, and fast ensembling of dnns. In Neural Information Processing Systems, 2018.
+
+[25] Pavel Izmailov, Dmitrii Podoprikhin, Timur Garipov, Dmitry Vetrov, and Andrew Gordon Wilson. Averaging weights leads to wider optima and better generalization. Conference on Uncertainty in Artificial Intelligence, 2018.
+
+[26] Pierre Foret, Ariel Kleiner, Hossein Mobahi, and Behnam Neyshabur. Sharpness-aware minimization for efficiently improving generalization. In International Conference on Learning Representations, 2021.
+
+[27] Gintare Karolina Dziugaite and Daniel M Roy. Computing nonvacuous generalization bounds for deep (stochastic) neural networks with many more parameters than training data. In Uncertainty in Artificial Intelligence, 2017.
+
+[28] Yiding Jiang, Behnam Neyshabur, Hossein Mobahi, Dilip Krishnan, and Samy Bengio. Fantastic generalization measures and where to find them. arXiv preprint arXiv:1912.02178, 2019.
+
+[29] V Vapnik. Statistical learning theory. NY: Wiley, 1998.
+
+[30] Seonguk Seo, Yumin Suh, Dongwan Kim, Jongwoo Han, and Bohyung Han. Learning to optimize domain specific normalization for domain generalization. European Conference on Computer Vision, 2020.
+
+[31] Baochen Sun and Kate Saenko. Deep coral: Correlation alignment for deep domain adaptation. In European conference on computer vision, pages 443–450. Springer, 2016.
+
+[32] Hyeonseob Nam, HyunJae Lee, Jongchan Park, Wonjun Yoon, and Donggeun Yoo. Reducing domain gap by reducing style bias. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, pages 8690–8699, 2021.
+
+[33] Prithvijit Chattopadhyay, Yogesh Balaji, and Judy Hoffman. Learning to balance specificity and invariance for in and out of domain generalization. In European Conference on Computer Vision, pages 301–318. Springer, 2020.
+
+[34] Matthew Norton and Johannes O Royset. Diametrical risk minimization: Theory and computations. arXiv preprint arXiv:1910.10844, 2019.
+
+[35] Hongyi Zhang, Moustapha Cisse, Yann N. Dauphin, and David Lopez-Paz. mixup: Beyond empirical risk minimization. International Conference on Learning Representations, 2018.   
+[36] Sangdoo Yun, Dongyoon Han, Seong Joon Oh, Sanghyuk Chun, Junsuk Choe, and Youngjoon Yoo. Cutmix: Regularization strategy to train strong classifiers with localizable features. In International Conference on Computer Vision (ICCV), 2019.   
+[37] Shai Ben-David, John Blitzer, Koby Crammer, Alex Kulesza, Fernando Pereira, and Jennifer Wortman Vaughan. A theory of learning from different domains. Machine learning, 79(1): 151–175, 2010.   
+[38] Diederik P Kingma and Jimmy Ba. Adam: A method for stochastic optimization. In International Conference on Learning Representations, 2015.   
+[39] Pratik Chaudhari, Anna Choromanska, Stefano Soatto, Yann LeCun, Carlo Baldassi, Christian Borgs, Jennifer Chayes, Levent Sagun, and Riccardo Zecchina. Entropy-sgd: Biasing gradient descent into wide valleys. Journal of Statistical Mechanics: Theory and Experiment, 2019(12): 124018, 2019.   
+[40] Leslie N Smith. Cyclical learning rates for training neural networks. In 2017 IEEE winter conference on applications of computer vision (WACV), pages 464–472. IEEE, 2017.   
+[41] Kaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. Deep residual learning for image recognition. In IEEE Conference on Computer Vision and Pattern Recognition, 2016.   
+[42] Olga Russakovsky, Jia Deng, Hao Su, Jonathan Krause, Sanjeev Satheesh, Sean Ma, Zhiheng Huang, Andrej Karpathy, Aditya Khosla, Michael Bernstein, et al. Imagenet large scale visual recognition challenge. International Journal of Computer Vision, 115(3):211–252, 2015.   
+[43] Chen Fang, Ye Xu, and Daniel N Rockmore. Unbiased metric learning: On the utilization of multiple datasets and web images for softening bias. In IEEE International Conference on Computer Vision, pages 1657–1664, 2013.   
+[44] Hemanth Venkateswara, Jose Eusebio, Shayok Chakraborty, and Sethuraman Panchanathan. Deep hashing network for unsupervised domain adaptation. In IEEE conference on computer vision and pattern recognition, pages 5018–5027, 2017.   
+[45] Sara Beery, Grant Van Horn, and Pietro Perona. Recognition in terra incognita. In European Conference on Computer Vision, pages 456–473, 2018.   
+[46] Xingchao Peng, Qinxun Bai, Xide Xia, Zijun Huang, Kate Saenko, and Bo Wang. Moment matching for multi-source domain adaptation. In IEEE/CVF International Conference on Computer Vision, pages 1406–1415, 2019.   
+[47] Oren Nuriel, Sagie Benaim, and Lior Wolf. Permuted adain: Reducing the bias towards global statistics in image classification. In IEEE/CVF Conference on Computer Vision and Pattern Recognition, 2021.   
+[48] Shujun Wang, Lequan Yu, Caizi Li, Chi-Wing Fu, and Pheng-Ann Heng. Learning from extrinsic and intrinsic supervisions for domain generalization. In European Conference on Computer Vision, pages 159–176. Springer, 2020.   
+[49] Shiori Sagawa\*, Pang Wei Koh\*, Tatsunori B. Hashimoto, and Percy Liang. Distributionally robust neural networks. In International Conference on Learning Representations, 2020.   
+[50] Minghao Xu, Jian Zhang, Bingbing Ni, Teng Li, Chengjie Wang, Qi Tian, and Wenjun Zhang. Adversarial domain adaptation with domain mixup. In AAAI Conference on Artificial Intelligence, volume 34, pages 6502–6509, 2020.   
+[51] Shen Yan, Huan Song, Nanxiang Li, Lincan Zou, and Liu Ren. Improve unsupervised domain adaptation with mixup training. arXiv preprint arXiv:2001.00677, 2020.   
+[52] Yufei Wang, Haoliang Li, and Alex C Kot. Heterogeneous domain generalization via domain mixup. In IEEE International Conference on Acoustics, Speech and Signal Processing, pages 3622–3626. IEEE, 2020.   
+[53] Haoliang Li, Sinno Jialin Pan, Shiqi Wang, and Alex C Kot. Domain generalization with adversarial feature learning. In IEEE Conference on Computer Vision and Pattern Recognition, pages 5400–5409, 2018.   
+[54] Gilles Blanchard, Aniket Anand Deshmukh, Urun Dogan, Gyemin Lee, and Clayton Scott. Domain generalization by marginal transfer learning. Journal of Machine Learning Research, 22(2):1–55, 2021.   
+[55] Zeyi Huang, Haohan Wang, Eric P Xing, and Dong Huang. Self-challenging improves crossdomain generalization. European Conference on Computer Vision, 2, 2020.   
+[56] Boris T Polyak and Anatoli B Juditsky. Acceleration of stochastic approximation by averaging. SIAM journal on control and optimization, 30(4):838–855, 1992.   
+[57] Takeru Miyato, Shin-ichi Maeda, Masanori Koyama, and Shin Ishii. Virtual adversarial training: a regularization method for supervised and semi-supervised learning. IEEE Transactions on Pattern Analysis and Machine Intelligence, 41(8):1979–1993, 2018.   
+[58] Samuli Laine and Timo Aila. Temporal ensembling for semi-supervised learning. In International Conference on Learning Representations, 2017.   
+[59] Dan Hendrycks and Thomas Dietterich. Benchmarking neural network robustness to common corruptions and perturbations. In International Conference on Learning Representations, 2018.   
+[60] Dan Hendrycks, Steven Basart, Norman Mu, Saurav Kadavath, Frank Wang, Evan Dorundo, Rahul Desai, Tyler Zhu, Samyak Parajuli, Mike Guo, et al. The many faces of robustness: A critical analysis of out-of-distribution generalization. arXiv preprint arXiv:2006.16241, 2020.   
+[61] Kai Yuanqing Xiao, Logan Engstrom, Andrew Ilyas, and Aleksander Madry. Noise or signal: The role of image backgrounds in object recognition. In International Conference on Learning Representations, 2020.   
+[62] Hanjoo Kim, Minkyu Kim, Dongjoo Seo, Jinwoong Kim, Heungseok Park, Soeun Park, Hyunwoo Jo, KyungHyun Kim, Youngil Yang, Youngkwan Kim, et al. Nsml: Meet the mlaas platform with a real-world case study. arXiv preprint arXiv:1810.09957, 2018.

parse/train/zkHlu_3sJYU/zkHlu_3sJYU_content_list.json

@@ -0,0 +1,1149 @@
+[
+    {
+        "type": "text",
+        "text": "SWAD: Domain Generalization by Seeking Flat Minima ",
+        "text_level": 1,
+        "bbox": [
+            305,
+            122,
+            689,
+            172
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Junbum Cha1† Sanghyuk Chun2∗ Kyungjae Lee3∗ Han-Cheol Cho4 Seunghyun Park4 Yunsung Lee5 Sungrae Park6† ",
+        "bbox": [
+            240,
+            224,
+            753,
+            256
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 Kakao Brain 2 NAVER AI Lab 3 Chung-Ang University   \n4 NAVER Clova 5 Korea University 6 Upstage AI Research ",
+        "bbox": [
+            289,
+            267,
+            710,
+            297
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Abstract ",
+        "text_level": 1,
+        "bbox": [
+            462,
+            333,
+            535,
+            349
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Domain generalization (DG) methods aim to achieve generalizability to an unseen target domain by using only training data from the source domains. Although a variety of DG methods have been proposed, a recent study shows that under a fair evaluation protocol, called DomainBed, the simple empirical risk minimization (ERM) approach works comparable to or even outperforms previous methods. Unfortunately, simply solving ERM on a complex, non-convex loss function can easily lead to sub-optimal generalizability by seeking sharp minima. In this paper, we theoretically show that finding flat minima results in a smaller domain generalization gap. We also propose a simple yet effective method, named Stochastic Weight Averaging Densely (SWAD), to find flat minima. SWAD finds flatter minima and suffers less from overfitting than does the vanilla SWA by a dense and overfit-aware stochastic weight sampling strategy. SWAD shows state-of-the-art performances on five DG benchmarks, namely PACS, VLCS, OfficeHome, TerraIncognita, and DomainNet, with consistent and large margins of $+ 1 . 6 \\%$ averagely on outof-domain accuracy. We also compare SWAD with conventional generalization methods, such as data augmentation and consistency regularization methods, to verify that the remarkable performance improvements are originated from by seeking flat minima, not from better in-domain generalizability. Last but not least, SWAD is readily adaptable to existing DG methods without modification; the combination of SWAD and an existing DG method further improves DG performances. Source code is available at https://github.com/khanrc/swad. ",
+        "bbox": [
+            232,
+            358,
+            766,
+            648
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 Introduction ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            674,
+            312,
+            693
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Independent and identically distributed (i.i.d.) condition is the underlying assumption of machine learning experiments. However, this assumption may not hold in real-world scenarios, i.e., the training and the test data distribution may differ significantly by distribution shifts. For example, a self-driving car should adapt to adverse weather or day-to-night shifts [1, 2]. Even in a simple image recognition scenario, systems rely on wrong cues for their prediction, e.g., geographic distribution [3], demographic statistics [4], texture [5], or backgrounds [6]. Consequently, a practical system should require generalizability to distribution shift, which is yet often failed by traditional approaches. ",
+        "bbox": [
+            174,
+            703,
+            825,
+            801
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Domain generalization (DG) aims to address domain shift simulated by training and evaluating on different domains. DG tasks assume that both task labels and domain labels are accessible. For example, PACS dataset [7] has seven task labels (e.g., “dog”, “horse”) and four domain labels (e.g., “photo”, “sketch”). Previous approaches explicitly reduced domain gaps in the latent space $[ 8 -$ ",
+        "bbox": [
+            174,
+            806,
+            825,
+            863
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "table",
+        "img_path": "images/8f5b81be5d5fa3e25bad2d3b5bfaaee39e19115b5633c0957065478960c9a925.jpg",
+        "table_caption": [
+            "Table 1: Comparisons with SOTA. The proposed SWAD outperforms other state-of-the-art DG methods on five different DG benchmarks with significant gaps $( + 1 . 6 \\mathrm { p p }$ in the average). "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td></td><td>PACS</td><td>VLCS</td><td>OfficeHome</td><td>TerraInc</td><td>DomainNet</td><td>Avg.</td></tr><tr><td>ERM [29]</td><td>85.5</td><td>77.5</td><td>66.5</td><td>46.1</td><td>40.9</td><td>63.3</td></tr><tr><td>Best SOTA competitor</td><td>86.6 [30]</td><td>78.8 [31]</td><td>68.7 [31]</td><td>48.6 [32]</td><td>43.6[15,33]</td><td>65.3</td></tr><tr><td>SWAD (proposed)</td><td>88.1</td><td>79.1</td><td>70.6</td><td>50.0</td><td>46.5</td><td>66.9</td></tr><tr><td>Previous SOTA [31] + SWAD</td><td>88.3</td><td>78.9</td><td>71.3</td><td>51.0</td><td>46.8</td><td>67.3</td></tr></table>",
+        "bbox": [
+            173,
+            128,
+            821,
+            215
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "12], obtained well-transferable model parameters by the meta-learning framework [13–16], data augmentation [17–19], or capturing causal relation [20, 21]. Despite numerous previous attempts for a decade, Gulrajani and Lopez-Paz [22] showed that a simple empirical risk minimization (ERM) approach works comparably or even outperforms the previous attempts on diverse DG benchmarks under a fair evaluation protocol, called “DomainBed”. ",
+        "bbox": [
+            174,
+            229,
+            825,
+            299
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Unfortunately, although ERM showed surprising empirical success on DomainBed, simply minimizing the empirical loss on a complex and non-convex loss landscape is typically not sufficient to arrive at a good generalization [23–26]. In particular, the connection between the generalization gap and the flatness of loss landscapes has been actively discussed under the i.i.d. condition [23–28]. Izmailov et al. [25] argued that seeking flat minima will lead to robustness against the loss landscape shift between training and test datasets, while a simple ERM converges to the boundary of a wide flat minimum and achieves insufficient generalization. In the DG scenario, because training and test loss landscapes differ more drastically due to the domain shift, we conjecture that the generalization gap between flat and sharp minima is larger than expected in the i.i.d. scenario. ",
+        "bbox": [
+            174,
+            305,
+            825,
+            431
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "To show that flatter minima generalize better to unseen domains, we formulate a robust risk minimization (RRM) problem defined by the worst-case empirical risks within neighborhoods in parameter space [26, 34]. We theoretically show that the generalization gap of DG, i.e., the error on the target domain, is upper bounded by RRM, i.e., a flat optimal solution. Based on our theoretical observation, we modify stochastic weight averaging (SWA) [25], one of the popular existing flatness-aware solvers, by introducing a dense and overfit-aware stochastic weight sampling strategy. First, we suggest to sample weights densely, i.e., for every iteration. Also, we search the start and end iterations for averaging by considering the validation loss to avoid overfitting. We empirically show that the proposed Stochastic Weight Averaging Densely (SWAD) finds flatter minima than the vanilla SWA does, resulting in better generalization to unseen domains. ",
+        "bbox": [
+            174,
+            436,
+            825,
+            575
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Contribution. Our main contribution is introducing flatness into DG, and showing remarkably outperforming performances against existing DG methods. As shown in Table 1, our SWAD improves the average DG performances by 3.6pp against the ERM baseline and $1 . 6 \\mathrm { p p }$ against the existing best methods. Furthermore, by combining SWAD and previous SOTA [31], we even achieve $0 . 4 \\mathrm { p p }$ improvements against the vanilla SWAD results. We also empirically show that while popular indomain generalization methods without considering flatness, e.g., Mixup [35] or CutMix [36], are not effective to out-of-domain generalization (Table 3), flatness-aware methods, e.g., SWA [25] or SAM [26], are only effective methods to both in-domain and out-of-domain generalization. ",
+        "bbox": [
+            174,
+            582,
+            825,
+            693
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2 A Theoretical Relationship between Flatness and Domain Generalization ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            708,
+            812,
+            727
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Let $\\mathcal { D } : = \\{ \\mathcal { D } _ { i } \\} _ { i } ^ { I }$ be a set of training domains, where $\\mathcal { D } _ { i }$ is a distribution over input space $\\mathcal { X }$ , and $I$ is the total number of domains. From each domain, we observe $n$ training data points which consist of input $x$ and target label $y$ , $( \\boldsymbol { x } _ { j } ^ { i } , \\boldsymbol { y } _ { j } ^ { i } ) _ { j = 1 } ^ { n } \\sim \\mathcal { D } _ { i }$ . We also define a set of target domain $\\mathcal { T } : = \\left\\{ \\mathcal { T } _ { i } \\right\\} _ { i } ^ { T }$ similarly, where the number of target domains is usually set to one. For the sake of simplicity, unlike Ben-David et al. [37], we assume that there exists a global labeling function $h ( x )$ that generates target label for multiple domains, i.e., $y _ { j } ^ { i } = h ( x _ { j } ^ { i } )$ for all $i$ and $j$ . Domain generalization (DG) aims to find a model parameter $\\theta \\in \\Theta$ which generalizes well over both multiple training domains $\\mathcal { D }$ and unseen target domain $\\tau$ . More specifically, let us consider a bounded instance loss function $\\ell : \\mathcal { V } \\times \\mathcal { V }  \\mathbf { \\bar { \\mu } } [ 0 , c ]$ , such that $\\ell ( y _ { 1 } , y _ { 2 } ) = 0$ holds if and only if $y _ { 1 } ~ = ~ y _ { 2 }$ where $\\mathcal { V }$ is a set of labels. For simplicity, we set $c$ to one in our proofs, but we note that $\\ell ( \\cdot , \\cdot )$ can be generalized for any bounded loss function. Then, we can define a population loss over multiple domains by $\\begin{array} { r } { \\mathcal { E } _ { \\mathcal { D } } ( \\theta ) { \\bf \\tilde { \\theta } } = \\frac { 1 } { I } \\sum _ { i = 1 } ^ { I } \\mathbb { E } _ { x ^ { i } \\sim \\mathcal { D } _ { i } } [ \\ell ( f ( x ^ { i } ; \\theta ) , y ^ { i } ) ) ] } \\end{array}$ , where $f ( \\cdot ; \\theta )$ is a model parameterized by $\\theta$ . Formally, the goal of DG is to find a model which minimizes both $\\mathcal { E } _ { \\mathcal { D } } ( { \\boldsymbol { \\theta } } )$ and ${ \\mathcal { E } } _ { T } ( \\theta )$ by only minimizing an empirical risk $\\begin{array} { r } { \\hat { \\mathcal { E } } _ { \\mathcal { D } } ( \\boldsymbol { \\theta } ) : = \\frac { 1 } { I n } \\sum _ { i = 1 } ^ { I } \\sum _ { j = 1 } ^ { n } \\ell ( f ( x ^ { i } ; \\boldsymbol { \\theta } ) , y ^ { i } ) ) } \\end{array}$ over training domains $\\mathcal { D }$ . ",
+        "bbox": [
+            173,
+            738,
+            825,
+            912
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            90,
+            823,
+            126
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "In practice, ERM, i.e., $\\mathrm { a r g m i n } _ { \\theta } \\hat { \\mathcal { E } } _ { \\mathcal { D } } ( \\theta )$ , can have multiple solutions that provide similar values of the training losses but significantly different generalizability on $\\mathcal { E } _ { \\mathcal { D } } ( { \\boldsymbol { \\theta } } )$ and ${ \\mathcal { E } } _ { T } ( \\theta )$ . Unfortunately, the typical optimization methods, such as SGD and Adam [38], often lead sub-optimal generalizability as finding sharp and narrow minima even under the i.i.d. assumption [23–28]. In the DG scenario, the generalization gap between empirical loss and target domain loss becomes even worse due to domain shift. Here, we provide a theoretical interpretation of the relationship between finding a flat minimum and minimizing the domain generalization gap, inspired by previous studies [23–28]. ",
+        "bbox": [
+            173,
+            132,
+            826,
+            232
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "We consider a robust empirical loss function defined by the worst-case loss within neighborhoods in the parameter space as $\\begin{array} { r } { \\hat { \\mathcal { E } } _ { \\mathcal { D } } ^ { \\gamma } ( \\theta ) : = \\operatorname* { m a x } _ { \\| \\Delta \\| \\leq \\gamma } \\hat { \\mathcal { E } } _ { \\mathcal { D } } ( \\theta + \\Delta ) } \\end{array}$ , where $\\| \\cdot \\|$ denotes the L2 norm and $\\gamma$ is a radius which defines neighborhoods of $\\theta$ . Intuitively, if $\\gamma$ is sufficiently larger than the “radius” of a sharp optimum $\\theta _ { s }$ of $\\hat { \\mathcal { E } } _ { \\mathcal { D } } ( \\theta )$ , $\\theta _ { s }$ is no longer an optimum of $\\hat { \\mathcal { E } } _ { \\mathcal { D } } ^ { \\gamma } ( \\theta )$ as well as its neighborhoods within the $\\gamma$ -ball. On the other hand, if an optimum $\\theta _ { f }$ has larger “radius” than $\\gamma$ , there exists a local optimum within $\\gamma$ -ball – See Figure 1. Hence, solving the robust risk minimization (RRM), i.e., $\\arg \\operatorname* { m i n } _ { \\theta } \\hat { \\mathcal { E } } _ { \\mathcal { D } } ^ { \\gamma } ( \\theta )$ , will find a near solution of a flat optimum showing better generalizability [26, 34]. However, as domain shift worsen the generalization gap by breaking the i.i.d. assumption, it is not trivial that RRM will find an optimum with better DG performance. To answer the question, we first show the generalization bound between $\\hat { \\mathcal { E } } _ { \\mathcal { D } } ^ { \\gamma }$ and $\\mathcal { E } _ { T }$ as follows: ",
+        "bbox": [
+            173,
+            236,
+            544,
+            398
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "image",
+        "img_path": "images/0c298f89243367a5caeaf75d1a922847cc8cf15d5cc0345d520d5a5ecd0c8065.jpg",
+        "image_caption": [
+            "Figure 1: Robust risk minimization (RRM) and flat minima. With proper $\\gamma$ , RRM will find flat minima. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            568,
+            253,
+            816,
+            347
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            398,
+            825,
+            455
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Theorem 1. Consider a set of $N$ covers $\\{ \\Theta _ { k } \\} _ { k = 1 } ^ { N }$ such that the parameter space $\\Theta \\subset \\cup _ { k } ^ { N } \\Theta _ { k }$ where $\\begin{array} { r } { d i a m ( \\Theta ) : = \\operatorname* { s u p } _ { \\theta , \\theta ^ { \\prime } \\in \\Theta } \\| \\theta - \\theta ^ { \\prime } \\| _ { 2 } , N : = \\Big \\lceil ( d i a m ( \\Theta ) / \\gamma ) ^ { d } \\Big \\rceil } \\end{array}$ and $d$ is dimension of $\\Theta$ . Let $v _ { k }$ be a $V C$ dimension of each $\\Theta _ { k }$ . Then, for any $\\theta \\in \\Theta$ , the following bound holds with probability at least $1 - \\delta$ ",
+        "bbox": [
+            174,
+            458,
+            825,
+            512
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/d68071c96bf626f6573c635632fb7669f4f052dca4e1468d3338c40bc264b813.jpg",
+        "text": "$$\n\\mathcal { E } _ { \\mathcal { T } } ( \\theta ) < \\hat { \\mathcal { E } } _ { \\mathcal { D } } ^ { \\gamma } ( \\theta ) + \\frac { 1 } { 2 I } \\sum _ { i = 1 } ^ { I } \\mathbf { D i v } ( \\mathcal { D } _ { i } , \\mathcal { T } ) + \\operatorname* { m a x } _ { k \\in [ 1 , N ] } \\sqrt { \\frac { v _ { k } \\ln \\left( m / v _ { k } \\right) + \\ln \\left( N / \\delta \\right) } { m } } ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            243,
+            521,
+            753,
+            564
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "where $m = n I$ is the number of the training samples and $\\begin{array} { r } { \\mathbf { D i v } ( \\mathcal { D } _ { i } , \\mathcal { T } ) : = 2 \\operatorname* { s u p } _ { A } \\left| \\mathbb { P } _ { \\mathcal { D } _ { i } } ( A ) - \\mathbb { P } _ { \\mathcal { T } } ( A ) \\right| } \\end{array}$ is a divergence between two distributions. ",
+        "bbox": [
+            176,
+            564,
+            823,
+            593
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Proof can be done similarly as [37] and [34]. In Theorem 1, the test loss ${ \\mathcal { E } } _ { T } ( \\theta )$ is bounded by three terms: (1) the robust empirical loss $\\hat { \\mathcal { E } } _ { \\mathcal { D } } ^ { \\gamma } ( \\theta )$ , (2) the discrepancy between training distribution and test distribution, i.e., the quantity of domain shift, and (3) a confidence bound related to the radius $\\gamma$ and the number of the training samples $m$ . Our theorem is similar to Ben-David et al. [37], while our theorem does not have the term related to the difference in labeling functions across the domains. It is because we simply assume there is no difference between labeling functions for each domain for simplicity. If one assumes a different labeling function, the dissimilarity term can be derived easily because it is independent and compatible with our main proof. More details of Theorem 1, including proof and discussions on the confidence bound, are in Appendix C.1 and C.2. ",
+        "bbox": [
+            173,
+            602,
+            825,
+            731
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "From Theorem 1, one can conjure that minimizing the robust empirical loss is directly related to the generalization performances on the target distribution. We show that the domain generalization gap on the target domain $\\tau$ by the optimal solution of RRM, ${ \\hat { \\theta } } ^ { \\gamma }$ , is upper bounded as follows: ",
+        "bbox": [
+            173,
+            736,
+            826,
+            781
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Theorem 2. Let $\\hat { \\theta } ^ { \\gamma }$ denote the optimal solution of the RRM, i.e., $\\begin{array} { r } { \\hat { \\theta } ^ { \\gamma } : = \\arg \\operatorname* { m i n } _ { \\theta } \\hat { \\mathcal { E } } _ { \\mathcal { D } } ^ { \\gamma } ( \\theta ) . } \\end{array}$ , and let v be a VC dimension of the parameter space $\\Theta$ . Then, the gap between the optimal test loss, minθ0 $\\mathcal { E } \\tau \\left( \\theta ^ { \\prime } \\right)$ , and the test loss of ${ \\hat { \\theta } } ^ { \\gamma }$ , $\\mathcal { E } _ { \\mathcal { T } } ( \\hat { \\theta } ^ { \\gamma } )$ , has the following bound with probability at least $1 - \\delta$ . ",
+        "bbox": [
+            174,
+            784,
+            825,
+            832
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/33612a6331f5d3ef0e8c8fd291fb3c31a5f6f8ac42ec31a736e2fdd3fd04a275.jpg",
+        "text": "$$\n\\begin{array} { r c l } { \\mathcal { E } _ { \\mathcal { T } } ( \\hat { \\theta } ^ { \\gamma } ) - \\underset { \\theta ^ { \\prime } } { \\operatorname* { m i n } } \\ \\mathcal { E } _ { \\mathcal { T } } \\left( \\theta ^ { \\prime } \\right) } & { \\leq } & { \\displaystyle \\hat { \\mathcal { E } } _ { \\mathcal { D } } ^ { \\gamma } ( \\hat { \\theta } ^ { \\gamma } ) - \\underset { \\theta ^ { \\prime \\prime } } { \\operatorname* { m i n } } \\ \\hat { \\mathcal { E } } _ { \\mathcal { D } } ( \\theta ^ { \\prime \\prime } ) + \\frac { 1 } { I } \\sum _ { i = 1 } ^ { I } \\mathbf { D i v } ( \\mathcal { D } _ { i } , \\mathcal { T } ) } \\\\ & { + \\underset { k \\in \\left[ 1 , N \\right] } { \\operatorname* { m a x } } \\ \\sqrt { \\frac { v _ { k } \\ln \\left( m / v _ { k } \\right) + \\ln \\left( 2 N / \\delta \\right) } { m } } + \\sqrt { \\frac { v \\ln \\left( m / v \\right) + \\ln \\left( 2 / \\delta \\right) } { m } } } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            214,
+            834,
+            784,
+            916
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "image",
+        "img_path": "images/5be2415e2dfae8eeafe9efa1dafa3882628cb0216856667b76b7a5ebfcb20a08.jpg",
+        "image_caption": [
+            "Figure 2: Comparison between SWA and SWAD. (a) SWA collects stochastic weights for every $K$ epochs from the pre-defined $K _ { 0 }$ epochs to the final epoch. (b) Our SWAD collects stochastic weights densely, i.e., for every iteration, to obtain sufficiently many weights. SWAD collects the weights from the start iteration $t _ { s }$ to the end iteration $t _ { e }$ , where $t _ { s }$ and $t _ { e }$ are obtained by monitoring the validation loss (overfit-aware scheduling). "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            210,
+            90,
+            782,
+            218
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Proof is in Appendix C.3. It implies that if we find the optimal solution of the RRM $( i . e . , \\hat { \\theta } ^ { \\gamma } )$ , then the generalization gap in the test domain (i.e., $\\mathcal { E } _ { T } ( \\hat { \\theta } ^ { \\gamma } ) - \\mathrm { m i n } _ { \\theta ^ { \\prime } } \\mathcal { E } _ { T } ( \\theta ^ { \\prime } ) )$ is upper bounded by the gap between the RRM and ERM (i.e., $\\hat { \\mathcal { E } } _ { \\mathcal { D } } ^ { \\gamma } ( \\hat { \\theta } ^ { \\gamma } ) - \\operatorname* { m i n } _ { \\theta ^ { \\prime \\prime } } \\hat { \\mathcal { E } } _ { \\mathcal { D } } ( \\theta ^ { \\prime \\prime } ) )$ . Other terms in Theorem 2 are the discrepancy between the train domains $\\mathcal { D }$ and the target domain $\\tau$ , and the confidence bounds caused by sample means. We remark that if we choose a proper $\\gamma$ , the optimal solution of the RRM will find a point near a flat optimum of ERM as shown in Figure 1. Hence, Theorem 2 and the intuition from Figure 1 imply that seeking a flat minimum of ERM will lead to a better domain generalization gap. ",
+        "bbox": [
+            173,
+            282,
+            825,
+            386
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3 SWAD: Domain Generalization by Seeking Flat Minima ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            406,
+            673,
+            425
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "We have shown that flat minima will bring a better domain generalization. In this section, we propose Stochastic Weight Averaging Densely (SWAD) algorithm, and provide empirical quantitative and qualitative analyses on SWAD and flatness to understand why SWAD works better than ERM. ",
+        "bbox": [
+            176,
+            440,
+            823,
+            482
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3.1 A baseline method: stochastic weight averaging ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            501,
+            542,
+            515
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Since the importance of flatness in loss landscapes has emerged [23–28], several methods have been proposed to find flat minima [25, 26, 39]. We select stochastic weight averaging (SWA) [25] as a baseline, which finds flat minima by a weight ensemble approach. More specifically, SWA updates a pretrained model (namely, a model trained with sufficiently enough training epochs, $K _ { 0 }$ ) with a cyclical [40] or high constant learning rate scheduling. SWA gathers model parameters for every $K$ epochs during the update and averages them for the model ensemble. SWA finds an ensembled solution of different local optima found by a sufficiently large learning rate to escape a local minimum. Izmailov et al. [25] empirically showed that SWA finds flatter minima than ERM. We also considered sharpness-aware minimization (SAM) [26], which is another popular flatness-aware solver, but SWA finds flatter minima than SAM (See Figure 3). We illustrate an overview of SWA in Figure 2a. ",
+        "bbox": [
+            174,
+            526,
+            825,
+            666
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3.2 Dense and overfit-aware stochastic weight sampling strategy ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            684,
+            630,
+            699
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Despite its advantages, directly applying SWA to DG task has two problems. First, SWA averages a few weights (usually less than ten) by sampling weights for every $K$ epochs, results in an inaccurate approximation of flat minima on a high-dimensional parameter space (e.g., 23M for ResNet-50 [41]). Furthermore, a common DG benchmark protocol uses relatively small training epochs (e.g., Gulrajani and Lopez-Paz [22] trained with less than two epochs for DomainNet benchmark), resulting in insufficient stochastic weights for SWA. From this motivation, we propose a “dense” sampling strategy for gathering sufficiently enough stochastic weights. ",
+        "bbox": [
+            174,
+            710,
+            825,
+            808
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "In addition, widely used DG datasets, such as PACS $\\approx 1 0 \\mathrm { K }$ images, 7 classes) and VLCS $( \\approx 1 1 \\mathsf { K }$ images, 5 classes), are relatively smaller than large-scale datasets, such as ImageNet [42] $( \\approx 1 . 2 \\mathrm { M }$ images, 1K classes). In this case, we observe that a simple ERM approach is rapidly reached to a local optimum only within a few epochs, and easily suffers from the overfitting issue, i.e., the validation loss is increased after a few training epochs. It implies that directly applying the vanilla SWA will suffer from the overfitting issue by averaging sub-optimal solutions (i.e., overfitted parameters). Hence, we need an “overfit-aware” sampling scheduling to omit the sub-optimal solutions for SWA. ",
+        "bbox": [
+            174,
+            814,
+            825,
+            911
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "image",
+        "img_path": "images/6b80552c0af4a15dca897acbebf0ff96cc58d66aa2fda81b9bdb8e56e9209211.jpg",
+        "image_caption": [
+            "Figure 3: Local flatness comparisons. We plot the local flatness via loss gap, i.e., $\\begin{array} { r l } { { \\mathcal F } _ { \\gamma } ( \\theta ) } & { { } = } \\end{array}$ $\\mathbb { E } _ { \\| \\theta ^ { \\prime } \\| = \\| \\theta \\| + \\gamma } [ \\mathcal { E } ( \\theta ^ { \\prime } ) - \\mathcal { E } ( \\theta ) ]$ , of ERM, SAM, SWA, and SWAD by varying radius $\\gamma$ on different domains of PACS dataset. For each figure, Y-axis indicates the flatness ${ \\mathcal { F } } _ { \\gamma } ( \\theta )$ and X-axis indicates the radius $\\gamma$ . We measure the train flatness $\\mathcal { F } _ { \\gamma } ^ { \\mathcal { D } } ( \\theta )$ on seen domains and the test flatness $\\mathcal { F } _ { \\gamma } ^ { \\mathcal { T } } ( \\theta )$ on unseen domain. Each point is computed by Monte-Carlo approximation with 100 random samples. This comparisons show SWAD finds flatter minima than not only ERM but also SAM and SWA. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            171,
+            88,
+            825,
+            367
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "The main idea of Stochastic Weight Averaging Densely (SWAD) is a dense and overfit-aware stochastic weight gathering strategy. First, instead of collecting weights for every $K$ epochs, SWAD collects weights for every iteration. This dense sampling strategy easily collects sufficiently many weights than the sparse one. We also employ overfit-aware sampling scheduling by considering traces of the validation loss. Instead of sampling weights from $K _ { 0 }$ pretraining epochs to the final epoch, we search the start iteration (when the validation loss achieves a local optimum for the first time) and the end iteration (when the validation loss is no longer decreased, but keep increasing). More specifically, we introduce three parameters: an optimum patient parameter $N _ { s }$ , an overfitting patient parameter $N _ { e }$ , and the tolerance rate $r$ for searching the start iteration $t _ { s }$ and the end iteration $t _ { e }$ . First, we search ts which satisfies mini∈[0,...,Ns−1] $\\bar { \\mathcal { E } } _ { \\mathrm { v a l } } ^ { ( t _ { s } + i ) } = \\mathcal { E } _ { \\mathrm { v a l } } ^ { ( t _ { s } ) }$ E (ts)val , where $\\mathcal { E } _ { \\mathrm { v a l } } ^ { ( i ) }$ denotes the validation loss at iteration iterationfirst itera $i$ . Simply,  Then, weon where $t _ { s }$ isnd e v e first iterasatisfying dation loss g.g ecreased duther words, iterations. ng is $N _ { s }$ s. fi te mini∈[0,1,...,Ne−1] E (teval $\\begin{array} { r } { \\operatorname* { m i n } _ { i \\in [ 0 , 1 , \\dots , N _ { e } - 1 ] } \\mathcal { E } _ { \\mathrm { v a l } } ^ { ( t _ { e } + i ) } > r \\mathcal { E } _ { \\mathrm { v a l } } ^ { ( t _ { s } ) } } \\end{array}$ $t _ { e }$ ti th ali values exceed the tolerance $r$ durin $N _ { e }$ ",
+        "bbox": [
+            174,
+            472,
+            825,
+            659
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "We illustrate the overview of SWAD and the comparison of SWAD to SWA in Figure 2. Detailed pseudo code is provided in Appendix B.4. We compare SWAD with other possible SWA strategies in $\\ S 4 . 3$ and show that our design choice works better for DG tasks. ",
+        "bbox": [
+            176,
+            664,
+            821,
+            707
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "3.3 Empirical analysis of SWAD and flatness ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            727,
+            496,
+            741
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Here, we analyze solutions found by SWAD in terms of flatness. We first verify that the SWAD solution is flatter than those of ERM, SWA, and SAM. Our loss surface visualization shows that the SWAD solution is located on the center of the flat region, while ERM finds a boundary solution. Finally, we show that the sharp boundary solutions by ERM are not generalized well, resulting in sensitivity to the model selection. All following empirical analyses are conducted on PACS dataset, validating by all four domains (art painting, cartoon, photo, and sketch). ",
+        "bbox": [
+            174,
+            753,
+            825,
+            837
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Local flatness anaylsis. To begin with, we quantify the local flatness of a model parameter $\\theta$ by assuming that flat minima will have smaller changes of loss value within its neighborhoods than sharp minima. For the given model parameter $\\theta$ , we compute the expected loss value changes between $\\theta$ and parameters on the sphere surrounding $\\theta$ with radius $\\gamma$ , i.e., $\\mathcal { \\bar { F } } _ { \\gamma } ( \\theta ) = \\mathbb { E } _ { \\| \\theta ^ { \\prime } \\| = \\| \\theta \\| + \\gamma } [ \\mathcal { \\bar { E } } ( \\theta ^ { \\prime } ) - \\mathcal { E } ( \\theta ) ]$ . In practice, ${ \\mathcal { F } } _ { \\gamma } ( \\theta )$ is approximated by Monte-Carlo sampling with 100 samples. Note that the proposed local flatness ${ \\mathcal { F } } _ { \\gamma } ( \\theta )$ is computationally efficient than measuring curvature using the Hessian-based quantities. Also, ${ \\mathcal { F } } _ { \\gamma } ( \\theta )$ has an unbiased finite sample estimator, while the worst-case loss value, i.e., $\\operatorname* { m a x } _ { \\| \\theta ^ { \\prime } \\| = \\| \\theta \\| + \\gamma } [ { \\mathcal { E } } ( \\theta ^ { \\prime } ) - { \\mathcal { E } } ( \\theta ) ]$ has no unbiased finite sample estimator. ",
+        "bbox": [
+            174,
+            856,
+            825,
+            912
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "image",
+        "img_path": "images/754f10657b9f14284a8fe1a62243c0a45d0fff540230864084447d0ccbd8e4be.jpg",
+        "image_caption": [
+            "Figure 4: Loss surfaces on model parameters in PACS dataset for each target domain. The three triangles indicate model weights chosen at the end of training phase with equal intervals. Each plane is defined by the three weights and losses upon the plane are visualized with contours. The center cross mark is averaged point of the three weights. The first and second rows show the averaged training loss and the test loss surfaces, respectively. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            197,
+            89,
+            799,
+            267
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "image",
+        "img_path": "images/1556786cc200b405880ee4ae90530162a87adce971d22c005304ed2740cab5b6.jpg",
+        "image_caption": [
+            "Figure 5: Validation accuracies for in-domains. The $X \\mathrm { - }$ and Y-axis indicate the training iterations and accuracy, respectively, about the validation domains (legend) and the test domain (caption). The vertical dot lines represent start and end iterations, $t _ { s }$ and $t _ { e }$ , identified by the overfit-aware sampling strategy of SWAD. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            176,
+            342,
+            823,
+            452
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            527,
+            825,
+            584
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "In Figure 3, we compare ${ \\mathcal { F } } _ { \\gamma } ( \\theta )$ of ERM, SAM, SWA with cyclic learning rate, SWA with constant learning rate, and SWAD by varying radius $\\gamma$ . SAM and SWA find the solutions with lower local flatness than ERM on average. SWAD finds the most flat minimum in every experiment. ",
+        "bbox": [
+            174,
+            592,
+            823,
+            633
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Loss surface visualization. We visualize the loss landscapes by choosing three model weights on the optimization trajectory $( \\theta _ { 1 } , \\theta _ { 2 } , \\theta _ { 3 } ) ^ { 2 }$ , and computing the loss values by linear combinations of $\\theta _ { 1 } , \\theta _ { 2 } , \\theta _ { 3 } { } ^ { 3 }$ as [25]. More details are in Appendix B.5. In Figure 4, we observe that for all cases, ERM solutions are located at the boundary of a flat minimum of training loss, resulting in poor generalizability in test domains, that is aligned with our theoretical analysis and empirical flatness analysis. Since ERM solutions are located on the boundary of a flat loss surface, we observe that ERM solutions are very sensitive to model selection. In Figure 5, we illustrate the validation accuracies for each train-test domain combination of PACS by ERM, over training iterations (one epoch is equivalent to 83 iterations). We first observe that ERM rapidly reaches the best accuracy within only a few training epochs, namely less than 6 epochs. Furthermore, the ERM validation accuracies fluctuate a lot, and the final performance is very sensitive to the model selection criterion. ",
+        "bbox": [
+            173,
+            651,
+            825,
+            804
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "On the other hand, we observe that SWA solutions are located on the center of the training loss surfaces as well as of the test loss surfaces (Figure 4). Also, our overfit-aware stochastic weight gathering strategy (denoted as the vertical dot lines in Figure 5) prevents the ensembled weight from overfitting and makes SWAD model selection-free. ",
+        "bbox": [
+            176,
+            810,
+            823,
+            866
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "table",
+        "img_path": "images/61812e810ccf39dd2731b749f42a72a3d462f52a8ede135374ca289893dcb24b.jpg",
+        "table_caption": [
+            "Table 2: Comparison with domain generalization methods and SWAD. Out-of-domain accuracies on five domain generalization benchmarks are shown. We highlight the best results and the second best results. Note that ERM (reproduced), Mixstyle are reproduced numbers, and other numbers are from the original literature and Gulrajani and Lopez-Paz [22] (denoted with †). Our experiments are repeated three times. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Algorithm</td><td>PACS</td><td>VLCS</td><td>OfficeHome</td><td>TerraInc</td><td>DomainNet</td><td>Avg.</td></tr><tr><td>MASF[14]</td><td>82.7</td><td>=</td><td></td><td></td><td></td><td>=</td></tr><tr><td>DMG [33]</td><td>83.4</td><td>=</td><td></td><td></td><td>43.6</td><td>=</td></tr><tr><td>MetaReg [15]</td><td>83.6</td><td>=</td><td></td><td></td><td>43.6</td><td></td></tr><tr><td>ER[12]</td><td>85.3</td><td></td><td>=</td><td></td><td>-</td><td>=</td></tr><tr><td>pAdaIN [47]</td><td>85.4</td><td>=</td><td></td><td></td><td>=</td><td></td></tr><tr><td>EISNet [48]</td><td>85.8</td><td></td><td></td><td></td><td></td><td></td></tr><tr><td>DSON [30]</td><td>86.6</td><td>=</td><td></td><td>=</td><td>=</td><td>=</td></tr><tr><td>ERM+ [29]</td><td>85.5</td><td>77.5</td><td>66.5</td><td>46.1</td><td>40.9</td><td>63.3</td></tr><tr><td>ERM (reproduced)</td><td>84.2</td><td>77.3</td><td>67.6</td><td>47.8</td><td>44.0</td><td>64.2</td></tr><tr><td>IRM+ [20]</td><td>83.5</td><td>78.6</td><td>64.3</td><td>47.6</td><td>33.9</td><td>61.6</td></tr><tr><td>GroupDRO+ [49]</td><td>84.4</td><td>76.7</td><td>66.0</td><td>43.2</td><td>33.3</td><td>60.7</td></tr><tr><td>I-Mixup† [50-52]</td><td>84.6</td><td>77.4</td><td>68.1</td><td>47.9</td><td>39.2</td><td>63.4</td></tr><tr><td>MLDG+ [13]</td><td>84.9</td><td>77.2</td><td>66.8</td><td>47.8</td><td>41.2</td><td>63.6</td></tr><tr><td>CORAL† [31]</td><td>86.2</td><td>78.8</td><td>68.7</td><td>47.7</td><td>41.5</td><td>64.5</td></tr><tr><td>MMD† [53]</td><td>84.7</td><td>77.5</td><td>66.4</td><td>42.2</td><td>23.4</td><td>58.8</td></tr><tr><td>DANN+ [9]</td><td>83.7</td><td>78.6</td><td>65.9</td><td>46.7</td><td>38.3</td><td>62.6</td></tr><tr><td>CDANN† [10]</td><td>82.6</td><td>77.5</td><td>65.7</td><td>45.8</td><td>38.3</td><td>62.0</td></tr><tr><td>MTL+ [54]</td><td>84.6</td><td>77.2</td><td>66.4</td><td>45.6</td><td>40.6</td><td>62.9</td></tr><tr><td>SagNet† [32]</td><td>86.3</td><td>77.8</td><td>68.1</td><td>48.6</td><td>40.3</td><td>64.2</td></tr><tr><td>ARM+ [16]</td><td>85.1</td><td>77.6</td><td>64.8</td><td>45.5</td><td>35.5</td><td>61.7</td></tr><tr><td>VREx+ [21]</td><td>84.9</td><td>78.3</td><td>66.4</td><td>46.4</td><td>33.6</td><td>61.9</td></tr><tr><td>RSC+ [55]</td><td>85.2</td><td>77.1</td><td>65.5</td><td>46.6</td><td>38.9</td><td>62.7</td></tr><tr><td>Mixstyle [17]</td><td>85.2</td><td>77.9</td><td>60.4</td><td>44.0</td><td>34.0</td><td>60.3</td></tr><tr><td>SWAD (ours)</td><td>88.1 (±0.1)</td><td>79.1 (±0.1)</td><td>70.6 (±0.2)</td><td>50.0 (±0.3)</td><td>46.5 (±0.1)</td><td>66.9</td></tr></table>",
+        "bbox": [
+            215,
+            155,
+            777,
+            516
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "4 Experiments ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            545,
+            312,
+            563
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "4.1 Evaluation protocols ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            579,
+            356,
+            594
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Dataset and optimization protocol. Following Gulrajani and Lopez-Paz [22], we exhaustively evaluate our method and comparison methods on various benchmarks: PACS [7] (9,991 images, 7 classes, and 4 domains), VLCS [43] (10,729 images, 5 classes, and 4 domains), OfficeHome [44] (15,588 images, 65 classes, and 4 domains), TerraIncognita [45] (24,788 images, 10 classes, and 4 domains), and DomainNet [46] (586,575 images, 345 classes, and 6 domains). ",
+        "bbox": [
+            174,
+            607,
+            825,
+            678
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "For a fair comparison, we follow training and evaluation protocol by Gulrajani and Lopez-Paz [22], including the dataset splits, hyperparameter (HP) search and model selection (while SWAD does not need it) on the validation set, and optimizer HP, except the HP search space and the number of iterations for DomainNet. We use a reduced HP search space to reduce the computational costs. We also tripled the number of iterations for DomainNet from 5,000 to 15,000 because we observe that 5,000 is not sufficient to convergence. We re-evaluate ERM with 15,000 iterations, and observe $3 . 1 \\mathrm { p p }$ average performance improvement $( 4 0 . 9 \\%  4 4 . 0 \\% )$ ) in DomainNet. For training, we choose a domain as the target domain and use the remaining domains as the training domain where $20 \\%$ samples are used for validation and model selection. ImageNet [42] trained ResNet-50 [41] is employed as the initial weight, and optimized by Adam [38] optimizer with a learning rate of 5e-5. We construct a mini-batch containing all domains where each domain has 32 images. We set SWAD HPs $N _ { s }$ to 3, $N _ { e }$ to 6, and $r$ to 1.2 for VLCS and 1.3 for the others by HP search on the validation sets. Additional implementation details, such as other HPs, are given in Appendix B. ",
+        "bbox": [
+            174,
+            683,
+            825,
+            863
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Evaluation metrics. We report out-of-domain accuracies for each domain and their average, i.e., a model is trained and validated on training domains and evaluated on the unseen target domain. Each out-of-domain performance is an average of three different runs with different train-validation splits. ",
+        "bbox": [
+            176,
+            869,
+            825,
+            911
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Comparison with domain generalization methods. We report the full out-of-domain performances on five DG benchmarks in Table 2. The full tables including outof-domain accuracies for each domain are in Appendix E. In all experiments, our SWAD achieves significant performance gain against ERM as well as the previous best results: $+ 2 . 6 \\mathrm { p p }$ in PACS, $+ 0 . 3 \\mathrm { p p }$ in VLCS, $+ 1 . 4 \\mathrm { p p }$ in TerraIncognita, $+ 1 . 9 \\mathrm { p p }$ in OfficeHome, and $+ 2 . 9 \\mathrm { p p }$ in DomainNet comparing to the previous best results. We observe that SWAD provides two practical advantages comparing to previous methods. First, SWAD does not need any modification on training objectives or model architecture, i.e., it is universally applicable to any other methods. As an example, we show that SWAD actually improves the performances of other DG methods, such as CORAL [31] in Table 4. Moreover, as we discussed before, SWAD is free to the model selection, resulting in stable performances (i.e., small standard errors) on various benchmarks. Note that we only compare results with ResNet-50 backbone for a fair comparison. We describe the implementation details of each comparison method and the hyperparameter search protocol in Appendix B. ",
+        "bbox": [
+            174,
+            125,
+            537,
+            358
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "table",
+        "img_path": "images/c32faae3a91097bedea7320df061b75ad882c9f5fab922ff250421ea9ba3730e.jpg",
+        "table_caption": [
+            "Table 3: Comparison between generalization methods on PACS. The scores are averaged over all settings using different target domains. $( \\uparrow )$ and $\\cdot$ indicate statistically significant improvement and degradation from ERM. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td colspan=\"2\">Out-of-domain In-domain</td></tr><tr><td>ERM</td><td>85.3±0.4 96.6±0.0 85.5±0.4(-) 97.0±0.1(↑)</td></tr><tr><td>EMA SAM</td><td>85.5±0.1(-) 97.4±0.1(↑)</td></tr><tr><td>Mixup</td><td>84.8±0.3(-) 97.3±0.1(1)</td></tr><tr><td>CutMix</td><td>83.8±0.4(↓) 97.6±0.1(↑)</td></tr><tr><td>VAT</td><td>85.4±0.6(-) 96.9±0.2(↑)</td></tr><tr><td>II-model</td><td>83.5±0.5(↓) 96.8±0.2(1)</td></tr><tr><td>SWA SWAD</td><td>85.9±0.1(↑) 97.1±0.1(↑) 87.1±0.2(↑) 97.7±0.1(↑)</td></tr></table>",
+        "bbox": [
+            555,
+            188,
+            813,
+            349
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            358,
+            825,
+            400
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Comparison with conventional generalization methods. We also compare SWAD with other conventional generalization methods to show that the remarkable domain generalization gaps by SWAD is not achieved by better generalization, but by seeking flat minima. The comparison methods include flatness-aware optimization methods, such as SAM [26], ensemble methods, such as EMA [56], data augmentation methods, such as Mixup [35] and CutMix [36], and consistency regularization methods, such as VAT [57] and $\\Pi$ -model [58]. We also split in-domain datasets into training $( 6 0 \\% )$ , validation $( 2 0 \\% )$ , and test $( 2 0 \\% )$ splits, while no in-domain test set used for Table 2. Every experiment is repeated three times. ",
+        "bbox": [
+            173,
+            406,
+            825,
+            517
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "The results are shown in Table 3. We observe that all conventional methods helps in-domain generalization, i.e., performing better than ERM on in-domain test set. However, their out-of-domain performances are similar to or even worse than ERM. For example, CutMix and Π-model improve in-domain performances by $1 . 0 \\mathrm { p p }$ and $0 . 2 \\mathrm { p p }$ but degrade out-of-domain performances by $1 . 5 \\mathrm { p p }$ and $1 . 8 \\mathrm { p p }$ . SAM, another method for seeking flat minima, slightly increases both in-domain and out-of-domain performances but the out-of-domain performance is not statistically significant. We will discuss performances of SAM in other benchmarks later. In contrast, the vanilla SWA and our SWAD significantly improve both in-domain and out-of-domain performances. SWAD improves the performances by SWA with statistically significantly gaps: $1 . 2 \\mathrm { p p }$ on the out-of-domain and $0 . 6 \\mathrm { p p }$ on the in-domain. Further comparison between SWA and SWAD is provided in $\\ S 4 . 3$ . ",
+        "bbox": [
+            173,
+            522,
+            825,
+            661
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "table",
+        "img_path": "images/52da16afc4302804d6a4ab22cd1c386be51e97663e0104a66ba3cba153d51343.jpg",
+        "table_caption": [
+            "Table 4: Combination of SWAD and other methods. The scores are averaged over every target domain case. The performances of ERM, CORAL, and SAM are optimized by HP searches of DomainBed. In contrast, for the SWAD combination cases, CORAL and SAM use default HPs without additional HP search. We additionally compare SWAD to $\\mathrm { S W A } _ { \\mathrm { w / c o n s t } }$ . Note that $\\mathrm { E R M + S W A D }$ is same as “SWAD” in Table 2. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td></td><td>PACS</td><td>VLCS</td><td>OfficeHome</td><td>TerraInc</td><td>DomainNet</td><td>Avg. (△)</td></tr><tr><td>ERM</td><td>85.5 ±0.2</td><td>77.5 ±0.4</td><td>66.5 ±0.3</td><td>46.1 ±1.8</td><td>40.9 ±0.1</td><td>63.3</td></tr><tr><td>ERM + SWAw/ const</td><td>86.9 ±0.2</td><td>76.6 ±0.1</td><td>69.3 ±0.3</td><td>49.2 ±1.2</td><td>45.9 ±0.0</td><td>65.6 (+2.3)</td></tr><tr><td>ERM + SWAD</td><td>88.1 ±0.1</td><td>79.1 ±0.1</td><td>70.6 ±0.2</td><td>50.0±0.3</td><td>46.5 ±0.1</td><td>66.9 (+3.6)</td></tr><tr><td>CORAL</td><td>86.2 ±0.3</td><td>78.8 ±0.6</td><td>68.7 ±0.3</td><td>47.6 ±1.0</td><td>41.5 ±0.1</td><td>64.5</td></tr><tr><td>CORAL + SWAD</td><td>88.3 ±0.1</td><td>78.9 ±0.1</td><td>71.3 ±0.1</td><td>51.0 ±0.1</td><td>46.8 ±0.0</td><td>67.3 (+2.8)</td></tr><tr><td>SAM</td><td>85.8 ±0.2</td><td>79.4 ±0.1</td><td>69.6 ±0.1</td><td>43.3 ±0.7</td><td>44.3 ±0.0</td><td>64.5</td></tr><tr><td> SAM + SWAD</td><td>87.1 ±0.2</td><td>78.5 ±0.2</td><td>69.9 ±0.1</td><td>45.3 ±0.9</td><td>46.5 ±0.1</td><td>65.5 (+1.0)</td></tr></table>",
+        "bbox": [
+            176,
+            767,
+            820,
+            909
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Combinations with other methods. Since SWAD does not require any modification on training procedures and model architectures, SWAD is universally applicable to any other methods. Here, we combine SWAD with ERM, CORAL [31], and SAM [26]. Results are shown in Table 4. Both CORAL and SAM solely show better performances than ERM with $+ 1 . 2 \\mathrm { p p }$ average out-of-domain accuracy gap. Note that SAM is not a DG method but a sharpness-aware optimization method to find flat minima. It supports our theoretical motivation: DG can be achieved by seeking flat minima. ",
+        "bbox": [
+            174,
+            90,
+            825,
+            174
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "By applying SWAD on the baselines, the performances are consistently improved by 3.6pp on ERM, $2 . 8 \\mathrm { p p }$ on CORAL, and $1 . 0 \\mathrm { p p }$ on SAM. Interestingly, $\\mathrm { C O R A L } + \\mathrm { S W A D }$ show the best performances with both incorporating different advantages of utilizing domain labels and seeking flat minima. We also observe that $\\mathrm { S A M + S W A D }$ shows worse performance than $\\mathrm { E R M + S W A D }$ , while SAM performs better than ERM. We conjecture that it is because the objective control by SAM restricts the model parameter diversity durinig training, reducing the diversity for SWA ensemble. However, applying SWAD on SAM still leads to better performances than the sole SAM. The results demonstrate that the application of SWAD on other baselines is a simple yet effective method for DG. ",
+        "bbox": [
+            173,
+            180,
+            825,
+            291
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "4.3 Ablation study ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            309,
+            313,
+            324
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "table",
+        "img_path": "images/ac6ac6ecbb8287397ec2dfba7dee09aaed1514be15b60f03372b18028cc9c400.jpg",
+        "table_caption": [
+            "Table 5: Ablation studies of the stochastic weights selection strategies on PACS and VLCS. In the configuration, $^ { 6 * } t _ { s } { } ^ { , 3 } , ^ { 6 * } t _ { e } { } ^ { , 3 } ,$ , “lr”, and “interval” indicate start and end iterations of sampling, a learning rate schedule, and a stochastic weight sampling interval, respectively. “Opt” and “Overfit” indicate the start and end iterations identified by our overfit-aware sampling strategy, and “Val” means the start and end iterations whose averaging shows the best accuracy on the validation set. “Cyclic” and “Const” represent cyclic and constant learning rate schedules. All experiments are repeated three times. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=\"2\"></td><td colspan=\"4\">Configuration</td><td colspan=\"3\">Out-of-domain</td><td colspan=\"3\">In-domain</td></tr><tr><td>ts</td><td>te</td><td>lr</td><td>interval</td><td>PACS</td><td>VLCS</td><td>Avg.</td><td>PACS</td><td>VLCS</td><td>Avg.</td></tr><tr><td>SWAw/ cyclic</td><td>4000</td><td>5000</td><td>Cyclic</td><td>100</td><td>85.9 ±0.1</td><td>76.6 ±0.1</td><td>81.2</td><td>97.1 ±0.1</td><td>85.0 ±0.2</td><td>91.0</td></tr><tr><td>SWAw/ const</td><td>4000</td><td>5000</td><td>Const</td><td>100</td><td>86.5 ±0.3</td><td>76.7 ±0.2</td><td>81.6</td><td>97.3 ±0.1</td><td>85.0 ±0.2</td><td>91.1</td></tr><tr><td>S WADw/o Dense</td><td>Opt</td><td>Overfit</td><td>Const</td><td>100</td><td>86.5 ±0.4</td><td>78.0 ±0.7</td><td>82.2</td><td>97.6±0.1</td><td>85.8 ±0.4</td><td>91.7</td></tr><tr><td>S WADw/o Opt-Overfit</td><td>4000</td><td>5000</td><td>Const</td><td>1</td><td>86.6 ±0.6</td><td>76.9 ±0.3</td><td>81.7</td><td>97.5 ±0.1</td><td>85.2 ±0.1</td><td>91.3</td></tr><tr><td>SWADw/o Overfit</td><td>Opt</td><td>5000</td><td>Const</td><td>1</td><td>87.1 ±0.3</td><td>77.6 ±0.1</td><td>82.4</td><td>97.7 ±0.1</td><td>85.8±0.3</td><td>91.8</td></tr><tr><td>S WADfit-on-val</td><td>Val</td><td>Val</td><td>Const</td><td>1</td><td>86.2 ±0.2</td><td>78.6 ±0.1</td><td>82.4</td><td>97.5 ±0.2</td><td>85.8 ±0.3</td><td>91.7</td></tr><tr><td>SWAD (proposed)</td><td>Opt</td><td>Overfit</td><td>Const</td><td>1</td><td>87.1 ±0.2</td><td>78.9 ±0.2</td><td>83.0</td><td>97.7 ±0.1</td><td>86.1 ±0.5</td><td>91.9</td></tr></table>",
+        "bbox": [
+            173,
+            424,
+            823,
+            575
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Table 5 provides ablative studies on the starting and ending iterations for averaging, the learning rate schedule, and the sampling interval. SWAw/ cyclic (SWA in Table 3) and $\\operatorname { S W A } _ { \\mathrm { w } / }$ constant are vanilla SWAs with fixed sampling positions. We also report SWAD by eliminating three factors: the dense sampling strategy, and searching the start iteration, searching the end iteration. The dense sampling strategy lets SWAD estimate a more accurate approximation of flat minima: showing $0 . 8 \\mathrm { p p }$ degeneration in the average out-of-domain accuracy $( \\mathrm { S W A D _ { w / o D e n s e } } )$ . When we take an average from $t _ { s }$ to the final iteration, the out-of-domain performance degrades by $0 . 6 \\mathrm { p p }$ $\\mathrm { \\Delta S W A D _ { w / o } }$ Overfit). Similarly, a fixed scheduling without the overfit-aware scheduling only shows very marginal improvements from the vanilla SWA (SWADw/o Opt-Overfit). We also evaluate $\\mathbf { S W A D _ { f i t - o n - v a l } }$ that uses the range achieving the best performances on the validation set, but it becomes overfitted to the validation, results in lower performances than SWAD. The results demonstrate the benefits of combining “dense” and “overfit-aware” sampling strategies of SWAD. ",
+        "bbox": [
+            173,
+            585,
+            825,
+            752
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "4.4 Exploring the other applications: ImageNet robustness ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            768,
+            593,
+            785
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "table",
+        "img_path": "images/a971bafe07034ad3756bcc541f10ef2bdfe6116f41021ff798aadfe23d680b5b.jpg",
+        "table_caption": [
+            "Table 6: ImageNet robustness benchmarks. We show the ImageNet generalization performances on ImageNet-C, background challenge (BGC), and ImageNet-R. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Method</td><td>ImageNet (%) ↑</td><td>ImageNet-C (mCE)↓</td><td>BGC (%) ↑</td><td>ImageNet-R(%) ↑</td></tr><tr><td>ERM</td><td>76.5</td><td>57.6</td><td>8.7</td><td>36.7</td></tr><tr><td>SWA</td><td>76.9</td><td>56.8</td><td>10.9</td><td>37.5</td></tr><tr><td>SWAD (ours)</td><td>77.0</td><td>55.7</td><td>11.8</td><td>38.8</td></tr></table>",
+        "bbox": [
+            209,
+            837,
+            787,
+            910
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Since SWAD does not rely on domain labels, it can be applied to other robustness tasks not containing domain labels. Table 6 show the generalizability of SWAD on ImageNet [42] and its shifted benchmarks, namely, ImageNet-C [59], ImageNet-R [60], and background challenge (BGC) [61]. SWAD consistently improves robustness performances against the ERM baseline and the SWA baseline. These results support that our method is robustly and widely applicable to improve both in-domain and out-of-domain generalizability. The detailed setup is provided in Appendix B.6. ",
+        "bbox": [
+            174,
+            90,
+            825,
+            174
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "5 Discussion and Limitations ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            195,
+            431,
+            213
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Despite many benefits from SWAD, such as the significant performance improvements, model selection-free property, working plug-and-play manner for various methods, there are some potential limitations. Here, we discuss the limitations of SWAD for further improvements. ",
+        "bbox": [
+            176,
+            228,
+            823,
+            270
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Confidence error in Theorem 1. While the confidence error in Theorem 1 tells the effect of $\\gamma$ on generalization error bound, there exists a limitation in that the confidence error term shows improper behavior with respect to $\\gamma$ if $\\gamma$ is close to zero. The behavior we expect is that the confidence error of RRM converges to the confidence error of ERM as $\\gamma$ decreases to zero, however, the current theorem does not show such tendency since the confidence bound diverges to infinity when $\\gamma$ goes to zero. However, we would like to note that this limitation is not a drawback of RRM, but it is caused by the looseness of the union bound which is a mathematical technique used to derive the confidence error of RRM. Our RRM formulation has a similarity to previous works [26, 34] and we note that the counter-intuitive behavior of the confidence bound and $\\gamma$ also appears in Foret et al. [26]. ",
+        "bbox": [
+            174,
+            276,
+            825,
+            401
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "SWAD is not a perfect flatness-aware optimization method. Note that SWAD is not a perfect and theoretically guaranteed solver for flat minima, but a heuristic approximation with empirical benefits. However, even if a better flatness-aware optimization method is proposed, our theoretical contribution still holds: showing the relationship between flat minima and DG. ",
+        "bbox": [
+            174,
+            409,
+            825,
+            463
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "SWAD does not strongly utilize domain-specific information. In Theorem 2, the domain generalization gap is bounded by three factors: flat minima, domain discrepancy, and confidence bound. Most of the existing approaches focus on domain discrepancy, reducing the difference between the source domains and the target domain by domain invariant learning [8–12]. SWAD focuses on the first factor, the flat minima. While the domain labels are used to construct a mini-batch, SWAD does not strongly utilize domain-specific information. It implies that if one can consider both flatness and domain discrepancy, better domain generalization can be achievable. Table 4 gives us a clue: the combination of CORAL (utilizing domain-specific information) and SWAD (seeking flat minima) shows the best performance among all comparison methods. As a future research direction, we encourage studying a method that can achieve both flat optima and small domain discrepancy. ",
+        "bbox": [
+            174,
+            469,
+            825,
+            608
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "6 Concluding Remarks ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            630,
+            383,
+            647
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "In this paper, we theoretically and empirically demonstrate that domain generalization (DG) is achievable by seeking flat minima. We propose SWAD that captures flatter minima than the vanilla SWA does. The extensive experiments on five DG benchmarks show superior performances of SWAD compared with existing DG methods. In addition, combinations of SWAD and existing DG methods even show better performances than the vanilla SWAD. We theoretically and empirically observe that seeking flat minima can achieve better generalizability to both in-domain and out-of-domain, while strong in-domain generalization methods without consideration of flatness, e.g., Mixup or CutMix, cannot guarantee to achieve out-of-domain generalizability in both theory and practice. This study first brings the concept of flatness into DG tasks, and shows strong empirical performances not only in DG but also in ImageNet benchmarks. We hope that this study promotes a new research direction of seeking flat minima for domain generalization and other robustness tasks. ",
+        "bbox": [
+            174,
+            662,
+            825,
+            815
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Acknowledgments and Disclosure of Funding ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            835,
+            553,
+            853
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "NAVER Smart Machine Learning (NSML) [62] and Kakao Brain Cloud platform have been used in experiments. This work was supported by IITP grant funded by the Korea government (MSIT) (No. 2021-0-01341, AI Graduate School Program, CAU). ",
+        "bbox": [
+            174,
+            868,
+            826,
+            911
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "References   \n[1] Dengxin Dai and Luc Van Gool. Dark model adaptation: Semantic image segmentation from daytime to nighttime. In 2018 21st International Conference on Intelligent Transportation Systems (ITSC), pages 3819–3824. IEEE, 2018.   \n[2] Claudio Michaelis, Benjamin Mitzkus, Robert Geirhos, Evgenia Rusak, Oliver Bringmann, Alexander S Ecker, Matthias Bethge, and Wieland Brendel. Benchmarking robustness in object detection: Autonomous driving when winter is coming. arXiv preprint arXiv:1907.07484, 2019.   \n[3] Terrance de Vries, Ishan Misra, Changhan Wang, and Laurens van der Maaten. Does object recognition work for everyone? In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition Workshops, pages 52–59, 2019.   \n[4] Kaiyu Yang, Klint Qinami, Li Fei-Fei, Jia Deng, and Olga Russakovsky. Towards fairer datasets: Filtering and balancing the distribution of the people subtree in the imagenet hierarchy. In Proceedings of the 2020 Conference on Fairness, Accountability, and Transparency, pages 547–558, 2020.   \n[5] Robert Geirhos, Patricia Rubisch, Claudio Michaelis, Matthias Bethge, Felix A. Wichmann, and Wieland Brendel. Imagenet-trained cnns are biased towards texture; increasing shape bias improves accuracy and robustness. In International Conference on Learning Representations, 2019.   \n[6] Sara Beery, Grant Van Horn, and Pietro Perona. Recognition in terra incognita. In Proceedings of the European Conference on Computer Vision (ECCV), pages 456–473, 2018.   \n[7] Da Li, Yongxin Yang, Yi-Zhe Song, and Timothy M Hospedales. Deeper, broader and artier domain generalization. In IEEE International Conference on Computer Vision, pages 5542– 5550, 2017.   \n[8] Krikamol Muandet, David Balduzzi, and Bernhard Schölkopf. Domain generalization via invariant feature representation. In International Conference on Machine Learning, pages 10–18. PMLR, 2013.   \n[9] Yaroslav Ganin, Evgeniya Ustinova, Hana Ajakan, Pascal Germain, Hugo Larochelle, François Laviolette, Mario Marchand, and Victor Lempitsky. Domain-adversarial training of neural networks. Journal of machine learning research, 17(1):2096–2030, 2016.   \n[10] Ya Li, Mingming Gong, Xinmei Tian, Tongliang Liu, and Dacheng Tao. Domain generalization via conditional invariant representations. In AAAI Conference on Artificial Intelligence, volume 32, 2018.   \n[11] Hyojin Bahng, Sanghyuk Chun, Sangdoo Yun, Jaegul Choo, and Seong Joon Oh. Learning de-biased representations with biased representations. In International Conference on Machine Learning (ICML), 2020.   \n[12] Shanshan Zhao, Mingming Gong, Tongliang Liu, Huan Fu, and Dacheng Tao. Domain generalization via entropy regularization. Neural Information Processing Systems, 33, 2020.   \n[13] Da Li, Yongxin Yang, Yi-Zhe Song, and Timothy Hospedales. Learning to generalize: Metalearning for domain generalization. In AAAI Conference on Artificial Intelligence, volume 32, 2018.   \n[14] Qi Dou, Daniel C Castro, Konstantinos Kamnitsas, and Ben Glocker. Domain generalization via model-agnostic learning of semantic features. Neural Information Processing System, 2019.   \n[15] Yogesh Balaji, Swami Sankaranarayanan, and Rama Chellappa. Metareg: Towards domain generalization using meta-regularization. Neural Information Processing Systems, 31:998–1008, 2018.   \n[16] Marvin Zhang, Henrik Marklund, Abhishek Gupta, Sergey Levine, and Chelsea Finn. Adaptive risk minimization: A meta-learning approach for tackling group shift. arXiv preprint arXiv:2007.02931, 2020. ",
+        "bbox": [
+            173,
+            54,
+            828,
+            915
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "[17] Kaiyang Zhou, Yongxin Yang, Yu Qiao, and Tao Xiang. Domain generalization with mixstyle. In International Conference on Learning Representations, 2021. ",
+        "bbox": [
+            169,
+            90,
+            826,
+            121
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "[18] Shiv Shankar, Vihari Piratla, Soumen Chakrabarti, Siddhartha Chaudhuri, Preethi Jyothi, and Sunita Sarawagi. Generalizing across domains via cross-gradient training. In International Conference on Learning Representations, 2018. ",
+        "bbox": [
+            174,
+            128,
+            823,
+            172
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "[19] Fabio M Carlucci, Antonio D’Innocente, Silvia Bucci, Barbara Caputo, and Tatiana Tommasi. Domain generalization by solving jigsaw puzzles. In IEEE/CVF Conference on Computer Vision and Pattern Recognition, pages 2229–2238, 2019. ",
+        "bbox": [
+            173,
+            181,
+            823,
+            224
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "[20] Martin Arjovsky, Léon Bottou, Ishaan Gulrajani, and David Lopez-Paz. Invariant risk minimization. arXiv preprint arXiv:1907.02893, 2019. ",
+        "bbox": [
+            173,
+            233,
+            823,
+            263
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "[21] David Krueger, Ethan Caballero, Joern-Henrik Jacobsen, Amy Zhang, Jonathan Binas, Remi Le Priol, and Aaron Courville. Out-of-distribution generalization via risk extrapolation (rex). arXiv preprint arXiv:2003.00688, 2020. ",
+        "bbox": [
+            173,
+            272,
+            823,
+            315
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "[22] Ishaan Gulrajani and David Lopez-Paz. In search of lost domain generalization. In International Conference on Learning Representations, 2021. ",
+        "bbox": [
+            173,
+            324,
+            823,
+            354
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "[23] Nitish Shirish Keskar, Dheevatsa Mudigere, Jorge Nocedal, Mikhail Smelyanskiy, and Ping Tak Peter Tang. On large-batch training for deep learning: Generalization gap and sharp minima. In International Conference on Learning Representations, 2017. ",
+        "bbox": [
+            174,
+            362,
+            823,
+            406
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "[24] Timur Garipov, Pavel Izmailov, Dmitrii Podoprikhin, Dmitry P Vetrov, and Andrew Gordon Wilson. Loss surfaces, mode connectivity, and fast ensembling of dnns. In Neural Information Processing Systems, 2018. ",
+        "bbox": [
+            171,
+            415,
+            825,
+            458
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "[25] Pavel Izmailov, Dmitrii Podoprikhin, Timur Garipov, Dmitry Vetrov, and Andrew Gordon Wilson. Averaging weights leads to wider optima and better generalization. Conference on Uncertainty in Artificial Intelligence, 2018. ",
+        "bbox": [
+            171,
+            467,
+            823,
+            511
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "[26] Pierre Foret, Ariel Kleiner, Hossein Mobahi, and Behnam Neyshabur. Sharpness-aware minimization for efficiently improving generalization. In International Conference on Learning Representations, 2021. ",
+        "bbox": [
+            173,
+            518,
+            825,
+            563
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "[27] Gintare Karolina Dziugaite and Daniel M Roy. Computing nonvacuous generalization bounds for deep (stochastic) neural networks with many more parameters than training data. In Uncertainty in Artificial Intelligence, 2017. ",
+        "bbox": [
+            173,
+            571,
+            823,
+            614
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "[28] Yiding Jiang, Behnam Neyshabur, Hossein Mobahi, Dilip Krishnan, and Samy Bengio. Fantastic generalization measures and where to find them. arXiv preprint arXiv:1912.02178, 2019. ",
+        "bbox": [
+            173,
+            625,
+            823,
+            654
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "[29] V Vapnik. Statistical learning theory. NY: Wiley, 1998. ",
+        "bbox": [
+            173,
+            662,
+            568,
+            678
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "[30] Seonguk Seo, Yumin Suh, Dongwan Kim, Jongwoo Han, and Bohyung Han. Learning to optimize domain specific normalization for domain generalization. European Conference on Computer Vision, 2020. ",
+        "bbox": [
+            173,
+            688,
+            823,
+            729
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "[31] Baochen Sun and Kate Saenko. Deep coral: Correlation alignment for deep domain adaptation. In European conference on computer vision, pages 443–450. Springer, 2016. ",
+        "bbox": [
+            171,
+            739,
+            825,
+            770
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "[32] Hyeonseob Nam, HyunJae Lee, Jongchan Park, Wonjun Yoon, and Donggeun Yoo. Reducing domain gap by reducing style bias. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, pages 8690–8699, 2021. ",
+        "bbox": [
+            173,
+            779,
+            823,
+            821
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "[33] Prithvijit Chattopadhyay, Yogesh Balaji, and Judy Hoffman. Learning to balance specificity and invariance for in and out of domain generalization. In European Conference on Computer Vision, pages 301–318. Springer, 2020. ",
+        "bbox": [
+            174,
+            830,
+            823,
+            873
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "[34] Matthew Norton and Johannes O Royset. Diametrical risk minimization: Theory and computations. arXiv preprint arXiv:1910.10844, 2019. ",
+        "bbox": [
+            173,
+            882,
+            821,
+            911
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "[35] Hongyi Zhang, Moustapha Cisse, Yann N. Dauphin, and David Lopez-Paz. mixup: Beyond empirical risk minimization. International Conference on Learning Representations, 2018.   \n[36] Sangdoo Yun, Dongyoon Han, Seong Joon Oh, Sanghyuk Chun, Junsuk Choe, and Youngjoon Yoo. Cutmix: Regularization strategy to train strong classifiers with localizable features. In International Conference on Computer Vision (ICCV), 2019.   \n[37] Shai Ben-David, John Blitzer, Koby Crammer, Alex Kulesza, Fernando Pereira, and Jennifer Wortman Vaughan. A theory of learning from different domains. Machine learning, 79(1): 151–175, 2010.   \n[38] Diederik P Kingma and Jimmy Ba. Adam: A method for stochastic optimization. In International Conference on Learning Representations, 2015.   \n[39] Pratik Chaudhari, Anna Choromanska, Stefano Soatto, Yann LeCun, Carlo Baldassi, Christian Borgs, Jennifer Chayes, Levent Sagun, and Riccardo Zecchina. Entropy-sgd: Biasing gradient descent into wide valleys. Journal of Statistical Mechanics: Theory and Experiment, 2019(12): 124018, 2019.   \n[40] Leslie N Smith. Cyclical learning rates for training neural networks. In 2017 IEEE winter conference on applications of computer vision (WACV), pages 464–472. IEEE, 2017.   \n[41] Kaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. Deep residual learning for image recognition. In IEEE Conference on Computer Vision and Pattern Recognition, 2016.   \n[42] Olga Russakovsky, Jia Deng, Hao Su, Jonathan Krause, Sanjeev Satheesh, Sean Ma, Zhiheng Huang, Andrej Karpathy, Aditya Khosla, Michael Bernstein, et al. Imagenet large scale visual recognition challenge. International Journal of Computer Vision, 115(3):211–252, 2015.   \n[43] Chen Fang, Ye Xu, and Daniel N Rockmore. Unbiased metric learning: On the utilization of multiple datasets and web images for softening bias. In IEEE International Conference on Computer Vision, pages 1657–1664, 2013.   \n[44] Hemanth Venkateswara, Jose Eusebio, Shayok Chakraborty, and Sethuraman Panchanathan. Deep hashing network for unsupervised domain adaptation. In IEEE conference on computer vision and pattern recognition, pages 5018–5027, 2017.   \n[45] Sara Beery, Grant Van Horn, and Pietro Perona. Recognition in terra incognita. In European Conference on Computer Vision, pages 456–473, 2018.   \n[46] Xingchao Peng, Qinxun Bai, Xide Xia, Zijun Huang, Kate Saenko, and Bo Wang. Moment matching for multi-source domain adaptation. In IEEE/CVF International Conference on Computer Vision, pages 1406–1415, 2019.   \n[47] Oren Nuriel, Sagie Benaim, and Lior Wolf. Permuted adain: Reducing the bias towards global statistics in image classification. In IEEE/CVF Conference on Computer Vision and Pattern Recognition, 2021.   \n[48] Shujun Wang, Lequan Yu, Caizi Li, Chi-Wing Fu, and Pheng-Ann Heng. Learning from extrinsic and intrinsic supervisions for domain generalization. In European Conference on Computer Vision, pages 159–176. Springer, 2020.   \n[49] Shiori Sagawa\\*, Pang Wei Koh\\*, Tatsunori B. Hashimoto, and Percy Liang. Distributionally robust neural networks. In International Conference on Learning Representations, 2020.   \n[50] Minghao Xu, Jian Zhang, Bingbing Ni, Teng Li, Chengjie Wang, Qi Tian, and Wenjun Zhang. Adversarial domain adaptation with domain mixup. In AAAI Conference on Artificial Intelligence, volume 34, pages 6502–6509, 2020.   \n[51] Shen Yan, Huan Song, Nanxiang Li, Lincan Zou, and Liu Ren. Improve unsupervised domain adaptation with mixup training. arXiv preprint arXiv:2001.00677, 2020.   \n[52] Yufei Wang, Haoliang Li, and Alex C Kot. Heterogeneous domain generalization via domain mixup. In IEEE International Conference on Acoustics, Speech and Signal Processing, pages 3622–3626. IEEE, 2020.   \n[53] Haoliang Li, Sinno Jialin Pan, Shiqi Wang, and Alex C Kot. Domain generalization with adversarial feature learning. In IEEE Conference on Computer Vision and Pattern Recognition, pages 5400–5409, 2018.   \n[54] Gilles Blanchard, Aniket Anand Deshmukh, Urun Dogan, Gyemin Lee, and Clayton Scott. Domain generalization by marginal transfer learning. Journal of Machine Learning Research, 22(2):1–55, 2021.   \n[55] Zeyi Huang, Haohan Wang, Eric P Xing, and Dong Huang. Self-challenging improves crossdomain generalization. European Conference on Computer Vision, 2, 2020.   \n[56] Boris T Polyak and Anatoli B Juditsky. Acceleration of stochastic approximation by averaging. SIAM journal on control and optimization, 30(4):838–855, 1992.   \n[57] Takeru Miyato, Shin-ichi Maeda, Masanori Koyama, and Shin Ishii. Virtual adversarial training: a regularization method for supervised and semi-supervised learning. IEEE Transactions on Pattern Analysis and Machine Intelligence, 41(8):1979–1993, 2018.   \n[58] Samuli Laine and Timo Aila. Temporal ensembling for semi-supervised learning. In International Conference on Learning Representations, 2017.   \n[59] Dan Hendrycks and Thomas Dietterich. Benchmarking neural network robustness to common corruptions and perturbations. In International Conference on Learning Representations, 2018.   \n[60] Dan Hendrycks, Steven Basart, Norman Mu, Saurav Kadavath, Frank Wang, Evan Dorundo, Rahul Desai, Tyler Zhu, Samyak Parajuli, Mike Guo, et al. The many faces of robustness: A critical analysis of out-of-distribution generalization. arXiv preprint arXiv:2006.16241, 2020.   \n[61] Kai Yuanqing Xiao, Logan Engstrom, Andrew Ilyas, and Aleksander Madry. Noise or signal: The role of image backgrounds in object recognition. In International Conference on Learning Representations, 2020.   \n[62] Hanjoo Kim, Minkyu Kim, Dongjoo Seo, Jinwoong Kim, Heungseok Park, Soeun Park, Hyunwoo Jo, KyungHyun Kim, Youngil Yang, Youngkwan Kim, et al. Nsml: Meet the mlaas platform with a real-world case study. arXiv preprint arXiv:1810.09957, 2018. ",
+        "bbox": [
+            169,
+            42,
+            826,
+            917
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            171,
+            89,
+            828,
+            547
+        ],
+        "page_idx": 13
+    }
+]