Add files using upload-large-folder tool

.gitattributes

@@ -16181,3 +16181,101 @@ parse/train/URc7gYBcjVn/URc7gYBcjVn_span.pdf filter=lfs diff=lfs merge=lfs -text
 parse/train/URc7gYBcjVn/URc7gYBcjVn_layout.pdf filter=lfs diff=lfs merge=lfs -text
 parse/train/Hyl9xxHYPr/Hyl9xxHYPr_layout.pdf filter=lfs diff=lfs merge=lfs -text
 parse/train/Hyl9xxHYPr/Hyl9xxHYPr_span.pdf filter=lfs diff=lfs merge=lfs -text
+parse/train/Hyl9xxHYPr/Hyl9xxHYPr_origin.pdf filter=lfs diff=lfs merge=lfs -text
+parse/train/Hke0K1HKwr/Hke0K1HKwr_origin.pdf filter=lfs diff=lfs merge=lfs -text
+parse/train/Hke0K1HKwr/Hke0K1HKwr_span.pdf filter=lfs diff=lfs merge=lfs -text
+parse/train/Hke0K1HKwr/Hke0K1HKwr_layout.pdf filter=lfs diff=lfs merge=lfs -text
+parse/train/OEgDatKuz2O/OEgDatKuz2O_layout.pdf filter=lfs diff=lfs merge=lfs -text
+parse/train/OEgDatKuz2O/OEgDatKuz2O_origin.pdf filter=lfs diff=lfs merge=lfs -text
+parse/train/OEgDatKuz2O/OEgDatKuz2O_span.pdf filter=lfs diff=lfs merge=lfs -text
+parse/train/bqGK5PyI6-N/bqGK5PyI6-N_layout.pdf filter=lfs diff=lfs merge=lfs -text
+parse/train/bqGK5PyI6-N/bqGK5PyI6-N_span.pdf filter=lfs diff=lfs merge=lfs -text
+parse/train/bqGK5PyI6-N/bqGK5PyI6-N_origin.pdf filter=lfs diff=lfs merge=lfs -text
+parse/train/HygOjhEYDH/HygOjhEYDH_span.pdf filter=lfs diff=lfs merge=lfs -text
+parse/train/HygOjhEYDH/HygOjhEYDH_layout.pdf filter=lfs diff=lfs merge=lfs -text
+parse/train/HygOjhEYDH/HygOjhEYDH_origin.pdf filter=lfs diff=lfs merge=lfs -text
+parse/train/HkSOlP9lg/HkSOlP9lg_origin.pdf filter=lfs diff=lfs merge=lfs -text
+parse/train/HkSOlP9lg/HkSOlP9lg_span.pdf filter=lfs diff=lfs merge=lfs -text
+parse/train/HkSOlP9lg/HkSOlP9lg_layout.pdf filter=lfs diff=lfs merge=lfs -text
+parse/train/r1lrAiA5Ym/r1lrAiA5Ym_origin.pdf filter=lfs diff=lfs merge=lfs -text
+parse/train/r1lrAiA5Ym/r1lrAiA5Ym_layout.pdf filter=lfs diff=lfs merge=lfs -text
+parse/train/r1lrAiA5Ym/r1lrAiA5Ym_span.pdf filter=lfs diff=lfs merge=lfs -text
+parse/train/HJgJNCEKPr/HJgJNCEKPr_span.pdf filter=lfs diff=lfs merge=lfs -text
+parse/train/HJgJNCEKPr/HJgJNCEKPr_layout.pdf filter=lfs diff=lfs merge=lfs -text
+parse/train/HJgJNCEKPr/HJgJNCEKPr_origin.pdf filter=lfs diff=lfs merge=lfs -text
+parse/train/cdlzxKUBr-A/cdlzxKUBr-A_layout.pdf filter=lfs diff=lfs merge=lfs -text
+parse/train/cdlzxKUBr-A/cdlzxKUBr-A_origin.pdf filter=lfs diff=lfs merge=lfs -text
+parse/train/cdlzxKUBr-A/cdlzxKUBr-A_span.pdf filter=lfs diff=lfs merge=lfs -text
+parse/train/rylDfnCqF7/rylDfnCqF7_layout.pdf filter=lfs diff=lfs merge=lfs -text
+parse/train/rylDfnCqF7/rylDfnCqF7_origin.pdf filter=lfs diff=lfs merge=lfs -text
+parse/train/rylDfnCqF7/rylDfnCqF7_span.pdf filter=lfs diff=lfs merge=lfs -text
+parse/train/B9t708KMr9d/B9t708KMr9d_layout.pdf filter=lfs diff=lfs merge=lfs -text
+parse/train/B9t708KMr9d/B9t708KMr9d_origin.pdf filter=lfs diff=lfs merge=lfs -text
+parse/train/B9t708KMr9d/B9t708KMr9d_span.pdf filter=lfs diff=lfs merge=lfs -text
+parse/train/HyxY6JHKwr/HyxY6JHKwr_origin.pdf filter=lfs diff=lfs merge=lfs -text
+parse/train/HyxY6JHKwr/HyxY6JHKwr_layout.pdf filter=lfs diff=lfs merge=lfs -text
+parse/train/HyxY6JHKwr/HyxY6JHKwr_span.pdf filter=lfs diff=lfs merge=lfs -text
+parse/train/r1Ddp1-Rb/r1Ddp1-Rb_span.pdf filter=lfs diff=lfs merge=lfs -text
+parse/train/r1Ddp1-Rb/r1Ddp1-Rb_layout.pdf filter=lfs diff=lfs merge=lfs -text
+parse/train/r1Ddp1-Rb/r1Ddp1-Rb_origin.pdf filter=lfs diff=lfs merge=lfs -text
+parse/train/SklsBJHKDS/SklsBJHKDS_origin.pdf filter=lfs diff=lfs merge=lfs -text
+parse/train/SklsBJHKDS/SklsBJHKDS_span.pdf filter=lfs diff=lfs merge=lfs -text
+parse/train/SklsBJHKDS/SklsBJHKDS_layout.pdf filter=lfs diff=lfs merge=lfs -text
+parse/train/r1gdj2EKPB/r1gdj2EKPB_span.pdf filter=lfs diff=lfs merge=lfs -text
+parse/train/r1gdj2EKPB/r1gdj2EKPB_layout.pdf filter=lfs diff=lfs merge=lfs -text
+parse/train/r1gdj2EKPB/r1gdj2EKPB_origin.pdf filter=lfs diff=lfs merge=lfs -text
+parse/train/SJZsR7kCZ/SJZsR7kCZ_span.pdf filter=lfs diff=lfs merge=lfs -text
+parse/train/SJZsR7kCZ/SJZsR7kCZ_origin.pdf filter=lfs diff=lfs merge=lfs -text
+parse/train/SJZsR7kCZ/SJZsR7kCZ_layout.pdf filter=lfs diff=lfs merge=lfs -text
+parse/train/ByghKiC5YX/ByghKiC5YX_layout.pdf filter=lfs diff=lfs merge=lfs -text
+parse/train/ByghKiC5YX/ByghKiC5YX_origin.pdf filter=lfs diff=lfs merge=lfs -text
+parse/train/ByghKiC5YX/ByghKiC5YX_span.pdf filter=lfs diff=lfs merge=lfs -text
+parse/train/Skgxcn4YDS/Skgxcn4YDS_span.pdf filter=lfs diff=lfs merge=lfs -text
+parse/train/Skgxcn4YDS/Skgxcn4YDS_layout.pdf filter=lfs diff=lfs merge=lfs -text
+parse/train/Skgxcn4YDS/Skgxcn4YDS_origin.pdf filter=lfs diff=lfs merge=lfs -text
+parse/train/SklVEnR5K7/SklVEnR5K7_origin.pdf filter=lfs diff=lfs merge=lfs -text
+parse/train/SklVEnR5K7/SklVEnR5K7_layout.pdf filter=lfs diff=lfs merge=lfs -text
+parse/train/SklVEnR5K7/SklVEnR5K7_span.pdf filter=lfs diff=lfs merge=lfs -text
+parse/train/HktJec1RZ/HktJec1RZ_layout.pdf filter=lfs diff=lfs merge=lfs -text
+parse/train/HktJec1RZ/HktJec1RZ_span.pdf filter=lfs diff=lfs merge=lfs -text
+parse/train/HktJec1RZ/HktJec1RZ_origin.pdf filter=lfs diff=lfs merge=lfs -text
+parse/train/HyM8V2A9Km/HyM8V2A9Km_origin.pdf filter=lfs diff=lfs merge=lfs -text
+parse/train/HyM8V2A9Km/HyM8V2A9Km_span.pdf filter=lfs diff=lfs merge=lfs -text
+parse/train/HyM8V2A9Km/HyM8V2A9Km_layout.pdf filter=lfs diff=lfs merge=lfs -text
+parse/train/Hk8rlUqge/Hk8rlUqge_span.pdf filter=lfs diff=lfs merge=lfs -text
+parse/train/Hk8rlUqge/Hk8rlUqge_origin.pdf filter=lfs diff=lfs merge=lfs -text
+parse/train/Hk8rlUqge/Hk8rlUqge_layout.pdf filter=lfs diff=lfs merge=lfs -text
+parse/train/ByxPYjC5KQ/ByxPYjC5KQ_span.pdf filter=lfs diff=lfs merge=lfs -text
+parse/train/ByxPYjC5KQ/ByxPYjC5KQ_layout.pdf filter=lfs diff=lfs merge=lfs -text
+parse/train/ByxPYjC5KQ/ByxPYjC5KQ_origin.pdf filter=lfs diff=lfs merge=lfs -text
+parse/train/iVaPuvROtMm/iVaPuvROtMm_layout.pdf filter=lfs diff=lfs merge=lfs -text
+parse/train/iVaPuvROtMm/iVaPuvROtMm_origin.pdf filter=lfs diff=lfs merge=lfs -text
+parse/train/iVaPuvROtMm/iVaPuvROtMm_span.pdf filter=lfs diff=lfs merge=lfs -text
+parse/train/QbVza2PKM7T/QbVza2PKM7T_layout.pdf filter=lfs diff=lfs merge=lfs -text
+parse/train/QbVza2PKM7T/QbVza2PKM7T_span.pdf filter=lfs diff=lfs merge=lfs -text
+parse/train/QbVza2PKM7T/QbVza2PKM7T_origin.pdf filter=lfs diff=lfs merge=lfs -text
+parse/train/SkxpxJBKwS/SkxpxJBKwS_layout.pdf filter=lfs diff=lfs merge=lfs -text
+parse/train/SkxpxJBKwS/SkxpxJBKwS_origin.pdf filter=lfs diff=lfs merge=lfs -text
+parse/train/SkxpxJBKwS/SkxpxJBKwS_span.pdf filter=lfs diff=lfs merge=lfs -text
+parse/train/S1lhbnRqF7/S1lhbnRqF7_layout.pdf filter=lfs diff=lfs merge=lfs -text
+parse/train/S1lhbnRqF7/S1lhbnRqF7_span.pdf filter=lfs diff=lfs merge=lfs -text
+parse/train/S1lhbnRqF7/S1lhbnRqF7_origin.pdf filter=lfs diff=lfs merge=lfs -text
+parse/train/SkfTIj0cKX/SkfTIj0cKX_span.pdf filter=lfs diff=lfs merge=lfs -text
+parse/train/SkfTIj0cKX/SkfTIj0cKX_origin.pdf filter=lfs diff=lfs merge=lfs -text
+parse/train/SkfTIj0cKX/SkfTIj0cKX_layout.pdf filter=lfs diff=lfs merge=lfs -text
+parse/train/aohkNJxjYJX/aohkNJxjYJX_origin.pdf filter=lfs diff=lfs merge=lfs -text
+parse/train/aohkNJxjYJX/aohkNJxjYJX_layout.pdf filter=lfs diff=lfs merge=lfs -text
+parse/train/aohkNJxjYJX/aohkNJxjYJX_span.pdf filter=lfs diff=lfs merge=lfs -text
+parse/train/ry3iBFqgl/ry3iBFqgl_origin.pdf filter=lfs diff=lfs merge=lfs -text
+parse/train/ry3iBFqgl/ry3iBFqgl_layout.pdf filter=lfs diff=lfs merge=lfs -text
+parse/train/XjIm8hOCxTm/XjIm8hOCxTm_origin.pdf filter=lfs diff=lfs merge=lfs -text
+parse/train/SklTQCNtvS/SklTQCNtvS_origin.pdf filter=lfs diff=lfs merge=lfs -text
+parse/train/SklTQCNtvS/SklTQCNtvS_span.pdf filter=lfs diff=lfs merge=lfs -text
+parse/train/SklTQCNtvS/SklTQCNtvS_layout.pdf filter=lfs diff=lfs merge=lfs -text
+parse/train/rJeW1yHYwH/rJeW1yHYwH_span.pdf filter=lfs diff=lfs merge=lfs -text
+parse/train/rJeW1yHYwH/rJeW1yHYwH_layout.pdf filter=lfs diff=lfs merge=lfs -text
+parse/train/rJeW1yHYwH/rJeW1yHYwH_origin.pdf filter=lfs diff=lfs merge=lfs -text
+parse/train/BJlBSkHtDS/BJlBSkHtDS_layout.pdf filter=lfs diff=lfs merge=lfs -text
+parse/train/BJlBSkHtDS/BJlBSkHtDS_span.pdf filter=lfs diff=lfs merge=lfs -text
+parse/train/BJlBSkHtDS/BJlBSkHtDS_origin.pdf filter=lfs diff=lfs merge=lfs -text
+parse/train/IOqr2ZyXHz1/IOqr2ZyXHz1_span.pdf filter=lfs diff=lfs merge=lfs -text

parse/dev/E0zOKxQsZhN/E0zOKxQsZhN.md

@@ -0,0 +1,505 @@
+# RECURRENT MODEL-FREE RL IS A STRONGBASELINE FOR MANY POMDPS
+
+Anonymous authors Paper under double-blind review
+
+# ABSTRACT
+
+Many problems in RL, such as meta RL, robust RL, and generalization in RL, can be cast as POMDPs. In theory, simply augmenting model-free RL with memory, such as recurrent neural networks, provides a general approach to solving all types of POMDPs. However, prior work has found that such recurrent model-free $R L$ methods tend to perform worse than more specialized algorithms that are designed for specific types of POMDPs. This paper revisits this claim. We find that a careful architecture and hyperparameter decisions yield a recurrent model-free implementation that performs on par with (and occasionally substantially better than) more sophisticated recent techniques in their respective domains. We also release a simple and efficient implementation of recurrent model-free RL for future work to use as a baseline for POMDPs.1
+
+# 1 INTRODUCTION
+
+While reinforcement learning (RL) is often cast as the problem of learning a single fully observable task, also known as MDP, training and testing on that same task, most real-world applications of RL demand some degree of transfer and partial observability. For example, visual navigation (Zhu et al., 2017) requires adaptation to unseen scenes with occlusion in observations, and human-robot collaboration requires that robots infer the intentions of human collaborators. (Chen et al., 2018).
+
+Many subareas in RL study problems that are special cases of POMDPs, and we summarize them in Table 1. For example, meta RL (Duan et al., 2016; Schmidhuber, 1987; Thrun & Pratt, 2012; Wang et al., 2017) is a POMDP where certain aspects of the reward function or (less commonly) dynamics function are unobserved but held constant through one episode. The robust RL problem (Bagnell et al., 2001; Pattanaik et al., 2018; Pinto et al., 2017; Rajeswaran et al., 2017a) assumes that certain aspects of the dynamics or reward function are
+
+![](images/0263b0377870a9e706cac9a587cc7239ea6cfcc9daae0f0b1f499a4ca8db104b.jpg)  
+Figure 1: Implementation Matters for Recurrent Model-Free RL. This paper identifies critical design decisions for recurrent model-free RL that outperforms not only prior implementations (e.g. PPO-GRU and A2C-GRU from Kostrikov (2018)), but also purposedesigned methods (e.g. VRM from Han et al. (2020)). We also show Markovian policies as lower bounds for reference. The y-axis is normalized return given the return of oracle policy (Raffin et al., 2021).
+
+unknown, aiming at finding optimal policies that perform against adversarially-chosen perturbations. Generalization in RL (Cobbe et al., 2019; Packer et al., 2018; Whiteson et al., 2011; Zhang et al., 2018a) focuses on unobserved aspects of the dynamics or reward function that are novel during testing, using an average-case objective instead of a worst-case objective like robust RL. Recent work has proposed efficient and performant algorithms for solving these specialized problem settings. However, these algorithms often make assumptions that preclude their application to other classes of POMDPs. For example, methods for robust RL are rarely used for the meta RL setting due to objective mismatch; methods for meta RL are rarely used for general POMDPs due to the stationarity assumption in meta RL.
+
+Nonetheless, many prior works have used a simple baseline that is applicable to all POMDPs: model-free RL equipped with a recurrent policy and (sometimes) value function (Duan et al., 2016; Fakoor et al., 2020; Igl et al., 2018; Packer et al., 2018; Rakelly et al., 2019; Wang et al., 2017; Yu et al., 2019). We will refer to this approach as recurrent model-free RL. This baseline is simultaneously simple (requiring changing only a few lines of code from a model-free RL algorithm) and general. However, prior work has consistently found that recurrent model-free RL performs poorly across a wide range of problem settings, including meta RL (Rakelly et al., 2019; Zintgraf et al., 2020), general POMDPs (Han et al., 2020; Igl et al., 2018), robust RL (Zhang et al., 2021), and generalization in RL (Packer et al., 2018). One common explanation is that specialized algorithms that are tailored to specific types of POMDPs are very likely to outperform recurrent model-free RL because they (implicitly) encode inductive biases for solving these specific tasks. For example, algorithms for meta RL may leverage the assumption that the underlying dynamics (while unknown) are fixed, and the underlying goals are fixed within one episode (Rakelly et al., 2019; Zintgraf et al., 2020); algorithms for robust RL may assume that the dynamics parameters are known (Rajeswaran et al., 2017a) and dynamics is Lipschitz continuous (Jiang et al., 2021).
+
+This paper challenges this explanation. We argue that, contrary to popular belief, recurrent modelfree RL is competitive with recent state-of-the-art algorithms across a range of different POMDP settings. Similar to prior work in Markovian on-policy RL methods (Andrychowicz et al., 2021; Engstrom et al., 2020), our experiments show that implementation in recurrent model-free RL matters. Fig. 1 shows a typical scenario in PyBullet occlusion environments (Coumans & Bai, 2016) to support this argument. Through extensive experiments, we show that the careful design and implementation of recurrent model-free RL is critical to its performance. Design decisions, such as the actor-critic architecture, conditioning on previous actions and/or rewards, the underlying model-free RL algorithms, and context length in RNNs, are especially crucial.
+
+The main contribution of this paper is a performant implementation of recurrent-model free RL. We demonstrate that simple yet important design decisions, such as the underlying RL algorithm and the context length, yield a recurrent model-free RL algorithm that performs on par with prior specialized POMDP algorithms on the environments those algorithms were designed to solve. Ablation experiments identify the importance of these design decisions. We also open-sourced our code that is easy to use and memory-efficient.
+
+# 2 BACKGROUND
+
+MDP. A Markov decision process (MDP) (Bellman, 1957) is a tuple $( S , A , T , T _ { 0 } , R , H , \gamma )$ , where $s$ is the set of states, $\mathcal { A }$ is the set of actions, $T : \mathcal { S } \times \mathcal { A } \times \mathcal { S }  [ 0 , 1 ]$ is the transition function (dynamics), $T _ { 0 } : { \mathcal { S } }  [ 0 , 1 ]$ is the initial state distribution, $R : \mathcal { S } \times \mathcal { A } \times \mathcal { S } \to \mathbb { R }$ is the reward function, $H \in \mathbb { N }$ is the time horizon, and $\gamma \in \ [ 0 , 1 )$ is the discount factor. Solving an MDP requires learning a memoryless policy $\pi : \mathcal { S \times A } \to [ 0 , 1 ]$ that maximizes the expected discounted return: $\begin{array} { r } { \pi ^ { * } = \arg \operatorname* { m a x } _ { \pi } \mathbb { E } _ { s _ { t } , a _ { t } , r _ { t } \sim T , \pi } \left[ \sum _ { t = 0 } ^ { H - 1 } \gamma ^ { t } r _ { t + 1 } \ | \ s _ { 0 } \right] } \end{array}$ . For any MDP, there exists an optimal policy that is both memoryless and deterministic (Puterman, 2014). MaxEnt RL algorithms (Ziebart, 2010), such as SAC (Haarnoja et al., 2018a), add an entropy bonus to the RL objective.
+
+POMDP. A partially observable Markov decision process (POMDP) (Astr ˚ om¨ , 1965) is a tuple $( S , A , \mathcal { O } , T , T _ { 0 } , O , O _ { 0 } , R , H , \gamma )$ , where the underlying process is an MDP $( S , A , T , T _ { 0 } , R , H , \gamma )$ . Let $\mathcal { O }$ be the set of observations and let $O : S \times A \times \mathcal { O }  [ 0 , 1 ]$ be the emission function. Let the observable trajectory up to time-step $t$ be $\tau _ { 0 : t } = ( o _ { 0 } , a _ { 0 } , o _ { 1 } , r _ { 1 } , \dots , a _ { t - 1 } , o _ { t } , r _ { t } )$ , the memory-based policy in the most general form is defined as $\pi ( \boldsymbol { a } _ { t } \mid \tau _ { 0 : t } )$ , conditioning on the whole history. At the first time step $t = 0$ , an initial state $s _ { 0 } \sim T _ { 0 } ( \cdot )$ and initial observation $\phantom { } O _ { 0 } \sim O _ { 0 } ( \cdot \mid s _ { 0 } )$ are sampled. At any time-step $t \in \{ 0 , \ldots , H - 1 \}$ , the policy emits the action $a _ { t } \in \mathcal A$ to the system, the system updates the state following the dynamics, $s _ { t + 1 } \sim T ( \cdot \mid s _ { t } , a _ { t } )$ , then the next observation is sampled $\tilde { o _ { t + 1 } } \sim O ( \cdot \mid s _ { t + 1 } , a _ { t } )$ and the reward is computed as $r _ { t + 1 } = R ( s _ { t } , a _ { t } , s _ { t + 1 } )$ .
+
+We refer to the part of the state $s _ { t }$ at current time-step $t$ that can be directly unveiled from current observation $o _ { t }$ as the observable state sot , and the rest part of the state as the hidden state s ht . We call the hidden state $s _ { t } ^ { h }$ stationary if it does not change within an episode. In this scenario, the policy objective can be rewritten as $\pi ^ { * } =$ arg $\begin{array} { r } { \operatorname* { m a x } _ { \boldsymbol { \pi } } \mathbb { E } _ { s ^ { h } \sim T _ { 0 } } \left[ \mathbb { E } _ { s _ { t } , a _ { t } , r _ { t } \sim T , O , O _ { 0 } , \boldsymbol { \pi } } \left[ \sum _ { t = 0 } ^ { H - 1 } \gamma ^ { t } r _ { t + 1 } \ | \ s ^ { h } \right] \right] } \end{array}$ for the average-case POMDP objec
+
+Table 1: The summary of selected POMDP subareas. For each subarea, we list the information of the hidden state $s ^ { h }$ including its appearance in dynamics and reward function and its stationarity during one trajectory. We also list the policy input space that are connected with the hidden states, where $\bigcirc$ , a, r, and d refer to the sequence of observations, actions, rewards, and done signals, respectively. Finally, we list the RL objective in terms of average-case or worst-case, and whether there is a domain shift between training and testing environments. We append the check $( \checkmark )$ or cross mark $( { \pmb x } )$ with $^ *$ if it applies to some but not all the work in that subarea. The notation in this table will be covered in Sec. 2.
+
+<table><tr><td rowspan=1 colspan=1>Subarea</td><td rowspan=1 colspan=1>shin dynam-sics？</td><td rowspan=1 colspan=1>sin re-ward?</td><td rowspan=1 colspan=1>Isshsta-tionary?</td><td rowspan=1 colspan=1>Policy in-put space</td><td rowspan=1 colspan=1>RL objec-tive</td><td rowspan=1 colspan=1>Domainshift？</td></tr><tr><td rowspan=1 colspan=1>“Standard”POMDP</td><td rowspan=1 colspan=1>√</td><td rowspan=1 colspan=1>√</td><td rowspan=1 colspan=1>X</td><td rowspan=1 colspan=1>oar</td><td rowspan=1 colspan=1>Avg</td><td rowspan=1 colspan=1>X</td></tr><tr><td rowspan=1 colspan=1>Meta RL</td><td rowspan=1 colspan=1>X*</td><td rowspan=1 colspan=1>√</td><td rowspan=1 colspan=1>√</td><td rowspan=1 colspan=1>oard</td><td rowspan=1 colspan=1>Avg</td><td rowspan=1 colspan=1>X</td></tr><tr><td rowspan=1 colspan=1>Robust RL</td><td rowspan=1 colspan=1>*</td><td rowspan=1 colspan=1>X</td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>oa</td><td rowspan=1 colspan=1>Worst</td><td rowspan=1 colspan=1>×</td></tr><tr><td rowspan=1 colspan=1>Generalizationin RL</td><td rowspan=1 colspan=1>*</td><td rowspan=1 colspan=1>X*</td><td rowspan=1 colspan=1>*</td><td rowspan=1 colspan=1>oa</td><td rowspan=1 colspan=1>Avg</td><td rowspan=1 colspan=1></td></tr></table>
+
+tive, or POMD $\begin{array} { r } { \pi ^ { * } = \arg \operatorname* { m a x } _ { \pi } \operatorname* { m i n } _ { s ^ { h } \in \mathrm { s u p p } ( T _ { 0 } ) } \mathbb { E } _ { s _ { t } , a _ { t } , r _ { t } \sim T , O , O _ { 0 } , \pi } \left[ \sum _ { t = 0 } ^ { H - 1 } \gamma ^ { t } r _ { t + 1 } \mid s ^ { h } \right] } \end{array}$ for the worst-case
+
+# 3 RELATED WORK
+
+In this section, we discuss several subareas of RL that both explicitly and implicitly solve POMDPs, as well as algorithms proposed for these specialized settings. Table 1 summarizes these subareas.
+
+RL for “Standard” POMDPs. We use the term “standard” to refer to prior work that explicitly labels the problems studied as POMDPs. Common tasks include scenarios where the states are partially occluded (Heess et al., 2015), different states correspond to the same observation (perceptual aliasing (Whitehead & Ballard, 1990)), random frames are dropped (Hausknecht & Stone, 2015), observations use egocentric images (Zhu et al., 2017), or the observations are perturbed with random noise (Meng et al., 2021). These POMDPs often have hidden states that are non-stationary and affect both the rewards and the dynamics. POMDPs are hard to solve (Littman, 1996; Papadimitriou & Tsitsiklis, 1987) because of the curse of dimensionality: the size of the history grows linearly with the horizon length. Many prior POMDP algorithms (Cassandra et al., 1994; Kaelbling et al., 1998) attempt to infer the state from the past sequence of observations, and then apply standard RL techniques to that inferred state. However, the exact inference requires the knowledge of the dynamics, emission, and reward functions, and is intractable in all except the most simple settings. A common strategy for solving these general POMDPs is to use recurrent policies, which take the entire history of past observations as inputs (Bakker, 2001; Schmidhuber, 1991; Wierstra et al., 2007). This strategy is very simple and general, and can be applied to arbitrary tasks without knowledge of the task structure (e.g., whether the hidden states change within an episode) across long time horizons (Duan et al., 2016). These recurrent strategies can be further subdivided into model-free methods (Hausknecht & Stone, 2015; Heess et al., 2015; Meng et al., 2021) , where the single objective is to maximize the return, and model-based methods (Freeman et al., 2019; Han et al., 2020; Igl et al., 2018; Watter et al., 2015) that have explicit objectives on modeling the belief states and use them as the inputs of memoryless policies. The recurrent model-free RL that we focus on belongs to the class of model-free off-policy memory-based algorithms.
+
+Meta RL. Meta RL, also called “learning to learn” (Schmidhuber, 1987; Thrun & Pratt, 2012), focuses on POMDPs where some parameters in the rewards or (less commonly) dynamics are varied from episode to episode, but remain fixed within a single episode, which represent different tasks with different values (Humplik et al., 2019). The meta RL setting is almost the same as multitask RL (Wilson et al., 2007; Yu et al., 2019), but differs in that multi-task RL can observe the task parameters, making it an MDP instead of a POMDP. Algorithms for meta RL can be roughly categorized based on how the adaptation step is performed. Gradient-based algorithms (Fakoor et al., 2020; Finn et al., 2017; Hochreiter et al., 2001) run a few gradient steps on the pre-trained models to adapt. Memory or context-based algorithms use RNNs to implicitly adapt, which can be further subdivided into implicit and explicit task inference methods. Implicit task inference methods (Duan et al., 2016; Wang et al., 2017) use RL objective only to learn recurrent policies. Explicit task inference methods (Rakelly et al., 2019; Zintgraf et al., 2020) train an extra inference model to explicitly estimate task embeddings (i.e., a representation of the unobserved parameters) by variational inference. Task embeddings are then used as additional inputs to memoryless policies.
+
+Robust RL. The goal of robust RL is to find a policy that maximizes returns in the worst-case environments. Early work in the control and operations research community (Khalil et al., 1996; Nilim & Ghaoui, 2005) and RL community (Bagnell et al., 2001; Morimoto & Doya, 2005) focused on linear or finite systems. Prior work designs deep RL algorithms that are robust against a variety of adversarial attacks, including attacks on the dynamics (Jiang et al., 2021; Rajeswaran et al., 2017a), observations (Huang et al., 2017; Pattanaik et al., 2018; Zhang et al., 2021), and actions (Gleave et al., 2020; Pinto et al., 2017; Tessler et al., 2019). Treating the robust RL problem as a POMDP, rather than an MDP (as done in most prior work), unlocks a key capability for RL agents, because agents can use their memory to identify the hidden states of the current adversarial environment, although previous work (Jiang et al., 2021; Rajeswaran et al., 2017a) only train Markovian policies on POMDPs. While some work find memory-based policies are more robust to the adversarial attacks than Markovian policies (Russo & Proutiere \` , 2021; Zhang et al., 2021), they train these baselines in a single MDP without adversaries, which differs from our training setting where the recurrent model-free RL can have access to a set of MDPs.
+
+Generalization in RL. The goal of generalization in RL is to make RL algorithms perform well in test domains that are unseen during training, which emphasizes the average case on the novel test domains instead of the worse case in the possibly seen test domains as in robust RL. Prior work have studied generalization to initial states in the same MDP (Rajeswaran et al., 2017b; Whiteson et al., 2011; Zhang et al., 2018b), random disturbance in dynamics (Rajeswaran et al., 2017b), states (Stulp et al., 2011), observations (Song et al., 2020; Zhang et al., 2018a), and actions (Srouji et al., 2018), and different modes in procedurally generated games (Cobbe et al., 2019; Farebrother et al., 2018; Justesen et al., 2018). Among them, Packer et al. (2018) provides a benchmark on both in-distribution (ID) and out-of-distribution (OOD) generalization to different dynamics parameters, and Zhao et al. (2019) extends the benchmark by introducing random noise in states, observations, and actions. Algorithms for improving generalization in RL can be roughly divided into classic regularization methods such as weight decay, dropout, batch normalization, and entropy regularization (Cobbe et al., 2020; Farebrother et al., 2018; Igl et al., 2019), model architectures (Raileanu & Fergus, 2021; Srouji et al., 2018), data augmentation through randomization (Lee et al., 2020; Tobin et al., 2017), Although introducing observational noise and the change in dynamics parameters will transform MDPs to POMDPs, few work study memory-based policies such as model-free recurrent RL with mixed results. Same algorithm RL2 (Duan et al., 2016) was found to perform badly in Packer et al. (2018) but relatively well in Yu et al. (2019).
+
+# 4 DESIGN CONSIDERATIONS FOR RECURRENT MODEL-FREE RL
+
+Implementing a recurrent model-free RL algorithm requires making a number of design decisions. This section describes the decisions that we found most important to make recurrent model-free RL competitive with more complex, recent algorithms. We will focus on continuous control problems with state-based inputs (i.e., not image-based inputs). Importantly, we assume that the policy can observe the reward and done signals (the end of one episode during one trial (Duan et al., 2016)) from the environment during evaluation. This assumption is common in prior work (Han et al., 2020; Zintgraf et al., 2020), but many recurrent model-free implementations do not provide the agent with information. In the following paragraphs, we will describe the important decision factors in recurrent model-free RL. Table 2 summarizes how prior work and our method makes these design decisions when implementing recurrent model-free RL.
+
+Recurrent Off-Policy Actor-Critic Architecture. The first important design decision is whether the recurrent policy (actor) and the recurrent Q-value function (critic) use shared RNN encoder (and embedders) or use separate ones. In the experiment section (Sec. 5.2) we will show that a shared encoder would cause large gradient norm in the (off-policy) recurrent actor-critic and thus hinder learning, while separate encoders can greatly mitigate this issue and learn efficiently. This echoes prior work (Fakoor et al., 2020; Meng et al., 2021; Sun et al., 2021; Wang et al., 2020) that also use separate encoders in their (off-policy) recurrent actor-critic. To avoid running an inordinate number of experiments, we will use the separate architecture in the rest of the paper.
+
+Policy Input Space. The next consideration is the input space of the model-free policy. The maximal input space of policy to emit an action $a _ { t }$ at time $t$ , should be the history of all quantities that the policy has observed, namely the past observations $o _ { 0 : t }$ , the past actions $a _ { 0 : t - 1 }$ , the past rewards $r _ { 0 : t }$ , and the past done signals $d _ { 0 : t }$ , which was already employed in the early work (Duan et al., 2016). Generally, the input space of optimal policy should only depend on the quantities that have connections with hidden states (defined in Sec. 2) (Izadi & Precup, 2005; Poupart & Boutilier, 2002). We show the policy input spaces that are connected with the hidden states for the discussed subareas in the “Inputs” column of Table 1. While prior work often only conditions the recurrent RL baseline on previous observations (and actions) (Han et al., 2020; Igl et al., 2018; Kostrikov, 2018; Meng et al., 2021; Wang et al., 2020; Yang & Nguyen, 2021), our experiments in Sec. 5.2 find that additionally conditioning on other previous information, such as previous rewards, can increase reward by up to $3 0 \%$ .
+
+Table 2: How the prior work and our method implement the recurrent model-free RL as their own method or baseline. We can see that none of the prior work share the same set of decision variables, some of which have bad choices that may lead to the poor performance reported in the prior work. Our method covers a range of choices in these decision factors and finds the combinations in the last rows that lead to the best performance in terms of the average performance across the experimented environments in each subarea.   
+
+<table><tr><td>Algorithm</td><td>Domain</td><td>Arch</td><td>Encoder</td><td>Inputs</td><td>Len</td><td>RL</td></tr><tr><td>Duan et al. (2016)</td><td>Meta RL</td><td>separate</td><td>GRU</td><td>oard</td><td>1000</td><td>TRPO,PPO</td></tr><tr><td>Wang et al. (2017)</td><td>Meta RL</td><td>shared</td><td>LSTM</td><td>oart</td><td>5-150</td><td>A2C</td></tr><tr><td>Baseline from Rakelly et al. (2019)</td><td>Meta RL</td><td>separate</td><td>GRU</td><td>oard</td><td>100</td><td>PPO</td></tr><tr><td>Baseline from Zintgraf et al. (2020)</td><td>Meta RL</td><td>separate</td><td>GRU</td><td>oard</td><td>Max</td><td>A2C,PPO</td></tr><tr><td>Baseline from Fakoor et al. (2020)</td><td>MetaRL</td><td>separate</td><td>GRU</td><td>oar</td><td>10-25</td><td>TD3</td></tr><tr><td>Baseline from Yu et al. (2019)</td><td>Meta RL</td><td>separate</td><td>GRU</td><td>oard</td><td>500</td><td>PPO</td></tr><tr><td>Kostrikov (2018)</td><td>POMDP</td><td>shared</td><td>GRU</td><td>0</td><td>5-2048</td><td>PPO,A2C</td></tr><tr><td>Wang et al. (2020)</td><td>POMDP</td><td>separate</td><td>LSTM</td><td>oa</td><td>150</td><td>TD3, SAC</td></tr><tr><td>Meng et al. (2021)</td><td>POMDP</td><td>separate</td><td>LSTM</td><td>oa</td><td>1-5</td><td>TD3</td></tr><tr><td>Yang &amp; Nguyen (2021)</td><td>POMDP</td><td>separate</td><td>both</td><td>oa</td><td>Max</td><td>TD3, SAC</td></tr><tr><td>Baseline from Igl et al. (2018)</td><td>POMDP</td><td>shared</td><td>GRU</td><td>oa</td><td>25</td><td>A2C</td></tr><tr><td>Baseline from Han et al. (2020)</td><td>POMDP</td><td>shared</td><td>LSTM</td><td>0</td><td>64</td><td>SAC</td></tr><tr><td>Baseline from Zhang et al. (2021)</td><td>Robust RL</td><td>separate</td><td>LSTM</td><td>0</td><td>100</td><td>PPO</td></tr><tr><td>Baseline1 from Packer et al. (2018)</td><td>Generalization</td><td>shared</td><td>LSTM</td><td>0</td><td>128-512</td><td>PPO,A2C</td></tr><tr><td>Baseline2 from Packer et al. (2018)</td><td>Generalization</td><td>separate</td><td>LSTM</td><td>oard</td><td>128-512</td><td>PPO,A2C</td></tr><tr><td>Our method</td><td>Meta RL</td><td>separate</td><td>LSTM</td><td>oard</td><td>64</td><td>TD3</td></tr><tr><td>Our method</td><td>POMDP</td><td>separate</td><td>GRU</td><td>oa</td><td>64</td><td>TD3</td></tr><tr><td>Our method</td><td>Robust RL</td><td>separate</td><td>LSTM</td><td>0</td><td>64</td><td>TD3</td></tr><tr><td>Our method</td><td>Generalization</td><td>separate</td><td>LSTM</td><td>0</td><td>64</td><td>TD3</td></tr></table>
+
+Model-free RL Algorithms. Recurrent model-free RL can be understood as applying an off-theshelf model-free RL algorithm with an actor and a Q function parametrized to take sequences of inputs. As such, the choice of the underlying model-free RL algorithm is paramount. Most prior work on continuous control POMDP problems used on-policy algorithms, such as A2C (Mnih et al., 2016), TRPO (Schulman et al., 2015) or PPO (Schulman et al., 2017). While off-policy algorithms such as TD3 (Fujimoto et al., 2018) and SAC (Haarnoja et al., 2018a;b) greatly improve the performance in continuous control MDP problems in terms of sample efficiency and asymptotic performance, these methods are rarely used in recurrent model-free RL baselines (Rakelly et al., 2019; Zhang et al., 2020; Zintgraf et al., 2020). In the experiment section (Sec. 5.1), we will show that using these off-policy algorithms for recurrent model-free RL provides results that are better than using on-policy algorithms and are comparable to their specialized methods in POMDP. This echoes the finding that model-free off-policy TD3-Context (Fakoor et al., 2020) can be better than the specialized method PEARL (Rakelly et al., 2019) in meta RL.
+
+RNN Variants and Context Length. RNN training is known to be unstable, especially with long sequences input (Bengio et al., 1994). The RNN variants like LSTM (Hochreiter & Schmidhuber, 1997) and GRU (Chung et al., 2014) mitigate the training issues, but still may fail to learn long-term dependencies (Trinh et al., 2018). In POMDP problems, these dependencies reflect the memory that an agent must have to solve a task. For example, a POMDP that hides velocities from observations theoretically requires a short memory length to infer velocities through consecutive positions (Meng et al., 2021). Prior work in POMDPs choose a variety set of context lengths for RNNs from 1 to 2048 (see the “Len” column of Table 2), and we select three representatives of short (5), medium (64), and long length (larger than 100) in the experiments (Sec. 5) for comparison. We also try both LSTM and GRU as RNN variants to compare their performance. We find that the optimal context length and RNN variant are task-specific (see Sec. 5.2).
+
+# 5 EXPERIMENTS
+
+Our experiments aim to answer two questions. First, how does a well-tuned implementation of recurrent model-free RL compare to specialized POMDP methods, such as purpose-designed meta RL and robust RL algorithms? To give these prior methods the strongest possible footing, we will compare prior methods on the specific problem types for which they were developed (i.e., meta RL algorithms were tested on meta RL tasks). Our second question studies which design decisions are essential for recurrent model-free RL. We put the environment details in Appendix D.
+
+Code Implementation. We release a modular and highly-configurable implementation of recurrent (off-policy) model-free RL: url. Our implementation is efficient in terms of computer memory compared to previous off-policy RL methods for POMDPs $2 0 0 \mathrm { x }$ less RAM than Han et al. (2020) and $9 \mathbf { x }$ less GPU memory than Dorfman et al. (2020)). Please see the appendix A for details, including an explanation of why our implementation is more memory-efficient than prior work.
+
+# 5.1 RECURRENT MODEL-FREE RL IS COMPARABLE WITH PRIOR SPECIALIZED METHODS
+
+While prior work has studied a range of different POMDP settings (e.g., meta RL, occluded observations), recurrent model-free RL is a ubiquitous baseline (Han et al., 2020; Humplik et al., 2019; Igl et al., 2018; Rakelly et al., 2019; Zintgraf et al., 2020). However, prior work consistently report that this baseline is reported to be unperformed to more specialized methods. This section casts doubt on that claim, showing that a well-tuned implementation of recurrent model-free RL can perform at least as well as more specialized methods.
+
+We study four subareas of POMDPs: the “standard” POMDP, meta RL, robust RL, and generalization in RL. We tune a wide range of decision factors shown in Sec. 4 in our implemented recurrent model-free RL. Appendix A.3 shows the details of the tuning options. For each subarea, we show the performance of a single variant that works best across the environments in that subarea, compared with the prior specialized methods in this subsection. In other words, the following plots of each subarea report the same model-free recurrent RL algorithm with the same hyperparameters. The exact configurations of each subarea can be found in the last four rows of Table 2. Under this restricted setting, we find that our implementation can actually outperform prior (specialized) methods by a wide margin across the four subareas.
+
+For each plot of learning curves, we show three approaches as reference. First, an Oracle policy has access to the POMDP hidden states, turning the POMDP into an MDP; this policy should therefore be treated as an upper bound on the performance that any POMDP method should receive. Second, as a lower bound, we use a Markovian policy to solve the POMDP. Both Oracle policy and Markovian policy are trained with the same hyperparameters as our recurrent model-free RL implementation. Third, we add a Random policy, which represents a trivial lower bound. We show the full learning curves in Appendix E.1 due to the space limit. See Appendix B for details about the implementation of these comparisons.
+
+“Standard” POMDP. Our first experiments look at the “standard” POMDPs that typically occlude some part of states in the environment. We will compare against VRM (Han et al., 2020), a recent state-of-the-art model-based POMDP algorithm. We directly apply the environment design of VRM paper that occludes either positions&angles or velocities of the simulated robot in PyBullet (Coumans & Bai, 2016). There are 8 environments {Hopper, Ant, Walker, Cheetah}- $\{ \mathrm { P } , \mathrm { V } \}$ , where “-P” stands for observing positions&angles only, and “-V” stands for observing velocities only. Fig. 1 and Fig. 18 in appendix show that the best single variant of our model-free recurrent RL implementation outperform VRM in 6 out of 8 environments, especially in {Cheetah,Hopper}- $\{ \mathrm { P } \}$ (over $8 0 \%$ of the Oracles). Our results suggest that, while the variational dynamics model used by VRM may be useful for some tasks, a simple recurrent model-free RL baseline can outperform VRM if properly tuned. While we are primarily interested in sample complexity, but not compute, it is worth noting that our recurrent model-free RL implementation is substantially more efficient than the open-source VRM implementation, training $5 \times$ faster and requiring at most $2 0 0 \times$ less RAM usage (see Appendix A).
+
+Meta RL. We next compare the recurrent model-free RL to the meta RL setting, where some indicator of the task is unobserved. We compare our implementation of recurrent model-free RL to a specialized state-of-the-art method, VariBAD (Zintgraf et al., 2020) that explicitly learns the task embeddings by variational model-based objectives. As suggested by Dorfman et al. (2020), we modified VariBAD to use SAC instead of PPO. This change also allows us for fair comparison with our implementation of recurrent model-free RL, which uses SAC and TD3. We adopt the three environments used in Dorfman et al. (2020) for experiments, including Semi-Circle and CheetahVel, and we also adapt Wind to make it harder to solve. Figure 2 shows that our best single variant outperforms VariBAD and even reaches Oracles in the two meta RL environments, Cheetah-Vel and Wind, leaving Semi-Circle in the appendix. Prior work (Rakelly et al., 2019; Zintgraf et al., 2020) show that disentangling task inference and control can stabilize training. However, our experiments suggest that joint training of task inference and control could also have comparable performance if well implemented. Additionally, because recurrent model-free RL is trained end-to-end, without using pre-trained task representations saved in the replay buffer like the off-policy VariBAD (Dorfman et al., 2020), our implementation does not have non-stationarity issue in task representations.
+
+![](images/30edb2beedd34b03559cfe4a7cb9d2b19f7fdd16870545558111d5f04ec4f72b.jpg)  
+Figure 2: Learning curves on two meta RL environments. The single best variant of our implementation on recurrent model-free RL can surpass the specialized meta RL method off-policy VariBAD (Dorfman et al., 2020), and match the performance of an “Oracle” policy that gets to observe the hidden state.
+
+![](images/473825d8305f612f2647b1794d5d4c29303a403a99877872238870f73e2911e4.jpg)  
+Figure 3: Learning curves on one robust RL environment, Cheetah-Robust. We show the average returns (left figure) and worst returns (right figure) of each method. The single best variant of our implementation on recurrent model-free RL can greatly outperform the specialized robust RL method MRPO (Jiang et al., 2021), and surpass the Oracle that are trained with same simulation and gradient steps.
+
+Robust RL. Thirdly, we focus on the robust RL that aims to maximize the worst returns over the tasks. We choose the recent specialized algorithm MRPO (Jiang et al., 2021) as the compared method, and adopt their used environments based on SunBlaze benchmark (Packer et al., 2018). These environments have hidden states that are fixed during one episode, including the density and the friction coefficients of the simulated robots, namely {Cheetah, Hopper, Walker $\}$ -Robust. Fig. 3 shows both the average return and worst return of our single best variant and MRPO on the three environments, where the worst return is measured by the average return in the worst $1 0 \%$ testing tasks following the practice in Jiang et al. (2021). The results are quite surprising: although our implementation, using average-case RL objective and without access to the hidden states, is not expected to surpass MRPO and Oracle with access to hidden states in worst return, we found that our best variant vastly outperforms the specialized MRPO and Oracle in both average return and worst return, with over $8 0 \%$ fewer simulation steps. Our implementation benefits from its memory and off-policy algorithms, while MRPO might suffer from its Markovian on-policy algorithm and a bit ideal Lipschitz assumption in dynamics. Nevertheless, our implementation is around $1 7 . 5 \mathrm { x }$ slower than MRPO given the same simulation steps (see Appendix A), so we only run it with 3M steps with a limited time budget.
+
+Generalization in RL. Finally, we focus on the SunBlaze benchmark from Packer et al. (2018) for investigating generalization in RL, including {Hopper, Cheetah}-Generalize. We pick the best specialized method in the tables of final performance in Packer et al. (2018), Markovian on-policy robust RL method EPOpt-PPO-FF (Rajeswaran et al., 2017a). Fig. 4 show the interpolation and extrapolation success rates in one environment, where in the interpolation the testing tasks have same distribution of hidden states as that of the training tasks, while in the extrapolation the testing distribution is disjoint from that of training. We can see that our model-free method is on par with the EPOpt-PPO-FF in the interpolation benchmark, while EPOpt-PPO-FF requires access to the dynamics parameters but ours does not. In the extrapolation benchmark, our method greatly outperforms the previous method, although our objective does not consider extrapolation.
+
+![](images/77085ccdb2c33145a870334a711f81035c3a228a1dd349da3475e0735128d0c8.jpg)  
+Figure 4: Learning curves on generalization in one RL environment, Hopper-Generalize. We show the interpolation success rates (left figures) and extrapolation success rates (right figures) of each method. The single best variant of our implementation on recurrent model-free RL can be par with the specialized method EPOpt-PPO-FF (Rajeswaran et al., 2017a) in interpolation and outperform it in extrapolation. The data of EPOpt-PPO-FF and A2C-RC (a recurrent model-free on-policy RL method) are copied from the Table 7 & 8 in Packer et al. (2018).
+
+Overall, we can see that with careful tuning on recurrent model-free RL, it can at least perform as well as the specialized or more complicated methods, in various kinds of POMDPs.
+
+# 5.2 WHAT MATTERS IN RECURRENT MODEL-FREE RL ALGORITHMS?
+
+In the previous subsection, we showed that recurrent model-free RL can perform on par with the specialized (state-of-the-art) methods, then a natural question comes: Why our implementation of recurrent model-free RL outperforms the implementation used in prior work?
+
+Our analysis will focus on ablating the five important design decisions introduced in Sec. 4: the actor-critic architecture (Arch), the policy input space (Inputs), the underlying model-free RL algorithm (RL), the RNN encoder (Encoder), and the RNN context length (Len). See Table. 2 for a summary of how prior work made these design decisions. Due to the space limit, we show the ablation results in some but not all the environments to compare the performance between the best single variant and the other variant that only differs in one decision factor. We also provide “single factor analysis” plots for each decision factor by averaging the performance over the other factors in Appendix E.2.
+
+Recurrent Off-Policy Actor-Critic Architecture. First, we ran some experiments with both shared and separate architectures on two toy POMDP environments. Fig. 5 show the results in one of them (see Appendix E.3 for the other). We can see that the shared architecture failed to learn, compared to the separate architecture. The large RNN gradient norm in the shared architecture suggests that the actor and critic losses may cause conflicts in gradient update. Our results echo prior work (Fakoor et al., 2020; Meng et al.,
+
+![](images/1a7c066033dd192c76200952bccffa2034a7b549306d97b25307dd5892ba7fd1.jpg)  
+Figure 5: Comparison between shared and separate recurrent actor-critic architecture with all the other hyperparameters same, on Semi-Circle, a toy meta RL environment. We show the performance metric (left) and also gradient norm of the RNN encoder(s) (right, in log-scale). For the separate architecture, :critic and :actor refer to the separate RNN in critic and actor networks, respectively.
+
+2021; Sun et al., 2021) that only consider separate RNN encoders that can achieve high asymptotic rewards, and also echo that (Han et al., 2020) shows poor results in the shared architecture of SAC-LSTM.
+
+Policy Input Space. The 1st row of Table 3 shows the effect of policy input space in a POMDP environment Walker-P. The reward signals could help reveal the missing information of the velocity of the robot base, which is occluded in Walker-P. Similarly, the single factor analysis on policy input in Fig. 12 shows that oar is among the best in “-P” environments. Therefore, it is reasonable that adding previous rewards into policy inputs can increase the performance.
+
+Table 3: Ablation results in our implementation of recurrent model-free RL. In this table, we show how a single change in one decision factor from the variant that is best on average in that subarea, could significantly increase the performance. The first column shows how we change the single decision factor, and the last column shows the performance comparison between the best variant in that subarea (left) and the ablated one (right). For robust RL and generalization in RL, we show the performance metric in worst returns and extrapolation success rates, respectively.   
+
+<table><tr><td>Change in one decision factor</td><td>Subarea</td><td>Env</td><td>Performance comparison</td></tr><tr><td>Inputs:oa→oar</td><td>“Standard”POMDP</td><td>Walker-P</td><td>981.6 → 1345.0 (1.3×)</td></tr><tr><td>RL: TD3 →SAC</td><td>“Standard”POMDP</td><td>Ant-P</td><td>310.7 → 2123.5 (6.8×)</td></tr><tr><td>Encoder: LSTM→GRU</td><td>Robust RL</td><td>Walker-Robust</td><td>765.9 → 931.3 (1.2×)</td></tr><tr><td>Len: 64 →400</td><td>Meta RL</td><td>Cheetah-Vel</td><td>-85.2 -→ -74.6 (+14%)</td></tr><tr><td>Len: 64→5</td><td>Generalization</td><td>Hopper-Generalize</td><td>0.292 -→ 0.415 (1.4×)</td></tr><tr><td>Len: 64→5</td><td>“Standard&quot;POMDP</td><td>Walker-V</td><td>121.4 -→ 264.3 (2.2×)</td></tr></table>
+
+Model-free RL Algorithms. Table 2 shows that TD3 dominates all the best variants in each subarea, which may be due to dense reward setting in most environments. However, the 2nd row of Table 3 shows the effect of RL algorithm in a POMDP environment Ant-P. SAC is significantly better than TD3 (increase by $6 . 8 \times$ , surpassing the PPO-GRU (Kostrikov, 2018) in Fig. 1), possibly due to strategic exploration where the action noise conditions on the history instead of being independent. This is prominent mainly in Ant-P as it might be much harder than the others.
+
+RNN Variants and Context Length. Generally, there is no significant difference between LSTM and GRU (see the single factor analysis in Appendix E.2), which is understandable as both are designed for general purpose. Howover, the 3rd row of Table 3 shows the effect of RNN encoder in a robust RL environment. We can see replacing LSTM with GRU can increase the worst-case metric in Walker-Robust. For the context length in RNNs, a medium length (64) dominates in all the best variants in each subarea (see Table 2), which could be viewed as a trade-off between memory capacity and computation costs. However, the remaining rows of Table 3 show the mixed effects of context length in RNNs. Both increasing and decreasing the context length can boost the performance in different environments. Specifically, decreasing the length from 64 to 5 makes our method surpass VRM in Walker-V (increase by $2 . 2 \times \phantom { }$ . This might explain why the prior methods adopt a wide range of context lengths from 1 to 2048 (see Table 2). Therefore, the choice of context length is problem-specific and can require tuning.
+
+Summary. We now summarize the main findings of our experiments:
+
+1. Using separate weights for the recurrent actor and recurrent critic boosts performance, likely because it avoids gradient explosion (Fig. 5 and Fig. 17 in Appendix).   
+2. Using state-of-the-art off-policy RL algorithms as the backbone in recurrent model-free RL can improve asymptotic performance (Fig. 1 and Figures in Appendix E.1).   
+3. The context length for the recurrent actor and critic has a large influence on task performance, but the optimal length is task-specific. Reasonable values are 5 to 500, and 64 is a good start (Rows 4–6 in Table 3 and Figures in Appendix E.2).   
+4. It is important that the inputs to the recurrent actor and critic, such as past observations and past returns, contain enough information to infer the POMDP hidden states (Row 1 in Table 3 and Figures in Appendix E.2).
+
+These findings may provide a useful initialization for researchers studying recurrent model-free RL.
+
+# 6 CONCLUSION
+
+In this paper, we show that a carefully-designed implementation of recurrent model-free RL can perform well across a range of POMDP domains, often on par with (if not significantly better than) prior methods that are specifically designed for specific types of POMDPs. Our ablation experiments demonstrate the importance of key design decisions, such as the underlying RL algorithm and RNN context length. While the best choices for some decisions (such as using separate RNNs for the actor and the critic) are consistent across domains, the best choices for other decisions (such as RNN context length) are problem-dependent.
+
+# REPRODUCIBILITY STATEMENT
+
+We release our code at the url for reproducibility. In this code repository, we provide instructions on how to run our method and the compared methods in this paper on all the environments involved in the experiment section. We provide the default configuration files for training and evaluating these algorithms that are adopted in our experiments. We also attach the numeric results of all the bar charts shown in the experiment section.
+
+ETHICS STATEMENT
+
+We do not believe that our work has direct ethical or societal implications.
+
+# REFERENCES
+
+Marcin Andrychowicz, Anton Raichuk, Piotr Stanczyk, Manu Orsini, Sertan Girgin, Raphael Marinier, L ¨ eonard ´ Hussenot, Matthieu Geist, Olivier Pietquin, Marcin Michalski, Sylvain Gelly, and Olivier Bachem. What matters for on-policy deep actor-critic methods? A large-scale study. In 9th International Conference on Learning Representations, ICLR 2021, Virtual Event, Austria, May 3-7, 2021, 2021.
+
+Karl Johan Astr ˚ om. Optimal control of markov processes with incomplete state information i. ¨ Journal of Mathematical Analysis and Applications, 10:174–205, 1965.
+
+J Andrew Bagnell, Andrew Y Ng, and Jeff G Schneider. Solving uncertain markov decision processes. 2001.
+
+Bram Bakker. Reinforcement learning with long short-term memory. In Advances in Neural Information Processing Systems 14 [Neural Information Processing Systems: Natural and Synthetic, NIPS 2001, December 3-8, 2001, Vancouver, British Columbia, Canada], 2001.
+
+Richard Bellman. A markovian decision process. Journal of mathematics and mechanics, 6(5):679–684, 1957.
+
+Yoshua Bengio, Patrice Y. Simard, and Paolo Frasconi. Learning long-term dependencies with gradient descent is difficult. IEEE Trans. Neural Networks, 1994.
+
+Anthony R. Cassandra, Leslie Pack Kaelbling, and Michael L. Littman. Acting optimally in partially observable stochastic domains. In Proceedings of the 12th National Conference on Artificial Intelligence, Seattle, WA, USA, July 31 - August 4, 1994, Volume 2, 1994.
+
+Min Chen, Stefanos Nikolaidis, Harold Soh, David Hsu, and Siddhartha S. Srinivasa. Planning with trust for human-robot collaboration. In Proceedings of the 2018 ACM/IEEE International Conference on HumanRobot Interaction, HRI 2018, Chicago, IL, USA, March 05-08, 2018, 2018.
+
+Kyunghyun Cho, Bart van Merrienboer, C¸ aglar Gulc¸ehre, Dzmitry Bahdanau, Fethi Bougares, Holger ¨ Schwenk, and Yoshua Bengio. Learning phrase representations using RNN encoder-decoder for statistical machine translation. In Proceedings of the 2014 Conference on Empirical Methods in Natural Language Processing, EMNLP 2014, October 25-29, 2014, Doha, Qatar, A meeting of SIGDAT, a Special Interest Group of the ACL, 2014.
+
+Junyoung Chung, C¸ aglar Gulc¸ehre, KyungHyun Cho, and Yoshua Bengio. Empirical evaluation of gated re-¨ current neural networks on sequence modeling. arXiv preprint arXiv:1412.3555, 2014.
+
+Karl Cobbe, Oleg Klimov, Christopher Hesse, Taehoon Kim, and John Schulman. Quantifying generalization in reinforcement learning. In Proceedings of the 36th International Conference on Machine Learning, ICML 2019, 9-15 June 2019, Long Beach, California, USA, 2019.
+
+Karl Cobbe, Christopher Hesse, Jacob Hilton, and John Schulman. Leveraging procedural generation to benchmark reinforcement learning. In Proceedings of the 37th International Conference on Machine Learning, ICML 2020, 13-18 July 2020, Virtual Event, 2020.
+
+Erwin Coumans and Yunfei Bai. Pybullet, a python module for physics simulation for games, robotics and machine learning. 2016.
+
+Ron Dorfman, Idan Shenfeld, and Aviv Tamar. Offline meta learning of exploration. arXiv preprint arXiv:2008.02598, 2020.
+
+Yan Duan, John Schulman, Xi Chen, Peter L Bartlett, Ilya Sutskever, and Pieter Abbeel. Rl2: Fast reinforcement learning via slow reinforcement learning. arXiv preprint arXiv:1611.02779, 2016.
+
+Logan Engstrom, Andrew Ilyas, Shibani Santurkar, Dimitris Tsipras, Firdaus Janoos, Larry Rudolph, and Aleksander Madry. Implementation matters in deep RL: A case study on PPO and TRPO. In 8th International Conference on Learning Representations, ICLR 2020, Addis Ababa, Ethiopia, April 26-30, 2020, 2020.
+
+Rasool Fakoor, Pratik Chaudhari, Stefano Soatto, and Alexander J. Smola. Meta-q-learning. In 8th International Conference on Learning Representations, ICLR 2020, Addis Ababa, Ethiopia, April 26-30, 2020, 2020.
+
+Jesse Farebrother, Marlos C. Machado, and Michael Bowling. Generalization and regularization in DQN. arXiv preprint arXiv:1810.00123, 2018.
+
+Chelsea Finn, Pieter Abbeel, and Sergey Levine. Model-agnostic meta-learning for fast adaptation of deep networks. In Proceedings of the 34th International Conference on Machine Learning, ICML 2017, Sydney, NSW, Australia, 6-11 August 2017, 2017.
+
+C. Daniel Freeman, David Ha, and Luke Metz. Learning to predict without looking ahead: World models without forward prediction. In Advances in Neural Information Processing Systems 32: Annual Conference on Neural Information Processing Systems 2019, NeurIPS 2019, December 8-14, 2019, Vancouver, BC, Canada, 2019.
+
+Scott Fujimoto, Herke van Hoof, and David Meger. Addressing function approximation error in actor-critic methods. In Proceedings of the 35th International Conference on Machine Learning, ICML 2018, Stockholmsmassan, Stockholm, Sweden, July 10-15, 2018¨ , 2018.
+
+Adam Gleave, Michael Dennis, Cody Wild, Neel Kant, Sergey Levine, and Stuart Russell. Adversarial policies: Attacking deep reinforcement learning. In 8th International Conference on Learning Representations, ICLR 2020, Addis Ababa, Ethiopia, April 26-30, 2020, 2020.
+
+Tuomas Haarnoja, Aurick Zhou, Pieter Abbeel, and Sergey Levine. Soft actor-critic: Off-policy maximum entropy deep reinforcement learning with a stochastic actor. In Proceedings of the 35th International Conference on Machine Learning, ICML 2018, Stockholmsmassan, Stockholm, Sweden, July 10-15, 2018 ¨ , 2018a.
+
+Tuomas Haarnoja, Aurick Zhou, Kristian Hartikainen, George Tucker, Sehoon Ha, Jie Tan, Vikash Kumar, Henry Zhu, Abhishek Gupta, Pieter Abbeel, and Sergey Levine. Soft actor-critic algorithms and applications. arXiv preprint arXiv:1812.05905, 2018b.
+
+Dongqi Han, Kenji Doya, and Jun Tani. Variational recurrent models for solving partially observable control tasks. In 8th International Conference on Learning Representations, ICLR 2020, Addis Ababa, Ethiopia, April 26-30, 2020, 2020.
+
+Matthew J. Hausknecht and Peter Stone. Deep recurrent q-learning for partially observable mdps. In 2015 AAAI Fall Symposia, Arlington, Virginia, USA, November 12-14, 2015, 2015.
+
+Nicolas Heess, Jonathan J. Hunt, Timothy P. Lillicrap, and David Silver. Memory-based control with recurrent neural networks. arXiv preprint arXiv:1512.04455, 2015.
+
+Sepp Hochreiter and Jurgen Schmidhuber. Long short-term memory. ¨ Neural computation, 9(8):1735–1780, 1997.
+
+Sepp Hochreiter, A. Steven Younger, and Peter R. Conwell. Learning to learn using gradient descent. In Artificial Neural Networks - ICANN 2001, International Conference Vienna, Austria, August 21-25, 2001 Proceedings, 2001.
+
+Sandy H. Huang, Nicolas Papernot, Ian J. Goodfellow, Yan Duan, and Pieter Abbeel. Adversarial attacks on neural network policies. In 5th International Conference on Learning Representations, ICLR 2017, Toulon, France, April 24-26, 2017, Workshop Track Proceedings, 2017.
+
+Jan Humplik, Alexandre Galashov, Leonard Hasenclever, Pedro A. Ortega, Yee Whye Teh, and Nicolas Heess. Meta reinforcement learning as task inference. arXiv preprint arXiv:1905.06424, 2019.
+
+Maximilian Igl, Luisa M. Zintgraf, Tuan Anh Le, Frank Wood, and Shimon Whiteson. Deep variational reinforcement learning for pomdps. In Proceedings of the 35th International Conference on Machine Learning, ICML 2018, Stockholmsmassan, Stockholm, Sweden, July 10-15, 2018 ¨ , 2018.
+
+Maximilian Igl, Kamil Ciosek, Yingzhen Li, Sebastian Tschiatschek, Cheng Zhang, Sam Devlin, and Katja Hofmann. Generalization in reinforcement learning with selective noise injection and information bottleneck. In Advances in Neural Information Processing Systems 32: Annual Conference on Neural Information Processing Systems 2019, NeurIPS 2019, December 8-14, 2019, Vancouver, BC, Canada, 2019.
+
+Masoumeh T. Izadi and Doina Precup. Using rewards for belief state updates in partially observable markov decision processes. In Machine Learning: ECML 2005, 16th European Conference on Machine Learning, Porto, Portugal, October 3-7, 2005, Proceedings, 2005.
+
+Yuankun Jiang, Chenglin Li, Wenrui Dai, Junni Zou, and Hongkai Xiong. Monotonic robust policy optimization with model discrepancy. In Proceedings of the 38th International Conference on Machine Learning, ICML 2021, 18-24 July 2021, Virtual Event, 2021.
+
+Niels Justesen, Ruben Rodriguez Torrado, Philip Bontrager, Ahmed Khalifa, Julian Togelius, and Sebastian Risi. Illuminating generalization in deep reinforcement learning through procedural level generation. arXiv preprint arXiv:1806.10729, 2018.
+
+Leslie Pack Kaelbling, Michael L. Littman, and Anthony R. Cassandra. Planning and acting in partially observable stochastic domains. Artif. Intell., 1998.
+
+Islam SM Khalil, JC Doyle, and K Glover. Robust and optimal control. prentice hall, new jersey, 1996.
+
+Ilya Kostrikov. Pytorch implementations of reinforcement learning algorithms. https://github.com/ ikostrikov/pytorch-a2c-ppo-acktr-gail, 2018.
+
+Kimin Lee, Kibok Lee, Jinwoo Shin, and Honglak Lee. Network randomization: A simple technique for generalization in deep reinforcement learning. In 8th International Conference on Learning Representations, ICLR 2020, Addis Ababa, Ethiopia, April 26-30, 2020, 2020.
+
+Michael Lederman Littman. Algorithms for sequential decision-making. Brown University, 1996.
+
+Xiao Ma, Peter Karkus, David Hsu, and Wee Sun Lee. Particle filter recurrent neural networks. In Proceedings of the AAAI Conference on Artificial Intelligence, volume 34, pp. 5101–5108, 2020a.
+
+Xiao Ma, Peter Karkus, David Hsu, Wee Sun Lee, and Nan Ye. Discriminative particle filter reinforcement learning for complex partial observations. arXiv preprint arXiv:2002.09884, 2020b.
+
+Lingheng Meng, Rob Gorbet, and Dana Kulic. Memory-based deep reinforcement learning for POMDP. arXiv preprint arXiv:2102.12344, 2021.
+
+Volodymyr Mnih, Adria Puigdom \` enech Badia, Mehdi Mirza, Alex Graves, Timothy P. Lillicrap, Tim Harley, \` David Silver, and Koray Kavukcuoglu. Asynchronous methods for deep reinforcement learning. In Proceedings of the 33nd International Conference on Machine Learning, ICML 2016, New York City, NY, USA, June 19-24, 2016, 2016.
+
+Jun Morimoto and Kenji Doya. Robust reinforcement learning. Neural computation, 17(2):335–359, 2005.
+
+Arnab Nilim and Laurent El Ghaoui. Robust control of markov decision processes with uncertain transition matrices. Oper. Res., 2005.
+
+Charles Packer, Katelyn Gao, Jernej Kos, Philipp Krahenb ¨ uhl, Vladlen Koltun, and Dawn Song. Assessing ¨ generalization in deep reinforcement learning. arXiv preprint arXiv:1810.12282, 2018.
+
+Christos H. Papadimitriou and John N. Tsitsiklis. The complexity of markov decision processes. Math. Oper. Res., 1987.
+
+Anay Pattanaik, Zhenyi Tang, Shuijing Liu, Gautham Bommannan, and Girish Chowdhary. Robust deep reinforcement learning with adversarial attacks. In Proceedings of the 17th International Conference on Autonomous Agents and MultiAgent Systems, AAMAS 2018, Stockholm, Sweden, July 10-15, 2018, 2018.
+
+Lerrel Pinto, James Davidson, Rahul Sukthankar, and Abhinav Gupta. Robust adversarial reinforcement learning. In Proceedings of the 34th International Conference on Machine Learning, ICML 2017, Sydney, NSW, Australia, 6-11 August 2017, 2017.
+
+Pascal Poupart and Craig Boutilier. Value-directed compression of pomdps. In Advances in Neural Information Processing Systems 15 [Neural Information Processing Systems, NIPS 2002, December 9-14, 2002, Vancouver, British Columbia, Canada], 2002.
+
+Martin L Puterman. Markov decision processes: discrete stochastic dynamic programming. John Wiley and Sons, 2014.
+
+Antonin Raffin. Rl baselines3 zoo. https://github.com/DLR-RM/rl-baselines3-zoo, 2020.
+
+Antonin Raffin, Jens Kober, and Freek Stulp. Smooth exploration for robotic reinforcement learning. In 5th Annual Conference on Robot Learning, 2021.
+
+Roberta Raileanu and Rob Fergus. Decoupling value and policy for generalization in reinforcement learning. In Proceedings of the 38th International Conference on Machine Learning, ICML 2021, 18-24 July 2021, Virtual Event, 2021.
+
+Aravind Rajeswaran, Sarvjeet Ghotra, Balaraman Ravindran, and Sergey Levine. Epopt: Learning robust neural network policies using model ensembles. In 5th International Conference on Learning Representations, ICLR 2017, Toulon, France, April 24-26, 2017, Conference Track Proceedings, 2017a.
+
+Aravind Rajeswaran, Kendall Lowrey, Emanuel Todorov, and Sham M. Kakade. Towards generalization and simplicity in continuous control. In Advances in Neural Information Processing Systems 30: Annual Conference on Neural Information Processing Systems 2017, December 4-9, 2017, Long Beach, CA, USA, 2017b.
+
+Kate Rakelly, Aurick Zhou, Chelsea Finn, Sergey Levine, and Deirdre Quillen. Efficient off-policy metareinforcement learning via probabilistic context variables. In Proceedings of the 36th International Conference on Machine Learning, ICML 2019, 9-15 June 2019, Long Beach, California, USA, 2019.
+
+Alessio Russo and Alexandre Proutiere. Towards optimal attacks on reinforcement learning policies. In \` 2021 American Control Conference, ACC 2021, New Orleans, LA, USA, May 25-28, 2021, 2021.
+
+Jurgen Schmidhuber. ¨ Evolutionary principles in self-referential learning, or on learning how to learn: the meta-meta-... hook. PhD thesis, Technische Universitat M¨ unchen, 1987. ¨
+
+Jurgen Schmidhuber. Reinforcement learning in markovian and non-markovian environments. In ¨ Advances in Neural Information Processing Systems 3, NIPS’3, pp. 500–506, 1991.
+
+John Schulman, Sergey Levine, Pieter Abbeel, Michael I. Jordan, and Philipp Moritz. Trust region policy optimization. In Proceedings of the 32nd International Conference on Machine Learning, ICML 2015, Lille, France, 6-11 July 2015, 2015.
+
+John Schulman, Filip Wolski, Prafulla Dhariwal, Alec Radford, and Oleg Klimov. Proximal policy optimization algorithms. arXiv preprint arXiv:1707.06347, 2017.
+
+Xingyou Song, Yiding Jiang, Stephen Tu, Yilun Du, and Behnam Neyshabur. Observational overfitting in reinforcement learning. In 8th International Conference on Learning Representations, ICLR 2020, Addis Ababa, Ethiopia, April 26-30, 2020, 2020.
+
+Mario Srouji, Jian Zhang, and Ruslan Salakhutdinov. Structured control nets for deep reinforcement learning. In Proceedings of the 35th International Conference on Machine Learning, ICML 2018, Stockholmsmassan, ¨ Stockholm, Sweden, July 10-15, 2018, 2018.
+
+Freek Stulp, Evangelos A. Theodorou, Jonas Buchli, and Stefan Schaal. Learning to grasp under uncertainty. In IEEE International Conference on Robotics and Automation, ICRA 2011, Shanghai, China, 9-13 May 2011, 2011.
+
+Hao Sun, Ziping Xu, Meng Fang, Zhenghao Peng, Jiadong Guo, Bo Dai, and Bolei Zhou. Safe exploration by solving early terminated mdp. arXiv preprint arXiv:2107.04200, 2021.
+
+Chen Tessler, Yonathan Efroni, and Shie Mannor. Action robust reinforcement learning and applications in continuous control. In Proceedings of the 36th International Conference on Machine Learning, ICML 2019, 9-15 June 2019, Long Beach, California, USA, 2019.
+
+Sebastian Thrun and Lorien Pratt. Learning to learn. Springer Science and Business Media, 2012.
+
+Josh Tobin, Rachel Fong, Alex Ray, Jonas Schneider, Wojciech Zaremba, and Pieter Abbeel. Domain randomization for transferring deep neural networks from simulation to the real world. In 2017 IEEE/RSJ International Conference on Intelligent Robots and Systems, IROS 2017, Vancouver, BC, Canada, September 24-28, 2017, 2017.
+
+Emanuel Todorov, Tom Erez, and Yuval Tassa. Mujoco: A physics engine for model-based control. In 2012 IEEE/RSJ International Conference on Intelligent Robots and Systems, IROS 2012, Vilamoura, Algarve, Portugal, October 7-12, 2012, 2012.
+
+Trieu Trinh, Andrew Dai, Thang Luong, and Quoc Le. Learning longer-term dependencies in rnns with auxiliary losses. In International Conference on Machine Learning, pp. 4965–4974. PMLR, 2018.
+
+Haonan Wang, Ning Liu, Yiyun Zhang, Dawei Feng, Feng Huang, Dong Sheng Li, and Yiming Zhang. Deep reinforcement learning: a survey. Frontiers Inf. Technol. Electron. Eng., 2020.
+
+Jane Wang, Zeb Kurth-Nelson, Hubert Soyer, Joel Z. Leibo, Dhruva Tirumala, Remi Munos, Charles Blundell, ´ Dharshan Kumaran, and Matt M. Botvinick. Learning to reinforcement learn. In Proceedings of the 39th Annual Meeting of the Cognitive Science Society, CogSci 2017, London, UK, 16-29 July 2017, 2017.
+
+Manuel Watter, Jost Tobias Springenberg, Joschka Boedecker, and Martin A. Riedmiller. Embed to control: A locally linear latent dynamics model for control from raw images. In Advances in Neural Information Processing Systems 28: Annual Conference on Neural Information Processing Systems 2015, December 7-12, 2015, Montreal, Quebec, Canada, 2015.
+
+Steven D Whitehead and Dana H Ballard. Active perception and reinforcement learning. In Machine Learning Proceedings 1990, pp. 179–188. Elsevier, 1990.
+
+Shimon Whiteson, Brian Tanner, Matthew E. Taylor, and Peter Stone. Protecting against evaluation overfitting in empirical reinforcement learning. In 2011 IEEE Symposium on Adaptive Dynamic Programming And Reinforcement Learning, ADPRL 2011, Paris, France, April 12-14, 2011, 2011.
+
+Daan Wierstra, Alexander Forster, Jan Peters, and J ¨ urgen Schmidhuber. Solving deep memory pomdps with ¨ recurrent policy gradients. In Artificial Neural Networks - ICANN 2007, 17th International Conference, Porto, Portugal, September 9-13, 2007, Proceedings, Part I, 2007.
+
+Aaron Wilson, Alan Fern, Soumya Ray, and Prasad Tadepalli. Multi-task reinforcement learning: a hierarchical bayesian approach. In Machine Learning, Proceedings of the Twenty-Fourth International Conference (ICML 2007), Corvallis, Oregon, USA, June 20-24, 2007, 2007.
+
+Zhihan Yang and Hai Nguyen. Recurrent off-policy baselines for memory-based continuous control. arXiv preprint arXiv:2110.12628, 2021.
+
+Tianhe Yu, Deirdre Quillen, Zhanpeng He, Ryan Julian, Karol Hausman, Chelsea Finn, and Sergey Levine. Meta-world: A benchmark and evaluation for multi-task and meta reinforcement learning. In 3rd Annual Conference on Robot Learning, CoRL 2019, Osaka, Japan, October 30 - November 1, 2019, Proceedings, 2019.
+
+Amy Zhang, Nicolas Ballas, and Joelle Pineau. A dissection of overfitting and generalization in continuous reinforcement learning. arXiv preprint arXiv:1806.07937, 2018a.
+
+Chiyuan Zhang, Oriol Vinyals, Remi Munos, and Samy Bengio. A study on overfitting in deep reinforcement ´ learning. arXiv preprint arXiv:1804.06893, 2018b.
+
+Huan Zhang, Hongge Chen, Chaowei Xiao, Bo Li, Mingyan Liu, Duane S. Boning, and Cho-Jui Hsieh. Robust deep reinforcement learning against adversarial perturbations on state observations. In Advances in Neural Information Processing Systems 33: Annual Conference on Neural Information Processing Systems 2020, NeurIPS 2020, December 6-12, 2020, virtual, 2020.
+
+Huan Zhang, Hongge Chen, Duane S. Boning, and Cho-Jui Hsieh. Robust reinforcement learning on state observations with learned optimal adversary. In 9th International Conference on Learning Representations, ICLR 2021, Virtual Event, Austria, May 3-7, 2021, 2021.
+
+Chenyang Zhao, Olivier Sigaud, Freek Stulp, and Timothy M. Hospedales. Investigating generalisation in continuous deep reinforcement learning. arXiv preprint arXiv:1902.07015, 2019.
+
+Yuke Zhu, Roozbeh Mottaghi, Eric Kolve, Joseph J. Lim, Abhinav Gupta, Li Fei-Fei, and Ali Farhadi. Targetdriven visual navigation in indoor scenes using deep reinforcement learning. In 2017 IEEE International Conference on Robotics and Automation, ICRA 2017, Singapore, Singapore, May 29 - June 3, 2017, 2017.
+
+Brian D Ziebart. Modeling purposeful adaptive behavior with the principle of maximum causal entropy. Carnegie Mellon University, 2010.
+
+Luisa M. Zintgraf, Kyriacos Shiarlis, Maximilian Igl, Sebastian Schulze, Yarin Gal, Katja Hofmann, and Shimon Whiteson. Varibad: A very good method for bayes-adaptive deep RL via meta-learning. In 8th International Conference on Learning Representations, ICLR 2020, Addis Ababa, Ethiopia, April 26-30, 2020, 2020.
+
+# A CODE-LEVEL DETAILS
+
+In this section, we first introduce the outline of code design, especially the replay buffer for sequences, and then compare the system usage, including computing speed, RAM, and GPU memory with previous POMDP methods.
+
+# A.1 CODE DESIGN
+
+Easy to use. Our code can be either used as an API to call the recurrent model-free RL class or a framework to tune the details in the class. The recurrent model-free RL class takes the hyperparameters of RNN encoder type, shared or separate actor-critic architecture, and whether include previous observations, and/or actions, and/or rewards into the inputs, to generate different instances. The details of the hyperparameter tuning set are shown in Sec. A.3.
+
+Memory-efficient replay buffer for sequences. Moreover, we design an efficient replay buffer for off-policy RL methods to cope with sequential inputs. Previous methods (Han et al., 2020; Yang & Nguyen, 2021) mainly use three-dimensional replay buffer to store sequential inputs, with the dimensions of (num episodes, max episode length, observation dimension), taking observation storage as example. This kind of implementation becomes memory-inefficient if the actual episode length is far smaller than the max episode length (then there will be many padded zeros (Dorfman et al., 2020)). Instead, we manage to implement a two-dimensional replay buffer of shape (num transitions, observation dimension) for observation storage, which also records the locations where each stored episode ends. In case of actual episodes that are shorter than provided sampled sequence length, the buffer also generates on-the-fly masks to indicate if the corresponding transitions are valid, so that we do not need to save zero-padded observations in the buffer. This enables the policy to receive a batch of previous experiences in a tensor-like data structure when sampling from the replay buffer. To sum up, our replay buffer can support varying-length sequence inputs and subsequence sampling without zero padding.
+
+Flexible training speed. Finally, our code supports flexible training speed by controlling the ratio of the numbers of gradient updates in RL w.r.t. the environment rollout steps. The training speed is approximately proportional to the ratio if the simulator speed is much faster than the policy gradient update. Typically, the ratio is less than or equal to 1.0 to enjoy higher training speed.
+
+# A.2 SYSTEM USAGE
+
+Table 4 shows the typical system usage of our method and the compared specialized methods on different environments. The time cost for our method and VariBAD depends on how many processes in parallel are run on a single GPU – our method is run with 8 processes on a single GPU while VariBAD is run with one process due to large GPU memory usage. From the results we can see that our method is memory-efficient in both RAM and GPU, and has an acceptable training speed with default hyperparameters. The computer system we used during the experiments includes a GeForce RTX 2080 Ti Graphic Card (with 11GB memory) and Intel(R) Xeon(R) Gold 6148 CPU $@$ 2.40GHz (with 250GB RAM and 80 cores).
+
+Table 4: Comparison between our method and specialized methods in system usage. The time costs are evaluated within 1M environment steps. Both VRM and MRPO are run on CPUs and MRPO does not have a replay buffer (shown in N/A). VariBAD requires the assumption of fixed episode length for the RAM cost.   
+
+<table><tr><td>Method</td><td>Environment</td><td>Time cost</td><td>RAM</td><td>GPU memory</td></tr><tr><td>Ours (GRU)</td><td>Hopper-V</td><td>22.5 h</td><td>0(1)</td><td>1.2 GB</td></tr><tr><td>VRM (Han et al., 2020)</td><td>Hopper-V</td><td>102 h</td><td>0(200)</td><td>N/A</td></tr><tr><td>Ours</td><td>Semi-Circle</td><td>12h</td><td>0(1)</td><td>1 GB</td></tr><tr><td>VariBAD (Dorfman et al., 2020)</td><td>Semi-Circle</td><td>2.3 h</td><td>0(1)*</td><td>9.5 GB</td></tr><tr><td>Ours</td><td>Cheetah-Robust</td><td>7h</td><td>0(1)</td><td>1.1 GB</td></tr><tr><td>MRPO (Jiang et al., 2021)</td><td>Cheetah-Robust</td><td>0.4 h</td><td>N/A</td><td>N/A</td></tr></table>
+
+# A.3 OUR HYPERPARAMETER TUNING SET
+
+Our proposed method has the following decision factors (introduced in Sec. 4) to tune in the experiments with the following options (the names in brackets are abbreviated ones):
+
+• Actor-Critic architecture (Arch): share the encoder weights between the recurrent actor and recurrent critic or not, namely shared and separate.   
+• Model-free RL algorithms (RL): td3 (Fujimoto et al., 2018) or sac (Haarnoja et al., 2018a)   
+• Encoder architecture (Encoder): lstm (Hochreiter & Schmidhuber, 1997) or gru (Cho et al., 2014)   
+• Policy input space (Inputs): o, oa, or, oar, oard (the notation is introduced in Sec. 4; depending on the POMDPs, see “Policy input” row in Table 5)   
+• Context length (Len): short (5), medium (64), long (larger than 100, depending on the POMDPs).
+
+For each instance, we label it with the names of all the hyperparameters it used in lowercase as notation. For example, td3-lstm-64-or-separate in Fig. 5 refers to the instance that uses the separate actor-critic architecture, TD3 RL algorithm, LSTM encoder, the policy input space of previous observations and reward sequences, and RNN context length of 64.
+
+# B TRAINING DETAILS
+
+![](images/bdf52f41abe2592c14a688161716770e854e2501df874d95c4b850a55ebaab8e.jpg)  
+Figure 6: The network architecture of our implementation on recurrent model-free RL. The left part shows the actor network, and the right shows the critic network. Each block shows a trainable module, with independent weights. We italicize the previous action and reward encoders as they are optional. By default, each encoder has one hidden layer, each RNN is one-layer LSTM or GRU, each MLP has two hidden layers.
+
+Fig. 6 shows our (separate) recurrent actor-critic architecture. Table 5 shows the main hyperparameters we adopt for each subarea. We did not tune these hyperparameters, except that we adjusted the number of gradient steps so that all the experiments could be completed in 36 hours.
+
+For Markovian policies (SAC and TD3), we remove the encoders and RNNs from the actor-critic architecture, and train them with same hyperparameters as those of recurrent policies. For each task, we report the results of either SAC or TD3, whichever achieves higher returns. For Oracle policies, we use the well-tuned results from Table 1 (“SAC w/ unstructured row”) in Raffin et al. (2021), which is based on Stable Baseline3 (Raffin, 2020), for “standard” POMDPs. For the other subareas, we have to run the Markovian policies (SAC and TD3) with access to the hidden states, using the same training hyperparameters as those of recurrent policies. But these Oracle policies might be not well-tuned given same environment and gradient steps, especially in robust RL and generalization in RL.
+
+We also show the settings of the specialized methods we compared in the main paper in Table 6. Note that our recurrent model-free RL share the exactly same settings as (off-policy) VariBAD (Dorfman et al., 2020) and VRM (Han et al., 2020). For MRPO (Jiang et al., 2021) and EPOPT (Rajeswaran et al., 2017a), they adopt totally different settings, i.e. on-policy Markovian approaches to MDPs (with access to the ground-truth state (s) of environment). Thus, in fact, MRPO and EPOPT should be more viewed as oracle policies as upper bounds of recurrent model-free RL.
+
+Table 5: Hyperparameter summary in our implementation of model-free recurrent RL. For each subarea, we report the hidden layer size of each module, RL and training hyperparameters. For Meta-RL, we take the model on Cheetah-Vel as example, which follows the architecture design of off-policy VariBAD (Dorfman et al., 2020). The hidden size of observation-action encoder is the sum of that of observation encoder, previous action encoder (if exists), and reward encoder (if exists).   
+
+<table><tr><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>Meta-RL*    POMDP  Robust RL  Gen. in RL</td></tr><tr><td rowspan=1 colspan=1>Hiddenlayersize</td><td rowspan=1 colspan=1>Observ.encoderPrev. Action encoder*Reward encoder*RNNMLP</td><td rowspan=1 colspan=1>[32][16][16][128][128,128,128]                [256,256]</td></tr><tr><td rowspan=1 colspan=1>RLhparams</td><td rowspan=1 colspan=1>Learning rateDiscount factor ySmoothing coef T SAC temperatureTD3 noisesReplay buffer sizeBatch size</td><td rowspan=1 colspan=1>3e-40.990.005 automatically updated by Haarnoja et al. (2018b)default values from Fujimoto et al. (2018)1e632                           64</td></tr><tr><td rowspan=1 colspan=1>Traininghparams</td><td rowspan=1 colspan=1>Environment stepsGradient steps</td><td rowspan=1 colspan=1>5M         1.5M               3M0.1M        1.5M              0.6M</td></tr><tr><td rowspan=1 colspan=1>Policyinputs</td><td rowspan=1 colspan=1>Largest input spaceBest input space</td><td rowspan=1 colspan=1>oard         oar         oa          oaroard         oa          0            0</td></tr></table>
+
+Table 6: Settings of the specialized methods we compared in the main paper. For Meta-RL, we take the model on Cheetah-Vel as example.   
+
+<table><tr><td></td><td>Meta-RL*</td><td>POMDP</td><td>RobustRL</td><td>Gen. in RL</td></tr><tr><td>Approach</td><td>(off-policy) VariBAD</td><td>VRM</td><td>MRPO</td><td>EPOPT</td></tr><tr><td>Memory-based?</td><td>√</td><td>√</td><td>X</td><td>X</td></tr><tr><td>Off-policy?</td><td>√</td><td>√</td><td>X</td><td>X</td></tr><tr><td>Input space</td><td>oard</td><td>oar</td><td>S</td><td>S</td></tr><tr><td>Access to hidden states?</td><td>X</td><td>X</td><td>√</td><td>√</td></tr></table>
+
+# C EVALUATION DETAILS
+
+The bar charts in Fig. 1 and 18 and Table 3 adopt the final performance of each method. We run each instance/variant in our method and each compared method with 4 random seeds. The final performance is calculated by the average performance of the last $20 \%$ environment steps across the 4 seeds.
+
+In terms of selecting the best variant in our method for each subarea, we first compute the final performance of each variant, then normalize the final performance into $[ 0 , 1 ]$ , and finally select the best variant in the average of the normalized final performance across all the environments in each subarea.
+
+For the bar charts in Fig. 1 and 18, we show the normalized returns of each method, calculated by R−RminR −R ∈ [0, 1], where R is the raw average return of that method and Rmax and Rmin are the maximum and minimum of all the methods including Oracle policy and Random policy.
+
+# D ENVIRONMENT DETAILS
+
+# D.1 “STANDARD” POMDP
+
+Except for the classic Pendulum environment, we use PyBullet (Coumans & Bai, 2016) as the simulator for “standard” POMDP environments. As the practice in VRM (Han et al., 2020), we remove all the position/angle-related entries in the observation space for “-V” environments and velocityrelated entries for “-P” environments, to transform the original MDP into POMDP.
+
+{Pendulum,Ant,Cheetah,Hopper,Walker}-P. The “-P” stands for the environments that keep position-related entries by removal of velocity-related entries. Thus, the observed state $s ^ { o }$ includes positions $p$ , while the hidden state $s ^ { h }$ is the velocities $v$ .
+
+{Pendulum,Ant,Cheetah,Hopper,Walker}-V. The “-V” stands for the environments that keep velocity-related entries by removal of position-related entries. Thus, the observed state $s ^ { o }$ includes positions $v$ , while the hidden state $s ^ { h }$ is the velocities $p$ .
+
+# D.2 META RL
+
+Semi-Circle. We directly follow off-policy version of VariBAD (Dorfman et al., 2020). The observed state $s ^ { o }$ includes the agent’s 2D position $p$ , and the hidden state $s ^ { h }$ is referred to the goal state $p _ { g }$ . The goal state only appears in reward function: $R ( s _ { t } ^ { o } , s _ { t + 1 } ^ { o } , a _ { t } , s ^ { h } ) \equiv R ( p _ { t + 1 } , p _ { g } { \bar { ) } } =$ $\mathbb { 1 } ( \lVert p _ { t + 1 } - p _ { g } \rVert _ { 2 } \leq r )$ . The dynamic function $T$ is independent of the goal state.
+
+Cheetah-Vel. We directly follow Dorfman et al. (2020) using MuJoCo (Todorov et al., 2012) simulator of HalfCheetah-v2. The hidden state $s ^ { h }$ is the target velocity $v _ { g }$ and observed state $s ^ { o }$ includes the velocity $v$ . Reward function includes both the hidden state and action: $R ( s _ { t } ^ { o } , s _ { t + 1 } ^ { o } , a _ { t } , s ^ { h } ) \equiv R ( v _ { t } , v _ { g } , a _ { t } ) = - \| v _ { t } - v _ { g } \| _ { 1 } - 0 . 0 5 \| a _ { t } \| _ { 2 }$ . The dynamic function $T$ is independent of the goal state.
+
+Wind. We modified the parameters of Wind environment in Dorfman et al. (2020) to make it harder to solve. The agent must navigate to a fixed (but unknown) goal $p _ { g }$ within a distance of $D = 1$ from its fixed initial state. Similarly to Semi-Circle, the reward function is goal conditioned but without hidden state: $R ( s _ { t } ^ { o } , s _ { t + 1 } ^ { o } , a _ { t } , \bar { s ^ { h } } ) \equiv R ( p _ { t + 1 } , p _ { g } ) = \mathbb { 1 } ( \| p _ { t + 1 } - p _ { g } \| _ { 2 } \bar { \leq ^ { } { r } } )$ . The hidden state $s ^ { h }$ appear in the deterministic dynamics as a noise term, i.e. $s _ { t + 1 } ^ { o } = s _ { t } ^ { o } + a _ { t } + s ^ { h }$ , where $s ^ { h }$ is sampled from $U [ - 0 . 0 8 , 0 . 0 8 ]$ at the initial time-step and then kept fixed.
+
+# D.3 ROBUST RL
+
+{Hopper,Walker,Cheetah}-Robust. We directly adopt the environments used in MRPO (Jiang et al., 2021). In each environment, the hidden state is the dynamics parameters including the density and friction coefficients of the simulated robot in roboschool, adapted from the SunBlaze (Packer et al., 2018). The exact ranges of the hidden states in each environment can be found in Table 1 of MRPO (Jiang et al., 2021). We evaluate the algorithms with 100 tasks in each environment, and use the average of them as average returns, and the average of the worst $1 0 \%$ of them as worst returns, following MRPO paper.
+
+# D.4 GENERALIZATION IN RL
+
+{Hopper,Cheetah}-Generalize. We directly adopt the environments used in SunBlaze (Packer et al., 2018). In each environment, the hidden state is the dynamics parameters including the density, friction coefficients, and the power of the simulated robot in roboschool. The exact ranges of both interpolation and extrapolation in the hidden state distribution for each environment can be found in Table 1 of SunBlaze (Packer et al., 2018). We follow the practice of SunBlaze to evaluate interpolation and extrapolation success rates.
+
+# E FULL EXPERIMENTAL RESULTS
+
+# E.1 LEARNING CURVES OF ALL THE COMPARED METHODS
+
+In this subsection, we show all the learning curves of all the compared methods (including Oracle policy as upper bound, Markovian and Random policies as lower bounds) in each subarea, namely “Standard” POMDPs (Fig. 7 and Fig. 8), meta RL (Fig. 9), robust RL (Fig. 10), and generalization in RL (Fig. 11). The final performance of these learning curves generate the bar charts in Sec. 5.1.
+
+![](images/85ccefe946b801cd15f2e89cf6c81a75ab616a8ab9469593b794c32433d306e9.jpg)  
+Figure 7: Learning curves on “standard” POMDP environments that preserve positions & angles but occlude velocities in the states in PyBullet (Coumans & Bai, 2016) (namely “-P”). We show the results from the single best variant of our implementation on recurrent model-free RL, the popular recurrent model-free on-policy implementation (PPO-GRU, A2C-GRU) (Kostrikov, 2018), and also model-based method VRM (Han et al., 2020). Note that VRM is around ${ 5 } \mathbf { x }$ slower than ours, so we have to run 0.5M environment steps for it.
+
+# E.2 SINGLE FACTOR ANALYSIS ON OUR METHOD
+
+Our analysis will focus on ablating the important design decisions: the actor-critic architecture (Arch), the policy input space (Inputs), the underlying model-free RL algorithm (RL), the RNN encoder (Encoder), and the RNN context length (Len). As there are several decision variables in our method, we could only show the results of each variable in the plots by averaging the performance over the other variables, which we call single factor analysis. In this kind of analysis, we can only say one value is better than another in one factor in the average sense (not the maximal sense); therefore it can show the robustness of each factor, but cannot tell the best choices (showed in Sec. 5.1). We show single factor analysis plots in each subarea, namely “Standard” POMDPs (Fig. 12 and Fig. 13), meta RL (Fig. 14), robust RL (Fig. 15), and generalization in RL (Fig. 16).
+
+From these plots, we can see that each decision factor can make a difference in some environments. For example, the choice of RL algorithm is crucial in Ant-P (Fig. 12), Cheetah-V (Fig. 13), Wind (Fig. 14) and Hopper-Generalize (Fig. 16). The context length is essential in all the “-P” environments (Fig. 12), Cheetah-Vel (Fig. 14), and both the generalization environments (Fig. 16). The policy input space can make a difference in most “-P” environments (Fig. 12) possibly because oar contains the information of missing velocities.
+
+![](images/9b9ca379534e68d909afc28de5d21154b0d5cd869969737e00fe2763f6376029.jpg)  
+Figure 8: Learning curves on “standard” POMDP environments that preserve velocities but occlude positions $\pmb { \& }$ angles in the states in PyBullet (Coumans & Bai, 2016) (namely “-V”). We show the results from the single best variant of our implementation on recurrent model-free RL, the popular recurrent model-free on-policy implementation (PPO-GRU, A2C-GRU) (Kostrikov, 2018), and also model-based method VRM (Han et al., 2020). Note that VRM is around ${ 5 } \mathrm { x }$ slower than ours, so we have to run 0.5M environment steps for it.
+
+# E.3 ADDITIONAL RESULTS ON SEPARATE VS SHARED RECURRENT ACTOR-CRITICARCHITECTURE
+
+In Fig. 5 of Sec. 5.2, we show the importance of selecting a separate recurrent actor-critic architecture in a meta RL environment, Semi-Circle. Now we show the result in another POMDP environment, Pendulum-V, which occludes the positions and angles, in Fig. 17. We can see that the shared encoder architecture is also worse than the separate one, possibly due to the different gradient scales in actor and critic losses w.r.t. the encoder.
+
+# E.4 ADDITIONAL RESULTS ON COMPARISON WITH VRM
+
+Both Fig. 1 and Fig. 18 shows the final performance of the same single variant of our implementation, but the former shows our results with 1.5M simulation steps while the latter shows our results with $0 . 5 \mathbf { M }$ simulation steps to match with those of VRM due to the time budget.
+
+![](images/3894fdfca46be8394637e0e88be03a60d4ad34c6d20b7fdc0897c0d605dcfe11.jpg)  
+Figure 9: Learning curves on meta RL environments. We show the results from the single best variant of our implementation on recurrent model-free RL, the specialized meta RL method VariBAD (Dorfman et al., 2020)
+
+![](images/dfa7dc791a89631fd6f6bc1cdf6f0871db3745292eea57b55d353289f7d243a6.jpg)  
+Figure 10: Learning curves on robust RL environments. We show the average returns (left figures) and worst returns (right figures) from the single best variant of our implementation on recurrent model-free RL, the specialized robust RL method MRPO (Jiang et al., 2021). Note that our method is much slower than MRPO, so we have to run our method within 3M environment steps. But the results show that our method have much better sample efficiency over MRPO.
+
+![](images/66064063e5800389fd2dbd583070929708fb7b1e199ff2798820509b4e39ad54.jpg)  
+Figure 11: Learning curves on generalization in RL environments. We show the interpolation success rates (left figures) and extrapolation success rates (right figures) from the single best variant of our implementation on recurrent model-free RL. We also show the final performance of the specialized method EPOpt-PPO-FF (Rajeswaran et al., 2017a) and another recurrent model-free (on-policy) RL method (A2C-RC) copied from the Table 7 & 8 in Packer et al. (2018).
+
+![](images/d9a540b849cdaba473400f6d2b726dee14f5c2a4d5c468fa53d01c31cd5000fa.jpg)  
+Figure 12: Ablation study of our implementation on “standard” POMDP environments that preserve positions $\pmb { \& }$ angles but occlude velocities in the states in pybullet (Coumans & Bai, 2016) (namely $\mathbf { \tilde { \Sigma } ^ { 6 6 } - } \mathbf { P } ^ { 9 } \mathbf { \bar { \Sigma } } ,$ ). We show the single factor analysis on the 4 decision factors including RL, Encoder, Len, and Inputs for each environment.
+
+![](images/32445265e20f1f545fd08fe0230bf577d359a0980e43099b5bce76317dc9ecf4.jpg)  
+Figure 13: Ablation study of our implementation on “standard” POMDP environments that preserve velocities but occlude positions & angles in the states in pybullet (Coumans & Bai, 2016) (namely “-V”). We show the single factor analysis on the 4 decision factors including RL, Encoder, Len, and Inputs for each environment.
+
+![](images/26813d40fd770010f14b184f9791b978c08ed29426a0c77c554d40a4d575ad91.jpg)  
+Figure 14: Ablation study of our implementation on meta RL environments. We show the single factor analysis on covering all the decision factors
+
+![](images/af848a7b1bd8022f0a5a01bf2cddbe2366af14d2091951fb72fcae8b645a9a7b.jpg)  
+Figure 15: Ablation study of our implementation on robust RL environments. We show the single factor analysis on the 4 decision factors including RL, Encoder, Len, and Inputs for each environment in both average returns and worst returns.
+
+![](images/fc734dbfd8668706406e93d90ff0fd4650c5d5adff372b1c88b6ff670ae61a5a.jpg)  
+Figure 16: Ablation study of our implementation on generalization in RL environments. We show the single factor analysis on the 3 decision factors including RL, Len, and Inputs for each environment in both interpolation and extraploation success rates.
+
+![](images/5ff5f0fcb3a9f61051dd00d39ed12967134c54b38301ce44e33adf4838a9fa2f.jpg)  
+Figure 17: Comparison between shared and separate recurrent actor-critic architecture with all the other hyperparameters same, on Pendulum-V, a toy “standard” POMDP environment. We show the performance metric (left) and also the gradient norm of the RNN encoder(s) (right, in log-scale). For the separate architecture, :critic and :actor refer to the separate RNN in critic and actor networks, respectively.
+
+![](images/87a809e96598bc16313fea09489dbdb6bb785477299c66ee97a72274e50173bc.jpg)  
+Figure 18: Final normalized returns of our implemented recurrent model-free RL algorithm with the same hyperparameters, and the prior method VRM (Han et al., 2020) across the eight environments in “standard” POMDPs, each of which trained in 0.5M simulation steps.
+
+# F ABLATION STUDY ON RNN ARCHITECTURES
+
+Our implementation of recurrent model-free RL uses the popular 1-layer LSTM or GRU. To investigate the effect of RNN architecture, we ablate two RNN variants: one is 2-layer stacked LSTM/GRU, the other is Particle-Filter RNN (PF-RNN (Ma et al., 2020a)). PF-RNN maintains a stochastic belief (posterior distribution) through a set of weighted particles to better capture the uncertainty and multi-modality, compared to classic RNN’s deterministic belief. DPFRL (Ma et al., 2020b) applies PF-GRU to POMDP tasks, using the mean of particles and MGF features of particles as the belief state. We follow the implementation of PF-GRU in DPFRL (Ma et al., 2020b) to replace regular GRU, keeping the other model components the same.
+
+We try 2-layer LSTM/GRU, on our best variant across all the environments. We run PF-GRU on “standard” POMDP environments where the best variant also uses GRU for fair comparison, and do not try PF-LSTM as it is not adopted in DPFRL (Ma et al., 2020b).
+
+Since 2-layer LSTM/GRU doubles the training time of 1-layer LSTM/GRU given the same gradient updating frequency, we have to decrease the frequency from 1.0 to 0.6 in “standard” POMDPs. Similarly, PF-GRU costs $1 5 \times$ than 1-layer GRU, so we also have to decrease the frequency from 1.0 to 0.6. All the other hyperparameters remain the same.
+
+![](images/75896b02d02693733e2773334d33463d9735c1ded84e90b3d11b64954c25f30b.jpg)  
+Figs. 19 to 23 show all the learning curves of the ablation study on RNN architectures. Except for rare cases (e.g. Ant-P, Walker-V), the RNN variants perform worse than or are par with 1-layer LSTM/GRU, although in most cases the RNN variants can still outperform the Markovian policies. Possible reasons are that the RNN variants need hyperparameter tuning and more training samples to converge.   
+Figure 19: Ablation study on RNN architecture in “standard” POMDPs (“-P”). We show two models that are only different from our best single variant in the RNN architectures, namely using 2-layer stacked GRU (td3-2gru) and PF-GRU (Ma et al., 2020a;b) (td3-pfgru), instead of 1-layer GRU.
+
+![](images/058c7ea47e1c159b6fe098fd66aa4e39e8383fe8a07e5ec40a45895b54c4ebb4.jpg)  
+Figure 20: Ablation study on RNN architecture in “standard” POMDPs (“-V”). We show two models that are only different from our best single variant in the RNN architectures, namely using 2-layer stacked GRU (td3-2gru) and PF-GRU (Ma et al., 2020a;b) (td3-pfgru), instead of 1-layer GRU.
+
+![](images/1d04cd47f46e4193da7f651143562f09f9344d1245c759d8448902ccfb028f35.jpg)  
+Figure 21: Ablation study on RNN architecture in Meta RL. We show one model that are only different from our best single variant in the RNN architecture, namely using 2-layer stacked LSTM (td3-2lstm), instead of 1-layer LSTM.
+
+![](images/764e5249b62d350489348f58de8742e57e05989fadfe593ce37c71ee8c06e097.jpg)  
+Figure 22: Ablation study on RNN architecture in robust RL. We show one model that are only different from our best single variant in the RNN architecture, namely using 2-layer stacked LSTM (td3-2lstm), instead of 1-layer LSTM.
+
+![](images/eb61e0519c56998e2edeb2bb48ea3ac6587ada65032b50129bb78d91c80618ee.jpg)  
+Figure 23: Ablation study on RNN architecture in generalization in RL. We show one model that are only different from our best single variant in the RNN architecture, namely using 2-layer stacked LSTM (td3-2lstm), instead of 1-layer LSTM.
+
+# G ADDITIONAL RESULTS ON COMPARISON WITH OFF-POLICY VARIBAD
+
+In our experiment section (Sec. 5) and Fig. 9, we show the learning curves of our method and our re-implemented off-policy VariBAD (Dorfman et al., 2020). To rule out the possibility of reimplementation bugs in the off-policy VariBAD, we ran the official off-policy VariBAD implementation2, denoted as VariBAD-BOReL.
+
+In Fig. 24, we show official off-policy VariBAD (VariBAD-BOReL in short), our re-implemented off-policy VariBAD (VariBAD in short), and one variant of our recurrent model-free RL, which uses the same decision factors as VariBAD-BOReL (SAC as RL algorithm, GRU as encoder, oar as input, 400 as context length) for fair comparison. We also try Ant-Dir from Dorfman et al. (2020) paper, a more challenging meta RL environment than Cheetah-Vel.
+
+In Semi-Circle and Wind, VariBAD-BOReL has similar performance as our re-implemented version (VariBAD).
+
+In Cheetah-Vel, we find VariBAD-BOReL outperforms our re-implemented version, but still has a gap from what they reported in Fig. 11 in the appendix of Dorfman et al. (2020). Our implementation still outperforms VariBAD-BOReL, supporting our claim in the main paper.
+
+Finally, in the newly added and more challenging Ant-Dir, we found our recurrent model-free RL can even greatly surpass Oracle (trained with same environment and gradient steps), while VariBADBOReL somehow has extremely low performance (worse than Random) and suffers from numerical issue to terminate early.
+
+![](images/2bee8e27956779c2058d9477678f8a6064ff9f8f6cd810dfb28714dc2934413c.jpg)  
+Figure 24: Additional learning curves on meta RL environments. We show the results from the single variant of our implementation on recurrent model-free RL (sac-gru-oar-400), and the specialized meta RL method off-policy VariBAD (Dorfman et al., 2020) (their official implementation VariBAD-BOReL and our re-implementation VariBAD).

parse/dev/QNBzcgY0f4e/QNBzcgY0f4e_content_list.json

@@ -0,0 +1,1469 @@
+[
+    {
+        "type": "text",
+        "text": "Easy incremental learning methods to consider for commercial fine-tuning applications ",
+        "text_level": 1,
+        "bbox": [
+            194,
+            122,
+            803,
+            172
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Anonymous Author(s)   \nAffiliation   \nAddress   \nemail ",
+        "bbox": [
+            423,
+            226,
+            580,
+            281
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Abstract ",
+        "text_level": 1,
+        "bbox": [
+            462,
+            318,
+            535,
+            334
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Fine-tuning deep learning models for commercial use cases is growing exponentially as more and more companies are adopting AI to enhance their core products and services, as well as automate their diurnal processes and activities. However, not many countries like the U.S. and those in Europe follow quality data collection methods for AI vision or NLP related automation applications. Thus, on many of these kinds of data, existing state-of-the-art pre-trained deep learning models fail to perform accurately, and when fine-tuning is done on these models, issues like catastrophic forgetting or being less specific in predictions as expected occur. Hence, in this paper, simplified incremental learning methods are introduced to be considered in existing fine-tuning infrastructures of pre-trained models (such as those available in huggingface.com) to help mitigate the aforementioned issues for commercial applications. The methods introduced are: 1) Fisher Shut-off, 2) Fractional Data Retention and 3) Border Control. Results show that when applying these methods on vanilla pre-trained models, the models are in fact able to add more to their knowledge without hurting much on what they had learned previously. ",
+        "bbox": [
+            148,
+            348,
+            766,
+            556
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "16 1 Introduction ",
+        "text_level": 1,
+        "bbox": [
+            148,
+            580,
+            312,
+            598
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "17 Many companies and organizations today are adopting AI in automation, automating their daily   \n18 processes and activities, as well as offering them in their core products and services. Automation   \n19 has traditionally been in the industry for many years, as a means for which economics of scale could   \n20 be acheived so as to remain competitive in the market. Now with AI, more and more intelligence is   \n21 being brought into automation, and in countries like India, organizations are beginning to adopt AI   \n22 for this particular purpose.   \n23 With recent advancements in AI vision and NLP models such as the GPT-3, Jurassic-1, and so on,   \n24 organizations today are using AI for 1) Document Reading and Understanding, 2) Online Proctoring,   \n25 3) Chatbots, 4) Intelligent Information Parsing and other application related process automations.   \n26 Given these use cases, AI solutions need to be specific to their processes, but yet be an addition to   \n27 their generally known formats. This in a sense, is more like making use of a human employee who   \n28 has some kind of general education on various tasks or processes but still is required to learn the   \n29 companies counterparts well and in detail before he/she is allowed to execute them. These processes   \n30 can include between, reading customer emails for entering relevant information about their product   \n31 requirements onto a structured database, to understanding various types of printed documents for   \n32 information parsing, and to identifying newer objects for either document filtering or malicious   \n33 activity detection.   \n34 For natural language related tasks, powerful models like the GPT-3 are now being widely used, but   \n35 they require good prompt engineering skills to get the best out of them. Also, given that they are   \n36 probabilistic models, the generated outputs can sometimes falter away from what is expected, and   \n37 this can become a problem when selling it to customers, because even the slightest faltering may not   \n38 be acceptable to them at all. Hence, to reduce this, more and more examples have to be provided in   \n39 the prompt, and this can come at a high cost not suitable for low cost of living countries like India.   \n40 The other workaround is to fine-tune the model on the new datasets, but this has epoch limitations   \n41 on how deeply it can fit on the new dataset without hurting the body of general knowledge it gained   \n42 earlier. Also, fine-tuning models like the GPT-3 comes at a very high cost now-a-days, and is no   \n43 more an option. This leaves the automation builders to use huggingface.com transformers instead.   \n44 In vision, although state-of-the-art pre-trained deep learning models are able to achieve human level   \n45 performance on a variety of inputs, they can only perform so in upto close to high quality inputs. If   \n46 the quality goes lower, they fail terribly. Not all organizations have a good quality data collection   \n47 process involved for applying automation, and this is ubiquitously the case in many parts of the world.   \n48 So it becomes quite difficult to sell AI as a human-level performer, and at this point AI becomes of   \n49 lesser use than it could potentially be.   \n50 Another approach typically used to resolve such problems is to employ transfer learning, which   \n51 typically involves replacing the last layers of the model with a new model to get the specific outputs   \n52 required. Some examples done in research are Too, et al. (2019), Dif & Elberrichi (2020), Alshalali   \n53 & Joysula (2018), Jung, et al. (2015), Qian, et al. (2021) and Vrbanciˇ c & Podgorelec (2020). While ˇ   \n54 this may not seem to be a problem with vision based tasks, it is definitely a problem with natural   \n55 language based tasks. This is because the final layers of the natural language models have all the vital   \n56 information of language structure that help with the language generative process. When this is to   \n57 be changed, catastrophic forgetting can happen. Catastrophic forgetting is a phenomenon in which   \n58 previously learned knowledge is lost partly by the application of new data for training. Also, with   \n59 vision based tasks, when the requirement is to just improve the performance on lower quality data,   \n60 transfer learning may not be the appropriate approach. Fine-tuning for these must involve the final   \n61 layers of the model which could inevitably lead to catastrophic forgetting on the higher quality inputs.   \n62 This brings the only solution towards incremental learning. This type of learning is all about   \n63 learning on newer datasets without having the side-effects catastrophic forgetting, and there has been   \n64 substantial amount of research done in this area. Luo, et al. (2020) summarizes all the work that has   \n65 happened in this area so far. There are several approaches to implementing incremental learning on   \n66 pre-trained models, some of which will be discussed in the forthcoming sections. In this paper, a   \n67 few of these approaches will be simplified for commercial applications along with novel intuitive   \n68 additions to further help the learning process. The paper introduces: 1) Fisher Shut-off which is a   \n69 simplification of the work done by Kirkpatrick, et al. (2017), 2) Fractional Data Retention which   \n70 adopts ideas from Castro, et al. (2018), and 3) Border Control which is an extension to the idea   \n71 outlined by Ren, et al. (2018) on reweighting examples by employing a method similar to Adaboost.   \n72 The last one is the novel addition as it formulates a different approach to retaining salient examples   \n73 for incremental learning. It is based on the work by Ruping (2001) on incremental learning with   \n74 SVMs. But since SVMs are too complex in the context on neural networks, a similar but simplified   \n75 approach is proposed.   \n76 The purpose of this work is to initiate the development of a new infrastructure for commercial   \n77 fine-tuning of pre-trained models with simplified incremental learning methods.   \n78 The rest of this paper proceeds as follows: Section 2 will provide a brief discussion on incremental   \n79 learning methods developed so far, followed by the proposal of simplified incremental learning   \n80 methods in Section 3. Section 4 will show sample results of the proposed methods on a vanilla   \n81 pre-trained model using a toy dataset. A toy dataset is used for the only purpose of providing   \n82 visualizations on the performance of the proposed methods. Nevertheless, these methods can be   \n83 extended on to real world datasets. The paper then concludes in Section 5 discussing steps forward   \n84 for implementation. ",
+        "bbox": [
+            147,
+            612,
+            825,
+            694
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            147,
+            702,
+            825,
+            853
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            148,
+            859,
+            823,
+            901
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            147,
+            92,
+            825,
+            188
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            147,
+            194,
+            825,
+            277
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            145,
+            285,
+            825,
+            450
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            145,
+            457,
+            825,
+            650
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            151,
+            656,
+            823,
+            684
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            147,
+            690,
+            825,
+            787
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "85 2 Incremental Learning ",
+        "text_level": 1,
+        "bbox": [
+            148,
+            818,
+            388,
+            835
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "86 This section is a summary of the review published by Luo, et al. (2020). In this review, four different   \n87 types of strategies for incremental learning are highlighted, and every work published in this area   \n88 uses either one or more such strategies. Some examples are Castro, et al. (2018) and He, et al. (2020).   \n89 The four strategies are: ",
+        "bbox": [
+            147,
+            854,
+            825,
+            911
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "• Architectural • Regularization • Rehearsal • Pseudo-Rehearsal ",
+        "bbox": [
+            217,
+            92,
+            352,
+            164
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "94 The following subsections will disccuss these briefly. ",
+        "bbox": [
+            155,
+            176,
+            522,
+            190
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "2.1 Architectural Strategy ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            207,
+            369,
+            223
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "96 This strategy is similar to boosting techniques where multiple models are trained. But when used in the context of incremental learning, each model is trained on a different task separately. Then another 98 meta-model that effectively selects which model to use for inference is trained. The work done by 99 Poliker, et al. (2001) resembles this in many ways. In this work, multiple classifiers are trained with 0 different training sets, and then a Adaboost style of ensemble learning is employed to combine the model outputs. ",
+        "bbox": [
+            155,
+            233,
+            825,
+            316
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "102 Another interesting work is by Rusu, et al. (2016) on Progressive Neural Networks (PNN). In this   \n103 work, a neural network is trained sequentially on different tasks or training sets. However, each time,   \n104 new neurons are added in each layer with new weights, and the weights of the previously learned   \n105 neural network are frozen. Then, to prevent catastrophic forgetting, the outputs of each layer of the   \n106 previous neural network on the earlier training set are used in addition to the new task or training   \n107 set, when training the new layer neurons. The results on this type of incremental learning were quite   \n108 encouraging that it set a new direction in the research of dynamically expanding networks that could   \n109 make better use the neural networks capacity than the PNN. In fact, it will be seen later that the Fisher   \n110 Shut-off method proposed in this paper inherently employs the idea of PNNs. ",
+        "bbox": [
+            140,
+            321,
+            825,
+            448
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "2.2 Regularization Strategy ",
+        "text_level": 1,
+        "bbox": [
+            168,
+            464,
+            379,
+            479
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "112 In this strategy, as the name suggest, a regularization term is added in the loss function that measures   \n113 the importance of old knowledge when learning on a new training set. The representive work done in   \n114 this is Kirkpatrick, et al. (2017), whereby they introduce the concept of Elastic Weight Consolidation   \n115 (EWC) by means of a Fisher Information Matrix. The EWC brings about the regularization term in   \n116 the loss function as ",
+        "bbox": [
+            140,
+            489,
+            825,
+            559
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/eaddded0272291affae7fe4a9660de274f9483c623d565b1f57f253082e94a12.jpg",
+        "text": "$$\nR ( w ) = \\sum _ { i } \\frac { \\lambda } { 2 } F _ { i } ( w _ { i } - w _ { i , o l d } ) ^ { 2 }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            392,
+            589,
+            606,
+            627
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "117 where $F _ { i }$ is the Fisher Information Matrix which suggests the importance of the $i$ -th weight trained   \n118 on the old (or previous) training set. Here, as one could speculate, the term Fisher Shut-off proposed   \n119 in this paper actually derives itself from the Fisher Information Matrix, meaning that this matrix is   \n120 used as the basis for shutting off the training of certain weights when training on a new set.   \n121 Another popular type of regularization strategy is Knowledge Distillation introduced by Hinton, et al.   \n122 (2015). In this method, knowledge from an ensemble of models trained on different tasks (or training   \n123 sets) separately are distilled into a smaller model that can be deployed much easily for inference.   \n124 There are many huggingface.com transformers that are a product of such knowledge distillation.   \n125 The distillation ensures that the smaller model holds all the knowledge of the ensemble, and that it   \n126 can infer as good as it. Distillation is done by setting soft-targets on the smaller network from all the   \n127 earlier training sets of the ensemble. The soft-targets are the output logits from the ensemble models   \n128 on their respective trained datasets. ",
+        "bbox": [
+            140,
+            640,
+            825,
+            696
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            142,
+            702,
+            825,
+            813
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "129 2.3 Rehearsal and Pseudo-Rehearsal Strategies ",
+        "text_level": 1,
+        "bbox": [
+            143,
+            829,
+            516,
+            844
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "130 Rehearsal strategies in incremental learning make use of the earlier training sets when training a   \n131 model on new tasks or training sets. This by far is the simplest of all incremental learning strategies   \n132 that ensures catastrophic forgetting is prevented. The only issue is that when this strategy is used for   \n133 deep learning models trained on large datasets, the training on new datasets could become extremely   \n134 slow and even time consuming before any fruitful results are achieved. Hence, newer research work in   \n135 this area formulate methods for retaining only the most important data points to prevent catastrophic   \n136 forgetting. The work done by Castro, et al. (2018) is an example of this. In this work, selection and   \n137 removal mechanisms on data are introduced for assimilation into a memory network.   \n138 Talking about memory networks, the Pseudo-Rehearsal strategy involves training an additional data   \n139 generator to generate the samples, the neural network was trained on earlier. Hence, newer research   \n140 in this area involve GANs for data generation. Examples are Odena, et al. (2017) and Wu, et al.   \n141 (2018). ",
+        "bbox": [
+            142,
+            856,
+            825,
+            911
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            142,
+            90,
+            825,
+            147
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            142,
+            152,
+            826,
+            209
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "142 3 Proposed Incremental Learning Methods ",
+        "text_level": 1,
+        "bbox": [
+            142,
+            228,
+            550,
+            246
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "143 Commercial applications always require simplistic implementations of advanced methods no matter   \n144 how complex they may be. Therefore, it is for this purpose alone this paper proposes some simplified   \n145 methods for implementing incremental learning. As metioned earlier in Section 1, these methods are:   \n146 1) Fisher Shut-off, 2) Fractional Data Retention, and 3) Border Control. This section covers them in   \n147 detail. ",
+        "bbox": [
+            142,
+            258,
+            825,
+            329
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "148 3.1 Fisher Shut-off ",
+        "text_level": 1,
+        "bbox": [
+            150,
+            344,
+            318,
+            359
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "149 As mentioned in the previous section, the term Fisher Shut-off derives itself from the Fisher Infor  \n150 mation Matrix which weighs the importance of weights trained on previous datasets. Hence, in this   \n151 sub-section, a brief overview of the details behind this matrix is covered with the help of Aich (2021).   \n152 Let $\\mathcal { D }$ represent a dataset coming from a stream of data for incremental learning. Then $p ( w | \\mathcal { D } )$   \n153 represents the model trained on data $\\mathcal { D }$ . This means that to train a model on a new dataset, the   \n154 following posterior must satisfy: ",
+        "bbox": [
+            142,
+            369,
+            826,
+            412
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            142,
+            417,
+            826,
+            462
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/a15358fc3e1a14de53b12997fbe20e35ff131d70a2b4f35932e082c514b1f6fd.jpg",
+        "text": "$$\np ( w | \\mathcal D _ { n e w } ) = \\frac { p ( \\mathcal D _ { n e w } | w ) p ( w | \\mathcal D _ { o l d } ) } { p ( \\mathcal D _ { n e w } ) }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            375,
+            488,
+            622,
+            523
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "155 Note here that $p ( w | \\mathcal { D } _ { o l d } )$ is written in place of $p ( w )$ because when $\\mathcal { D } _ { n e w }$ is applied to the model, the   \n156 weights $w$ have already been trained with $\\mathcal { D } _ { o l d }$ . Hence, given the model, $p ( w | \\mathcal { D } _ { o l d } )$ , the log-likelihood   \n157 loss on $\\mathcal { D } _ { n e w }$ becomes, ",
+        "bbox": [
+            142,
+            535,
+            825,
+            579
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/74a6be926e26dca91399c1d70f54ee531dccf5ad29e080f5c507622ca7e9206c.jpg",
+        "text": "$$\n\\begin{array} { r l } & { \\mathcal { L } _ { \\mathcal { D } _ { n e w } } ( w ) = l o g ( p ( w | \\mathcal { D } _ { n e w } ) ) } \\\\ & { \\qquad = l o g ( p ( \\mathcal { D } _ { n e w } | w ) ) + l o g ( p ( w | \\mathcal { D } _ { o l d } ) ) - l o g ( p ( \\mathcal { D } _ { n e w } ) ) } \\\\ & { \\qquad \\approx l o g ( p ( \\mathcal { D } _ { n e w } | w ) ) + l o g ( p ( w | \\mathcal { D } _ { o l d } ) ) } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            279,
+            606,
+            717,
+            661
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "158 Here, the $l o g ( p ( \\mathcal { D } _ { n e w } | w ) )$ equals the cross-entropy loss of the model on $\\mathcal { D } _ { n e w }$ while $l o g ( p ( w | \\mathcal { D } _ { o l d } ) )$   \n159 is loss of the model on $\\mathcal { D } _ { o l d }$ . To ensure that catastrophic forgetting does not occur on $\\mathcal { D } _ { o l d }$ in its   \n160 absence while training on $\\mathcal { D } _ { n e w }$ , the loss on $\\mathcal { D } _ { o l d }$ will have to be approximated using $w$ alone. To do   \n161 this, the Taylor’s expansion on $l o g ( p ( w | \\mathcal { D } _ { o l d } ) )$ is taken as, ",
+        "bbox": [
+            140,
+            672,
+            826,
+            731
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/69d6f37d75fec7962529c0788241d518bd3252a0ddf7853b32e2ecb344af45e1.jpg",
+        "text": "$$\n\\begin{array} { r l } & { \\mathcal { L } _ { \\mathcal { D } _ { o l d } } ( w ) \\approx \\mathcal { L } ( w ) \\big | _ { \\mathcal { D } _ { o l d } } + \\left( \\frac { \\partial \\mathcal { L } ( w ) } { \\partial w } \\Big | _ { \\mathcal { D } _ { o l d } } \\right) + \\frac { 1 } { 2 } ( w - w \\big | _ { \\mathcal { D } _ { o l d } } ) ^ { T } \\left( \\frac { \\partial ^ { 2 } \\mathcal { L } ( w ) } { \\partial ^ { 2 } w } \\Big | _ { \\mathcal { D } _ { o l d } } \\right) ( w - w \\big | _ { \\mathcal { D } _ { o l d } } ) } \\\\ & { \\qquad \\approx \\mathcal { L } ( w ) \\big | _ { \\mathcal { D } _ { o l d } } + \\frac { 1 } { 2 } ( w - w \\big | _ { \\mathcal { D } _ { o l d } } ) ^ { T } \\left( \\frac { \\partial ^ { 2 } \\mathcal { L } ( w ) } { \\partial ^ { 2 } w } \\Big | _ { \\mathcal { D } _ { o l d } } \\right) ( w - w \\big | _ { \\mathcal { D } _ { o l d } } ) } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            184,
+            757,
+            813,
+            844
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "since technically 162 $\\begin{array} { r } { \\frac { \\partial \\mathcal { L } ( w ) } { \\partial w } \\bigg | _ { \\mathcal { D } _ { o l d } } = 0 } \\end{array}$ , if the model is trained well on $\\mathcal { D } _ { o l d }$ . Then, noting that the last term 163 in (4) is equivalent to a regularization term, this term alone could be considered as the loss on $\\mathcal { D } _ { o l d }$ ",
+        "bbox": [
+            142,
+            871,
+            825,
+            912
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "164 for preventing catastrophic forgetting. In doing so, the Fisher Information Matrix will equal to the   \n165 Hessian, $\\frac { \\partial ^ { 2 } \\mathcal { L } ( w ) } { \\partial ^ { 2 } w } \\bigg | _ { \\mathscr { D } _ { o l d } } .$ This Hessian, $\\mathcal { H }$ , can be simply computed by the model gradients $\\frac { \\bar { \\partial \\mathcal { L } } ( w ) } { \\partial w } \\bigg | _ { \\mathscr { D } _ { o l d } }$   \n166 assuming that not all gradients are zero, as, ",
+        "bbox": [
+            140,
+            90,
+            825,
+            145
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/dc622a320eb64ae2f8c4a32f04f15ce714556f4f59239c6f7c1f30980ae8a0e8.jpg",
+        "text": "$$\n\\mathcal { H } = \\frac { \\partial \\mathcal { L } ( w ) } { \\partial w } \\bigg | _ { \\mathcal { D } _ { o l d } } \\cdot \\frac { \\partial \\mathcal { L } ( w ) } { \\partial w } \\bigg | _ { \\mathcal { D } _ { o l d } } ^ { T }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            390,
+            172,
+            607,
+            212
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "167 Doing so, and keeping only the diagonal terms, would imply that the model gradients are more   \n168 than enough to weigh the important weights of the model trained on $\\mathcal { D } _ { o l d }$ . Replacing (5) in (4) and   \n169 substituting in (3) would give the loss on $\\mathcal { D } _ { n e w }$ as, ",
+        "bbox": [
+            142,
+            223,
+            826,
+            266
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/bc1f880fd17423a3ede2612347abfdb476b2eb4631734f31c3e5d1576d5dfb26.jpg",
+        "text": "$$\n\\mathcal { L } _ { \\mathcal { D } _ { n e w } } ( w ) \\approx l o g ( p ( \\mathcal { D } _ { n e w } | w ) ) + \\frac { 1 } { 2 } ( w - w \\big | _ { \\mathcal { D } _ { o l d } } ) ^ { T } \\left( \\frac { \\partial \\mathcal { L } ( w ) } { \\partial w } \\bigg | _ { \\mathcal { D } _ { o l d } } \\cdot \\frac { \\partial \\mathcal { L } ( w ) } { \\partial w } \\bigg | _ { \\mathcal { D } _ { o l d } } ^ { T } \\right) ( w - w \\big | _ { \\mathcal { D } _ { o l d } } )\n$$",
+        "text_format": "latex",
+        "bbox": [
+            181,
+            294,
+            802,
+            337
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "170 which to an extent implies that if the model gradients on $\\mathcal { D } _ { o l d }$ are absolutely zero, they get trained on   \n171 $\\mathcal { D } _ { n e w }$ without regularization, while those that are not, get regularized towards $w \\big | _ { \\mathscr { D } _ { o l d } }$ .   \n172 This is what the proposed Fisher Shut-off exploits. In Fisher Shut-off, all weights of the model   \n173 trained on $\\mathcal { D } _ { o l d }$ that do not have absolute zero gradients get shut-off for training on $\\mathcal { D } _ { n e w }$ , while the   \n174 remaining that do take part. Also, since in practice $R e L U$ functions are commonly used in deep   \n175 learning models as the activation functions of the neurons, shutting off these weights becomes as   \n176 simple as setting a condition. Figure 1 shows a sample performance of Fisher Shut-off on a regression   \n177 model trained sequentially on mutually exclusive batches of data. These batches could represent the   \n178 different tasks or training sets.   \n179 However, when it comes to classification, simple shut-off does not work completely. This is because,   \n180 while in regression problems datasets could inherently employ some kind of piece-wise nonlinear fit   \n181 in their distributions, the same cannot always be guaranteed in classification. Thus, in classification,   \n182 the shut-off weights must also take part in training. And, as per (1), there is a learning constant   \n183 required in the regularization to ensure that the right balances between $\\mathcal { D } _ { n e w }$ and $\\mathcal { D } _ { o l d }$ are met on   \n184 these weights. This paper provides a novel learning constant determination for this regularization.   \n185 This is detailed in Appendix A.   \n86 Also in regression problems, if datasets have batch distributions that are quite far apart from each   \n87 previous batch, then Fisher-Shutoff may not fully work too. Appendix B shows some of these   \n188 examples ",
+        "bbox": [
+            137,
+            347,
+            828,
+            377
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            140,
+            383,
+            825,
+            482
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            142,
+            488,
+            826,
+            530
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "image",
+        "img_path": "images/ec3ca6e1de828ff9f19c334a4f580525e37d7f6bbb827e170bad1c560561bda1.jpg",
+        "image_caption": [
+            "Figure 1: Fisher Shut-off on a regression model on six mutually exclusive batches of data. Blue dots represent the overall dataset, while green square dots are the batch or task data. The red line is the model’s output after each batch is fed to it. Fisher Shut-off is used from Batch $\\# 2$ onwards. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            204,
+            553,
+            792,
+            854
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            142,
+            92,
+            825,
+            147
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            150,
+            154,
+            826,
+            195
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "3.2 Fractional Data Retention ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            213,
+            393,
+            227
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "This is a very simply proposal. The idea is to retain only a fraction of the data trained on the neural network on the earlier tasks or training sets. There is nothing more to this. However, banking on the ideas of selection highlighted in Castro, et al. (2018), whereby data is selected based on their proximity to cluster centers, to be more representative of the classes, this paper uses this as the baseline idea behind its proposal on Fractional Data Retention. Thus in Fractional Data Retention, a fraction of the data within the data cluster is retained and appended in every stage of incremental learning. ",
+        "bbox": [
+            166,
+            238,
+            825,
+            337
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "197 3.3 Border Control ",
+        "text_level": 1,
+        "bbox": [
+            145,
+            353,
+            321,
+            368
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "The most important requirement when incrementally learning classes is to ensure that the decision boundaries of the earlier training tasks are protected as much as possible when training on new sets. If data points are used for this purpose, it would seem that, those that lie closest to the decision boundaries after training would be the most important ones to retain, for any succeeding incremental learning tasks. Thus, the Border Control method proposed in this paper exploits this. Ruping (2001) used SVMs to identify these data points as the support vectors that helped define the overall decision boundaries. But with deep learning models or vanilla neural networks, SVM is quite complex and therefore in order to be able retain data points closest to the decision boundaries, a different selection mechanism is required. This selection mechanism could instead be based on selecting data points on how large the absolute errors in sigmoidal outputs are for the applied dataset, as the data points closest to the decision boundaries have this inherent property. ",
+        "bbox": [
+            165,
+            378,
+            825,
+            531
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "209 Furthermore, since real world data can be quite complex, it would be necessary to not only select data   \n210 points based on how large their errors in sigmoidal outputs are, but also those points that are far away   \n211 from them. This is because, given the context of incremental learning where there is a high chance   \n212 that newer training sets may have data points that could potentially set newer decision boundaries in   \n213 those fartherest regions, these data points would help protect those.   \n214 Hence in Border Control, the top- $\\mathtt { k }$ data points that have the largest absolute errors in the sigmoidal   \n215 outputs and their respective top- $\\mathtt { k }$ fartherest data points are retained in every task or training set   \n216 for further incremental learning. These points are appended to the newer training sets before further   \n217 training is applied. ",
+        "bbox": [
+            140,
+            537,
+            825,
+            607
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            142,
+            613,
+            825,
+            669
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "218 4 Sample Results ",
+        "text_level": 1,
+        "bbox": [
+            143,
+            690,
+            333,
+            707
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "219 The proposed methods are tested on a toy dataset, as mentioned in Section 1, only to provide some   \n220 visuals on how the incremental learning progresses using the proposed methods. Figure 2 shows this   \n221 dataset. A vanilla deep neural network of size, 1000-1000-1000-1000-3, is used for incrementally   \n222 learning batches of data from this toy dataset. The activation functions for all layers are $R e L U$ except   \n223 for the output which is a sof tmax. All weights are uniformly but randomly initialized with a single   \n224 random seed to make the results comparable. The weights are also scaled by a $\\frac { 2 } { \\sqrt { n } }$ factor to ensure   \n225 that minimal overfitting occurs during training. Here $n$ is the layer fan-in.   \n226 To visualize incremental learning on the proposed methods, the dataset is divided into 6 batches   \n227 with mututally exclusive data points. This gives roughly between 100 to 200 data points in each   \n228 batch, a size that is commonly used when training neural networks of this size. Figure 3 shows this.   \n229 In this figure, it can be clearly seen that the batch distributions on the class data for incremental   \n230 learning do not always form a piece-wise nonlinear fit, and therefore, plain shut-off of weights cannot   \n231 fully retain knowledge learned earlier. Also, among these distributions, some allowed incremental   \n232 learning to happen easily, while others did not, and the distribution shown in Figure 3 is one such.   \n233 Table 1 summarizes the results of the proposed methods on this particular distribution. For other batch   \n234 distributions, similar results could be achieved. Note here that quite some ML-Ops were required to   \n235 achieve the results in Table 1. This was especially the case for those that employed Fisher Shut-off,   \n236 since this method has a regularization constant that requires adapting on each batch. Furthermore,   \n237 training on each batch was stopped once $1 0 0 . 0 \\%$ accuracy was obtained on the batch. This left quite   \n238 some data points to lie very close to the boundary lines or in some cases just right on them. Thus,   \n239 the neural network was very vulnerable to catastrophic forgetting when succeeding batch trainings   \n240 occurred as part of incremental learning.   \n241 However, taking a look at Table 1, it can be seen that when Fisher Shut-off is applied, additional   \n242 leverage against catastrophic forgetting occurs on each incremental batch, than when it is not used.   \n243 And, among the three methods proposed in this paper, the Border Control method shows much   \n244 stronger performance. In Figure 4, sample decision boundaries learned when each incremental batch   \n245 is applied to the neural network using Fisher Shut-off and Border Control together is shown. A topk   \n246 value of 5 is used for the Border Control. Also, note in Figure 4 that the red circles mark the border   \n247 points accumulated on each batch. It can be seen that they clearly assume the data points closest   \n248 to the decision boundaries, as well as those far away from it. All with respect to their batches. For   \n249 the far away data points, their purpose can be clearly seen between batches #1 and $\\# 2$ , where the   \n250 fartherest points of class 2 in Batch #1 helped protect the decision boundaries from the data points   \n251 of class 0 in Batch $\\# 2$ . This means that more complex datasets can be accommodated by simply   \n252 applying Border Control. More examples are shown in Appendix C. ",
+        "bbox": [
+            142,
+            722,
+            825,
+            821
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            142,
+            828,
+            825,
+            911
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "image",
+        "img_path": "images/ed5b8993eaca01d170d93842c74b1f8afc29195bd92a7249a0f7e6d54ce3a8c4.jpg",
+        "image_caption": [
+            "Figure 2: The toy dataset having three nonlinearly arranged classes. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            380,
+            92,
+            619,
+            215
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/b02e14d6cf3d7912dafbbcf85b828e0529858490504fb69b8d48e1be08459fa6.jpg",
+        "image_caption": [
+            "Figure 3: Batches on the toy dataset. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            215,
+            276,
+            784,
+            568
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            138,
+            641,
+            826,
+            767
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            140,
+            772,
+            825,
+            911
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "table",
+        "img_path": "images/44a71df70375c6308a562a9a44508116449215d01a051506c004a38008ac986e.jpg",
+        "table_caption": [
+            "Table 1: Performance of proposed methods on the dataset of Figure 2 "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=\"2\">Method</td><td colspan=\"6\"> Sample accuracy on accumulated dataset after Batch1</td></tr><tr><td>#1</td><td>#2</td><td>#3</td><td>#4</td><td>#5</td><td>#6</td></tr><tr><td>No Incremental Learning</td><td>100.0%</td><td>90.98%2</td><td>92.76%</td><td>94.89%</td><td>98.32%</td><td>96.11%</td></tr><tr><td>Fisher Shut-off (FS)</td><td>100.0%</td><td>99.74%</td><td>98.19%</td><td>98.88%</td><td>98.96%</td><td>96.89%</td></tr><tr><td>Frac. Data Ret. (FDR)[10%]</td><td>100.0%</td><td>97.94%</td><td>98.39%</td><td>98.89%</td><td>98.71%</td><td>98.67%</td></tr><tr><td>FDR[20%]</td><td>100.0%</td><td>98.71%</td><td>98.59%</td><td>99.36%</td><td>98.97%</td><td>98.78%</td></tr><tr><td>Border Ctrl. (BC)[t opk = 5]</td><td>100.0%</td><td>100.0%</td><td>100.0%</td><td>99.84%</td><td>100.0%</td><td>100.0%</td></tr><tr><td>BC[topk = 10]</td><td>100.0%</td><td>100.0%</td><td>100.0%</td><td>99.84%</td><td>100.0%</td><td>100.0%</td></tr><tr><td>FS + FDR[10%]</td><td>100.0%</td><td>99.74%</td><td>98.79%</td><td>99.52%</td><td>99.23%</td><td>98.78%</td></tr><tr><td>FS + FDR[20%]</td><td>100.0%</td><td>100.0%</td><td>99.19%</td><td>99.52%</td><td>99.48%</td><td>99.11%</td></tr><tr><td>FS +BC[topk = 5]</td><td>100.0%</td><td>100.0%</td><td>100.0%</td><td>99.84%</td><td>100.0%</td><td>100.0%</td></tr><tr><td>FS + BC[topk = 10]</td><td>100.0%</td><td>100.0%</td><td>100.0%</td><td>100.0%</td><td>100.0%</td><td>100.0%</td></tr></table>",
+        "bbox": [
+            176,
+            109,
+            823,
+            299
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "image",
+        "img_path": "images/5bccdefef0dd25c13f1ecc98bcf95de7a924e776d8da83295052a7d16b995c74.jpg",
+        "image_caption": [
+            "Figure 4: Incremental learning using Fisher Shut-off and Border Control together $[ t o p k = 5 ]$ ]. Black circles mark the batch data, while the red circles mark the accumulated border points. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            214,
+            315,
+            784,
+            614
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            143,
+            684,
+            821,
+            713
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Also, to add on further to this, for the most difficult incremental learning applications such as learning new classes as highlighted in Castro, et al. (2018) and He, et al. (2020), Border Control can help leverage the many issues associated with it like class imbalance, concept drift and so on. ",
+        "bbox": [
+            163,
+            719,
+            825,
+            761
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "5 Conclusion ",
+        "text_level": 1,
+        "bbox": [
+            163,
+            781,
+            299,
+            799
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "257 To summarize the work in this paper, three simplified methods for implementing incremental learning   \n258 for commercial fine-tuning of pre-trained models was proposed. Results showed that while Border   \n259 Control performed the best, Fisher Shut-off was able to leverage the performances. However, dataset   \n260 used in this paper was a toy dataset and not one of the benchmark datasets typically used for   \n261 incremental learning. Hence, testing these methods on the benchmark datasets is a potential next step   \n262 forward. Then, preparing the prerequisites for each model available, like say in huggingface.com,   \n263 for incremental learning must be done so that automation companies or any other AI organization   \n264 can make use of them. From the methods proposed in this paper, the prerequisites would be: 1)   \n265 the Shut-off matrix for the neural network weights, and 2) the border points for each of the learned   \n266 classes. Additionally, an ML-Ops infrastructure can be provided to optimize the performances of   \n267 the models that employ the Fisher Shut-off method. Metrics like the Backward Transfer (BWT) and   \n268 Forward Transfer (FWT) proposed in Lopez-Paz & Ranzato (2017) can be used for this purpose. ",
+        "bbox": [
+            140,
+            814,
+            825,
+            871
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            140,
+            92,
+            826,
+            203
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "269 References ",
+        "text_level": 1,
+        "bbox": [
+            143,
+            227,
+            267,
+            242
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "270 [1] Aich, A. (2021) Elastic weight consolidation (EWC): Nuts and bolts. arXiv preprint arXiv:2105.04093.   \n271 [2] Alshalali, T. & Joysula, D. (2018) Fine-Tuning of Pre-Trained Deep Learning Models with Extreme Learning   \n272 Machine. IEEE International Conference on Computational Science and Computational Intelligence (CSCI), pp.   \n273 469-473.   \n274 [3] Castro, F., Marín-Jiménez, M.J., Guil, N., Schmid, C. & Alahari, K. (2018) End-to-end incremental learning.   \n275 Proceedings of the European Conference on Computer Vision (ECCV), pp. 233-248.   \n276 [4] Dif, N. & Elberrichi, Z. (2020) A New Intra Fine-Tuning Method. International Journal of Service Science,   \n277 Management, Engineering, and Technology, 11(2), pp. 16-40.   \n278 [5] He, J., Mao, R., Shao, Z. & Zhu, F. (2020) Incremental learning in online scenario. IEEE/CVF Conference   \n279 on Computer Vision and Pattern Recognition, pp. 13926-13935.   \n280 [6] Hinton, G., Vinyals, O. & Dean, J. (2015) Distilling the Knowledge in a Neural Network. arXiv preprint   \n281 arXiv:1503.02531, 2(7).   \n282 [7] Jung, H., Lee, S., Yim, J., Park, S. & Kim, J. (2015) Joint fine-tuning in deep neural networks for facial   \n283 expression recognition. Proceedings of the IEEE International Conference on Computer Vision, pp. 2983-2991.   \n284 [8] Kirkpatrick, J., Pascanu, R., Rabinowitz, N., Veness, J., Desjardins, G., Rusu, A.A., Milan, K., Quan, J.,   \n285 Ramalho, T., Grabska-Barwinska, A. & Hassabis, D. (2017) Overcoming catastrophic forgetting in neural   \n286 networks. Proceedings of the National Academy of Sciences, 114(13), pp. 3521-3526.   \n287 [9] Lopez-Paz, D. & Ranzato, M.A. (2017) Gradient episodic memory for continual learning. Proceedings of   \n288 Neural Information Processing Systems (NIPS), pp. 6467-6476.   \n289 [10] Luo, Y., Yin, L., Bai, W. & Mao, K. (2020) An Appraisal of Incremental Learning Methods. Entropy,   \n290 22(11), pp. 1190-1216.   \n291 [11] Odena, A., Olah, C. & Shlens, J. (2017) Conditional image synthesis with auxiliary classifier GANs.   \n292 International Conference on Machine Learning (ICML), pp. 2642–2651.   \n293 [12] Polikar, R., Udpa, L., Udpa, S. & Honavar, V. (2001) Learn++: An Incremental Learning Algorithm for   \n294 Supervised Neural Networks. IEEE Transactions on Systems, Man, and Cybernetics, part C (applications and   \n295 reviews), 31(4), pp. 497-508.   \n296 [13] Qian, X., Zhang, C., Yella, J., Huang, Y., Huang, M.C. & Bom, S. (2021) Soft sensing model visualization:   \n297 Fine-tuning neural network from what model learned. IEEE International Conference on Big Data (Big Data),   \n298 pp. 1900-1908.   \n299 [14] Ren, M., Zeng, W., Yang, B. & Urtasun, R. (2018) Learning to reweight examples for robust deep learning.   \n300 International Conference on Machine Learning (ICML), pp. 4334-4343.   \n301 [15] Ruping, S. (2001) Incremental learning with support vector machines. IEEE International Conference on   \n302 Data Mining, pp. 641-642.   \n303 [16] Rusu, A.A., Rabinowitz, N.C., Desjardins, G., Soyer, H., Kirkpatrick, J., Kavukcuoglu, K., Pascanu, R. &   \n304 Hadsell, R. (2016) Progressive neural networks. arXiv preprint arXiv:1606.04671.   \n305 [17] Too, E., Yujian, L., Njuki, S. & Yingchun, L. (2019) A comparative study of fine-tuning deep learning   \n306 models for plant disease. Computers and Electronics in Agriculture, 161, pp. 272-279.   \n307 [18] Vrbanciˇ c, G. & Podgorelec, V. (2020) ˇ Transfer learning with adaptive fine-tuning. IEEE Access, Volume 8,   \n308 pp. 196197-196211.   \n309 [19] Wu, Y., Chen, Y.P., Wang, L.J., Ye, Y.C., Liu, Z.C., Guo, Y.D., Zhang, Z.Y. & Fu, Y. (2018) Incremental   \n310 Classifier Learning with Generative Adversarial Networks. arXiv preprint arXiv:1802.00853. ",
+        "bbox": [
+            137,
+            262,
+            826,
+            917
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "The checklist follows the references. Please read the checklist guidelines carefully for information on how to answer these questions. For each question, change the default [TODO] to [Yes] , [No] , or [N/A] . You are strongly encouraged to include a justification to your answer, either by referencing the appropriate section of your paper or providing a brief inline description. For example: ",
+        "bbox": [
+            143,
+            119,
+            826,
+            176
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "• Did you include the license to the code and datasets? [Yes] See Section ??.   \n• Did you include the license to the code and datasets? [No] The code and the data are proprietary.   \n• Did you include the license to the code and datasets? [N/A] ",
+        "bbox": [
+            217,
+            186,
+            825,
+            252
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Please do not modify the questions and only use the provided macros for your answers. Note that the Checklist section does not count towards the page limit. In your paper, please delete this instructions block and only keep the Checklist section heading above along with the questions/answers below. ",
+        "bbox": [
+            143,
+            262,
+            826,
+            305
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "1. For all authors... ",
+        "bbox": [
+            214,
+            316,
+            339,
+            330
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "(a) Do the main claims made in the abstract and introduction accurately reflect the paper’s contributions and scope? [Yes]   \n(b) Did you describe the limitations of your work? [Yes] See Sections 4 and 5   \n(c) Did you discuss any potential negative societal impacts of your work? [N/A]   \n(d) Have you read the ethics review guidelines and ensured that your paper conforms to them? [Yes] ",
+        "bbox": [
+            238,
+            335,
+            825,
+            425
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "2. If you are including theoretical results... ",
+        "bbox": [
+            214,
+            429,
+            493,
+            444
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "(a) Did you state the full set of assumptions of all theoretical results? [Yes] See Section 3 and Appendix A   \n(b) Did you include complete proofs of all theoretical results? [Yes] See Section 3 and Appendix A ",
+        "bbox": [
+            238,
+            446,
+            825,
+            506
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "3. If you ran experiments... ",
+        "bbox": [
+            214,
+            510,
+            393,
+            523
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "(a) Did you include the code, data, and instructions needed to reproduce the main experimental results (either in the supplemental material or as a URL)? [Yes] As a supplemental material   \n(b) Did you specify all the training details (e.g., data splits, hyperparameters, how they were chosen)? [No] But it’s in the supplemental material   \n(c) Did you report error bars (e.g., with respect to the random seed after running experiments multiple times)? [No] But additional examples are shown in Appendix C   \n(d) Did you include the total amount of compute and the type of resources used (e.g., type of GPUs, internal cluster, or cloud provider)? [N/A] ",
+        "bbox": [
+            238,
+            529,
+            825,
+            660
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "4. If you are using existing assets (e.g., code, data, models) or curating/releasing new assets... ",
+        "bbox": [
+            217,
+            662,
+            823,
+            678
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "(a) If your work uses existing assets, did you cite the creators? [N/A]   \n(b) Did you mention the license of the assets? [N/A]   \n(c) Did you include any new assets either in the supplemental material or as a URL? [N/A]   \n(d) Did you discuss whether and how consent was obtained from people whose data you’re using/curating? [N/A]   \n(e) Did you discuss whether the data you are using/curating contains personally identifiable information or offensive content? [N/A] ",
+        "bbox": [
+            238,
+            681,
+            825,
+            801
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "5. If you used crowdsourcing or conducted research with human subjects... ",
+        "bbox": [
+            214,
+            805,
+            704,
+            820
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "(a) Did you include the full text of instructions given to participants and screenshots, if applicable? [N/A]   \n(b) Did you describe any potential participant risks, with links to Institutional Review Board (IRB) approvals, if applicable? [N/A]   \n(c) Did you include the estimated hourly wage paid to participants and the total amount spent on participant compensation? [N/A] ",
+        "bbox": [
+            238,
+            824,
+            825,
+            912
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "362 Here, the derivation of regularization constant for Fisher Shut-off method is detailed. To start with,   \n363 let the neural network be defined as, ",
+        "bbox": [
+            142,
+            119,
+            828,
+            148
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "equation",
+        "img_path": "images/b07fcd772a1ae5904c64e4fc051920aa75d3ca2813faf1927bfb0d4fd135093c.jpg",
+        "text": "$$\ny = w ^ { T } \\phi ( x , \\omega )\n$$",
+        "text_format": "latex",
+        "bbox": [
+            446,
+            179,
+            552,
+            198
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "364 Here, $w$ is the weights of the output layer, $\\phi ( \\cdot )$ is the output of the preceding layer, $x$ is the input and   \n365 $\\omega$ represents the rest of the weights of the neural network. Throughout the derivation, we will be   \n366 dealing with only the output layer, and so the $\\phi ( x , \\omega )$ will be written in short form as $\\Phi$ from here on.   \n367 Let $e _ { k }$ denoted the error of fitting in the $k$ -th iteration, and $g _ { k }$ denote the error gradient. This would   \n368 mean that $g _ { k } = \\Phi _ { k } e _ { k }$ .   \n369 Then, given the regularization term in (6), let $\\tilde { w }$ denote difference in weights, between the new   \n370 training and the previous training. This would give the weight updation policy as, ",
+        "bbox": [
+            140,
+            210,
+            825,
+            282
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            140,
+            286,
+            826,
+            318
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "equation",
+        "img_path": "images/32a1481d5eac0518a8ad59224b8997ba40c10f990725a8ed8066814040237018.jpg",
+        "text": "$$\nw _ { k + 1 } = w _ { k } - \\eta g _ { k } - \\beta \\tilde { w } _ { k }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            411,
+            349,
+            588,
+            366
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "If 371 $e _ { k } = w _ { k } ^ { T } \\Phi _ { k } - Y$ , then the error $e _ { k + 1 }$ after the weight updation would equal, ",
+        "bbox": [
+            137,
+            378,
+            692,
+            395
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "equation",
+        "img_path": "images/75fd1c7bddf5675b9a8270ce21e7403d4ca9b0ef8250aa0f5b77a702d88261d2.jpg",
+        "text": "$$\n\\begin{array} { r l } & { e _ { k + 1 } = w _ { k + 1 } ^ { T } \\Phi _ { k + 1 } - Y } \\\\ & { \\qquad = ( w _ { k } - \\eta g _ { k } - \\beta \\tilde { w } _ { k } ) ^ { T } \\Phi _ { k + 1 } - Y } \\\\ & { \\qquad = w _ { k } ^ { T } \\Phi _ { k + 1 } - \\eta g _ { k } ^ { T } \\Phi _ { k + 1 } - \\beta \\tilde { w } _ { k } ^ { T } \\Phi _ { k + 1 } - Y } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            338,
+            421,
+            660,
+            486
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "372 Asumming for simplicity sake that $\\Phi _ { k + 1 } \\approx \\Phi _ { k } + \\delta$ , then (9) can continue as, ",
+        "bbox": [
+            138,
+            496,
+            679,
+            513
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "equation",
+        "img_path": "images/3bd40be7231c96c492c72d712f848099c8f312b6cf67e43166835c66cc492a11.jpg",
+        "text": "$$\n\\begin{array} { c } { { e _ { k + 1 } \\approx w _ { k } ^ { T } \\Phi _ { k } - \\eta g _ { k } ^ { T } \\Phi _ { k } - \\beta \\tilde { w } _ { k } ^ { T } \\Phi _ { k } - Y + \\Delta } } \\\\ { { { } } } \\\\ { { \\approx e _ { k } - \\eta g _ { k } ^ { T } \\Phi _ { k } - \\beta \\tilde { w } _ { k } ^ { T } \\Phi _ { k } } } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            346,
+            540,
+            653,
+            583
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "373 Taking the square norm of $e _ { k + 1 }$ in (10), would equate this to, ",
+        "bbox": [
+            140,
+            594,
+            578,
+            611
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "equation",
+        "img_path": "images/1594f9cb5eaafa167fdce65b86dc7a69713dd83bb615c7944800fc7e545a6c2d.jpg",
+        "text": "$$\n\\begin{array} { r l } & { | | e _ { k + 1 } | | ^ { 2 } = | | e _ { k } | | ^ { 2 } + \\eta ^ { 2 } | | g _ { k } ^ { T } \\Phi _ { k } | | ^ { 2 } + \\beta ^ { 2 } | | \\tilde { w } _ { k } ^ { T } \\Phi _ { k } | | ^ { 2 } } \\\\ & { ~ - ~ 2 \\eta e _ { k } ^ { T } \\Phi _ { k } ^ { T } g _ { k } - 2 \\beta e _ { k } ^ { T } \\Phi _ { k } ^ { T } \\tilde { w } _ { k } + 2 \\eta \\beta \\tilde { w } _ { k } ^ { T } \\Phi _ { k } \\Phi _ { k } ^ { T } g _ { k } } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            308,
+            637,
+            689,
+            681
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "374 We require that $| | e _ { k + 1 } | | ^ { 2 } < | | e _ { k } | | ^ { 2 }$ at all times, so that regularization does not affect the fit at any   \n375 point during the training. Applying this condition in (11) would give, ",
+        "bbox": [
+            137,
+            693,
+            826,
+            724
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "equation",
+        "img_path": "images/a73b5e0026dc7e8708344c3c012a764d7ff01a567b05f9e9a78fd4f3a3b7fdab.jpg",
+        "text": "$$\n\\eta ^ { 2 } | | g _ { k } ^ { T } \\Phi _ { k } | | ^ { 2 } + \\beta ^ { 2 } | | \\tilde { w } _ { k } ^ { T } \\Phi _ { k } | | ^ { 2 } - 2 \\eta e _ { k } ^ { T } \\Phi _ { k } ^ { T } g _ { k } - 2 \\beta e _ { k } ^ { T } \\Phi _ { k } ^ { T } \\tilde { w } _ { k } + 2 \\eta \\beta \\tilde { w } _ { k } ^ { T } \\Phi _ { k } \\Phi _ { k } ^ { T } g _ { k } < 0\n$$",
+        "text_format": "latex",
+        "bbox": [
+            232,
+            752,
+            767,
+            772
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "376 Then, taking the partial derivatives of (12) w.r.t $\\eta$ and $\\beta$ would give the following equations to be   \n377 satisfied: ",
+        "bbox": [
+            135,
+            785,
+            828,
+            814
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "equation",
+        "img_path": "images/178a66c2f9c1db1202932a8706ff13775e3340c3d2ed3da0e9372b31d071df91.jpg",
+        "text": "$$\n\\eta | | g _ { k } ^ { T } \\Phi _ { k } | | ^ { 2 } - e _ { k } ^ { T } \\Phi _ { k } ^ { T } g _ { k } + \\beta \\tilde { w } _ { k } ^ { T } \\Phi _ { k } \\Phi _ { k } ^ { T } g _ { k } = 0\n$$",
+        "text_format": "latex",
+        "bbox": [
+            352,
+            844,
+            645,
+            863
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "equation",
+        "img_path": "images/3887c583a9beba4d0e8f666c6a8c3e0c3040d332dc7bb6005a23f23594457692.jpg",
+        "text": "$$\n\\beta | | \\tilde { w } _ { k } ^ { T } \\Phi _ { k } | | ^ { 2 } - e _ { k } ^ { T } \\Phi _ { k } ^ { T } \\tilde { w } _ { k } + \\eta \\tilde { w } _ { k } ^ { T } \\Phi _ { k } \\Phi _ { k } ^ { T } g _ { k } = 0\n$$",
+        "text_format": "latex",
+        "bbox": [
+            349,
+            893,
+            648,
+            912
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "378 Solving, (13) and (14) can result in negative $\\eta$ and $\\beta$ , which is not acceptable, and so to simplify the   \n379 solution, we neglect the $\\beta$ -term in (13). Doing so we get, ",
+        "bbox": [
+            135,
+            90,
+            826,
+            121
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "equation",
+        "img_path": "images/d0d765dc0222ec6a060eeb994411b77f93b4ddc58b23c1f9fff18a87429dfc82.jpg",
+        "text": "$$\n\\begin{array} { r l } & { \\eta = \\frac { e _ { k } ^ { T } \\Phi _ { k } ^ { T } g _ { k } } { \\vert \\vert g _ { k } ^ { T } \\Phi _ { k } \\vert \\vert ^ { 2 } } , } \\\\ & { } \\\\ & { \\beta = \\frac { e _ { k } ^ { T } \\Phi _ { k } ^ { T } \\tilde { w } _ { k } - \\eta \\tilde { w } _ { k } ^ { T } \\Phi _ { k } \\Phi _ { k } ^ { T } g _ { k } } { \\vert \\vert \\tilde { w } _ { k } ^ { T } \\Phi _ { k } \\vert \\vert ^ { 2 } } } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            393,
+            148,
+            606,
+            243
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "380 Then, substituting for $g _ { k }$ and openning up the norms, we get, ",
+        "bbox": [
+            140,
+            255,
+            575,
+            271
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "equation",
+        "img_path": "images/2b0ecdf49a1badd8bcbfabc9f3fa8b388c3809d322e50de7adf0d3dc23af6ba7.jpg",
+        "text": "$$\n\\eta = \\frac { e _ { k } ^ { T } \\Phi _ { k } ^ { T } \\Phi _ { k } e _ { k } } { e _ { k } ^ { T } ( \\Phi _ { k } ^ { T } \\Phi _ { k } ) ( \\Phi _ { k } ^ { T } \\Phi _ { k } ) e _ { k } } ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            380,
+            299,
+            563,
+            337
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "equation",
+        "img_path": "images/ea3b0d31b1692e2a6daae854f40df4ba6cf4946fd880a617540abe3f1a9cfb5b.jpg",
+        "text": "$$\n\\beta = \\frac { e _ { k } ^ { T } \\Phi _ { k } ^ { T } \\tilde { w } _ { k } - \\eta \\tilde { w } _ { k } ^ { T } ( \\Phi _ { k } \\Phi _ { k } ^ { T } ) \\Phi _ { k } e _ { k } } { \\tilde { w } _ { k } ^ { T } ( \\Phi _ { k } \\Phi _ { k } ^ { T } ) \\tilde { w } _ { k } }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            379,
+            354,
+            619,
+            392
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "381 Simplifying (16) gives, ",
+        "bbox": [
+            140,
+            405,
+            328,
+            421
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "equation",
+        "img_path": "images/ded3e70309e85198252e5583b697e498e31e4871f702de56db16a64a62168365.jpg",
+        "text": "$$\n\\eta = \\frac { e _ { k } ^ { T } e _ { k } } { e _ { k } ^ { T } \\Phi _ { k } ^ { T } \\Phi _ { k } e _ { k } } ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            428,
+            452,
+            544,
+            488
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "equation",
+        "img_path": "images/6022507d8b8f82158ca71a569238702b1df503f4d316bfe75c079e2875a223ab.jpg",
+        "text": "$$\n\\beta = ( 1 - \\eta ) \\frac { \\tilde { w } _ { k } ^ { T } \\Phi _ { k } e _ { k } } { \\tilde { w } _ { k } ^ { T } \\tilde { w } _ { k } }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            426,
+            506,
+            571,
+            542
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "382 Equation (17) gives the raw form for both $\\eta$ and $\\beta$ to be regulated. However, this will be further   \n383 simplified for computating purposes, but will be used as a basis.   \n384 Since the errors $e _ { k }$ get smaller as the neural network fits the data, using them in learning constants   \n385 will only slow down the fits. A common way to overcome this is by replacing $e _ { k }$ with all ones.   \n386 Similarly, for the $\\tilde { w } _ { k }$ , all weights that are to be regularized are replaced with ones. If we denote   \n387 the weights to be regularized as $w _ { r }$ , and there are $m$ patterns in the dataset with $n$ weights to be   \n388 regularized, the $\\eta$ and $\\beta$ computations become, ",
+        "bbox": [
+            147,
+            556,
+            826,
+            587
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            140,
+            590,
+            825,
+            661
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "equation",
+        "img_path": "images/442b45703e0d5bc953ed91857f82f1af81d17476e62fa79baeb583297874dfda.jpg",
+        "text": "$$\n\\eta = \\frac { 1 } { | | \\Phi _ { k } | | ^ { 2 } } ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            429,
+            690,
+            517,
+            724
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "equation",
+        "img_path": "images/c9f7fc511d626c576863ed43e74e284cd34b4e4f59f8229db4e15d89189fac5e.jpg",
+        "text": "$$\n\\beta = \\frac { \\alpha } { m n } \\sum _ { i : w \\in w _ { r } } \\Phi _ { i , k }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            428,
+            743,
+            568,
+            779
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "389 Here, $\\alpha$ represents the $( 1 - \\eta )$ -term in (17). This constant will not neccessarily take the computed $\\eta$   \n390 when being regulated. Instead, this constant will have to be adapted each time for every incremental   \n391 batch applied to the neural network.   \n392 The reason why the computed $\\eta$ is not used for the $\\alpha$ adaptation is because this $\\eta$ can sometimes   \n393 become too small in the adaptation, that the $1 - \\eta$ would always tend towards 1. When this was   \n394 empirically tested on the toy dataset, the regularization was found at times to have gone too strong   \n395 that the fit never happened. ML-Ops on the $\\alpha$ found that this constant is not always 1, and can be   \n396 anywhere between 0 and 1, or higher in some cases. ",
+        "bbox": [
+            140,
+            792,
+            825,
+            835
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            140,
+            842,
+            825,
+            911
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "398 Additional examples on the regression problem with Fisher Shut-off. Fisher Shut-off could not be used completely, and regularization had to take over for some batches. Figures 5 and 6 show this. ",
+        "bbox": [
+            145,
+            127,
+            826,
+            157
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "image",
+        "img_path": "images/72e9762490cf8ee10f248a8d3a0d85b6b28ea32a596f13c1b194dc4898ba90c7.jpg",
+        "image_caption": [
+            "Figure 5: Complete Fisher Shut-off is used in Batches #2 and #6. Batches #3, #4 and #5 are regularized. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            222,
+            183,
+            776,
+            469
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "image",
+        "img_path": "images/b70e35df8ae79c3da760bbd94c1191f3f81fda2aacf6961298510e013e24a3ed.jpg",
+        "image_caption": [
+            "Figure 6: Complete Fisher Shut-off is used in Batches $\\# 2$ and $\\# 6$ . Batches $\\# 3$ and $\\# 4$ are regularized. Batch #5 is fine-tuned "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            223,
+            563,
+            777,
+            849
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "401 In this appendix, additional examples on the toy dataset classification is shown. Figures 7 and 8 show 402 the batch distributions considered. Among these, Figure 8 has more cases in which the farthest points 403 in Border Control can play a vital role in retaining previously learned knowledge. Tables 2 and 3 summarize their performances. ",
+        "bbox": [
+            142,
+            121,
+            825,
+            176
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "image",
+        "img_path": "images/df00e79da7646169cbe201b37f70a3bcbb78337b977ceaff9e318f5cd16ecc4a.jpg",
+        "image_caption": [
+            "Figure 7: Another batch distribution on the toy dataset. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            214,
+            190,
+            785,
+            483
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "table",
+        "img_path": "images/35169b5859d76b2ba8db2696ee69a6e233a337b896515790bfc98fef3d4d9924.jpg",
+        "table_caption": [
+            "Table 2: Performance of proposed methods on the dataset of Figure 7 "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=\"2\">Method</td><td colspan=\"6\">Sample accuracy on accumulated dataset after Batch</td></tr><tr><td>#1</td><td>#2</td><td>#3</td><td>#4</td><td>#5</td><td>#6</td></tr><tr><td>No Incremental Learning</td><td>100.0%</td><td>73.14%</td><td>92.07%</td><td>97.56%</td><td>88.33%</td><td>91.67%</td></tr><tr><td>Fisher Shut-off (FS)</td><td>100.0%</td><td>99.43%</td><td>98.26%</td><td>99.54%</td><td>92.85%</td><td>97.78%</td></tr><tr><td>Frac. Data Ret. (FDR)[10%]</td><td>100.0%</td><td>97.43%</td><td>96.13%</td><td>98.93%</td><td>98.75%</td><td>96.78%</td></tr><tr><td>FDR[20%]</td><td>100.0%</td><td>98.86%</td><td>98.84%</td><td>99.69%</td><td>99.75%</td><td>98.89%</td></tr><tr><td>Border Ctrl. (BC)[topk = 5]</td><td>100.0%</td><td>100.0%</td><td>100.0%</td><td>100.0%</td><td>100.0%</td><td>99.78%</td></tr><tr><td>BC[topk = 10]</td><td>100.0%</td><td>100.0%</td><td>100.0%</td><td>100.0%</td><td>100.0%</td><td>100.0%</td></tr><tr><td>FS + FDR[10%]</td><td>100.0%</td><td>99.71%</td><td>98.84%</td><td>99.54%</td><td>98.75%</td><td>98.33%</td></tr><tr><td>FS + FDR[20%]</td><td>100.0%</td><td>100.0%</td><td>99.23%</td><td>99.85%</td><td>99.87%</td><td>98.89%</td></tr><tr><td>FS +BC[topk = 5]</td><td>100.0%</td><td>100.0%</td><td>100.0%</td><td>100.0%</td><td>100.0%</td><td>100.0%</td></tr><tr><td>FS + BC[topk = 10]</td><td>100.0%</td><td>100.0%</td><td>100.0%</td><td>100.0%</td><td>100.0%</td><td>100.0%</td></tr></table>",
+        "bbox": [
+            176,
+            559,
+            820,
+            747
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "image",
+        "img_path": "images/198dee612d5cdc63ee02fcb729ec0a2fd31f55ddf925d97353d37ff12ee507bd.jpg",
+        "image_caption": [
+            "Figure 8: Yet another batch distribution on the toy dataset. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            215,
+            103,
+            784,
+            395
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "table",
+        "img_path": "images/2a566a85f88b5b15a7d4734f39bf4999233c5f778294a1ba3927f6050be29e24.jpg",
+        "table_caption": [
+            "Table 3: Performance of proposed methods on the dataset of Figure 8 "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=\"2\">Method</td><td colspan=\"6\">Sample accuracy on accumulated dataset after Batch</td></tr><tr><td>#1</td><td>#2</td><td>#3</td><td>#4</td><td>#5</td><td>#6</td></tr><tr><td>No Incremental Learning</td><td>100.0%</td><td>89.34%</td><td>93.80%</td><td>95.60%</td><td>97.81%</td><td>84.78%</td></tr><tr><td>Fisher Shut-off (FS)</td><td>100.0%</td><td>95.36%</td><td>99.59%</td><td>99.55%</td><td>99.36%</td><td>94.56%</td></tr><tr><td>Frac. Data Ret. (FDR)[10%]</td><td>100.0%</td><td>95.08%</td><td>96.07%</td><td>97.42%</td><td>99.61%</td><td>98.67%</td></tr><tr><td>FDR[20%]</td><td>100.0%</td><td>98.36%</td><td>98.97%</td><td>99.85%</td><td>100.0%</td><td>99.67%</td></tr><tr><td>Border Ctrl. (BC)[top k = 5]</td><td>100.0%</td><td>100.0%</td><td>99.79%</td><td>99.85%</td><td>100.0%</td><td>100.0%</td></tr><tr><td>BC[topk = 10]</td><td>100.0%</td><td>100.0%</td><td>100.0%</td><td>100.0%</td><td>99.74%</td><td>100.0%</td></tr><tr><td>FS + FDR[10%]</td><td>100.0%</td><td>95.36%</td><td>99.79%</td><td>98.48%</td><td>99.61%</td><td>98.89%</td></tr><tr><td>FS + FDR[20%]</td><td>100.0%</td><td>98.36%</td><td>99.79%</td><td>99.69%</td><td>100.0%</td><td>99.67%</td></tr><tr><td>FS+BC[topk = 5]</td><td>100.0%</td><td>100.0%</td><td>100.0%</td><td>100.0%</td><td>99.74%</td><td>100.0%</td></tr><tr><td>FS + BC[topk = 10]</td><td>100.0%</td><td>100.0%</td><td>100.0%</td><td>100.0%</td><td>100.0%</td><td>100.0%</td></tr></table>",
+        "bbox": [
+            176,
+            477,
+            821,
+            666
+        ],
+        "page_idx": 14
+    }
+]

parse/dev/edONMAnhLu-/edONMAnhLu-.md

@@ -0,0 +1,824 @@
+# SURROGATE GAP MINIMIZATIONIMPROVES SHARPNESS-AWARE TRAINING
+
+Juntang Zhuang1 ∗ j.zhuang@yale.edu
+
+Boqing Gong2, Liangzhe Yuan2, Yin $\mathbf { C } \mathbf { u } \mathbf { i } ^ { 2 }$ , Hartwig Adam2 {bgong, lzyuan, yincui, hadam}@google.com
+
+Nicha C. Dvornek1, Sekhar Tatikonda1, James S. Duncan1 {nicha.dvornek, sekhar.tatikonda, james.duncan}@yale.edu
+
+Ting Liu2liuti@google.com
+
+1 Yale University, 2 Google Research
+
+# ABSTRACT
+
+The recently proposed Sharpness-Aware Minimization (SAM) improves generalization by minimizing a perturbed loss defined as the maximum loss within a neighborhood in the parameter space. However, we show that both sharp and flat minima can have a low perturbed loss, implying that SAM does not always prefer flat minima. Instead, we define a surrogate gap, a measure equivalent to the dominant eigenvalue of Hessian at a local minimum when the radius of neighborhood (to derive the perturbed loss) is small. The surrogate gap is easy to compute and feasible for direct minimization during training. Based on the above observations, we propose Surrogate Gap Guided Sharpness-Aware Minimization (GSAM), a novel improvement over SAM with negligible computation overhead. Conceptually, GSAM consists of two steps: 1) a gradient descent like SAM to minimize the perturbed loss, and 2) an ascent step in the orthogonal direction (after gradient decomposition) to minimize the surrogate gap and yet not affect the perturbed loss. GSAM seeks a region with both small loss (by step 1) and low sharpness (by step 2), giving rise to a model with high generalization capabilities. Theoretically, we show the convergence of GSAM and provably better generalization than SAM. Empirically, GSAM consistently improves generalization (e.g., $+ 3 . 2 \%$ over SAM and $+ 5 . 4 \%$ over AdamW on ImageNet top-1 accuracy for ViT-B/32). Code is released at https://sites.google.com/view/gsam-iclr22/home.
+
+# 1 INTRODUCTION
+
+Modern neural networks are typically highly over-parameterized and easy to overfit to training data, yet the generalization performances on unseen data (test set) often suffer a gap from the training performance (Zhang et al., 2017a). Many studies try to understand the generalization of machine learning models, including the Bayesian perspective (McAllester, 1999; Neyshabur et al., 2017), the information perspective (Liang et al., 2019), the loss surface geometry perspective (Hochreiter & Schmidhuber, 1995; Jiang et al., 2019) and the kernel perspective (Jacot et al., 2018; Wei et al., 2019). Besides analyzing the properties of a model after training, some works study the influence of training and the optimization process, such as the implicit regularization of stochastic gradient descent (SGD) (Bottou, 2010; Zhou et al., 2020), the learning rate’s regularization effect (Li et al., 2019), and the influence of the batch size (Keskar et al., 2016).
+
+These studies have led to various modifications to the training process to improve generalization. Keskar & Socher (2017) proposed to use Adam in early training phases for fast convergence and then switch to SGD in late phases for better generalization. Izmailov et al. (2018) proposed to average weights to achieve a wider local minimum, which is expected to generalize better than sharp minima. A similar idea was later used in Lookahead (Zhang et al., 2019). Entropy-SGD (Chaudhari et al., 2019) derived the gradient of local entropy to avoid solutions in sharp valleys. Entropy-SGD has a nested Langevin iteration, inducing much higher computation costs than vanilla training.
+
+The recently proposed Sharpness-Aware Minimization (SAM) (Foret et al., 2020) is a generic training scheme that improves generalization and has been shown especially effective for Vision Transformers (Dosovitskiy et al., 2020) when large-scale pre-training is unavailable (Chen et al., 2021). Suppose vanilla training minimizes loss $f ( w )$ (e.g., the cross-entropy loss for classification), where $w$ is the parameter. SAM minimizes a perturbed loss defined as $f _ { p } ( w ) \triangleq \operatorname* { m a x } _ { | | \delta | | \leq \rho } f ( w + \delta )$ , which is the maximum loss within radius $\rho$ centered at the model parameter $w$ . Intuitively, vanilla training seeks a single point with a low loss, while SAM searches for a neighborhood within which the maximum loss is low. However, we show that a low perturbed loss $f _ { p }$ could appear in both flat and sharp minima, implying that only minimizing $f _ { p }$ is not always sharpness-aware.
+
+Although the perturbed loss $f _ { p } ( w )$ might disagree with sharpness, we find a surrogate gap defined as $h ( w ) \triangleq f _ { p } ( w ) - f ( w )$ agrees with sharpness — Lemma 3.3 shows that the surrogate gap $h$ is an equivalent measure of the dominant eigenvalue of Hessian at a local minimum. Inspired by this observation, we propose the Surrogate Gap Guided Sharpness Aware Minimization (GSAM) which jointly minimizes the perturbed loss $f _ { p }$ and the surrogate gap $h$ : a low perturbed loss $f _ { p }$ indicates a low training loss within the neighborhood, and a small surrogate gap $h$ avoids solutions in sharp valleys and hence narrows the generalization gap between training and test performances (Thm. 5.3). When both criteria are satisfied, we find a generalizable model with good performances.
+
+GSAM consists of two steps for each update: 1) descend gradient $\nabla f _ { p } ( w )$ to minimize the perturbed loss $f _ { p }$ (this step is exactly the same as SAM), and 2) decompose gradient $\nabla f ( w )$ of the original loss $\bar { f } ( w )$ into components that are parallel and orthogonal to $\nabla f _ { p } ( w )$ , i.e., $\nabla f ( w ) = \nabla _ { \| } f ( w ) +$ $\nabla _ { \perp } f ( w )$ , and perform an ascent step in $\nabla _ { \perp } f ( w )$ to minimize the surrogate gap $h ( w )$ . Note that this ascent step does not change the perturbed loss $f _ { p }$ because $\nabla f _ { \perp } ( w ) \perp \mathbf { \bar { \nabla } } \nabla f _ { p } ( \bar { w } )$ by construction.
+
+We summarize our contribution as follows:
+
+• We define surrogate gap, which measures the sharpness at local minima and is easy to compute. • We propose the GSAM method to improve the generalization of neural networks. GSAM is widely applicable and incurs negligible computation overhead compared to SAM. • We demonstrate the convergence of GSAM and its provably better generalization than SAM. • We empirically validate GSAM over image classification tasks with various neural architectures, including ResNets (He et al., 2016), Vision Transformers (Dosovitskiy et al., 2020), and MLP-Mixers (Tolstikhin et al., 2021).
+
+# 2 PRELIMINARIES
+
+# 2.1 NOTATIONS
+
+• $f ( w )$ : A loss function $f$ with parameter $w \in \mathbb { R } ^ { k }$ , where $k$ is the parameter dimension.
+
+• $\rho _ { t } \in \mathbb { R }$ : A scalar value controlling the amplitude of perturbation at step $t$ • $\epsilon \in \mathbb { R }$ : A small positive constant (to avoid division by $) , \epsilon = 1 0 ^ { - 1 2 }$ by default).
+
+• $\begin{array} { r } { w _ { t } ^ { a d v } \triangleq w _ { t } + \rho _ { t } \frac { \nabla f ( w _ { t } ) } { | | \nabla f ( w _ { t } ) | | + \epsilon } } \end{array}$ : The solution to $\operatorname* { m a x } _ { | | w ^ { \prime } - w _ { t } | | \leq \rho _ { t } } f ( w ^ { \prime } )$ when $\rho _ { t }$ is small.
+
+• $\begin{array} { r } { f _ { p } ( w _ { t } ) \triangleq \operatorname* { m a x } _ { | | \delta | | \leq \rho _ { t } } f ( w _ { t } + \delta ) \approx f ( w _ { t } ^ { a d v } ) } \end{array}$ : The perturbed loss induced by $f ( w _ { t } )$ . For each $w _ { t }$ , $f _ { p } ( w _ { t } )$ returns the worst possible loss $f$ within a ball of radius $\rho _ { t }$ centered at $w _ { t }$ . When $\rho _ { t }$ is small, by Taylor expansion, the solution to the maximization problem is equivalent to a gradient ascent from $w _ { t }$ to $w _ { t } ^ { a d v }$ .
+
+• $h ( w ) \triangleq f _ { p } ( w ) - f ( w )$ : The surrogate gap defined as the difference between $f _ { p } ( w )$ and $f ( w )$
+
+• $\eta _ { t } \in \mathbb { R }$ : Learning rate at step $t$ .
+
+• $\alpha \in \mathbb { R }$ : A constant value that controls the scaled learning rate of the ascent step in GSAM.
+
+$g ^ { ( t ) } , g _ { p } ^ { ( t ) } \in \mathbb { R } ^ { k }$ : At the $t$ -th step, the noisy observation of the gradients $\nabla f ( w _ { t } )$ , $\nabla f _ { p } ( w _ { t } )$ of the original loss and perturbed loss, respectively.
+
+![](images/3396788a9126ef1da5043f16c4c9713656da2cf3b5a9e09a6b9971d5556bacff.jpg)
+
+Figure 1: Consider original loss $f$ (solid line), perturbed loss $\begin{array} { r } { f _ { p } \triangleq \operatorname* { m a x } _ { | | \delta | | \leq \rho } f ( w + \delta ) } \end{array}$ (dashed line), and surrogate gap $h ( w ) \triangleq f _ { p } ( w ) - f ( w )$ . Intuitively, $f _ { p }$ is approximately a max-pooled version of $f$ with a pooling kernel of width $2 \rho$ , and SAM minimizes $f _ { p }$ . From left to right are the local minima centered at $w _ { 1 } , w _ { 2 } , w _ { 3 }$ , and the valleys become flatter. Since $f _ { p } ( w _ { 1 } ) = f _ { p } ( w _ { 3 } ) < f _ { p } ( w _ { 2 } )$ , SAM prefers $w _ { 1 }$ and $w _ { 3 }$ to $w _ { 2 }$ . However, a low $f _ { p }$ could appear in both sharp $( w _ { 1 } )$ and flat $( w _ { 3 } )$ minima, so $f _ { p }$ might disagree with sharpness. On the contrary, a smaller surrogate gap $h$ indicates a flatter loss surface (Lemma 3.3). From $w _ { 1 }$ to $w _ { 3 }$ , the loss surface is flatter, and $h$ is smaller.
+
+• $\nabla f ( w _ { t } ) = \nabla f _ { \parallel } ( w _ { t } ) + \nabla f _ { \perp } ( w _ { t } )$ : Decompose $\nabla f ( w _ { t } )$ into parallel component $\nabla f _ { \parallel } ( \boldsymbol { w } _ { t } )$ and vertical component $\nabla f _ { \perp } ( w _ { t } )$ by projection $\nabla f ( w _ { t } )$ onto $\nabla f _ { p } ( w _ { t } )$ .
+
+# 2.2 SHARPNESS-AWARE MINIMIZATION
+
+Conventional optimization of neural networks typically minimizes the training loss $f ( w )$ by gradient descent w.r.t. $\nabla f ( w )$ and searches for a single point $w$ with a low loss. However, this vanilla training often falls into a sharp valley of the loss surface, resulting in inferior generalization performance (Chaudhari et al., 2019). Instead of searching for a single point solution, SAM seeks a region with low losses so that small perturbation to the model weights does not cause significant performance degradation. SAM formulates the problem as:
+
+$$
+\begin{array} { r } { \operatorname* { m i n } _ { w } f _ { p } ( w ) \mathrm { { w h e r e } } f _ { p } ( w ) \triangleq \operatorname* { m a x } _ { | | \delta | | \leq \rho } f ( w + \delta ) } \end{array}
+$$
+
+where $\rho$ is a predefined constant controlling the radius of a neighborhood. This perturbed loss $f _ { p }$ induced by $f ( w )$ is the maximum loss within the neighborhood. When the perturbed loss is minimized, the neighborhood corresponds to low losses (below the perturbed loss). For a small $\rho$ , using Taylor expansion around $w$ , the inner maximization in Eq. 1 turns into a linear constrained optimization with solution
+
+$$
+\arg \operatorname* { m a x } _ { | | \delta | | \leq \rho } f ( w + \delta ) = \arg \operatorname* { m a x } _ { | | \delta | | \leq \rho } f ( w ) + \delta ^ { \top } \nabla f ( w ) + O ( \rho ^ { 2 } ) = \rho \frac { \nabla f ( w ) } { | | \nabla f ( w ) | | }
+$$
+
+As a result, the optimization problem of SAM reduces to
+
+$$
+\operatorname* { m i n } _ { w } f _ { p } ( w ) \approx \operatorname* { m i n } _ { w } f ( w ^ { a d v } ) { \mathrm { ~ w h e r e ~ } } w ^ { a d v } \triangleq w + \rho { \frac { \nabla f ( w ) } { | | \nabla f ( w ) | | + \epsilon } }
+$$
+
+where $\epsilon$ is a scalar (default: 1e-12) to avoid division by 0, and $w ^ { a d v }$ is the “perturbed weight” with the highest loss within the neighborhood. Equivalently, SAM seeks a solution on the surface of the perturbed loss $f _ { p } ( w )$ rather than the original loss $f ( w )$ (Foret et al., 2020).
+
+# 3 THE SURROGATE GAP MEASURES THE SHARPNESS AT A LOCAL MINIMUM
+
+# 3.1 THE PERTURBED LOSS IS NOT ALWAYS SHARPNESS-AWARE
+
+Despite that SAM searches for a region of low losses, we show that a solution by SAM is not guaranteed to be flat. Throughout this paper we measure the sharpness at a local minimum of loss $f ( w )$ by the dominant eigenvalue $\sigma _ { m a x }$ (eigenvalue with the largest absolute value) of Hessian. For simplicity, we do not consider the influence of reparameterization on the geometry of loss surfaces, which is thoroughly discussed in (Laurent & Massart, 2000; Kwon et al., 2021).
+
+For $t = 1$ to $T$ 0) ρt schedule: ρt = ρmin + (ρmax−ρmin)(lr−lrmin)lr −lr ∇f (t) 1a) ∆wt = ρt ||∇f (t)||+ 1b) $w _ { t } ^ { a d v } = w _ { t } + \Delta w _ { t }$ 2) Get $\nabla f _ { p } ^ { ( t ) }$ by back-propagation at $w _ { t } ^ { a d v }$ . 3) $\begin{array} { r l r } { \mathrm { ~ } } & { { } } & { = \nabla f _ { \parallel } ^ { ( t ) } + \nabla f _ { \perp } ^ { ( t ) } } \end{array}$ Decompose $\nabla f ^ { ( t ) }$ into compo  
+nents that are parallel and orthogonal to $\nabla f _ { p } ^ { ( t ) }$ .
+
+![](images/872b59aec8a7a8aaa3e5f73fed10c4e224fe6b0af656dfe3a11efa43b6098e4f.jpg)  
+Figure 2: $\nabla f$ is decomposed into parallel and vertical $( \nabla f _ { \perp } )$ components by projection onto $\nabla f _ { p }$ . $\mathsf { \bar { V } } f ^ { G S A M } = \mathsf { \bar { V } } \bar { f } _ { p } - \alpha \nabla f _ { \perp }$
+
+# Algorithm 1 GSAM Algorithm
+
+4) Update weights:
+
+Vanilla $\begin{array} { r l } & { w _ { t + 1 } = w _ { t } - \eta _ { t } } \\ & { w _ { t + 1 } = w _ { t } - \eta _ { t } \nabla f _ { p } ^ { ( t ) } } \\ & { w _ { t + 1 } = w _ { t } - \eta _ { t } \big ( \nabla f _ { p } ^ { ( t ) } - \alpha \nabla f _ { \bot } ^ { ( t ) } \big ) } \end{array}$   
+SAM   
+GSAM
+
+Lemma 3.1. For some fixed $\rho _ { ; }$ , consider two local minima $w _ { 1 }$ and $w _ { 2 }$ , $f _ { p } ( w _ { 1 } ) \leq f _ { p } ( w _ { 2 } ) \neq$ $\sigma _ { m a x } ( w _ { 1 } ) \leq \sigma _ { m a x } ( w _ { 2 } )$ , where $\sigma _ { m a x }$ is the dominant eigenvalue of the Hessian.
+
+We leave the proof to Appendix. Fig. 1 illustrates Lemma 3.1 with an example. Consider three local minima denoted as $w _ { 1 }$ to $w _ { 3 }$ , and suppose the corresponding loss surfaces are flatter from $w _ { 1 }$ to $w _ { 3 }$ . For some fixed $\rho$ , we plot the perturbed loss $f _ { p }$ and surrogate gap $h \triangleq f _ { p } - f$ around each solution. Comparing $w _ { 2 }$ with $w _ { 3 }$ : Suppose their vanilla losses are equal, $f ( \tilde { w _ { 2 } } ) = f ( w _ { 3 } )$ , then $f _ { p } ( w _ { 2 } ) > f _ { p } ( \bar { w } _ { 3 } )$ because the loss surface is flatter around $w _ { 3 }$ , implying that SAM will prefer $w _ { 3 }$ to $w _ { 2 }$ . Comparing $w _ { 1 }$ and $w _ { 2 }$ : $f _ { p } ( w _ { 1 } ) < f _ { p } ( w _ { 2 } )$ , and SAM will favor $w _ { 1 }$ over $w _ { 2 }$ because it only cares about the perturbed loss $f _ { p }$ , even though the loss surface is sharper around $w _ { 1 }$ than $w _ { 2 }$ .
+
+# 3.2 THE SURROGATE GAP AGREES WITH SHARPNESS
+
+We introduce the surrogate gap that agrees with sharpness, defined as:
+
+$$
+\begin{array} { r } { h ( w ) \triangleq \operatorname* { m a x } _ { | | \delta | | \leq \rho } f ( w + \delta ) - f ( w ) \approx f ( w ^ { a d v } ) - f ( w ) } \end{array}
+$$
+
+Intuitively, the surrogate gap represents the difference between the maximum loss within the neighborhood and the loss at the center point. The surrogate gap has the following properties.
+
+Lemma 3.2. Suppose the perturbation amplitude $\rho$ is sufficiently small, then the approximation to the surrogate gap in Eq. 4 is always non-negative, $h ( w ) \approx f ( w ^ { a d v } ) - f ( w ) \geq 0 , \forall w$ .
+
+Lemma 3.3. For a local minimum $w ^ { * }$ , consider the dominate eigenvalue $\sigma _ { m a x }$ of the Hessian of loss $f$ as a measure of sharpness. Considering the neighborhood centered at $w ^ { * }$ with a small radius $\rho$ , the surrogate gap $h ( w ^ { * } )$ is an equivalent measure of the sharpness: $\sigma _ { m a x } \approx 2 h ( w ^ { * } ) / \rho ^ { 2 }$ .
+
+The proof is in Appendix. Lemma 3.2 tells that the surrogate gap is non-negative, and Lemma 3.3 shows that the loss surface is flatter as $h$ gets closer to 0. The two lemmas together indicate that we can find a region with a flat loss surface by minimizing the surrogate gap $h ( w )$ .
+
+# 4 SURROGATE GAP GUIDED SHARPNESS-AWARE MINIMIZATION
+
+4.1 GENERAL IDEA: SIMULTANEOUSLY MINIMIZE THE PERTURBED LOSS AND SURROGATE GAP
+
+Inspired by the analysis in Section 3, we propose Surrogate Gap Guided Sharpness-Aware Minimzation (GSAM) to simultaneously minimize two objectives, the perturbed loss $f _ { p }$ and the surrogate gap $h$ :
+
+$$
+\operatorname* { m i n } _ { w } \left( f _ { p } ( w ) , h ( w ) \right)
+$$
+
+Intuitively, by minimizng $f _ { p }$ we search for a region with a low perturbed loss similar to SAM, and by minimizing $h$ we search for a local minimum with a flat surface. A low perturbed loss implies low training losses within the neighborhood, and a flat loss surface reduces the generalization gap between training and test performances (Chaudhari et al., 2019). When both are minimized, the solution gives rise to high accuracy and good generalization.
+
+Potential caveat in optimization It is tempting and yet sub-optimal to combine the objectives in Eq. 5 to arrive at $\mathrm { m i n } _ { w }$ $f _ { p } ( w ) + \lambda h ( w )$ , where $\lambda$ is some positive scalar. One caveat when solving this weighted combination is the potential conflict between the gradients of the two terms, i.e., $\nabla f _ { p } ( w )$ and $\overline { { \nabla } h } ( \boldsymbol { w } )$ . We illustrate this conflict by Fig. 2, where $\bar { \nabla } h ( w ) = \nabla f _ { p } ( w ) - \nabla f ( w )$ (the grey dashed arrow) has a negative inner product with $\nabla f _ { p } ( w )$ and $\nabla f ( w )$ . Hence, the gradient descent for the surrogate gap could potentially increase the loss $f _ { p }$ , harming the model’s performance. We empirically validate this argument in Sec. 6.4.
+
+# 4.2 GRADIENT DECOMPOSITION AND ASCENT FOR THE MULTI-OBJECTIVE OPTIMIZATION
+
+Our primary goal is to minimize $f _ { p }$ because otherwise a flat solution of high loss is meaningless, and the minimization of $h$ should not increase $f _ { p }$ . We propose to decompose $\nabla f ( w _ { t } )$ and $\nabla h$ into components that are parallel and orthogonal to $\dot { \nabla } f _ { p } ( \boldsymbol { w } _ { t } )$ , respectively (see Fig. 2):
+
+$$
+\begin{array} { r l } & { \nabla f ( w _ { t } ) = \nabla f _ { \parallel } ( w _ { t } ) + \nabla f _ { \perp } ( w _ { t } ) } \\ & { \nabla h ( w _ { t } ) = \nabla h _ { \parallel } ( w _ { t } ) + \nabla h _ { \perp } ( w _ { t } ) } \\ & { \nabla h _ { \perp } ( w _ { t } ) = - \nabla f _ { \perp } ( w _ { t } ) } \end{array}
+$$
+
+The key is that updating in the direction of $\nabla h _ { \perp } ( w _ { t } )$ does not change the value of the perturbed loss $f _ { p } ( w _ { t } )$ because $\nabla h _ { \perp } \perp \nabla f _ { p }$ by construction. Therefore, we propose to perform a descent step in the $\nabla h _ { \perp } ( w _ { t } )$ direction, which is equivalent to an ascent step in the $\nabla f _ { \perp } ( w _ { t } )$ direction (because $\nabla h _ { \perp } = - \nabla f _ { \perp }$ by the definition of $h$ ), and achieve two goals simultaneously — it keeps the value of $f _ { p } ( w _ { t } )$ intact and meanwhile decreases the surrogate gap $h ( w _ { t } ) = f _ { p } ( w _ { t } ) - f ( w _ { t } )$ (by increasing $f ( w _ { t } )$ and not affect $f _ { p } ( w _ { t } ) )$ ).
+
+The full GSAM Algorithm is shown in Algo. 1 and Fig. 2, where $g ^ { ( t ) } , g _ { p } ^ { ( t ) }$ are noisy observations of $\nabla f ( w _ { t } )$ and $\nabla f _ { p } ( w _ { t } )$ , respectively, and $g _ { \parallel } ^ { ( t ) } , g _ { \perp } ^ { ( t ) }$ are noisy observations of $\nabla f _ { \parallel } ( w _ { t } )$ and $\nabla f _ { \perp } ( w _ { t } )$ , respectively, by projecting $g ^ { ( t ) }$ onto $g _ { p } ^ { ( t ) }$ . We introduce a constant $\alpha$ to scale the stepsize of the ascent step. Steps 1) to 2) are the same as SAM: At current point $w _ { t }$ , step 1) takes a gradient ascent to $w _ { t } ^ { a d v }$ followed by step 2) evaluating the gradient $g _ { p } ^ { ( t ) }$ at $w _ { t } ^ { a d v }$ . Step 3) projects $g ^ { ( t ) }$ onto $g _ { p } ^ { ( t ) }$ , which requires negligible computation compared to the forward and backward passes. In step 4), $- \eta _ { t } g _ { p } ^ { ( t ) }$ is the same as in SAM and minimizes the perturbed loss $f _ { p } ( w _ { t } )$ with gradient descent, and αηtg(t)⊥ performs an ascent step in the orthogonal direction of $g _ { p } ^ { ( t ) }$ to minimize the surrogate gap $h ( w _ { t } )$ ( equivalently increase $f ( w _ { t } )$ and keep $f _ { p } ( w _ { t } )$ intact). In coding, GSAM feeds the “surrogate gradient” ∇fGSAMt , g $\nabla f _ { t } ^ { G S A M } \triangleq g _ { p } ^ { ( t ) } - \alpha g _ { \perp } ^ { ( t ) }$ to first-order gradient optimizers such as SGD and Adam.
+
+The ascent step along $g _ { \perp } ^ { ( t ) }$ does not harm convergence SAM demonstrates that minimizing $f _ { p }$ makes the network generalize better than minimizing $f$ . Even though our ascent step along $g _ { \perp } ^ { ( t ) }$ increases $f ( w )$ , it does not affect $f _ { p } ( w )$ , so GSAM still decreases the perturbed loss $f _ { p }$ in a way similar to SAM. In Thm. 5.1, we formally prove the convergence of GSAM. In Sec. 6 and Appendix C, we empirically validate that the loss decreases and accuracy increases with training.
+
+Illustration with a toy example We demonstrate different algorithms by a numerical toy example shown in Fig. 3. The trajectory of GSAM is closer to the ridge and tends to find a flat minimum. Intuitively, since the loss surface is smoother along the ridge than in sharp local minima, the surrogate gap $h ( w )$ is small near the ridge, and the ascent step in GSAM minimizes $h$ to pushes the trajectory closer to the ridge. More concretely, $\nabla f ( w _ { t } )$ points to a sharp local solution and deviates from the ridge; in contrast, $w _ { t } ^ { a d v }$ is closer to the ridge and $\nabla f ( w _ { t } ^ { a d v } )$ is closer to the ridge descent direction than $\nabla f ( w _ { t } )$ . Note that $\nabla f _ { t } ^ { G S A M }$ and $\nabla f ( w _ { t } )$ always lie at different sides of $\nabla f _ { p } ( w _ { t } )$ by construction (see Fig. 2), hence $\nabla f _ { t } ^ { G S A M }$ pushes the trajectory closer to the ridge than $\nabla f _ { p } ( w _ { t } )$ does. The trajectory of GSAM is like descent along the ridge and tends to find flat minima.
+
+![](images/64c1996c768babc0d124bb80d0862cf1e6d992f4b1b70cc711ed289334144e3d.jpg)  
+Figure 3: Consider the loss surface with a few sharp local minima. Left: Overview of the procedures of SGD, SAM and GSAM. SGD takes a descent step at $w _ { t }$ using $\nabla f ( w _ { t } )$ (orange), which points to a sharp local minima. SAM first performs gradient ascent in the direction of $\nabla f ( w _ { t } )$ to reach $w _ { t } ^ { a d v }$ with a higher loss, followed by descent with gradient $\nabla f ( w _ { t } ^ { a d v } )$ (green) at the perturbed weight. Based on $\nabla f ( w _ { t } )$ and $\nabla f ( w _ { t } ^ { a d v } )$ , GSAM updates in a new direction (red) that points to a flatter region. Right: Trajectories by different methods. SGD and SAM fall into different sharp local minima, while GSAM reaches a flat region. A video is in the supplement for better visualization.
+
+# 5 THEORETICAL PROPERTIES OF GSAM
+
+# 5.1 CONVERGENCE DURING TRAINING
+
+Theorem 5.1. Consider a non-convex function $f ( w )$ with Lipschitz-smooth constant $L$ and lower bound $f _ { m i n }$ . Suppose we can access a noisy, bounded observation $g ^ { ( t ) } \ ( \vert \vert g ^ { ( t ) } \vert \vert _ { 2 } \leq G , \forall t )$ of the true gradient $\nabla f ( w _ { t } )$ at the $t$ -th step. For some constant $\alpha$ , with learning rate $\eta _ { t } = \eta _ { 0 } / \sqrt { t }$ , and perturbation amplitude $\rho _ { t }$ proportional to the learning rate, e.g., $\rho _ { t } = \rho _ { 0 } / \sqrt { t }$ , we have
+
+$$
+\frac { 1 } { T } \sum _ { t = 1 } ^ { T } \mathbb { E } \Big | \Big | \nabla f _ { p } ( w _ { t } ) \Big | \Big | _ { 2 } ^ { 2 } \leq \frac { C _ { 1 } + C _ { 2 } \log T } { \sqrt { T } } , \quad \frac { 1 } { T } \sum _ { t = 1 } ^ { T } \mathbb { E } \Big | \Big | \nabla f ( w _ { t } ) \Big | \Big | _ { 2 } ^ { 2 } \leq \frac { C _ { 3 } + C _ { 4 } \log T } { \sqrt { T } }
+$$
+
+where $C _ { 1 } , C _ { 2 } , C _ { 3 } , C _ { 4 }$ are some constants.
+
+Thm. 5.1 implies both $f _ { p }$ and $f$ converge in GSAM at rate $O ( \log T / \sqrt { T } )$ for non-convex stochastic optimization, matching the convergence rate of first-order gradient optimizers like Adam.
+
+# 5.2 GENERALIZATION OF GSAM
+
+In this section, we show the surrogate gap in GSAM is provably lower than SAM’s, so GSAM is expected to find a smoother minimum with better generalization.
+
+Theorem 5.2 (PAC-Bayesian Theorem (McAllester, 2003)). Suppose the training set has m elements drawn i.i.d. from the true distribution, and denote the loss on the training set as ${ \widehat { f } } ( w ) =$ Pmi=1 f (w, xi), where we use xi to denote the (input, target) pair of the i-th element. Let w be learned from the training set. Suppose $w$ is drawn from posterior distribution $\mathcal { Q } .$ Denote the prior distribution (independent of training) as $\mathcal { P }$ , then
+
+$$
+\mathbb { E } _ { w \sim Q } \mathbb { E } _ { x } f ( w , x ) \le \mathbb { E } _ { w \sim Q } \widehat { f } ( w ) + 4 \sqrt { \Big ( K L ( Q | | \mathcal { P } ) + \log \frac { 2 m } { a } \Big ) / m } w i t h \ p r o b a b i l i t y \ a t \ l e a s t 1 - a
+$$
+
+Corollary 5.2.1. Suppose perturbation $\delta$ is drawn from distribution $\delta \sim \mathcal { N } ( 0 , b ^ { 2 } I ^ { k } ) , \delta \in \mathbb { R } ^ { k }$ , $k$ is the dimension of $w$ , then with probability at least $\left( 1 - a \right) \left[ 1 - e ^ { - \left( \frac { \rho } { \sqrt { 2 } b } - \sqrt { k } \right) ^ { 2 } } \right]$
+
+$$
+\begin{array} { r l } & { \mathbb { E } _ { w \sim Q } \mathbb { E } _ { x } f ( w , x ) \le \widehat { h } + C + 4 \sqrt { \Big ( K L ( Q | \mathcal { P } ) + \log \frac { 2 m } { a } \Big ) / m } } \\ & { \widehat { h } \triangleq \operatorname* { m a x } _ { | | \delta | | _ { 2 } \le \rho } \widehat { f } ( w + \delta ) - \widehat { f } ( w ) = \displaystyle \frac { 1 } { m } \sum _ { i = 1 } ^ { m } \Big [ \operatorname* { m a x } _ { | | \delta | | _ { 2 } \le \rho } f ( w + \delta , x _ { i } ) - f ( w , x _ { i } ) \Big ] } \end{array}
+$$
+
+where $C = { \widehat { f } } ( w )$ is the empirical training loss, and $\widehat { h }$ is the surrogate gap evaluated on the training set.
+
+Corollary 5.2.1 implies that minimizing $\widehat { h }$ (right hand side of Eq. 7) is expected to achieve a tighter upper bound of the generalization performance (left hand side of Eq. 7). The third term on the right of Eq. 7 is typically hard to analyze and often simplified to $L 2$ regularization (Foret et al., 2020). Note that $f _ { p } = C + \widehat { h }$ only holds when $\rho _ { t r a i n }$ (the perturbation amplitude specified by users during training) equals $\rho _ { t r u e }$ (the ground truth value determined by underlying data distribution); when $\rho _ { t r a i n } \neq \rho _ { t r u e }$ , $m i n ( f _ { p } , \widehat { h } )$ is more effective than $m i n ( f _ { p } )$ in terms of minimizing generalization loss. A detailed discussion is in Appendix A.7.
+
+Theorem 5.3 (Unlike SAM, GSAM decreases the surrogate gap). Under the assumption in Thm. 5.1, Thm. 5.2 and Corollary 5.2.1, we assume the Hessian has a lower-bound $| \sigma | _ { m i n }$ on the absolute value of eigenvalue, and the variance of noisy observation $g ^ { ( t ) }$ is lower-bounded by $c ^ { 2 }$ . The surrogate gap h can be minimized by the ascent step along the orthogonal direction $g _ { \perp } ^ { ( t ) }$ . During training we minimize the sample estimate of $h$ . We use $\Delta \widehat { h } _ { t }$ to denote the amount that the ascent step in GSAM decreases $\widehat { h }$ for the $t$ -th step. Compared to SAM, the proposed method generates a total decrease in surrogate gap $\Sigma _ { t = 1 } ^ { T } \Delta \widehat { h } _ { t }$ , which is bounded by
+
+$$
+\frac { \alpha c ^ { 2 } \rho _ { 0 } ^ { 2 } \eta _ { 0 } | \sigma | _ { m i n } ^ { 2 } } { G ^ { 2 } } \le \operatorname* { l i m } _ { T \to \infty } \sum _ { t = 1 } ^ { T } \Delta \widehat { h } _ { t } \le 2 . 7 \alpha L ^ { 2 } \eta _ { 0 } \rho _ { 0 } ^ { 2 }
+$$
+
+We provide proof in the appendix. The lower-bound of provably non-trivial decrease in the surrogate gap. Com $\Sigma _ { t = 1 } ^ { T } \Delta \widehat { h } _ { t }$ indicates that GSAM achieves aCorollary 5.2.1, GSAM provably improves the generalization performance over SAM.
+
+# 6 EXPERIMENTS
+
+# 6.1 GSAM IMPROVES TEST PERFORMANCE ON VARIOUS MODEL ARCHITECTURES
+
+We conduct experiments with ResNets (He et al., 2016), Vision Transformers (ViTs) (Dosovitskiy et al., 2020) and MLP-Mixers (Tolstikhin et al., 2021). Following the settings by Chen et al. (2021), we train on the ImageNet-1k (Deng et al., 2009) training set using the Inception-style (Szegedy et al., 2015) pre-processing without extra training data or strong augmentation. For all models, we search for the best learning rate and weight decay for vanilla training, and then use the same values for the experiments with SAM and GSAM. For ResNets, we search for $\rho$ from 0.01 to 0.05 with a stepsize 0.01. For ViTs and Mixers, we search for $\rho$ from 0.05 to 0.6 with a stepsize 0.05. In GSAM, we search for $\alpha$ in $\{ 0 . 0 1 , 0 . 0 2 , 0 . 0 3 \}$ for ResNets and $\alpha$ in $\{ 0 . 1 , 0 . 2 , 0 . 3 \}$ for ViTs and Mixers. Considering that each step in SAM and GSAM requires twice the computation of vanilla training, we experiment with the vanilla training for twice the epochs of SAM and GSAM, but we observe no significant improvements from the longer training (Table 5 in appendix). We summarize the best hyper-parameters for each model in Appendix B.
+
+We report the performances on ImageNet (Deng et al., 2009), ImageNet-v2 (Recht et al., 2019) and ImageNet-Real (Beyer et al., 2020) in Table 1. GSAM consistently improves over SAM and vanilla training (with SGD or AdamW): on ViT-B/32, GSAM achieves $+ 5 . 4 \%$ improvement over AdamW and $+ 3 . 2 \%$ over SAM in top-1 accuracy; on Mixer-B/32, GSAM achieves $+ 1 1 . 1 \%$ over AdamW and $+ 1 . 2 \%$ over SAM. We ignore the standard deviation since it is typically negligible $( < 0 . 1 \% )$ compared to the improvements. We also test the generalization performance on out-of-distribution data (ImageNet-R and ImageNet-C), and the observation is consistent with that on ImageNet, e.g., $+ 5 . 1 \%$ on ImageNet-R and $+ 5 . 9 \%$ on ImageNet-C for Mixer-B/32.
+
+# 6.2 GSAM FINDS A MINIMUM WHOSE HESSIAN HAS SMALL DOMINANT EIGENVALUES
+
+Lemma 3.3 indicates that the surrogate gap $h$ is an equivalent measure of the dominant eigenvalue of the Hessian, and minimizing $h$ equivalently searches for a flat minimum. We empirically validate this in Fig. 4. As shown in the left subfigure, for some fixed $\rho$ , increasing $\alpha$ decreases the dominant value and improves generalization (test accuracy). In the middle subfigure, we plot the dominant eigenvalues estimated by the surrogate gap, $\sigma _ { m a x } \approx 2 h / \rho ^ { 2 }$ (Lemma 3.3). In the right subfigure, we directly calculate the dominant eigenvalues using the power-iteration (Mises & Pollaczek-Geiringer, 1929). The estimated dominant eigenvalues (middle) match the real eigenvalues $\sigma _ { m a x }$ (right) in terms of the trend that $\sigma _ { m a x }$ decreases with $\alpha$ and $\rho$ . Note that the surrogate gap $h$ is derived over the whole training set, while the measured eigenvalues are over a subset to save computation. These results show that the ascent step in GSAM minimizes the dominant eigenvalue by minimizing the surrogate loss, validating $\mathrm { T h m } 5 . 3$ .
+
+Table 1: Top-1 Accuracy $( \% )$ on ImageNet datasets for ResNets, ViTs and MLP-Mixers trained with Vanilla SGD or AdamW, SAM, and GSAM optimizers.   
+
+<table><tr><td>Model</td><td>Training</td><td>ImageNet-v1</td><td>ImageNet-Real</td><td>ImageNet-V2</td><td>ImageNet-R</td><td>ImageNet-C</td></tr><tr><td colspan="7">ResNet</td></tr><tr><td rowspan="3">ResNet50</td><td>Vanilla (SGD)</td><td>76.0</td><td>82.4</td><td>63.6</td><td>22.2</td><td>44.6</td></tr><tr><td>SAM</td><td>76.9</td><td>83.3</td><td>64.4</td><td>23.8</td><td>46.5</td></tr><tr><td>GSAM</td><td>77.2</td><td>83.9</td><td>64.6</td><td>23.6</td><td>47.6</td></tr><tr><td rowspan="3">ResNet101</td><td>Vanilla (SGD)</td><td>77.8</td><td>83.9</td><td>65.3</td><td>24.4</td><td>48.5</td></tr><tr><td>SAM</td><td>78.6</td><td>84.8</td><td>66.7</td><td>25.9</td><td>51.3</td></tr><tr><td>GSAM</td><td>78.9</td><td>85.2</td><td>67.3</td><td>26.3</td><td>51.8</td></tr><tr><td rowspan="3">ResNet152</td><td>Vanilla (SGD)</td><td>78.5</td><td>84.2</td><td>66.3</td><td>25.3</td><td>50.0</td></tr><tr><td>SAM</td><td>79.3</td><td>84.9</td><td>67.3</td><td>25.7</td><td>52.2</td></tr><tr><td>GSAM</td><td>80.0</td><td>85.9</td><td>68.6</td><td>27.3</td><td>54.1</td></tr><tr><td colspan="7"></td></tr><tr><td rowspan="3">ViT-S/32</td><td>Vanilla (AdamW)</td><td>68.4</td><td>Vision Transformer 75.2</td><td>54.3</td><td></td><td></td></tr><tr><td>SAM</td><td>70.5</td><td>77.5</td><td>56.9</td><td>19.0 21.4</td><td>43.3</td></tr><tr><td>GSAM</td><td>73.8</td><td>80.4</td><td>60.4</td><td>22.5</td><td>46.2 48.2</td></tr><tr><td rowspan="3">ViT-S/16</td><td>Vanilla (AdamW)</td><td>74.4</td><td>80.4</td><td>61.7</td><td>20.0</td><td>46.5</td></tr><tr><td>SAM</td><td>78.1</td><td>84.1</td><td>65.6</td><td>24.7</td><td>53.0</td></tr><tr><td>GSAM</td><td>79.5</td><td>85.3</td><td>67.3</td><td>25.3</td><td>53.3</td></tr><tr><td rowspan="3">ViT-B/32</td><td>Vanilla (AdamW)</td><td>71.4</td><td>77.5</td><td>57.5</td><td>23.4</td><td>44.0</td></tr><tr><td>SAM</td><td>73.6</td><td>80.3</td><td>60.0</td><td>24.0</td><td>50.7</td></tr><tr><td>GSAM</td><td>76.8</td><td>82.7</td><td>63.0</td><td>25.1</td><td>51.7</td></tr><tr><td rowspan="3">ViT-B/16</td><td>Vanilla (AdamW)</td><td>74.6</td><td>79.8</td><td>61.3</td><td>20.1</td><td>46.6</td></tr><tr><td>SAM</td><td>79.9</td><td>85.2</td><td>67.5</td><td>26.4</td><td>56.5</td></tr><tr><td>GSAM</td><td>81.0</td><td>86.5</td><td>69.2</td><td>27.1</td><td>55.7</td></tr><tr><td colspan="7"></td></tr><tr><td rowspan="3">Mixer-S/32</td><td>Vanilla (AdamW)</td><td>63.9</td><td>MLP-Mixer 70.3</td><td>49.5</td><td>16.9</td><td>35.2</td></tr><tr><td>SAM</td><td>66.7</td><td>73.8</td><td>52.4</td><td>18.6</td><td>39.3</td></tr><tr><td>GSAM</td><td>68.6</td><td>75.8</td><td>55.0</td><td>22.6</td><td>44.6</td></tr><tr><td rowspan="3">Mixer-S/16</td><td>Vanilla (AdamW)</td><td>68.8</td><td>75.1</td><td>54.8</td><td>15.9</td><td>35.6</td></tr><tr><td>SAM</td><td>72.9</td><td>79.8</td><td>58.9</td><td>20.1</td><td>42.0</td></tr><tr><td>GSAM</td><td>75.0</td><td>81.7</td><td>61.9</td><td>23.7</td><td>48.5</td></tr><tr><td rowspan="3">Mixer-S/8</td><td>Vanilla (AdamW)</td><td>70.2</td><td>76.2</td><td>56.1</td><td>15.4</td><td>34.6</td></tr><tr><td>SAM</td><td>75.9</td><td>82.5</td><td>62.3</td><td>20.5</td><td>42.4</td></tr><tr><td>GSAM</td><td>76.8</td><td>83.4</td><td>64.0</td><td>24.6</td><td>47.8</td></tr><tr><td rowspan="3">Mixer-B/32</td><td>Vanilla (AdamW)</td><td>62.5</td><td>68.1</td><td>47.6</td><td>14.6</td><td>33.8</td></tr><tr><td>SAM</td><td>72.4</td><td>79.0</td><td>58.0</td><td>22.8</td><td>46.2</td></tr><tr><td>GSAM</td><td>73.6</td><td>80.2</td><td>59.9</td><td>27.9</td><td>52.1</td></tr><tr><td rowspan="3">Mixer-B/16</td><td>Vanilla (AdamW)</td><td>66.4</td><td>72.1</td><td>50.8</td><td>14.5</td><td>33.8</td></tr><tr><td>SAM</td><td>77.4</td><td>83.5</td><td>63.9</td><td>24.7</td><td>48.8</td></tr><tr><td>GSAM</td><td>77.8</td><td>84.0</td><td>64.9</td><td>28.3</td><td>54.4</td></tr><tr><td></td><td></td><td></td><td></td><td></td><td></td><td></td></tr></table>
+
+![](images/0ab9a693376a9164b50af0714b51b883842522baa5f9217592cd485202ddf052.jpg)  
+Figure 4: Influence of $\rho$ (set as constant for ease of comparison, other experiments use decayed $\rho _ { t }$ schedule) and $\alpha$ on the training of ViT-B/32. Left: Top-1 accuracy on ImageNet. Middle: Estimation of the dominant eigenvalues from the surrogate gap, $\sigma _ { m a x } \approx 2 h / \rho ^ { 2 }$ . Right: Dominant eigenvalues of the Hessian calculated via the power iteration. Middle and right figures match in the trend of curves, validating that the surrogate gap can be viewed as a proxy of the dominant eigenvalue of Hessian.
+
+![](images/cd91a39c4fda1aa38347bb16bcf091af8803ccb572f7dae609b6c2bda9d3fc93.jpg)  
+Figure 5: Top-1 accuracy of Mixer-S/32 trained with different methods. “+ascent” represents applying the ascent step in Algo. 1 to an optimizer. Note that our GSAM is described as SAM+ascent $\mathbf { \Lambda } = \mathbf { G S A M } )$ for consistency.
+
+Table 2: Results $( \% )$ of GSAM and $\operatorname* { m i n } ( f _ { p } + \lambda h )$ on ViT-B/32   
+
+<table><tr><td>Dataset</td><td>min(fp+Xh)</td><td>GSAM</td></tr><tr><td>ImageNet</td><td>75.4</td><td>76.8</td></tr><tr><td>ImageNet-Real</td><td>81.1</td><td>82.7</td></tr><tr><td>ImageNet-v2</td><td>60.9</td><td>63.0</td></tr><tr><td>ImageNet-R</td><td>23.9</td><td>25.1</td></tr></table>
+
+Table 3: Transfer learning results (top-1 accuracy, $\%$ )   
+
+<table><tr><td></td><td colspan="3">ViT-B/16</td><td colspan="3">ViT-S/16</td></tr><tr><td></td><td>Vanilla</td><td>SAM</td><td>GSAM</td><td>Vanilla</td><td>SAM</td><td>GSAM</td></tr><tr><td>Cifar10</td><td>98.1</td><td>98.6</td><td>98.8</td><td>97.6</td><td>98.2</td><td>98.4</td></tr><tr><td>Cifar100</td><td>87.6</td><td>89.1</td><td>89.7</td><td>85.7</td><td>87.6</td><td>88.1</td></tr><tr><td>Flowers</td><td>88.5</td><td>91.8</td><td>91.2</td><td>86.4</td><td>91.5</td><td>90.3</td></tr><tr><td>Pets</td><td>91.9</td><td>93.1</td><td>94.4</td><td>90.4</td><td>92.9</td><td>93.5</td></tr><tr><td>mean</td><td>91.5</td><td>93.2</td><td>93.5</td><td>90.0</td><td>92.6</td><td>92.6</td></tr></table>
+
+# 6.3 COMPARISON WITH METHODS IN THE LITERATURE
+
+Section 6.1 compares GSAM to SAM and vanilla training. In this subsection, we further compare GSAM against Entropy-SGD (Chaudhari et al., 2019) and Adaptive-SAM (ASAM) (Kwon et al., 2021), which are designed to improve generalization. Note that Entropy-SGD uses SGD in the inner Langevin iteration and can be combined with other base optimizers such as AdamW as the outer loop. For Entropy-SGD, we find the hyper-parameter “scope” from 0.0 and 0.9, and search for the inner-loop iteration number between 1 and 14. For ASAM, we search for $\rho$ between 1 and 7 $( 1 0 \times$ larger than in SAM) as recommended by the ASAM authors. Note that the only difference between ASAM and SAM is the derivation of the perturbation, so both can be combined with the proposed ascent step. As shown in Fig. 5, the proposed ascent step increases test accuracy when combined with both SAM and ASAM and outperforms Entropy-SGD and vanilla training.
+
+# 6.4 ADDITIONAL STUDIES
+
+GSAM outperforms a weighted combination of the perturbed loss and surrogate gap With an example in Fig. 2, we demonstrate that directly minimizing $f _ { p } ( w ) + \lambda h ( w )$ as discussed in Sec. 4.1 is sub-optimal because $\nabla h ( w )$ could conflict with $\nabla f _ { p } ( w )$ and $\nabla f ( w )$ . We empirically validate this argument on ViT-B/32. We search for $\lambda$ between 0.0 and 0.5 with a step 0.1 and search for $\rho$ in the same grid as SAM and GSAM. We report the best accuracy of each method. Top-1 accuracy in Table 2 show the superior performance of GSAM, validating our analysis.
+
+$\operatorname* { m i n } ( f _ { p } , h )$ vs. $\operatorname* { m i n } ( f , h )$ GSAM solves $\operatorname* { m i n } ( f _ { p } , h )$ by descent in $\nabla f _ { p }$ , decomposing $\nabla f$ onto $\nabla f _ { p }$ , and an ascent step in the orthogonal direction to increase $f$ while keep $f _ { p }$ intact. Alternatively, we can also optimize $\operatorname* { m i n } ( f , h )$ by descent in $\nabla f$ , decomposing $\nabla f _ { p }$ onto $\nabla f$ , and a descent step in the orthogonal direction to decrease $f _ { p }$ while keep $f$ intact. The two GSAM variations perform similarly (see Fig. 6, right). We choose $\operatorname* { m i n } ( f _ { p } , h )$ mainly to make the minimal change to SAM.
+
+GSAM benefits transfer learning Using weights trained on ImageNet-1k, we finetune models with SGD on downstream tasks including the CIFAR10/CIFAR100 (Krizhevsky et al., 2009), Oxfordflowers (Nilsback & Zisserman, 2008) and Oxford-IITPets (Parkhi et al., 2012). Results in Table 3 shows that GSAM leads to better transfer performance than vanilla training and SAM.
+
+![](images/819890a555e7fa3dd273a452709db6a6112e787f55b5798c88bf87f762261419.jpg)  
+Figure 6: Top-1 accuracy of ViT-B/32 for the additional studies (Section 6.4). Left: from left to right are performances under different data augmentations (details in Appendix B.3) , where the vanilla method is trained for $2 \times$ the epochs. Middle: performance with different base optimizers. Right: Comparison between $\operatorname* { m i n } ( f _ { p } , h )$ and $\operatorname* { m i n } ( f , h )$ .
+
+GSAM remains effective under various data augmentations We plot the top-1 accuracy of a ViT-B/32 model under various Mixup (Zhang et al., 2017b) augmentations in Fig. 6 (left subfigure). Under different augmentations, GSAM consistently outperforms SAM and vanilla training.
+
+GSAM is compatible with different base optimizers GSAM is generic and applicable to various base optimizers. We compare vanilla training, SAM and GSAM using AdamW (Loshchilov & Hutter, 2017) and AdaBelief (Zhuang et al., 2020) with default hyper-parameters. Fig. 6 (middle subfigure) shows that GSAM performs the best, and SAM improves over vanilla training.
+
+# 7 CONCLUSION
+
+We propose the surrogate gap as an equivalent measure of sharpness which is easy to compute and feasible to optimize. We propose the GSAM method, which improves the generalization over SAM at negligible computation cost. We show the convergence and provably better generalization of GSAM compared to SAM, and validate the superior performance of GSAM on various models.
+
+# ACKNOWLEDGEMENT
+
+We would like to thank Xiangning Chen (UCLA) and Hossein Mobahi (Google) for discussions, Yi Tay (Google) for help with datasets, and Yeqing Li, Xianzhi Du, and Shawn Wang (Google) for help with TensorFlow implementation.
+
+# ETHICS STATEMENT
+
+This paper focuses on the development of optimization methodologies and can be applied to the training of different deep neural networks for a wide range of applications. Therefore, the ethical impact of our work would primarily be determined by the specific models that are trained using our new optimization strategy.
+
+# REPRODUCIBILITY STATEMENT
+
+We provide the detailed proof of theoretical results in Appendix A and provide the data preprocessing and hyper-parameter settings in Appendix B. Together with the references to existing works and public codebases, we believe the paper contains sufficient details to ensure reproducibility. We plan to release the models trained by using GSAM upon publication.
+
+# REFERENCES
+
+Randall Balestriero, Jerome Pesenti, and Yann LeCun. Learning in high dimension always amounts to extrapolation. arXiv preprint arXiv:2110.09485, 2021.
+
+Lucas Beyer, Olivier J. Henaff, Alexander Kolesnikov, Xiaohua Zhai, and Aaron van den Oord. Are we done with imagenet? arXiv preprint arXiv:2002.05709, 2020.
+
+Leon Bottou. Large-scale machine learning with stochastic gradient descent. In ´ Proceedings of COMPSTAT’2010, pp. 177–186. Springer, 2010.
+
+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.
+
+Xiangning Chen, Cho-Jui Hsieh, and Boqing Gong. When vision transformers outperform resnets without pretraining or strong data augmentations, 2021.
+
+Ekin D Cubuk, Barret Zoph, Dandelion Mane, Vijay Vasudevan, and Quoc V Le. Autoaugment: Learning augmentation policies from data. arXiv preprint arXiv:1805.09501, 2018.
+
+Alex Damian, Tengyu Ma, and Jason Lee. Label noise sgd provably prefers flat global minimizers. arXiv preprint arXiv:2106.06530, 2021.
+
+Jia Deng, Wei Dong, Richard Socher, Li-Jia Li, Kai Li, and Li Fei-Fei. Imagenet: A large-scale hierarchical image database. In 2009 IEEE conference on computer vision and pattern recognition, pp. 248–255. Ieee, 2009.
+
+Terrance DeVries and Graham W Taylor. Improved regularization of convolutional neural networks with cutout. arXiv preprint arXiv:1708.04552, 2017.
+
+Alexey Dosovitskiy, Lucas Beyer, Alexander Kolesnikov, Dirk Weissenborn, Xiaohua Zhai, Thomas Unterthiner, Mostafa Dehghani, Matthias Minderer, Georg Heigold, Sylvain Gelly, et al. An image is worth 16x16 words: Transformers for image recognition at scale. arXiv preprint arXiv:2010.11929, 2020.
+
+John Duchi, Elad Hazan, and Yoram Singer. Adaptive subgradient methods for online learning and stochastic optimization. Journal of machine learning research, 12(Jul):2121–2159, 2011.
+
+Pierre Foret, Ariel Kleiner, Hossein Mobahi, and Behnam Neyshabur. Sharpness-aware minimization for efficiently improving generalization. arXiv preprint arXiv:2010.01412, 2020.
+
+Xavier Gastaldi. Shake-shake regularization. arXiv preprint arXiv:1705.07485, 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.
+
+Byeongho Heo, Sanghyuk Chun, Seong Joon Oh, Dongyoon Han, Sangdoo Yun, Gyuwan Kim, Youngjung Uh, and Jung-Woo Ha. Adamp: Slowing down the slowdown for momentum optimizers on scale-invariant weights. arXiv preprint arXiv:2006.08217, 2020.
+
+Sepp Hochreiter and Jurgen Schmidhuber. Simplifying neural nets by discovering flat minima. In ¨ Advances in neural information processing systems, pp. 529–536, 1995.
+
+Pavel Izmailov, Dmitrii Podoprikhin, Timur Garipov, Dmitry Vetrov, and Andrew Gordon Wilson. Averaging weights leads to wider optima and better generalization. arXiv preprint arXiv:1803.05407, 2018.
+
+Arthur Jacot, Franck Gabriel, and Clement Hongler. Neural tangent kernel: Convergence and gen- ´ eralization in neural networks. arXiv preprint arXiv:1806.07572, 2018.
+
+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.
+
+Nitish Shirish Keskar and Richard Socher. Improving generalization performance by switching from adam to sgd. arXiv preprint arXiv:1712.07628, 2017.
+
+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. arXiv preprint arXiv:1609.04836, 2016.
+
+Alex Krizhevsky, Geoffrey Hinton, et al. Learning multiple layers of features from tiny images. 2009.
+
+Jungmin Kwon, Jeongseop Kim, Hyunseo Park, and In Kwon Choi. Asam: Adaptive sharpnessaware minimization for scale-invariant learning of deep neural networks. arXiv preprint arXiv:2102.11600, 2021.
+
+Beatrice Laurent and Pascal Massart. Adaptive estimation of a quadratic functional by model selection. Annals of Statistics, pp. 1302–1338, 2000.
+
+Yuanzhi Li, Colin Wei, and Tengyu Ma. Towards explaining the regularization effect of initial large learning rate in training neural networks. arXiv preprint arXiv:1907.04595, 2019.
+
+Tengyuan Liang, Tomaso Poggio, Alexander Rakhlin, and James Stokes. Fisher-rao metric, geometry, and complexity of neural networks. In The 22nd International Conference on Artificial Intelligence and Statistics, pp. 888–896. PMLR, 2019.
+
+Tao Lin, Lingjing Kong, Sebastian Stich, and Martin Jaggi. Extrapolation for large-batch training in deep learning. In International Conference on Machine Learning, pp. 6094–6104. PMLR, 2020.
+
+Liyuan Liu, Haoming Jiang, Pengcheng He, Weizhu Chen, Xiaodong Liu, Jianfeng Gao, and Jiawei Han. On the variance of the adaptive learning rate and beyond. arXiv preprint arXiv:1908.03265, 2019.
+
+Ilya Loshchilov and Frank Hutter. Decoupled weight decay regularization. arXiv preprint arXiv:1711.05101, 2017.
+
+Liangchen Luo, Yuanhao Xiong, Yan Liu, and Xu Sun. Adaptive gradient methods with dynamic bound of learning rate. arXiv preprint arXiv:1902.09843, 2019.
+
+David McAllester. Simplified pac-bayesian margin bounds. In Learning theory and Kernel machines, pp. 203–215. Springer, 2003.
+
+David A McAllester. Pac-bayesian model averaging. In Proceedings of the twelfth annual conference on Computational learning theory, pp. 164–170, 1999.
+
+RV Mises and Hilda Pollaczek-Geiringer. Praktische verfahren der gleichungsauflosung. ¨ ZAMMJournal of Applied Mathematics and Mechanics/Zeitschrift fur Angewandte Mathematik und ¨ Mechanik, 9(1):58–77, 1929.
+
+Rafael Muller, Simon Kornblith, and Geoffrey Hinton. When does label smoothing help? ¨ arXiv preprint arXiv:1906.02629, 2019.
+
+Behnam Neyshabur, Srinadh Bhojanapalli, and Nathan Srebro. A pac-bayesian approach to spectrally-normalized margin bounds for neural networks. arXiv preprint arXiv:1707.09564, 2017.
+
+Maria-Elena Nilsback and Andrew Zisserman. Automated flower classification over a large number of classes. In 2008 Sixth Indian Conference on Computer Vision, Graphics & Image Processing, pp. 722–729. IEEE, 2008.
+
+Omkar M Parkhi, Andrea Vedaldi, Andrew Zisserman, and CV Jawahar. Cats and dogs. In 2012 IEEE conference on computer vision and pattern recognition, pp. 3498–3505. IEEE, 2012.
+
+Benjamin Recht, Rebecca Roelofs, Ludwig Schmidt, and Vaishaal Shankar. Do imagenet classifiers generalize to imagenet? In International Conference on Machine Learning, pp. 5389–5400, 2019.
+
+Sashank J Reddi, Satyen Kale, and Sanjiv Kumar. On the convergence of adam and beyond. arXiv preprint arXiv:1904.09237, 2019.
+
+David E Rumelhart, Geoffrey E Hinton, and Ronald J Williams. Learning internal representations by error propagation. Technical report, California Univ San Diego La Jolla Inst for Cognitive Science, 1985.
+
+Nitish Srivastava, Geoffrey Hinton, Alex Krizhevsky, Ilya Sutskever, and Ruslan Salakhutdinov. Dropout: a simple way to prevent neural networks from overfitting. The journal of machine learning research, 15(1):1929–1958, 2014.
+
+Christian Szegedy, Wei Liu, Yangqing Jia, Pierre Sermanet, Scott Reed, Dragomir Anguelov, Dumitru Erhan, Vincent Vanhoucke, and Andrew Rabinovich. Going deeper with convolutions. In Proceedings of the IEEE conference on computer vision and pattern recognition, pp. 1–9, 2015.
+
+Ilya Tolstikhin, Neil Houlsby, Alexander Kolesnikov, Lucas Beyer, Xiaohua Zhai, Thomas Unterthiner, Jessica Yung, Daniel Keysers, Jakob Uszkoreit, Mario Lucic, et al. Mlp-mixer: An all-mlp architecture for vision. arXiv preprint arXiv:2105.01601, 2021.
+
+Colin Wei, Jason Lee, Qiang Liu, and Tengyu Ma. Regularization matters: Generalization and optimization of neural nets vs their induced kernel. 2019.
+
+Zeke Xie, Li Yuan, Zhanxing Zhu, and Masashi Sugiyama. Positive-negative momentum: Manipulating stochastic gradient noise to improve generalization. arXiv preprint arXiv:2103.17182, 2021.
+
+Xubo Yue, Maher Nouiehed, and Raed Al Kontar. Salr: Sharpness-aware learning rates for improved generalization. arXiv preprint arXiv:2011.05348, 2020.
+
+Manzil Zaheer, Sashank Reddi, Devendra Sachan, Satyen Kale, and Sanjiv Kumar. Adaptive methods for nonconvex optimization. In Advances in neural information processing systems, pp. 9793– 9803, 2018.
+
+Matthew D Zeiler. Adadelta: an adaptive learning rate method. arXiv preprint arXiv:1212.5701, 2012.
+
+Chiyuan Zhang, Samy Bengio, Moritz Hardt, Benjamin Recht, and Oriol Vinyals. Understanding deep learning requires rethinking generalization. 2017a.
+
+Hongyi Zhang, Moustapha Cisse, Yann N Dauphin, and David Lopez-Paz. mixup: Beyond empirical risk minimization. arXiv preprint arXiv:1710.09412, 2017b.
+
+Michael Zhang, James Lucas, Jimmy Ba, and Geoffrey E Hinton. Lookahead optimizer: k steps forward, 1 step back. In Advances in Neural Information Processing Systems, pp. 9593–9604, 2019.
+
+Yaowei Zheng, Richong Zhang, and Yongyi Mao. Regularizing neural networks via adversarial model perturbation. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, pp. 8156–8165, 2021.
+
+Pan Zhou, Jiashi Feng, Chao Ma, Caiming Xiong, Steven Hoi, et al. Towards theoretically understanding why sgd generalizes better than adam in deep learning. arXiv preprint arXiv:2010.05627, 2020.
+
+Juntang Zhuang, Tommy Tang, Yifan Ding, Sekhar Tatikonda, Nicha Dvornek, Xenophon Papademetris, and James S Duncan. Adabelief optimizer: Adapting stepsizes by the belief in observed gradients. arXiv preprint arXiv:2010.07468, 2020.
+
+# A PROOFS
+
+A.1 PROOF OF LEMMA. 3.1
+
+Suppose $\rho$ is small, perform Taylor expansion around the local minima $w$ , we have:
+
+$$
+\boldsymbol { f } ( \boldsymbol { w } + \delta ) = \boldsymbol { f } ( \boldsymbol { w } ) + \nabla \boldsymbol { f } ( \boldsymbol { w } ) ^ { \top } \delta + \frac { 1 } { 2 } \delta ^ { \top } \boldsymbol { H } \delta + O ( | | \delta | | ^ { 3 } )
+$$
+
+where $H$ is the Hessian, and is positive semidefinite at a local minima. At a local minima, $\nabla f ( w ) =$ 0, hence we have
+
+$$
+f ( w + \delta ) = f ( w ) + \frac { 1 } { 2 } \delta ^ { \top } H \delta + O ( | | \delta | | ^ { 3 } )
+$$
+
+and
+
+$$
+f _ { p } ( w ) = \operatorname* { m a x } _ { | | \delta | | \leq \rho } f ( w + \delta ) = f ( w ) + \frac { 1 } { 2 } \rho ^ { 2 } \sigma _ { m a x } ( H ) + O ( | | \delta | | ^ { 3 } )
+$$
+
+where $\sigma _ { m a x }$ is the dominate eigenvalue (eigenvalue with the largest absolute value). Now consider two local minima $w _ { 1 }$ and $w _ { 2 }$ with dominate eigenvalue $\sigma _ { 1 }$ and $\sigma _ { 2 }$ respectively, we have
+
+$$
+f _ { p } ( w _ { 1 } ) \approx f ( w _ { 1 } ) + \frac { 1 } { 2 } \rho ^ { 2 } \sigma _ { 1 } \qquad f _ { p } ( w _ { 2 } ) \approx f ( w _ { 2 } ) + \frac { 1 } { 2 } \rho ^ { 2 } \sigma _ { 2 }
+$$
+
+We have $f _ { p } ( w _ { 1 } ) > f _ { p } ( w _ { 2 } ) \implies \sigma _ { 1 } > \sigma _ { 2 }$ and $\sigma _ { 1 } > \sigma _ { 2 } \implies f _ { p } ( w _ { 1 } ) > f _ { p } ( w _ { 2 } )$ because the relation between $f ( w _ { 1 } )$ and $f ( w _ { 2 } )$ is undetermined. 
+
+# A.2 PROOF OF LEMMA. 3.2
+
+Since $\rho$ is small, we can perform Taylor expansion around $w$
+
+$$
+\begin{array} { r l } & { h ( w ) = f ( w + \delta ) - f ( w ) } \\ & { \qquad = \delta ^ { \top } \nabla f ( w ) + O ( \rho ^ { 2 } ) } \\ & { \qquad = \rho | | \nabla f ( w ) | | _ { 2 } + O ( \rho ^ { 2 } ) > 0 } \end{array}
+$$
+
+where the last line is because δ is approximated as δ = ρ ∇f(w)||∇f(w)||2+ , h ence has the same direction as $\nabla f ( w )$ . 
+
+# A.3 PROOF OF LEMMA. 3.3
+
+Since $\rho$ is small, we can approximate $f ( w )$ with a quadratic model around a local minima $w$ :
+
+$$
+f ( w + \delta ) = f ( w ) + \frac { 1 } { 2 } \delta ^ { \top } H \delta + O ( \rho ^ { 3 } )
+$$
+
+where $H$ is the Hessian at $w$ , assumed to be positive semidefinite at local minima. Normalize $\delta$ such that $| | \delta | | _ { 2 } = \rho$ , Hence we have:
+
+$$
+h ( w ) = f _ { p } ( w ) - f ( w ) = \operatorname* { m a x } _ { | | \delta | | _ { 2 } \leq \rho } f ( w + \delta ) - f ( w ) = \frac { 1 } { 2 } \sigma _ { m a x } \rho ^ { 2 } + O ( \rho ^ { 3 } )
+$$
+
+where $\sigma _ { m a x }$ is the dominate eigenvalue of the hessian $H$ , and first order term is 0 because the gradient is 0 at local minima. Therefore, we have $\sigma _ { m a x } \approx 2 h ( w ) / \rho ^ { 2 }$ . 
+
+# A.4 PROOF OF THM. 5.1
+
+For simplicity we consider the base optimizer is SGD. For other optimizers such as Adam, we can derive similar results by applying standard proof techniques in the literature to our proof.
+
+STEP 1: CONVERGENCE W.R.T FUNCTION $f _ { p } ( w )$
+
+For simplicity of notation, we denote the update at step $t$ as
+
+$$
+d _ { t } = - \eta _ { t } g _ { p } ^ { ( t ) } + \eta _ { t } \alpha g _ { \perp } ^ { ( t ) }
+$$
+
+By $L -$ smoothness of $f$ and the definition of $f _ { p } ( w _ { t } ) = f ( w _ { t } ^ { a d v } )$ , and definition of $d _ { t } = w _ { t + 1 } - w _ { t }$ and $w _ { t } ^ { a d v } = w _ { t } + \delta _ { t }$ we have
+
+$$
+\begin{array} { l } { \displaystyle f _ { p } ( w _ { t + 1 } ) = f ( w _ { t + 1 } ^ { a d v } ) \leq f ( w _ { t } ^ { a d v } ) + \langle \nabla f ( w _ { t } ^ { a d v } ) , w _ { t + 1 } ^ { a d v } - w _ { t } ^ { a d v } \rangle + \frac { L } { 2 } \Big \| | w _ { t + 1 } ^ { a d v } - w _ { t } ^ { a d v } \Big \| ^ { 2 } } \\ { \displaystyle \qquad = f ( w _ { t } ^ { a d v } ) + \langle \nabla f ( w _ { t } ^ { a d v } ) , w _ { t + 1 } + \delta _ { t + 1 } - w _ { t } - \delta _ { t } \rangle } \\ { \displaystyle \qquad + \frac { L } { 2 } \Big \| w _ { t + 1 } + \delta _ { t + 1 } - w _ { t } - \delta _ { t } \Big \| ^ { 2 } } \\ { \displaystyle \qquad \leq f ( w _ { t } ^ { a d v } ) + \langle \nabla f ( w _ { t } ^ { a d v } ) , d _ { t } \rangle + L \Big \| d _ { t } \Big \| ^ { 2 } } \\ { \displaystyle \qquad + \langle \nabla f ( w _ { t } ^ { a d v } ) , \delta _ { t + 1 } - \delta _ { t } \rangle + L \Big \| \delta _ { t + 1 } - \delta _ { t } \Big \| ^ { 2 } } \end{array}
+$$
+
+STEP 1.0: BOUND EQ. 18
+
+We first bound Eq. 18. Take expectation conditioned on observation up to step $t$ (for simplicity of notation, we use $\mathbb { E }$ short for $\mathbb { E } _ { x }$ to denote expectation over all possible data points) conditioned on observations up to step $t$ , also by definition of $d _ { t }$ , we have
+
+$$
+\begin{array} { r l } & { \mathbb { E } f _ { p } ( w _ { t + 1 } ) - f _ { p } ( w _ { t } ) \leq - \eta _ { t } \langle \nabla f _ { p } ( w _ { t } ) , \mathbb { E } g _ { p } ^ { ( t ) } \rangle + \alpha \eta _ { t } \langle \nabla f _ { p } ( w _ { t } ) , \mathbb { E } g _ { \perp } ^ { ( t ) } \rangle } \\ & { \qquad + L \eta _ { t } ^ { 2 } \mathbb { E } \Big | \Big | - g _ { p } ^ { ( t ) } + \alpha g _ { \perp } ^ { ( t ) } \Big | \Big | _ { 2 } ^ { 2 } } \\ & { \qquad \leq - \eta _ { t } \mathbb { E } \Big | \Big | \nabla f _ { p } ( w _ { t } ) \Big | \Big | _ { 2 } ^ { 2 } + 0 + ( \alpha + 1 ) ^ { 2 } G ^ { 2 } \eta _ { t } ^ { 2 } } \end{array}
+$$
+
+Since $\mathbb { E } g _ { \perp } ^ { ( t ) }$ is orthogonal to $\nabla f _ { p } ( w _ { t } )$ by construction,
+
+$$
+\vert \vert g ^ { ( t ) } \vert \vert \le G \mathrm { b y } \mathrm { a s s u m p t i o n } \bigg )
+$$
+
+STEP 1.1: BOUND EQ. 19
+
+By definition of $\delta _ { t }$ , we have
+
+$$
+\begin{array} { c } { \displaystyle \delta _ { t } = \rho _ { t } \frac { g ^ { ( t ) } } { | | g ^ { ( t ) } | | + \epsilon } } \\ { \displaystyle \delta _ { t + 1 } = \rho _ { t + 1 } \frac { g ^ { ( t + 1 ) } } { | | g ^ { ( t + 1 ) } | | + \epsilon } } \end{array}
+$$
+
+where $g ^ { ( t ) }$ is the gradient of $f$ at $w _ { t }$ evaluated with a noisy data sample. When learning rate $\eta _ { t }$ is small, the update in weight $d _ { t }$ is small, and expected gradient is
+
+$$
+\nabla f ( w _ { t + 1 } ) = \nabla f ( w _ { t } + d _ { t } ) = \nabla f ( w _ { t } ) + H d _ { t } + O ( | | d _ { t } | | ^ { 2 } )
+$$
+
+where $H$ is the Hessian at $w _ { t }$ . Therefore, we have
+
+$$
+\begin{array} { r l } & { \mathbb { E } \langle \nabla f ( w _ { t } ^ { a d v } ) , \delta _ { t + 1 } - \delta _ { t } \rangle = \langle \nabla f ( w _ { t } ^ { a d v } ) , \rho _ { t } \mathbb { E } \frac { g ^ { ( t ) } } { | | g ^ { ( t ) } | | + \epsilon } - \rho _ { t + 1 } \mathbb { E } \frac { g ^ { ( t + 1 ) } } { | | g ^ { ( t + 1 ) } | | + \epsilon } \rangle } \\ & { \qquad \leq | | \nabla f ( w _ { t } ^ { a d v } ) | | \rho _ { t } \Big | \Big | \mathbb { E } \frac { g ^ { ( t ) } } { | | g ^ { ( t ) } | | + \epsilon } - \mathbb { E } \frac { g ^ { ( t + 1 ) } } { | | g ^ { ( t + 1 ) } | | + \epsilon } \Big | \Big | } \\ & { \qquad \leq | | \nabla f ( w _ { t } ^ { a d v } ) | | \rho _ { t } \phi _ { t } } \end{array}
+$$
+
+where the first inequality is due to (1) $\rho _ { t }$ is monotonically decreasing with $t$ , and (2) triangle inequality that $\langle a , b \rangle \overset { \cdot } { \leq } | | \boldsymbol { \dot { a } } | | \cdot | | b | |$ . $\phi _ { t }$ is the angle between the unit vector in the direction of $\nabla f ( w _ { t } )$
+
+and $\nabla f ( w _ { t + 1 } )$ . The second inequality comes from that (1) $\begin{array} { r } { \left\| \frac { g } { | | g | | + \epsilon } \right\| < 1 } \end{array}$ strictly, so we can replace $\delta _ { t }$ in Eq. 25 with a unit vector in corresponding directions multiplied by $\rho _ { t }$ and get the upper bound, (2) the norm of difference in unit vectors can be upper bounded by the arc length on a unit circle.
+
+When learning rate $\eta _ { t }$ and update stepsize $d _ { t }$ is small, $\phi _ { t }$ is also small. Using the limit that
+
+$$
+\tan x = x + O ( x ^ { 2 } ) , \quad \sin x = x + O ( x ^ { 2 } ) , \quad x \to 0
+$$
+
+We have:
+
+$$
+\begin{array} { r l r } {  { \tan \phi _ { t } = \frac { | | \nabla f ( w _ { t + 1 } ) - \nabla f ( w _ { t } ) | | } { | | \nabla f ( w _ { t } ) | | } + O ( \phi _ { t } ^ { 2 } ) } } \\ & { } & { = \frac { | | H d _ { t } + O ( | | d _ { t } | | ^ { 2 } ) | | } { | | \nabla f ( w _ { t } ) | | } + O ( \phi _ { t } ^ { 2 } ) } \\ & { } & { \leq \eta _ { t } L ( 1 + \alpha ) } \end{array}
+$$
+
+where the last inequality is due to (1) max eigenvalue of $H$ is upper bounded by $L$ because $f$ is $L -$ smooth, (2) $| | d _ { t } | | = | | \eta _ { t } ( g _ { \parallel } + \alpha g _ { \perp } ) | |$ and $\mathbb { E } g _ { t } = \nabla f ( w _ { t } )$ .
+
+Plug into Eq. 27, also note that the perturbation amplitude $\rho _ { t }$ is small so $w _ { t }$ is close to $w _ { t } ^ { a d v }$ , then we have
+
+$$
+\mathbb { E } \langle \nabla f ( w _ { t } ^ { a d v } ) , \delta _ { t + 1 } - \delta _ { t } \rangle \leq L ( 1 + \alpha ) G \rho _ { t } \eta _ { t }
+$$
+
+Similarly, we have
+
+$$
+\begin{array} { r l } & { \mathbb { E } \Big \lvert \Big \lvert \delta _ { t + 1 } - \delta _ { t } \Big \rvert \Big \rvert ^ { 2 } \leq \rho _ { t } ^ { 2 } \mathbb { E } \Big \lvert \Big \lvert \frac { g ^ { ( t ) } } { \lvert | g ^ { ( t ) } \rvert \rvert + \epsilon } - \frac { g ^ { ( t + 1 ) } } { \lvert | g ^ { ( t + 1 ) } \rvert \rvert + \epsilon } \Big \rvert \Big \rvert ^ { 2 } } \\ & { \qquad \leq \rho _ { t } ^ { 2 } \phi _ { t } ^ { 2 } } \\ & { \qquad \leq \rho _ { t } ^ { 2 } \eta _ { t } ^ { 2 } L ^ { 2 } ( 1 + \alpha ) ^ { 2 } } \end{array}
+$$
+
+STEP 1.2: TOTAL BOUND
+
+Reuse results from Eq. 21 (replace $L _ { p }$ with $2 L$ ) and plug into Eq. 18, and plug Eq. 31 and Eq. 34 into Eq. 19, we have
+
+$$
+\begin{array} { r l } & { \mathbb { E } f _ { p } ( w _ { t + 1 } ) - f _ { p } ( w _ { t } ) \leq - \eta _ { t } \mathbb { E } \Big | \Big | \nabla f _ { p } ( w _ { t } ) \Big | \Big | _ { 2 } ^ { 2 } + \frac { 2 L ( \alpha + 1 ) ^ { 2 } } { 2 } G ^ { 2 } \eta _ { t } ^ { 2 } } \\ & { \qquad + L ( 1 + \alpha ) G \rho _ { t } \eta _ { t } + \frac { 2 L ^ { 3 } ( 1 + \alpha ) ^ { 2 } } { 2 } \eta _ { t } ^ { 2 } \rho _ { t } ^ { 2 } } \end{array}
+$$
+
+Perform telescope sum, we have
+
+$$
+\begin{array} { l } { \displaystyle \mathbb { E } f _ { p } ( w _ { T } ) - f _ { p } ( w _ { 0 } ) \leq - \sum _ { t = 1 } ^ { T } \eta _ { t } \mathbb { E } | | \nabla f _ { p } ( w _ { t } ) | | ^ { 2 } + \left[ L ( 1 + \alpha ) ^ { 2 } G ^ { 2 } \eta _ { 0 } ^ { 2 } + L ( 1 + \alpha ) G \rho _ { 0 } \eta _ { 0 } \right] \sum _ { t = 1 } ^ { T } \frac { 1 } { t } } \\ { \displaystyle \qquad + L ^ { 3 } ( 1 + \alpha ) ^ { 2 } \eta _ { 0 } ^ { 2 } \rho _ { 0 } ^ { 2 } \sum _ { t = 1 } ^ { T } \frac { 1 } { t ^ { 2 } } } \end{array}
+$$
+
+Hence
+
+$$
+\eta _ { T } \sum _ { t = 1 } ^ { T } \mathbb { E } | | \nabla f _ { p } ( w _ { t } ) | | ^ { 2 } \leq \sum _ { t = 1 } ^ { T } \eta _ { t } \mathbb { E } | | \nabla f _ { p } ( w _ { t } ) | | ^ { 2 } \leq f _ { p } ( w _ { 0 } ) - \mathbb { E } f _ { p } ( w _ { T } ) + D \log T + \frac { \pi ^ { 2 } E } { 6 }
+$$
+
+where
+
+$$
+D = L ( 1 + \alpha ) ^ { 2 } G ^ { 2 } \eta _ { 0 } ^ { 2 } + L ( 1 + \alpha ) G \rho _ { 0 } \eta _ { 0 } , \quad E = L ^ { 3 } ( 1 + \alpha ) ^ { 2 } \eta _ { 0 } ^ { 2 } \rho _ { 0 } ^ { 2 }
+$$
+
+Note that $\begin{array} { r } { \eta _ { T } = \frac { \eta _ { 0 } } { \sqrt { T } } } \end{array}$ , we have
+
+$$
+\frac { 1 } { T } \sum _ { t = 1 } ^ { T } \mathbb { E } | | \nabla f _ { p } ( w _ { t } ) | | ^ { 2 } \leq \frac { f _ { p } ( w _ { 0 } ) - f _ { m i n } + \pi ^ { 2 } E / 6 } { \eta _ { 0 } } \frac { 1 } { \sqrt { T } } + \frac { D } { \eta _ { 0 } } \frac { \log T } { \sqrt { T } }
+$$
+
+which implies that GSAM enables $f _ { p }$ to converge at a rate of $O ( \log T / \sqrt { T } )$ , and all the constants here are well-bounded.
+
+STEP 2: CONVERGENCE W.R.T. FUNCTION $f ( w )$
+
+We prove the risk for $f ( w )$ convergences for non-convex stochastic optimization case using SGD. Denote the update at step $t$ as
+
+$$
+d _ { t } = - \eta _ { t } g _ { p } ^ { ( t ) } + \alpha \eta _ { t } g _ { \perp } ^ { ( t ) }
+$$
+
+By smoothness of $f$ , we have
+
+$$
+\begin{array} { l } { f ( w _ { t + 1 } ) \leq f ( w _ { t } ) + \langle \nabla f ( w _ { t } ) , d _ { t } \rangle + \displaystyle \frac { L } { 2 } \Big \lvert \Big \lvert d _ { t } \Big \rvert \Big \rvert _ { 2 } ^ { 2 } } \\ { = f ( w _ { t } ) + \langle \nabla f ( w _ { t } ) , - \eta _ { t } g _ { p } ^ { ( t ) } + \alpha \eta _ { t } g _ { \perp } ^ { ( t ) } \rangle + \displaystyle \frac { L } { 2 } \Big \lvert \Big \lvert d _ { t } \Big \rvert \Big \rvert _ { 2 } ^ { 2 } } \end{array}
+$$
+
+For simplicity, we introduce a scalar $\beta _ { t }$ such that
+
+$$
+\nabla f _ { \parallel } ( w _ { t } ) = \beta _ { t } \nabla f _ { p } ( w _ { t } )
+$$
+
+where $\nabla f _ { \parallel } ( w _ { t } )$ is the projection of $\nabla f ( w _ { t } )$ onto $\nabla f _ { p } ( w _ { t } )$ . When perturbation amplitude $\rho$ is small, we expect $\beta _ { t }$ to be very close to 1.
+
+Take expectation conditioned on observations up to step $t$ for both sides of Eq. 42, we have:
+
+$$
+\begin{array} { l } { \displaystyle \mathbb { E } f ( w _ { t + 1 } ) \leq f ( w _ { t } ) + \left. \nabla f ( w _ { t } ) , - \frac { \eta _ { t } } { \beta _ { t } } \Big ( \nabla f ( w _ { t } ) - \nabla f _ { \perp } ( w _ { t } ) \Big ) + \alpha \eta _ { t } \mathbb { E } g _ { \perp } ^ { ( t ) } \right. + \displaystyle \frac { L } { 2 } \mathbb { E } \Big \| \boldsymbol { d } _ { t } \Big \| _ { 2 } ^ { 2 } } \\ { = f ( w _ { t } ) - \displaystyle \frac { \eta _ { t } } { \beta _ { t } } \Big \| \nabla f ( w _ { t } ) \Big \| _ { 2 } ^ { 2 } + \Big ( \frac { 1 } { \beta _ { t } } + \alpha \Big ) \eta _ { t } \Big \langle \nabla f ( w _ { t } ) , \nabla f _ { \perp } ( w _ { t } ) \Big \rangle + \displaystyle \frac { L } { 2 } \mathbb { E } \Big \| \boldsymbol { d } _ { t } \Big \| _ { 2 } ^ { 2 } } \\ { = f ( w _ { t } ) - \displaystyle \frac { \eta _ { t } } { \beta _ { t } } \Big \| \nabla f ( w _ { t } ) \Big \| _ { 2 } ^ { 2 } + \Big ( \frac { 1 } { \beta _ { t } } + \alpha \Big ) \eta _ { t } \Big \langle \nabla f ( w _ { t } ) , \nabla f ( w _ { t } ) \sin \theta _ { t } \Big \rangle + \displaystyle \frac { L } { 2 } \mathbb { E } \Big \| \boldsymbol { d } _ { t } \Big \| _ { 2 } ^ { 2 } } \end{array}
+$$
+
+$$
+= f ( w _ { t } ) - \frac { \eta _ { t } } { \beta _ { t } } \Big \lvert \Big | \nabla f ( w _ { t } ) \Big \rvert \Big | _ { 2 } ^ { 2 } + \Big ( \frac { 1 } { \beta _ { t } } + \alpha \Big ) \eta _ { t } \Big \lvert \Big | \nabla f ( w _ { t } ) \Big \rvert \Big | _ { 2 } ^ { 2 } ( | \tan \theta _ { t } | + O ( \theta _ { t } ^ { 2 } ) ) + \frac { L } { 2 } \mathbb { E } \Big \lvert \Big | d _ { t } \Big \rvert \Big | _ { 2 } ^ { 2 }
+$$
+
+$$
+\Big ( \sin x = x + O ( x ^ { 2 } ) , \tan x = x + O ( x ^ { 2 } ) \mathrm { w h e n } x  0 . \Big )
+$$
+
+Also note when perturbation amplitude $\rho _ { t }$ is small, we have
+
+$$
+\nabla f _ { p } ( w _ { t } ) = \nabla f ( w _ { t } + \delta _ { t } ) = \nabla f ( w _ { t } ) + \frac { \rho _ { t } } { | | \nabla f ( w _ { t } ) | | _ { 2 } + \epsilon } H ( w _ { t } ) \nabla f ( w _ { t } ) + O ( \rho _ { t } ^ { 2 } )
+$$
+
+where δt = ρt ∇f (wt)||∇f (wt)||2 by definition, $H ( w _ { t } )$ is the Hessian. Hence we have
+
+$$
+| \tan \theta _ { t } | \leq \frac { | | \nabla f _ { p } ( w _ { t } ) - \nabla f ( w _ { t } ) | | } { | | \nabla f ( w _ { t } ) | | } \leq \frac { \rho _ { t } L } { | | \nabla f ( w _ { t } ) | | }
+$$
+
+where $L$ is the Lipschitz constant of $f$ , and $L -$ smoothness of $f$ indicates the maximum absolute eigenvalue of $H$ is upper bounded by $L$ . Plug Eq. 49 into Eq. 47, we have
+
+$$
+\begin{array} { l } { \displaystyle \mathbb { E } f ( w _ { t + 1 } ) \leq f ( w _ { t } ) - \frac { \eta _ { t } } { \beta _ { t } } \Big \| \nabla f ( w _ { t } ) \Big \| _ { 2 } ^ { 2 } + \Big ( \frac { 1 } { \beta _ { t } } + \alpha \Big ) \eta _ { t } \Big \| \nabla f ( w _ { t } ) \Big \| _ { 2 } ^ { 2 } | \tan \theta _ { t } | + \frac { L } { 2 } \mathbb { E } \Big \| d t _ { t } \Big \| _ { 2 } ^ { 2 } } \\ { \displaystyle \leq f ( w _ { t } ) - \frac { \eta _ { t } } { \beta _ { t } } \Big \| \nabla f ( w _ { t } ) \Big \| _ { 2 } ^ { 2 } + \Big ( \frac { 1 } { \beta _ { t } } + \alpha \Big ) L \rho _ { t } \eta _ { t } \Big \| \nabla f ( w _ { t } ) \Big \| _ { 2 } + \frac { L } { 2 } \mathbb { E } \Big \| d t _ { t } \Big \| _ { 2 } ^ { 2 } } \\ { \displaystyle \leq f ( w _ { t } ) - \frac { \eta _ { t } } { \beta _ { t } } \Big \| \nabla f ( w _ { t } ) \Big \| _ { 2 } ^ { 2 } + \Big ( \frac { 1 } { \beta _ { t } } + \alpha \Big ) L \rho _ { t } \eta _ { t } G + \frac { L } { 2 } \mathbb { E } \Big \| d t _ { t } \Big \| _ { 2 } ^ { 2 } } \\ { \Big ( \mathrm { A s s u m e ~ g r a d i e n t ~ h a s ~ b o u n d e d ~ n o r m ~ } G _ { \cdot } \Big ) } \\ { \displaystyle \leq f ( w _ { t } ) - \frac { \eta _ { t } } { \beta _ { m a x } } \Big \| \nabla f ( w _ { t } ) \Big \| _ { 2 } ^ { 2 } + \Big ( \frac { 1 } { \beta _ { m i n } } + \alpha \Big ) L \rho _ { t } \eta _ { t } G + \frac { L } { 2 } \mathbb { E } ( \alpha + 1 ) ^ { 2 } G ^ { 2 } \eta _ { t } ^ { 2 } } \end{array}
+$$
+
+ $\beta _ { t }$ is close to 1 assuming $\rho$ is small,
+
+Re-arranging above formula, we have
+
+$$
+\frac { \eta _ { t } } { \beta _ { m a x } } \Big | \Big | \nabla f ( w _ { t } ) \Big | \Big | _ { 2 } ^ { 2 } \le f ( w _ { t } ) - \mathbb { E } f ( w _ { t + 1 } ) + \Big ( \frac { 1 } { \beta _ { m i n } } + \alpha \Big ) L G \eta _ { t } \rho _ { t } + \frac { L } { 2 } ( \alpha + 1 ) ^ { 2 } G ^ { 2 } \eta _ { t } ^ { 2 }
+$$
+
+perform telescope sum and taking expectations on each step, we have
+
+$$
+\frac { 1 } { \beta _ { m a x } } \sum _ { t = 1 } ^ { T } \eta _ { t } \Big | \Big | \nabla f ( w _ { t } ) \Big | \Big | _ { 2 } ^ { 2 } \le f ( w _ { 0 } ) - \mathbb { E } f ( w _ { T } ) + \Big ( \frac { 1 } { \beta _ { m i n } } + \alpha \Big ) L G \sum _ { t = 1 } ^ { T } \eta _ { t } \rho _ { t } + \frac { L } { 2 } ( \alpha + 1 ) ^ { 2 } G ^ { 2 } \sum _ { t = 1 } ^ { T } \eta _ { t } ^ { 2 }
+$$
+
+Take the schedule to be $\begin{array} { r } { \eta _ { t } = \frac { \eta _ { 0 } } { \sqrt { t } } } \end{array}$ and $\begin{array} { r } { \rho _ { t } = \frac { \rho _ { 0 } } { \sqrt { t } } } \end{array}$ , then we have
+
+$$
+\begin{array} { r l r } {  { \frac { \eta _ { 0 } } { 3 m \alpha \lambda } \frac { 1 } { \sqrt { T } } \sum _ { t = 1 } ^ { T } \| \nabla f ( w _ { t } ) \| _ { 2 } ^ { 2 } \le L H S } } \\ & { } & { \le R H S } \\ & { } & { \le { \cal J } ( w _ { 0 } ) - { \cal J } _ { m i n } + \Big ( \frac { 1 } { \beta _ { m i n } } + \alpha \Big ) L G \eta _ { 0 } \rho _ { 0 } \sum _ { t = 1 } ^ { T } \frac { 1 } { t } + \frac { L } { 2 } ( \alpha + 1 ) ^ { 2 } G ^ { 2 } \eta _ { 0 } ^ { 2 } \frac { T } { t - 1 } ; } \\ & { } & { \overset { ( \mathrm { 5 9 } ) } { \le } ~ } \\ & { } & { \le f ( w _ { 0 } ) - f _ { m i n } + \Big ( \frac { 1 } { \beta _ { m i n } } + \alpha \Big ) L G \eta _ { 0 } \rho _ { 0 } ( 1 + \log T ) } \\ & { } & { ~ + \frac { L } { 2 } ( \alpha + 1 ) ^ { 2 } G ^ { 2 } \eta _ { 0 } ^ { 2 } ( 1 + \log T ) ~ ( 6 0 ) } \end{array}
+$$
+
+Hence
+
+$$
+\frac { 1 } { T } \sum _ { t = 1 } ^ { T } \Big | \Big | \nabla f ( w _ { t } ) \Big | \Big | _ { 2 } ^ { 2 } \le \frac { C _ { 3 } } { \sqrt { T } } + C _ { 4 } \frac { \log T } { \sqrt { T } }
+$$
+
+where $C _ { 1 } , C _ { 4 }$ are some constants. This implies the convergence rate w.r.t $f ( w )$ is $O ( \log T / \sqrt { T } )$
+
+STEP 3: CONVERGENCE W.R.T. SURROGATE GAP $h ( w )$
+
+Note that we have proved convergence for $f _ { p } ( w )$ in step 1, and convergence for $f ( w )$ in step 3. Also note that
+
+$$
+\Big | \Big | \nabla h ( w _ { t } ) \Big | \Big | _ { 2 } ^ { 2 } = \Big | \Big | \nabla f _ { p } ( w _ { t } ) - \nabla f ( w _ { t } ) \Big | \Big | _ { 2 } ^ { 2 } \leq 2 \Big | \Big | \nabla f _ { p } ( w _ { t } ) \Big | \Big | _ { 2 } ^ { 2 } + 2 \Big | \Big | \nabla f ( w _ { t } ) \Big | \Big | _ { 2 } ^ { 2 }
+$$
+
+Hence
+
+$$
+\frac { 1 } { T } \sum _ { t = 1 } ^ { T } \Big | \Big | \nabla h ( w _ { t } ) \Big | \Big | _ { 2 } ^ { 2 } \le \frac { 2 } { T } \sum _ { t = 1 } ^ { T } \Big | \Big | \nabla f _ { p } ( w _ { t } ) \Big | \Big | _ { 2 } ^ { 2 } + \frac { 2 } { T } \sum _ { t = 1 } ^ { T } \Big | \Big | \nabla f ( w _ { t } ) \Big | \Big | _ { 2 } ^ { 2 }
+$$
+
+also converges at rate $O ( \log T / \sqrt { T } )$ because each item in the RHS converges at rate $O ( \log T \sqrt { T } )$
+
+# A.5 PROOF OF COROLLARY. 5.2.1
+
+Using the results from Thm. 5.2, with probability at least $1 - a$ , we have
+
+$$
+\mathbb { E } _ { w \sim \mathcal { Q } } \mathbb { E } _ { { x } } f ( w , { x } ) \le \mathbb { E } _ { w \sim \mathcal { Q } } \widehat { f } ( w ) + 4 \sqrt { \frac { K L ( \mathcal { Q } | | \mathcal { P } ) + \log \frac { 2 m } { a } } { m } }
+$$
+
+Assume $\delta \sim \mathcal { N } ( 0 , b ^ { 2 } I _ { k } )$ where $k$ is the dimension of model parameters, hence $\delta ^ { 2 }$ (element-wise square) follows a a Chi-square distribution. By Lemma.1 in Laurent $\&$ Massart (2000), we have
+
+$$
+\mathbb { P } \big ( | | \delta | | _ { 2 } ^ { 2 } - k b ^ { 2 } \geq 2 b ^ { 2 } \sqrt { k t } + 2 t b ^ { 2 } \big ) \leq e x p ( - t )
+$$
+
+hence with probability at least $1 - 1 / \sqrt { n }$ , we have
+
+$$
+| | \delta | | _ { 2 } ^ { 2 } \leq b ^ { 2 } \Bigg ( 2 \log \sqrt { n } + k + 2 \sqrt { k \log \sqrt { n } } \Bigg ) \leq 2 b ^ { 2 } k \Bigg ( 1 + \sqrt { \frac { \log \sqrt { n } } { k } } \Bigg ) ^ { 2 } \leq \rho ^ { 2 }
+$$
+
+Therefore, with probability at least $\begin{array} { r } { 1 - 1 / \sqrt { n } = 1 - e x p \bigg ( - \big ( \frac { \rho } { \sqrt { 2 } b } - \sqrt { k } \big ) ^ { 2 } \bigg ) } \end{array}$
+
+$$
+\begin{array} { r } { \mathbb { E } _ { \delta } \widehat { f } ( w + \delta ) \leq \operatorname* { m a x } _ { | | \delta | | _ { 2 } \leq \rho } \widehat { f } ( w + \delta ) } \end{array}
+$$
+
+Combine Eq. 65 and Eq. 67, subtract the same constant $C$ on both sides, and under the same assumption as in (Foret et al., 2020) that $\begin{array} { r } { \mathbb { E } _ { w \sim \mathcal { Q } } \mathbb { E } _ { x } f ( w , x ) \le \mathbb { E } _ { \delta \sim \mathcal { N } ( 0 , b ^ { 2 } I ^ { k } ) } \mathbb { E } _ { w \sim \mathcal { Q } } \mathbb { E } _ { x } f ( w + \delta , x ) \mathrm { w e } } \end{array}$ finish the proof. 
+
+# A.6 PROOF OF THM. 5.3
+
+STEP 1: A SUFFICIENT CONDITION THAT THE LOSS GAP IS EXPECTED TO DECREASE FOR EACH STEP
+
+Take Taylor expansion, then the expected change of loss gap caused by descent step is
+
+$$
+\begin{array} { r l } & { \mathbb { E } \langle \nabla f _ { p } ( w _ { t } ) - \nabla f ( w _ { t } ) , - \eta _ { t } \nabla f _ { p } ( w _ { t } ) \rangle } \\ & { \Big ( w h e r e \mathbb { E } g _ { \perp } = \nabla f _ { \perp } ( w _ { t } ) \Big ) } \\ & { = \eta _ { t } \Bigg [ - | | \nabla f _ { p } ( w _ { t } ) | | _ { 2 } ^ { 2 } + | | \nabla f _ { p } ( w _ { t } ) | | _ { 2 } \big | | \nabla f ( w _ { t } ) | | _ { 2 } \cos \theta _ { t } \Bigg ] } \end{array}
+$$
+
+where $\theta _ { t }$ is the angle between vector $\nabla f _ { p } ( w _ { t } )$ and $\nabla f ( w _ { t } )$ .
+
+The expected change of loss gap caused by ascent step is
+
+$$
+\begin{array} { r } { \mathbb { E } \langle \nabla f _ { p } ( w _ { t } ) - \nabla f ( w _ { t } ) , \alpha \eta _ { t } \nabla f _ { \perp } ( w _ { t } ) \rangle = - \alpha \eta _ { t } \big \lvert \big \rvert \nabla f _ { \perp } ( w _ { t } ) \big \rvert \big \rvert _ { 2 } ^ { 2 } < 0 } \end{array}
+$$
+
+Above results demonstrate that ascent step decreases the loss gap, while descent step might increase the loss gap. A sufficient (but not necessary) condition for $\mathbb { E } \langle \nabla h ( w _ { t } ) , d t \rangle \leq 0$ requires $\alpha$ to be large or $| \big | \nabla f ( w _ { t } ) \big | \big | _ { 2 } \cos \theta _ { t } \leq \big | \big | \nabla f _ { p } ( w _ { t } ) \big | \big |$ . In practice, the perturbation amplitude $\rho$ is small and we can assume $\theta _ { t }$ is close to 0 and $\big | \big | \nabla f _ { p } ( w _ { t } ) \big | \big |$ is close to $\left| \left| \nabla f ( w _ { t } ) \right| \right|$ , we can also set the parameter $\alpha$ to be large in order to decrease the loss gap.
+
+STEP 2: UPPER AND LOWER BOUND OF DECREASE IN LOSS GAP (BY THE ASCENT STEP IN ORTHOGONAL GRADIENT DIRECTION) COMPARED TO SAM.
+
+Next we give an estimate of the decrease in $\widehat { h }$ caused by our ascent step. We refer to Eq. 69 and Eq. 70 to analyze the change in loss gap caused by the descent and ascent (orthogonally) respectively. It can be seen that gradient descent step might not decrease loss gap, in fact they often increase loss gap in practice; while the ascent step is guaranteed to decrease the loss gap.
+
+The decrease in loss gap is:
+
+$$
+\begin{array} { r l r } & { } & { \Delta \widehat { h } _ { t } = - \langle \nabla \widehat { f } _ { p } ( w _ { t } ) - \nabla \widehat { f } ( w _ { t } ) , \alpha \eta _ { t } \nabla \widehat { f } _ { \bot } ( w _ { t } ) \rangle = \alpha \eta _ { t } \big \lvert \big \lvert \nabla \widehat { f } _ { \bot } ( w _ { t } ) \big \rvert \big \rvert _ { 2 } ^ { 2 } } \\ & { } & { = \alpha \eta _ { t } \big \lvert \big \lvert \nabla \widehat { f } ( w _ { t } ) \big \rvert \big \rvert _ { 2 } ^ { 2 } \big \lvert \tan \theta _ { t } \big \rvert ^ { 2 } } \end{array}
+$$
+
+$$
+\begin{array} { r l r } {  { \sum _ { t = 1 } ^ { T } \Delta \widehat { h } _ { t } \le \sum _ { t = 1 } ^ { T } \alpha L ^ { 2 } \eta _ { t } \rho _ { t } ^ { 2 } } } \\ & { } & { \Big ( \mathrm { B y ~ E q . ~ 4 9 } \Big ) } \\ & { } & { \le \displaystyle \sum _ { t = 1 } ^ { T } \alpha L ^ { 2 } \eta _ { 0 } \rho _ { 0 } ^ { 2 } \frac { 1 } { t ^ { 3 / 2 } } } \\ & { } & { \le 2 . 7 \alpha L ^ { 2 } \eta _ { 0 } \rho _ { 0 } ^ { 2 } } \end{array}
+$$
+
+Hence we derive an upper bound for $\Sigma _ { t = 1 } ^ { T } \Delta \widehat { h } _ { t }$
+
+Next we derive a lower bound for $\Sigma _ { t = 1 } ^ { T } \Delta \widehat { h } _ { t }$ Note that when $\rho _ { t }$ is small, by Taylor expansion
+
+$$
+\nabla \widehat { f } _ { p } ( w _ { t } ) = \nabla \widehat { f } ( w _ { t } + \delta _ { t } ) = \nabla \widehat { f } ( w _ { t } ) + \frac { \rho _ { t } } { | | \nabla \widehat { f } ( w _ { t } ) | | } \widehat { H } ( w _ { t } ) \nabla \widehat { f } ( w _ { t } ) + O ( \rho _ { t } ^ { 2 } )
+$$
+
+where $\widehat { H } ( w _ { t } )$ is the Hessian evaluated on training samples. Also when $\rho _ { t }$ is small, the angle $\theta _ { t }$ between $\nabla \widehat { f } _ { p } ( w _ { t } )$ and $\nabla \widehat { f } ( \boldsymbol { w } _ { t } )$ is small, by the limit that
+
+$$
+\begin{array} { l } { \tan x = x + O ( x ^ { 2 } ) , x \to 0 } \\ { \sin x = x + O ( x ^ { 2 } ) , x \to 0 } \end{array}
+$$
+
+We have
+
+$$
+\left| \tan \theta _ { t } \right| = \left| \sin \theta _ { t } \right| + O ( \theta _ { t } ^ { 2 } ) = | \theta _ { t } | + O ( \theta _ { t } ^ { 2 } )
+$$
+
+Omitting high order term, we have
+
+$$
+| \tan \theta _ { t } | \approx | \theta _ { t } | = \frac { | | \nabla \widehat { f } _ { p } ( w _ { t } ) - \nabla \widehat { f } ( w _ { t } ) | | } { | | \widehat { f } ( w _ { t } ) | | } = \frac { | | \rho _ { t } \widehat { H } ( w _ { t } ) + O ( \rho _ { t } ^ { 2 } ) | | } { | | \nabla \widehat { f } ( w _ { t } ) | | } \geq \frac { \rho _ { t } | \sigma | _ { m i n } } { G }
+$$
+
+where $G$ is the upper-bound on norm of gradient, $| \sigma | _ { m i n }$ is the minimum absolute eigenvalue of the Hessian. The intuition is that as perturbation amplitude decreases, the angle $\theta _ { t }$ decreases at a similar rate, though the scale constant might be different. Hence we have
+
+$$
+\begin{array} { r l } {  { \sum _ { t = 1 } ^ { T } \Delta \hat { h } _ { t } = \sum _ { t = 1 } ^ { T } \alpha \eta _ { t } \vert \big \vert \nabla \widehat { f } ( w _ { t } ) \big \vert \big \vert _ { 2 } ^ { 2 } \vert \tan \theta _ { t } \vert ^ { 2 } + O ( \theta _ { t } ^ { 4 } ) } \ ~ } \\ & { \geq \sum _ { t = 1 } ^ { T } \alpha \eta _ { t } c ^ { 2 } \Big ( \frac { \rho _ { t } \vert \sigma \vert _ { m i n } } { G } \Big ) ^ { 2 } } \\ & { = \frac { \alpha c ^ { 2 } \rho _ { 0 } ^ { 2 } \eta _ { 0 } \vert \sigma \vert _ { m i n } ^ { 2 } } { G ^ { 2 } } \sum _ { t = 1 } ^ { T } \frac { 1 } { t ^ { 3 / 2 } } } \\ & { \geq \frac { \alpha c ^ { 2 } \rho _ { 0 } ^ { 2 } \eta _ { 0 } \vert \sigma \vert _ { m i n } ^ { 2 } } { G ^ { 2 } } } \end{array}
+$$
+
+where $c ^ { 2 }$ is the lower bound of $| | \nabla \widehat { f } | | ^ { 2 }$ (e.g. due to noise in data and gradient observation). Results above indicate that the decrease in loss gap caused by the ascent step is non-trivial, hence our proposed method efficiently improves generalization compared with SAM. 
+
+# A.7 DISCUSSION ON COROLLARY 5.2.1
+
+The comment “‘The corollary gives a bound on the risk in terms of the perturbed training loss if one removes $C$ from both sides”’ is correct. But there is a misunderstanding in the statement “‘the perturbed training loss is small then the model has a small risk”’: it’s only true when $\rho _ { t r a i n }$ for training equals its real value $\rho _ { t r u e }$ determined by the data distribution; in practice, we never know $\rho _ { t r u e }$ . In the following we show that the minimization of both $h$ and $f _ { p }$ is better than simply minimizing $f _ { p }$ when $\rho _ { t r u e } \neq \rho _ { t r a i n }$ .
+
+1. First, we re-write the conclusion of Corollary 5.2.1 as
+
+$$
+\begin{array} { r } { \mathbb { E } _ { w } \mathbb { E } _ { x } f ( w , x ) \le f _ { p } + R = C + \widehat { h } + R = C + \rho ^ { 2 } \sigma / 2 + R + O ( \rho ^ { 3 } ) } \\ { w i t h p r o b a b i l i t y \left( 1 - a \right) [ 1 - e ^ { - ( \frac { \rho } { \sqrt { 2 } b } - \sqrt { k } ) ^ { 2 } } ] } \end{array}
+$$
+
+where $R$ is the regularization term, $C$ is the training loss, $\sigma$ is the dominant eigenvalue of Hessian. As in lemma 3.3, we perform Taylor-expansion and can ignore the high-order term $O ( \rho ^ { 3 } )$ . We focus on
+
+$$
+f _ { p } = C + \widehat { h } = C + \rho ^ { 2 } \sigma / 2
+$$
+
+2. When $\rho _ { t r u e } \neq \rho _ { t r a i n }$ , minimizing $h$ achieves a lower risk than only minimizing $f _ { p }$ . (1) Note that after training, $C$ (training loss) is fixed, but $h$ could vary with $\rho$ (e.g. when training on dataset A and testing on an unrelated dataset B, the training loss remains unchanged, but the risk would be huge and a large $\rho$ is required for a valid bound). (2) With an example, we show a low $f _ { p }$ is insufficient for generalization, and a low $\sigma$ is necessary:
+
+A Suppose we use $\rho _ { t r a i n }$ for training, and consider two solutions with $C _ { 1 } , \sigma _ { 1 }$ (SAM) and $C _ { 2 } , \sigma _ { 2 }$ (GSAM). Suppose they have the same $f _ { p }$ during training for some $\rho _ { t r a i n }$ , so $f _ { p 1 } = C _ { 1 } + \sigma _ { 1 } / 2 \times \rho _ { t r a i n } ^ { 2 } = C _ { 2 } + \sigma _ { 2 } / 2 \times \rho _ { t r a i n } ^ { 2 } = f _ { p 2 }$ Suppose $C _ { 1 } < C _ { 2 }$ so $\sigma _ { 1 } > \sigma _ { 2 }$ .   
+B When $\rho _ { t r u e } > \rho _ { t r a i n }$ , we have risk bound $\begin{array} { r } { - 1 = C _ { 1 } + \sigma _ { 1 } / 2 \times \rho _ { t r u e } ^ { 2 } + R > \mathrm { r i s k . b o u n d . } 2 = C _ { 2 } + \sigma _ { 2 } / 2 \times \rho _ { t r u e } ^ { 2 } + R } \end{array}$ This implies that a small $\sigma$ helps generalization, but only a low $f _ { p 1 }$ (caused by a low $C _ { 1 }$ and high $\sigma _ { 1 }$ ) is insufficient for a good generalization.   
+C Note that $\rho _ { t r a i n }$ is fixed during training, so minimizing $h _ { t r a i n }$ during training is equivalently minimizing $\sigma$ by Lemma 3.3
+
+3. Why we are often unlucky to have $\rho _ { t r u e } ~ > ~ \rho _ { t r a i n }$ (1) First, the test sets are almost surely outside the convex hull of the training set because “‘interpolation almost surely never occurs in high-dimensional $( > ~ 1 0 0 )$ cases”’ Balestriero et al. (2021). As a result, the variability of (train $^ +$ test) sets is almost surely larger than the variability of (train) set. Since $\rho$ increases with data variability (see point 4 below), we have $\rho _ { t r u e } > \rho _ { t r a i n - s e t }$ almost surely. (2) Second, we don’t know the value of $\rho _ { t r u e }$ and can only guess it. In practice, we often guess a small value because training often diverges with large $\rho$ (as observed in Foret et al. (2020); Chen et al. (2021)).
+
+4. Why $\rho$ increases with data variability. In Corollary 5.2.1, we assume weight perturbation $\delta \sim \mathcal { N } ( 0 , b ^ { 2 } I ^ { k } )$ . The meaning of $b$ is the following. If we can randomly sample a fixed number of samples from the underlying distribution, then training the model from scratch (with a fixed seed for random initialization) gives rise to a set of weights. Repeating this process, we get many sets of weights, and their standard deviation is $b$ . Since the number of training samples is limited and fixed, the more variability in data, the more variability in weights, and the larger $b$ . Note that Corollary stated that the bound holds with probability proportional to $[ 1 - e ^ { - ( \frac { \rho } { \sqrt { 2 } b } - \sqrt { k } ) ^ { 2 } } ]$ . In order for the result to hold with a fixed probability, $\rho$ must stay proportional to $b$ , hence $\rho$ also increases with the variability of data.
+
+Table 4: Hyper-parameters to reproduce experimental results   
+
+<table><tr><td>Model</td><td>Pmax</td><td>Pmin</td><td>α</td><td>lrmax</td><td>lrmin</td><td>Weight Decay</td><td>Base Optimizer</td><td>Epochs</td><td>Warmup Steps</td><td>LR schedule</td></tr><tr><td>ResNet50</td><td>0.04</td><td>0.02</td><td>0.01</td><td>1.6</td><td>1.6e-2</td><td>0.3</td><td>SGD</td><td>90</td><td>5k</td><td>Linear</td></tr><tr><td>ResNet101</td><td>0.04</td><td>0.02</td><td>0.01</td><td>1.6</td><td>1.6e-2</td><td>0.3</td><td>SGD</td><td>90</td><td>5k</td><td>Linear</td></tr><tr><td>ResNet512</td><td>0.04</td><td>0.02</td><td>0.005</td><td>1.6</td><td>1.6e-2</td><td>0.3</td><td>SGD</td><td>90</td><td>5k</td><td>Linear</td></tr><tr><td>ViT-S/32</td><td>0.6</td><td>0.0</td><td>0.4</td><td>3e-3</td><td>3e-5</td><td>0.3</td><td>AdamW</td><td>300</td><td>10k</td><td>Linear</td></tr><tr><td>ViT-S/16</td><td>0.6</td><td>0.0</td><td>1.0</td><td>3e-3</td><td>3e-5</td><td>0.3</td><td>AdamW</td><td>300</td><td>10k</td><td>Linear</td></tr><tr><td>ViT-B/32</td><td>0.6</td><td>0.1</td><td>0.6</td><td>3e-3</td><td>3e-5</td><td>0.3</td><td>AdamW</td><td>300</td><td>10k</td><td>Linear</td></tr><tr><td>ViT-B/16</td><td>0.6</td><td>0.2</td><td>0.4</td><td>3e-3</td><td>3e-5</td><td>0.3</td><td>AdamW</td><td>300</td><td>10k</td><td>Linear</td></tr><tr><td>Mixer-S/32</td><td>0.5</td><td>0.0</td><td>0.2</td><td>3e-3</td><td>3e-5</td><td>0.3</td><td>AdamW</td><td>300</td><td>10k</td><td>Linear</td></tr><tr><td>Mixer-S/16</td><td>0.5</td><td>0.0</td><td>0.6</td><td>3e-3</td><td>3e-5</td><td>0.3</td><td>AdamW</td><td>300</td><td>10k</td><td>Linear</td></tr><tr><td>Mixer-S/8</td><td>0.5</td><td>0.1</td><td>0.1</td><td>3e-3</td><td>3e-5</td><td>0.3</td><td>AdamW</td><td>300</td><td>10k</td><td>Linear</td></tr><tr><td>Mixer-B/32</td><td>0.7</td><td>0.2</td><td>0.05</td><td>3e-3</td><td>3e-5</td><td>0.3</td><td>AdamW</td><td>300</td><td>10k</td><td>Linear</td></tr><tr><td>Mixer-B/16</td><td>0.5</td><td>0.2</td><td>0.01</td><td>3e-3</td><td>3e-5</td><td>0.3</td><td>AdamW</td><td>300</td><td>10k</td><td>Linear</td></tr></table>
+
+# B EXPERIMENTAL DETAILS
+
+# B.1 TRAINING DETAILS
+
+For ViT and Mixer, we search the learning rate in $\{ 1 \mathrm { e } { - } 3 , 3 \mathrm { e } { - } 3 , 1 \mathrm { e } { - } 2 , 3 \mathrm { e } { - } 3 \}$ , and search weight decay in $\{ 0 . 0 0 3 , 0 . 0 3 , 0 . 3 \}$ . For ResNet, we search the learning rate in $\left. 1 . 6 , 0 . 1 6 , 0 . 0 1 6 \right.$ , and search the weight decay in $\{ 0 . 0 0 1 , 0 . 0 1 , 0 . 1 \}$ . For ViT and Mixer, we use the AdamW optimizer with $\beta _ { 1 } = 0 . 9 , \beta _ { 2 } = 0 . 9 9 $ ; for ResNet we use SGD with momentum $\ l = 0 . 9$ . We train ResNets for 90 epochs, and train ViTs and Mixers for 300 epochs following the settings in (Chen et al., 2021) and (Dosovitskiy et al., 2020). Considering that SAM and GSAM uses twice the computation of vanilla training for each step, for vanilla training we try $2 \times$ longer training, and does not find significant improvement as in Table. 5.
+
+We first search the optimal learning rate and weight decay for vanilla training, and keep these two hyper-parameters fixed for SAM and GSAM. For ViT and Mixer, we search $\rho$ in $\{ 0 . 1 , \bar { 0 . 2 } , 0 . 3 , 0 . 4 ,$ $0 . 5 , 0 . 6 \}$ for SAM and GSAM; for ResNet, we search $\rho$ from 0.01 to 0.05 with a stepsize 0.01. For ASAM, we amplify $\rho$ by $1 0 \times$ compared to SAM, as recommended by Kwon et al. (2021). For GSAM, we search $\alpha$ in $\{ 0 . 1 , 0 . 2 , 0 . 3 \}$ throughout the paper. We report the best configuration of each individual model in Table. 4.
+
+# B.2 TRANSFER LEARNING EXPERIMENTS
+
+Using weights trained on ImageNet-1k, we finetune models with SGD on downstream tasks including the CIFAR10/CIFAR100 (Krizhevsky et al., 2009), Oxford-flowers (Nilsback & Zisserman, 2008) and Oxford-IITPets (Parkhi et al., 2012). For all experiments, we use the SGD optimizer with no weight decay under a linear learning rate schedule and gradient clipping with global norm 1. We search the maximum learning rate in $\left. 0 . 0 0 1 , 0 . 0 0 3 , 0 . 0 1 , 0 . 0 3 \right.$ . On Cifar datasets, we train models for 10k steps with a warmup step of 500; on Oxford datasets, we train models for 500 steps with a wamup step of 100.
+
+# B.3 EXPERIMENTAL SETUP WITH ABLATION STUDIES ON DATA AUGMENTATION
+
+We follow the settings in (Tolstikhin et al., 2021) to perform ablation studies on data augmentation. In the left subfigure of Fig. 6, “Light” refers to Inception-style data augmentation with random flip and crop of images, “Medium” refers to the mixup augmentation with probability 0.2 and RandAug magnitude 10; “Strong” refers to the mixup augmentation with probability 0.2 and RandAug magnitude 15.
+
+# C ABLATION STUDIES AND DISCUSSIONS
+
+# C.1 INFLUENCE OF $\rho$ AND $\alpha$
+
+We plot the performance of a ViT-B/32 model varying with $\rho$ (Fig. 7a) and $\alpha$ (Fig. 7b). We empirically validate that fine-tuning $\rho$ in SAM can not achieve comparable performance with GSAM, as
+
+![](images/24eba187fef4c92575a570adcf3b277bd800c56050a22796582502f9883ba719.jpg)  
+Figure 7: Performance of GSAM varying with $\rho$ and $\alpha$
+
+Table 5: Top-1 accuracy of ViT-B/32 on ImageNet with Inception-style data augmentation. For vanilla training we report results for training 300 epochs and 600 epochs, for GSAM we report the results for 300 epochs.   
+
+<table><tr><td>Method</td><td>Epochs</td><td>ImageNet</td><td>ImageNet-Real</td><td>ImageNet-v2</td><td>ImageNet-R</td></tr><tr><td rowspan="2">Vanilla</td><td>300</td><td>71.4</td><td>77.5</td><td>57.5</td><td>23.4</td></tr><tr><td>600</td><td>72.0</td><td>78.2</td><td>57.9</td><td>23.6</td></tr><tr><td>GSAM</td><td>300</td><td>76.8</td><td>82.7</td><td>63.0</td><td>25.1</td></tr></table>
+
+shown in Fig. 7a. Considering that GSAM has one more parameter $\alpha$ , we plot the accuracy varying with $\alpha$ in Fig. 7b, and show that GSAM consistently outperforms SAM and vanilla training.
+
+# C.2 CONSTANT $\rho$ V.S. DECAYED $\rho _ { t }$ SCHEDULE
+
+Note that Thm. 5.1 assumes $\rho _ { t }$ to decay with $t$ in order to prove the convergence, while SAM uses a constant $\rho$ during training. To eliminate the influence of $\rho _ { t }$ schedule, we conduct ablation study as in Table. 6. The ascent step in GSAM can be applied to both constant $\rho$ or a decayed $\rho _ { t }$ schedule, and improves accuracy for both cases. Without ascent step, constant $\rho$ and decayed $\rho _ { t }$ achieve similar performance. Results in Table. 6 implies that the ascent step in GSAM is the main reason for improvement of generalization performance.
+
+![](images/9b390274fa28b5ba47c294dfef588e29c76201cc8670a2da5a44ef3d22931fcd.jpg)  
+Figure 8: The value of $\cos \theta _ { t }$ varying with training steps, where $\theta _ { t }$ is the angle between $\nabla f ( w _ { t } )$ and $\nabla f _ { p } ( w _ { t } )$ as in Fig. 2.
+
+![](images/c33dd62d4567c39ae55b11964e44b74a04f56f0f5e2ffdc6a47b45abc7f9be5f.jpg)  
+Figure 9: Surrogate gap curve under different $\alpha$ values.
+
+Table 6: Top-1 Accuracy on ViT-B/32 on ImageNet. Ablation studies on constant $\rho$ or a decayed $\rho _ { t }$   
+
+<table><tr><td>Vanilla</td><td>Constant p (SAM)</td><td>Constant ρ+ascent</td><td>Decayed ptI</td><td>Decayed pt+ascent</td></tr><tr><td>72.0</td><td>75.8</td><td>76.2</td><td>75.8</td><td>76.8</td></tr></table>
+
+# C.3 VISUALIZE THE TRAINING PROCESS
+
+In the proof of Thm. 5.3, our analysis relies on assumption that $\theta _ { t }$ is small. We empirically validated this assumption by plotting $\cos \theta _ { t }$ in Fig. 8, where $\theta _ { t }$ is the angle between $\nabla f ( \bar { w } _ { t } )$ and $\nabla f _ { p } ( w _ { t } )$ . Note that the cosine value is calculated in the parameter space of dimension $8 . 8 \times 1 0 ^ { 7 }$ , and in high-dimensional space two random vectors are highly likely to be perpendicular. In Fig. 8 the cosine value is always above 0.9, indicating that $\nabla f ( w _ { t } )$ and $\nabla f _ { p } ( w _ { t } )$ point to very close directions considering the high dimension of parameters. This empirically validates our assumption that $\theta _ { t }$ is small during training.
+
+We also plot the surrogate gap during training in Fig. 9. As $\alpha$ increases, the surrogate gap decreases, validating that the ascent step in GSAM efficiently minimizes the surrogate gap. Furthermore, the surrogate gap increases with training steps for any fixed $\alpha$ , indicating that the training process gradually falls into local minimum in order to minimize the training loss.
+
+# D RELATED WORKS
+
+Besides SAM and ASAM, other methods were proposed in the literature to improve generalization: Lin et al. (2020) proposed extrapolation of gradient, Xie et al. (2021) proposed to manipulate the noise in gradient, and Damian et al. (2021) proved label noise improves generalization, Yue et al. (2020) proposed to adjust learning rate according to sharpness, and Zheng et al. (2021) proposed model perturbation with similar idea to SAM. Izmailov et al. (2018) proposed averaging weights to improve generalization, and Heo et al. (2020) restricted the norm of updated weights to improve generalization. Many of aforementioned methods can be combined with GSAM to further improve generalization.
+
+Besides modified training schemes, there are other two types of techniques to improve generalization: data augmentation and model regularization. Data augmentation typically generates new data from training samples; besides standard data augmentation such as flipping or rotation of images, recent data augmentations include label smoothing (Muller et al., 2019) and mixup (M ¨ uller et al., ¨ 2019) which trains on convex combinations of both inputs and labels, automatically learned augmentation (Cubuk et al., 2018), and cutout (DeVries & Taylor, 2017) which randomly masks out parts of an image. Model regularization typically applies auxiliary losses besides the training loss such as weight decay (Loshchilov & Hutter, 2017), other methods randomly modify the model architecture during training, such as dropout (Srivastava et al., 2014) and shake-shake regularization (Gastaldi, 2017). Note that the data augmentation and model regularization literature mentioned here typically train with the standard back-propagation (Rumelhart et al., 1985) and first-order gradient optimizers, and both techniques can be combined with GSAM.
+
+Besides SGD, Adam and AdaBelief, GSAM can be combined with other first-order gradient optimizers, such as AdaBound (Luo et al., 2019), RAdam (Liu et al., 2019), Yogi (Zaheer et al., 2018), AdaGrad (Duchi et al., 2011), AMSGrad (Reddi et al., 2019) and AdaDelta (Zeiler, 2012).

parse/dev/hy0a5MMPUv/hy0a5MMPUv.md

@@ -0,0 +1,443 @@
+# IN-CONTEXT REINFORCEMENT LEARNING WITH ALGORITHM DISTILLATION
+
+Michael Laskin∗†, Luyu Wang∗, Junhyuk Oh, Emilio Parisotto, Stephen Spencer, Richie Steigerwald, DJ Strouse, Steven Hansen, Angelos Filos, Ethan Brooks, Maxime Gazeau, Himanshu Sahni, Satinder Singh, Volodymyr Mnih† DeepMind
+
+# ABSTRACT
+
+We propose Algorithm Distillation (AD), a method for distilling reinforcement learning (RL) algorithms into neural networks by modeling their training histories with a causal sequence model. Algorithm Distillation treats learning to reinforcement learn as an across-episode sequential prediction problem. A dataset of learning histories is generated by a source RL algorithm, and then a causal transformer is trained by autoregressively predicting actions given their preceding learning histories as context. Unlike sequential policy prediction architectures that distill post-learning or expert sequences, AD is able to improve its policy entirely in-context without updating its network parameters. We demonstrate that AD can reinforcement learn in-context in a variety of environments with sparse rewards, combinatorial task structure, and pixel-based observations, and find that AD learns a more data-efficient RL algorithm than the one that generated the source data.
+
+![](images/679c16b167e631679ba20610706e8543cd9d762d7dab80268efc9673f356c188.jpg)  
+Figure 1: Algorithm Distillation (AD) has two steps – (i) a dataset of learning histories is collected from individual single-task RL algorithms solving different tasks; (ii) a causal transformer predicts actions from these histories using across-episodic contexts. Since the RL policy improves throughout the learning histories, by predicting actions accurately AD learns to output an improved policy relative to the one seen in its context. AD models state-action-reward tokens, and does not condition on returns.
+
+# 1 INTRODUCTION
+
+Transformers have emerged as powerful neural network architectures for sequence modeling (Vaswani et al., 2017). A striking property of pre-trained transformers is their ability to adapt to downstream tasks through prompt conditioning or in-context learning. After pre-training on large offline datasets, large transformers have been shown to generalize to downstream tasks in text completion (Brown et al., 2020), language understanding (Devlin et al., 2018), and image generation (Yu et al., 2022).
+
+Recent work demonstrated that transformers can also learn policies from offline data by treating offline Reinforcement Learning (RL) as a sequential prediction problem. While Chen et al. (2021) showed that transformers can learn single-task policies from offline RL data via imitation learning, subsequent work showed that transformers can also extract multi-task policies in both same-domain (Lee et al., 2022) and cross-domain settings (Reed et al., 2022). These works suggest a promising paradigm for extracting generalist multi-task policies – first collect a large and diverse dataset of environment interactions, then extract a policy from the data via sequential modeling. We refer to the family of approaches that learns policies from offline RL data via imitation learning as Offline Policy Distillation, or simply Policy Distillation1 (PD).
+
+Despite its simplicity and scalability, a substantial drawback of PD is that the resulting policy does not improve incrementally from additional interaction with the environment. For instance, the MultiGame Decision Transformer (MGDT, Lee et al., 2022) learns a return-conditioned policy that plays many Atari games while Gato (Reed et al., 2022) learns a policy that solves tasks across diverse environments by inferring tasks through context, but neither method can improve its policy in-context through trial and error. MGDT adapts the transformer to new tasks by finetuning the model weights while Gato requires prompting with an expert demonstration to adapt to a new task. In short, Policy Distillation methods learn policies but not Reinforcement Learning algorithms.
+
+We hypothesize that the reason Policy Distillation does not improve through trial and error is that it trains on data that does not show learning progress. Current methods either learn policies from data that contains no learning (e.g. by distilling fixed expert policies) or data with learning (e.g. the replay buffer of an RL agent) but with a context size that is too small to capture policy improvement.
+
+Our key observation is that the sequential nature of learning within RL algorithm training could, in principle, make it possible to model the process of reinforcement learning itself as a causal sequence prediction problem. Specifically, if a transformer’s context is long enough to include policy improvement due to learning updates it should be able to represent not only a fixed policy but a policy improvement operator by attending to states, actions and rewards from previous episodes. This opens the possibility that any RL algorithm can be distilled into a sufficiently powerful sequence model such as a transformer via imitation learning, converting it into an in-context RL algorithm. By in-context RL we mean that the transformer should improve its policy through trial and error within the environment by attending to its context, without updating its parameters.
+
+We present Algorithm Distillation (AD), a method that learns an in-context policy improvement operator by optimizing a causal sequence prediction loss on the learning histories of an RL algorithm. AD has two components. First, a large multi-task dataset is generated by saving the training histories of an RL algorithm on many individual tasks. Next, a transformer models actions causally using the preceding learning history as its context. Since the policy improves throughout the course of training of the source RL algorithm, AD is forced to learn the improvement operator in order to accurately model the actions at any given point in the training history. Crucially, the transformer context size must be sufficiently large (i.e. across-episodic) to capture improvement in the training data. The full method is shown in Fig. 1.
+
+We show that by imitating gradient-based RL algorithms using a causal transformer with sufficiently large contexts, AD can reinforcement learn new tasks entirely in-context. We evaluate AD across a number of partially observed environments that require exploration, including the pixel-based Watermaze (Morris, 1981) from DMLab (Beattie et al., 2016). We show that AD is capable of in-context exploration, temporal credit assignment, and generalization. We also show that AD learns a more data-efficient algorithm than the one that generated the source data for transformer training. To the best of our knowledge, AD is the first method to demonstrate in-context reinforcement learning via sequential modeling of offline data with an imitation loss.
+
+# 2 BACKGROUND
+
+Partially Observable Markov Decision Processes: A Markov Decision Process (MDP) consists of states $s \in S$ , actions $a \in { \mathcal { A } }$ , rewards $r \in \mathcal { R }$ , a discount factor $\gamma$ , and a transition probability function $p ( s _ { t + 1 } | s _ { t } , a _ { t } )$ , where $t$ is an integer denoting the timestep and $( \cal { S } , \cal { A } )$ are state and action spaces. In environments described by an MDP, at each timestep $t$ the agent observes the state $s _ { t }$ , selects an action $a _ { t } \sim \pi ( \cdot | s _ { t } )$ from its policy, and then observes the next state $s _ { t + 1 } \sim p \big ( \cdot | s _ { t } , a _ { t } \big )$ sampled from the transition dynamics of the environment. In this work, we operate in the Partially Observable Markov Decision Process (POMDP) setting where instead of states $s \in S$ the agent receives observations $o \in \mathcal { O }$ that only have partial information about the true state of the environment. Full state information may be incomplete due to missing information about the goal in the environment, which the agent must instead infer through rewards with memory, or because the observations are pixel-based, or both.
+
+Online and Offline Reinforcement Learning: Reinforcement Learning algorithms aim to maximize the return, defined as the cumulative sum of rewards $\textstyle \sum _ { t } \gamma ^ { t } r _ { t }$ , throughout an agent’s lifetime or episode of training. RL algorithms broadly fall into two categories: on-policy algorithms (Williams, 1992) where the agent directly maximizes a Monte-Carlo estimate of the total returns or off-policy (Mnih et al., 2013; 2015) where an agent learns and maximizes a value function that approximates the total future return. Most RL algorithms maximize returns through trial-and-error by directly interacting with the environment. However, offline RL (Levine et al., 2020) has recently emerged as an alternate and often complementary paradigm for RL where an agent aims to extract return maximizing policies from offline data gathered by another agent. The offline dataset consists of $( s , a , r )$ tuples which are often used to train an off-policy agent, though other algorithms for extracting return maximizing policies from offline data are also possible.
+
+Self-Attention and Transformers The self-attention (Vaswani et al., 2017) operation begins by projecting input data $X$ with three separate matrices onto $D$ -dimensional vectors called queries $Q$ , keys $K$ , and values $V$ . These vectors are then passed through the attention function:
+
+$$
+\mathrm { A t t e n t i o n } ( Q , K , V ) = \mathrm { s o f t m a x } ( Q K ^ { T } / \sqrt { D } ) V .
+$$
+
+The $Q K ^ { T }$ term computes an inner product between two projections of the input data $X$ . The inner product is then normalized and projected back to a $D$ -dimensional vector with the scaling term $V$ . Transformers (Vaswani et al., 2017; Devlin et al., 2018; Brown et al., 2020) utilize self-attention as a core part of the architecture to process sequential data such as text sequences. Transformers are usually pre-trained with a self-supervised objective that predicts tokens within the sequential data. Common prediction tasks include predicting randomly masked out tokens (Devlin et al., 2018) or applying a causal mask and predicting the next token (Radford et al., 2018).
+
+Offline Policy Distillation: We refer to the family of methods that treat offline Reinforcement Learning as a sequential prediction problem as Offline Policy Distillation, or Policy Distillation (PD) for brevity. Rather than learning a value function from offline data, PD extracts policies by predicting actions in the offline data (i.e. behavior cloning) with a sequence model and either return conditioning (Chen et al., 2021; Lee et al., 2022) or filtering out suboptimal data (Reed et al., 2022). Initially proposed to learn single-task policies (Chen et al., 2021; Janner et al., 2021), PD was recently extended to learn multi-task policies from diverse offline data (Lee et al., 2022; Reed et al., 2022).
+
+In-Context Learning: In-context learning refers to the ability to infer tasks from context. For example, large language models like GPT-3 (Brown et al., 2020) or Gopher (Rae et al., 2021) can be directed at solving tasks such as text completion, code generation, and text summarization by specifying the task through language as a prompt. This ability to infer the task from prompt is often called in-context learning. We use the terms ‘in-weights learning’ and ‘in-context learning’ from prior work on sequence models (Brown et al., 2020; Chan et al., 2022) to distinguish between gradient-based learning with parameter updates and gradient-free learning from context, respectively.
+
+# 3 METHOD
+
+Over the course of its lifetime a capable reinforcement learning (RL) agent will exhibit complex behaviours, such as exploration, temporal credit assignment, and planning. Our key insight is that an agent’s actions, regardless of the environment it inhabits, its internal structure, and implementation, can be viewed as a function of its past experience, which we refer to as its history. Formally, we write:
+
+$$
+\mathcal { H } \ni h _ { t } : = \left( o _ { 0 } , a _ { 0 } , r _ { 0 } , \ldots , o _ { t - 1 } , a _ { t - 1 } , r _ { t - 1 } , o _ { t } , a _ { t } , r _ { t } \right) = \left( o _ { \leq t } , r _ { \leq t } , a _ { \leq t } \right)
+$$
+
+and we refer to a $l o n g ^ { 2 }$ history-conditioned policy as an algorithm:
+
+$$
+P : \mathcal { H } \cup \mathcal { O }  \Delta ( \mathcal { A } ) ,
+$$
+
+where $\Delta ( \mathcal { A } )$ denotes the space of probability distributions over the action space $\mathcal { A }$ . Eqn. (3) suggests that, similar to a policy, an algorithm can be unrolled in an environment to generate sequences of observations, rewards, and actions. For brevity, we denote the algorithm as $P$ and environment (i.e. task) as $\mathcal { M }$ , such that the history of learning for any given task $\mathcal { M }$ is generated by the algorithm $P _ { \mathcal { M } }$ .
+
+$$
+( O _ { 0 } , A _ { 0 } , R _ { 0 } , \ldots , O _ { T } , A _ { T } , R _ { T } ) \sim P _ { \mathcal { M } } .
+$$
+
+Here, we’re denoting random variables with uppercase Latin letters, e.g. $O , A , R$ , and their values with lowercase Latin letters, $e . g . \ o , a , r$ . By viewing algorithms as long history-conditioned policies, we hypothesize that any algorithm that generated a set of learning histories can be distilled into a neural network by performing behavioral cloning over actions. Next, we present a method that, provided agents’ lifetimes, learns a sequence model with behavioral cloning to map long histories to distributions over actions.
+
+# 3.1 ALGORITHM DISTILLATION
+
+Suppose the agents’ lifetimes, which we also call learning histories, are generated by the source algorithm $P ^ { \mathrm { s o u r c e } }$ for many individual tasks $\{ \mathcal { M } _ { n } \} _ { n = 1 } ^ { N }$ , producing the dataset $\mathcal { D }$ :
+
+$$
+\begin{array} { r } { \mathcal { D } : = \left\{ \left( o _ { 0 } ^ { ( n ) } , a _ { 0 } ^ { ( n ) } , r _ { 0 } ^ { ( n ) } , \ldots , o _ { T } ^ { ( n ) } , a _ { T } ^ { ( n ) } , r _ { T } ^ { ( n ) } \right) \sim P _ { \mathcal { M } _ { n } } ^ { \mathrm { s o u r c e } } \right\} _ { n = 1 } ^ { N } . } \end{array}
+$$
+
+Then we distill the source algorithm’s behaviour into a sequence model that maps long histories to probabilities over actions with a negative log likelihood (NLL) loss and refer to this process as algorithm distillation (AD). In this work, we consider neural network models $P _ { \theta }$ with parameters $\theta$ which we train by minimizing the following loss function:
+
+$$
+\mathcal { L } ( \theta ) : = - \sum _ { n = 1 } ^ { N } \sum _ { t = 1 } ^ { T - 1 } \log P _ { \theta } ( A = a _ { t } ^ { ( n ) } | h _ { t - 1 } ^ { ( n ) } , o _ { t } ^ { ( n ) } ) .
+$$
+
+Intuitively, a sequence model with fixed parameters that is trained with AD should amortise the source RL algorithm $P ^ { \mathrm { s o u r c e } }$ and by doing so exhibit similarly complex behaviours, such as exploration and temporal credit assignment. Since the RL policy improves throughout the learning history of the source algorithm, accurate action prediction requires the sequence model to not only infer the current policy from the preceding context but also infer the improved policy, therefore distilling the policy improvement operator.
+
+# Algorithm 1 Algorithm Distillation
+
+Require: Train $\{ \mathcal { M } ^ { \mathrm { t r a i n } } \}$ and test $\{ \mathcal { M } ^ { \mathrm { t e s t } } \}$ tasks, observations $o \in \mathcal { O }$ , actions $a \in { \mathcal { A } }$ , and rewards $r \in \mathcal { R }$ . Require: Network parameters $\phi _ { i }$ for $i = 1 , \ldots , N$ source RL algorithms.   
+Require: Network parameters $\theta$ for a causal transformer $P _ { \theta }$ that predicts actions.   
+Require: An empty buffer to store data $\mathcal { D }$ .   
+1: for $i = 1 \dots N$ do ▷ Part 1: Dataset Generation 2: Sample a task $\mathcal { M } _ { i } ^ { \mathrm { t r a i n } }$ randomly from the train task distribution.   
+3: Train the source RL algorithm $\phi _ { i }$ until it converges to the optimal policy.   
+4: Save the learning history $h _ { T } ^ { ( i ) } = ( o _ { 0 } , a _ { 0 } , r _ { 0 } , \ldots , o _ { T } , a _ { T } , r _ { T } ) _ { i }$ to the dataset $\mathcal { D }  \mathcal { D } \cup h _ { T } ^ { ( i ) }$ . 5: end for   
+6: while $P _ { \theta }$ not converged do ▷ Part 2: Algorithm Distillation 7: Randomly sample a multi-episodic subsequence $\bar { h } _ { j } ^ { ( i ) } = \left( o _ { j } , a _ { j } , r _ { j } , \dotsc , o _ { j + c } , a _ { j + c } , r _ { j + c } \right) _ { i }$ of length $c$ 8: Autoregressively predict the actions with $P _ { \theta }$ and compute the NLL loss in Eq. 6.   
+9: Backpropagate to update the transformer parameters.   
+10: end while   
+11: for $k = 1 \dots M _ { \mathrm { s e e d s } }$ do ▷ Part 3: Autoregressive Evaluation 12: Sample a task $\mathcal { M } _ { k } ^ { \mathrm { t e s t } }$ randomly from the test task distribution. Initialize empty context queue $C$ . 13: Unroll the transformer $P _ { \theta } ( \cdot | C )$ in the environment storing sequential transitions (i.e. histories) in $C$ . 14: Measure the return accumulated by the agent for each episode of evaluation.   
+15: end for
+
+# 3.2 PRACTICAL IMPLEMENTATION
+
+In practice, we implement AD as a two-step procedure. First, a dataset of learning histories is collected by running an individual gradient-based RL algorithm on many different tasks. Next, a sequence model with multi-episodic context is trained to predict actions from the histories. We describe these two steps below and detail the full practical implementation in Algorithm 1.
+
+Dataset Generation: A dataset of learning histories is collected by training $N$ individual single-task gradient-based RL algorithms. To prevent overfitting to any specific task during sequence model training, a task $\mathcal { M }$ is sampled randomly from a task distribution for each RL run. The data generation step is RL algorithm agnostic - any RL algorithm can be distilled. We show results distilling UCB exploration (Lai & Robbins, 1985), an on-policy actor-critic (Mnih et al., 2016), and an off-policy DQN (Mnih et al., 2013), in both distributed and single-stream settings. We denote the dataset of learning histories as $\mathcal { D }$ in Eq. 5.
+
+Training the Sequence Model: Once a dataset of learning histories $\mathcal { D }$ is collected, a sequential prediction model is trained to predict actions given the preceding histories. We utilize the GPT (Radford et al., 2018) causal transformer model for sequential action prediction, but AD is compatible with any sequence model including RNNs (Williams & Zipser, 1989). For instance, we show in Appendix $\mathrm { L }$ that AD can also be achieved with an LSTM (Hochreiter & Schmidhuber, 1997), though less effectively than AD with causal transformers. Since causal transformer training and inference are quadratic in the sequence length, we sample across-episodic subsequences $\bar { h _ { j } } ^ { - } = \left( o _ { j } , r _ { j } , a _ { j } \ldots , o _ { j + c } , r _ { j + c } , a _ { j + c } \right)$ of length $c < T$ from $\mathcal { D }$ rather than training full histories.
+
+# 4 EXPERIMENTAL SETUP
+
+# 4.1 ENVIRONMENTS
+
+To investigate the in-context RL capabilities of AD and the baselines (see next section), we focus on environments that cannot be solved through zero-shot generalization after pre-training. Specifically, we require that each environment supports many tasks, that the tasks cannot be inferred easily from the observation, and that episodes are short enough to feasibly train across-episodic causal transformers - for more details regarding environments see Appendix B. We list the evaluation environments below:
+
+Adversarial Bandit: a multi-armed bandit with 10 arms and 100 trials similar to the environment considered in $\mathrm { { R L ^ { 2 } } }$ (Duan et al., 2016). However, during evaluation the reward is out of distribution. Reward is more likely distributed under odd arms $9 5 \%$ of the time during training. At evaluation, the opposite happens - reward appears more often under even arms $9 5 \%$ of the time.
+
+![](images/a3da0f2d56a2dea7e0ac773cbc4072974da4d3b19ed7b19d036e66b3977c8b9e.jpg)  
+Figure 2: Agent view from the DMLab Watermaze environment. The task is to find a hidden platform that elevates once found.
+
+Dark Room: a 2D discrete POMDP where an agent spawns in a room and must find a goal location. The agent only knows its own $( x , y )$ coordinates but does not know the goal location and must infer it from the reward. The room size is $9 \times 9$ , the possible actions are one step left, right, up, down, and no-op, the episode length is 20, and the agent resets at the center of the map. We test two environment variants – Dark Room where the agent receives $r = 1$ every time the goal is reached and Dark Room Hard, a hard exploration variant with a $1 7 \times 1 7$ size and sparse reward $\mathbf { \boldsymbol { r } } = 1$ exactly once for reaching the goal). When not $r = 1$ , then $r = 0$ .
+
+Dark Key-to-Door: similar to Dark Room but this environment requires an agent to first find an invisible key upon which it receives a reward of $r = 1$ once and then open an invisible door upon which it receives a reward of $r = 1$ once again. Otherwise, the reward is $r = 0$ . The room size is $9 \times 9$ making the task space combinatorial with $8 1 ^ { 2 } = 6 5 6 1$ possible tasks. This environment is similar to the one considered in Chen et al. (2021) except the key and door are invisible and the reward is semisparse $\boldsymbol { r } = 1$ for both key and the door). The agent is randomly reset. The episode length is 50 steps.
+
+DMLab Watermaze: a partially observable 3D visual DMLab environment based on the classic Morris Watermaze (Morris, 1981). The task is to navigate the water maze to find a randomly spawned trap-door. The maze walls have color patterns that can be used to remember the goal location. Observations are pixel images of size $7 2 \times 9 6 \times 3$ . There are 8 possible actions in total, including going forward, backward, left, or right, rotating left or right, and rotating left or right while going forward. The episode length is 50, and the agent resets at the center of the map. Similar to Dark
+
+![](images/d5537f516f3e701ce2d1f385b3b62e3325664799bf1950f1bd449d7fede0b517.jpg)  
+Figure 3: Adversarial Bandit (Section 5): AD, $\mathrm { { R L } ^ { 2 } }$ , and ED evaluated on a 10-arm bandit with 100 trials. The source data for AD comes from learning histories from UCB (Lai & Robbins, 1985). During training, the reward is distributed under odd arms $9 5 \%$ of the time and under even arms $9 5 \%$ of the time during evaluation. Both AD and $\mathrm { { R L } ^ { 2 } }$ can in-context learn in-distribution tasks, but AD generalizes better out of distribution. Running $\mathrm { { R L } ^ { 2 } }$ with a transformer generally doesn’t offer an advantage over the original LSTM variant. ED performs poorly both in and out of distribution relative to AD and $\mathrm { { R L } ^ { 2 } }$ . Scores are normalized relative to UCB.
+
+Room, the agent cannot see the location of the goal from the observations and must infer it through the reward of $r = 1$ if reached and $r = 0$ otherwise; however, the goal space is continuous and therefore there are an infinite number of goals.
+
+# 4.2 BASELINES
+
+The main aim of this work is to investigate to what extent AD reinforcement learns in-context relative to prior related work. AD is mostly closely related to Policy Distillation, where a policy is learned with a sequential model from offline interaction data. In-context online meta-RL is also related though not directly comparable to AD, since AD is an in-context offline meta-RL method. Still, we consider both types of baselines to better contextualize our work. For a more detailed discussion of these baseline choices we refer the reader to Appendix C. Our baselines include:
+
+Expert Distillation $( E D )$ : this baseline is exactly the same as AD but the source data consists of expert trajectories only, rather than learning histories. ED is most similar to Gato (Reed et al., 2022) except ED models state-action-reward sequences like AD, while Gato models state-action sequences.
+
+Source Algorithm: we compare AD to the gradient-based source RL algorithm that generates the training data for distillation. We include running the source algorithm from scratch as a baseline to compare the data-efficiency of in-context RL to the in-weights source algorithm.
+
+$R L ^ { 2 }$ (Duan et al., 2016): an online meta-RL algorithm where exploration and fast in-context adaptation are learned jointly by maximizing a multi-episodic value function. $\mathrm { { R L } ^ { 2 } }$ is not directly comparable to AD for similar reasons to why online and offline RL algorithms are not directly comparable – RL2 gets to interact with the environment during training while AD does not. We use $\mathrm { { R L } ^ { 2 } }$ asymptotic performance as an approximate upper bound for AD.
+
+# 4.3 EVALUATION
+
+After pre-training, the AD transformer $P _ { \theta }$ can reinforcement learn in-context. Evaluation is exactly the same as with an in-weights RL algorithm except the learning happens entirely in-context without updating the transformer network parameters. Given an MDP (or POMDP), the transformer interacts with the environment and populates its own context (i.e. without demonstrations), where the context is a queue containing the last $c$ transitions. The transformer’s performance is then evaluated in terms of its ability to maximize return. For all evaluation runs, we average results across 5 training seeds with 20 evaluation seeds each for a total of 100 seeds. A task $\mathcal { M }$ is sampled uniformly from the test task distribution and fixed for each evaluation seed. The aggregate statistics reported reflect multi-task performance. We evaluate for 1000 and 160 episodes for the Dark and Watermaze environments respectively and plot performance as a function of total environment steps at test-time.
+
+# 5 EXPERIMENTS
+
+The main research question of this work is whether an in-weights RL algorithm can be amortized into an in-context one via Algorithm Distillation. The in-context RL algorithm should behave in a similar way as the in-weights one and exhibit exploration, credit assignment, and generalization capabilities. We begin our analysis in a clean and simple experimental setting where all three properties are required to solve the task - the Adversarial Bandit described in Sec. 4.
+
+![](images/9ee4c7c970fbe6d5f893cf896ce23072080991bcd6e0b43221766e63d5068738.jpg)  
+Figure 4: Main results: we evaluate AD, $\mathrm { { R L } ^ { 2 } }$ , ED, and the source algorithm on environments that require memory and exploration. In these environments, an agent must reach a goal location that can only be inferred through a binary reward. AD is consistently able to in-context reinforcement learn across all environments and is more data-efficient than the A3C (“Dark” environments) (Mnih et al., 2016) or DQN (Watermaze) (Mnih et al., 2013) source algorithm it distilled. We report the mean return $\pm \nobreakspace 1 \nobreakspace$ standard deviation over 5 training seeds with 20 test seeds each.
+
+To generate the source data, we sample a set of training tasks Bound algorithm (Lai & Robbins, 1985), and save its learning $\{ \mathcal { M } _ { j } \} _ { j = 1 } ^ { N }$ , run the Upper Confidence We then train a transformer to predict actions as described in Alg. 1. We evaluate AD, ED, and $\mathrm { { R L } ^ { 2 } }$ and normalize their scores relative to UCB and a random policy $( r - r _ { r a n d . } ) / ( r _ { U C B } - r _ { r a n d . } )$ . The results are shown in Fig. 3. We find that both AD and $\mathtt { R L } ^ { 2 }$ can reliably in-context learn tasks sampled from the training distribution while ED cannot, though ED does do better than random guessing when evaluated in-distribution. However, AD can also in-context learn to solve out of distribution tasks whereas the other methods cannot. This experiment shows that AD can explore the bandit arms, can assign credit by exploiting an arm once reached, and can generalize well out of distribution nearly as well as UCB. We now move beyond the bandit setting and investigate similar research questions in more challenging RL environments and present our results as answers to a series of research questions.
+
+Does Algorithm Distillation exhibit in-context reinforcement learning? To answer this question, we first generate source data for Algorithm Distillation. In the Dark Room and Dark Key-to-Door environments we collect 2000 learning histories with an Asynchronous Advantage Actor-Critic (A3C) (Mnih et al., 2016) with 100 actors, while in DMLab Watermaze we collect 4000 learning histories with a distributed DQN with 16 parallel actors (see Appendix F for asymptotic learning curves of the source algorithm and Appendix O for hyperparameters). Shown in Fig. 4, AD in-context reinforcement learns in all of the environments. In contrast, ED fails to explore and learn in-context in most settings. We use $\mathrm { { R L } ^ { 2 } }$ trained for 1 billion environment steps as a proxy for the upper bound of performance for a meta-RL method. $\mathrm { { R L ^ { 2 } } }$ achieves a near-optimal asymptotic score in all the environments except for Dark Room (Hard). Despite learning from offline data, AD matches asymptotic $\mathtt { R L } ^ { 2 }$ on the Dark environments and approaches it (within $1 3 \%$ ) on Watermaze.
+
+Credit-assignment: In Dark Room, the agent receives $r = 1$ each time it visits the goal location. Even though AD is trained to condition only on single timestep reward and not episodic return tokens, it is still able to maximize the reward, which suggests that AD has learned to do credit assignment.
+
+Exploration: Dark Room (Hard) tests the agents exploration capability. Since the reward is sparse $r = 1$ exactly once), most of the learning history has reward values of $r = 0$ . Nevertheless, AD infers the goal from previous episodes in its context which means it has learned to explore and exploit.
+
+Generalization: Dark Key-to-Door tests in-distribution generalization with a combinatorial task space. While the environment has a total of $\sim 6 . 5 \mathrm { k }$ tasks, less than 2k were seen during training. During evaluation, AD both generalizes and achieves near-optimal performance on mostly unseen tasks.
+
+Can Algorithm Distillation learn from pixel-based observations? DMLab Watermaze is a pixelbased environment that is larger than the Dark environments with tasks sampled from a continuous uniform distribution. The environment is partially observable in two ways - the goal is invisible until the agent has reached it and the first-person view limits the agent’s field of vision. Shown in Fig. 4, AD maximizes the episodic return with in-context RL while ED does not learn.
+
+Can AD learn a more data-efficient RL algorithm than the one that produced the source data? In Fig. 4, AD is significantly more data-efficient than the source algorithm. This gain is a byproduct of distilling a multi-stream algorithm into a single-stream one. The source algorithms (A3C and DQN) are distributed, which means they run many actors in parallel to achieve good performance.3 A distributed RL algorithm may not be very data-efficient in aggregate but each individual actor can be data-efficient. Since the learning history for each actor is saved separately,
+
+![](images/e72730fa811ddedf85713313c74350731b168f42cfdbd85e088031cd6898d726.jpg)  
+Figure 5: $A D$ and $E D$ conditioned on partial demonstrations: We compare the performance of AD and ED when prompted with a demonstration from the source algorithm’s training history on Dark Room (semi-dense). While ED slightly improves and then maintains performance from the input policy, AD is able to improve it in-context until the policy is optimal or nearly optimal.
+
+AD achieves similar performance to the multi-stream distributed RL algorithm, but is more data-efficient as a single-stream method.
+
+These data-efficiency gains are also evident for distilling single-stream algorithms. In Fig 6 we show that by subsampling every $k$ -th episode (where $k = 1 0$ ) from a single stream A3C learning history, AD can still learn a more data-efficient in-context RL algorithm (for more detail, see Appendix J). Therefore, AD can be more data-efficient than both a multi and single-stream source RL algorithm.
+
+![](images/c652f1346777c272cd0157cbac3dddfaa6bac8bab0398dde13e052045c590f1e.jpg)  
+Figure 6: Single-stream Algorithm Distillation: AD trained on the learning history from an A3C agent with only one actor (i.e. single-stream). By training on subsampled learning histories (see Sec. 5), AD learns are more data-efficient in-context RL algorithm.
+
+While AD is more data-efficient, the source algorithm achieves slightly higher asymptotic performance (see Appendix F). However, the source algorithm produces many single-task agents with a unique set of weights $\phi _ { n }$ per task $\mathcal { M } _ { n }$ , while AD produces a single generalist agent with weights $\theta$ that are fixed across all tasks.
+
+Is it possible to accelerate AD by prompting it with demonstrations? Although AD can reinforcement learn without relying on demonstrations, it has the added benefit that, unlike the source algorithm, it can be conditioned on or prompted with external data. To answer the research question, we sample policies from the hold-out test-set data along different points of the source algorithm history - from a near-random policy to a near-expert policy. We then pre-fill the context for both AD and ED with this policy data, and run both methods in the environment in Dark Room (Fig. 5). While ED maintains the performance of the input policy, AD improves every policy in-context until it is near-optimal. Importantly, the more optimal the input policy the faster AD improves it until it is optimal.
+
+![](images/326a444f7a476152beb4d779e7e9c87e058d5d0329f877516a605551d10515aa.jpg)  
+Figure 7: Context size: AD in Dark Key-toDoor with different context sizes. In-context RL only emerges once the context size is large enough and across-episodic.
+
+What context size is required for in-context RL to emerge? We’ve hypothesized that AD requires sufficiently long (i.e. across-episodic) contexts to in-context reinforcement learn. We test this hypothesis by training several AD variants with different context sizes on the Dark Room environment. We plot the learning curves of these different variants in Fig. 7 and find that multi-episodic contexts of 2-4 episodes are necessary to learn a near-optimal in-context RL algorithm. Initial signs of in-context RL begin to emerge when the context size is roughly the length of an episode. The reason for this is likely that the context is large enough to retrain across-episodic information – e.g., at the start of a new episode, the context will be filled with transitions from most of the previous episode.
+
+# 6 RELATED WORK
+
+Offline Policy Distillation: Most closely related to our work are the recent advances in learning policies from offline environment interaction data with transformers, which we have been referring to as Policy Distillation (PD). Initial PD architectures such as Decision Transformer (DT) (Chen et al., 2021) and Trajectory Transformer (Janner et al., 2021) showed that transformers can learn single-task policies from offline data. Subsequently the Multi-Game Decision Transformer (MGDT) (Lee et al., 2022) and Gato (Reed et al., 2022) showed that PD architectures can also learn multi-task same domain and cross-domain policies, respectively. Importantly, these prior methods use contexts substantially smaller than an episode length, which is likely the reason in-context RL was not observed in these works. Instead, they rely on alternate ways to adapt to new tasks - MGDT finetunes the model parameters while Gato gets prompted with expert demonstrations to adapt to downstream tasks. AD adapts in-context without finetuning and does not rely on demonstrations. A number of recent works have explored more generalized PD architectures (Furuta et al., 2021), prompt conditioning (Xu et al., 2022), and online gradient-based RL (Zheng et al., 2022). Some PD architectures such as DT and MGDT are instantiations of Upside Down RL (UDRL) Schmidhuber (2019); Srivastava et al. (2019) where rather than learning a value function, a policy is conditioned directly on the desired return. However, AD is not explicitly doing UDRL since it is not conditioned on returns. In fact, return maximization is not specified anywhere in the AD objective but rather emerges implicitly by modeling the learning histories of an RL algorithm.
+
+Meta Reinforcement Learning: AD falls into the category of methods that learn to reinforcement learn, also known as meta-RL. Specifically, AD is an in-context offline meta-RL method. This general idea of learning the policy improvement process has a long history in reinforcement learning, but has been limited to meta-learning hyper-parameters4 until recently (Ishii et al., 2002). In-context deep meta-RL methods introduced by Wang et al. (2016) and Duan et al. (2016) are usually trained in the online setting by maximizing multi-episodic value functions with memory-based architectures through environment interactions (Ni et al., 2022). Meta-RL through multi-episodic value functions has been done in both on-policy (Duan et al., 2016) and off-policy (Rakelly et al., 2019; Fakoor et al., 2020) settings. Another common approach to online meta-RL includes optimization-based methods that find good network parameter initializations for meta-RL (Hochreiter et al., 2001; Finn et al., 2017; Nichol et al., 2018) and adapt by taking additional gradient steps. Like other in-context meta-RL approaches, AD is gradient-free - it adapts to downstream tasks without updating its network parameters. Recent works have proposed learning to reinforcement learn from offline datasets, or offline meta-RL, using Bayesian RL (Dorfman et al., 2021) and optimization-based meta-RL (Mitchell et al., 2021). Given the difficulty of offline meta-RL, Pong et al. (2022) proposed a hybrid offline-online strategy for meta-RL.
+
+In-Context Learning with Transformers: In this work, we make the distinction between in-context learning and incremental or in-context learning. In-context learning involves learning from a provided prompt or demonstration while incremental in-context learning involves learning from one’s own behavior through trial and error. While many recent works have demonstrated the former, it is much less common to see methods that exhibit the latter. Arguably, the most impressive demonstrations of in-context learning to date have been shown in the text completion setting (Radford et al., 2018; Chen et al., 2020; Brown et al., 2020) through prompt conditioning. Similar methodology was recently extended to show powerful composability properties in text-conditioned image generation (Yu et al., 2022). Recent work showed that transformers can also learn simple algorithm classes, such as linear regression, in-context in a small-scale setting (Garg et al., 2022). Like prior in-context learning methods, Garg et al. (2022) required initializing the transformer prompt with expert examples. While the aforementioned approaches were examples of in-context learning, a recent work (Chen et al., 2022) demonstrated incremental in-context learning for hyperparameter optimization by treating hyperparameter optimization as a sequential prediction problem with a score function.
+
+# 7 CONCLUSION
+
+We have demonstrated that can distill RL algorithms by modeling their learning histories causally with imitation learning and that AD can learn more data-efficient algorithms than those that generated the source data. We hope that AD inspires further investigation into in-context reinforcement learning from the research community.
+
+# REFERENCES
+
+Charles Beattie, Joel Z. Leibo, Denis Teplyashin, Tom Ward, Marcus Wainwright, Heinrich Kuttler, ¨ Andrew Lefrancq, Simon Green, V´ıctor Valdes, Amir Sadik, Julian Schrittwieser, Keith Anderson, ´ Sarah York, Max Cant, Adam Cain, Adrian Bolton, Stephen Gaffney, Helen King, Demis Hassabis, Shane Legg, and Stig Petersen. DeepMind Lab. CoRR, abs/1612.03801, 2016.
+
+Tom B Brown, Benjamin Mann, Nick Ryder, Melanie Subbiah, Jared Kaplan, Prafulla Dhariwal, Arvind Neelakantan, Pranav Shyam, Girish Sastry, Amanda Askell, et al. Language models are few-shot learners. arXiv preprint arXiv:2005.14165, 2020.
+
+Stephanie CY Chan, Adam Santoro, Andrew K Lampinen, Jane X Wang, Aaditya Singh, Pierre H Richemond, Jay McClelland, and Felix Hill. Data Distributional Properties Drive Emergent In-Context Learning in Transformers. arXiv preprint arXiv:2205.05055, 2022.
+
+Lili Chen, Kevin Lu, Aravind Rajeswaran, Kimin Lee, Aditya Grover, Misha Laskin, Pieter Abbeel, Aravind Srinivas, and Igor Mordatch. Decision transformer: Reinforcement learning via sequence modeling. Advances in neural information processing systems, 34:15084–15097, 2021.
+
+Mark Chen, Alec Radford, Rewon Child, Jeffrey Wu, Heewoo Jun, David Luan, and Ilya Sutskever. Generative pretraining from pixels. In International Conference on Machine Learning, pp. 1691– 1703. PMLR, 2020.
+
+Yutian Chen, Xingyou Song, Chansoo Lee, Zi Wang, Qiuyi Zhang, David Dohan, Kazuya Kawakami, Greg Kochanski, Arnaud Doucet, Marc’aurelio Ranzato, Sagi Perel, and Nando de Freitas. Towards Learning Universal Hyperparameter Optimizers with Transformers, 2022.
+
+Jacob Devlin, Ming-Wei Chang, Kenton Lee, and Kristina Toutanova. Bert: Pre-training of deep bidirectional transformers for language understanding. arXiv preprint arXiv:1810.04805, 2018.
+
+Ron Dorfman, Idan Shenfeld, and Aviv Tamar. Offline Meta Reinforcement Learning–Identifiability Challenges and Effective Data Collection Strategies. Advances in Neural Information Processing Systems, 34:4607–4618, 2021.
+
+Yan Duan, John Schulman, Xi Chen, Peter L. Bartlett, Ilya Sutskever, and Pieter Abbeel. RL2: Fast Reinforcement Learning via Slow Reinforcement Learning, 2016.
+
+Rasool Fakoor, Pratik Chaudhari, Stefano Soatto, and Alexander J. Smola. Meta-q-learning. In International Conference on Learning Representations, 2020. URL https://openreview. net/forum?id=SJeD3CEFPH.
+
+Chelsea Finn, Pieter Abbeel, and Sergey Levine. Model-agnostic meta-learning for fast adaptation of deep networks. In International conference on machine learning, pp. 1126–1135. PMLR, 2017.
+
+Sebastian Flennerhag, Yannick Schroecker, Tom Zahavy, Hado van Hasselt, David Silver, and Satinder Singh. Bootstrapped meta-learning. In International Conference on Learning Representations, 2022. URL https://openreview.net/forum?id=b-ny3x071E5.
+
+Hiroki Furuta, Yutaka Matsuo, and Shixiang Shane Gu. Generalized decision transformer for offline hindsight information matching. arXiv preprint arXiv:2111.10364, 2021.
+
+Shivam Garg, Dimitris Tsipras, Percy Liang, and Gregory Valiant. What Can Transformers Learn In-Context? A Case Study of Simple Function Classes, 2022.
+
+Matteo Hessel, Ivo Danihelka, Fabio Viola, Arthur Guez, Simon Schmitt, Laurent Sifre, Theophane Weber, David Silver, and Hado van Hasselt. Muesli: Combining Improvements in Policy Optimization. In Marina Meila and Tong Zhang (eds.), Proceedings of the 38th International Conference on Machine Learning, ICML 2021, 18-24 July 2021, Virtual Event, volume 139 of Proceedings of Machine Learning Research, pp. 4214–4226. PMLR, 2021.
+
+Sepp Hochreiter and Jurgen Schmidhuber. ¨ Long Short-Term Memory. Neural Computation, 9(8): 1735–1780, 1997.
+
+Sepp Hochreiter, A Steven Younger, and Peter R Conwell. Learning to learn using gradient descent. In International conference on artificial neural networks, pp. 87–94. Springer, 2001.
+
+Shin Ishii, Wako Yoshida, and Junichiro Yoshimoto. Control of exploitation–exploration metaparameter in reinforcement learning. Neural networks, 15(4-6):665–687, 2002.
+
+Michael Janner, Qiyang Li, and Sergey Levine. Reinforcement Learning as One Big Sequence Modeling Problem. arXiv preprint arXiv:2106.02039, 2021.
+
+T.L Lai and Herbert Robbins. Asymptotically Efficient Adaptive Allocation Rules. Adv. Appl. Math., 6(1):4–22, mar 1985. ISSN 0196-8858. doi: 10.1016/0196-8858(85)90002-8.
+
+Kuang-Huei Lee, Ofir Nachum, Mengjiao Yang, Lisa Lee, Daniel Freeman, Winnie Xu, Sergio Guadarrama, Ian Fischer, Eric Jang, Henryk Michalewski, and Igor Mordatch. Multi-Game Decision Transformers, 2022.
+
+Sergey Levine, Aviral Kumar, George Tucker, and Justin Fu. Offline reinforcement learning: Tutorial, review, and perspectives on open problems. arXiv preprint arXiv:2005.01643, 2020.
+
+Eric Mitchell, Rafael Rafailov, Xue Bin Peng, Sergey Levine, and Chelsea Finn. Offline metareinforcement learning with advantage weighting. In International Conference on Machine Learning, pp. 7780–7791. PMLR, 2021.
+
+Volodymyr Mnih, Koray Kavukcuoglu, David Silver, Alex Graves, Ioannis Antonoglou, Daan Wierstra, and Martin Riedmiller. Playing atari with deep reinforcement learning. arXiv preprint arXiv:1312.5602, 2013.
+
+Volodymyr Mnih, Koray Kavukcuoglu, David Silver, Andrei A Rusu, Joel Veness, Marc G Bellemare, Alex Graves, Martin Riedmiller, Andreas K Fidjeland, Georg Ostrovski, et al. Human-level control through deep reinforcement learning. nature, 518(7540):529–533, 2015.
+
+Volodymyr Mnih, Adria Puigdom \` enech Badia, Mehdi Mirza, Alex Graves, Timothy P. Lillicrap, Tim \` Harley, David Silver, and Koray Kavukcuoglu. Asynchronous Methods for Deep Reinforcement Learning. In Maria-Florina Balcan and Kilian Q. Weinberger (eds.), Proceedings of the 33nd International Conference on Machine Learning, ICML 2016, New York City, NY, USA, June 19-24, 2016, volume 48 of JMLR Workshop and Conference Proceedings, pp. 1928–1937. JMLR.org, 2016.
+
+Richard G.M. Morris. Spatial localization does not require the presence of local cues. Learning and Motivation, 12(2):239–260, 1981. doi: 10.1016/0023-9690(81)90020-5.
+
+Rafael Muller, Simon Kornblith, and Geoffrey E Hinton.¨ When does label smoothing help? In H. Wallach, H. Larochelle, A. Beygelzimer, F. d'Alche-Buc, E. Fox, and R. Gar- ´ nett (eds.), Advances in Neural Information Processing Systems, volume 32. Curran Associates, Inc., 2019. URL https://proceedings.neurips.cc/paper/2019/file/ f1748d6b0fd9d439f71450117eba2725-Paper.pdf.
+
+Tianwei Ni, Benjamin Eysenbach, and Ruslan Salakhutdinov. Recurrent model-free RL can be a strong baseline for many pomdps. In Kamalika Chaudhuri, Stefanie Jegelka, Le Song, Csaba Szepesvari, Gang Niu, and Sivan Sabato (eds.), ´ International Conference on Machine Learning, ICML 2022, 17-23 July 2022, Baltimore, Maryland, USA, volume 162 of Proceedings of Machine Learning Research, pp. 16691–16723. PMLR, 2022. URL https://proceedings.mlr. press/v162/ni22a.html.
+
+Alex Nichol, Joshua Achiam, and John Schulman. On First-Order Meta-Learning Algorithms, 2018.
+
+Vitchyr H Pong, Ashvin V Nair, Laura M Smith, Catherine Huang, and Sergey Levine. Offline meta-reinforcement learning with online self-supervision. In International Conference on Machine Learning, pp. 17811–17829. PMLR, 2022.
+
+Alec Radford, Karthik Narasimhan, Tim Salimans, Ilya Sutskever, et al. Improving language understanding by generative pre-training, 2018.
+
+ack W. Rae, Sebastian Borgeaud, Trevor Cai, Katie Millican, Jordan Hoffmann, Francis Song, John Aslanides, Sarah Henderson, Roman Ring, Susannah Young, Eliza Rutherford, Tom Hennigan, Jacob Menick, Albin Cassirer, Richard Powell, George van den Driessche, Lisa Anne Hendricks, Maribeth Rauh, Po-Sen Huang, Amelia Glaese, Johannes Welbl, Sumanth Dathathri, Saffron Huang, Jonathan Uesato, John Mellor, Irina Higgins, Antonia Creswell, Nat McAleese, Amy Wu, Erich Elsen, Siddhant Jayakumar, Elena Buchatskaya, David Budden, Esme Sutherland, Karen Simonyan, Michela Paganini, Laurent Sifre, Lena Martens, Xiang Lorraine Li, Adhiguna Kuncoro, Aida Nematzadeh, Elena Gribovskaya, Domenic Donato, Angeliki Lazaridou, Arthur Mensch, Jean-Baptiste Lespiau, Maria Tsimpoukelli, Nikolai Grigorev, Doug Fritz, Thibault Sottiaux, Mantas Pajarskas, Toby Pohlen, Zhitao Gong, Daniel Toyama, Cyprien de Masson d’Autume, Yujia Li, Tayfun Terzi, Vladimir Mikulik, Igor Babuschkin, Aidan Clark, Diego de Las Casas, Aurelia Guy, Chris Jones, James Bradbury, Matthew Johnson, Blake Hechtman, Laura Weidinger, Iason Gabriel, William Isaac, Ed Lockhart, Simon Osindero, Laura Rimell, Chris Dyer, Oriol Vinyals, Kareem Ayoub, Jeff Stanway, Lorrayne Bennett, Demis Hassabis, Koray Kavukcuoglu, and Geoffrey Irving. Scaling Language Models: Methods, Analysis & Insights from Training Gopher, 2021.
+
+Kate Rakelly, Aurick Zhou, Chelsea Finn, Sergey Levine, and Deirdre Quillen. Efficient off-policy meta-reinforcement learning via probabilistic context variables. In Kamalika Chaudhuri and Ruslan Salakhutdinov (eds.), Proceedings of the 36th International Conference on Machine Learning, ICML 2019, 9-15 June 2019, Long Beach, California, USA, volume 97 of Proceedings of Machine Learning Research, pp. 5331–5340. PMLR, 2019. URL http://proceedings. mlr.press/v97/rakelly19a.html.
+
+Scott Reed, Konrad Zolna, Emilio Parisotto, Sergio Gomez Colmenarejo, Alexander Novikov, Gabriel Barth-Maron, Mai Gimenez, Yury Sulsky, Jackie Kay, Jost Tobias Springenberg, Tom Eccles, Jake Bruce, Ali Razavi, Ashley Edwards, Nicolas Heess, Yutian Chen, Raia Hadsell, Oriol Vinyals, Mahyar Bordbar, and Nando de Freitas. A Generalist Agent, 2022.
+
+Andrei A. Rusu, Sergio Gomez Colmenarejo, C¸ aglar Gul¨ c¸ehre, Guillaume Desjardins, James Kirkpatrick, Razvan Pascanu, Volodymyr Mnih, Koray Kavukcuoglu, and Raia Hadsell. Policy distillation. In Yoshua Bengio and Yann LeCun (eds.), 4th International Conference on Learning Representations, ICLR 2016, San Juan, Puerto Rico, May 2-4, 2016, Conference Track Proceedings, 2016. URL http://arxiv.org/abs/1511.06295.
+
+Jurgen Schmidhuber. Reinforcement learning upside down: Don’t predict rewards - just map them to ¨ actions. CoRR, abs/1912.02875, 2019. URL http://arxiv.org/abs/1912.02875.
+
+Julian Schrittwieser, Ioannis Antonoglou, Thomas Hubert, Karen Simonyan, Laurent Sifre, Simon Schmitt, Arthur Guez, Edward Lockhart, Demis Hassabis, Thore Graepel, Timothy P. Lillicrap, and David Silver. Mastering Atari, Go, Chess and Shogi by Planning with a Learned Model. CoRR, abs/1911.08265, 2019.
+
+Rupesh Kumar Srivastava, Pranav Shyam, Filipe Mutz, Wojciech Jaskowski, and J ´ urgen Schmidhuber. ¨ Training agents using upside-down reinforcement learning. arXiv preprint arXiv:1912.02877, 2019.
+
+Christian Szegedy, Vincent Vanhoucke, Sergey Ioffe, Jon Shlens, and Zbigniew Wojna. Rethinking the inception architecture for computer vision. In 2016 IEEE Conference on Computer Vision and Pattern Recognition (CVPR), pp. 2818–2826, 2016. doi: 10.1109/CVPR.2016.308.
+
+Ashish Vaswani, Noam Shazeer, Niki Parmar, Jakob Uszkoreit, Llion Jones, Aidan N Gomez, Lukasz Kaiser, and Illia Polosukhin. Attention is all you need. In Advances in Neural Information Processing Systems, 2017.
+
+Jane X Wang, Zeb Kurth-Nelson, Dhruva Tirumala, Hubert Soyer, Joel Z Leibo, Remi Munos, Charles Blundell, Dharshan Kumaran, and Matt Botvinick. Learning to reinforcement learn, 2016.
+
+Ronald J. Williams. Simple Statistical Gradient-Following Algorithms for Connectionist Reinforcement Learning. Mach. Learn., 8:229–256, 1992. doi: 10.1007/BF00992696.
+
+Ronald J Williams and David Zipser. A learning algorithm for continually running fully recurrent neural networks. Neural computation, 1(2):270–280, 1989.
+
+Mengdi Xu, Yikang Shen, Shun Zhang, Yuchen Lu, Ding Zhao, Joshua Tenenbaum, and Chuang Gan. Prompting decision transformer for few-shot policy generalization. In International Conference on Machine Learning, pp. 24631–24645. PMLR, 2022.
+
+Jiahui Yu, Yuanzhong Xu, Jing Yu Koh, Thang Luong, Gunjan Baid, Zirui Wang, Vijay Vasudevan, Alexander Ku, Yinfei Yang, Burcu Karagol Ayan, Ben Hutchinson, Wei Han, Zarana Parekh, Xin Li, Han Zhang, Jason Baldridge, and Yonghui Wu. Scaling Autoregressive Models for Content-Rich Text-to-Image Generation, 2022.
+
+Qinqing Zheng, Amy Zhang, and Aditya Grover. Online decision transformer. arXiv preprint arXiv:2202.05607, 2022.
+
+# A DISCUSSION AND LIMITATIONS
+
+Discussion: While AD is more data-efficient than the source algorithm, we found that the source algorithm achieves a slightly higher asymptotic score in harder environments. This presents a tradeoff between data-efficiency and asymptotic optimality when using AD that should be taken into consideration when applying AD to a specific problem. In terms of long-term consequences, AD presents a path for converting narrow single-task RL agents into multi-task generalist ones. To date, deep RL research has mostly focused on powerful single-task agents Mnih et al. (2015); Schrittwieser et al. (2019); Hessel et al. (2021). These algorithms have produced powerful but data-inefficient agents, which has limited their applicability beyond narrow domains. AD offers a path toward training substantially more data-efficient, though perhaps less optimal, generalist agents by distilling narrow RL algorithms into sequence models like transformers.
+
+Limitations: While AD is a general method, in this work we’ve shown that AD generalizes to new tasks within the same domain. Showing the ability to distill cross-domain RL algorithms and generalize to new domains would be an interesting line if inquiry for future work. AD also requires storing many learning histories which could take up significant memory, though this may not be too much of an issue since the learning histories can be stored on disk rather than RAM. Perhaps the main limitation of AD is that most RL environments of interest have long episodes and modeling multiepisodic context requires more powerful long-horizon sequential models than the ones considered in this work. We believe this is a promising direction for future research.
+
+# B ENVIRONMENT CONSIDERATIONS
+
+In this work, we consider environments where zero-shot generalization is difficult, so the agent must learn through trial and error. We also want environments where overfitting to any particular task is difficult to ensure our method is general. A final practical consideration is that we consider environments wher across-episodic histories can be feasibly modeled with a causal transformer. Given these considerations, our evaluation environments need to satisfy three criteria:
+
+1. Supports many tasks: The environments must be multi-task to ensure that our agent and the baselines do not overfit to any single task and instead is able to in-context reinforcement learn across many tasks within a given domain.   
+2. Task must be hard to infer: To ensure that the downstream tasks are hard to generalize to in zero-shot, we use environments that require exploration. Namely, we require environments where either the task can only be inferred from the reward and not the observation, or tasks that are partially observable.   
+3. Supports multi-episodic contexts: Lastly, we impose a practical constraint - the environment episodes must be short enough such that a normal GPT-like transformer can fit multiple episodes in its context. Since this work introduces AD as a method, we wish to investigate it in the cleanest possible setting using a canonical architecture. We leave investigating AD with more complex architectures that scale to longer sequences for future work.
+
+Prior related works (Chen et al., 2021; Lee et al., 2022; Janner et al., 2021; Reed et al., 2022) evaluated on Atari, OpenAI gym, and as well as other environments. However, Atari and OpenAI gym don’t satisfy at least one of the above criteria. Atari and OpenAI gym episodes are often long and can contain thousands or more transitions per episode, so it’s technically challenging to populate a causal transformer’s context with across-episode histories. Indeed, the prior related works only considered within-episode context lengths. Additionally, it is often easy to infer the task from either the observation or the dense reward alone in both Atari and OpenAI gym, which reduces the need for exploration. For these reasons, we evaluate in environments that satisfy all three criteria instead.
+
+# C CLOSELY RELATED PRIOR METHODS
+
+In our main results we use Expert Distillation (ED) as a baseline. Here, we discuss how the most closely related methods differ from AD and why ED is sufficient to support the paper’s claims.
+
+Expert Distillation (ED): ED is most similar to Gato (Reed et al., 2022), which models expert sequences from a converged RL policy using a causal transformer. ED also trains a causal transformer to predict actions using expert policy data. There are two key differences between ED and Gato. First, unlike Gato which utilizes small (relative to an episode length) within-episode contexts, ED is trained on the same across-episode contexts as AD, so the architectures used by ED and AD are the same. The benefits of AD cannot therefore be attributed to across-episode contexts alone but also learning progress in the offline data used to train AD. Second, ED models state-action-reward sequences while Gato models only state-action sequences. The main difference between ED and AD is that AD is trained on full multi-task learning histories rather than expert policy data.
+
+Decision Transformer (DT) (Chen et al., 2021) and Multi-Game Decision Transformer (Lee et al., 2022): DTs learn return-conditioned policies from single-task offline data collected by an RL agent. While the training data itself (an RL agent’s replay buffer) contains learning, the context sizes used in DT are too small to capture any learning progress or identify the task using across-episode information. For instance, the Atari experiments use a context of length $3 0 - 5 0$ tokens, or $1 0 - 1 7$ transitions. Atari games can have hundreds or thousands of transitions in a single episode, which means these contexts capture mostly within-episode information. Additionally, very little learning progress happens in the underlying replay buffer data within that many transitions.
+
+Another difference between DT and AD / ED is that DT learns a return-conditioned model whereas AD / ED are both reward-conditioned. In our setting return-conditioning alone cannot yield an optimal policy since the agent does not know the task until after it explores the environment and can identify it using across-episode contexts. Since (i) DT uses small within-episodic contexts and (ii) return-conditioning would not help in the environments considered, this baseline is similar to ED with a small within-episode context which is strictly weaker than the long across-episode context variant of ED we consider.
+
+Trajectory Transformer (TTO) (Janner et al., 2021): Like AD, TTO also models state-action-reward tokens but in addition to predicting actions it also learns a world model by predicting states and rewards. To maximize return, TTO then uses beam search to select high-reward actions. However, in our setting, TTO will run into the same problem as DT. To model rewards accurately it will need longer across-episodic contexts since one environment supports many tasks. Similar to DT, MGDT, and Gato, TTO uses smaller within-episode contexts. For this reason, TTO will fare no better than DT, MGDT, or ED in the settings we consider. We also note that in contrast to TTO, AD is model-free. In AD, actions are sampled from the transformer history-conditioned predictions and return maximization emerges from modeling the learning histories of an RL algorithm.
+
+To summarize, AD differs from prior methods mainly because its context is across-episodic and hence large enough to capture learning progress and task information. AD could further be augmented by learning world models like TTO or conditioning on returns like DT, but these investigations would be well suited for future work since they are tangential to the main research question addressed in this work – whether in-context RL can emerge by imitating the learning histories of an RL algorithm with long across-episodic contexts.
+
+AD is also closely related to prior work in in-context meta-RL. While both AD and in-context meta-RL model across-episodic histories with memory-based architectures, prior in-context meta-RL algorithms, such as RL2 (Duan et al., 2016) are trained online and rely on learning multi-episodic value functions with TD learning while AD is trained offline and uses a supervised imitation learning objective.
+
+# D EXPERT DISTILLATION MAIN RESULTS
+
+We elaborate further on the main results in Fig. 4 and provide intuition regarding the behaviors of the ED baseline. In Dark Room, Dark Room (Hard), and Watermaze, ED performance is either flat or it degrades. The reason for this is that ED only saw expert trajectories during training, but during evaluation it needs to first explore (i.e. perform non-expert behavior) to identify the task. This required behavior is out-of-distribution for ED and for this reason it does not reinforcement learning in-context. In Dark Key-to-Door the agent is reset randomly at the beginning of each episode, whereas in all of the environments the agent’s starting position is fixed. Due to random resets, the ED agent is sometimes reset by the first goal in Dark Key-to-Door which allows it to occasionally identify the first goal of the task, which is why it shows slight improvement.
+
+# E MODEL SIZE
+
+We investigate how transformer capacity affects performance in Fig. 8. While in-context RL emerges across all model sizes investigated, we find that increasing the model depth, the model width in terms of embedding dimension, and (to a lesser extent) the number of attention heads improves performance on Dark Key-to-Door.
+
+![](images/7268b332c41895dedc19c08ef9b6099f4da74ea1f1754cc2dd5c84977a7dc825.jpg)  
+Figure 8: Model size investigations: We investigate how increasing model capacity affects AD. While in-context RL with AD emerges regardless of the model capacity, increasing the model depth and width helps improve AD until it achieves near-optimal performance.
+
+![](images/5225296573b7d46d8a1d9f73f0c47aa7acab27725bdc5f8cd9d76937d0d127b6.jpg)  
+Figure 9: Asymptotic performance of the A3C (Mnih et al., 2016) and a $\mathbf { Q - } \lambda$ variant of the DQN (Mnih et al., 2013) RL algorithms used to produce learning histories for the Dark and Watermaze environments. These curves show the learning histories AD is trained on. The source algorithms plotted in Fig. 4 are the same as in these plots.
+
+# G LABEL SMOOTHING ABLATION
+
+For the harder exploration task of Dark Room (Hard), we found that adding label smoothing regularization (Szegedy et al., 2016; Muller et al. ¨ , 2019) improved the in-context learning ability of AD . In Figure 10 we ablate the benefit of using label smoothing for 3 different $\alpha$ values as well as with it turned off. Each curve in the figure denotes average performance over 5 training seeds. We can see that adding label smoothing up to a point improves the in-context learning ability of Algorithm Distillation, with performance continually increasing with the number of evaluation episodes.
+
+![](images/e07003b625836d03f8abae3f9b6de0dbf38604250cecc84a2937ab5a8c642300.jpg)  
+Figure 10: AD trained with different amounts of label smoothing on Dark Room (Hard).
+
+# H $\mathtt { R L } ^ { 2 }$ NETWORK ARCHITECTURE: TRANSFORMER VS LSTM
+
+We compared using a transformer as the architecture for $\mathrm { { R L ^ { 2 } } }$ instead of an LSTM. In Figure 11, we ran both transformer and LSTM $\mathrm { { R L ^ { 2 } } }$ agents over the Dark Room environment. The curves shown are the best from a sweep over learning rate and unroll length hyperparameters. The transformer architecture is 4-layers with a model size of 256 and pre-norm layer normalization placement. While both agents reached a similar level of final performance, all $\mathtt { R L } ^ { \dot { 2 } }$ transformer models trained tended to be more unstable with the average return not as consistent as with an LSTM architecture. Given the poor performance of the transformer-based $\mathrm { { R L ^ { 2 } } }$ on the simpler Dark Room setting, our other experimental settings used the LSTM.
+
+![](images/d84a5680152d9b0d5a45f824e697e85bb345213b6f295d3072548835b0a69b86.jpg)  
+LSTM v.s. Transformer   
+Figure 11: Comparison of LSTM and Transformer architecture for $\mathtt { R L } ^ { 2 }$ agent on Dark Room. Each curve is averaged over 5 training seeds with the shaded area representing the standard error.
+
+# I NUMBER OF TRAINING TASKS IN SOURCE DATA
+
+![](images/3f6801f52bcd71f0fcf1231b4856e8cbd97a9ff344198d24cc0710b9d3353f73.jpg)  
+Figure 12: Algorithm distillation trained on different numbers of training tasks on Dark Key-to-Door evaluated on a fixed set of test tasks for 300 episodes of evaluation.
+
+One interesting question is how many tasks AD needs to be trained on to learn an algorithm that generalizes to held out tasks. We trained AD on different numbers of Dark Key-to-Door training tasks and evaluated the resulting models on the same set of test tasks. Figure 12 shows the incontext learning plots for the resulting AD models on the set of test tasks. As a reminder, there are $8 1 ^ { 2 } = 6 5 6 1$ unique Dark Key-to-Door tasks. Models trained on 1, 9 or 18 training tasks did not show any in-context learning on test tasks. While models trained on 37, 75 and 151 tasks did not achieve good performance overall, they did exhibit some in-context learning over the course of 300 episodes. The best models were trained on 1212 and 2424 tasks which corresponds to roughly $1 8 \%$ and $3 7 \%$ of the total number of tasks in the Dark Key-to-Door domain.
+
+# J SINGLE-STREAM ALGORITHM DISTILLATION
+
+We provide more details around the experimental setup for the single-stream result shown in Fig. 6. We showed in Fig. 4 that when AD is trained on data from a subset of the actors of a distributed source RL algorithm, the resulting model is more data efficient than the source algorithm. Here we confirm that AD can produce a faster algorithm than the one it was trained on in the single-stream setting. For this experiment we trained A3C on 2048 Dark Key-to-Door tasks for 2000 episodes each. We then trained AD on the resulting data while subsampling the learning histories by a factor of 10. More concretely, we took every 10th episode from each of the learning history, which resulted in a 200 episode compressed learning trajectory for each task. Figure 6 compares the resulting AD model evaluated on a set of test tasks to the performance of the source algorithm on these tasks. The model learned by AD learns much faster than the source algorithm confirming that Algorithm Distillation can turn a slow gradient-based algorithm into a much more data efficient in-context learning algorithm.
+
+# K RANDOM MASK
+
+![](images/1038f6e9da6d542b87e80cfa6740b77180b4083883611e385d6a893aeadde962.jpg)  
+Figure 13: Downstream performance of Algorithm Distillation with different values of random masking during training in $9 \mathrm { { x 9 1 } }$ goal gridworld.
+
+During training, input tokens were randomly masked to avoid overfitting to training data. This plot shows the downstreams results on a $9 \mathrm { x } 9$ Dark Key-to-Door domain with different values of this random masking. Values of $0 . 3 - 0 . 5$ perform the best with the value of 0.3 chosen for all experiments.
+
+# L AD NETWORK ARCHITECTURE: TRANSFORMER VS LSTM
+
+Here we consider the importance of the Transformer architecture to the success of algorithm distillation (AD) by comparing to AD based off of an LSTM (Hochreiter & Schmidhuber, 1997). Specifically, the LSTM receives the concatenated embeddings of $\left( o _ { i } , a _ { i } , r _ { i } \right)$ triplets up to the most recent time step $t - 1$ . The output of the LSTM is then concatenated with the current observation $o _ { t }$ embedding and both are then fed through a multi-layer perceptron (MLP) policy torso to produce a distribution over the present action $a _ { t }$ . The LSTM hidden size (512), MLP depth (2), and MLP width (256) were swept and tuned by grid search based on downstream reward attainment.
+
+Comparing Transformer AD and LSTM AD on the Dark Key-to-Door task (Figure 14), we find that both agents are capable of in-context learning, demonstrating that the success of AD is not tied to the underlying network architecture. However, we also find that the Transformer variant consistently outperforms the LSTM variant, which is why all other experiments in this paper employ the Transformer variant. This finding is consistent with the recent wider success of Transformer-based architectures over recurrent neural network (RNN)-based architectures in sequence prediction tasks.
+
+# M DISTILLING ACTIONS VS PROBABILITIES
+
+In the rest of the paper, we use (one-hot) actions taken by the source policy as the prediction target for AD. Here, we compare that choice to predicting the source policy probabilities from which that action was sampled. In other words, is it better to distill actions or probabilities?
+
+Figure 15 compares all combinations of: 1) distilling actions vs probabilities, and 2) conditioning those predictions on past actions, probabilities, or both. The plot labels represent various input/output combinations, e.g. $\mathtt { S a r - } > \mathtt { a }$ indicates observing states, actions, and rewards while predicting actions (i.e. the main variant of AD in the rest of the paper), sar $- > \mathrm { p }$ represents using the same observations but instead predicting probabilities, and $\tt S a p r - > a$ represents observing states, actions, probabilities, and rewards while predicting actions, etc.
+
+Two conclusions stand out from this plot. First, the original action distillation variant of AD $( s \mathsf { a r } - \mathsf { > a } )$ performs best, followed closely by probability distillation $( \mathsf { s a r - > p } )$ . In the paragraphs and experiments below, we explore why action distillation outperforms probability distillation. Second, all variants that condition on past probabilities catastrophically fail. We speculate on two somewhat contradictory reasons why this might occur: 1) The AD prediction task involves a combination of inferring the current policy, as well as predicting when policy updates will occur. Since observing policy probabilities provides more information about the current policy than actions do, it is possible that this leads to AD fully focusing on inferring the current policy and ignoring the prediction of policy updates. In other words, observing only actions taken may act as a useful information bottleneck. 2) On the other hand, observing probabilities may inadvertently leak information about when policy updates occur. If the transformer context includes multiple visits to the same state, AD could learn to compare the policy probabilities to infer whether a policy update occurred in between the two visits. If AD learned during training to rely on this information, then during autoregressive evaluation, it may be “waiting“ for a policy update than never occurs. If this is the source of the issue, then a potential solution would be retraining with explicit policy update tokens and including them between evaluation episodes, however we leave this investigation to future work.
+
+![](images/454e8467c64103db58787ec5b2c5c859eefc5a040f070dda6d155b0f1e59d8e6.jpg)  
+Figure 14: Comparison between algorithm distillation with a Transformer and LSTM architecture on Dark Key-to-Door. Mean $\pm \nobreakspace 1 \nobreakspace$ standard deviation over 5 training seeds and 20 evaluation seeds. 300 episodes corresponds to $1 5 \mathrm { k }$ environment steps.
+
+![](images/a807c9a242becc876d7e1138b0bdc3096c70672568caf1845fcca6c88bec2352.jpg)  
+Figure 15: Comparison between algorithm distillation with various input/output combinations on Dark Key-to-Door. Mean $\pm \nobreakspace 1 \nobreakspace$ standard deviation over 5 training seeds and 20 evaluation seeds. 1000 episodes corresponds to $5 0 \mathrm { k }$ environment steps.
+
+Now we return to the question of why action distillation $\left( s \mathsf { a r } - \mathsf { > a } \right)$ outperforms probability distillation $( s \mathsf { a r } \mathrm { - } \mathsf { > p } )$ . Intuitively, distilling one-hot actions will result in a more deterministic policy than distilling probabilities when training on finite data. Indeed, the red curves in the top two plots of Figure 16 show that probability distillation (top left) converges to a higher entropy ${ \sim } 1 . 2$ bits) policy than does action distillation (top right, ${ \sim } 1$ bit). Noting this discrepancy, we speculated that encouraging probability distillation towards a more deterministic policy might lead to increased performance. To do so, we experimented with an entropy penalty regularizer added to the AD loss from equation 6, leading to the modified objective:
+
+$$
+\tilde { \mathcal { L } } ( \theta , \alpha ) : = \sum _ { n = 1 } ^ { N } \sum _ { t = 1 } ^ { T - 1 } - \log P _ { \theta } ( A = a _ { t } ^ { ( n ) } | h _ { t - 1 } ^ { ( n ) } , o _ { t } ^ { ( n ) } ) + \alpha H \Big [ P _ { \theta } ( A | h _ { t - 1 } ^ { ( n ) } , o _ { t } ^ { ( n ) } ) \Big ] ,
+$$
+
+where $H [ \cdot ]$ is the Shannon entropy in bits, and $\alpha$ is a regularization weight. The top two panels of Figure 16 show the effect of increasing $\alpha$ on decreasing policy entropy for action distillation (top right) and probability distillation (top left), throughout training. The bottom two panels show the corresponding changes in evaluation returns. Notably, entropy penalization indeed improves performance for probability distillation (bottom left), with the best performing regularization value $\alpha = 0 . 1$ ) achieving a similar return to the original unregularized action distillation (bottom right, red). Interestingly, this is the amount of regularization that leads probability distillation to have the most similar entropy to the unregularized action distillation variant $_ { \sim 1 }$ bit) as well. Further entropy penalization for action distillation, on the other hand, does not lead to increased performance (bottom right). Together, these results suggest that action distillation naturally leads to the “optimal“ amount of entropy regularization on its own, at least in the environments we study.
+
+![](images/1193b4fb8b446f1e1eb9a0060b68dfb52c35743a1269cf2b5dabdd292afbbd8e.jpg)  
+Figure 16: Policy entropy during training and reward during evaluation for the action distillation $( s \mathsf { a r } - \mathsf { > a } )$ and probability distillation $( \mathsf { s a r - > p } )$ variants of AD on Dark Key-to-Door. Colors indicate the strength of the weight on the entropy penalty regularizer from equation 7. Mean $\pm \nobreakspace 1 \nobreakspace$ standard deviation over 5 training seeds and 20 evaluation seeds. 1000 episodes corresponds to $5 0 \mathrm { k }$ environment steps.
+
+In addition to closing gap between probability and action distillation with an entropy penalty, we also explored retuning various hyperparameters for $\mathtt { S a r - > p }$ rather than reusing those tuned for $\mathtt { S a r - } > \mathtt { a }$ . We found that many hyperparameters, such as the dropout rate, attention dropout rate, and sequence mask probability, had similar optimal values in the two cases, and so retuning them did not help. However, one hyperparameter that did have an effect was the size of the transformer context window (Figure 17). While action distillation performance increased only up to a context window size of 200 steps (4 episodes) and then plateaued (Figure 17, right), probability distillation performance continued to increase up to a context window size of 300 steps (6 episodes) before plateauing (Figure 17, left). Thus, while a comparison at our default context window size of 200 steps favored action distillation, for larger context window sizes, action and probability distillation performed similarly. We leave any further explanation of why probability distillation requires larger context windows than action distillation to future work.
+
+![](images/5dfce0c0db48409f890ffe00174597da457e40c2ba659bd24f1e455836d5c726.jpg)  
+Figure 17: Context window size dependence for the action distillation $( s \mathsf { a r } - > \mathsf { a } )$ and probability distillation $( \mathsf { s a r - > p } )$ variants of AD on Dark Key-to-Door. Mean $\pm \nobreakspace 1 \nobreakspace$ standard deviation over 5 training seeds and 20 evaluation seeds. 1000 episodes corresponds to $5 0 \mathrm { k }$ environment steps.
+
+N ALGORITHM DISTILLATION HYPERPARAMETERS   
+
+<table><tr><td>Hyperparameter</td><td>Dark Room</td><td>Dark Room (Hard)</td><td>Dark Key-to-Door</td><td>Watermaze</td></tr><tr><td>Embedding Dim.</td><td></td><td colspan="3">64</td></tr><tr><td>Number of Layers</td><td colspan="4"></td></tr><tr><td>Number of Heads</td><td colspan="4">4</td></tr><tr><td>Feedforward Dim.</td><td colspan="4">2048</td></tr><tr><td>Position Encodings</td><td colspan="4">Absolute</td></tr><tr><td>LayerNorm Placement</td><td colspan="4">Post Norm</td></tr><tr><td>Dropout Rate</td><td colspan="4">0.1</td></tr><tr><td>Context Window</td><td colspan="4">600 tokens (200 timesteps)</td></tr><tr><td>Attention Dropout Rate</td><td></td><td>0</td><td>0.5</td><td>0.5</td></tr><tr><td>Sequence Mask Prob</td><td>0.5 0.3</td><td>0.5</td><td>0.3</td><td>0.3</td></tr><tr><td>Label Smoothing α</td><td>0</td><td>0.2</td><td>0</td><td>0</td></tr></table>
+
+Table 1: Algorithm Distillation Architecture Hyperparameters.   
+
+<table><tr><td>Hyperparameter</td><td>Value</td></tr><tr><td>Batch Size</td><td>128</td></tr><tr><td>Optimizer</td><td>Adam</td></tr><tr><td>β</td><td>0.9</td></tr><tr><td></td><td>0.99</td></tr><tr><td>Gradient Clip Norm Threshold</td><td>1</td></tr><tr><td>Learning Rate Schedule</td><td>Cosine Decay</td></tr><tr><td>Initial Value</td><td>2e-6</td></tr><tr><td>Peak Value</td><td>3e-4</td></tr></table>
+
+Table 2: Algorithm Distillation Optimization Hyperparameters.   
+Table 3: Watermaze Image Encoder Hyperparameters.   
+
+<table><tr><td>Layer</td><td>Hyperparameter</td><td>Value</td></tr><tr><td>Conv Block</td><td></td><td></td></tr><tr><td rowspan="3">Conv</td><td>Channel</td><td>128</td></tr><tr><td>Kernel</td><td>5</td></tr><tr><td>Stride</td><td>2</td></tr><tr><td>BatchNorm</td><td>Decay Rate</td><td>0.999</td></tr><tr><td>Activation</td><td>eps</td><td>1e-5</td></tr><tr><td></td><td>-</td><td>ReLU</td></tr><tr><td rowspan="2">Max Pooling</td><td>Kernel</td><td>2</td></tr><tr><td>Stride</td><td>2</td></tr><tr><td>Dropout</td><td>Rate</td><td>0.2</td></tr><tr><td>Network</td><td></td><td></td></tr><tr><td>Conv Blocks</td><td>=</td><td>3</td></tr><tr><td>FinalLinearLayer</td><td>Units</td><td>256</td></tr></table>
+
+# O SOURCE RL ALGORITHM HYPERPARAMETERS
+
+# O.1 DARK ENVIRONMENTS
+
+Table 4: Source A3C Algorithm Hyperparameters for Dark Environments.   
+
+<table><tr><td colspan="2">Hyperparameter Value</td></tr><tr><td>Batch Size (Num.Actors)</td><td>100</td></tr><tr><td>入</td><td>0.95</td></tr><tr><td>Agent Discount</td><td>0.99</td></tr><tr><td>Entropy Bonus Weight</td><td>0.01</td></tr><tr><td>MLPLayers</td><td>3</td></tr><tr><td>MLPHidden Dim</td><td>128</td></tr><tr><td>Optimizer</td><td>Adam</td></tr><tr><td>β</td><td>0.9</td></tr><tr><td>β2</td><td>0.999</td></tr><tr><td>E</td><td>1e-6</td></tr><tr><td>Learning Rate</td><td>1e-4</td></tr></table>
+
+# O.2 DMLAB WATERMAZE
+
+Table 5: Source $\mathrm { D Q N } ( \mathrm { Q } - \lambda )$ Algorithm Hyperparameters for Watermaze.   
+
+<table><tr><td>Hyperparameter</td><td>Value</td></tr><tr><td>Batch Size</td><td>8</td></tr><tr><td>Rollout Length</td><td>40</td></tr><tr><td>Rollout Overlap</td><td>31</td></tr><tr><td>Number of Actors</td><td>16</td></tr><tr><td>Reply Buffer Capacity</td><td>1e5</td></tr><tr><td>Offline Data Fraction</td><td>0.7</td></tr><tr><td>入</td><td>0.75</td></tr><tr><td>E</td><td>0.01</td></tr><tr><td>Agent Discount</td><td>0.9</td></tr><tr><td>Target Update Period</td><td>50</td></tr><tr><td>ResNet Channels</td><td>[32, 64, 64]</td></tr><tr><td>ResNetKernels</td><td>[3,3,3]</td></tr><tr><td>ResNet Strides</td><td>[1, 1, 1]</td></tr><tr><td>Pool Kernels</td><td>[3,3,3]</td></tr><tr><td>Pool Strides</td><td>[2,2,2]</td></tr><tr><td>Optimizer</td><td>Adam</td></tr><tr><td>β</td><td>0.9</td></tr><tr><td>阳</td><td>0.999</td></tr><tr><td>E</td><td>1e-6</td></tr><tr><td>Gradient Clip Norm Threshold</td><td>10</td></tr><tr><td>Learning Rate</td><td>1e-4</td></tr></table>
+
+# P RL2 HYPERPARAMETERS
+
+Table 6: RL2 Hyperparameters used in “Dark” Environments.   
+
+<table><tr><td>Hyperparameter</td><td>Value</td></tr><tr><td>RL Algorithm</td><td>A3C</td></tr><tr><td>Learning Rate</td><td>3e-4</td></tr><tr><td>Batch Size</td><td>256</td></tr><tr><td>Unroll Length</td><td>20</td></tr><tr><td>LSTM Hidden Dim. LSTMNumber ofLayers</td><td>256</td></tr><tr><td>Episodes Per Trial</td><td>2 10</td></tr></table>
+
+<table><tr><td>Hyperparameter</td><td>Value</td></tr><tr><td>RL Algorithm</td><td>DQN(Q-入)</td></tr><tr><td>Learning Rate</td><td>1e-4</td></tr><tr><td>Batch Size</td><td>96</td></tr><tr><td>Unroll Length</td><td>40</td></tr><tr><td>LSTM Hidden Dim.</td><td>256</td></tr><tr><td>LSTMNumber of Layers</td><td>1</td></tr><tr><td>Episodes Per Trial</td><td>30</td></tr></table>
+
+Table 7: RL2 Hyperparameters used in the Watermaze Environment.
+
+![](images/ea1fc762f193fd44d789c64e6914ec2d901af77612e21bb3dcbce6fbfe7da485.jpg)  
+0 1700Figure 18: Attention maps for AD from five separate seeds. White and gray colors correspond to low and high attention. Red and blue colors indicate that those transitions correspond to an episode restart and a positive reward token, respectively. The left column plots attention for an AD transformer after 200 time-steps of evaluation (when the context is initially filled). The right column plots attention after 1900 steps (38 episodes) of evaluation. Each episode has a length of 50 steps. From these patterns, it is evident that AD attends to tokens across several episodes to predict its next action.

parse/dev/xDaoT2zlJ0r/xDaoT2zlJ0r.md

@@ -0,0 +1,506 @@
+# FINDE: Neural Differential Equations for Finding and Preserving Invariant Quantities
+
+Anonymous Author(s)   
+Affiliation   
+Address   
+email
+
+# Abstract
+
+1 Neural networks have shown promise for modeling dynamical systems from data.   
+2 Recent models, such as Hamiltonian neural networks, have been designed to   
+3 ensure known geometric structures of target systems and have shown excellent   
+4 modeling accuracy. However, in most situations where neural networks learn   
+5 unknown systems, their underlying structures are also unknown. Even in such   
+6 cases, one can expect that target systems are associated with first integrals (a.k.a. in  
+7 variant quantities), which are quantities remaining unchanged over time. First   
+8 integrals come from the conservation laws of system energy, momentum, and mass,   
+9 from constraints on states, and from other features of governing equations. By   
+10 leveraging projection methods and discrete gradient methods, we propose first   
+11 integral-preserving neural differential equations (FINDE). The proposed FINDE   
+12 finds and preserves first integrals from data, even in the absence of prior knowl  
+13 edge about the underlying structures. Experimental results demonstrate that the   
+14 proposed FINDE is able to predict future states of given systems much longer and   
+15 find various quantities consistent with well-known first integrals of the systems in   
+16 a unified manner.
+
+# 17 1 Introduction
+
+18 Although neural networks have achieved remarkable results in image and natural language pro  
+19 cessing [17, 28], they have also been actively investigated for modeling dynamical systems [41].   
+20 Target systems include the chemical dynamics to accelerate computer simulations [46], the climate   
+21 dynamics for climate change prediction and weather forecasting [47, 52], and the physical dynamics   
+22 of vehicles and robots for optimal control [41]. Their history dates back to at least the 1990s, and   
+23 many approaches have been proposed so far (see [7, 12, 35, 40, 49, 55] for example). Recently,   
+24 neural ordinary differential equation (NODE) has redefined neural networks for continuous-time   
+25 dynamics [8]. A target system is described by an ordinary differential equation (ODE) $\begin{array} { r } { \frac { \mathrm { d } } { \mathrm { d } t } \pmb { u } = \pmb { f } ( t , \pmb { u } ) } \end{array}$   
+26 where $\textbf { \em u }$ denotes the system state. Then, a NODE replaces the vector field $f$ with a neural network   
+27 and employs a numerical integrator to obtain a solution ${ \mathbf { } } { \mathbf { } } { \mathbf { } } { \mathbf { } } { \mathbf { } } { \mathbf { } } { \mathbf { } } { \mathbf { } } { \mathbf { } } { \mathbf { } } { \mathbf { } } \mathbf { } { \mathbf { } } \mathbf { } { \mathbf { } } \mathbf { } { \mathbf { } } \mathbf { } \mathbf { } \mathbf { } \mathbf { } \mathbf { } \mathbf { } \mathbf { } \mathbf { } \mathbf { } \mathbf { } \mathbf { } \mathbf { } \mathbf { } \mathbf { } \mathbf { } \mathbf { } \mathbf { } \mathbf { } \mathbf { } \mathbf { } \mathbf { } \mathbf { } \mathbf { } \mathbf { } \mathbf { } \mathbf { } \mathbf { } \mathbf { } \mathbf { } \mathbf { } \mathbf { } \mathbf { } \mathbf { } \mathbf { } \mathbf { } \mathbf { } \mathbf { } \mathbf { } \mathbf { } \mathbf { } \mathbf { } \mathbf { } \mathbf { } \mathbf { } \mathbf { } \mathbf { } \mathbf { } \mathbf { } \mathbf { } \mathbf { } \mathbf { } \mathbf { } \mathbf { } \mathbf { } \mathbf { } \mathbf { } \mathbf { } \mathbf { } \mathbf { } \mathbf { } \mathbf { } \mathbf { } \mathbf { } \mathbf { } \mathbf { } \mathbf { } \mathbf { } \mathbf { } \mathbf { } \mathbf { } \mathbf { } \mathbf { } \mathbf { } \mathbf { } \mathbf { } \mathbf { } \mathbf { } \mathbf { } \mathbf { } \mathbf { } \mathbf { } \mathbf { } \mathbf { } \mathbf { } \mathbf { } \mathbf { } \mathbf { } \mathbf { } \mathbf { } \mathbf { } \mathbf { } \mathbf { } \mathbf { } \mathbf { } \mathbf \Psi \mathbf { } \Psi \mathbf { } \mathbf { } \mathbf { } \mathbf { } \mathbf { } \mathbf \Psi { } \mathbf \Psi \mathbf { } \mathbf { } \mathbf \Psi \Psi \mathbf { } \mathbf { } \mathbf \Psi \mathbf { } \mathbf \Psi \mathbf { } \mathbf \Psi \Psi \mathbf { } \mathbf \mathbf { } \mathbf \Psi \mathbf { } \mathbf \mathbf { } \mathbf \mathbf \Psi \Psi \mathbf { } \mathbf \mathbf \Psi \Psi \mathbf { } \mathbf \mathbf \Psi \mathbf { } \mathbf \mathbf \Psi \mathbf \Psi \Psi \mathbf \Psi \mathbf { \mathbf } \mathbf \mathbf \Psi \mathbf \Psi \mathbf \Psi \mathbf \mathbf  \mathbf \Psi \mathbf \Psi \mathbf \Psi \mathbf \mathbf \Psi \mathbf \Psi \mathbf \mathbf \Psi \mathbf \Psi \mathbf \mathbf \Psi \mathbf \mathbf \Psi \mathbf \mathbf \mathbf \Psi \mathbf \mathbf \mathbf \Psi \mathbf \mathbf \mathbf \Psi \mathbf \mathbf \mathbf \mathbf \mathbf \mathbf \Psi \mathbf \mathbf \mathbf \mathbf \mathbf \mathbf \mathbf \mathbf \mathbf \mathbf \Psi \mathbf \mathbf \mathbf \mathbf \mathbf \mathbf \mathbf \mathbf \mathbf \mathbf \mathbf \mathbf \mathbf \mathbf \mathbf \mathbf \mathbf \mathbf \mathbf $ .   
+28 Most real-world systems are associated with first integrals (a.k.a. invariant quantities), which are   
+29 quantities remaining unchanged over time [27]. If a system has a first integral $V ( { \pmb u } )$ , the solution   
+30 ${ \mathbf { } } { \mathbf { } } { \mathbf { } } { \mathbf { } } { \mathbf { } } { \mathbf { } } { \mathbf { } } { \mathbf { } } { \mathbf { } } { \mathbf { } } { \mathbf { } } \mathbf { } { \mathbf { } } \mathbf { } { \mathbf { } } \mathbf { } { \mathbf { } } \mathbf { } \mathbf { } \mathbf { } \mathbf { } \mathbf { } \mathbf { } \mathbf { } \mathbf { } \mathbf { } \mathbf { } \mathbf { } \mathbf { } \mathbf { } \mathbf { } \mathbf { } \mathbf { } \mathbf { } \mathbf { } \mathbf { } \mathbf { } \mathbf { } \mathbf { } \mathbf { } \mathbf { } \mathbf { } \mathbf { } \mathbf { } \mathbf { } \mathbf { } \mathbf { } \mathbf { } \mathbf { } \mathbf { } \mathbf { } \mathbf { } \mathbf { } \mathbf { } \mathbf { } \mathbf { } \mathbf { } \mathbf { } \mathbf { } \mathbf { } \mathbf { } \mathbf { } \mathbf { } \mathbf { } \mathbf { } \mathbf { } \mathbf { } \mathbf { } \mathbf { } \mathbf { } \mathbf { } \mathbf { } \mathbf { } \mathbf { } \mathbf { } \mathbf { } \mathbf { } \mathbf { } \mathbf { } \mathbf { } \mathbf { } \mathbf { } \mathbf { } \mathbf { } \mathbf { } \mathbf { } \mathbf { } \mathbf { } \mathbf { } \mathbf { } \mathbf { } \mathbf { } \mathbf { } \mathbf { } \mathbf { } \mathbf { } \mathbf { } \mathbf { } \mathbf { } \mathbf { } \mathbf { } \mathbf { } \mathbf { } \mathbf { } \mathbf { } \mathbf { } \mathbf { } \mathbf { } \mathbf { } \mathbf \Psi { } \mathbf { } \mathbf { } \mathbf { } \mathbf { } \mathbf { } \mathbf \Psi { } \mathbf \Psi { } \mathbf { } \mathbf \Psi \mathbf { } \mathbf { } \mathbf { } \mathbf \Psi \mathbf { } \mathbf { } \mathbf \Psi \mathbf { } \mathbf { } \mathbf \Psi \mathbf { } \mathbf \Psi \mathbf { } \mathbf \Psi \mathbf { } \mathbf \Psi \mathbf { } \mathbf \mathbf { } \mathbf \mathbf { \Psi } \mathbf \mathbf \Psi \mathbf { } \mathbf \mathbf \Psi \Psi \mathbf { } \mathbf \mathbf \mathbf { \Psi \mathbf } \mathbf \mathbf \Psi \Psi \mathbf \Psi \mathbf { \mathbf } \mathbf \mathbf \mathbf \Psi \mathbf  \mathbf \Psi \mathbf \mathbf \Psi \mathbf \Psi \mathbf \Psi \mathbf \Psi \mathbf \Psi \mathbf \mathbf \Psi \mathbf \mathbf \Psi \mathbf \mathbf \Psi \mathbf \mathbf \Psi \mathbf \mathbf \mathbf \Psi \mathbf \mathbf \mathbf \Psi \mathbf \mathbf \mathbf \mathbf \mathbf \mathbf \Psi \mathbf \mathbf \mathbf \mathbf \mathbf \mathbf \mathbf \mathbf \mathbf \mathbf \Psi \mathbf \mathbf \mathbf \mathbf \mathbf \mathbf \mathbf \mathbf \mathbf \mathbf \mathbf \mathbf \mathbf \mathbf \mathbf \mathbf \mathbf \mathbf \mathbf $ for the initial condition $\pmb { u } ( 0 )$ remains at a contour line $V ( \mathbf { \boldsymbol { u } } ( t ) ) = V ( \mathbf { \boldsymbol { u } } ( 0 ) )$ over time. Many   
+31 previous studies have attempted to learn a target system accurately by incorporating prior knowledge   
+32 about first integrals. Greydanus et al. [26] proposed Hamiltonian neural network (HNN), which   
+33 employs a neural network to approximate Hamilton’s equation, thereby conserving the system energy   
+34 called the Hamiltonian. Finzi et al. [19] proposed neural network architectures that conserve linear   
+35 and angular momenta by utilizing the graph structure. Finzi et al. [20] also extended HNN to a system   
+36 with holonomic constraints, which lead to first integrals such as a pendulum length. Matsubara et al.   
+37 [38] proposed a model that preserves the total mass of a discretized partial differential equation   
+38 (PDE). These studies have demonstrated that a neural network with more prior knowledge about first   
+39 integrals predicts the dynamics of the target system more accurately. See Table 1 for comparison.   
+40 Previous studies have mainly attempted to preserve known first integrals. However, in situations   
+41 where a neural network learns an unknown target system, it is naturally expected that first integrals   
+42 associated with the target system are also unknown, and it is not clear which of the above methods are   
+43 available. Given the above, this study proposes First Integral-preserving Neural Differential Equation   
+44 (FINDE) to find and preserve first integrals from data. FINDE has the following advantages.   
+45 Learning First Integrals For modeling continuous-time dynamics with known first integrals, many   
+46 studies have designed architectures or operations of neural networks [13, 19, 20, 26, 38]. For each   
+47 type of first integral, one dedicated method was proposed. However, the properties of a target system   
+48 are generally unknown in practice. In contrast, the proposed FINDE finds various kinds of first   
+49 integrals from data in a unified manner and preserves them in predictions. A symbolic regression   
+50 confirms that the learned first integrals are consistent with well-known first integrals of target systems.
+
+Table 1: Comparison between Related Studies on Preservation of First Integrals.   
+
+<table><tr><td colspan="7"></td></tr><tr><td></td><td>energy</td><td colspan="3">monentum mass</td><td colspan="3">constraint learning invariants exact conservation</td></tr><tr><td>NODE [8]</td><td></td><td></td><td></td><td></td><td></td><td></td></tr><tr><td>HNN [26]</td><td>√</td><td></td><td></td><td></td><td></td><td></td></tr><tr><td>LieConv [19]</td><td>√</td><td>厂</td><td></td><td></td><td></td><td></td></tr><tr><td>DGNet [38]</td><td>√</td><td></td><td>√</td><td></td><td></td><td></td></tr><tr><td>CHNN [20]</td><td>√</td><td></td><td></td><td>√</td><td></td><td></td></tr><tr><td>continuous FINDE (proposed)</td><td>√</td><td>√</td><td>√</td><td>√</td><td>√</td><td></td></tr><tr><td>discrete FINDE (proposed)</td><td>√</td><td>厂</td><td>厂</td><td>丁</td><td></td><td></td></tr></table>
+
+Combination with Known First Integrals The proposed FINDE can be combined with previously proposed neural networks designed to preserve known first integrals, such as HNN. Therefore, FINDE is available in various situations.
+
+54 Exact Preservation of First Integrals Even if a first integral is associated with a continuous-time   
+55 system, it is destroyed after the system is discretized in time for computer simulations. This is true   
+56 even when using a symplectic integrator, which preserves the system energy only approximately [27].   
+57 By leveraging discrete gradients [38], the discrete-time version of FINDE preserves first integrals   
+58 exactly (up to rounding errors) in discrete time and further improves the prediction performance.
+
+# 59 2 Background and Related Work
+
+60 First Integrals Let us consider a time-invariant differential system $\begin{array} { r } { \frac { \mathrm { d } } { \mathrm { d } t } \pmb { u } \ = \ f ( \pmb { u } ) } \end{array}$ on an $N$ -   
+61 dimensional manifold $\mathcal { M }$ , where $\textbf { \em u }$ denotes the system state and $f : \mathcal { M } ^ { } \to \mathcal { T } _ { u } \mathcal { M }$ represents a   
+62 vector field on the manifold $\mathcal { M }$ . The manifold $\mathcal { M }$ can be $\mathcal { M } = S ^ { 1 } \times \mathbb { R } ^ { 1 }$ for a pendulum. In this   
+63 paper, we suppose the manifold $\mathcal { M }$ be a Eucleadian space $\mathbb { R } ^ { N }$ for simplicity.   
+64 Definition 1 (first integral). $A$ quantity $V : { \mathcal { M } }  \mathbb { R }$ is referred to as a first integral of a system   
+65 $\begin{array} { r } { \frac { \mathrm { d } } { \mathrm { d } t } \pmb { u } = f ( \pmb { u } ) } \end{array}$ if it remains constant along with any solution ${ \mathbf { } } { \mathbf { } } { \mathbf { } } { \mathbf { } } { \mathbf { } } { \mathbf { } } { \mathbf { } } { \mathbf { } } { \mathbf { } } { \mathbf { } } \mathbf { } { \mathbf { } } \mathbf { } { \mathbf { } } \mathbf { } \mathbf { } \mathbf { } \mathbf { } \mathbf { } \mathbf { } \mathbf { } \mathbf { } \mathbf { } \mathbf { } \mathbf { } \mathbf { } \mathbf { } \mathbf { } \mathbf { } \mathbf { } \mathbf { } \mathbf { } \mathbf { } \mathbf { } \mathbf { } \mathbf { } \mathbf { } \mathbf { } \mathbf { } \mathbf { } \mathbf { } \mathbf { } \mathbf { } \mathbf { } \mathbf { } \mathbf { } \mathbf { } \mathbf { } \mathbf { } \mathbf { } \mathbf { } \mathbf { } \mathbf { } \mathbf { } \mathbf { } \mathbf { } \mathbf { } \mathbf { } \mathbf { } \mathbf { } \mathbf { } \mathbf { } \mathbf { } \mathbf { } \mathbf { } \mathbf { } \mathbf { } \mathbf { } \mathbf { } \mathbf { } \mathbf { } \mathbf { } \mathbf { } \mathbf { } \mathbf { } \mathbf { } \mathbf { } \mathbf { } \mathbf { } \mathbf { } \mathbf { } \mathbf { } \mathbf { } \mathbf { } \mathbf { } \mathbf { } \mathbf { } \mathbf { } \mathbf { } \mathbf { } \mathbf { } \mathbf { } \mathbf { } \mathbf { } \mathbf { } \mathbf { } \mathbf { } \mathbf { } \mathbf { } \mathbf { } \mathbf { } \mathbf { } \mathbf { } \mathbf { } \mathbf { } \mathbf { } \mathbf { } \mathbf { } \mathbf { } \mathbf { } \mathbf \Psi  \mathbf { } \mathbf { } \mathbf { } \mathbf { } \mathbf { } \mathbf { } \mathbf \mathbf { } \mathbf { } \mathbf { } \mathbf \Psi { } \mathbf \mathbf { } \mathbf { } \mathbf \Psi \mathbf { } \mathbf { } \mathbf \mathbf { } \mathbf \Psi { } \mathbf \mathbf { } \mathbf \mathbf { } \mathbf \mathbf { } \mathbf \Psi \mathbf { } \mathbf \mathbf { } \mathbf \mathbf { } \mathbf \mathbf { } \mathbf \mathbf \Psi \mathbf { } \mathbf \mathbf { } \mathbf \mathbf \mathbf { } \mathbf \mathbf \mathbf { } \mathbf \mathbf \mathbf { \mathbf } \mathbf \mathbf \mathbf  \mathbf \Psi \mathbf \Psi \mathbf { } \mathbf \mathbf \mathbf \mathbf \mathbf { } \mathbf \mathbf \mathbf \mathbf \mathbf \Psi \mathbf \mathbf { } \mathbf \mathbf \mathbf \mathbf \mathbf \mathbf \mathbf \mathbf  \mathbf \mathbf \mathbf \mathbf \Psi \mathbf \mathbf \mathbf \mathbf \mathbf \Psi \mathbf \mathbf \mathbf \mathbf \mathbf \mathbf \mathbf \mathbf \mathbf \mathbf \mathbf \mathbf \mathbf \mathbf \mathbf \mathbf \mathbf \mathbf \mathbf \mathbf \mathbf \mathbf \mathbf \mathbf \mathbf \mathbf \mathbf \mathbf \mathbf \mathbf \mathbf \mathbf \mathbf \mathbf \mathbf \mathbf$ , i.e., $\begin{array} { r } { \frac { \mathrm { d } } { \mathrm { d } t } V ( \pmb { u } ) = 0 } \end{array}$ .
+
+ntial system $\begin{array} { r } { \frac { \mathrm { d } } { \mathrm { d } t } { \pmb u } = f ( { \pmb u } ) } \end{array}$ is associate ith $K$ functionally independent first integrals $V _ { 1 } , \dots , V _ { K }$ ${ \bf \ddot { u } } ( t )$ given an initial value $\mathbf { \delta } \mathbf { u } _ { 0 }$ stays at the
+
+$$
+\mathcal { M } ^ { \prime } = \{ \pmb { u } \in \mathcal { M } : V _ { 1 } ( \pmb { u } ) = V _ { 1 } ( \pmb { u } _ { 0 } ) , \allowbreak \dots , V _ { K } ( \pmb { u } ) = V _ { K } ( \pmb { u } _ { 0 } ) \} .
+$$
+
+69 The tangent space $\mathcal { T } _ { u } \mathcal { M } ^ { \prime } \subset \mathcal { T } _ { u } \mathcal { M }$ of the submanifold $\mathcal { M } ^ { \prime } \subset \mathcal { M }$ at a point $\textbf { \em u }$ is the orthogonal   
+70 complement to the space spanned by the gradients $\nabla V _ { k } ( { \boldsymbol { \mathbf { \mathit { u } } } } )$ of the first integrals $V _ { k }$ for $k = 1 , \ldots , K$ ,   
+71 that is,
+
+$$
+\mathcal { T } _ { \boldsymbol { u } } \mathcal { M } ^ { \prime } = \{ \pmb { w } \in \mathcal { T } _ { \boldsymbol { u } } \mathcal { M } : \nabla V _ { k } ( \boldsymbol { u } ) ^ { \top } \pmb { w } = 0 \mathrm { ~ f o r ~ } k = 1 , \dots , K \}
+$$
+
+If a quantity 72 $V _ { k }$ is a first integral of the system $\begin{array} { r } { \frac { \mathrm { d } } { \mathrm { d } t } \pmb { u } = f ( \pmb { u } ) } \end{array}$ , the time-derivative $f$ at point $\textbf { \em u }$ is on the 73 tangent space $\mathcal { T } _ { u } \mathcal { M } ^ { \prime }$ , being orthogonal to the gradient $\nabla V _ { k }$ of the first integral $V _ { k }$ . Then, it holds that 74 $\begin{array} { r } { \frac { \mathrm { d } } { \mathrm { d } t } \dot { V _ { k } ( \pmb { u } ) } = \nabla V _ { k } ( \pmb { u } ) ^ { \top } \frac { \mathrm { d } } { \mathrm { d } t } \pmb { u } = \bar { \nabla } V _ { k } ( \pmb { u } ) ^ { \top } \pmb { f } ( \bar { \pmb { u } } ) = 0 } \end{array}$ .
+
+75 One of the most well-known first integrals is the Hamiltonian $H$ , which represents the system energy   
+76 of a Hamiltonian system. Noether’s theorem states that a continuous symmetry of a system leads to a   
+77 conservation law (and hence a first integral) [27]; a Hamiltonian system is symmetric to translation   
+78 in time and conserves the Hamiltonian. Symmetries to translation and rotation in space lead to the   
+79 conservation of linear and angular momenta. Not all first integrals are related to symmetries. A   
+80 pendulum can be expressed in Cartesian coordinates, and then the rod length constrains the mass   
+81 position. This kind of constraint is called a holonomic constraint and leads to a first integral. A model   
+82 for disease spreading called an susceptible-infected-recovered (SIR) model and the dynamics of   
+83 chemical reactions have the total mass (population) as a first integral. Also for a system described by   
+84 a PDE, the total mass is sometimes a first integral [23]. See Appendix A for theoretical classification   
+85 of dynamics.   
+86 First Integrals in Numerical Analysis For computer simulations, a differential system is dis  
+87 cretized in time and solved by numerical integration. Then, the geometric structures of the system   
+88 are often destroyed, and most first integrals are no longer preserved. A common remedy is a sym  
+89 plectic integrator, which preserves the symplectic structure and integrates a Hamiltonian system   
+90 accurately [27]. However, Ge–Marsden theorem states that a symplectic integrator conserves the   
+91 Hamiltonian only approximately [56]. Hence, many numerical schemes have also been investigated   
+92 for preserving first integrals exactly, while they cannot preserve the symplectic structure.   
+93 Let a superscript $s$ denote the state $\pmb { u } ^ { s }$ or time $t ^ { s }$ at $s$ -th time step, and $\Delta t ^ { s } = t ^ { s + 1 } - t ^ { s }$ denote a   
+94 time step size. A projection method predicts a next state $\tilde { \pmb u } ^ { s + 1 }$ from the current state $\pmb { u } ^ { s }$ using a   
+95 numerical integrator and projects it onto the submanifold $\mathcal { M } ^ { \prime }$ , obtaining the projected state $\pmb { u } ^ { s + 1 }$ that   
+96 preserves the first integrals $V _ { k }$ [24] (see also [27, Section IV.4]). In particular, the projected state   
+97 $\mathbf { \Delta } _ { \mathbf { u } } { } ^ { s + 1 }$ is obtained by solving the optimization problem
+
+$$
+\boldsymbol { u } ^ { s + 1 } = \operatorname * { a r g m i n } _ { \boldsymbol { u } ^ { \prime } ^ { s + 1 } } | | \boldsymbol { u } ^ { \prime * s + 1 } - \tilde { \boldsymbol { u } } ^ { s + 1 } | | \operatorname * { s u b j e c t } \operatorname { t o } V _ { k } ( \boldsymbol { u } ^ { \prime * s + 1 } ) = V _ { k } ( \boldsymbol { u } ^ { s } ) \operatorname { f o r } k = 1 , \dots , K .
+$$
+
+98 A local coordinate method defines a coordinate system to the neighborhood of the current state $\pmb { u } ^ { s }$   
+99 and integrates a differential equation on it [43] (see also [27, Section IV.5]). A discrete gradient   
+100 method defines a discrete analogue to a given differential system and integrates it in discrete time [6,   
+101 23, 25, 29, 44, 45]. This method eliminates numerical errors caused by temporal discretization and is   
+102 used to preserve the Hamiltonian exactly (up to rounding errors) in discrete time.   
+103 Except for DGNet, which used discrete gradients to preserve the Hamiltonian [38], all the above   
+104 methods have never been applied to neural networks due to difficulties that we will introduce later. To   
+105 our best knowledge, the discrete-time version of FINDE is the first projection method for dynamical   
+106 systems modeled using neural networks.   
+107 Preservation of First Integrals by Neural Networks NODE defines an ODE using a neural net  
+108 work in the most general way with no associated first integrals [8]. NODE is a universal approximator   
+109 to ODEs [51], and it can approximate any ODE with arbitrary accuracy if there is an infinite amount   
+110 of training data. In practice, the amount of training data is limited, and prior knowledge about the   
+111 target system is helpful for learning (see [48] for the case with convolutional neural networks). HNN   
+112 assumes the target system to be a Hamiltonian system in the canonical form [26]. HNN guarantees   
+113 various properties of Hamiltonian systems by definition, including the conservation of the energy   
+114 and the preservation of the symplectic structure in continuous time [27]. Some studies employed a   
+115 symplectic integrator for HNN to preserve the energy and symplectic structure with smaller numerical   
+116 errors [10]. LieConv and EMLP-HNN employed neural network architectures with translational   
+117 and rotational symmetries to preserve momenta [19, 21]. CHNN incorporates a known holonomic   
+118 constraint in the dynamics [20]. Deep conservation extracts latent dynamics of a PDE system and   
+119 preserves a quantity of interest by forcing its flux to be zero [34]. $\mathrm { H N N + + }$ also guarantees the   
+120 conservation of the mass in PDE systems by using a coefficient matrix derived from differential   
+121 operators [38].   
+122 Several studies proposed neural networks to learn Lyapunov functions, which are expected to be   
+123 non-increasing over time, in contrast to first integrals [37, 50]. If the state moves in the direction of   
+124 increasing the function, it is projected onto or moved inside the counter line of the gradient of the   
+125 Lyapunov function. Their idea is similar to the continuous-time version of FINDE but limited to a   
+126 single non-increasing quantity in continuous time. On the other hand, our proposed FINDE preserves   
+127 multiple quantities in both continuous and discrete time.   
+28 Previous studies aimed to preserve known first integrals. Moreover, except for DGNet [38], all   
+29 the above methods suffer from numerical errors caused by temporal discretization. In contrast, our   
+30 proposed FINDE learns first integrals from data and can eliminate discretization errors.
+
+# 131 3 First Integral-Preserving Neural Differential Equation
+
+132 The main purpose is to find and preserve first integrals from data by neural networks. We suppose   
+133 that a target system has at least $K$ unknown functionally independent first integrals. Even when   
+134 a NODE learns the target system, it is not guaranteed to learn these first integrals. Hence, we   
+135 introduce a neural network with $K$ outputs, each of which is expected to learn one of first integrals   
+136 expressed as $V _ { k } : \mathbb { R } ^ { N }  \mathbb { R }$ for $k = 1 , \dots , K$ . We denote the set of first integrals by a vector   
+137 $\pmb { V } ( \pmb { u } ) = ( V _ { 1 } ( \pmb { u } ) V _ { 2 } ( \pmb { u } ) \dotsm V _ { K } ( \pmb { u } ) ) ^ { \top }$ . Then, the submanifold $\mathcal { M } ^ { \prime }$ is defined using the neural   
+138 network $V$ as in Eq. (1).   
+139 Because there is no way to define local coordinates on such submanifolds, a local coordinate method   
+140 is not applicable. When using a projection method, the optimization problem in Eq. (3) should   
+141 be solved at every training iteration as well as in the prediction phase. Optimization problems are   
+142 computationally expensive, and common libraries for neural networks do not provide backpropagation   
+143 algorithms for optimization problems [1, 42].1 Until a recent study has proposed an algorithm [38],   
+144 there was no way to obtain discrete gradients of neural networks. Because of these difficulties,   
+145 no methods for preserving first integrals have been applied to neural networks. By leveraging a   
+146 projection method and a discrete gradient method, we propose FINDE as follows.
+
+# 3.1 Continuous FINDE: Time-Derivative Projection Method
+
+First, we propose a time-derivative projection method called continuous FINDE (cFINDE) for neural networks, which projects the time-derivative onto the tangent space $\mathcal { T } _ { u } \mathcal { M } ^ { \prime }$ . While it still suffers from numerical errors, it is sufficient to find first integrals from data.
+
+We suppose that a neural network called a base model defines the time-derivative $\hat { f } : \mathbb { R } ^ { N } \to \mathbb { R } ^ { N }$ Then, we define the time-derivative $f$ of the cFINDE $\begin{array} { r } { \frac { \mathrm { d } } { \mathrm { d } t } \pmb { u } = f ( \pmb { u } ) } \end{array}$ as
+
+$$
+\begin{array} { r }  \boldsymbol { f } ( \boldsymbol { \mathbf { \rho } } \boldsymbol { \mathbf { \rho } } \boldsymbol { \mathbf { \rho } } \boldsymbol { \mathbf { \rho } } \boldsymbol { \mathbf { \rho } } \boldsymbol { \mathbf { \rho } } \boldsymbol { \mathbf { \rho } } \boldsymbol { \mathbf { \rho } } \boldsymbol { \mathbf { \rho } } \boldsymbol { \mathbf { \rho } } \boldsymbol { \mathbf { \rho } } \boldsymbol { \mathbf { \rho } } \boldsymbol { \mathbf { \rho } } \boldsymbol { \mathbf { \rho } } \boldsymbol { \mathbf { \rho } } \boldsymbol { \mathbf { \rho } } \boldsymbol { \mathbf { \rho } } \boldsymbol { \mathbf { \rho } } \boldsymbol { \mathbf { \rho } } \boldsymbol { \mathbf { \rho } } \boldsymbol { \mathbf { \rho } } \boldsymbol { \mathbf { \rho } } \boldsymbol { \mathbf { \rho } } \boldsymbol { \mathbf { \rho } } \boldsymbol { \mathbf { \rho } } \boldsymbol { \mathbf { \rho } } \boldsymbol { \mathbf { \rho } } \boldsymbol { \mathbf { \rho } } \boldsymbol { \mathbf { \rho } } \boldsymbol { \mathbf { \rho } } \boldsymbol { \mathbf { \rho } } \boldsymbol { \mathbf { \rho } } \boldsymbol { \mathbf { \rho } } \boldsymbol { \mathbf { \rho } } \boldsymbol { \mathbf { \rho } } \boldsymbol { \mathbf { \rho } } \boldsymbol { \mathbf { \rho } } \boldsymbol { \mathbf { \rho } } \boldsymbol { \mathbf { \rho } } \boldsymbol { \mathbf { \rho } } \boldsymbol { \mathbf { \rho } } \boldsymbol { \mathbf { \rho } } \boldsymbol { \mathbf { \rho } } \boldsymbol { \mathbf { \rho } } \boldsymbol { \mathbf { \rho } } \boldsymbol { \mathbf { \rho } } \boldsymbol { \mathbf { \rho } } \boldsymbol { \mathbf { \rho } } \boldsymbol { \mathbf { \rho } } \boldsymbol { \mathbf { \rho } } \boldsymbol { \mathbf { \rho } } \boldsymbol { \mathbf { \rho } } \boldsymbol { \mathbf { \rho } } \boldsymbol { \mathbf { \rho } } \boldsymbol { \mathbf { \rho } } \boldsymbol { \mathbf { \rho } } \boldsymbol { \mathbf { \rho } } \boldsymbol { \mathbf { \rho } } \boldsymbol { \mathbf { \rho } } \boldsymbol { \mathbf { \rho } } \boldsymbol { \mathbf { \rho } } \boldsymbol { \mathbf { \rho } } \boldsymbol { \mathbf { \rho } } \boldsymbol { \mathbf { \rho } } \boldsymbol { \mathbf { \rho } } \boldsymbol { \mathbf { \rho } } \boldsymbol { \mathbf { \rho } } \boldsymbol { \mathbf { \rho } } \boldsymbol { \mathbf { \rho } } \boldsymbol { \mathbf { \rho } } \boldsymbol { \mathbf { \rho } } \boldsymbol { \mathbf { \rho } } \boldsymbol { \mathbf { \rho } } \boldsymbol { \mathbf { \rho } } \boldsymbol { \mathbf { \rho } } \boldsymbol { \mathbf { \rho } } \boldsymbol  \mathbf { \rho } \boldsymbol { \rho } \boldsymbol  \end{array}
+$$
+
+where 153 $\lambda _ { k }$ is a Lagrange multiplier, $\begin{array} { r } { M \mathrm { ~ = ~ } \frac { \partial V } { \partial \mathbf { u } } } \end{array}$ , and $\lambda ( { \pmb u } ) = ( \lambda _ { 1 } ( { \pmb u } ) \lambda _ { 2 } ( { \pmb u } ) \dots \lambda _ { K } ( { \pmb u } ) ) ^ { \top }$ . If $V _ { k }$
+
+$$
+\begin{array} { r } { \mathbf { 0 } = \frac { \mathrm { d } } { \mathrm { d } t } { \pmb V } ( { \pmb u } ( t ) ) = M ( \pmb { u } ) \frac { \mathrm { d } } { \mathrm { d } t } { \pmb u } = M ( \pmb { u } ) f ( \pmb { u } ) = M ( \pmb { u } ) ( \hat { f } ( \pmb { u } ) - M ( \pmb { u } ) ^ { \top } \pmb { \lambda } ( \pmb { u } ) ) , } \end{array}
+$$
+
+where 155 $\mathbf { 0 } = ( 0 \ldots 0 ) ^ { \top }$ . By transforming Eq. (5), we obtain the Lagrange multiplier $\lambda ( { \pmb u } ) =$ 156 $( M ( \pmb { \mathscr { u } } ) M ( \pmb { \mathscr { u } } ) ^ { \top } ) ^ { - 1 } M ( \pmb { \mathscr { u } } ) \hat { f } ( \pmb { \mathscr { u } } )$ . By eliminating it, the cFINDE $\begin{array} { r } { \frac { \mathrm { d } } { \mathrm { d } t } \pmb { u } = f ( \pmb { u } ) } \end{array}$ is given by
+
+Remark 1 (continuous-time first integral preservation). The cFINDE 57 $\begin{array} { r } { \frac { \mathrm { d } } { \mathrm { d } t } \pmb { u } = f ( \pmb { u } ) } \end{array}$ preserves all first integrals 58 $V _ { k }$ for $k = 1 , \ldots , K$ in continuous time, i.e., $\begin{array} { r } { { \frac { \mathrm { d } } { \mathrm { d } t } } V _ { k } = 0 } \end{array}$ .
+
+159 The base model $\hat { f }$ can be a NODE, an HNN, or other models depending on available prior knowledge.   
+160 Also, if a first integral is already known, one can use it directly as one of first integrals $V _ { k }$ instead   
+161 of learning it using a neural network. Note that even though the base model $\hat { f }$ is an HNN, due to   
+162 projection, the cFINDE $f$ is no longer a Hamiltonian system in the strict sense.
+
+Compared to the base model $\hat { f }$ , the cFINDE requires the additional computation of the neural network $V$ , several matrix multiplications, and an inverse operation. The inverse operation needs a computational cost of $O ( K ^ { 3 } )$ , which is not costly if the number $K$ of first integrals is small. For satisfying the constraints and geometric structures, many previous models also need the inverse operation, such as Lagrangian neural network (LNN) [13], neural symplectic form [9], and CHNN [20].
+
+69 To eliminate numerical errors caused by temporal discretization, we employ discrete gradients and   
+70 propose a projection method called discrete FINDE (dFINDE).
+
+A discrete gradient $\overline { { \nabla } } V$ is a discrete analogue to a gradient $\nabla V$ [6, 23, 25, 29, 44, 45]. Recall that a gradient $\nabla V$ of a function $V : \mathbb { R } ^ { N }  \mathbb { R }$ can be regarded as a function $\mathbb { R } ^ { N } \to \mathbb { R } ^ { N }$ that satisfies the chain rule $\begin{array} { r } { \frac { \mathrm { d } } { \mathrm { d } t } V ( \pmb { u } ) = \nabla V ( \pmb { u } ) ^ { \top } \frac { \mathrm { d } } { \mathrm { d } t } \pmb { u } } \end{array}$ . Analogously, a discrete gradient $\overline { \nabla }$ is defined as follows.
+
+Definition 2 (discrete gradient). A discrete gradient $\overline { { \nabla } } V$ of a function $V : \mathbb { R } ^ { N }  \mathbb { R }$ is a function $\mathbb { R } ^ { N } \times \mathbb { R } ^ { N } \xrightarrow [ ] { } \mathbb { R } ^ { N }$ that satisfies
+
+$$
+V ( \pmb { v } ) - V ( \pmb { u } ) = \overline { { \nabla } } V ( \pmb { v } , \pmb { u } ) ^ { \top } ( \pmb { v } - \pmb { u } ) ~ a n d ~ \overline { { \nabla } } V ( \pmb { u } , \pmb { u } ) = \nabla V ( \pmb { u } ) .
+$$
+
+176 The first condition is a discrete analogue to the chain rule when replacing the time-derivatives ${ \frac { \mathrm { d } } { \mathrm { d } t } } V$   
+177 and ${ \frac { \mathrm { d } } { \mathrm { d } t } } { \pmb u }$ with finite differences $( V ( \pmb { v } ) - V ( \pmb { u } ) )$ and $( { \pmb v } - { \pmb u } )$ , respectively, and the second condition   
+178 ensures the consistency with the ordinary gradient $\nabla V$ . A discrete gradient $\overline { { \nabla } } V$ is not uniquely   
+179 determined and has been obtained manually. Recently, the automatic discrete differentiation algorithm   
+180 (ADDA) has been proposed in [38], which obtains a discrete gradient of a neural network in a similar   
+181 way to the automatic differentiation algorithm [1, 42]. The discrete gradient is defined in discrete   
+182 time, and hence a numerical integration using the discrete gradient is free from numerical errors   
+183 caused by temporal discretization. See Appendix $\mathbf { B }$ and the references [6, 23, 38] for more details.
+
+Following [11, 15], we introduce a discrete analogue to the tangent space 184 $\mathcal { T } _ { \mathbf { \ b { u } } } \mathcal { M } ^ { \prime }$ called the discrete tangent space 185 $\mathcal { T } _ { ( \pmb { v } , \pmb { u } ) } \mathcal { M } ^ { \prime }$ . In particular, for a pair $( \pmb { v } , \pmb { u } ) \in \mathcal { M } ^ { \prime }$ of points, it is defined as
+
+$$
+\mathcal { T } _ { ( v , u ) } \mathcal { M } ^ { \prime } = \{ \pmb { w } \in \mathbb { R } ^ { N } : \overline { { \nabla } } V _ { k } ( \pmb { v } , \pmb { u } ) ^ { \top } \pmb { w } = 0 \mathrm { ~ f o r ~ } k = 1 , \ldots , K \} .
+$$
+
+186 If the finite difference $( \pmb { u } ^ { s + 1 } - \pmb { u } ^ { s } )$ between the predicted and current states is on the discrete   
+187 tangent space $\mathcal { T } _ { \left( \pmb { u } ^ { s + 1 } , \pmb { u } ^ { s } \right) } \mathcal { M } ^ { \prime }$ , the first integrals $V _ { k }$ are preserved because $V _ { k } ( { \pmb u } ^ { s + 1 } ) - V _ { k } ( { \pmb u } ^ { s } ) =$   
+188 $\overline { { \nabla } } V _ { k } ( \pmb { u } ^ { s + 1 } , \pmb { u } ^ { s } ) ^ { \top } ( \pmb { u } ^ { s + 1 } - \pmb { u } ^ { s } ) = 0$ . Note that similar concepts defined in different ways are also   
+189 referred to as discrete tangent spaces [14, 16].
+
+Let ψˆ denote a discrete-time base model that satisfies u˜s+1−us∆ts 190 $\begin{array} { r } { \frac { \tilde { \mathbf { u } } ^ { s + 1 } - \mathbf { u } ^ { s } } { \Delta t ^ { s } } = \hat { \psi } ( \mathbf { u } ^ { s } ; \Delta t ^ { s } ) } \end{array}$ , where $\tilde { { \pmb u } } ^ { s + 1 }$ denotes 191 the predicted state. We assume that the base model $\hat { \psi }$ is composed of a continuous-time base model 192 ˆf and a numerical integrator. Then, the dFINDE us+1−∆ts $\begin{array} { r } { \frac { { \pmb u } ^ { s + 1 } - { \pmb u } ^ { s } } { \Delta t ^ { s } } = \psi ( { \pmb u } ^ { s + 1 } , { \pmb u } ^ { s } ; \Delta t ^ { s } ) } \end{array}$ is given by
+
+$$
+\psi ( \pmb { u } ^ { s + 1 } , \pmb { u } ^ { s } ; \Delta t ^ { s } ) = \hat { \psi } ( \pmb { u } ^ { s } ; \Delta t ^ { s } ) - \overline { { M } } ( \pmb { u } ^ { s + 1 } , \pmb { u } ^ { s } ) ^ { \top } \lambda ( \pmb { u } ^ { s + 1 } , \pmb { u } ^ { s } ) ,
+$$
+
+where 193 $\overline { { M } } ( { \pmb u } ^ { s + 1 } , { \pmb u } ^ { s } ) = ( \overline { { \nabla } } V _ { 1 } ( { \pmb u } ^ { s + 1 } , { \pmb u } ^ { s } )$ . . . $\overline { { \nabla } } V _ { K } ( \pmb { u } ^ { s + 1 } , \pmb { u } ^ { s } ) ) ^ { \top }$ . As is the case in continuous time, 194 the preservation of the first integrals $V _ { k }$ leads to
+
+$$
+\begin{array} { r } { \mathbf { 0 } = \frac { V ( u ^ { s + 1 } ) - V ( u ^ { s } ) } { \Delta t ^ { s } } = \overline { { M } } ( u ^ { s + 1 } , u ^ { s } ) \frac { u ^ { s + 1 } - u ^ { s } } { \Delta t ^ { s } } = \overline { { M } } ( u ^ { s + 1 } , u ^ { s } ) \psi ( u ^ { s + 1 } , u ^ { s } ; \Delta t ^ { s } ) . } \end{array}
+$$
+
+195 Substituting Eq. (9) and eliminating the Lagrange multiplier $\boldsymbol { \lambda }$ , we obtain
+
+$$
+\psi ( \pmb { u } ^ { s + 1 } , \pmb { u } ^ { s } ; \Delta t ^ { s } ) = ( I - \overline { { Y } } ( \pmb { u } ^ { s + 1 } , \pmb { u } ^ { s } ) ) \hat { \psi } ( \pmb { u } ^ { s } ; \Delta t ^ { s } )
+$$
+
+Remark 2 (discrete-time first integral preservation). The dFINDE us+1−us∆ts preserves all first integrals $V _ { k }$ for $k = 1 , \ldots , K$ in discrete time, i.e., $V _ { k } ( { \pmb u } ^ { s + 1 } ) - V _ { k } ( { \pmb u } ^ { s } ) = 0$ $\begin{array} { r } { \frac { { \pmb u } ^ { s + 1 } - { \pmb u } ^ { s } } { \Delta t ^ { s } } = \psi ( { \pmb u } ^ { s + 1 } , { \pmb u } ^ { s } ; \Delta t ^ { s } ) } \end{array}$
+
+198 Due to projection, dFINDE can be regarded as a projection method using discrete gradients. For the   
+199 base model $\hat { \psi }$ , the continuous-time base model $\hat { f }$ can be a NODE, an HNN, or other models, and the   
+200 numerical integrator can be a Runge–Kutta method, the leapfrog integrator, or others.   
+201 Because dFINDE is an implicit method, it is computationally expensive for prediction. However, the   
+202 next state $\boldsymbol { u } ^ { s + 1 }$ is given for training, and the ADDA can explicitly obtain the discrete gradient w.r.t. the   
+203 pair $( { \pmb u } ^ { s + 1 } , { \pmb u } ^ { s } )$ as well as its computational graph. Thus, dFINDE can be computed explicitly and   
+204 optimized by standard backpropagation algorithms. Moreover, we suppose that dFINDE projects   
+205 the finite difference $\hat { \psi }$ only at every time step, whereas cFINDE projects the time-derivative $\hat { f }$ at   
+206 every substep inside a numerical integrator. Therefore, dFINDE is less computationally expensive   
+207 than cFINDE for training. In contrast, a typical projection method requires much computational   
+208 cost to solve an optimization problem for training, and standard backpropagation algorithms are not   
+209 applicable to it.   
+10 Remark 3 (trainability). The dFINDE can be trained using the standard backpropagation algorithm,   
+211 whereas a straightforward application of a projection method cannot.
+
+Table 2: Datasets, Dynamics, and First Integrals.   
+
+<table><tr><td rowspan="2">Dataset</td><td rowspan="2">Dynamics</td><td rowspan="2">N</td><td colspan="4">First Integrals</td></tr><tr><td>Energy</td><td>Momentum</td><td>Mass</td><td>Constraint</td></tr><tr><td>Two-body problem</td><td>Canonical Hamiltonian</td><td>8</td><td></td><td>1</td><td></td><td></td></tr><tr><td>Discretized KdV equation</td><td>Non-canonical Hamiltonian</td><td>50</td><td>广</td><td></td><td>1</td><td></td></tr><tr><td>Double pendulum</td><td>Poisson</td><td>8</td><td>√</td><td></td><td></td><td>√</td></tr><tr><td>FitzHugh-Nagumo model</td><td>Dirac</td><td>4</td><td></td><td></td><td></td><td>√</td></tr></table>
+
+# 4 Experiments
+
+# 4.1 Experimental Settings
+
+Target Systems We evaluated FINDE and base models using datasets associated with first integrals, summarized in Table 2. A gravitational two-body problem (2-body) on a 2-dimensional configuration space is a typical Hamiltonian system in the canonical form. In addition to the total energy, it has first integrals related to symmetries in space, namely, the linear and angular momenta. The Korteweg–De Vries (KdV) equation is a PDE model of shallow water waves. This is a Hamiltonian system in a non-canonical form and has the Hamiltonian, total mass, and many other quantities as first integrals. A double pendulum (2-pend) is a Hamiltonian system in polar coordinates. However, we transformed it to Cartesian coordinates; it was no longer a Hamiltonian system but a Poisson system. The lengths of two rods work as holonomic constraints and lead to four first integrals. The FitzHugh–Nagumo model is a biological neuron model as an electric circuit, which exhibits a rapid and transient change of voltage called a spike. As an electric circuit, the currents through and voltages applied to the inductor and capacitor can be regarded as system states, and the states are constrained by the circuit topology and Kirchhoff’s current and voltage laws. Then, this system has a state of four elements and two first integrals. Due to energy dissipation in the resistor, the model is not a Poisson system, but one can find a Dirac structure [53]. See Appendix C for more details.
+
+Implementation We implemented the proposed FINDE and evaluated it under the following settings. We implemented all codes by modifying the officially released codes of HNN [26] 2 and DGNet $[ 3 8 ] ^ { 3 }$ . We used Python v3.8.12 with packages scipy v1.7.3, pytorch v1.10.2, torchdiffeq v0.1.1, functorch v1.10 preview, and gplearn v0.4.2. We used the Dormand–Prince method (dopri5) [18] as the numerical integrator, unless otherwise stated. All experiments were performed on a single NVIDIA A100 provided by (ANONYMOUS PROVIDER).
+
+Following HNN [26] and DGNet [38], we represented the first integrals $V$ , NODE, and HNN $H$ using fully-connected neural networks with two hidden layers. Each hidden layer had 200 units and preceded a hyperbolic tangent activation function. Each weight matrix was initialized as an orthogonal matrix. The input was the state $\textbf { \em u }$ , and the output represented the first integrals $V$ for FINDE, time-derivative $\hat { f }$ for NODE, and the Hamiltonian $H$ for HNN. For the KdV dataset, we used a 1-dimensional convolutional neural network (CNN), each of whose layers had a kernel size of 3. The double pendulum is a second–order system, implying that the time-derivative ddt q of the position $\pmb q$ is known as the velocity $\textbf {  { v } }$ . Hence, we treated only the acceleration $\begin{array} { r } { \frac { \mathrm { d } } { \mathrm { d } t } \pmb { v } } \end{array}$ as the output to learn. This assumption slightly improved the absolute performances but did not change the relative trends.
+
+We used the $I$ -step error as the loss function to be minimized. In particular, it is the mean squared error (MSE) between the ground truth state $\pmb { u } _ { \mathrm { G T } } ^ { s }$ and the state $\pmb { u } _ { \mathrm { p r e d . } } ^ { s }$ . predicted from the previous step $u _ { \mathrm { G T } } ^ { s - 1 }$ . The base model and FINDE were jointly trained using the Adam optimizer [33] with the parameters $( \beta _ { 1 } , \beta _ { 2 } ) = ( 0 . 9 , 0 . 9 9 9 )$ and a batch size of 200. The learning rate was initialized to $1 0 ^ { - 3 }$ and decayed to zero with a cosine annealing [36].
+
+249 Evaluation Metric As an evaluation metric, we used the 1-step error, which is identical to the loss   
+250 function. We displayed it at the scale of $\times 1 0 ^ { - 9 }$ . The lower this indicator, the better, as emphasized   
+251 by $\downarrow$ . While several studies used the MSEs of the state or system energy over the whole time   
+252 series [26, 38], we consider these indicators are misleading, as pointed in several studies [4]. For   
+253 example, in the case of a periodic orbit, an orbit that is correctly learned except for a slight difference   
+254 in angular velocity will have the same MSE as an orbit that never moves from its initial position.   
+255 Instead, we used the valid prediction time $( V P T )$ [4, 32, 54]. VPT denotes the time point $s$ divided by   
+256 the length $S$ of time series at which the MSE of the predicted state $\pmb { u } _ { \mathrm { p r e d . } } ^ { s }$ . exceeds a given threshold $\theta$   
+257 for the first time in an initial value problem, that is,
+
+$$
+\begin{array} { r } { V P T ( u _ { \mathrm { p r e d . } } ; u _ { \mathrm { G T } } ) = \frac { 1 } { S } \arg \operatorname* { m a x } _ { s _ { f } } \{ s _ { f } | \mathrm { M S E } ( u _ { \mathrm { p r e d . } } ^ { s } , u _ { \mathrm { G T } } ^ { s } ) < \theta \mathrm { f o r } \mathrm { a l l } s \leq s _ { f } \} . } \end{array}
+$$
+
+258 To obtain VPTs, we normalized each element of state to have zero mean and unit variance in the   
+259 training data and set $\theta$ to 0.01. The higher this indicator, the better, as emphasized by $\uparrow$ . Because of   
+260 the “spiking” behavior of the FitzHugh–Nagumo model, a small error in phase is regarded as a large   
+261 error in state. To measure the qualitative performance, we calculated VPTs by allowing for a delay   
+262 and advance of up to 5 steps.
+
+# 4.2 First Integral Preservation for Hamiltonian System
+
+Before learning first integrals from data, we first evaluated FINDE as a numerical integrator using a known mass-spring system. The system has the state $\mathbf { \boldsymbol { \mathscr { u } } } \doteq ( q v ) ^ { \top }$ , the dynamics ddt q = v and d $\begin{array} { r } { { \frac { \mathrm { d } } { \mathrm { d } t } } v \ = - q } \end{array}$ , and the system energy $E ( q , v ) =$ ${ \scriptstyle { \frac { 1 } { 2 } } } ( q ^ { 2 } + v ^ { 2 } )$ . Using the initial value $( 1 . 0 \ 0 . 0 ) ^ { \top }$ and the time step size $\Delta t = 0 . 2$ , we solved the initial value problem of the true ODE using the leapfrog integrator. We applied FINDE with the true system energy $E$ as the first integral $V$ . Note that no neural networks nor training were involved.
+
+![](images/e62087da4d5eea6ebb9b01535f06401e481e011b62a41af256ef1f7e2091ccfd.jpg)  
+Figure 1: Integration of a known mass-spring system.
+
+273 The results with the analytical solution are shown in Fig. 1. The upper panel shows that the time series   
+274 predicted by comparison methods overlap each other and are apparently almost identical. However,   
+275 the lower panel shows that the energy obtained from the states predicted by the leapfrog integrator is   
+276 fluctuating. The same is true for the case with the cFINDE. This is because the symplectic integrator   
+277 and the cFINDE suffer from numerical errors caused by temporal discretization. In contrast, the   
+278 dFINDE preserves the energy accurately. This is because, at every step, the dFINDE projects the state   
+279 $( q v ) ^ { \top }$ onto the discrete tangent space $\mathcal { T } _ { ( \pmb { v } , \pmb { u } ) } \mathcal { M } ^ { \prime }$ . Although a smaller step size reduces numerical   
+280 errors, this result demonstrates the advantage of dFINDE.
+
+# 281 4.3 Learning First Integrals from Data of Hamiltonian System
+
+82 We evaluated FINDE on learning from the 2-body dataset. We used HNN as the base model $\hat { f }$ . We   
+83 found that the FINDE got better performances if it did not treat the Hamiltonian $H$ of the HNN   
+84 as one of first integrals $V _ { k }$ . The medians and standard deviations of 5 trials are summarized in the   
+85 leftmost column of Table 3. The cFINDE achieved better VPTs than the vanilla HNN with $K = 1$   
+86 to 2, and the performance was suddenly degraded for $K = 3$ . The dFINDE showed a similar trend   
+7 with slightly better performances. The HNN with FINDE found two first integrals in addition to the   
+88 Hamiltonian $H$ of the HNN. Even though a two-body problem is a Hamiltonian system that HNN   
+89 can learn, the prior knowledge that there exist first integrals other than the Hamiltonian $H$ can be   
+90 a clue to better learning. The HNN with FINDE got worse 1-step errors, suggesting that without   
+FINDE, HNN overfitted short-term change and had difficulty predicting long-term dynamics.
+
+We performed a symbolic regression of first integrals $V$ learned by the neural network. For $K = 2$ , the learned first integrals $V$ were identical to the linear momenta in the $x$ - and $y$ -directions up to affine transformation in most cases. See Appendix D.1 for more details.
+
+We depict example results in Fig. 2. In the absence of FINDE, the mass positions $( x _ { 1 } , y _ { 1 } ) , ( x _ { 2 } , y _ { 2 } )$ became inaccurate in a short time and the center-of-gravity position $\textstyle ( x _ { c } , y _ { c } ) = ( { \frac { x _ { 1 } + x _ { 2 } } { 2 } } , { \frac { y _ { 1 } + y _ { 2 } } { 2 } } )$ deviated rapidly. The HNN with cFINDE accurately predicted the state for a longer period. Even after errors in the mass positions became non-negligible, errors in the center-of-gravity position were still small. We show the absolute errors averaged over all trials in Fig. 3. In each of $x$ - and $y$ -directions,
+
+Table 3: Results of FINDE.   
+
+<table><tr><td colspan="2"></td><td colspan="2">2-body + HNN</td><td colspan="2">KdV</td><td colspan="2">2-pend</td><td colspan="2">FitzHugh-Nagumo</td></tr><tr><td>Model</td><td>K</td><td>1-step↓</td><td>VPT个</td><td>1-step↓</td><td>VPT个</td><td>1-step↓</td><td>VPT个</td><td>1-step↓</td><td>VPT个</td></tr><tr><td>base model -</td><td></td><td></td><td>5.17 ±0.57 0.362 ±0.026</td><td>5.59 ±0.30</td><td>0.339 ±0.038</td><td>0.82 ±0.02</td><td>0.110±0.035</td><td></td><td>73.66 ±12.59 0.236 ±0.053</td></tr><tr><td rowspan="6">+ cFINDE</td><td>1</td><td>7.10 ±1.25</td><td>0.374 ±0.036</td><td>6.24 ±0.44</td><td>0.371 ±0.088</td><td>0.75 ±0.04</td><td>0.156±0.042</td><td>54.18 ±8.12</td><td>0.127 ±0.148</td></tr><tr><td>2</td><td>7.78 ±1.39</td><td>0.450 ±0.052</td><td>2.59 ±0.11</td><td>0.608 ±0.085</td><td>0.73±0.05</td><td>0.198 ±0.088</td><td>37.03 ±3.81</td><td>0.437 ±0.084</td></tr><tr><td>3</td><td>&gt;103</td><td>0.147 ±0.146*</td><td>3.19 ±0.37</td><td>0.730 ±0.091</td><td>0.69 ±0.03</td><td>0.411 ±0.093</td><td>&gt;106</td><td>0.007 ±0.007*</td></tr><tr><td>4</td><td>&gt;103</td><td>0.101 ±0.005</td><td>3.65 ±0.30</td><td>0.641 ±0.071</td><td>0.77 ±0.07</td><td>0.395 ±0.083</td><td>一</td><td></td></tr><tr><td>5</td><td>&gt;103</td><td>0.080±0.014</td><td>4.68 ±0.43</td><td>0.601 ±0.069</td><td>0.80±0.07</td><td>0.585 ±0.097</td><td></td><td></td></tr><tr><td>6</td><td>&gt;10³</td><td>0.070 ±0.019</td><td>7.79 ±0.51</td><td>0.425 ±0.067</td><td>12.53±0.00</td><td>0.005 ±0.000*</td><td></td><td></td></tr><tr><td rowspan="5">+ dFINDE</td><td>1</td><td>7.01 ±1.06</td><td>0.379 ±0.040</td><td>11.61 ±6.60</td><td>0.288 ±0.083</td><td>0.75 ±0.10</td><td>0.152 ±0.017</td><td>47.07 ±8.03</td><td>0.117 ±0.122</td></tr><tr><td>2</td><td>7.03 ±1.00</td><td>0.475 ±0.022</td><td>2.70 ±0.26</td><td>0.598 ±0.059</td><td>0.74±0.05</td><td>0.271 ±0.111</td><td>33.24 ±3.40</td><td>0.455 ±0.032</td></tr><tr><td></td><td></td><td>3 54.78 ±36.39 0.309 ±0.024</td><td>3.78±0.27</td><td>0.636 ±0.024</td><td>0.69±0.05</td><td>0.447 ±0.081</td><td></td><td>319.70 ±91.11 0.049 ±0.007</td></tr><tr><td>4</td><td>&gt;10</td><td>0.102 ±0.015</td><td>3.48±0.32</td><td>0.780 ±0.059</td><td>0.71 ±0.03</td><td>0.454 ±0.060</td><td></td><td></td></tr><tr><td>5</td><td>&gt;103</td><td>0.086±0.011*</td><td>5.26 ±0.15</td><td>0.718±0.038</td><td>0.86 ±0.09</td><td>0.591 ±0.087</td><td></td><td></td></tr><tr><td></td><td>6</td><td>&gt;103</td><td>0.059 ±0.017</td><td>9.60 ±3.61</td><td></td><td></td><td>0.573 ±0.121 58.88 ±22.98 0.037 ±0.039</td><td></td><td></td></tr></table>
+
+A standard deviation follows $\pm$ symbol. Underlines indicate results better than the base models’ results, and bolded fonts indicate the best results. ∗ denotes that some trials failed in training because of the underflow of the step size. A dash denotes a case we did not try.
+
+![](images/89d03c9a7890406db2fbecc814f8b6b34cdc584df01fb3eb8c8146f7deede677.jpg)  
+Figure 2: Example results of the 2-body dataset.
+
+![](images/468b3482f1aadb8120b8263d0dcca0d63d619e797bf1f63eb5d4a25bb716d4d7.jpg)  
+Figure 3: Mean absolute errors of states for the 2-body dataset with or without cFINDE.
+
+300 the HNN without FINDE produced errors in the center-of-gravity position $x _ { c }$ (or $y _ { c }$ ) and those in the   
+301 mass positions $x _ { 1 } , x _ { 2 }$ (or $y _ { 1 } , y _ { 2 } )$ at almost the same level. In contrast, when the cFINDE is present,   
+302 errors in the center-of-gravity position were much smaller than those in the mass positions, implying   
+303 that errors in one mass position canceled out errors in the other mass position.
+
+Therefore, we conclude that FINDE not only had better prediction accuracy but also found and preserved linear momenta (which are related to symmetries in space) more accurately despite not having prior knowledge about symmetries.
+
+# 307 4.4 Learning First Integrals from Data of Unknown Systems
+
+308 It is often unclear whether a target system is a Hamiltonian system or not, but one can expect that the   
+309 target system has several first integrals. We evaluated FINDE using NODE as the base model. We   
+310 summarized the results in Table 3.   
+311 For the KdV dataset, the NODE with FINDE got much better 1-step errors and VPTs for a wide   
+312 range of $K$ . Figure 4 shows an example result. The top panels show that the prediction results were   
+313 apparently similar. The bottom panels summarize mean absolute errors in states $\textbf { \em u }$ , total mass $\textstyle \sum _ { k } u _ { k }$   
+314 and energy. In the absence of FINDE, the NODE increased all of its errors in proportion to time. With   
+315 the cFINDE, the error in total mass increased at the point where the two solitons collided but then   
+316 returned to the original level. Although the calculation is slightly inaccurate, the cFINDE learned   
+317 to preserve the total mass. The rightmost panel shows that the error in energy continued to increase   
+318 for $K = 2$ , but it stayed within a small range for $K = 3$ . These results suggest that the first or   
+319 second quantity learned by the cFINDE was total mass, the third quantity was system energy, and the   
+320 remaining quantity may correspond to one of the many first integrals of the KdV equation.   
+321 For the 2-pend dataset, the NODE with FINDE got better 1-step errors and VPTs for $K = 1$ to 5   
+322 except for the 1-step error of the dFINDE with $K = 5$ . In addition to the system energy, the double   
+323 pendulum has two holonomic constraints on the position, which lead to two additional constraints   
+324 involving the velocity (see Appendix C for details). Thus, it is reasonable that the NODE with FINDE   
+325 got the best VPTs for $K = 5$ first integrals and totally failed when assuming $K > 5$ first integrals.   
+326 As exemplified in Fig. 5, the NODE without FINDE did not preserve the lengths of rods, making   
+327 the states deviate gradually. See Appendix D.2 for the case when actual constraints are known. For   
+328 the FitzHugh–Nagumo dataset, the NODE with FINDE got much better 1-step errors and VPTs for   
+329 $K = 2$ . As exemplified in Fig. 6, the ground truth state converged to a periodic orbit, and only the   
+330 NODE with cFINDE for $K = 2$ reproduced such dynamics. On the other hand, the state did not   
+331 stay at a limited region without FINDE and converged to a wrong equilibrium with the cFINDE for   
+332 $K = 1$ . For $K = 1$ , the sole quantity $V _ { 1 }$ may have tried to learn both of the two first integrals and   
+333 remained under-trained. In these two cases, FINDE found all first integrals; $K = 5$ for the 2-pend   
+334 dataset and $K = 2$ for the FitzHugh–Nagumo dataset.
+
+![](images/be5e28ffd5b113697cd23b60e955f60ccb12a63a936fb9ef9c08be823a75a887.jpg)  
+Figure 4: Example results of the KdV dataset. (top) Predicted states. Red belts denote moving solitons. (bottom) Mean absolute errors.
+
+![](images/8556882ad46dc0590252f5c7531273f1da140556e98cc6d80d3d2b4923a070e9.jpg)  
+Figure 5: Example results of the 2-pend dataset for 2,000 steps.
+
+![](images/7787089d38eb6cba10618809e53bcab45a879c57163f3cfcbb6474ad1a9cd456.jpg)  
+Figure 6: Example results of the FitzHugh–Nagumo dataset.
+
+# 335 5 Conclusion
+
+This study proposed first integral-preserving neural differential equation (FINDE). FINDE projects the time evolution onto the submanifold defined using the (discrete) gradients of first integrals represented by a neural network. With an appropriate number of assumed first integrals, FINDE predicted future states more accurately than base models. Not only that, FINDE found and preserved the system energy and the total mass as first integrals, first integrals related to symmetries in space, and first integrals led by constraints in a unified manner. Therefore, FINDE has the potential to make a scientific discovery by revealing unknown properties of target dynamical systems.
+
+The 1-step errors were on the order of $1 0 ^ { - 5 }$ to $1 0 ^ { - 4 }$ in absolute error, being much larger than the numerical error tolerance of $1 0 ^ { - 9 }$ used in the experiments; numerical errors were negligible compared to modeling errors. However, the dFINDE tended to get VPTs better than the cFINDE despite the fact that its advantage is to eliminate numerical errors caused by temporal discretization. This result suggests that a method leading to smaller numerical errors results in a model with smaller modeling errors. Similar tendencies have been observed in previous works [10, 38], and these results may form a new frontier for integrating numerical and modeling errors.
+
+# References
+
+[1] Abadi, M., Agarwal, A., Barham, P., Brevdo, E., Chen, Z., Citro, C., Corrado, G. S., Davis, A., Dean, J., Devin, M., Ghemawat, S., Goodfellow, I., Harp, A., Irving, G., Isard, M., Jozefowicz, R., Jia, Y., Kaiser, L., Kudlur, M., Levenberg, J., Mané, D., Schuster, M., Monga, R., Moore, S., Murray, D., Olah, C., Shlens, J., Steiner, B., Sutskever, I., Talwar, K., Tucker, P., Vanhoucke, V., Vasudevan, V., Viégas, F., Vinyals, O., Warden, P., Wattenberg, M., Wicke, M., Yu, Y., and Zheng, X. (2016). TensorFlow: Large-scale machine learning on heterogeneous systems. USENIX Symposium on Operating Systems Design and Implementation (OSDI).   
+58 [2] Bai, S., Kolter, J. Z., and Koltun, V. (2019). Deep Equilibrium Models. In Advances in Neural Information Processing Systems (NeurIPS).   
+60 [3] Barrett, D. G. T. and Dherin, B. (2021). Implicit Gradient Regularization. In International Conference on Learning Representations (ICLR).   
+[4] Botev, A., Jaegle, A., Wirnsberger, P., Hennes, D., and Higgins, I. (2021). Which priors matter? Benchmarking models for learning latent dynamics. In Advances in Neural Information Processing Systems (NeurIPS) Track on Datasets and Benchmarks. [5] Cao, Y., Fang, Z., Wu, Y., Zhou, D. X., and Gu, Q. (2021). Towards Understanding the Spectral Bias of Deep Learning. International Joint Conference on Artificial Intelligence (IJCAI), pages 2205–2211.   
+7 [6] Celledoni, E., Grimm, V., McLachlan, R., McLaren, D., O’Neale, D., Owren, B., and Quispel, G. (2012). Preserving energy resp. dissipation in numerical PDEs using the “Average Vector Field” method. Journal of Computational Physics, 231(20):6770–6789. [7] Chen, S., Billings, S. A., and Grant, P. M. (1990). Non-linear system identification using neural networks. International Journal of Control, 51(6):1191–1214. [8] Chen, T. Q., Rubanova, Y., Bettencourt, J., Duvenaud, D., Chen, R. T. Q., Rubanova, Y., Bettencourt, J., and Duvenaud, D. (2018). Neural Ordinary Differential Equations. In Advances in Neural Information Processing Systems (NeurIPS), pages 1–19. [9] Chen, Y., Matsubara, T., and Yaguchi, T. (2021). Neural Symplectic Form $:$ Learning Hamiltonian Equations on General Coordinate Systems. In Advances in Neural Information Processing Systems (NeurIPS). [10] Chen, Z., Zhang, J., Arjovsky, M., and Bottou, L. (2020). Symplectic Recurrent Neural Networks. In International Conference on Learning Representations (ICLR), pages 1–23. [11] Christiansen, S. H., Munthe-Kaas, H. Z., and Owren, B. (2011). Topics in structure-preserving discretization. Acta Numerica, 20:1–119. [12] Clouse, D. S., Giles, C. L., Horne, B. G., and Cottrell, G. W. (1997). Time-delay neural networks: representation and induction of finite-state machines. IEEE Transactions on Neural Networks, 8(5):1065–70. [13] Cranmer, M., Greydanus, S., Hoyer, S., Battaglia, P., Spergel, D., and Ho, S. (2020). Lagrangian Neural Networks. In ICLR Deep Differential Equations Workshop, pages 1–9. [14] Cuell, C. and Patrick, G. W. (2009). Geometric discrete analogues of tangent bundles and constrained Lagrangian systems. Journal of Geometry and Physics, 59(7):976–997. [15] Dahlby, M., Owren, B., and Yaguchi, T. (2011). Preserving multiple first integrals by discrete gradients. Journal of Physics A: Mathematical and Theoretical, 44(30). [16] Dehmamy, N., Walters, R., Liu, Y., Wang, D., and Yu, R. (2021). Automatic Symmetry Discovery with Lie Algebra Convolutional Network. In Advances in Neural Information Processing Systems (NeurIPS), number 2018, pages 1–30. [17] Devlin, J., Chang, M.-W., Lee, K., and Toutanova, K. (2018). BERT: Pre-training of Deep Bidirectional Transformers for Language Understanding. arXiv, pages 1–15. [18] Dormand, J. R. and Prince, P. J. (1986). A reconsideration of some embedded Runge-Kutta formulae. Journal of Computational and Applied Mathematics, 15(2):203–211. [19] Finzi, M., Stanton, S., Izmailov, P., and Wilson, A. G. (2020a). Generalizing Convolutional Neural Networks for Equivariance to Lie Groups on Arbitrary Continuous Data. In International Conference on Machine Learning (ICML), pages 3146–3157.   
+[20] Finzi, M., Wang, K. A., and Wilson, A. G. (2020b). Simplifying Hamiltonian and Lagrangian Neural Networks via Explicit Constraints. In Advances in Neural Information Processing Systems (NeurIPS).   
+[21] Finzi, M., Welling, M., and Wilson, A. G. (2021). A Practical Method for Constructing Equivariant Multilayer Perceptrons for Arbitrary Matrix Groups. In International Conference on Machine Learning (ICML).   
+[22] Furihata, D. (2001). A stable and conservative finite difference scheme for the Cahn-Hilliard equation. Numerische Mathematik, 87(4):675–699.   
+[23] Furihata, D. and Matsuo, T. (2010). Discrete Variational Derivative Method: A Structure-Preserving Numerical Method for Partial Differential Equations. Chapman and Hall/CRC.   
+[24] Gear, C. W. (1986). Maintaining Solution Invariants in the Numerical Solution of ODE s. SIAM Journal on Scientific and Statistical Computing, 7(3):734–743.   
+[25] Gonzalez, O. (1996). Time integration and discrete Hamiltonian systems. Journal of Nonlinear Science, 6(5):449–467.   
+[26] Greydanus, S., Dzamba, M., and Yosinski, J. (2019). Hamiltonian Neural Networks. In Advances in Neural Information Processing Systems (NeurIPS), pages 1–16.   
+[27] Hairer, E., Lubich, C., and Wanner, G. (2006). Geometric Numerical Integration: Structure-Preserving Algorithms for Ordinary Differential Equations, volume 31 of Springer Series in Computational Mathematics. Springer-Verlag, Berlin/Heidelberg.   
+[28] He, K., Zhang, X., Ren, S., and Sun, J. (2016). Deep Residual Learning for Image Recognition. In IEEE Conference on Computer Vision and Pattern Recognition (CVPR), pages 1–9.   
+[29] Hong, J., Zhai, S., and Zhang, J. (2011). Discrete Gradient Approach to Stochastic Differential Equations with a Conserved Quantity. SIAM Journal on Numerical Analysis, 49(5):2017–2038.   
+[30] Izhikevich, E. M. and FitzHugh, R. (2006). FitzHugh-Nagumo model.   
+[31] Jin, P., Zhang, Z., Kevrekidis, I. G., and Karniadakis, G. E. (2020a). Learning Poisson systems and trajectories of autonomous systems via Poisson neural networks. pages 1–12.   
+[32] Jin, P., Zhu, A., Karniadakis, G. E., and Tang, Y. (2020b). Symplectic networks: Intrinsic structurepreserving networks for identifying Hamiltonian systems. Neural Networks, 132:166–179.   
+[33] Kingma, D. P. and Ba, J. (2015). Adam: A Method for Stochastic Optimization. In International Conference on Learning Representations (ICLR), pages 1–15.   
+[34] Lee, K. and Carlberg, K. (2021). Deep Conservation: A latent-dynamics model for exact satisfaction of physical conservation laws. In AAAI Conference on Artificial Intelligence (AAAI).   
+[35] Levin, A. U. and Narendra, K. S. (1995). Recursive identification using feedforward neural networks. International Journal of Control, 61(3):533–547.   
+[36] Loshchilov, I. and Hutter, F. (2017). SGDR: Stochastic gradient descent with warm restarts. In International Conference on Learning Representations (ICLR), pages 1–16.   
+[37] Manek, G. and Kolter, J. Z. (2019). Learning Stable Deep Dynamics Models. In Advances in Neural Information Processing Systems (NeurIPS), pages 1–9.   
+[38] Matsubara, T., Ishikawa, A., and Yaguchi, T. (2020). Deep Energy-Based Modeling of Discrete-Time Physics. In Advances in Neural Information Processing Systems (NeurIPS).   
+[39] Miura, R. M., Gardner, C. S., and Kruskal, M. D. (1968). Korteweg-de Vries equation and generalizations. II. Existence of conservation laws and constants of motion. Journal of Mathematical Physics, 9(8):1204–1209.   
+[40] Narendra, K. S. and Parthasarathy, K. (1990). Identification and Control of Dynamical Systems Using Neural Networks. IEEE Transactions on Neural Networks, 1(1):4–27.   
+[41] Nelles, O. (2001). Nonlinear System Identification. Springer Berlin Heidelberg, Berlin, Heidelberg.   
+[42] Paszke, A., Chanan, G., Lin, Z., Gross, S., Yang, E., Antiga, L., and Devito, Z. (2017). Automatic differentiation in PyTorch. In Autodiff Workshop on Advances in Neural Information Processing Systems, pages 1–4.
+
+446 [43] Potra, F. A. and Yen, J. (1991). Implicit numerical integration for euler-lagrange equations via tangent   
+447 space parametrization. Mechanics of Structures and Machines, 19(1):77–98.   
+448 [44] Quispel, G. R. and Capel, H. W. (1996). Solving ODEs numerically while preserving a first integral.   
+449 Physics Letters, Section A: General, Atomic and Solid State Physics, 218(3-6):223–228.   
+450 [45] Quispel, G. R. and Turner, G. S. (1996). Discrete gradient methods for solving ODEs numerically while   
+451 preserving a first integral. Journal of Physics A: Mathematical and General, 29(13).   
+452 [46] Raff, L., Komanduri, R., Hagan, M., and Bukkapatnam, S. (2012). Neural Networks in Chemical Reaction   
+453 Dynamics.   
+454 [47] Rasp, S., Dueben, P. D., Scher, S., Weyn, J. A., Mouatadid, S., and Thuerey, N. (2020). WeatherBench: A   
+455 Benchmark Data Set for Data-Driven Weather Forecasting. Journal of Advances in Modeling Earth Systems,   
+456 12(11).   
+457 [48] Sannai, A., Imaizumi, M., and Kawano, M. (2021). Improved Generalization Bounds of Group Invariant   
+458 / Equivariant Deep Networks via Quotient Feature Spaces. In Conference on Uncertainty in Artificial   
+459 Intelligence (UAI).   
+460 [49] Sjöberg, J., Hjalmarsson, H., and Ljung, L. (1994). Neural Networks in System Identification. IFAC   
+461 Proceedings Volumes, 27(8):359–382.   
+462 [50] Takeishi, N. and Kawahara, Y. (2020). Learning dynamics models with stable invariant sets. In AAAI   
+463 Conference on Artificial Intelligence (AAAI).   
+464 [51] Teshima, T., Tojo, K., Ikeda, M., Ishikawa, I., and Oono, K. (2020). Universal Approximation Property   
+465 of Neural Ordinary Differential Equations. In NeurIPS Workshop on Differential Geometry meets Deep   
+466 Learning (DiffGeo4DL).   
+467 [52] Trigo, R. M. and Palutikof, J. P. (1999). Simulation of daily temperatures for climate change scenarios   
+468 over Portugal: A neural network model approach. Climate Research, 13(1):45–59.   
+469 [53] van der Schaft, A. and Jeltsema, D. (2014). Port-Hamiltonian Systems Theory: An Introductory Overview.   
+470 Foundations and Trends® in Systems and Control, 1(2):173–378.   
+471 [54] Vlachas, P. R., Pathak, J., Hunt, B. R., Sapsis, T. P., Girvan, M., Ott, E., and Koumoutsakos, P. (2020).   
+472 Backpropagation algorithms and Reservoir Computing in Recurrent Neural Networks for the forecasting of   
+473 complex spatiotemporal dynamics. Neural Networks, 126:191–217.   
+474 [55] Wang, Y. J. and Lin, C. T. (1998). Runge-Kutta neural network for identification of dynamical systems in   
+475 high accuracy. IEEE Transactions on Neural Networks, 9(2):294–307.   
+476 [56] Zhong, G. and Marsden, J. E. (1988). Lie-Poisson Hamilton-Jacobi Theory and Lie-Poisson Integrators.   
+477 Physics Letters A, 133(3):3–8.   
+478 [57] Zhong, Y. D., Dey, B., and Chakraborty, A. (2020). Dissipative SymODEN: Encoding Hamiltonian   
+479 Dynamics with Dissipation and Control into Deep Learning. arXiv, pages 1–6.
+
+1. For all authors...
+
+(a) Do the main claims made in the abstract and introduction accurately reflect the paper’s contributions and scope? [Yes] The theoretical contributions are summarized in Remarks 1 and 2. The performance improvements were validated numerically in Table 3 and visually in Figs. 1–6.   
+(b) Did you describe the limitations of your work? [Yes] We have discussed an increase in computational complexity at the bottoms of Sections 3.1 and 3.2. We also presented the limitations in Appendix D.2 while their situations were originally outside the scope of the proposed method.   
+(c) Did you discuss any potential negative societal impacts of your work? [N/A] No societal impact is supposed.   
+(d) Have you read the ethics review guidelines and ensured that your paper conforms to them? [N/A] We have read the guidelines carefully, but no ethical impact is supposed.
+
+2. If you are including theoretical results...
+
+(a) Did you state the full set of assumptions of all theoretical results? [Yes] We have introduced the background of the proposed method and provided the full set of assumptions in Section 2. Even though a slight modification may make the proposed method available on a general manifold, we have clearly stated that our theoretical and experimental results were limited to the finite-dimensional Eucleadian spaces.   
+(b) Did you include complete proofs of all theoretical results? [Yes] We have provided a proof just before each of Remarks 1 and 2.
+
+3. If you ran experiments...
+
+(a) Did you include the code, data, and instructions needed to reproduce the main experimental results (either in the supplemental material or as a URL)? [Yes] We have enclosed the source code to reproduce all experiments in supplemental materials.   
+(b) Did you specify all the training details (e.g., data splits, hyperparameters, how they were chosen)? [Yes] We have provided the software and hardware environment, network architectures, and hyperparameters in Section 4.1. We have also provided detailed hyperparameters to generate datasets in Appendix C.   
+(c) Did you report error bars (e.g., with respect to the random seed after running experiments multiple times)? [Yes] We have summarized the standard deviations over five trials in Table 3.   
+(d) Did you include the total amount of compute and the type of resources used (e.g., type of GPUs, internal cluster, or cloud provider)? [Yes] We have provided the hardware environment in Section 4.1, but we have anonymized the cloud service providers to avoid a potential violation of the double-blind policy.
+
+4. If you are using existing assets (e.g., code, data, models) or curating/releasing new assets...
+
+(a) If your work uses existing assets, did you cite the creators? [Yes] We have made the source code for all experiments by modifying the source codes of HNN [26] and DGNet [38]. We have cited these references and added links to respective repositories in the footnotes.   
+(b) Did you mention the license of the assets? [Yes] We have verified that the source codes of HNN [26] and DGNet [38] are provided in Apache-2.0 License and MIT License, respectively. We have clearly stated these facts in the footnotes.   
+(c) Did you include any new assets either in the supplemental material or as a URL? [Yes] We have enclosed the source code to generate datasets in supplemental materials.   
+(d) Did you discuss whether and how consent was obtained from people whose data you’re using/curating? [N/A]   
+(e) Did you discuss whether the data you are using/curating contains personally identifiable information or offensive content? [N/A]
+
+5. If you used crowdsourcing or conducted research with human subjects...
+
+(a) Did you include the full text of instructions given to participants and screenshots, if applicable? [N/A]
+
+534 (b) Did you describe any potential participant risks, with links to Institutional Review   
+535 Board (IRB) approvals, if applicable? [N/A]   
+536 (c) Did you include the estimated hourly wage paid to participants and the total amount   
+537 spent on participant compensation? [N/A]

parse/dev/xDaoT2zlJ0r/xDaoT2zlJ0r_content_list.json

@@ -0,0 +1,1288 @@
+[
+    {
+        "type": "text",
+        "text": "FINDE: Neural Differential Equations for Finding and Preserving Invariant Quantities ",
+        "text_level": 1,
+        "bbox": [
+            209,
+            122,
+            789,
+            172
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Anonymous Author(s)   \nAffiliation   \nAddress   \nemail ",
+        "bbox": [
+            423,
+            226,
+            578,
+            281
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Abstract ",
+        "text_level": 1,
+        "bbox": [
+            462,
+            318,
+            535,
+            334
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 Neural networks have shown promise for modeling dynamical systems from data.   \n2 Recent models, such as Hamiltonian neural networks, have been designed to   \n3 ensure known geometric structures of target systems and have shown excellent   \n4 modeling accuracy. However, in most situations where neural networks learn   \n5 unknown systems, their underlying structures are also unknown. Even in such   \n6 cases, one can expect that target systems are associated with first integrals (a.k.a. in  \n7 variant quantities), which are quantities remaining unchanged over time. First   \n8 integrals come from the conservation laws of system energy, momentum, and mass,   \n9 from constraints on states, and from other features of governing equations. By   \n10 leveraging projection methods and discrete gradient methods, we propose first   \n11 integral-preserving neural differential equations (FINDE). The proposed FINDE   \n12 finds and preserves first integrals from data, even in the absence of prior knowl  \n13 edge about the underlying structures. Experimental results demonstrate that the   \n14 proposed FINDE is able to predict future states of given systems much longer and   \n15 find various quantities consistent with well-known first integrals of the systems in   \n16 a unified manner. ",
+        "bbox": [
+            148,
+            349,
+            766,
+            570
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "17 1 Introduction ",
+        "text_level": 1,
+        "bbox": [
+            148,
+            598,
+            312,
+            614
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "18 Although neural networks have achieved remarkable results in image and natural language pro  \n19 cessing [17, 28], they have also been actively investigated for modeling dynamical systems [41].   \n20 Target systems include the chemical dynamics to accelerate computer simulations [46], the climate   \n21 dynamics for climate change prediction and weather forecasting [47, 52], and the physical dynamics   \n22 of vehicles and robots for optimal control [41]. Their history dates back to at least the 1990s, and   \n23 many approaches have been proposed so far (see [7, 12, 35, 40, 49, 55] for example). Recently,   \n24 neural ordinary differential equation (NODE) has redefined neural networks for continuous-time   \n25 dynamics [8]. A target system is described by an ordinary differential equation (ODE) $\\begin{array} { r } { \\frac { \\mathrm { d } } { \\mathrm { d } t } \\pmb { u } = \\pmb { f } ( t , \\pmb { u } ) } \\end{array}$   \n26 where $\\textbf { \\em u }$ denotes the system state. Then, a NODE replaces the vector field $f$ with a neural network   \n27 and employs a numerical integrator to obtain a solution ${ \\mathbf { } } { \\mathbf { } } { \\mathbf { } } { \\mathbf { } } { \\mathbf { } } { \\mathbf { } } { \\mathbf { } } { \\mathbf { } } { \\mathbf { } } { \\mathbf { } } { \\mathbf { } } \\mathbf { } { \\mathbf { } } \\mathbf { } { \\mathbf { } } \\mathbf { } { \\mathbf { } } \\mathbf { } \\mathbf { } \\mathbf { } \\mathbf { } \\mathbf { } \\mathbf { } \\mathbf { } \\mathbf { } \\mathbf { } \\mathbf { } \\mathbf { } \\mathbf { } \\mathbf { } \\mathbf { } \\mathbf { } \\mathbf { } \\mathbf { } \\mathbf { } \\mathbf { } \\mathbf { } \\mathbf { } \\mathbf { } \\mathbf { } \\mathbf { } \\mathbf { } \\mathbf { } \\mathbf { } \\mathbf { } \\mathbf { } \\mathbf { } \\mathbf { } \\mathbf { } \\mathbf { } \\mathbf { } \\mathbf { } \\mathbf { } \\mathbf { } \\mathbf { } \\mathbf { } \\mathbf { } \\mathbf { } \\mathbf { } \\mathbf { } \\mathbf { } \\mathbf { } \\mathbf { } \\mathbf { } \\mathbf { } \\mathbf { } \\mathbf { } \\mathbf { } \\mathbf { } \\mathbf { } \\mathbf { } \\mathbf { } \\mathbf { } \\mathbf { } \\mathbf { } \\mathbf { } \\mathbf { } \\mathbf { } \\mathbf { } \\mathbf { } \\mathbf { } \\mathbf { } \\mathbf { } \\mathbf { } \\mathbf { } \\mathbf { } \\mathbf { } \\mathbf { } \\mathbf { } \\mathbf { } \\mathbf { } \\mathbf { } \\mathbf { } \\mathbf { } \\mathbf { } \\mathbf { } \\mathbf { } \\mathbf { } \\mathbf { } \\mathbf { } \\mathbf { } \\mathbf { } \\mathbf { } \\mathbf { } \\mathbf { } \\mathbf { } \\mathbf { } \\mathbf { } \\mathbf { } \\mathbf { } \\mathbf { } \\mathbf \\Psi \\mathbf { } \\Psi \\mathbf { } \\mathbf { } \\mathbf { } \\mathbf { } \\mathbf { } \\mathbf \\Psi { } \\mathbf \\Psi \\mathbf { } \\mathbf { } \\mathbf \\Psi \\Psi \\mathbf { } \\mathbf { } \\mathbf \\Psi \\mathbf { } \\mathbf \\Psi \\mathbf { } \\mathbf \\Psi \\Psi \\mathbf { } \\mathbf \\mathbf { } \\mathbf \\Psi \\mathbf { } \\mathbf \\mathbf { } \\mathbf \\mathbf \\Psi \\Psi \\mathbf { } \\mathbf \\mathbf \\Psi \\Psi \\mathbf { } \\mathbf \\mathbf \\Psi \\mathbf { } \\mathbf \\mathbf \\Psi \\mathbf \\Psi \\Psi \\mathbf \\Psi \\mathbf { \\mathbf } \\mathbf \\mathbf \\Psi \\mathbf \\Psi \\mathbf \\Psi \\mathbf \\mathbf  \\mathbf \\Psi \\mathbf \\Psi \\mathbf \\Psi \\mathbf \\mathbf \\Psi \\mathbf \\Psi \\mathbf \\mathbf \\Psi \\mathbf \\Psi \\mathbf \\mathbf \\Psi \\mathbf \\mathbf \\Psi \\mathbf \\mathbf \\mathbf \\Psi \\mathbf \\mathbf \\mathbf \\Psi \\mathbf \\mathbf \\mathbf \\Psi \\mathbf \\mathbf \\mathbf \\mathbf \\mathbf \\mathbf \\Psi \\mathbf \\mathbf \\mathbf \\mathbf \\mathbf \\mathbf \\mathbf \\mathbf \\mathbf \\mathbf \\Psi \\mathbf \\mathbf \\mathbf \\mathbf \\mathbf \\mathbf \\mathbf \\mathbf \\mathbf \\mathbf \\mathbf \\mathbf \\mathbf \\mathbf \\mathbf \\mathbf \\mathbf \\mathbf \\mathbf $ .   \n28 Most real-world systems are associated with first integrals (a.k.a. invariant quantities), which are   \n29 quantities remaining unchanged over time [27]. If a system has a first integral $V ( { \\pmb u } )$ , the solution   \n30 ${ \\mathbf { } } { \\mathbf { } } { \\mathbf { } } { \\mathbf { } } { \\mathbf { } } { \\mathbf { } } { \\mathbf { } } { \\mathbf { } } { \\mathbf { } } { \\mathbf { } } { \\mathbf { } } \\mathbf { } { \\mathbf { } } \\mathbf { } { \\mathbf { } } \\mathbf { } { \\mathbf { } } \\mathbf { } \\mathbf { } \\mathbf { } \\mathbf { } \\mathbf { } \\mathbf { } \\mathbf { } \\mathbf { } \\mathbf { } \\mathbf { } \\mathbf { } \\mathbf { } \\mathbf { } \\mathbf { } \\mathbf { } \\mathbf { } \\mathbf { } \\mathbf { } \\mathbf { } \\mathbf { } \\mathbf { } \\mathbf { } \\mathbf { } \\mathbf { } \\mathbf { } \\mathbf { } \\mathbf { } \\mathbf { } \\mathbf { } \\mathbf { } \\mathbf { } \\mathbf { } \\mathbf { } \\mathbf { } \\mathbf { } \\mathbf { } \\mathbf { } \\mathbf { } \\mathbf { } \\mathbf { } \\mathbf { } \\mathbf { } \\mathbf { } \\mathbf { } \\mathbf { } \\mathbf { } \\mathbf { } \\mathbf { } \\mathbf { } \\mathbf { } \\mathbf { } \\mathbf { } \\mathbf { } \\mathbf { } \\mathbf { } \\mathbf { } \\mathbf { } \\mathbf { } \\mathbf { } \\mathbf { } \\mathbf { } \\mathbf { } \\mathbf { } \\mathbf { } \\mathbf { } \\mathbf { } \\mathbf { } \\mathbf { } \\mathbf { } \\mathbf { } \\mathbf { } \\mathbf { } \\mathbf { } \\mathbf { } \\mathbf { } \\mathbf { } \\mathbf { } \\mathbf { } \\mathbf { } \\mathbf { } \\mathbf { } \\mathbf { } \\mathbf { } \\mathbf { } \\mathbf { } \\mathbf { } \\mathbf { } \\mathbf { } \\mathbf { } \\mathbf { } \\mathbf { } \\mathbf { } \\mathbf \\Psi { } \\mathbf { } \\mathbf { } \\mathbf { } \\mathbf { } \\mathbf { } \\mathbf \\Psi { } \\mathbf \\Psi { } \\mathbf { } \\mathbf \\Psi \\mathbf { } \\mathbf { } \\mathbf { } \\mathbf \\Psi \\mathbf { } \\mathbf { } \\mathbf \\Psi \\mathbf { } \\mathbf { } \\mathbf \\Psi \\mathbf { } \\mathbf \\Psi \\mathbf { } \\mathbf \\Psi \\mathbf { } \\mathbf \\Psi \\mathbf { } \\mathbf \\mathbf { } \\mathbf \\mathbf { \\Psi } \\mathbf \\mathbf \\Psi \\mathbf { } \\mathbf \\mathbf \\Psi \\Psi \\mathbf { } \\mathbf \\mathbf \\mathbf { \\Psi \\mathbf } \\mathbf \\mathbf \\Psi \\Psi \\mathbf \\Psi \\mathbf { \\mathbf } \\mathbf \\mathbf \\mathbf \\Psi \\mathbf  \\mathbf \\Psi \\mathbf \\mathbf \\Psi \\mathbf \\Psi \\mathbf \\Psi \\mathbf \\Psi \\mathbf \\Psi \\mathbf \\mathbf \\Psi \\mathbf \\mathbf \\Psi \\mathbf \\mathbf \\Psi \\mathbf \\mathbf \\Psi \\mathbf \\mathbf \\mathbf \\Psi \\mathbf \\mathbf \\mathbf \\Psi \\mathbf \\mathbf \\mathbf \\mathbf \\mathbf \\mathbf \\Psi \\mathbf \\mathbf \\mathbf \\mathbf \\mathbf \\mathbf \\mathbf \\mathbf \\mathbf \\mathbf \\Psi \\mathbf \\mathbf \\mathbf \\mathbf \\mathbf \\mathbf \\mathbf \\mathbf \\mathbf \\mathbf \\mathbf \\mathbf \\mathbf \\mathbf \\mathbf \\mathbf \\mathbf \\mathbf \\mathbf $ for the initial condition $\\pmb { u } ( 0 )$ remains at a contour line $V ( \\mathbf { \\boldsymbol { u } } ( t ) ) = V ( \\mathbf { \\boldsymbol { u } } ( 0 ) )$ over time. Many   \n31 previous studies have attempted to learn a target system accurately by incorporating prior knowledge   \n32 about first integrals. Greydanus et al. [26] proposed Hamiltonian neural network (HNN), which   \n33 employs a neural network to approximate Hamilton’s equation, thereby conserving the system energy   \n34 called the Hamiltonian. Finzi et al. [19] proposed neural network architectures that conserve linear   \n35 and angular momenta by utilizing the graph structure. Finzi et al. [20] also extended HNN to a system   \n36 with holonomic constraints, which lead to first integrals such as a pendulum length. Matsubara et al.   \n37 [38] proposed a model that preserves the total mass of a discretized partial differential equation   \n38 (PDE). These studies have demonstrated that a neural network with more prior knowledge about first   \n39 integrals predicts the dynamics of the target system more accurately. See Table 1 for comparison.   \n40 Previous studies have mainly attempted to preserve known first integrals. However, in situations   \n41 where a neural network learns an unknown target system, it is naturally expected that first integrals   \n42 associated with the target system are also unknown, and it is not clear which of the above methods are   \n43 available. Given the above, this study proposes First Integral-preserving Neural Differential Equation   \n44 (FINDE) to find and preserve first integrals from data. FINDE has the following advantages.   \n45 Learning First Integrals For modeling continuous-time dynamics with known first integrals, many   \n46 studies have designed architectures or operations of neural networks [13, 19, 20, 26, 38]. For each   \n47 type of first integral, one dedicated method was proposed. However, the properties of a target system   \n48 are generally unknown in practice. In contrast, the proposed FINDE finds various kinds of first   \n49 integrals from data in a unified manner and preserves them in predictions. A symbolic regression   \n50 confirms that the learned first integrals are consistent with well-known first integrals of target systems. ",
+        "bbox": [
+            147,
+            630,
+            825,
+            768
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            145,
+            775,
+            825,
+            900
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "table",
+        "img_path": "images/b68f4c36f0f8436ffa368325e26671ba061972753e3b18687305a48494f583fa.jpg",
+        "table_caption": [
+            "Table 1: Comparison between Related Studies on Preservation of First Integrals. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td colspan=\"7\"></td></tr><tr><td></td><td>energy</td><td colspan=\"3\">monentum mass</td><td colspan=\"3\">constraint learning invariants exact conservation</td></tr><tr><td>NODE [8]</td><td></td><td></td><td></td><td></td><td></td><td></td></tr><tr><td>HNN [26]</td><td>√</td><td></td><td></td><td></td><td></td><td></td></tr><tr><td>LieConv [19]</td><td>√</td><td>厂</td><td></td><td></td><td></td><td></td></tr><tr><td>DGNet [38]</td><td>√</td><td></td><td>√</td><td></td><td></td><td></td></tr><tr><td>CHNN [20]</td><td>√</td><td></td><td></td><td>√</td><td></td><td></td></tr><tr><td>continuous FINDE (proposed)</td><td>√</td><td>√</td><td>√</td><td>√</td><td>√</td><td></td></tr><tr><td>discrete FINDE (proposed)</td><td>√</td><td>厂</td><td>厂</td><td>丁</td><td></td><td></td></tr></table>",
+        "bbox": [
+            217,
+            113,
+            779,
+            260
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            147,
+            285,
+            825,
+            327
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            147,
+            333,
+            825,
+            402
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            147,
+            416,
+            825,
+            501
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Combination with Known First Integrals The proposed FINDE can be combined with previously proposed neural networks designed to preserve known first integrals, such as HNN. Therefore, FINDE is available in various situations. ",
+        "bbox": [
+            163,
+            515,
+            823,
+            556
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "54 Exact Preservation of First Integrals Even if a first integral is associated with a continuous-time   \n55 system, it is destroyed after the system is discretized in time for computer simulations. This is true   \n56 even when using a symplectic integrator, which preserves the system energy only approximately [27].   \n57 By leveraging discrete gradients [38], the discrete-time version of FINDE preserves first integrals   \n58 exactly (up to rounding errors) in discrete time and further improves the prediction performance. ",
+        "bbox": [
+            147,
+            571,
+            826,
+            641
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "59 2 Background and Related Work ",
+        "text_level": 1,
+        "bbox": [
+            147,
+            660,
+            465,
+            678
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "60 First Integrals Let us consider a time-invariant differential system $\\begin{array} { r } { \\frac { \\mathrm { d } } { \\mathrm { d } t } \\pmb { u } \\ = \\ f ( \\pmb { u } ) } \\end{array}$ on an $N$ -   \n61 dimensional manifold $\\mathcal { M }$ , where $\\textbf { \\em u }$ denotes the system state and $f : \\mathcal { M } ^ { } \\to \\mathcal { T } _ { u } \\mathcal { M }$ represents a   \n62 vector field on the manifold $\\mathcal { M }$ . The manifold $\\mathcal { M }$ can be $\\mathcal { M } = S ^ { 1 } \\times \\mathbb { R } ^ { 1 }$ for a pendulum. In this   \n63 paper, we suppose the manifold $\\mathcal { M }$ be a Eucleadian space $\\mathbb { R } ^ { N }$ for simplicity.   \n64 Definition 1 (first integral). $A$ quantity $V : { \\mathcal { M } }  \\mathbb { R }$ is referred to as a first integral of a system   \n65 $\\begin{array} { r } { \\frac { \\mathrm { d } } { \\mathrm { d } t } \\pmb { u } = f ( \\pmb { u } ) } \\end{array}$ if it remains constant along with any solution ${ \\mathbf { } } { \\mathbf { } } { \\mathbf { } } { \\mathbf { } } { \\mathbf { } } { \\mathbf { } } { \\mathbf { } } { \\mathbf { } } { \\mathbf { } } { \\mathbf { } } \\mathbf { } { \\mathbf { } } \\mathbf { } { \\mathbf { } } \\mathbf { } \\mathbf { } \\mathbf { } \\mathbf { } \\mathbf { } \\mathbf { } \\mathbf { } \\mathbf { } \\mathbf { } \\mathbf { } \\mathbf { } \\mathbf { } \\mathbf { } \\mathbf { } \\mathbf { } \\mathbf { } \\mathbf { } \\mathbf { } \\mathbf { } \\mathbf { } \\mathbf { } \\mathbf { } \\mathbf { } \\mathbf { } \\mathbf { } \\mathbf { } \\mathbf { } \\mathbf { } \\mathbf { } \\mathbf { } \\mathbf { } \\mathbf { } \\mathbf { } \\mathbf { } \\mathbf { } \\mathbf { } \\mathbf { } \\mathbf { } \\mathbf { } \\mathbf { } \\mathbf { } \\mathbf { } \\mathbf { } \\mathbf { } \\mathbf { } \\mathbf { } \\mathbf { } \\mathbf { } \\mathbf { } \\mathbf { } \\mathbf { } \\mathbf { } \\mathbf { } \\mathbf { } \\mathbf { } \\mathbf { } \\mathbf { } \\mathbf { } \\mathbf { } \\mathbf { } \\mathbf { } \\mathbf { } \\mathbf { } \\mathbf { } \\mathbf { } \\mathbf { } \\mathbf { } \\mathbf { } \\mathbf { } \\mathbf { } \\mathbf { } \\mathbf { } \\mathbf { } \\mathbf { } \\mathbf { } \\mathbf { } \\mathbf { } \\mathbf { } \\mathbf { } \\mathbf { } \\mathbf { } \\mathbf { } \\mathbf { } \\mathbf { } \\mathbf { } \\mathbf { } \\mathbf { } \\mathbf { } \\mathbf { } \\mathbf { } \\mathbf { } \\mathbf { } \\mathbf { } \\mathbf { } \\mathbf { } \\mathbf { } \\mathbf \\Psi  \\mathbf { } \\mathbf { } \\mathbf { } \\mathbf { } \\mathbf { } \\mathbf { } \\mathbf \\mathbf { } \\mathbf { } \\mathbf { } \\mathbf \\Psi { } \\mathbf \\mathbf { } \\mathbf { } \\mathbf \\Psi \\mathbf { } \\mathbf { } \\mathbf \\mathbf { } \\mathbf \\Psi { } \\mathbf \\mathbf { } \\mathbf \\mathbf { } \\mathbf \\mathbf { } \\mathbf \\Psi \\mathbf { } \\mathbf \\mathbf { } \\mathbf \\mathbf { } \\mathbf \\mathbf { } \\mathbf \\mathbf \\Psi \\mathbf { } \\mathbf \\mathbf { } \\mathbf \\mathbf \\mathbf { } \\mathbf \\mathbf \\mathbf { } \\mathbf \\mathbf \\mathbf { \\mathbf } \\mathbf \\mathbf \\mathbf  \\mathbf \\Psi \\mathbf \\Psi \\mathbf { } \\mathbf \\mathbf \\mathbf \\mathbf \\mathbf { } \\mathbf \\mathbf \\mathbf \\mathbf \\mathbf \\Psi \\mathbf \\mathbf { } \\mathbf \\mathbf \\mathbf \\mathbf \\mathbf \\mathbf \\mathbf \\mathbf  \\mathbf \\mathbf \\mathbf \\mathbf \\Psi \\mathbf \\mathbf \\mathbf \\mathbf \\mathbf \\Psi \\mathbf \\mathbf \\mathbf \\mathbf \\mathbf \\mathbf \\mathbf \\mathbf \\mathbf \\mathbf \\mathbf \\mathbf \\mathbf \\mathbf \\mathbf \\mathbf \\mathbf \\mathbf \\mathbf \\mathbf \\mathbf \\mathbf \\mathbf \\mathbf \\mathbf \\mathbf \\mathbf \\mathbf \\mathbf \\mathbf \\mathbf \\mathbf \\mathbf \\mathbf \\mathbf \\mathbf$ , i.e., $\\begin{array} { r } { \\frac { \\mathrm { d } } { \\mathrm { d } t } V ( \\pmb { u } ) = 0 } \\end{array}$ . ",
+        "bbox": [
+            148,
+            691,
+            826,
+            750
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            155,
+            752,
+            823,
+            785
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "ntial system $\\begin{array} { r } { \\frac { \\mathrm { d } } { \\mathrm { d } t } { \\pmb u } = f ( { \\pmb u } ) } \\end{array}$ is associate ith $K$ functionally independent first integrals $V _ { 1 } , \\dots , V _ { K }$ ${ \\bf \\ddot { u } } ( t )$ given an initial value $\\mathbf { \\delta } \\mathbf { u } _ { 0 }$ stays at the ",
+        "bbox": [
+            158,
+            794,
+            823,
+            825
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "equation",
+        "img_path": "images/4fda744cad7a5884b3bb06dbd3ef5c5d88f008ecb07ec9d2a6e8ca4da3156a71.jpg",
+        "text": "$$\n\\mathcal { M } ^ { \\prime } = \\{ \\pmb { u } \\in \\mathcal { M } : V _ { 1 } ( \\pmb { u } ) = V _ { 1 } ( \\pmb { u } _ { 0 } ) , \\allowbreak \\dots , V _ { K } ( \\pmb { u } ) = V _ { K } ( \\pmb { u } _ { 0 } ) \\} .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            297,
+            835,
+            699,
+            853
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "69 The tangent space $\\mathcal { T } _ { u } \\mathcal { M } ^ { \\prime } \\subset \\mathcal { T } _ { u } \\mathcal { M }$ of the submanifold $\\mathcal { M } ^ { \\prime } \\subset \\mathcal { M }$ at a point $\\textbf { \\em u }$ is the orthogonal   \n70 complement to the space spanned by the gradients $\\nabla V _ { k } ( { \\boldsymbol { \\mathbf { \\mathit { u } } } } )$ of the first integrals $V _ { k }$ for $k = 1 , \\ldots , K$ ,   \n71 that is, ",
+        "bbox": [
+            143,
+            854,
+            826,
+            896
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "equation",
+        "img_path": "images/7ddeaa6911b38c8b1572e33538f92f0f8bcecebf0496bb90944eb978a90dba82.jpg",
+        "text": "$$\n\\mathcal { T } _ { \\boldsymbol { u } } \\mathcal { M } ^ { \\prime } = \\{ \\pmb { w } \\in \\mathcal { T } _ { \\boldsymbol { u } } \\mathcal { M } : \\nabla V _ { k } ( \\boldsymbol { u } ) ^ { \\top } \\pmb { w } = 0 \\mathrm { ~ f o r ~ } k = 1 , \\dots , K \\}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            299,
+            893,
+            697,
+            912
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "If a quantity 72 $V _ { k }$ is a first integral of the system $\\begin{array} { r } { \\frac { \\mathrm { d } } { \\mathrm { d } t } \\pmb { u } = f ( \\pmb { u } ) } \\end{array}$ , the time-derivative $f$ at point $\\textbf { \\em u }$ is on the 73 tangent space $\\mathcal { T } _ { u } \\mathcal { M } ^ { \\prime }$ , being orthogonal to the gradient $\\nabla V _ { k }$ of the first integral $V _ { k }$ . Then, it holds that 74 $\\begin{array} { r } { \\frac { \\mathrm { d } } { \\mathrm { d } t } \\dot { V _ { k } ( \\pmb { u } ) } = \\nabla V _ { k } ( \\pmb { u } ) ^ { \\top } \\frac { \\mathrm { d } } { \\mathrm { d } t } \\pmb { u } = \\bar { \\nabla } V _ { k } ( \\pmb { u } ) ^ { \\top } \\pmb { f } ( \\bar { \\pmb { u } } ) = 0 } \\end{array}$ . ",
+        "bbox": [
+            147,
+            90,
+            825,
+            138
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "75 One of the most well-known first integrals is the Hamiltonian $H$ , which represents the system energy   \n76 of a Hamiltonian system. Noether’s theorem states that a continuous symmetry of a system leads to a   \n77 conservation law (and hence a first integral) [27]; a Hamiltonian system is symmetric to translation   \n78 in time and conserves the Hamiltonian. Symmetries to translation and rotation in space lead to the   \n79 conservation of linear and angular momenta. Not all first integrals are related to symmetries. A   \n80 pendulum can be expressed in Cartesian coordinates, and then the rod length constrains the mass   \n81 position. This kind of constraint is called a holonomic constraint and leads to a first integral. A model   \n82 for disease spreading called an susceptible-infected-recovered (SIR) model and the dynamics of   \n83 chemical reactions have the total mass (population) as a first integral. Also for a system described by   \n84 a PDE, the total mass is sometimes a first integral [23]. See Appendix A for theoretical classification   \n85 of dynamics.   \n86 First Integrals in Numerical Analysis For computer simulations, a differential system is dis  \n87 cretized in time and solved by numerical integration. Then, the geometric structures of the system   \n88 are often destroyed, and most first integrals are no longer preserved. A common remedy is a sym  \n89 plectic integrator, which preserves the symplectic structure and integrates a Hamiltonian system   \n90 accurately [27]. However, Ge–Marsden theorem states that a symplectic integrator conserves the   \n91 Hamiltonian only approximately [56]. Hence, many numerical schemes have also been investigated   \n92 for preserving first integrals exactly, while they cannot preserve the symplectic structure.   \n93 Let a superscript $s$ denote the state $\\pmb { u } ^ { s }$ or time $t ^ { s }$ at $s$ -th time step, and $\\Delta t ^ { s } = t ^ { s + 1 } - t ^ { s }$ denote a   \n94 time step size. A projection method predicts a next state $\\tilde { \\pmb u } ^ { s + 1 }$ from the current state $\\pmb { u } ^ { s }$ using a   \n95 numerical integrator and projects it onto the submanifold $\\mathcal { M } ^ { \\prime }$ , obtaining the projected state $\\pmb { u } ^ { s + 1 }$ that   \n96 preserves the first integrals $V _ { k }$ [24] (see also [27, Section IV.4]). In particular, the projected state   \n97 $\\mathbf { \\Delta } _ { \\mathbf { u } } { } ^ { s + 1 }$ is obtained by solving the optimization problem ",
+        "bbox": [
+            145,
+            142,
+            825,
+            295
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            147,
+            310,
+            825,
+            409
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            145,
+            414,
+            825,
+            484
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/3879da5325cf97dc85691dd8ea4bb6d737ade345d2e91cf7216e13310995d06b.jpg",
+        "text": "$$\n\\boldsymbol { u } ^ { s + 1 } = \\operatorname * { a r g m i n } _ { \\boldsymbol { u } ^ { \\prime } ^ { s + 1 } } | | \\boldsymbol { u } ^ { \\prime * s + 1 } - \\tilde { \\boldsymbol { u } } ^ { s + 1 } | | \\operatorname * { s u b j e c t } \\operatorname { t o } V _ { k } ( \\boldsymbol { u } ^ { \\prime * s + 1 } ) = V _ { k } ( \\boldsymbol { u } ^ { s } ) \\operatorname { f o r } k = 1 , \\dots , K .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            217,
+            489,
+            781,
+            515
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "98 A local coordinate method defines a coordinate system to the neighborhood of the current state $\\pmb { u } ^ { s }$   \n99 and integrates a differential equation on it [43] (see also [27, Section IV.5]). A discrete gradient   \n100 method defines a discrete analogue to a given differential system and integrates it in discrete time [6,   \n101 23, 25, 29, 44, 45]. This method eliminates numerical errors caused by temporal discretization and is   \n102 used to preserve the Hamiltonian exactly (up to rounding errors) in discrete time.   \n103 Except for DGNet, which used discrete gradients to preserve the Hamiltonian [38], all the above   \n104 methods have never been applied to neural networks due to difficulties that we will introduce later. To   \n105 our best knowledge, the discrete-time version of FINDE is the first projection method for dynamical   \n106 systems modeled using neural networks.   \n107 Preservation of First Integrals by Neural Networks NODE defines an ODE using a neural net  \n108 work in the most general way with no associated first integrals [8]. NODE is a universal approximator   \n109 to ODEs [51], and it can approximate any ODE with arbitrary accuracy if there is an infinite amount   \n110 of training data. In practice, the amount of training data is limited, and prior knowledge about the   \n111 target system is helpful for learning (see [48] for the case with convolutional neural networks). HNN   \n112 assumes the target system to be a Hamiltonian system in the canonical form [26]. HNN guarantees   \n113 various properties of Hamiltonian systems by definition, including the conservation of the energy   \n114 and the preservation of the symplectic structure in continuous time [27]. Some studies employed a   \n115 symplectic integrator for HNN to preserve the energy and symplectic structure with smaller numerical   \n116 errors [10]. LieConv and EMLP-HNN employed neural network architectures with translational   \n117 and rotational symmetries to preserve momenta [19, 21]. CHNN incorporates a known holonomic   \n118 constraint in the dynamics [20]. Deep conservation extracts latent dynamics of a PDE system and   \n119 preserves a quantity of interest by forcing its flux to be zero [34]. $\\mathrm { H N N + + }$ also guarantees the   \n120 conservation of the mass in PDE systems by using a coefficient matrix derived from differential   \n121 operators [38].   \n122 Several studies proposed neural networks to learn Lyapunov functions, which are expected to be   \n123 non-increasing over time, in contrast to first integrals [37, 50]. If the state moves in the direction of   \n124 increasing the function, it is projected onto or moved inside the counter line of the gradient of the   \n125 Lyapunov function. Their idea is similar to the continuous-time version of FINDE but limited to a   \n126 single non-increasing quantity in continuous time. On the other hand, our proposed FINDE preserves   \n127 multiple quantities in both continuous and discrete time.   \n28 Previous studies aimed to preserve known first integrals. Moreover, except for DGNet [38], all   \n29 the above methods suffer from numerical errors caused by temporal discretization. In contrast, our   \n30 proposed FINDE learns first integrals from data and can eliminate discretization errors. ",
+        "bbox": [
+            143,
+            522,
+            825,
+            592
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            142,
+            598,
+            825,
+            654
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            140,
+            670,
+            825,
+            877
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            145,
+            883,
+            825,
+            911
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            140,
+            90,
+            825,
+            147
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            151,
+            154,
+            828,
+            195
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "131 3 First Integral-Preserving Neural Differential Equation ",
+        "text_level": 1,
+        "bbox": [
+            150,
+            213,
+            660,
+            231
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "132 The main purpose is to find and preserve first integrals from data by neural networks. We suppose   \n133 that a target system has at least $K$ unknown functionally independent first integrals. Even when   \n134 a NODE learns the target system, it is not guaranteed to learn these first integrals. Hence, we   \n135 introduce a neural network with $K$ outputs, each of which is expected to learn one of first integrals   \n136 expressed as $V _ { k } : \\mathbb { R } ^ { N }  \\mathbb { R }$ for $k = 1 , \\dots , K$ . We denote the set of first integrals by a vector   \n137 $\\pmb { V } ( \\pmb { u } ) = ( V _ { 1 } ( \\pmb { u } ) V _ { 2 } ( \\pmb { u } ) \\dotsm V _ { K } ( \\pmb { u } ) ) ^ { \\top }$ . Then, the submanifold $\\mathcal { M } ^ { \\prime }$ is defined using the neural   \n138 network $V$ as in Eq. (1).   \n139 Because there is no way to define local coordinates on such submanifolds, a local coordinate method   \n140 is not applicable. When using a projection method, the optimization problem in Eq. (3) should   \n141 be solved at every training iteration as well as in the prediction phase. Optimization problems are   \n142 computationally expensive, and common libraries for neural networks do not provide backpropagation   \n143 algorithms for optimization problems [1, 42].1 Until a recent study has proposed an algorithm [38],   \n144 there was no way to obtain discrete gradients of neural networks. Because of these difficulties,   \n145 no methods for preserving first integrals have been applied to neural networks. By leveraging a   \n146 projection method and a discrete gradient method, we propose FINDE as follows. ",
+        "bbox": [
+            140,
+            243,
+            825,
+            342
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            140,
+            347,
+            826,
+            458
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3.1 Continuous FINDE: Time-Derivative Projection Method ",
+        "text_level": 1,
+        "bbox": [
+            161,
+            472,
+            604,
+            488
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "First, we propose a time-derivative projection method called continuous FINDE (cFINDE) for neural networks, which projects the time-derivative onto the tangent space $\\mathcal { T } _ { u } \\mathcal { M } ^ { \\prime }$ . While it still suffers from numerical errors, it is sufficient to find first integrals from data. ",
+        "bbox": [
+            160,
+            498,
+            825,
+            540
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "We suppose that a neural network called a base model defines the time-derivative $\\hat { f } : \\mathbb { R } ^ { N } \\to \\mathbb { R } ^ { N }$ Then, we define the time-derivative $f$ of the cFINDE $\\begin{array} { r } { \\frac { \\mathrm { d } } { \\mathrm { d } t } \\pmb { u } = f ( \\pmb { u } ) } \\end{array}$ as ",
+        "bbox": [
+            158,
+            547,
+            823,
+            579
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/8f8b79adb26b9ef479e91536ac45479b6c800405868d7256ba6e077ccedb198f.jpg",
+        "text": "$$\n\\begin{array} { r }  \\boldsymbol { f } ( \\boldsymbol { \\mathbf { \\rho } } \\boldsymbol { \\mathbf { \\rho } } \\boldsymbol { \\mathbf { \\rho } } \\boldsymbol { \\mathbf { \\rho } } \\boldsymbol { \\mathbf { \\rho } } \\boldsymbol { \\mathbf { \\rho } } \\boldsymbol { \\mathbf { \\rho } } \\boldsymbol { \\mathbf { \\rho } } \\boldsymbol { \\mathbf { \\rho } } \\boldsymbol { \\mathbf { \\rho } } \\boldsymbol { \\mathbf { \\rho } } \\boldsymbol { \\mathbf { \\rho } } \\boldsymbol { \\mathbf { \\rho } } \\boldsymbol { \\mathbf { \\rho } } \\boldsymbol { \\mathbf { \\rho } } \\boldsymbol { \\mathbf { \\rho } } \\boldsymbol { \\mathbf { \\rho } } \\boldsymbol { \\mathbf { \\rho } } \\boldsymbol { \\mathbf { \\rho } } \\boldsymbol { \\mathbf { \\rho } } \\boldsymbol { \\mathbf { \\rho } } \\boldsymbol { \\mathbf { \\rho } } \\boldsymbol { \\mathbf { \\rho } } \\boldsymbol { \\mathbf { \\rho } } \\boldsymbol { \\mathbf { \\rho } } \\boldsymbol { \\mathbf { \\rho } } \\boldsymbol { \\mathbf { \\rho } } \\boldsymbol { \\mathbf { \\rho } } \\boldsymbol { \\mathbf { \\rho } } \\boldsymbol { \\mathbf { \\rho } } \\boldsymbol { \\mathbf { \\rho } } \\boldsymbol { \\mathbf { \\rho } } \\boldsymbol { \\mathbf { \\rho } } \\boldsymbol { \\mathbf { \\rho } } \\boldsymbol { \\mathbf { \\rho } } \\boldsymbol { \\mathbf { \\rho } } \\boldsymbol { \\mathbf { \\rho } } \\boldsymbol { \\mathbf { \\rho } } \\boldsymbol { \\mathbf { \\rho } } \\boldsymbol { \\mathbf { \\rho } } \\boldsymbol { \\mathbf { \\rho } } \\boldsymbol { \\mathbf { \\rho } } \\boldsymbol { \\mathbf { \\rho } } \\boldsymbol { \\mathbf { \\rho } } \\boldsymbol { \\mathbf { \\rho } } \\boldsymbol { \\mathbf { \\rho } } \\boldsymbol { \\mathbf { \\rho } } \\boldsymbol { \\mathbf { \\rho } } \\boldsymbol { \\mathbf { \\rho } } \\boldsymbol { \\mathbf { \\rho } } \\boldsymbol { \\mathbf { \\rho } } \\boldsymbol { \\mathbf { \\rho } } \\boldsymbol { \\mathbf { \\rho } } \\boldsymbol { \\mathbf { \\rho } } \\boldsymbol { \\mathbf { \\rho } } \\boldsymbol { \\mathbf { \\rho } } \\boldsymbol { \\mathbf { \\rho } } \\boldsymbol { \\mathbf { \\rho } } \\boldsymbol { \\mathbf { \\rho } } \\boldsymbol { \\mathbf { \\rho } } \\boldsymbol { \\mathbf { \\rho } } \\boldsymbol { \\mathbf { \\rho } } \\boldsymbol { \\mathbf { \\rho } } \\boldsymbol { \\mathbf { \\rho } } \\boldsymbol { \\mathbf { \\rho } } \\boldsymbol { \\mathbf { \\rho } } \\boldsymbol { \\mathbf { \\rho } } \\boldsymbol { \\mathbf { \\rho } } \\boldsymbol { \\mathbf { \\rho } } \\boldsymbol { \\mathbf { \\rho } } \\boldsymbol { \\mathbf { \\rho } } \\boldsymbol { \\mathbf { \\rho } } \\boldsymbol { \\mathbf { \\rho } } \\boldsymbol { \\mathbf { \\rho } } \\boldsymbol { \\mathbf { \\rho } } \\boldsymbol { \\mathbf { \\rho } } \\boldsymbol  \\mathbf { \\rho } \\boldsymbol { \\rho } \\boldsymbol  \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            300,
+            582,
+            694,
+            602
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "where 153 $\\lambda _ { k }$ is a Lagrange multiplier, $\\begin{array} { r } { M \\mathrm { ~ = ~ } \\frac { \\partial V } { \\partial \\mathbf { u } } } \\end{array}$ , and $\\lambda ( { \\pmb u } ) = ( \\lambda _ { 1 } ( { \\pmb u } ) \\lambda _ { 2 } ( { \\pmb u } ) \\dots \\lambda _ { K } ( { \\pmb u } ) ) ^ { \\top }$ . If $V _ { k }$ ",
+        "bbox": [
+            151,
+            602,
+            825,
+            632
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/9c2e9d3f26afcb1d2909b43b5c98d078e94dbe3a47d5ab0465bdde96a7dd7e0f.jpg",
+        "text": "$$\n\\begin{array} { r } { \\mathbf { 0 } = \\frac { \\mathrm { d } } { \\mathrm { d } t } { \\pmb V } ( { \\pmb u } ( t ) ) = M ( \\pmb { u } ) \\frac { \\mathrm { d } } { \\mathrm { d } t } { \\pmb u } = M ( \\pmb { u } ) f ( \\pmb { u } ) = M ( \\pmb { u } ) ( \\hat { f } ( \\pmb { u } ) - M ( \\pmb { u } ) ^ { \\top } \\pmb { \\lambda } ( \\pmb { u } ) ) , } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            240,
+            632,
+            754,
+            652
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "where 155 $\\mathbf { 0 } = ( 0 \\ldots 0 ) ^ { \\top }$ . By transforming Eq. (5), we obtain the Lagrange multiplier $\\lambda ( { \\pmb u } ) =$ 156 $( M ( \\pmb { \\mathscr { u } } ) M ( \\pmb { \\mathscr { u } } ) ^ { \\top } ) ^ { - 1 } M ( \\pmb { \\mathscr { u } } ) \\hat { f } ( \\pmb { \\mathscr { u } } )$ . By eliminating it, the cFINDE $\\begin{array} { r } { \\frac { \\mathrm { d } } { \\mathrm { d } t } \\pmb { u } = f ( \\pmb { u } ) } \\end{array}$ is given by ",
+        "bbox": [
+            150,
+            655,
+            825,
+            686
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Remark 1 (continuous-time first integral preservation). The cFINDE 57 $\\begin{array} { r } { \\frac { \\mathrm { d } } { \\mathrm { d } t } \\pmb { u } = f ( \\pmb { u } ) } \\end{array}$ preserves all first integrals 58 $V _ { k }$ for $k = 1 , \\ldots , K$ in continuous time, i.e., $\\begin{array} { r } { { \\frac { \\mathrm { d } } { \\mathrm { d } t } } V _ { k } = 0 } \\end{array}$ . ",
+        "bbox": [
+            155,
+            709,
+            825,
+            742
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "159 The base model $\\hat { f }$ can be a NODE, an HNN, or other models depending on available prior knowledge.   \n160 Also, if a first integral is already known, one can use it directly as one of first integrals $V _ { k }$ instead   \n161 of learning it using a neural network. Note that even though the base model $\\hat { f }$ is an HNN, due to   \n162 projection, the cFINDE $f$ is no longer a Hamiltonian system in the strict sense. ",
+        "bbox": [
+            143,
+            752,
+            825,
+            813
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Compared to the base model $\\hat { f }$ , the cFINDE requires the additional computation of the neural network $V$ , several matrix multiplications, and an inverse operation. The inverse operation needs a computational cost of $O ( K ^ { 3 } )$ , which is not costly if the number $K$ of first integrals is small. For satisfying the constraints and geometric structures, many previous models also need the inverse operation, such as Lagrangian neural network (LNN) [13], neural symplectic form [9], and CHNN [20]. ",
+        "bbox": [
+            173,
+            819,
+            825,
+            890
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "69 To eliminate numerical errors caused by temporal discretization, we employ discrete gradients and   \n70 propose a projection method called discrete FINDE (dFINDE). ",
+        "bbox": [
+            156,
+            116,
+            825,
+            145
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "A discrete gradient $\\overline { { \\nabla } } V$ is a discrete analogue to a gradient $\\nabla V$ [6, 23, 25, 29, 44, 45]. Recall that a gradient $\\nabla V$ of a function $V : \\mathbb { R } ^ { N }  \\mathbb { R }$ can be regarded as a function $\\mathbb { R } ^ { N } \\to \\mathbb { R } ^ { N }$ that satisfies the chain rule $\\begin{array} { r } { \\frac { \\mathrm { d } } { \\mathrm { d } t } V ( \\pmb { u } ) = \\nabla V ( \\pmb { u } ) ^ { \\top } \\frac { \\mathrm { d } } { \\mathrm { d } t } \\pmb { u } } \\end{array}$ . Analogously, a discrete gradient $\\overline { \\nabla }$ is defined as follows. ",
+        "bbox": [
+            160,
+            151,
+            825,
+            196
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Definition 2 (discrete gradient). A discrete gradient $\\overline { { \\nabla } } V$ of a function $V : \\mathbb { R } ^ { N }  \\mathbb { R }$ is a function $\\mathbb { R } ^ { N } \\times \\mathbb { R } ^ { N } \\xrightarrow [ ] { } \\mathbb { R } ^ { N }$ that satisfies ",
+        "bbox": [
+            160,
+            200,
+            826,
+            229
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/a1e6840231973b85c64c34a00b362183503d5ede99d36f77a752d512eb641e6d.jpg",
+        "text": "$$\nV ( \\pmb { v } ) - V ( \\pmb { u } ) = \\overline { { \\nabla } } V ( \\pmb { v } , \\pmb { u } ) ^ { \\top } ( \\pmb { v } - \\pmb { u } ) ~ a n d ~ \\overline { { \\nabla } } V ( \\pmb { u } , \\pmb { u } ) = \\nabla V ( \\pmb { u } ) .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            281,
+            233,
+            717,
+            252
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "176 The first condition is a discrete analogue to the chain rule when replacing the time-derivatives ${ \\frac { \\mathrm { d } } { \\mathrm { d } t } } V$   \n177 and ${ \\frac { \\mathrm { d } } { \\mathrm { d } t } } { \\pmb u }$ with finite differences $( V ( \\pmb { v } ) - V ( \\pmb { u } ) )$ and $( { \\pmb v } - { \\pmb u } )$ , respectively, and the second condition   \n178 ensures the consistency with the ordinary gradient $\\nabla V$ . A discrete gradient $\\overline { { \\nabla } } V$ is not uniquely   \n179 determined and has been obtained manually. Recently, the automatic discrete differentiation algorithm   \n180 (ADDA) has been proposed in [38], which obtains a discrete gradient of a neural network in a similar   \n181 way to the automatic differentiation algorithm [1, 42]. The discrete gradient is defined in discrete   \n182 time, and hence a numerical integration using the discrete gradient is free from numerical errors   \n183 caused by temporal discretization. See Appendix $\\mathbf { B }$ and the references [6, 23, 38] for more details. ",
+        "bbox": [
+            140,
+            262,
+            825,
+            381
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Following [11, 15], we introduce a discrete analogue to the tangent space 184 $\\mathcal { T } _ { \\mathbf { \\ b { u } } } \\mathcal { M } ^ { \\prime }$ called the discrete tangent space 185 $\\mathcal { T } _ { ( \\pmb { v } , \\pmb { u } ) } \\mathcal { M } ^ { \\prime }$ . In particular, for a pair $( \\pmb { v } , \\pmb { u } ) \\in \\mathcal { M } ^ { \\prime }$ of points, it is defined as ",
+        "bbox": [
+            150,
+            386,
+            825,
+            416
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/d15c5c5b37f8223f9e78ac890b92d60d5645de00be83ce74944e8ad884d45cf9.jpg",
+        "text": "$$\n\\mathcal { T } _ { ( v , u ) } \\mathcal { M } ^ { \\prime } = \\{ \\pmb { w } \\in \\mathbb { R } ^ { N } : \\overline { { \\nabla } } V _ { k } ( \\pmb { v } , \\pmb { u } ) ^ { \\top } \\pmb { w } = 0 \\mathrm { ~ f o r ~ } k = 1 , \\ldots , K \\} .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            284,
+            420,
+            712,
+            439
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "186 If the finite difference $( \\pmb { u } ^ { s + 1 } - \\pmb { u } ^ { s } )$ between the predicted and current states is on the discrete   \n187 tangent space $\\mathcal { T } _ { \\left( \\pmb { u } ^ { s + 1 } , \\pmb { u } ^ { s } \\right) } \\mathcal { M } ^ { \\prime }$ , the first integrals $V _ { k }$ are preserved because $V _ { k } ( { \\pmb u } ^ { s + 1 } ) - V _ { k } ( { \\pmb u } ^ { s } ) =$   \n188 $\\overline { { \\nabla } } V _ { k } ( \\pmb { u } ^ { s + 1 } , \\pmb { u } ^ { s } ) ^ { \\top } ( \\pmb { u } ^ { s + 1 } - \\pmb { u } ^ { s } ) = 0$ . Note that similar concepts defined in different ways are also   \n189 referred to as discrete tangent spaces [14, 16]. ",
+        "bbox": [
+            140,
+            443,
+            825,
+            503
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Let ψˆ denote a discrete-time base model that satisfies u˜s+1−us∆ts 190 $\\begin{array} { r } { \\frac { \\tilde { \\mathbf { u } } ^ { s + 1 } - \\mathbf { u } ^ { s } } { \\Delta t ^ { s } } = \\hat { \\psi } ( \\mathbf { u } ^ { s } ; \\Delta t ^ { s } ) } \\end{array}$ , where $\\tilde { { \\pmb u } } ^ { s + 1 }$ denotes 191 the predicted state. We assume that the base model $\\hat { \\psi }$ is composed of a continuous-time base model 192 ˆf and a numerical integrator. Then, the dFINDE us+1−∆ts $\\begin{array} { r } { \\frac { { \\pmb u } ^ { s + 1 } - { \\pmb u } ^ { s } } { \\Delta t ^ { s } } = \\psi ( { \\pmb u } ^ { s + 1 } , { \\pmb u } ^ { s } ; \\Delta t ^ { s } ) } \\end{array}$ is given by ",
+        "bbox": [
+            142,
+            508,
+            825,
+            563
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/d1a21837891a0816a8d90a934c2bd058b77755c9a71f9d7120f2e96416ef165f.jpg",
+        "text": "$$\n\\psi ( \\pmb { u } ^ { s + 1 } , \\pmb { u } ^ { s } ; \\Delta t ^ { s } ) = \\hat { \\psi } ( \\pmb { u } ^ { s } ; \\Delta t ^ { s } ) - \\overline { { M } } ( \\pmb { u } ^ { s + 1 } , \\pmb { u } ^ { s } ) ^ { \\top } \\lambda ( \\pmb { u } ^ { s + 1 } , \\pmb { u } ^ { s } ) ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            289,
+            566,
+            705,
+            585
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "where 193 $\\overline { { M } } ( { \\pmb u } ^ { s + 1 } , { \\pmb u } ^ { s } ) = ( \\overline { { \\nabla } } V _ { 1 } ( { \\pmb u } ^ { s + 1 } , { \\pmb u } ^ { s } )$ . . . $\\overline { { \\nabla } } V _ { K } ( \\pmb { u } ^ { s + 1 } , \\pmb { u } ^ { s } ) ) ^ { \\top }$ . As is the case in continuous time, 194 the preservation of the first integrals $V _ { k }$ leads to ",
+        "bbox": [
+            145,
+            589,
+            826,
+            619
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/c57172cf644c028312037ccb9029fe77af4e4c29c8dac75574ca1e6b7a921bd3.jpg",
+        "text": "$$\n\\begin{array} { r } { \\mathbf { 0 } = \\frac { V ( u ^ { s + 1 } ) - V ( u ^ { s } ) } { \\Delta t ^ { s } } = \\overline { { M } } ( u ^ { s + 1 } , u ^ { s } ) \\frac { u ^ { s + 1 } - u ^ { s } } { \\Delta t ^ { s } } = \\overline { { M } } ( u ^ { s + 1 } , u ^ { s } ) \\psi ( u ^ { s + 1 } , u ^ { s } ; \\Delta t ^ { s } ) . } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            205,
+            622,
+            746,
+            645
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "195 Substituting Eq. (9) and eliminating the Lagrange multiplier $\\boldsymbol { \\lambda }$ , we obtain ",
+        "bbox": [
+            140,
+            647,
+            658,
+            662
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/5cf3eab1461c710ba916e91303d63747b554722245d42fa5ae31f91a77890e74.jpg",
+        "text": "$$\n\\psi ( \\pmb { u } ^ { s + 1 } , \\pmb { u } ^ { s } ; \\Delta t ^ { s } ) = ( I - \\overline { { Y } } ( \\pmb { u } ^ { s + 1 } , \\pmb { u } ^ { s } ) ) \\hat { \\psi } ( \\pmb { u } ^ { s } ; \\Delta t ^ { s } )\n$$",
+        "text_format": "latex",
+        "bbox": [
+            209,
+            667,
+            547,
+            686
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Remark 2 (discrete-time first integral preservation). The dFINDE us+1−us∆ts preserves all first integrals $V _ { k }$ for $k = 1 , \\ldots , K$ in discrete time, i.e., $V _ { k } ( { \\pmb u } ^ { s + 1 } ) - V _ { k } ( { \\pmb u } ^ { s } ) = 0$ $\\begin{array} { r } { \\frac { { \\pmb u } ^ { s + 1 } - { \\pmb u } ^ { s } } { \\Delta t ^ { s } } = \\psi ( { \\pmb u } ^ { s + 1 } , { \\pmb u } ^ { s } ; \\Delta t ^ { s } ) } \\end{array}$ ",
+        "bbox": [
+            158,
+            690,
+            828,
+            726
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "198 Due to projection, dFINDE can be regarded as a projection method using discrete gradients. For the   \n199 base model $\\hat { \\psi }$ , the continuous-time base model $\\hat { f }$ can be a NODE, an HNN, or other models, and the   \n200 numerical integrator can be a Runge–Kutta method, the leapfrog integrator, or others.   \n201 Because dFINDE is an implicit method, it is computationally expensive for prediction. However, the   \n202 next state $\\boldsymbol { u } ^ { s + 1 }$ is given for training, and the ADDA can explicitly obtain the discrete gradient w.r.t. the   \n203 pair $( { \\pmb u } ^ { s + 1 } , { \\pmb u } ^ { s } )$ as well as its computational graph. Thus, dFINDE can be computed explicitly and   \n204 optimized by standard backpropagation algorithms. Moreover, we suppose that dFINDE projects   \n205 the finite difference $\\hat { \\psi }$ only at every time step, whereas cFINDE projects the time-derivative $\\hat { f }$ at   \n206 every substep inside a numerical integrator. Therefore, dFINDE is less computationally expensive   \n207 than cFINDE for training. In contrast, a typical projection method requires much computational   \n208 cost to solve an optimization problem for training, and standard backpropagation algorithms are not   \n209 applicable to it.   \n10 Remark 3 (trainability). The dFINDE can be trained using the standard backpropagation algorithm,   \n211 whereas a straightforward application of a projection method cannot. ",
+        "bbox": [
+            147,
+            733,
+            825,
+            779
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            143,
+            784,
+            825,
+            912
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "table",
+        "img_path": "images/9532b26093d205096da34a1d05959c144853a2f40d48bde0cd43c48af1534f6f.jpg",
+        "table_caption": [
+            "Table 2: Datasets, Dynamics, and First Integrals. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=\"2\">Dataset</td><td rowspan=\"2\">Dynamics</td><td rowspan=\"2\">N</td><td colspan=\"4\">First Integrals</td></tr><tr><td>Energy</td><td>Momentum</td><td>Mass</td><td>Constraint</td></tr><tr><td>Two-body problem</td><td>Canonical Hamiltonian</td><td>8</td><td></td><td>1</td><td></td><td></td></tr><tr><td>Discretized KdV equation</td><td>Non-canonical Hamiltonian</td><td>50</td><td>广</td><td></td><td>1</td><td></td></tr><tr><td>Double pendulum</td><td>Poisson</td><td>8</td><td>√</td><td></td><td></td><td>√</td></tr><tr><td>FitzHugh-Nagumo model</td><td>Dirac</td><td>4</td><td></td><td></td><td></td><td>√</td></tr></table>",
+        "bbox": [
+            173,
+            112,
+            825,
+            210
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            150,
+            236,
+            825,
+            265
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "4 Experiments ",
+        "text_level": 1,
+        "bbox": [
+            171,
+            290,
+            312,
+            306
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "4.1 Experimental Settings ",
+        "text_level": 1,
+        "bbox": [
+            166,
+            321,
+            366,
+            337
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Target Systems We evaluated FINDE and base models using datasets associated with first integrals, summarized in Table 2. A gravitational two-body problem (2-body) on a 2-dimensional configuration space is a typical Hamiltonian system in the canonical form. In addition to the total energy, it has first integrals related to symmetries in space, namely, the linear and angular momenta. The Korteweg–De Vries (KdV) equation is a PDE model of shallow water waves. This is a Hamiltonian system in a non-canonical form and has the Hamiltonian, total mass, and many other quantities as first integrals. A double pendulum (2-pend) is a Hamiltonian system in polar coordinates. However, we transformed it to Cartesian coordinates; it was no longer a Hamiltonian system but a Poisson system. The lengths of two rods work as holonomic constraints and lead to four first integrals. The FitzHugh–Nagumo model is a biological neuron model as an electric circuit, which exhibits a rapid and transient change of voltage called a spike. As an electric circuit, the currents through and voltages applied to the inductor and capacitor can be regarded as system states, and the states are constrained by the circuit topology and Kirchhoff’s current and voltage laws. Then, this system has a state of four elements and two first integrals. Due to energy dissipation in the resistor, the model is not a Poisson system, but one can find a Dirac structure [53]. See Appendix C for more details. ",
+        "bbox": [
+            171,
+            347,
+            825,
+            554
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Implementation We implemented the proposed FINDE and evaluated it under the following settings. We implemented all codes by modifying the officially released codes of HNN [26] 2 and DGNet $[ 3 8 ] ^ { 3 }$ . We used Python v3.8.12 with packages scipy v1.7.3, pytorch v1.10.2, torchdiffeq v0.1.1, functorch v1.10 preview, and gplearn v0.4.2. We used the Dormand–Prince method (dopri5) [18] as the numerical integrator, unless otherwise stated. All experiments were performed on a single NVIDIA A100 provided by (ANONYMOUS PROVIDER). ",
+        "bbox": [
+            173,
+            570,
+            825,
+            654
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Following HNN [26] and DGNet [38], we represented the first integrals $V$ , NODE, and HNN $H$ using fully-connected neural networks with two hidden layers. Each hidden layer had 200 units and preceded a hyperbolic tangent activation function. Each weight matrix was initialized as an orthogonal matrix. The input was the state $\\textbf { \\em u }$ , and the output represented the first integrals $V$ for FINDE, time-derivative $\\hat { f }$ for NODE, and the Hamiltonian $H$ for HNN. For the KdV dataset, we used a 1-dimensional convolutional neural network (CNN), each of whose layers had a kernel size of 3. The double pendulum is a second–order system, implying that the time-derivative ddt q of the position $\\pmb q$ is known as the velocity $\\textbf {  { v } }$ . Hence, we treated only the acceleration $\\begin{array} { r } { \\frac { \\mathrm { d } } { \\mathrm { d } t } \\pmb { v } } \\end{array}$ as the output to learn. This assumption slightly improved the absolute performances but did not change the relative trends. ",
+        "bbox": [
+            173,
+            660,
+            825,
+            791
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "We used the $I$ -step error as the loss function to be minimized. In particular, it is the mean squared error (MSE) between the ground truth state $\\pmb { u } _ { \\mathrm { G T } } ^ { s }$ and the state $\\pmb { u } _ { \\mathrm { p r e d . } } ^ { s }$ . predicted from the previous step $u _ { \\mathrm { G T } } ^ { s - 1 }$ . The base model and FINDE were jointly trained using the Adam optimizer [33] with the parameters $( \\beta _ { 1 } , \\beta _ { 2 } ) = ( 0 . 9 , 0 . 9 9 9 )$ and a batch size of 200. The learning rate was initialized to $1 0 ^ { - 3 }$ and decayed to zero with a cosine annealing [36]. ",
+        "bbox": [
+            173,
+            797,
+            825,
+            872
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "249 Evaluation Metric As an evaluation metric, we used the 1-step error, which is identical to the loss   \n250 function. We displayed it at the scale of $\\times 1 0 ^ { - 9 }$ . The lower this indicator, the better, as emphasized   \n251 by $\\downarrow$ . While several studies used the MSEs of the state or system energy over the whole time   \n252 series [26, 38], we consider these indicators are misleading, as pointed in several studies [4]. For   \n253 example, in the case of a periodic orbit, an orbit that is correctly learned except for a slight difference   \n254 in angular velocity will have the same MSE as an orbit that never moves from its initial position.   \n255 Instead, we used the valid prediction time $( V P T )$ [4, 32, 54]. VPT denotes the time point $s$ divided by   \n256 the length $S$ of time series at which the MSE of the predicted state $\\pmb { u } _ { \\mathrm { p r e d . } } ^ { s }$ . exceeds a given threshold $\\theta$   \n257 for the first time in an initial value problem, that is, ",
+        "bbox": [
+            138,
+            90,
+            825,
+            217
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "equation",
+        "img_path": "images/811dd5f21e7701a7467a228c4cae451c6d1973664d4fe839e7bf95ebdae7362c.jpg",
+        "text": "$$\n\\begin{array} { r } { V P T ( u _ { \\mathrm { p r e d . } } ; u _ { \\mathrm { G T } } ) = \\frac { 1 } { S } \\arg \\operatorname* { m a x } _ { s _ { f } } \\{ s _ { f } | \\mathrm { M S E } ( u _ { \\mathrm { p r e d . } } ^ { s } , u _ { \\mathrm { G T } } ^ { s } ) < \\theta \\mathrm { f o r } \\mathrm { a l l } s \\leq s _ { f } \\} . } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            241,
+            222,
+            754,
+            241
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "258 To obtain VPTs, we normalized each element of state to have zero mean and unit variance in the   \n259 training data and set $\\theta$ to 0.01. The higher this indicator, the better, as emphasized by $\\uparrow$ . Because of   \n260 the “spiking” behavior of the FitzHugh–Nagumo model, a small error in phase is regarded as a large   \n261 error in state. To measure the qualitative performance, we calculated VPTs by allowing for a delay   \n262 and advance of up to 5 steps. ",
+        "bbox": [
+            140,
+            247,
+            825,
+            316
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "4.2 First Integral Preservation for Hamiltonian System ",
+        "text_level": 1,
+        "bbox": [
+            171,
+            332,
+            568,
+            347
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Before learning first integrals from data, we first evaluated FINDE as a numerical integrator using a known mass-spring system. The system has the state $\\mathbf { \\boldsymbol { \\mathscr { u } } } \\doteq ( q v ) ^ { \\top }$ , the dynamics ddt q = v and d $\\begin{array} { r } { { \\frac { \\mathrm { d } } { \\mathrm { d } t } } v \\ = - q } \\end{array}$ , and the system energy $E ( q , v ) =$ ${ \\scriptstyle { \\frac { 1 } { 2 } } } ( q ^ { 2 } + v ^ { 2 } )$ . Using the initial value $( 1 . 0 \\ 0 . 0 ) ^ { \\top }$ and the time step size $\\Delta t = 0 . 2$ , we solved the initial value problem of the true ODE using the leapfrog integrator. We applied FINDE with the true system energy $E$ as the first integral $V$ . Note that no neural networks nor training were involved. ",
+        "bbox": [
+            171,
+            357,
+            584,
+            487
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/e62087da4d5eea6ebb9b01535f06401e481e011b62a41af256ef1f7e2091ccfd.jpg",
+        "image_caption": [
+            "Figure 1: Integration of a known mass-spring system. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            596,
+            315,
+            815,
+            459
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "273 The results with the analytical solution are shown in Fig. 1. The upper panel shows that the time series   \n274 predicted by comparison methods overlap each other and are apparently almost identical. However,   \n275 the lower panel shows that the energy obtained from the states predicted by the leapfrog integrator is   \n276 fluctuating. The same is true for the case with the cFINDE. This is because the symplectic integrator   \n277 and the cFINDE suffer from numerical errors caused by temporal discretization. In contrast, the   \n278 dFINDE preserves the energy accurately. This is because, at every step, the dFINDE projects the state   \n279 $( q v ) ^ { \\top }$ onto the discrete tangent space $\\mathcal { T } _ { ( \\pmb { v } , \\pmb { u } ) } \\mathcal { M } ^ { \\prime }$ . Although a smaller step size reduces numerical   \n280 errors, this result demonstrates the advantage of dFINDE. ",
+        "bbox": [
+            147,
+            492,
+            825,
+            604
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "281 4.3 Learning First Integrals from Data of Hamiltonian System ",
+        "text_level": 1,
+        "bbox": [
+            151,
+            619,
+            619,
+            635
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "82 We evaluated FINDE on learning from the 2-body dataset. We used HNN as the base model $\\hat { f }$ . We   \n83 found that the FINDE got better performances if it did not treat the Hamiltonian $H$ of the HNN   \n84 as one of first integrals $V _ { k }$ . The medians and standard deviations of 5 trials are summarized in the   \n85 leftmost column of Table 3. The cFINDE achieved better VPTs than the vanilla HNN with $K = 1$   \n86 to 2, and the performance was suddenly degraded for $K = 3$ . The dFINDE showed a similar trend   \n7 with slightly better performances. The HNN with FINDE found two first integrals in addition to the   \n88 Hamiltonian $H$ of the HNN. Even though a two-body problem is a Hamiltonian system that HNN   \n89 can learn, the prior knowledge that there exist first integrals other than the Hamiltonian $H$ can be   \n90 a clue to better learning. The HNN with FINDE got worse 1-step errors, suggesting that without   \nFINDE, HNN overfitted short-term change and had difficulty predicting long-term dynamics. ",
+        "bbox": [
+            155,
+            647,
+            825,
+            786
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "We performed a symbolic regression of first integrals $V$ learned by the neural network. For $K = 2$ , the learned first integrals $V$ were identical to the linear momenta in the $x$ - and $y$ -directions up to affine transformation in most cases. See Appendix D.1 for more details. ",
+        "bbox": [
+            163,
+            791,
+            825,
+            834
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "We depict example results in Fig. 2. In the absence of FINDE, the mass positions $( x _ { 1 } , y _ { 1 } ) , ( x _ { 2 } , y _ { 2 } )$ became inaccurate in a short time and the center-of-gravity position $\\textstyle ( x _ { c } , y _ { c } ) = ( { \\frac { x _ { 1 } + x _ { 2 } } { 2 } } , { \\frac { y _ { 1 } + y _ { 2 } } { 2 } } )$ deviated rapidly. The HNN with cFINDE accurately predicted the state for a longer period. Even after errors in the mass positions became non-negligible, errors in the center-of-gravity position were still small. We show the absolute errors averaged over all trials in Fig. 3. In each of $x$ - and $y$ -directions, ",
+        "bbox": [
+            158,
+            840,
+            825,
+            911
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "table",
+        "img_path": "images/e6b3cd7b17a1d2790ac4925eed911dd13f929f98dbd945f672f955bbceabeefd.jpg",
+        "table_caption": [
+            "Table 3: Results of FINDE. "
+        ],
+        "table_footnote": [
+            "A standard deviation follows $\\pm$ symbol. Underlines indicate results better than the base models’ results, and bolded fonts indicate the best results. ∗ denotes that some trials failed in training because of the underflow of the step size. A dash denotes a case we did not try. "
+        ],
+        "table_body": "<table><tr><td colspan=\"2\"></td><td colspan=\"2\">2-body + HNN</td><td colspan=\"2\">KdV</td><td colspan=\"2\">2-pend</td><td colspan=\"2\">FitzHugh-Nagumo</td></tr><tr><td>Model</td><td>K</td><td>1-step↓</td><td>VPT个</td><td>1-step↓</td><td>VPT个</td><td>1-step↓</td><td>VPT个</td><td>1-step↓</td><td>VPT个</td></tr><tr><td>base model -</td><td></td><td></td><td>5.17 ±0.57 0.362 ±0.026</td><td>5.59 ±0.30</td><td>0.339 ±0.038</td><td>0.82 ±0.02</td><td>0.110±0.035</td><td></td><td>73.66 ±12.59 0.236 ±0.053</td></tr><tr><td rowspan=\"6\">+ cFINDE</td><td>1</td><td>7.10 ±1.25</td><td>0.374 ±0.036</td><td>6.24 ±0.44</td><td>0.371 ±0.088</td><td>0.75 ±0.04</td><td>0.156±0.042</td><td>54.18 ±8.12</td><td>0.127 ±0.148</td></tr><tr><td>2</td><td>7.78 ±1.39</td><td>0.450 ±0.052</td><td>2.59 ±0.11</td><td>0.608 ±0.085</td><td>0.73±0.05</td><td>0.198 ±0.088</td><td>37.03 ±3.81</td><td>0.437 ±0.084</td></tr><tr><td>3</td><td>&gt;103</td><td>0.147 ±0.146*</td><td>3.19 ±0.37</td><td>0.730 ±0.091</td><td>0.69 ±0.03</td><td>0.411 ±0.093</td><td>&gt;106</td><td>0.007 ±0.007*</td></tr><tr><td>4</td><td>&gt;103</td><td>0.101 ±0.005</td><td>3.65 ±0.30</td><td>0.641 ±0.071</td><td>0.77 ±0.07</td><td>0.395 ±0.083</td><td>一</td><td></td></tr><tr><td>5</td><td>&gt;103</td><td>0.080±0.014</td><td>4.68 ±0.43</td><td>0.601 ±0.069</td><td>0.80±0.07</td><td>0.585 ±0.097</td><td></td><td></td></tr><tr><td>6</td><td>&gt;10³</td><td>0.070 ±0.019</td><td>7.79 ±0.51</td><td>0.425 ±0.067</td><td>12.53±0.00</td><td>0.005 ±0.000*</td><td></td><td></td></tr><tr><td rowspan=\"5\">+ dFINDE</td><td>1</td><td>7.01 ±1.06</td><td>0.379 ±0.040</td><td>11.61 ±6.60</td><td>0.288 ±0.083</td><td>0.75 ±0.10</td><td>0.152 ±0.017</td><td>47.07 ±8.03</td><td>0.117 ±0.122</td></tr><tr><td>2</td><td>7.03 ±1.00</td><td>0.475 ±0.022</td><td>2.70 ±0.26</td><td>0.598 ±0.059</td><td>0.74±0.05</td><td>0.271 ±0.111</td><td>33.24 ±3.40</td><td>0.455 ±0.032</td></tr><tr><td></td><td></td><td>3 54.78 ±36.39 0.309 ±0.024</td><td>3.78±0.27</td><td>0.636 ±0.024</td><td>0.69±0.05</td><td>0.447 ±0.081</td><td></td><td>319.70 ±91.11 0.049 ±0.007</td></tr><tr><td>4</td><td>&gt;10</td><td>0.102 ±0.015</td><td>3.48±0.32</td><td>0.780 ±0.059</td><td>0.71 ±0.03</td><td>0.454 ±0.060</td><td></td><td></td></tr><tr><td>5</td><td>&gt;103</td><td>0.086±0.011*</td><td>5.26 ±0.15</td><td>0.718±0.038</td><td>0.86 ±0.09</td><td>0.591 ±0.087</td><td></td><td></td></tr><tr><td></td><td>6</td><td>&gt;103</td><td>0.059 ±0.017</td><td>9.60 ±3.61</td><td></td><td></td><td>0.573 ±0.121 58.88 ±22.98 0.037 ±0.039</td><td></td><td></td></tr></table>",
+        "bbox": [
+            192,
+            112,
+            807,
+            333
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "image",
+        "img_path": "images/89d03c9a7890406db2fbecc814f8b6b34cdc584df01fb3eb8c8146f7deede677.jpg",
+        "image_caption": [
+            "Figure 2: Example results of the 2-body dataset. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            174,
+            390,
+            524,
+            531
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "image",
+        "img_path": "images/468b3482f1aadb8120b8263d0dcca0d63d619e797bf1f63eb5d4a25bb716d4d7.jpg",
+        "image_caption": [
+            "Figure 3: Mean absolute errors of states for the 2-body dataset with or without cFINDE. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            529,
+            386,
+            812,
+            522
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "300 the HNN without FINDE produced errors in the center-of-gravity position $x _ { c }$ (or $y _ { c }$ ) and those in the   \n301 mass positions $x _ { 1 } , x _ { 2 }$ (or $y _ { 1 } , y _ { 2 } )$ at almost the same level. In contrast, when the cFINDE is present,   \n302 errors in the center-of-gravity position were much smaller than those in the mass positions, implying   \n303 that errors in one mass position canceled out errors in the other mass position. ",
+        "bbox": [
+            142,
+            569,
+            825,
+            625
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Therefore, we conclude that FINDE not only had better prediction accuracy but also found and preserved linear momenta (which are related to symmetries in space) more accurately despite not having prior knowledge about symmetries. ",
+        "bbox": [
+            166,
+            631,
+            823,
+            672
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "307 4.4 Learning First Integrals from Data of Unknown Systems ",
+        "text_level": 1,
+        "bbox": [
+            150,
+            695,
+            606,
+            712
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "308 It is often unclear whether a target system is a Hamiltonian system or not, but one can expect that the   \n309 target system has several first integrals. We evaluated FINDE using NODE as the base model. We   \n310 summarized the results in Table 3.   \n311 For the KdV dataset, the NODE with FINDE got much better 1-step errors and VPTs for a wide   \n312 range of $K$ . Figure 4 shows an example result. The top panels show that the prediction results were   \n313 apparently similar. The bottom panels summarize mean absolute errors in states $\\textbf { \\em u }$ , total mass $\\textstyle \\sum _ { k } u _ { k }$   \n314 and energy. In the absence of FINDE, the NODE increased all of its errors in proportion to time. With   \n315 the cFINDE, the error in total mass increased at the point where the two solitons collided but then   \n316 returned to the original level. Although the calculation is slightly inaccurate, the cFINDE learned   \n317 to preserve the total mass. The rightmost panel shows that the error in energy continued to increase   \n318 for $K = 2$ , but it stayed within a small range for $K = 3$ . These results suggest that the first or   \n319 second quantity learned by the cFINDE was total mass, the third quantity was system energy, and the   \n320 remaining quantity may correspond to one of the many first integrals of the KdV equation.   \n321 For the 2-pend dataset, the NODE with FINDE got better 1-step errors and VPTs for $K = 1$ to 5   \n322 except for the 1-step error of the dFINDE with $K = 5$ . In addition to the system energy, the double   \n323 pendulum has two holonomic constraints on the position, which lead to two additional constraints   \n324 involving the velocity (see Appendix C for details). Thus, it is reasonable that the NODE with FINDE   \n325 got the best VPTs for $K = 5$ first integrals and totally failed when assuming $K > 5$ first integrals.   \n326 As exemplified in Fig. 5, the NODE without FINDE did not preserve the lengths of rods, making   \n327 the states deviate gradually. See Appendix D.2 for the case when actual constraints are known. For   \n328 the FitzHugh–Nagumo dataset, the NODE with FINDE got much better 1-step errors and VPTs for   \n329 $K = 2$ . As exemplified in Fig. 6, the ground truth state converged to a periodic orbit, and only the   \n330 NODE with cFINDE for $K = 2$ reproduced such dynamics. On the other hand, the state did not   \n331 stay at a limited region without FINDE and converged to a wrong equilibrium with the cFINDE for   \n332 $K = 1$ . For $K = 1$ , the sole quantity $V _ { 1 }$ may have tried to learn both of the two first integrals and   \n333 remained under-trained. In these two cases, FINDE found all first integrals; $K = 5$ for the 2-pend   \n334 dataset and $K = 2$ for the FitzHugh–Nagumo dataset. ",
+        "bbox": [
+            142,
+            724,
+            825,
+            766
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            143,
+            772,
+            825,
+            911
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "image",
+        "img_path": "images/be5e28ffd5b113697cd23b60e955f60ccb12a63a936fb9ef9c08be823a75a887.jpg",
+        "image_caption": [
+            "Figure 4: Example results of the KdV dataset. (top) Predicted states. Red belts denote moving solitons. (bottom) Mean absolute errors. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            176,
+            87,
+            777,
+            246
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "image",
+        "img_path": "images/8556882ad46dc0590252f5c7531273f1da140556e98cc6d80d3d2b4923a070e9.jpg",
+        "image_caption": [
+            "Figure 5: Example results of the 2-pend dataset for 2,000 steps. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            174,
+            286,
+            405,
+            397
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "image",
+        "img_path": "images/7787089d38eb6cba10618809e53bcab45a879c57163f3cfcbb6474ad1a9cd456.jpg",
+        "image_caption": [
+            "Figure 6: Example results of the FitzHugh–Nagumo dataset. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            415,
+            282,
+            794,
+            415
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            138,
+            462,
+            825,
+            656
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "335 5 Conclusion ",
+        "text_level": 1,
+        "bbox": [
+            151,
+            678,
+            299,
+            694
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "This study proposed first integral-preserving neural differential equation (FINDE). FINDE projects the time evolution onto the submanifold defined using the (discrete) gradients of first integrals represented by a neural network. With an appropriate number of assumed first integrals, FINDE predicted future states more accurately than base models. Not only that, FINDE found and preserved the system energy and the total mass as first integrals, first integrals related to symmetries in space, and first integrals led by constraints in a unified manner. Therefore, FINDE has the potential to make a scientific discovery by revealing unknown properties of target dynamical systems. ",
+        "bbox": [
+            169,
+            710,
+            825,
+            809
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "The 1-step errors were on the order of $1 0 ^ { - 5 }$ to $1 0 ^ { - 4 }$ in absolute error, being much larger than the numerical error tolerance of $1 0 ^ { - 9 }$ used in the experiments; numerical errors were negligible compared to modeling errors. However, the dFINDE tended to get VPTs better than the cFINDE despite the fact that its advantage is to eliminate numerical errors caused by temporal discretization. This result suggests that a method leading to smaller numerical errors results in a model with smaller modeling errors. Similar tendencies have been observed in previous works [10, 38], and these results may form a new frontier for integrating numerical and modeling errors. ",
+        "bbox": [
+            169,
+            814,
+            823,
+            911
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "References ",
+        "text_level": 1,
+        "bbox": [
+            142,
+            89,
+            267,
+            106
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "[1] Abadi, M., Agarwal, A., Barham, P., Brevdo, E., Chen, Z., Citro, C., Corrado, G. S., Davis, A., Dean, J., Devin, M., Ghemawat, S., Goodfellow, I., Harp, A., Irving, G., Isard, M., Jozefowicz, R., Jia, Y., Kaiser, L., Kudlur, M., Levenberg, J., Mané, D., Schuster, M., Monga, R., Moore, S., Murray, D., Olah, C., Shlens, J., Steiner, B., Sutskever, I., Talwar, K., Tucker, P., Vanhoucke, V., Vasudevan, V., Viégas, F., Vinyals, O., Warden, P., Wattenberg, M., Wicke, M., Yu, Y., and Zheng, X. (2016). TensorFlow: Large-scale machine learning on heterogeneous systems. USENIX Symposium on Operating Systems Design and Implementation (OSDI).   \n58 [2] Bai, S., Kolter, J. Z., and Koltun, V. (2019). Deep Equilibrium Models. In Advances in Neural Information Processing Systems (NeurIPS).   \n60 [3] Barrett, D. G. T. and Dherin, B. (2021). Implicit Gradient Regularization. In International Conference on Learning Representations (ICLR).   \n[4] Botev, A., Jaegle, A., Wirnsberger, P., Hennes, D., and Higgins, I. (2021). Which priors matter? Benchmarking models for learning latent dynamics. In Advances in Neural Information Processing Systems (NeurIPS) Track on Datasets and Benchmarks. [5] Cao, Y., Fang, Z., Wu, Y., Zhou, D. X., and Gu, Q. (2021). Towards Understanding the Spectral Bias of Deep Learning. International Joint Conference on Artificial Intelligence (IJCAI), pages 2205–2211.   \n7 [6] Celledoni, E., Grimm, V., McLachlan, R., McLaren, D., O’Neale, D., Owren, B., and Quispel, G. (2012). Preserving energy resp. dissipation in numerical PDEs using the “Average Vector Field” method. Journal of Computational Physics, 231(20):6770–6789. [7] Chen, S., Billings, S. A., and Grant, P. M. (1990). Non-linear system identification using neural networks. International Journal of Control, 51(6):1191–1214. [8] Chen, T. Q., Rubanova, Y., Bettencourt, J., Duvenaud, D., Chen, R. T. Q., Rubanova, Y., Bettencourt, J., and Duvenaud, D. (2018). Neural Ordinary Differential Equations. In Advances in Neural Information Processing Systems (NeurIPS), pages 1–19. [9] Chen, Y., Matsubara, T., and Yaguchi, T. (2021). Neural Symplectic Form $:$ Learning Hamiltonian Equations on General Coordinate Systems. In Advances in Neural Information Processing Systems (NeurIPS). [10] Chen, Z., Zhang, J., Arjovsky, M., and Bottou, L. (2020). Symplectic Recurrent Neural Networks. In International Conference on Learning Representations (ICLR), pages 1–23. [11] Christiansen, S. H., Munthe-Kaas, H. Z., and Owren, B. (2011). Topics in structure-preserving discretization. Acta Numerica, 20:1–119. [12] Clouse, D. S., Giles, C. L., Horne, B. G., and Cottrell, G. W. (1997). Time-delay neural networks: representation and induction of finite-state machines. IEEE Transactions on Neural Networks, 8(5):1065–70. [13] Cranmer, M., Greydanus, S., Hoyer, S., Battaglia, P., Spergel, D., and Ho, S. (2020). Lagrangian Neural Networks. In ICLR Deep Differential Equations Workshop, pages 1–9. [14] Cuell, C. and Patrick, G. W. (2009). Geometric discrete analogues of tangent bundles and constrained Lagrangian systems. Journal of Geometry and Physics, 59(7):976–997. [15] Dahlby, M., Owren, B., and Yaguchi, T. (2011). Preserving multiple first integrals by discrete gradients. Journal of Physics A: Mathematical and Theoretical, 44(30). [16] Dehmamy, N., Walters, R., Liu, Y., Wang, D., and Yu, R. (2021). Automatic Symmetry Discovery with Lie Algebra Convolutional Network. In Advances in Neural Information Processing Systems (NeurIPS), number 2018, pages 1–30. [17] Devlin, J., Chang, M.-W., Lee, K., and Toutanova, K. (2018). BERT: Pre-training of Deep Bidirectional Transformers for Language Understanding. arXiv, pages 1–15. [18] Dormand, J. R. and Prince, P. J. (1986). A reconsideration of some embedded Runge-Kutta formulae. Journal of Computational and Applied Mathematics, 15(2):203–211. [19] Finzi, M., Stanton, S., Izmailov, P., and Wilson, A. G. (2020a). Generalizing Convolutional Neural Networks for Equivariance to Lie Groups on Arbitrary Continuous Data. In International Conference on Machine Learning (ICML), pages 3146–3157.   \n[20] Finzi, M., Wang, K. A., and Wilson, A. G. (2020b). Simplifying Hamiltonian and Lagrangian Neural Networks via Explicit Constraints. In Advances in Neural Information Processing Systems (NeurIPS).   \n[21] Finzi, M., Welling, M., and Wilson, A. G. (2021). A Practical Method for Constructing Equivariant Multilayer Perceptrons for Arbitrary Matrix Groups. In International Conference on Machine Learning (ICML).   \n[22] Furihata, D. (2001). A stable and conservative finite difference scheme for the Cahn-Hilliard equation. Numerische Mathematik, 87(4):675–699.   \n[23] Furihata, D. and Matsuo, T. (2010). Discrete Variational Derivative Method: A Structure-Preserving Numerical Method for Partial Differential Equations. Chapman and Hall/CRC.   \n[24] Gear, C. W. (1986). Maintaining Solution Invariants in the Numerical Solution of ODE s. SIAM Journal on Scientific and Statistical Computing, 7(3):734–743.   \n[25] Gonzalez, O. (1996). Time integration and discrete Hamiltonian systems. Journal of Nonlinear Science, 6(5):449–467.   \n[26] Greydanus, S., Dzamba, M., and Yosinski, J. (2019). Hamiltonian Neural Networks. In Advances in Neural Information Processing Systems (NeurIPS), pages 1–16.   \n[27] Hairer, E., Lubich, C., and Wanner, G. (2006). Geometric Numerical Integration: Structure-Preserving Algorithms for Ordinary Differential Equations, volume 31 of Springer Series in Computational Mathematics. Springer-Verlag, Berlin/Heidelberg.   \n[28] He, K., Zhang, X., Ren, S., and Sun, J. (2016). Deep Residual Learning for Image Recognition. In IEEE Conference on Computer Vision and Pattern Recognition (CVPR), pages 1–9.   \n[29] Hong, J., Zhai, S., and Zhang, J. (2011). Discrete Gradient Approach to Stochastic Differential Equations with a Conserved Quantity. SIAM Journal on Numerical Analysis, 49(5):2017–2038.   \n[30] Izhikevich, E. M. and FitzHugh, R. (2006). FitzHugh-Nagumo model.   \n[31] Jin, P., Zhang, Z., Kevrekidis, I. G., and Karniadakis, G. E. (2020a). Learning Poisson systems and trajectories of autonomous systems via Poisson neural networks. pages 1–12.   \n[32] Jin, P., Zhu, A., Karniadakis, G. E., and Tang, Y. (2020b). Symplectic networks: Intrinsic structurepreserving networks for identifying Hamiltonian systems. Neural Networks, 132:166–179.   \n[33] Kingma, D. P. and Ba, J. (2015). Adam: A Method for Stochastic Optimization. In International Conference on Learning Representations (ICLR), pages 1–15.   \n[34] Lee, K. and Carlberg, K. (2021). Deep Conservation: A latent-dynamics model for exact satisfaction of physical conservation laws. In AAAI Conference on Artificial Intelligence (AAAI).   \n[35] Levin, A. U. and Narendra, K. S. (1995). Recursive identification using feedforward neural networks. International Journal of Control, 61(3):533–547.   \n[36] Loshchilov, I. and Hutter, F. (2017). SGDR: Stochastic gradient descent with warm restarts. In International Conference on Learning Representations (ICLR), pages 1–16.   \n[37] Manek, G. and Kolter, J. Z. (2019). Learning Stable Deep Dynamics Models. In Advances in Neural Information Processing Systems (NeurIPS), pages 1–9.   \n[38] Matsubara, T., Ishikawa, A., and Yaguchi, T. (2020). Deep Energy-Based Modeling of Discrete-Time Physics. In Advances in Neural Information Processing Systems (NeurIPS).   \n[39] Miura, R. M., Gardner, C. S., and Kruskal, M. D. (1968). Korteweg-de Vries equation and generalizations. II. Existence of conservation laws and constants of motion. Journal of Mathematical Physics, 9(8):1204–1209.   \n[40] Narendra, K. S. and Parthasarathy, K. (1990). Identification and Control of Dynamical Systems Using Neural Networks. IEEE Transactions on Neural Networks, 1(1):4–27.   \n[41] Nelles, O. (2001). Nonlinear System Identification. Springer Berlin Heidelberg, Berlin, Heidelberg.   \n[42] Paszke, A., Chanan, G., Lin, Z., Gross, S., Yang, E., Antiga, L., and Devito, Z. (2017). Automatic differentiation in PyTorch. In Autodiff Workshop on Advances in Neural Information Processing Systems, pages 1–4. ",
+        "bbox": [
+            155,
+            104,
+            828,
+            916
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            160,
+            94,
+            830,
+            911
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "446 [43] Potra, F. A. and Yen, J. (1991). Implicit numerical integration for euler-lagrange equations via tangent   \n447 space parametrization. Mechanics of Structures and Machines, 19(1):77–98.   \n448 [44] Quispel, G. R. and Capel, H. W. (1996). Solving ODEs numerically while preserving a first integral.   \n449 Physics Letters, Section A: General, Atomic and Solid State Physics, 218(3-6):223–228.   \n450 [45] Quispel, G. R. and Turner, G. S. (1996). Discrete gradient methods for solving ODEs numerically while   \n451 preserving a first integral. Journal of Physics A: Mathematical and General, 29(13).   \n452 [46] Raff, L., Komanduri, R., Hagan, M., and Bukkapatnam, S. (2012). Neural Networks in Chemical Reaction   \n453 Dynamics.   \n454 [47] Rasp, S., Dueben, P. D., Scher, S., Weyn, J. A., Mouatadid, S., and Thuerey, N. (2020). WeatherBench: A   \n455 Benchmark Data Set for Data-Driven Weather Forecasting. Journal of Advances in Modeling Earth Systems,   \n456 12(11).   \n457 [48] Sannai, A., Imaizumi, M., and Kawano, M. (2021). Improved Generalization Bounds of Group Invariant   \n458 / Equivariant Deep Networks via Quotient Feature Spaces. In Conference on Uncertainty in Artificial   \n459 Intelligence (UAI).   \n460 [49] Sjöberg, J., Hjalmarsson, H., and Ljung, L. (1994). Neural Networks in System Identification. IFAC   \n461 Proceedings Volumes, 27(8):359–382.   \n462 [50] Takeishi, N. and Kawahara, Y. (2020). Learning dynamics models with stable invariant sets. In AAAI   \n463 Conference on Artificial Intelligence (AAAI).   \n464 [51] Teshima, T., Tojo, K., Ikeda, M., Ishikawa, I., and Oono, K. (2020). Universal Approximation Property   \n465 of Neural Ordinary Differential Equations. In NeurIPS Workshop on Differential Geometry meets Deep   \n466 Learning (DiffGeo4DL).   \n467 [52] Trigo, R. M. and Palutikof, J. P. (1999). Simulation of daily temperatures for climate change scenarios   \n468 over Portugal: A neural network model approach. Climate Research, 13(1):45–59.   \n469 [53] van der Schaft, A. and Jeltsema, D. (2014). Port-Hamiltonian Systems Theory: An Introductory Overview.   \n470 Foundations and Trends® in Systems and Control, 1(2):173–378.   \n471 [54] Vlachas, P. R., Pathak, J., Hunt, B. R., Sapsis, T. P., Girvan, M., Ott, E., and Koumoutsakos, P. (2020).   \n472 Backpropagation algorithms and Reservoir Computing in Recurrent Neural Networks for the forecasting of   \n473 complex spatiotemporal dynamics. Neural Networks, 126:191–217.   \n474 [55] Wang, Y. J. and Lin, C. T. (1998). Runge-Kutta neural network for identification of dynamical systems in   \n475 high accuracy. IEEE Transactions on Neural Networks, 9(2):294–307.   \n476 [56] Zhong, G. and Marsden, J. E. (1988). Lie-Poisson Hamilton-Jacobi Theory and Lie-Poisson Integrators.   \n477 Physics Letters A, 133(3):3–8.   \n478 [57] Zhong, Y. D., Dey, B., and Chakraborty, A. (2020). Dissipative SymODEN: Encoding Hamiltonian   \n479 Dynamics with Dissipation and Control into Deep Learning. arXiv, pages 1–6. ",
+        "bbox": [
+            147,
+            85,
+            826,
+            669
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "1. For all authors... ",
+        "bbox": [
+            214,
+            116,
+            339,
+            130
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "(a) Do the main claims made in the abstract and introduction accurately reflect the paper’s contributions and scope? [Yes] The theoretical contributions are summarized in Remarks 1 and 2. The performance improvements were validated numerically in Table 3 and visually in Figs. 1–6.   \n(b) Did you describe the limitations of your work? [Yes] We have discussed an increase in computational complexity at the bottoms of Sections 3.1 and 3.2. We also presented the limitations in Appendix D.2 while their situations were originally outside the scope of the proposed method.   \n(c) Did you discuss any potential negative societal impacts of your work? [N/A] No societal impact is supposed.   \n(d) Have you read the ethics review guidelines and ensured that your paper conforms to them? [N/A] We have read the guidelines carefully, but no ethical impact is supposed. ",
+        "bbox": [
+            235,
+            133,
+            825,
+            306
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "2. If you are including theoretical results... ",
+        "bbox": [
+            215,
+            310,
+            493,
+            325
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "(a) Did you state the full set of assumptions of all theoretical results? [Yes] We have introduced the background of the proposed method and provided the full set of assumptions in Section 2. Even though a slight modification may make the proposed method available on a general manifold, we have clearly stated that our theoretical and experimental results were limited to the finite-dimensional Eucleadian spaces.   \n(b) Did you include complete proofs of all theoretical results? [Yes] We have provided a proof just before each of Remarks 1 and 2. ",
+        "bbox": [
+            233,
+            329,
+            825,
+            428
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "3. If you ran experiments... ",
+        "bbox": [
+            214,
+            433,
+            393,
+            446
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "(a) Did you include the code, data, and instructions needed to reproduce the main experimental results (either in the supplemental material or as a URL)? [Yes] We have enclosed the source code to reproduce all experiments in supplemental materials.   \n(b) Did you specify all the training details (e.g., data splits, hyperparameters, how they were chosen)? [Yes] We have provided the software and hardware environment, network architectures, and hyperparameters in Section 4.1. We have also provided detailed hyperparameters to generate datasets in Appendix C.   \n(c) Did you report error bars (e.g., with respect to the random seed after running experiments multiple times)? [Yes] We have summarized the standard deviations over five trials in Table 3.   \n(d) Did you include the total amount of compute and the type of resources used (e.g., type of GPUs, internal cluster, or cloud provider)? [Yes] We have provided the hardware environment in Section 4.1, but we have anonymized the cloud service providers to avoid a potential violation of the double-blind policy. ",
+        "bbox": [
+            236,
+            450,
+            826,
+            650
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "4. If you are using existing assets (e.g., code, data, models) or curating/releasing new assets... ",
+        "bbox": [
+            215,
+            655,
+            823,
+            669
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "(a) If your work uses existing assets, did you cite the creators? [Yes] We have made the source code for all experiments by modifying the source codes of HNN [26] and DGNet [38]. We have cited these references and added links to respective repositories in the footnotes.   \n(b) Did you mention the license of the assets? [Yes] We have verified that the source codes of HNN [26] and DGNet [38] are provided in Apache-2.0 License and MIT License, respectively. We have clearly stated these facts in the footnotes.   \n(c) Did you include any new assets either in the supplemental material or as a URL? [Yes] We have enclosed the source code to generate datasets in supplemental materials.   \n(d) Did you discuss whether and how consent was obtained from people whose data you’re using/curating? [N/A]   \n(e) Did you discuss whether the data you are using/curating contains personally identifiable information or offensive content? [N/A] ",
+        "bbox": [
+            238,
+            672,
+            825,
+            861
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "5. If you used crowdsourcing or conducted research with human subjects... ",
+        "bbox": [
+            214,
+            864,
+            707,
+            880
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "(a) Did you include the full text of instructions given to participants and screenshots, if applicable? [N/A] ",
+        "bbox": [
+            235,
+            883,
+            826,
+            912
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "534 (b) Did you describe any potential participant risks, with links to Institutional Review   \n535 Board (IRB) approvals, if applicable? [N/A]   \n536 (c) Did you include the estimated hourly wage paid to participants and the total amount   \n537 spent on participant compensation? [N/A] ",
+        "bbox": [
+            138,
+            90,
+            826,
+            151
+        ],
+        "page_idx": 13
+    }
+]

parse/train/B9t708KMr9d/B9t708KMr9d_layout.pdf

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

parse/train/B9t708KMr9d/B9t708KMr9d_origin.pdf

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

parse/train/B9t708KMr9d/B9t708KMr9d_span.pdf

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

parse/train/BJlBSkHtDS/BJlBSkHtDS_layout.pdf

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

parse/train/BJlBSkHtDS/BJlBSkHtDS_origin.pdf

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

parse/train/BJlBSkHtDS/BJlBSkHtDS_span.pdf

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

parse/train/ByghKiC5YX/ByghKiC5YX_layout.pdf

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

parse/train/ByghKiC5YX/ByghKiC5YX_origin.pdf

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

parse/train/ByghKiC5YX/ByghKiC5YX_span.pdf

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

parse/train/ByxPYjC5KQ/ByxPYjC5KQ_layout.pdf

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

parse/train/ByxPYjC5KQ/ByxPYjC5KQ_origin.pdf

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

parse/train/ByxPYjC5KQ/ByxPYjC5KQ_span.pdf

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

parse/train/HJgJNCEKPr/HJgJNCEKPr_layout.pdf

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

parse/train/HJgJNCEKPr/HJgJNCEKPr_origin.pdf

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

parse/train/HJgJNCEKPr/HJgJNCEKPr_span.pdf

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

parse/train/Hk8rlUqge/Hk8rlUqge_layout.pdf

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

parse/train/Hk8rlUqge/Hk8rlUqge_origin.pdf

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

parse/train/Hk8rlUqge/Hk8rlUqge_span.pdf

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

parse/train/HkSOlP9lg/HkSOlP9lg_layout.pdf

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

parse/train/HkSOlP9lg/HkSOlP9lg_origin.pdf

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

parse/train/HkSOlP9lg/HkSOlP9lg_span.pdf

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

parse/train/Hke0K1HKwr/Hke0K1HKwr_layout.pdf

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