Add files using upload-large-folder tool

parse/train/68B1ezcffDc/68B1ezcffDc.md

@@ -0,0 +1,343 @@
+# Subgroup Generalization and Fairness of Graph Neural Networks
+
+Jiaqi Ma ∗† jiaqima@umich.edu
+
+Junwei Deng ∗† junweid@umich.edu
+
+Qiaozhu Mei∗‡ qmei@umich.edu
+
+# Abstract
+
+Despite enormous successful applications of graph neural networks (GNNs), theoretical understanding of their generalization ability, especially for node-level tasks where data are not independent and identically-distributed (IID), has been sparse. The theoretical investigation of the generalization performance is beneficial for understanding fundamental issues (such as fairness) of GNN models and designing better learning methods. In this paper, we present a novel PAC-Bayesian analysis for GNNs under a non-IID semi-supervised learning setup. Moreover, we analyze the generalization performances on different subgroups of unlabeled nodes, which allows us to further study an accuracy-(dis)parity-style (un)fairness of GNNs from a theoretical perspective. Under reasonable assumptions, we demonstrate that the distance between a test subgroup and the training set can be a key factor affecting the GNN performance on that subgroup, which calls special attention to the training node selection for fair learning. Experiments across multiple GNN models and datasets support our theoretical results4.
+
+# 1 Introduction
+
+Graph Neural Networks (GNNs) [13, 35, 20] are a family of machine learning models that can be used to model non-Euclidean data as well as inter-related samples in a flexible way. In recent years, there have been enormous successful applications of GNNs in various areas, such as drug discovery [18], computer vision [29], transportation forecasting [49], recommender systems [48], etc. Depending on the type of prediction target, the application tasks can be roughly categorized into node-level, edge-level, subgraph-level, and graph-level tasks [46].
+
+In contrast to the marked empirical success, theoretical understanding of the generalization ability of GNNs has been rather limited. Among the existing literature, some studies [9, 11, 25] focus on the analysis of graph-level tasks where each sample is an entire graph and the samples of graphs are IID. A very limited number of studies [36, 42] explore GNN generalization for node-level tasks but they assume the nodes (and their associated neighborhoods) are IID samples, which does not align with the commonly seen graph-based semi-supervised learning setups. Baranwal et al. [3] investigate GNN generalization without IID assumptions but under a specific data generating mechanism.
+
+In this work, our first contribution is to provide a novel PAC-Bayesian analysis for the generalization ability of GNNs on node-level tasks with non-IID assumptions. In particular, we assume the node features are fixed and the node labels are independently sampled from distributions conditioned on the node features. We also assume the training set and the test set can be chosen as arbitrary subsets of nodes on the graph. We first prove two general PAC-Bayesian generalization bounds (Theorem 1 and Theorem 2) under this non-IID setup. Subsequently, we derive a generalization bound for GNN (Theorem 3) in terms of characteristics of the GNN models and the node features.
+
+Notably, the generalization bound for GNN is influenced by the distance between the test nodes and the training nodes in terms of their aggregated node features. This suggests that, given a fixed training set, test nodes that are “far away” from all the training nodes may suffer from larger generalization errors. Based on this analysis, our second contribution is the discovering of a type of unfairness that arises from theoretically predictable accuracy disparity across some subgroups of test nodes. We further conduct a empirical study that investigates the prediction accuracy of four popular GNN models on different subgroups of test nodes. The results on multiple benchmark datasets indicate that there is indeed a significant disparity in test accuracy among these subgroups.
+
+We summarize the contributions of this work as follows:
+
+(1) We establish a novel PAC-Bayesian analysis for graph-based semi-supervised learning with non-IID assumptions.   
+(2) Under this setup, we derive a generalization bound for GNNs that can be applied to an arbitrary subgroup of test nodes.   
+(3) As an implication of the generalization bound, we predict that there would be an unfairness of GNN predictions that arises from accuracy disparity across subgroups of test nodes.   
+(4) We empirically verify the existence of accuracy disparity of popular GNN models on multiple benchmark datasets, as predicted by our theoretical analysis.
+
+# 2 Related Work
+
+# 2.1 Generalization of Graph Neural Networks
+
+The majority of existing literature that aims to develop theoretical understandings of GNNs have focused on the expressive power of GNNs (see Sato [34] for a survey along this line), while the number of studies trying to understand the generalizability of GNNs is rather limited. Among them, some [9, 11, 25] focus on graph-level tasks, the analyses of which cannot be easily applied to node-level tasks. As far as we know, Scarselli et al. [36], Verma and Zhang [42], and Baranwal et al. [3] are the only existing studies investigating the generalization of GNNs on node-level tasks, even though node-level tasks are more common in reality. Scarselli et al. [36] present an upper bound of the VC-dimension of GNNs; Verma and Zhang [42] derive a stability-based generalization bound for a single-layer GCN [20] model. Yet, both Scarselli et al. [36] and Verma and Zhang [42] (implicitly) assume that the training nodes are IID samples from a certain distribution, which does not align with the common practice of node-level semi-supervised learning. Baranwal et al. [3] investigate the generalization of graph convolution under a specific data generating mechanism (i.e., the contextual stochastic block model [8]). Our work presents the first generalization analysis of GNNs for non-IID node-level tasks without strong assumptions on the data generating mechanism.
+
+# 2.2 Fairness of Machine Learning on Graphs
+
+The fairness issues of machine learning on graphs start to receive research attention recently. Following conventional machine learning fairness literature, the majority of previous work along this line [1, 5–7, 22, 32, 39, 50] concerns about fairness with respect to a given sensitive attribute, such as gender or race, which defines protected groups. In practice, the fairness issues of learning on graphs are much more complicated due to the asymmetric nature of the graph-structured data. However, only a few studies [19] investigate the unfairness caused by the graph structure without knowing a sensitive feature. Moreover, in a node-level semi-supervised learning task, the non-IID sampling of training nodes brings additional uncertainty to the fairness of the learned models. This work is the first to present a learning theoretic analysis under this setup, which in turn suggests how the graph structure and the selection of training nodes may influence the fairness of machine learning on graphs.
+
+# 2.3 PAC-Bayesian Analysis
+
+PAC-Bayesian analysis [27] has become one of the most powerful theoretical framework to analyze the generalization ability of machine learning models. We will briefly introduce the background in
+
+Section 3.2, and refer the readers to a recent tutorial [14] for a systematic overview of PAC-Bayesian analysis. We note that Liao et al. [25] recently present a PAC-Bayesian generalization bound for GNNs on IID graph-level tasks. Both Liao et al. [25] and this work utilize results from Neyshabur et al. [30], a PAC-Bayesian analysis for ReLU-activated neural networks, in part of our proofs. Compared to Neyshabur et al. [30], the key contribution of Liao et al. [25] is the derivation of perturbation bounds of two types of GNN architectures; while the key contribution of this work is the novel analysis under the setup of non-IID node-level tasks. There is also an existing work of PAC-Bayesian analysis for transductive semi-supervised learning [4]. But it is different from our problem setup and, in particular, it cannot be used to analyze the generalization on subgroups.
+
+# 3 Preliminaries
+
+In this section, we first formulate the problem of node-level semi-supervised learning. We also provide a brief introduction of the PAC-Bayesian framework.
+
+# 3.1 The Problem Formulation and Notations
+
+Semi-supervised node classification. Let $G = ( V , E ) \in \mathcal G _ { N }$ be an undirected graph, with $V = \{ 1 , \bar { 2 } , \dots , N \}$ being the set of $N$ nodes and $E \subseteq V \times V$ being the set of edges. And $\mathcal { G } _ { N }$ is the space of all undirected graphs with $N$ nodes. The nodes are associated with node features $\boldsymbol { X } \in \mathbb { R } ^ { \hat { \boldsymbol { N } } \times \boldsymbol { D } }$ and node labels $y \in \{ 1 , 2 , \ldots , K \} ^ { N }$ .
+
+In this work, we focus on the transductive node classification setting [47], where the node features $X$ and the graph $G$ are observed prior to learning, and every quantity of interest in the analysis will be conditioned on $X$ and $G$ . Without loss of generality, we treat $X$ and $G$ as fixed throughout our analysis, and the randomness comes from the labels $y$ . In particular, we assume that for each node $i \in V$ , its label $y _ { i }$ is generated from an unknown conditional distribution $\mathrm { P r } ( y _ { i } \mid Z _ { i } )$ , where $Z = g ( X , G )$ and $g : \mathbb { R } ^ { N \times D } \times \mathcal { G } _ { N }  \mathbb { R } ^ { N \times D ^ { \prime } }$ is an aggregation function that aggregates the features over (multi-hop) local neighborhoods5. We also assume that the node labels are generated independently conditional on their respective aggregated features $Z _ { i }$ ’s.
+
+Given a small set of the labeled nodes, $V _ { 0 } \subseteq V$ , the task of node-level semi-supervised learning is to learn a classifier $h : \mathbb { R } ^ { N \times D } \times \mathcal { G } _ { N }  \mathbb { R } ^ { N \times K }$ from a function family $\mathcal { H }$ and perform it on the remaining unlabeled nodes. Given a classifier $h$ , the classification for a node $i$ is obtained by
+
+$$
+\hat { y } _ { i } = \underset { k \in \{ 1 , \dots , K \} } { \mathrm { a r g m a x } } h _ { i } ( X , G ) [ k ] ,
+$$
+
+where $h _ { i } ( X , G )$ is the $i$ -th row of $h ( X , G )$ and $h _ { i } ( X , G ) [ k ]$ refers to the $k$ -th element of $h _ { i } ( X , G )$ .
+
+Subgroups. In Section 4, we will present an analysis of the GNN generalization performance on any subgroup of the set of unlabeled nodes, $V \setminus \bar { V _ { 0 } }$ . Note that the analysis on any subgroup is a stronger result than that on the entire unlabeled set, as any set is a subset of itself. Later we will show that the analysis on subgroups (rather than on the entire set) further allows us to investigate the accuracy disparity across subgroups. We denote a collection of subgroups of interest as $V _ { 1 } , \bar { V } _ { 2 } , \ldots , V _ { M } \subseteq \bar { V } \setminus \bar { V } _ { 0 }$ . In practice, a subgroup can be defined based on an attribute of the nodes (e.g., a gender group), certain graph-based properties, or an arbitrary partition of the nodes. We also define the size of each subgroup as $N _ { m } : = | V _ { m } | , m = 0 , \ldots , M$ .
+
+Margin loss on each subgroup. Now we can define the empirical and expected margin loss of any classifier $h \in \mathcal H$ on each subgroup $V _ { m } , m = 0 , 1 , \dots , M$ . Given a sample of observed node labels $y _ { i }$ ’s, the empirical margin loss of $h$ on $V _ { m }$ for a margin $\gamma \geq 0$ is defined as
+
+$$
+\widehat { \mathcal { L } } _ { m } ^ { \gamma } ( h ) : = \frac { 1 } { N _ { m } } \sum _ { i \in V _ { m } } \mathbb { 1 } \left[ h _ { i } ( X , G ) [ y _ { i } ] \leq \gamma + \operatorname* { m a x } _ { k \neq y _ { i } } h _ { i } ( X , G ) [ k ] \right] ,
+$$
+
+where $\mathbb { 1 } \left[ \cdot \right]$ is the indicator function. The expected margin loss is the expectation of Eq. (1), i.e.,
+
+$$
+\begin{array} { r } { \mathcal { L } _ { m } ^ { \gamma } ( h ) : = \mathbb { E } _ { y _ { i } \sim \operatorname* { P r } ( \mathbf { y } \mid Z _ { i } ) , i \in V _ { m } } \widehat { \mathcal { L } } _ { m } ^ { \gamma } ( h ) . } \end{array}
+$$
+
+To simplify the notation, we define $y ^ { m } : = \{ y _ { i } \} _ { i \in V _ { m } }$ , $\forall m = 0 , \ldots , M$ , so that Eq. (2) can be written as $\bar { \mathcal { L } } _ { m } ^ { \gamma } \bar { ( } h ) \bar { = } \mathbb { E } _ { y ^ { m } } \widehat { \mathcal { L } } _ { m } ^ { \gamma } ( h )$ . We note that the classification risk and empirical risk of $h$ on $V _ { m }$ are respectively equal to $\mathcal { L } _ { m } ^ { 0 } ( h )$ and $\widehat { \mathcal { L } } _ { m } ^ { 0 } ( h )$ .
+
+# 3.2 The PAC-Bayesian Framework
+
+The PAC-Bayesian framework [27] is an approach to analyze the generalization ability of a stochastic predictor drawn from a distribution $Q$ over the predictor family $\mathcal { H }$ that is learned from the training data. For any stochastic classifier distribution $Q$ and $m = 0 , \ldots , M$ , slightly overloading the notation, we denote the empirical margin loss of $Q$ on $V _ { m }$ as ${ \widehat { \mathcal { L } } } _ { m } ^ { \gamma } ( Q )$ , and the corresponding expected margin loss as $\mathcal { L } _ { m } ^ { \gamma } ( Q )$ . And they are given by
+
+$$
+\widehat { \mathscr { L } } _ { m } ^ { \gamma } ( Q ) : = \mathbb { E } _ { h \sim Q } \widehat { \mathscr { L } } _ { m } ^ { \gamma } ( h ) , \quad \mathscr { L } _ { m } ^ { \gamma } ( Q ) : = \mathbb { E } _ { h \sim Q } \mathscr { L } _ { m } ^ { \gamma } ( h ) .
+$$
+
+In general, a PAC-Bayesian analysis aims to bound the generalization gap between $\mathcal { L } _ { m } ^ { \gamma } ( Q )$ and $\widehat { \mathcal { L } } _ { m } ^ { \gamma } ( Q )$ . The analysis is usually done by first proving that, for any “prior” distribution6 $P$ over $\mathcal { H }$ that is independent of the training data, the generalization gap can be controlled by the discrepancy between $P$ and $Q$ ; the analysis is then followed by careful choices of $P$ to get concrete upper bounds of the generalization gap. While the PAC-Bayesian framework is built on top of stochastic predictors, there exist standard techniques [23] that can be used to derive generalization bounds for deterministic predictors from PAC-Bayesian bounds.
+
+Finally, we denote the Kullback-Leibler $( K L )$ divergence as $\begin{array} { r } { D _ { \mathrm { K L } } ( Q \| P ) : = \int \ln \frac { d Q } { d P } d Q } \end{array}$ , which will be used in the following analysis.
+
+# 4 The Generalization Bound and Its Implications for Fairness
+
+As we mentioned in Section 2.3, existing PAC-Bayesian analyses cannot be directly applied to the nonIID semi-supervised learning setup where we care about the generalization (and its disparity) across different subgroups of the unlabeled samples. In this section, we first present general PAC-Bayesian theorems for subgroup generalization under our problem setup; then we derive a generalization bound for GNNs and discuss fairness implications of the bound.
+
+# 4.1 General PAC-Bayesian Theorems for Subgroup Generalization
+
+Stochastic classifier bound. We first present the general PAC-Bayesian theorem (Theorem 1) for subgroup generalization of stochastic classifiers. The generalization bound depends on a notion of expected loss discrepancy between two subgroups as defined below.
+
+Definition 1 (Expected Loss Discrepancy). Given a distribution $P$ over $\mathcal { H }$ , for any $\lambda > 0$ and $\gamma \geq 0$ for any two subgroups $V _ { m }$ and $V _ { m ^ { \prime } }$ $0 \leq m , m ^ { \prime } \leq M )$ , define the expected loss discrepancy between $V _ { m }$ and $V _ { 0 }$ with respect to $( P , \gamma , \lambda )$ as
+
+$$
+D _ { m , m ^ { \prime } } ^ { \gamma } ( P ; \lambda ) : = \ln \mathbb { E } _ { h \sim P } e ^ { \lambda \left( \mathcal { L } _ { m } ^ { \gamma / 2 } ( h ) - \mathcal { L } _ { m ^ { \prime } } ^ { \gamma } ( h ) \right) } ,
+$$
+
+where $\mathcal { L } _ { m } ^ { \gamma / 2 } ( h )$ and $\mathcal { L } _ { m ^ { \prime } } ^ { \gamma } ( h )$ follow the definition of Eq. (2).
+
+Intuitively, $D _ { m , m ^ { \prime } } ^ { \gamma } ( P ; \lambda )$ captures the difference of the expected loss between $V _ { m }$ and $V _ { m ^ { \prime } }$ in an average sense (over $P$ ). Note that $D _ { m , m ^ { \prime } } ^ { \gamma } ( P ; \lambda )$ is asymmetric in terms of $V _ { m }$ and $V _ { m ^ { \prime } }$ , and can be negative if the loss on $V _ { m }$ is mostly smaller than that on $V _ { m ^ { \prime } }$ .
+
+For stochastic classifiers, we have the following Theorem 1. Proof can be found in Appendix A.1.
+
+Theorem 1 (Subgroup Generalization of Stochastic Classifiers). For any $0 < m \le M$ , for any $\lambda > 0$ and $\gamma \geq 0 _ { ; }$ , for any “prior” distribution $P$ on $\mathcal { H }$ that is independent of the training data on $V _ { 0 }$ , with
+
+probability at least $1 - \delta$ over the sample of $y ^ { 0 }$ , for any $Q$ on $\mathcal { H }$ , we have7
+
+$$
+\mathcal { L } _ { m } ^ { \gamma / 2 } ( Q ) \leq \widehat { \mathcal { L } } _ { 0 } ^ { \gamma } ( Q ) + \frac { 1 } { \lambda } \left( D _ { \mathrm { K L } } ( Q \| P ) + \ln \frac { 1 } { \delta } + \frac { \lambda ^ { 2 } } { 4 N _ { 0 } } + D _ { m , 0 } ^ { \gamma } ( P ; \lambda ) \right) .
+$$
+
+Theorem 1 can be viewed as an adaptation of a result by Alquier et al. [2] from the IID supervised setting to our non-IID semi-supervised setting. The terms $\begin{array} { r } { D _ { \mathrm { K L } } ( Q \| P ) , \mathrm { l n } \frac { 2 } { \delta } } \end{array}$ , and $\frac { \lambda ^ { 2 } } { 4 N _ { 0 } }$ are commonly seen in PAC-Bayesian analysis for IID supervised setting. In particular, when setting $\lambda = \Theta ( \sqrt { N _ { 0 } } )$ , $\begin{array} { r } { \frac { 1 } { \lambda } \left( \ln \frac { 2 } { \delta } + \frac { \lambda ^ { 2 } } { 4 N _ { 0 } } \right) } \end{array}$ vanishes as the training size $N _ { 0 }$ grows. The divergence between $Q$ and $P$ , $D _ { \mathrm { K L } } ( Q \| P )$ , is usually considered as a measurement of the model complexity [14]. And there will be a trade-off between the training loss, $\widehat { \mathcal { L } } _ { 0 } ^ { \gamma } ( Q )$ , and the complexity (how far can the learned “posterior” $Q$ go from the “prior” $P$ ).
+
+Uniquely for the non-IID semi-supervised setting, there is an extra term $D _ { m , 0 } ^ { \gamma } ( P ; \lambda )$ , which is the expected loss discrepancy between the target test subgroup $V _ { m }$ and the training set $V _ { 0 }$ . Note that this quantity is independent of the training labels $y ^ { 0 }$ . Not surprisingly, it is difficult to give generalization guarantees if the expected loss on $V _ { m }$ is much larger than that on $V _ { 0 }$ for any stochastic classifier $P$ independent of training data. We have to make some assumptions about the relationship between $V _ { m }$ and $V _ { 0 }$ to obtain a meaningful bound on $\begin{array} { r } { \frac { 1 } { \lambda } D _ { m , 0 } ^ { \gamma } ( P ; \lambda ) } \end{array}$ , which we will discuss in details in Section 4.2.
+
+Deterministic classifier bound. Utilizing standard techniques in PAC-Bayesian analysis [23, 27, 30], we can convert the bound for stochastic classifiers in Theorem 1 to a bound for deterministic classifiers as stated in Theorem 2 below (see Appendix A.2 for the proof).
+
+Theorem 2 (Subgroup Generalization of Deterministic Classifiers). Let $\tilde { h }$ be any classifier in $\mathcal { H }$ . For any $0 < m \le M$ , for any $\lambda > 0$ and $\gamma \geq 0$ , for any “prior” distribution $P$ on $\mathcal { H }$ that is independent of the training data on $V _ { 0 }$ , with probability at least $1 - \delta$ over the sample of $y ^ { 0 }$ , for any $Q$ on $\mathcal { H }$ such that $\begin{array} { r } { \operatorname* { P r } _ { h \sim Q } \left( \operatorname* { m a x } _ { i \in V _ { 0 } \cup V _ { m } } \| h _ { i } ( X , G ) - \tilde { h } _ { i } ( X , G ) \| _ { \infty } < \frac { \gamma } { 8 } \right) > \frac { 1 } { 2 } } \end{array}$ , we have
+
+$$
+\mathcal { L } _ { m } ^ { 0 } ( \widetilde { h } ) \le \widehat { \mathcal { L } } _ { 0 } ^ { \gamma } ( \widetilde { h } ) + \frac { 1 } { \lambda } \left( 2 ( D _ { \mathrm { K L } } ( Q \| P ) + 1 ) + \ln \frac { 1 } { \delta } + \frac { \lambda ^ { 2 } } { 4 N _ { 0 } } + D _ { m , 0 } ^ { \gamma / 2 } ( P ; \lambda ) \right) .
+$$
+
+Theorem 1 and 2 are not specific to GNNs and hold for any (respectively stochastic and deterministic) classifier under the semi-supervised setup. In Section 4.2, we will apply Theorem 2 to obtain a subgroup generalization bound that explicitly depends on the characteristics of GNNs and the data.
+
+# 4.2 Subgroup Generalization Bound for Graph Neural Networks
+
+The GNN model. We consider GNNs where the node feature aggregation step and the prediction step are separate. In particular, we assume the GNN classifier takes the form of $h _ { i } ( X , G ) ~ =$ $f ( \bar { g } _ { i } ( X , G ) ; W _ { 1 } , W _ { 2 } , \underline { { { \cdot \cdot \cdot } } } , W _ { L } )$ , where $g$ is an aggregation function as we described in Section 3.1 and $f$ is a ReLU-activated $L$ -layer Multi-Layer Perceptron (MLP) with $W _ { 1 } , \dots , W _ { L }$ as parameters for each layer8. Denote the largest width of all the hidden layers as $b$ .
+
+Remark 1. There is a technical restriction on the possible choice of the aggregation function $g$ . For the following derivation of the generalization bound (6) to be valid, we need the condition that the node labels $y _ { i }$ ’s are independent conditional on their aggregated features $g _ { i } ( X , G )$ ’s, as introduced in the problem formulation in Section 3.1. However, we also note that this condition tends to hold when the aggregated features $g _ { i } ( X , G )$ ’s contain rich information about the labels.
+
+Upper-bounding $D _ { m , 0 } ^ { \gamma } ( P ; \lambda )$ . To derive the generalization guarantee, we need to upper-bound the expected loss discrepancy $D _ { m , 0 } ^ { \gamma } ( P ; \lambda )$ . It turns out that we have to make some assumptions on the data in order to get a meaningful upper bound.
+
+So far we have not had any restrictions on the conditional label distributions $\operatorname* { P r } ( y _ { i } = k \mid g _ { i } ( X , G ) )$ If the label distributions on $V \backslash V _ { 0 }$ can be arbitrarily different from those on $V _ { 0 }$ , the generalization can be arbitrarily poor. We therefore assume that the label distributions conditional on aggregated features are smooth (Assumption 1).
+
+Assumption 1 (Smoothness of Data Distribution). Assume there exist $c$ -Lipschitz continuous functions $\mathring { \eta _ { 1 } } , \eta _ { 2 } , \dotsc , \eta _ { K } : \mathbb { R } ^ { D ^ { \prime } }  [ 0 , 1 ]$ , such that, for any node $i \in V$ ,
+
+$$
+\operatorname* { P r } ( y _ { i } = k \mid g _ { i } ( X , G ) ) = \eta _ { k } ( g _ { i } ( X , G ) ) , \forall k = 1 , \ldots , K .
+$$
+
+We also need to characterize the relationship between a target test subgroup $V _ { m }$ and the training set $V _ { 0 }$ . For this purpose, we define the distance from $V _ { m }$ to $V _ { 0 }$ and the concept of near set below.
+
+Definition 2 (Distance To Training Set and Near Set). For each $0 < m \le M$ , define the distance from the subgroup $V _ { m }$ to the training set $V _ { 0 }$ as
+
+$$
+\epsilon _ { m } : = \operatorname* { m a x } _ { j \in V _ { m } } \operatorname* { m i n } _ { i \in V _ { 0 } } \| g _ { i } ( X , G ) - g _ { j } ( X , G ) \| _ { 2 } .
+$$
+
+Further, for each $i \in V _ { 0 }$ , define the near set of $i$ with respect to $V _ { m }$ as
+
+$$
+V _ { m } ^ { ( i ) } : = \{ j \in V _ { m } \mid \| g _ { i } ( X , G ) - g _ { j } ( X , G ) \| _ { 2 } \leq \epsilon _ { m } \} .
+$$
+
+Clearly,
+
+$$
+V _ { m } = \cup _ { i \in V _ { 0 } } V _ { m } ^ { ( i ) } .
+$$
+
+Then, with the Assumption 2 and 3 below, we can bound the expected loss discrepancy $D _ { m , 0 } ^ { \gamma } ( P ; \lambda )$ with the following Lemma 1 (see the proof in Appendix A.3).
+
+Assumption 2 (Equal-Sized and Disjoint Near Sets). For any $0 < m \le M$ , assume the near sets of each $i \in V _ { 0 }$ with respect to $V _ { m }$ are disjoint and have the same size $s _ { m } \in \mathbb { N } ^ { + }$ .
+
+Assumption 3 (Concentrated Expected Loss Difference). Let $P$ be a distribution on $\mathcal { H }$ , defined by sampling the vectorized MLP parameters from ${ \mathcal { N } } ( 0 , \sigma ^ { 2 } I )$ for some $\begin{array} { r } { \sigma ^ { 2 } \le \frac { ( \gamma / 8 \epsilon _ { m } ) ^ { 2 / L } } { 2 b ( \lambda N _ { 0 } ^ { - \alpha } + \ln { 2 b L } ) } } \end{array}$ For any $L$ - layer GNN classifier $h \in \mathcal H$ with model parameters $W _ { 1 } ^ { h } , \ldots , W _ { L } ^ { h }$ , define $T _ { h } : = \operatorname* { m a x } _ { l = 1 , \ldots , L } \| W _ { l } \| _ { 2 }$ . Assume that there exists some $\textstyle 0 < \alpha < { \frac { 1 } { 4 } }$ satisfying
+
+$$
+\operatorname* { P r } _ { h \sim P } \left( \mathcal { L } _ { m } ^ { \gamma / 4 } ( h ) - \mathcal { L } _ { 0 } ^ { \gamma / 2 } ( h ) > N _ { 0 } ^ { - \alpha } + c K \epsilon _ { m } \mid T _ { h } ^ { L } \epsilon _ { m } > \frac { \gamma } { 8 } \right) \le e ^ { - N _ { 0 } ^ { 2 \alpha } } .
+$$
+
+Lemma 1 (Bound for $D _ { m , 0 } ^ { \gamma } ( P ; \lambda ) )$ . Under Assumption $I$ , 2 and 3, for any $0 < m \le M$ , any $0 < \lambda \leq N _ { 0 } ^ { 2 \alpha }$ and $\gamma \geq 0$ , assume the “prior” $P$ on $\mathcal { H }$ is defined by sampling the vectorized $M L P$ parameters from ${ \mathcal { N } } ( 0 , \sigma ^ { 2 } I )$ for some $\begin{array} { r } { \sigma ^ { 2 } \le \frac { ( \gamma / 8 \epsilon _ { m } ) ^ { 2 / L } } { 2 b ( \lambda N _ { 0 } ^ { - \alpha } + \ln { 2 b L } ) } } \end{array}$ . We have
+
+$$
+D _ { m , 0 } ^ { \gamma / 2 } ( P ; \lambda ) \leq \ln { 3 } + \lambda c K \epsilon _ { m } .
+$$
+
+Intuitively, what we need to bound $D _ { m , 0 } ^ { \gamma } ( P ; \lambda )$ is that the training set $V _ { 0 }$ is “representative” for $V _ { m }$ . This is reasonable in practice as it is natural to select the training samples according to the distribution of the population. Specifically, Assumption 2 assumes that $V _ { m }$ can be split into equalsized partitions indexed by the training samples. The elements of each partition $V _ { m } ^ { ( i ) }$ are close to the corresponding training sample $i$ but not so close to training samples other than $i$ . This assumption is stronger than needed to obtain a meaningful bound on $\bar { D } _ { m , 0 } ^ { \gamma } \bar { ( } P ; \lambda )$ , and we can relax it by only assuming that most samples in $V _ { m }$ have proportional “close representatives” in $V _ { 0 }$ . But we keep Assumption 2 in this work, as it is intuitively clear and significantly eases the analysis and notations. Assumption 3 essentially assumes that the expected margin loss on $V _ { m }$ is not much larger than that on $V _ { 0 }$ when the number of samples becomes large. We first note that this assumption becomes trivially true in the degenerate case that all samples in $V _ { m }$ and $V _ { 0 }$ are IID. In this case, $\bar { \mathcal { L } } _ { m } ^ { \gamma / 4 } ( h ) = \bar { \mathcal { L } } _ { 0 } ^ { \gamma / 4 } ( h ) < \bar { \mathcal { L } } _ { 0 } ^ { \gamma / 2 } ( h ) \bar { \ } \leq 0$ for any classifier $h$ . In Appendix A.5, we further provide a simple non-IID example where Assumption 3 holds.
+
+The bound (5) suggests that the closer between $V _ { m }$ and $V _ { 0 }$ (smaller $\epsilon _ { m }$ ), the smaller the expected loss discrepancy.
+
+Bound for GNNs. Finally, with an additional technical assumption (Assumption 4) that the maximum L2 norm of aggregated node features does not grow too fast in terms of the number of training samples, we obtain a subgroup generalization bound for GNNs in Theorem 3. The proof of Theorem 3 can be found in Appendix A.4.
+
+Assumption 4. Define $B _ { m } : = \operatorname* { m a x } _ { i \in V _ { 0 } \cup V _ { m } } \| g _ { i } ( X , G ) \| _ { 2 }$ . For any classifier $\tilde { h } \in \mathcal { H }$ with parameters $\{ \widetilde { W } _ { l } \} _ { l = 1 } ^ { L }$ , assume $\| \widetilde { W } _ { l } \| _ { F } \le C f o r l = 1 , \ldots , L .$ . Assume $B _ { m } , C$ are constants with respect to $N _ { 0 }$ .
+
+Theorem 3 (Subgroup Generalization Bound for GNNs). Let $\tilde { h }$ be any classifier in $\mathcal { H }$ with parameters $\{ \widetilde { W } _ { l } \} _ { l = 1 } ^ { L }$ . Under Assumptions 1, 2, 3, and 4, for any $0 < m \le M$ , $\gamma \geq 0$ , and large enough $N _ { 0 }$ , with probability at least $1 - \delta$ over the sample of $y ^ { 0 }$ , we have
+
+$$
+\mathcal { L } _ { m } ^ { 0 } ( \widetilde { h } ) \leq \widehat { \mathcal { L } } _ { 0 } ^ { \gamma } ( \widetilde { h } ) + O \left( c K \epsilon _ { m } + \frac { b \sum _ { l = 1 } ^ { L } \| \widetilde { W } _ { l } \| _ { F } ^ { 2 } } { ( \gamma / 8 ) ^ { 2 / L } N _ { 0 } ^ { \alpha } } ( \epsilon _ { m } ) ^ { 2 / L } + \frac { 1 } { N _ { 0 } ^ { 1 - 2 \alpha } } + \frac { 1 } { N _ { 0 } ^ { 2 \alpha } } \ln \frac { L C ( 2 B _ { m } ) ^ { 1 / L } } { \gamma ^ { 1 / L } \delta } \right) .
+$$
+
+Next, we investigate the qualitative implications of our theoretical results.
+
+# 4.3 Implications for Fairness of Graph Neural Networks
+
+Theoretically predictable accuracy disparity. One merit of our analysis is that we can apply Theorem 3 on different subgroups of the unlabeled nodes and compare the subgroup generalization bounds. This allows us to study the accuracy disparity across subgroups from a theoretical perspective.
+
+A major factor that affects the generalization bound (6) is $\epsilon _ { m }$ , the aggregated-feature distance (in terms of $g ( X , G ) )$ from the target test subgroup $V _ { m }$ to the training set $V _ { 0 }$ . The generalization bound (6) suggests that there is a better generalization guarantee for subgroups that are closer to the training set. In other words, it is unfair for subgroups that are far away from the training set. While our theoretical analysis can only tell the difference among upper bounds of generalization errors, we empirically verify that, in the following Section 5, the aggregated-feature distance $\epsilon _ { m }$ is indeed a strong predictor for the test accuracy of each subgroup $V _ { m }$ . More specifically, the test accuracy decreases as the distance increases, which is consistent with the theoretical prediction given by the bound (6).
+
+Impact of the structural positions of nodes. We further investigate if the aggregated-feature distance can be related to simpler and more interpretable graph characteristics, in order to obtain a more intuitive understanding of how the structural positions of nodes influence the prediction accuracy on them. We find that the geodesic distance (length of the shortest path) between two nodes is positively related to the distance between their aggregated features in some scenarios9, such as when the node features exhibit homophily [28]. Empirically, we also observe that test nodes with larger geodesic distance to the training set tend to suffer from lower accuracy (see Figure 2).
+
+In contrast, we find that common node centrality metrics (e.g., degree and PageRank) have less influence on the test accuracy (see Figure 3). These centrality metrics only capture the graph characteristics of the test nodes alone, but do not take their relationship to the training set into account, which is a key factor suggested by our theoretical analysis.
+
+Impact of training data selection. Another implication of the theoretical results is that the selection of the training set plays an important role on the fairness of the learned GNN models. First, if the training set is selected unevenly on the graph, leaving part of the test nodes far away, there will likely be a large accuracy disparity. Second, a key ingredient in the proof of Lemma 1 is that the GNN predictions on two nodes tend to be more similar if they are closer in terms of the aggregated node features. This suggests that, if an individual training node is close to many test nodes, it may bias the predictions of the learned GNN on the test nodes towards the class it belongs to.
+
+# 5 Experiments
+
+In this section, we empirically verify the fairness implications suggested by our theoretical analysis.
+
+General setup. We experiment on 4 popular GNN models, GCN [20], GAT [41], SGC [45], and APPNP [21], as well as an MLP model for reference. For all models, we use the implementations by Deep Graph Library [43]. For each experiment setting, 40 independent trials are carried out.
+
+# 5.1 Accuracy Disparity Across Subgroups
+
+Subgroups. We examine the accuracy disparity with three types of subgroups as described below.
+
+![](images/48f1a17779a5858cf36af9557baf10070dff8a78e3728d933ffc0b4856a6f4fc.jpg)  
+Figure 1: Test accuracy disparity across subgroups by aggregated-feature distance. Each figure corresponds to a dataset, and each bar cluster corresponds to a model. Bars labeled 1 to 5 represent subgroups with increasing distance to training set. Results are averaged over 40 independent trials with different random splits of the data, and the error bar represents the standard error of the mean.
+
+![](images/6677d439e47c9833970758a260951d224a6965a92db8cf0bb8ba71dbefa1f5b3.jpg)  
+Figure 2: Test accuracy disparity across subgroups by geodesic distance. The experiment and plot settings are the same as Figure 1, except for the bars labeled from 1 to 5 here represent subgroups with increasing shortest-path distance to training set.
+
+Subgroup by aggregated-feature distance. In order to directly investigate the effect of $\epsilon _ { m }$ on the generalization bound (6), we first split the test nodes into subgroups by their distance to the training set in terms of the aggregated features. We use the two-step aggregated features to calculate the distance. In particular, denote the adjacency matrix of the graph $G$ as $\breve { A } \in \{ 0 , 1 \} ^ { N \times N }$ and the corresponding degree matrix as D, where D is an N × N diagonal matrix with Dii = PNj=1 Aij , ∀i = 1, . . . , N . Given the feature matrix $X \in \mathbb { R } ^ { N \times D }$ , the two-step aggregated features $Z$ are obtained by $Z =$ $( D + I ) ^ { - 1 } ( A + I ) ( D + I ) ^ { - 1 } ( A + I ) X$ . For each test node $i$ , we calculate its aggregated-feature distance to the training set $V _ { 0 }$ as $\begin{array} { r } { d _ { i } = \operatorname* { m i n } _ { j \in V _ { 0 } } \| Z _ { i } - Z _ { j } \| _ { 2 } } \end{array}$ . Then we sort the test nodes according to this distance and split them into 5 equal-sized subgroups.
+
+Strictly speaking, our theory does not directly apply to GCN and GAT as they are not in the form as we defined in Section 4.2. Moreover, the two-step aggregated feature does not match exactly to the feature aggregation function of SGC and APPNP. Nevertheless, we find that even with such approximations, we are still able to observe the expected descending trend of test accuracy with respect to increasing distance in terms of the two-step aggregated features, on all four GNN models.
+
+Subgroup by geodesic distance. As we discussed in Section 4.3, geodesic distance on the graph may well relate to the aggregated-feature distance. So we also define subgroups based on geodesic distance. We split the subgroups by replacing the aggregated-feature distance $d _ { i }$ of each test node $i$ with the minimum of the geodesic distances from $i$ to each training node on the graph.
+
+Subgroup by node centrality. Lastly, we define subgroups based on 4 types of common node centrality metrics (degree, closeness, betweenness, and PageRank) of the test nodes. We split the subgroups by replacing the aggregated-feature distance $d _ { i }$ of each test node $i$ with the centrality score of $i$ . The purpose of this setup is to show that the common node centrality metrics are not sufficient to capture the monotonic trend of test accuracy.
+
+Experiment setup. Following common GNN experiment setup [38], we randomly select 20 nodes in each class for training, 500 nodes for validation, and 1,000 nodes for testing. Once training is done, we report the test accuracy on subgroups defined by aggregated-feature distance, geodesic distance, and node centrality in Figure 1, 2, and 3 respectively10.
+
+![](images/62daec6597baf0aa2fbaf0628bb7dbf3b33af1d4106321e0808a137b7b93049f.jpg)  
+Figure 3: Test accuracy disparity across subgroups by node centrality. Each figure corresponds to the results of a pair of model and dataset, and each bar cluster corresponds to the subgroups defined by a certain centrality metric. In each cluster, the bars labeled from 1 to 5 represent subgroups with decreasing node centrality. Other settings are the same as Figure 1.
+
+Experiment results. First, as shown in Figure 1, there is a clear trend that the accuracy of a test subgroup decreases as the aggregated-feature distance between the test subgroup and the training set increases. And the trend is consistent for all 4 GNN models on all the datasets we test on (except for APPNP on Cora). This result verifies the existence of accuracy disparity suggested by Theorem 3.
+
+Second, we observe in Figure 2 that there is a similar trend when we split subgroups by the geodesic distance. This suggests that the geodesic distance on the graph can sometimes be used as a simpler indicator in practice for machine learning fairness on graph-structured data. Using such a classical graph metric as an indicator also helps us connect graph-based machine learning to network theory, especially to understandings about social networks, to better analyze fairness issues of machine learning on social networks, where high-stake decisions related to human subjects may be involved.
+
+Furthermore, as shown in Figure 3, there is no clear monotonic trend for test accuracy when we split subgroups by node centrality, except for some particular combinations of GNN model and dataset. Empirically, the common node centrality metrics are not as good as the geodesic distance in terms of capturing the accuracy disparity. This contrast highlights the importance of the insight provided by our analysis: the “distance” to the training set, rather than some graph characteristics of the test nodes alone, is the key predictor of test accuracy.
+
+Finally, it is intriguing that, in both Figure 1 and 2, the test accuracy of MLP (which does not use the graph structure) also decreases as the distance of a subgroup to the training set increases. This result is perhaps not surprising if the subgroups were defined by distance on the original node features, as MLP can be viewed as a special GNN where the feature aggregation function is an identity mapping, so the “aggregated features” for MLP essentially equal to the original features. Our theoretical analysis can then be similarly applied to MLP. The question is why there is also an accuracy disparity w.r.t. the aggregated-feature distance and the geodesic distance. We suspect this is because these datasets present homophily, i.e., original (non-aggregated) features of geodesically closer nodes tend to be more similar. As a result, a subgroup with smaller geodesic distance may also have closer node features to the training set. To verify this hypothesis, we repeat the experiments in Figure 1, but with independent noises added to node features such that they become less homophilious. As in Figure 4, the decreasing pattern of test accuracy across subgroups remains for the 4 GNNs on all datasets; while for MLP, the pattern disappears on Cora and Pubmed and becomes less sharp on Citeseer.
+
+![](images/43a6f9ddd3cd82fb9e4751088ea82fe67ef906373cea7fa9923f126277ed7222.jpg)  
+Figure 4: Test accuracy disparity across subgroups by aggregated-feature distance, experimented with noisy features. The experiment and plot settings are the same as Figure 1, except for the node features are perturbed by independent noises such that they are less homophilious.
+
+![](images/4443e45c660f7f688ed8bc0cbbbdcea18c303fec1825501f557ef97f0856d03f.jpg)  
+Figure 5: Relative ratio between the FPR under biased training node selection and the FPR under uniform training node selection. Each bar in each cluster corresponds to a class (there are 7 classes in total). The red shaded bar indicates the class with high centrality training nodes under the biased setup. Each cluster corresponds to a centrality metric being used for the biased node selection.
+
+# 5.2 Impact of Biased Training Node Selection
+
+In all the previous experiments, we follow the standard GNN training setup where 20 training nodes are uniformly sampled for each class. Next we investigate the impact if the selection of training nodes is biased, verifying our discussions in Section 4.3. We will demonstrate that the node centrality scores of the training nodes play an important role in the learned GNN model.
+
+We choose a “dominant class” and construct a manipulated training set. For each class, we still sample 20 training nodes but in a biased way. For the dominant class, the sample is biased towards nodes of high centrality; while for other classes, the sample is biased towards nodes of low centrality. We evaluate the relative ratio of False Positive Rate (FPR) for each class between the setup using manipulated training set and the setup using uniformly sampled training set.
+
+As shown in Figure 5, compared to MLP, the GNN models have significantly worse FPR for the dominant class when the training nodes are biased. This is because, after feature aggregation, there will be a larger proportion of test nodes that are closer to the training nodes of higher centrality. And the learned GNN model will be heavily biased towards the training labels of these nodes.
+
+# 6 Conclusion
+
+We present a novel PAC-Bayesian analysis for the generalization ability of GNNs on node-level semi-supervised learning tasks. As far as we know, this is the first generalization bound for GNNs for non-IID node-level tasks without strong assumptions on the data generating mechanism. One advantage of our analysis is that it can be applied to arbitrary subgroups of the test nodes, which allows us to investigate an accuracy-disparity style of fairness for GNNs. Both the theoretical and empirical results suggest that there is an accuracy disparity across subgroups of test nodes that have varying distance to the training set, and nodes with larger distance to the training nodes suffer from a lower classification accuracy. In the future, we would like to utilize our theory to analyze the fairness of GNNs on real-world applications and develop principled methods to mitigate the unfairness.
+
+# Acknowledgements
+
+This work was in part supported by the National Science Foundation under grant number 1633370.   
+The authors claim no competing interests.   
+References   
+[1] Chirag Agarwal, Himabindu Lakkaraju, and Marinka Zitnik. Towards a unified framework for fair and stable graph representation learning. CoRR, abs/2102.13186, 2021. URL https: //arxiv.org/abs/2102.13186.   
+[2] Pierre Alquier, James Ridgway, and Nicolas Chopin. On the properties of variational approximations of gibbs posteriors. The Journal of Machine Learning Research, 17(1):8374–8414, 2016.   
+[3] Aseem Baranwal, Kimon Fountoulakis, and Aukosh Jagannath. Graph convolution for semisupervised classification: Improved linear separability and out-of-distribution generalization. arXiv preprint arXiv:2102.06966, 2021.   
+[4] Luc Bégin, Pascal Germain, François Laviolette, and Jean-Francis Roy. Pac-bayesian theory for transductive learning. In Artificial Intelligence and Statistics, pages 105–113. PMLR, 2014.   
+[5] Avishek Joey Bose and William L. Hamilton. Compositional fairness constraints for graph embeddings. CoRR, abs/1905.10674, 2019. URL http://arxiv.org/abs/1905.10674.   
+[6] Maarten Buyl and Tijl De Bie. The kl-divergence between a graph model and its fair i-projection as a fairness regularizer. CoRR, abs/2103.01846, 2021. URL https://arxiv.org/abs/2103. 01846.   
+[7] Enyan Dai and Suhang Wang. Say no to the discrimination: Learning fair graph neural networks with limited sensitive attribute information. In Proceedings of the 14th ACM International Conference on Web Search and Data Mining, WSDM ’21, page 680–688, New York, NY, USA, 2021. Association for Computing Machinery. ISBN 9781450382977. doi: 10.1145/3437963. 3441752. URL https://doi.org/10.1145/3437963.3441752.   
+[8] Yash Deshpande, Subhabrata Sen, Andrea Montanari, and Elchanan Mossel. Contextual stochastic block models. In NeurIPS, 2018.   
+[9] Simon S Du, Kangcheng Hou, Barnabás Póczos, Ruslan Salakhutdinov, Ruosong Wang, and Keyulu Xu. Graph neural tangent kernel: Fusing graph neural networks with graph kernels. arXiv preprint arXiv:1905.13192, 2019.   
+[10] Gintare Karolina Dziugaite, Kyle Hsu, Waseem Gharbieh, Gabriel Arpino, and Daniel Roy. On the role of data in pac-bayes. In International Conference on Artificial Intelligence and Statistics, pages 604–612. PMLR, 2021.   
+[11] Vikas Garg, Stefanie Jegelka, and Tommi Jaakkola. Generalization and representational limits of graph neural networks. In International Conference on Machine Learning, pages 3419–3430. PMLR, 2020.   
+[12] Pascal Germain, Alexandre Lacasse, Francois Laviolette, Mario March, and Jean-Francis Roy. Risk bounds for the majority vote: From a pac-bayesian analysis to a learning algorithm. Journal of Machine Learning Research, 16(26):787–860, 2015.   
+[13] Marco Gori, Gabriele Monfardini, and Franco Scarselli. A new model for learning in graph domains. In Proceedings. 2005 IEEE International Joint Conference on Neural Networks, 2005., volume 2, pages 729–734. IEEE, 2005.   
+[14] Benjamin Guedj. A primer on pac-bayesian learning. arXiv preprint arXiv:1901.05353, 2019.   
+[15] Wassily Hoeffding. Probability inequalities for sums of bounded random variables. In The Collected Works of Wassily Hoeffding, pages 409–426. Springer, 1994.
+
+[16] Yifan Hou, Jian Zhang, James Cheng, Kaili Ma, Richard TB Ma, Hongzhi Chen, and MingChang Yang. Measuring and improving the use of graph information in graph neural networks. In International Conference on Learning Representations, 2019.
+
+[17] Weihua Hu, Matthias Fey, Marinka Zitnik, Yuxiao Dong, Hongyu Ren, Bowen Liu, Michele Catasta, and Jure Leskovec. Open graph benchmark: Datasets for machine learning on graphs. arXiv preprint arXiv:2005.00687, 2020.
+
+[18] Wengong Jin, Regina Barzilay, and Tommi Jaakkola. Junction tree variational autoencoder for molecular graph generation. In International Conference on Machine Learning, pages 2323–2332. PMLR, 2018.
+
+[19] Ahmad Khajehnejad, Moein Khajehnejad, Mahmoudreza Babaei, Krishna P. Gummadi, Adrian Weller, and Baharan Mirzasoleiman. Crosswalk: Fairness-enhanced node representation learning, 2021.
+
+[20] Thomas N Kipf and Max Welling. Semi-supervised classification with graph convolutional networks. arXiv preprint arXiv:1609.02907, 2016.
+
+[21] Johannes Klicpera, Aleksandar Bojchevski, and Stephan Günnemann. Predict then propagate: Graph neural networks meet personalized pagerank. In ICLR, 2019.
+
+[22] Charlotte Laclau, Ievgen Redko, Manvi Choudhary, and Christine Largeron. All of the fairness for edge prediction with optimal transport. CoRR, abs/2010.16326, 2020. URL https: //arxiv.org/abs/2010.16326.
+
+[23] John Langford and John Shawe-Taylor. Pac-bayes & margins. Advances in neural information processing systems, pages 439–446, 2003.
+
+[24] Qimai Li, Zhichao Han, and Xiao-Ming Wu. Deeper insights into graph convolutional networks for semi-supervised learning. In Proceedings of the AAAI Conference on Artificial Intelligence, volume 32, 2018.
+
+[25] Renjie Liao, Raquel Urtasun, and Richard Zemel. A pac-bayesian approach to generalization bounds for graph neural networks. In ICLR, 2021.
+
+[26] Yao Ma, Xiaorui Liu, Neil Shah, and Jiliang Tang. Is homophily a necessity for graph neural networks? arXiv preprint arXiv:2106.06134, 2021.
+
+[27] David McAllester. Simplified pac-bayesian margin bounds. In Learning theory and Kernel machines, pages 203–215. Springer, 2003.
+
+[28] Miller McPherson, Lynn Smith-Lovin, and James M Cook. Birds of a feather: Homophily in social networks. Annual review of sociology, 27(1):415–444, 2001.
+
+[29] Federico Monti, Davide Boscaini, Jonathan Masci, Emanuele Rodola, Jan Svoboda, and Michael M Bronstein. Geometric deep learning on graphs and manifolds using mixture model cnns. In Proceedings of the IEEE conference on computer vision and pattern recognition, pages 5115–5124, 2017.
+
+[30] Behnam Neyshabur, Srinadh Bhojanapalli, and Nathan Srebro. A pac-bayesian approach to spectrally-normalized margin bounds for neural networks. 2018.
+
+[31] Hoang NT and Takanori Maehara. Revisiting graph neural networks: All we have is low-pass filters. arXiv preprint arXiv:1905.09550, 2019.
+
+[32] Tahleen Rahman, Bartlomiej Surma, Michael Backes, and Yang Zhang. Fairwalk: Towards fair graph embedding. In Proceedings of the Twenty-Eighth International Joint Conference on Artificial Intelligence, IJCAI-19, pages 3289–3295. International Joint Conferences on Artificial Intelligence Organization, 7 2019. doi: 10.24963/ijcai.2019/456. URL https: //doi.org/10.24963/ijcai.2019/456.
+
+[33] Omar Rivasplata. Subgaussian random variables: An expository note. Internet publication, PDF, 2012.
+
+[34] Ryoma Sato. A survey on the expressive power of graph neural networks. arXiv preprint arXiv:2003.04078, 2020.   
+[35] Franco Scarselli, Marco Gori, Ah Chung Tsoi, Markus Hagenbuchner, and Gabriele Monfardini. The graph neural network model. IEEE transactions on neural networks, 20(1):61–80, 2008.   
+[36] Franco Scarselli, Ah Chung Tsoi, and Markus Hagenbuchner. The vapnik–chervonenkis dimension of graph and recursive neural networks. Neural Networks, 108:248–259, 2018.   
+[37] Prithviraj Sen, Galileo Namata, Mustafa Bilgic, Lise Getoor, Brian Galligher, and Tina EliassiRad. Collective classification in network data. AI magazine, 29(3):93–93, 2008.   
+[38] Oleksandr Shchur, Maximilian Mumme, Aleksandar Bojchevski, and Stephan Günnemann. Pitfalls of graph neural network evaluation. CoRR, abs/1811.05868, 2018. URL http:// arxiv.org/abs/1811.05868.   
+[39] Indro Spinelli, Simone Scardapane, Amir Hussain, and Aurelio Uncini. Biased edge dropout for enhancing fairness in graph representation learning, 2021.   
+[40] Joel A Tropp. An introduction to matrix concentration inequalities. Foundations and Trends in Machine Learning, 8(1-2):1–230, 2015.   
+[41] Petar Velickovi ˇ c, Guillem Cucurull, Arantxa Casanova, Adriana Romero, Pietro Liò, and Yoshua ´ Bengio. Graph attention networks. In ICLR, 2018.   
+[42] Saurabh Verma and Zhi-Li Zhang. Stability and generalization of graph convolutional neural networks. In Proceedings of the 25th ACM SIGKDD International Conference on Knowledge Discovery & Data Mining, pages 1539–1548, 2019.   
+[43] Minjie Wang, Da Zheng, Zihao Ye, Quan Gan, Mufei Li, Xiang Song, Jinjing Zhou, Chao Ma, Lingfan Yu, Yu Gai, et al. Deep graph library: A graph-centric, highly-performant package for graph neural networks. arXiv preprint arXiv:1909.01315, 2019.   
+[44] Duncan J Watts and Steven H Strogatz. Collective dynamics of ‘small-world’networks. nature, 393(6684):440–442, 1998.   
+[45] Felix Wu, Amauri Souza, Tianyi Zhang, Christopher Fifty, Tao Yu, and Kilian Weinberger. Simplifying graph convolutional networks. In International conference on machine learning, pages 6861–6871. PMLR, 2019.   
+[46] Zonghan Wu, Shirui Pan, Fengwen Chen, Guodong Long, Chengqi Zhang, and S Yu Philip. A comprehensive survey on graph neural networks. IEEE transactions on neural networks and learning systems, 2020.   
+[47] Zhilin Yang, William Cohen, and Ruslan Salakhudinov. Revisiting semi-supervised learning with graph embeddings. In International conference on machine learning, pages 40–48. PMLR, 2016.   
+[48] Rex Ying, Ruining He, Kaifeng Chen, Pong Eksombatchai, William L Hamilton, and Jure Leskovec. Graph convolutional neural networks for web-scale recommender systems. In Proceedings of the 24th ACM SIGKDD International Conference on Knowledge Discovery & Data Mining, pages 974–983, 2018.   
+[49] Bing Yu, Haoteng Yin, and Zhanxing Zhu. Spatio-temporal graph convolutional networks: a deep learning framework for traffic forecasting. In Proceedings of the 27th International Joint Conference on Artificial Intelligence, pages 3634–3640, 2018.   
+[50] Ziqian Zeng, Rashidul Islam, Kamrun Naher Keya, James R. Foulds, Yangqiu Song, and Shimei Pan. Fair representation learning for heterogeneous information networks. CoRR, abs/2104.08769, 2021. URL https://arxiv.org/abs/2104.08769.   
+[51] Wenda Zhou, Victor Veitch, Morgane Austern, Ryan P Adams, and Peter Orbanz. Nonvacuous generalization bounds at the imagenet scale: a pac-bayesian compression approach. In International Conference on Learning Representations, 2018.

parse/train/68B1ezcffDc/68B1ezcffDc_content_list.json

@@ -0,0 +1,1631 @@
+[
+    {
+        "type": "text",
+        "text": "Subgroup Generalization and Fairness of Graph Neural Networks ",
+        "text_level": 1,
+        "bbox": [
+            207,
+            122,
+            792,
+            171
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Jiaqi Ma ∗† jiaqima@umich.edu ",
+        "bbox": [
+            230,
+            220,
+            375,
+            250
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Junwei Deng ∗† junweid@umich.edu ",
+        "bbox": [
+            437,
+            222,
+            586,
+            250
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Qiaozhu Mei∗‡ qmei@umich.edu ",
+        "bbox": [
+            647,
+            222,
+            769,
+            250
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Abstract ",
+        "text_level": 1,
+        "bbox": [
+            462,
+            286,
+            535,
+            301
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Despite enormous successful applications of graph neural networks (GNNs), theoretical understanding of their generalization ability, especially for node-level tasks where data are not independent and identically-distributed (IID), has been sparse. The theoretical investigation of the generalization performance is beneficial for understanding fundamental issues (such as fairness) of GNN models and designing better learning methods. In this paper, we present a novel PAC-Bayesian analysis for GNNs under a non-IID semi-supervised learning setup. Moreover, we analyze the generalization performances on different subgroups of unlabeled nodes, which allows us to further study an accuracy-(dis)parity-style (un)fairness of GNNs from a theoretical perspective. Under reasonable assumptions, we demonstrate that the distance between a test subgroup and the training set can be a key factor affecting the GNN performance on that subgroup, which calls special attention to the training node selection for fair learning. Experiments across multiple GNN models and datasets support our theoretical results4. ",
+        "bbox": [
+            233,
+            318,
+            766,
+            511
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 Introduction ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            537,
+            310,
+            555
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Graph Neural Networks (GNNs) [13, 35, 20] are a family of machine learning models that can be used to model non-Euclidean data as well as inter-related samples in a flexible way. In recent years, there have been enormous successful applications of GNNs in various areas, such as drug discovery [18], computer vision [29], transportation forecasting [49], recommender systems [48], etc. Depending on the type of prediction target, the application tasks can be roughly categorized into node-level, edge-level, subgraph-level, and graph-level tasks [46]. ",
+        "bbox": [
+            174,
+            570,
+            825,
+            654
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "In contrast to the marked empirical success, theoretical understanding of the generalization ability of GNNs has been rather limited. Among the existing literature, some studies [9, 11, 25] focus on the analysis of graph-level tasks where each sample is an entire graph and the samples of graphs are IID. A very limited number of studies [36, 42] explore GNN generalization for node-level tasks but they assume the nodes (and their associated neighborhoods) are IID samples, which does not align with the commonly seen graph-based semi-supervised learning setups. Baranwal et al. [3] investigate GNN generalization without IID assumptions but under a specific data generating mechanism. ",
+        "bbox": [
+            174,
+            660,
+            825,
+            757
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "In this work, our first contribution is to provide a novel PAC-Bayesian analysis for the generalization ability of GNNs on node-level tasks with non-IID assumptions. In particular, we assume the node features are fixed and the node labels are independently sampled from distributions conditioned on the node features. We also assume the training set and the test set can be chosen as arbitrary subsets of nodes on the graph. We first prove two general PAC-Bayesian generalization bounds (Theorem 1 and Theorem 2) under this non-IID setup. Subsequently, we derive a generalization bound for GNN (Theorem 3) in terms of characteristics of the GNN models and the node features. ",
+        "bbox": [
+            176,
+            763,
+            823,
+            833
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            92,
+            823,
+            119
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Notably, the generalization bound for GNN is influenced by the distance between the test nodes and the training nodes in terms of their aggregated node features. This suggests that, given a fixed training set, test nodes that are “far away” from all the training nodes may suffer from larger generalization errors. Based on this analysis, our second contribution is the discovering of a type of unfairness that arises from theoretically predictable accuracy disparity across some subgroups of test nodes. We further conduct a empirical study that investigates the prediction accuracy of four popular GNN models on different subgroups of test nodes. The results on multiple benchmark datasets indicate that there is indeed a significant disparity in test accuracy among these subgroups. ",
+        "bbox": [
+            173,
+            126,
+            825,
+            237
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "We summarize the contributions of this work as follows: ",
+        "bbox": [
+            173,
+            242,
+            544,
+            257
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "(1) We establish a novel PAC-Bayesian analysis for graph-based semi-supervised learning with non-IID assumptions.   \n(2) Under this setup, we derive a generalization bound for GNNs that can be applied to an arbitrary subgroup of test nodes.   \n(3) As an implication of the generalization bound, we predict that there would be an unfairness of GNN predictions that arises from accuracy disparity across subgroups of test nodes.   \n(4) We empirically verify the existence of accuracy disparity of popular GNN models on multiple benchmark datasets, as predicted by our theoretical analysis. ",
+        "bbox": [
+            205,
+            267,
+            825,
+            393
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2 Related Work ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            411,
+            321,
+            429
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2.1 Generalization of Graph Neural Networks ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            443,
+            508,
+            458
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "The majority of existing literature that aims to develop theoretical understandings of GNNs have focused on the expressive power of GNNs (see Sato [34] for a survey along this line), while the number of studies trying to understand the generalizability of GNNs is rather limited. Among them, some [9, 11, 25] focus on graph-level tasks, the analyses of which cannot be easily applied to node-level tasks. As far as we know, Scarselli et al. [36], Verma and Zhang [42], and Baranwal et al. [3] are the only existing studies investigating the generalization of GNNs on node-level tasks, even though node-level tasks are more common in reality. Scarselli et al. [36] present an upper bound of the VC-dimension of GNNs; Verma and Zhang [42] derive a stability-based generalization bound for a single-layer GCN [20] model. Yet, both Scarselli et al. [36] and Verma and Zhang [42] (implicitly) assume that the training nodes are IID samples from a certain distribution, which does not align with the common practice of node-level semi-supervised learning. Baranwal et al. [3] investigate the generalization of graph convolution under a specific data generating mechanism (i.e., the contextual stochastic block model [8]). Our work presents the first generalization analysis of GNNs for non-IID node-level tasks without strong assumptions on the data generating mechanism. ",
+        "bbox": [
+            174,
+            468,
+            826,
+            661
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2.2 Fairness of Machine Learning on Graphs ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            678,
+            500,
+            693
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "The fairness issues of machine learning on graphs start to receive research attention recently. Following conventional machine learning fairness literature, the majority of previous work along this line [1, 5–7, 22, 32, 39, 50] concerns about fairness with respect to a given sensitive attribute, such as gender or race, which defines protected groups. In practice, the fairness issues of learning on graphs are much more complicated due to the asymmetric nature of the graph-structured data. However, only a few studies [19] investigate the unfairness caused by the graph structure without knowing a sensitive feature. Moreover, in a node-level semi-supervised learning task, the non-IID sampling of training nodes brings additional uncertainty to the fairness of the learned models. This work is the first to present a learning theoretic analysis under this setup, which in turn suggests how the graph structure and the selection of training nodes may influence the fairness of machine learning on graphs. ",
+        "bbox": [
+            174,
+            703,
+            825,
+            842
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2.3 PAC-Bayesian Analysis ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            857,
+            375,
+            872
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "PAC-Bayesian analysis [27] has become one of the most powerful theoretical framework to analyze the generalization ability of machine learning models. We will briefly introduce the background in ",
+        "bbox": [
+            174,
+            882,
+            821,
+            911
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Section 3.2, and refer the readers to a recent tutorial [14] for a systematic overview of PAC-Bayesian analysis. We note that Liao et al. [25] recently present a PAC-Bayesian generalization bound for GNNs on IID graph-level tasks. Both Liao et al. [25] and this work utilize results from Neyshabur et al. [30], a PAC-Bayesian analysis for ReLU-activated neural networks, in part of our proofs. Compared to Neyshabur et al. [30], the key contribution of Liao et al. [25] is the derivation of perturbation bounds of two types of GNN architectures; while the key contribution of this work is the novel analysis under the setup of non-IID node-level tasks. There is also an existing work of PAC-Bayesian analysis for transductive semi-supervised learning [4]. But it is different from our problem setup and, in particular, it cannot be used to analyze the generalization on subgroups. ",
+        "bbox": [
+            173,
+            90,
+            826,
+            217
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3 Preliminaries ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            234,
+            318,
+            252
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "In this section, we first formulate the problem of node-level semi-supervised learning. We also provide a brief introduction of the PAC-Bayesian framework. ",
+        "bbox": [
+            174,
+            265,
+            823,
+            294
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3.1 The Problem Formulation and Notations ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            309,
+            496,
+            324
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Semi-supervised node classification. Let $G = ( V , E ) \\in \\mathcal G _ { N }$ be an undirected graph, with $V = \\{ 1 , \\bar { 2 } , \\dots , N \\}$ being the set of $N$ nodes and $E \\subseteq V \\times V$ being the set of edges. And $\\mathcal { G } _ { N }$ is the space of all undirected graphs with $N$ nodes. The nodes are associated with node features $\\boldsymbol { X } \\in \\mathbb { R } ^ { \\hat { \\boldsymbol { N } } \\times \\boldsymbol { D } }$ and node labels $y \\in \\{ 1 , 2 , \\ldots , K \\} ^ { N }$ . ",
+        "bbox": [
+            174,
+            335,
+            825,
+            393
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "In this work, we focus on the transductive node classification setting [47], where the node features $X$ and the graph $G$ are observed prior to learning, and every quantity of interest in the analysis will be conditioned on $X$ and $G$ . Without loss of generality, we treat $X$ and $G$ as fixed throughout our analysis, and the randomness comes from the labels $y$ . In particular, we assume that for each node $i \\in V$ , its label $y _ { i }$ is generated from an unknown conditional distribution $\\mathrm { P r } ( y _ { i } \\mid Z _ { i } )$ , where $Z = g ( X , G )$ and $g : \\mathbb { R } ^ { N \\times D } \\times \\mathcal { G } _ { N }  \\mathbb { R } ^ { N \\times D ^ { \\prime } }$ is an aggregation function that aggregates the features over (multi-hop) local neighborhoods5. We also assume that the node labels are generated independently conditional on their respective aggregated features $Z _ { i }$ ’s. ",
+        "bbox": [
+            173,
+            397,
+            825,
+            513
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Given a small set of the labeled nodes, $V _ { 0 } \\subseteq V$ , the task of node-level semi-supervised learning is to learn a classifier $h : \\mathbb { R } ^ { N \\times D } \\times \\mathcal { G } _ { N }  \\mathbb { R } ^ { N \\times K }$ from a function family $\\mathcal { H }$ and perform it on the remaining unlabeled nodes. Given a classifier $h$ , the classification for a node $i$ is obtained by ",
+        "bbox": [
+            174,
+            517,
+            825,
+            560
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/d52d86c3dd14f3a17979157016e249aa6cf3d0cc7c78d4b213a4be01cb97b120.jpg",
+        "text": "$$\n\\hat { y } _ { i } = \\underset { k \\in \\{ 1 , \\dots , K \\} } { \\mathrm { a r g m a x } } h _ { i } ( X , G ) [ k ] ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            401,
+            564,
+            593,
+            592
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "where $h _ { i } ( X , G )$ is the $i$ -th row of $h ( X , G )$ and $h _ { i } ( X , G ) [ k ]$ refers to the $k$ -th element of $h _ { i } ( X , G )$ . ",
+        "bbox": [
+            174,
+            597,
+            820,
+            613
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Subgroups. In Section 4, we will present an analysis of the GNN generalization performance on any subgroup of the set of unlabeled nodes, $V \\setminus \\bar { V _ { 0 } }$ . Note that the analysis on any subgroup is a stronger result than that on the entire unlabeled set, as any set is a subset of itself. Later we will show that the analysis on subgroups (rather than on the entire set) further allows us to investigate the accuracy disparity across subgroups. We denote a collection of subgroups of interest as $V _ { 1 } , \\bar { V } _ { 2 } , \\ldots , V _ { M } \\subseteq \\bar { V } \\setminus \\bar { V } _ { 0 }$ . In practice, a subgroup can be defined based on an attribute of the nodes (e.g., a gender group), certain graph-based properties, or an arbitrary partition of the nodes. We also define the size of each subgroup as $N _ { m } : = | V _ { m } | , m = 0 , \\ldots , M$ . ",
+        "bbox": [
+            173,
+            619,
+            825,
+            732
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Margin loss on each subgroup. Now we can define the empirical and expected margin loss of any classifier $h \\in \\mathcal H$ on each subgroup $V _ { m } , m = 0 , 1 , \\dots , M$ . Given a sample of observed node labels $y _ { i }$ ’s, the empirical margin loss of $h$ on $V _ { m }$ for a margin $\\gamma \\geq 0$ is defined as ",
+        "bbox": [
+            174,
+            738,
+            825,
+            781
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/c45f73335bd99a9af2447ab8e02052461a0b4c5342b50f207e76c052c8f2b707.jpg",
+        "text": "$$\n\\widehat { \\mathcal { L } } _ { m } ^ { \\gamma } ( h ) : = \\frac { 1 } { N _ { m } } \\sum _ { i \\in V _ { m } } \\mathbb { 1 } \\left[ h _ { i } ( X , G ) [ y _ { i } ] \\leq \\gamma + \\operatorname* { m a x } _ { k \\neq y _ { i } } h _ { i } ( X , G ) [ k ] \\right] ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            284,
+            785,
+            710,
+            824
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "where $\\mathbb { 1 } \\left[ \\cdot \\right]$ is the indicator function. The expected margin loss is the expectation of Eq. (1), i.e., ",
+        "bbox": [
+            171,
+            829,
+            800,
+            844
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/f254ad428adeaf5a7c0f4303e4ddcc081b96723c54c44d9d8699c10b3aef8430.jpg",
+        "text": "$$\n\\begin{array} { r } { \\mathcal { L } _ { m } ^ { \\gamma } ( h ) : = \\mathbb { E } _ { y _ { i } \\sim \\operatorname* { P r } ( \\mathbf { y } \\mid Z _ { i } ) , i \\in V _ { m } } \\widehat { \\mathcal { L } } _ { m } ^ { \\gamma } ( h ) . } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            377,
+            848,
+            620,
+            869
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "To simplify the notation, we define $y ^ { m } : = \\{ y _ { i } \\} _ { i \\in V _ { m } }$ , $\\forall m = 0 , \\ldots , M$ , so that Eq. (2) can be written as $\\bar { \\mathcal { L } } _ { m } ^ { \\gamma } \\bar { ( } h ) \\bar { = } \\mathbb { E } _ { y ^ { m } } \\widehat { \\mathcal { L } } _ { m } ^ { \\gamma } ( h )$ . We note that the classification risk and empirical risk of $h$ on $V _ { m }$ are respectively equal to $\\mathcal { L } _ { m } ^ { 0 } ( h )$ and $\\widehat { \\mathcal { L } } _ { m } ^ { 0 } ( h )$ . ",
+        "bbox": [
+            174,
+            90,
+            825,
+            141
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3.2 The PAC-Bayesian Framework ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            159,
+            429,
+            174
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "The PAC-Bayesian framework [27] is an approach to analyze the generalization ability of a stochastic predictor drawn from a distribution $Q$ over the predictor family $\\mathcal { H }$ that is learned from the training data. For any stochastic classifier distribution $Q$ and $m = 0 , \\ldots , M$ , slightly overloading the notation, we denote the empirical margin loss of $Q$ on $V _ { m }$ as ${ \\widehat { \\mathcal { L } } } _ { m } ^ { \\gamma } ( Q )$ , and the corresponding expected margin loss as $\\mathcal { L } _ { m } ^ { \\gamma } ( Q )$ . And they are given by ",
+        "bbox": [
+            173,
+            184,
+            826,
+            258
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/64432050e29f91da93f8a34f0f0e7ba84fa71525e03ebb4992dde54dacfdb228.jpg",
+        "text": "$$\n\\widehat { \\mathscr { L } } _ { m } ^ { \\gamma } ( Q ) : = \\mathbb { E } _ { h \\sim Q } \\widehat { \\mathscr { L } } _ { m } ^ { \\gamma } ( h ) , \\quad \\mathscr { L } _ { m } ^ { \\gamma } ( Q ) : = \\mathbb { E } _ { h \\sim Q } \\mathscr { L } _ { m } ^ { \\gamma } ( h ) .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            321,
+            267,
+            676,
+            287
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "In general, a PAC-Bayesian analysis aims to bound the generalization gap between $\\mathcal { L } _ { m } ^ { \\gamma } ( Q )$ and $\\widehat { \\mathcal { L } } _ { m } ^ { \\gamma } ( Q )$ . The analysis is usually done by first proving that, for any “prior” distribution6 $P$ over $\\mathcal { H }$ that is independent of the training data, the generalization gap can be controlled by the discrepancy between $P$ and $Q$ ; the analysis is then followed by careful choices of $P$ to get concrete upper bounds of the generalization gap. While the PAC-Bayesian framework is built on top of stochastic predictors, there exist standard techniques [23] that can be used to derive generalization bounds for deterministic predictors from PAC-Bayesian bounds. ",
+        "bbox": [
+            173,
+            295,
+            826,
+            397
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Finally, we denote the Kullback-Leibler $( K L )$ divergence as $\\begin{array} { r } { D _ { \\mathrm { K L } } ( Q \\| P ) : = \\int \\ln \\frac { d Q } { d P } d Q } \\end{array}$ , which will be used in the following analysis. ",
+        "bbox": [
+            171,
+            401,
+            823,
+            434
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "4 The Generalization Bound and Its Implications for Fairness ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            454,
+            702,
+            473
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "As we mentioned in Section 2.3, existing PAC-Bayesian analyses cannot be directly applied to the nonIID semi-supervised learning setup where we care about the generalization (and its disparity) across different subgroups of the unlabeled samples. In this section, we first present general PAC-Bayesian theorems for subgroup generalization under our problem setup; then we derive a generalization bound for GNNs and discuss fairness implications of the bound. ",
+        "bbox": [
+            173,
+            487,
+            826,
+            558
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "4.1 General PAC-Bayesian Theorems for Subgroup Generalization ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            577,
+            650,
+            592
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Stochastic classifier bound. We first present the general PAC-Bayesian theorem (Theorem 1) for subgroup generalization of stochastic classifiers. The generalization bound depends on a notion of expected loss discrepancy between two subgroups as defined below. ",
+        "bbox": [
+            174,
+            604,
+            825,
+            647
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Definition 1 (Expected Loss Discrepancy). Given a distribution $P$ over $\\mathcal { H }$ , for any $\\lambda > 0$ and $\\gamma \\geq 0$ for any two subgroups $V _ { m }$ and $V _ { m ^ { \\prime } }$ $0 \\leq m , m ^ { \\prime } \\leq M )$ , define the expected loss discrepancy between $V _ { m }$ and $V _ { 0 }$ with respect to $( P , \\gamma , \\lambda )$ as ",
+        "bbox": [
+            173,
+            652,
+            823,
+            695
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/251f0e935db798647347016b52c2f221e14f5acede631403884d2ebc9c3d49a8.jpg",
+        "text": "$$\nD _ { m , m ^ { \\prime } } ^ { \\gamma } ( P ; \\lambda ) : = \\ln \\mathbb { E } _ { h \\sim P } e ^ { \\lambda \\left( \\mathcal { L } _ { m } ^ { \\gamma / 2 } ( h ) - \\mathcal { L } _ { m ^ { \\prime } } ^ { \\gamma } ( h ) \\right) } ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            346,
+            704,
+            650,
+            728
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "where $\\mathcal { L } _ { m } ^ { \\gamma / 2 } ( h )$ and $\\mathcal { L } _ { m ^ { \\prime } } ^ { \\gamma } ( h )$ follow the definition of Eq. (2). ",
+        "bbox": [
+            173,
+            739,
+            562,
+            757
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Intuitively, $D _ { m , m ^ { \\prime } } ^ { \\gamma } ( P ; \\lambda )$ captures the difference of the expected loss between $V _ { m }$ and $V _ { m ^ { \\prime } }$ in an average sense (over $P$ ). Note that $D _ { m , m ^ { \\prime } } ^ { \\gamma } ( P ; \\lambda )$ is asymmetric in terms of $V _ { m }$ and $V _ { m ^ { \\prime } }$ , and can be negative if the loss on $V _ { m }$ is mostly smaller than that on $V _ { m ^ { \\prime } }$ . ",
+        "bbox": [
+            173,
+            767,
+            825,
+            815
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "For stochastic classifiers, we have the following Theorem 1. Proof can be found in Appendix A.1. ",
+        "bbox": [
+            171,
+            820,
+            810,
+            837
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Theorem 1 (Subgroup Generalization of Stochastic Classifiers). For any $0 < m \\le M$ , for any $\\lambda > 0$ and $\\gamma \\geq 0 _ { ; }$ , for any “prior” distribution $P$ on $\\mathcal { H }$ that is independent of the training data on $V _ { 0 }$ , with ",
+        "bbox": [
+            174,
+            840,
+            825,
+            869
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "probability at least $1 - \\delta$ over the sample of $y ^ { 0 }$ , for any $Q$ on $\\mathcal { H }$ , we have7 ",
+        "bbox": [
+            171,
+            90,
+            660,
+            107
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/2a3892c9cc6f527d2495e5054a91c91432242f78f5801a66c57e9ae8b800263b.jpg",
+        "text": "$$\n\\mathcal { L } _ { m } ^ { \\gamma / 2 } ( Q ) \\leq \\widehat { \\mathcal { L } } _ { 0 } ^ { \\gamma } ( Q ) + \\frac { 1 } { \\lambda } \\left( D _ { \\mathrm { K L } } ( Q \\| P ) + \\ln \\frac { 1 } { \\delta } + \\frac { \\lambda ^ { 2 } } { 4 N _ { 0 } } + D _ { m , 0 } ^ { \\gamma } ( P ; \\lambda ) \\right) .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            261,
+            112,
+            736,
+            147
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Theorem 1 can be viewed as an adaptation of a result by Alquier et al. [2] from the IID supervised setting to our non-IID semi-supervised setting. The terms $\\begin{array} { r } { D _ { \\mathrm { K L } } ( Q \\| P ) , \\mathrm { l n } \\frac { 2 } { \\delta } } \\end{array}$ , and $\\frac { \\lambda ^ { 2 } } { 4 N _ { 0 } }$ are commonly seen in PAC-Bayesian analysis for IID supervised setting. In particular, when setting $\\lambda = \\Theta ( \\sqrt { N _ { 0 } } )$ , $\\begin{array} { r } { \\frac { 1 } { \\lambda } \\left( \\ln \\frac { 2 } { \\delta } + \\frac { \\lambda ^ { 2 } } { 4 N _ { 0 } } \\right) } \\end{array}$ vanishes as the training size $N _ { 0 }$ grows. The divergence between $Q$ and $P$ , $D _ { \\mathrm { K L } } ( Q \\| P )$ , is usually considered as a measurement of the model complexity [14]. And there will be a trade-off between the training loss, $\\widehat { \\mathcal { L } } _ { 0 } ^ { \\gamma } ( Q )$ , and the complexity (how far can the learned “posterior” $Q$ go from the “prior” $P$ ). ",
+        "bbox": [
+            173,
+            157,
+            825,
+            275
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Uniquely for the non-IID semi-supervised setting, there is an extra term $D _ { m , 0 } ^ { \\gamma } ( P ; \\lambda )$ , which is the expected loss discrepancy between the target test subgroup $V _ { m }$ and the training set $V _ { 0 }$ . Note that this quantity is independent of the training labels $y ^ { 0 }$ . Not surprisingly, it is difficult to give generalization guarantees if the expected loss on $V _ { m }$ is much larger than that on $V _ { 0 }$ for any stochastic classifier $P$ independent of training data. We have to make some assumptions about the relationship between $V _ { m }$ and $V _ { 0 }$ to obtain a meaningful bound on $\\begin{array} { r } { \\frac { 1 } { \\lambda } D _ { m , 0 } ^ { \\gamma } ( P ; \\lambda ) } \\end{array}$ , which we will discuss in details in Section 4.2. ",
+        "bbox": [
+            173,
+            279,
+            825,
+            366
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Deterministic classifier bound. Utilizing standard techniques in PAC-Bayesian analysis [23, 27, 30], we can convert the bound for stochastic classifiers in Theorem 1 to a bound for deterministic classifiers as stated in Theorem 2 below (see Appendix A.2 for the proof). ",
+        "bbox": [
+            173,
+            371,
+            825,
+            414
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Theorem 2 (Subgroup Generalization of Deterministic Classifiers). Let $\\tilde { h }$ be any classifier in $\\mathcal { H }$ . For any $0 < m \\le M$ , for any $\\lambda > 0$ and $\\gamma \\geq 0$ , for any “prior” distribution $P$ on $\\mathcal { H }$ that is independent of the training data on $V _ { 0 }$ , with probability at least $1 - \\delta$ over the sample of $y ^ { 0 }$ , for any $Q$ on $\\mathcal { H }$ such that $\\begin{array} { r } { \\operatorname* { P r } _ { h \\sim Q } \\left( \\operatorname* { m a x } _ { i \\in V _ { 0 } \\cup V _ { m } } \\| h _ { i } ( X , G ) - \\tilde { h } _ { i } ( X , G ) \\| _ { \\infty } < \\frac { \\gamma } { 8 } \\right) > \\frac { 1 } { 2 } } \\end{array}$ , we have ",
+        "bbox": [
+            173,
+            419,
+            825,
+            484
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/58d1623d69b4b9c4aa8c896e24f0f8bf9d53658c4a937877d93d8e0b35711ab4.jpg",
+        "text": "$$\n\\mathcal { L } _ { m } ^ { 0 } ( \\widetilde { h } ) \\le \\widehat { \\mathcal { L } } _ { 0 } ^ { \\gamma } ( \\widetilde { h } ) + \\frac { 1 } { \\lambda } \\left( 2 ( D _ { \\mathrm { K L } } ( Q \\| P ) + 1 ) + \\ln \\frac { 1 } { \\delta } + \\frac { \\lambda ^ { 2 } } { 4 N _ { 0 } } + D _ { m , 0 } ^ { \\gamma / 2 } ( P ; \\lambda ) \\right) .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            245,
+            491,
+            753,
+            526
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Theorem 1 and 2 are not specific to GNNs and hold for any (respectively stochastic and deterministic) classifier under the semi-supervised setup. In Section 4.2, we will apply Theorem 2 to obtain a subgroup generalization bound that explicitly depends on the characteristics of GNNs and the data. ",
+        "bbox": [
+            173,
+            537,
+            825,
+            582
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "4.2 Subgroup Generalization Bound for Graph Neural Networks ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            595,
+            637,
+            612
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "The GNN model. We consider GNNs where the node feature aggregation step and the prediction step are separate. In particular, we assume the GNN classifier takes the form of $h _ { i } ( X , G ) ~ =$ $f ( \\bar { g } _ { i } ( X , G ) ; W _ { 1 } , W _ { 2 } , \\underline { { { \\cdot \\cdot \\cdot } } } , W _ { L } )$ , where $g$ is an aggregation function as we described in Section 3.1 and $f$ is a ReLU-activated $L$ -layer Multi-Layer Perceptron (MLP) with $W _ { 1 } , \\dots , W _ { L }$ as parameters for each layer8. Denote the largest width of all the hidden layers as $b$ . ",
+        "bbox": [
+            173,
+            623,
+            825,
+            694
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Remark 1. There is a technical restriction on the possible choice of the aggregation function $g$ . For the following derivation of the generalization bound (6) to be valid, we need the condition that the node labels $y _ { i }$ ’s are independent conditional on their aggregated features $g _ { i } ( X , G )$ ’s, as introduced in the problem formulation in Section 3.1. However, we also note that this condition tends to hold when the aggregated features $g _ { i } ( X , G )$ ’s contain rich information about the labels. ",
+        "bbox": [
+            173,
+            696,
+            825,
+            768
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Upper-bounding $D _ { m , 0 } ^ { \\gamma } ( P ; \\lambda )$ . To derive the generalization guarantee, we need to upper-bound the expected loss discrepancy $D _ { m , 0 } ^ { \\gamma } ( P ; \\lambda )$ . It turns out that we have to make some assumptions on the data in order to get a meaningful upper bound. ",
+        "bbox": [
+            174,
+            780,
+            825,
+            825
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "So far we have not had any restrictions on the conditional label distributions $\\operatorname* { P r } ( y _ { i } = k \\mid g _ { i } ( X , G ) )$ If the label distributions on $V \\backslash V _ { 0 }$ can be arbitrarily different from those on $V _ { 0 }$ , the generalization can be arbitrarily poor. We therefore assume that the label distributions conditional on aggregated features are smooth (Assumption 1). ",
+        "bbox": [
+            173,
+            830,
+            823,
+            859
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            171,
+            90,
+            823,
+            121
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Assumption 1 (Smoothness of Data Distribution). Assume there exist $c$ -Lipschitz continuous functions $\\mathring { \\eta _ { 1 } } , \\eta _ { 2 } , \\dotsc , \\eta _ { K } : \\mathbb { R } ^ { D ^ { \\prime } }  [ 0 , 1 ]$ , such that, for any node $i \\in V$ , ",
+        "bbox": [
+            173,
+            122,
+            825,
+            154
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "equation",
+        "img_path": "images/de88584bc801a4d743515e4152923b1944acce172e82245b43a3c765853a4b39.jpg",
+        "text": "$$\n\\operatorname* { P r } ( y _ { i } = k \\mid g _ { i } ( X , G ) ) = \\eta _ { k } ( g _ { i } ( X , G ) ) , \\forall k = 1 , \\ldots , K .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            313,
+            157,
+            684,
+            175
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "We also need to characterize the relationship between a target test subgroup $V _ { m }$ and the training set $V _ { 0 }$ . For this purpose, we define the distance from $V _ { m }$ to $V _ { 0 }$ and the concept of near set below. ",
+        "bbox": [
+            173,
+            185,
+            825,
+            214
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Definition 2 (Distance To Training Set and Near Set). For each $0 < m \\le M$ , define the distance from the subgroup $V _ { m }$ to the training set $V _ { 0 }$ as ",
+        "bbox": [
+            173,
+            217,
+            823,
+            246
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "equation",
+        "img_path": "images/f7752fd07052d77fed2ae327e680343a67084c54807d10fa53f1b698af41e46d.jpg",
+        "text": "$$\n\\epsilon _ { m } : = \\operatorname* { m a x } _ { j \\in V _ { m } } \\operatorname* { m i n } _ { i \\in V _ { 0 } } \\| g _ { i } ( X , G ) - g _ { j } ( X , G ) \\| _ { 2 } .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            356,
+            250,
+            642,
+            275
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Further, for each $i \\in V _ { 0 }$ , define the near set of $i$ with respect to $V _ { m }$ as ",
+        "bbox": [
+            173,
+            277,
+            632,
+            294
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "equation",
+        "img_path": "images/70d34dc9d33b7b2aaa231e517cf62a872ff6085234cd58ab25ee29b4bc93ee3b.jpg",
+        "text": "$$\nV _ { m } ^ { ( i ) } : = \\{ j \\in V _ { m } \\mid \\| g _ { i } ( X , G ) - g _ { j } ( X , G ) \\| _ { 2 } \\leq \\epsilon _ { m } \\} .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            323,
+            297,
+            671,
+            318
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Clearly, ",
+        "bbox": [
+            173,
+            320,
+            227,
+            335
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "equation",
+        "img_path": "images/858d59592d993ed28f882d7bad558139be6f2b553872658f28d5b5499ed8a1a3.jpg",
+        "text": "$$\nV _ { m } = \\cup _ { i \\in V _ { 0 } } V _ { m } ^ { ( i ) } .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            439,
+            333,
+            558,
+            353
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Then, with the Assumption 2 and 3 below, we can bound the expected loss discrepancy $D _ { m , 0 } ^ { \\gamma } ( P ; \\lambda )$ with the following Lemma 1 (see the proof in Appendix A.3). ",
+        "bbox": [
+            174,
+            361,
+            826,
+            390
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Assumption 2 (Equal-Sized and Disjoint Near Sets). For any $0 < m \\le M$ , assume the near sets of each $i \\in V _ { 0 }$ with respect to $V _ { m }$ are disjoint and have the same size $s _ { m } \\in \\mathbb { N } ^ { + }$ . ",
+        "bbox": [
+            173,
+            392,
+            825,
+            421
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Assumption 3 (Concentrated Expected Loss Difference). Let $P$ be a distribution on $\\mathcal { H }$ , defined by sampling the vectorized MLP parameters from ${ \\mathcal { N } } ( 0 , \\sigma ^ { 2 } I )$ for some $\\begin{array} { r } { \\sigma ^ { 2 } \\le \\frac { ( \\gamma / 8 \\epsilon _ { m } ) ^ { 2 / L } } { 2 b ( \\lambda N _ { 0 } ^ { - \\alpha } + \\ln { 2 b L } ) } } \\end{array}$ For any $L$ - layer GNN classifier $h \\in \\mathcal H$ with model parameters $W _ { 1 } ^ { h } , \\ldots , W _ { L } ^ { h }$ , define $T _ { h } : = \\operatorname* { m a x } _ { l = 1 , \\ldots , L } \\| W _ { l } \\| _ { 2 }$ . Assume that there exists some $\\textstyle 0 < \\alpha < { \\frac { 1 } { 4 } }$ satisfying ",
+        "bbox": [
+            173,
+            422,
+            826,
+            494
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "equation",
+        "img_path": "images/f2e2ef052fe29a4dba0573498e7dbeb1d6eb0ae441f6836551b31af6a640121d.jpg",
+        "text": "$$\n\\operatorname* { P r } _ { h \\sim P } \\left( \\mathcal { L } _ { m } ^ { \\gamma / 4 } ( h ) - \\mathcal { L } _ { 0 } ^ { \\gamma / 2 } ( h ) > N _ { 0 } ^ { - \\alpha } + c K \\epsilon _ { m } \\mid T _ { h } ^ { L } \\epsilon _ { m } > \\frac { \\gamma } { 8 } \\right) \\le e ^ { - N _ { 0 } ^ { 2 \\alpha } } .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            267,
+            500,
+            725,
+            526
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Lemma 1 (Bound for $D _ { m , 0 } ^ { \\gamma } ( P ; \\lambda ) )$ . Under Assumption $I$ , 2 and 3, for any $0 < m \\le M$ , any $0 < \\lambda \\leq N _ { 0 } ^ { 2 \\alpha }$ and $\\gamma \\geq 0$ , assume the “prior” $P$ on $\\mathcal { H }$ is defined by sampling the vectorized $M L P$ parameters from ${ \\mathcal { N } } ( 0 , \\sigma ^ { 2 } I )$ for some $\\begin{array} { r } { \\sigma ^ { 2 } \\le \\frac { ( \\gamma / 8 \\epsilon _ { m } ) ^ { 2 / L } } { 2 b ( \\lambda N _ { 0 } ^ { - \\alpha } + \\ln { 2 b L } ) } } \\end{array}$ . We have ",
+        "bbox": [
+            173,
+            531,
+            826,
+            588
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "equation",
+        "img_path": "images/092e640e7b2d7a5576a5e3ed10f256bd997cb9889c176e28b5661b1bc013d4fa.jpg",
+        "text": "$$\nD _ { m , 0 } ^ { \\gamma / 2 } ( P ; \\lambda ) \\leq \\ln { 3 } + \\lambda c K \\epsilon _ { m } .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            397,
+            592,
+            601,
+            614
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Intuitively, what we need to bound $D _ { m , 0 } ^ { \\gamma } ( P ; \\lambda )$ is that the training set $V _ { 0 }$ is “representative” for $V _ { m }$ . This is reasonable in practice as it is natural to select the training samples according to the distribution of the population. Specifically, Assumption 2 assumes that $V _ { m }$ can be split into equalsized partitions indexed by the training samples. The elements of each partition $V _ { m } ^ { ( i ) }$ are close to the corresponding training sample $i$ but not so close to training samples other than $i$ . This assumption is stronger than needed to obtain a meaningful bound on $\\bar { D } _ { m , 0 } ^ { \\gamma } \\bar { ( } P ; \\lambda )$ , and we can relax it by only assuming that most samples in $V _ { m }$ have proportional “close representatives” in $V _ { 0 }$ . But we keep Assumption 2 in this work, as it is intuitively clear and significantly eases the analysis and notations. Assumption 3 essentially assumes that the expected margin loss on $V _ { m }$ is not much larger than that on $V _ { 0 }$ when the number of samples becomes large. We first note that this assumption becomes trivially true in the degenerate case that all samples in $V _ { m }$ and $V _ { 0 }$ are IID. In this case, $\\bar { \\mathcal { L } } _ { m } ^ { \\gamma / 4 } ( h ) = \\bar { \\mathcal { L } } _ { 0 } ^ { \\gamma / 4 } ( h ) < \\bar { \\mathcal { L } } _ { 0 } ^ { \\gamma / 2 } ( h ) \\bar { \\ } \\leq 0$ for any classifier $h$ . In Appendix A.5, we further provide a simple non-IID example where Assumption 3 holds. ",
+        "bbox": [
+            173,
+            625,
+            826,
+            814
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "The bound (5) suggests that the closer between $V _ { m }$ and $V _ { 0 }$ (smaller $\\epsilon _ { m }$ ), the smaller the expected loss discrepancy. ",
+        "bbox": [
+            176,
+            819,
+            821,
+            848
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Bound for GNNs. Finally, with an additional technical assumption (Assumption 4) that the maximum L2 norm of aggregated node features does not grow too fast in terms of the number of training samples, we obtain a subgroup generalization bound for GNNs in Theorem 3. The proof of Theorem 3 can be found in Appendix A.4. ",
+        "bbox": [
+            174,
+            854,
+            825,
+            911
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Assumption 4. Define $B _ { m } : = \\operatorname* { m a x } _ { i \\in V _ { 0 } \\cup V _ { m } } \\| g _ { i } ( X , G ) \\| _ { 2 }$ . For any classifier $\\tilde { h } \\in \\mathcal { H }$ with parameters $\\{ \\widetilde { W } _ { l } \\} _ { l = 1 } ^ { L }$ , assume $\\| \\widetilde { W } _ { l } \\| _ { F } \\le C f o r l = 1 , \\ldots , L .$ . Assume $B _ { m } , C$ are constants with respect to $N _ { 0 }$ . ",
+        "bbox": [
+            174,
+            90,
+            825,
+            123
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Theorem 3 (Subgroup Generalization Bound for GNNs). Let $\\tilde { h }$ be any classifier in $\\mathcal { H }$ with parameters $\\{ \\widetilde { W } _ { l } \\} _ { l = 1 } ^ { L }$ . Under Assumptions 1, 2, 3, and 4, for any $0 < m \\le M$ , $\\gamma \\geq 0$ , and large enough $N _ { 0 }$ , with probability at least $1 - \\delta$ over the sample of $y ^ { 0 }$ , we have ",
+        "bbox": [
+            174,
+            127,
+            825,
+            174
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "equation",
+        "img_path": "images/4e81a4c1e803f17863568334c94bb2b29431c47e2a6e43e05980a4efafa63784.jpg",
+        "text": "$$\n\\mathcal { L } _ { m } ^ { 0 } ( \\widetilde { h } ) \\leq \\widehat { \\mathcal { L } } _ { 0 } ^ { \\gamma } ( \\widetilde { h } ) + O \\left( c K \\epsilon _ { m } + \\frac { b \\sum _ { l = 1 } ^ { L } \\| \\widetilde { W } _ { l } \\| _ { F } ^ { 2 } } { ( \\gamma / 8 ) ^ { 2 / L } N _ { 0 } ^ { \\alpha } } ( \\epsilon _ { m } ) ^ { 2 / L } + \\frac { 1 } { N _ { 0 } ^ { 1 - 2 \\alpha } } + \\frac { 1 } { N _ { 0 } ^ { 2 \\alpha } } \\ln \\frac { L C ( 2 B _ { m } ) ^ { 1 / L } } { \\gamma ^ { 1 / L } \\delta } \\right) .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            181,
+            178,
+            820,
+            219
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Next, we investigate the qualitative implications of our theoretical results. ",
+        "bbox": [
+            174,
+            241,
+            656,
+            256
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "4.3 Implications for Fairness of Graph Neural Networks ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            271,
+            578,
+            286
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Theoretically predictable accuracy disparity. One merit of our analysis is that we can apply Theorem 3 on different subgroups of the unlabeled nodes and compare the subgroup generalization bounds. This allows us to study the accuracy disparity across subgroups from a theoretical perspective. ",
+        "bbox": [
+            174,
+            299,
+            825,
+            340
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "A major factor that affects the generalization bound (6) is $\\epsilon _ { m }$ , the aggregated-feature distance (in terms of $g ( X , G ) )$ from the target test subgroup $V _ { m }$ to the training set $V _ { 0 }$ . The generalization bound (6) suggests that there is a better generalization guarantee for subgroups that are closer to the training set. In other words, it is unfair for subgroups that are far away from the training set. While our theoretical analysis can only tell the difference among upper bounds of generalization errors, we empirically verify that, in the following Section 5, the aggregated-feature distance $\\epsilon _ { m }$ is indeed a strong predictor for the test accuracy of each subgroup $V _ { m }$ . More specifically, the test accuracy decreases as the distance increases, which is consistent with the theoretical prediction given by the bound (6). ",
+        "bbox": [
+            173,
+            347,
+            825,
+            458
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Impact of the structural positions of nodes. We further investigate if the aggregated-feature distance can be related to simpler and more interpretable graph characteristics, in order to obtain a more intuitive understanding of how the structural positions of nodes influence the prediction accuracy on them. We find that the geodesic distance (length of the shortest path) between two nodes is positively related to the distance between their aggregated features in some scenarios9, such as when the node features exhibit homophily [28]. Empirically, we also observe that test nodes with larger geodesic distance to the training set tend to suffer from lower accuracy (see Figure 2). ",
+        "bbox": [
+            174,
+            465,
+            823,
+            563
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "In contrast, we find that common node centrality metrics (e.g., degree and PageRank) have less influence on the test accuracy (see Figure 3). These centrality metrics only capture the graph characteristics of the test nodes alone, but do not take their relationship to the training set into account, which is a key factor suggested by our theoretical analysis. ",
+        "bbox": [
+            174,
+            569,
+            825,
+            625
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Impact of training data selection. Another implication of the theoretical results is that the selection of the training set plays an important role on the fairness of the learned GNN models. First, if the training set is selected unevenly on the graph, leaving part of the test nodes far away, there will likely be a large accuracy disparity. Second, a key ingredient in the proof of Lemma 1 is that the GNN predictions on two nodes tend to be more similar if they are closer in terms of the aggregated node features. This suggests that, if an individual training node is close to many test nodes, it may bias the predictions of the learned GNN on the test nodes towards the class it belongs to. ",
+        "bbox": [
+            174,
+            632,
+            825,
+            729
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "5 Experiments ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            750,
+            313,
+            766
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "In this section, we empirically verify the fairness implications suggested by our theoretical analysis. ",
+        "bbox": [
+            176,
+            767,
+            823,
+            781
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "General setup. We experiment on 4 popular GNN models, GCN [20], GAT [41], SGC [45], and APPNP [21], as well as an MLP model for reference. For all models, we use the implementations by Deep Graph Library [43]. For each experiment setting, 40 independent trials are carried out. ",
+        "bbox": [
+            176,
+            789,
+            820,
+            832
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "5.1 Accuracy Disparity Across Subgroups ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            847,
+            478,
+            862
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Subgroups. We examine the accuracy disparity with three types of subgroups as described below. ",
+        "bbox": [
+            176,
+            873,
+            818,
+            888
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/48f1a17779a5858cf36af9557baf10070dff8a78e3728d933ffc0b4856a6f4fc.jpg",
+        "image_caption": [
+            "Figure 1: Test accuracy disparity across subgroups by aggregated-feature distance. Each figure corresponds to a dataset, and each bar cluster corresponds to a model. Bars labeled 1 to 5 represent subgroups with increasing distance to training set. Results are averaged over 40 independent trials with different random splits of the data, and the error bar represents the standard error of the mean. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            176,
+            112,
+            812,
+            233
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "image",
+        "img_path": "images/6677d439e47c9833970758a260951d224a6965a92db8cf0bb8ba71dbefa1f5b3.jpg",
+        "image_caption": [
+            "Figure 2: Test accuracy disparity across subgroups by geodesic distance. The experiment and plot settings are the same as Figure 1, except for the bars labeled from 1 to 5 here represent subgroups with increasing shortest-path distance to training set. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            176,
+            329,
+            812,
+            450
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Subgroup by aggregated-feature distance. In order to directly investigate the effect of $\\epsilon _ { m }$ on the generalization bound (6), we first split the test nodes into subgroups by their distance to the training set in terms of the aggregated features. We use the two-step aggregated features to calculate the distance. In particular, denote the adjacency matrix of the graph $G$ as $\\breve { A } \\in \\{ 0 , 1 \\} ^ { N \\times N }$ and the corresponding degree matrix as D, where D is an N × N diagonal matrix with Dii = PNj=1 Aij , ∀i = 1, . . . , N . Given the feature matrix $X \\in \\mathbb { R } ^ { N \\times D }$ , the two-step aggregated features $Z$ are obtained by $Z =$ $( D + I ) ^ { - 1 } ( A + I ) ( D + I ) ^ { - 1 } ( A + I ) X$ . For each test node $i$ , we calculate its aggregated-feature distance to the training set $V _ { 0 }$ as $\\begin{array} { r } { d _ { i } = \\operatorname* { m i n } _ { j \\in V _ { 0 } } \\| Z _ { i } - Z _ { j } \\| _ { 2 } } \\end{array}$ . Then we sort the test nodes according to this distance and split them into 5 equal-sized subgroups. ",
+        "bbox": [
+            173,
+            530,
+            826,
+            661
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Strictly speaking, our theory does not directly apply to GCN and GAT as they are not in the form as we defined in Section 4.2. Moreover, the two-step aggregated feature does not match exactly to the feature aggregation function of SGC and APPNP. Nevertheless, we find that even with such approximations, we are still able to observe the expected descending trend of test accuracy with respect to increasing distance in terms of the two-step aggregated features, on all four GNN models. ",
+        "bbox": [
+            174,
+            667,
+            825,
+            738
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Subgroup by geodesic distance. As we discussed in Section 4.3, geodesic distance on the graph may well relate to the aggregated-feature distance. So we also define subgroups based on geodesic distance. We split the subgroups by replacing the aggregated-feature distance $d _ { i }$ of each test node $i$ with the minimum of the geodesic distances from $i$ to each training node on the graph. ",
+        "bbox": [
+            174,
+            743,
+            825,
+            799
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Subgroup by node centrality. Lastly, we define subgroups based on 4 types of common node centrality metrics (degree, closeness, betweenness, and PageRank) of the test nodes. We split the subgroups by replacing the aggregated-feature distance $d _ { i }$ of each test node $i$ with the centrality score of $i$ . The purpose of this setup is to show that the common node centrality metrics are not sufficient to capture the monotonic trend of test accuracy. ",
+        "bbox": [
+            174,
+            805,
+            825,
+            875
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Experiment setup. Following common GNN experiment setup [38], we randomly select 20 nodes in each class for training, 500 nodes for validation, and 1,000 nodes for testing. Once training is done, we report the test accuracy on subgroups defined by aggregated-feature distance, geodesic distance, and node centrality in Figure 1, 2, and 3 respectively10. ",
+        "bbox": [
+            174,
+            882,
+            821,
+            911
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "image",
+        "img_path": "images/62daec6597baf0aa2fbaf0628bb7dbf3b33af1d4106321e0808a137b7b93049f.jpg",
+        "image_caption": [
+            "Figure 3: Test accuracy disparity across subgroups by node centrality. Each figure corresponds to the results of a pair of model and dataset, and each bar cluster corresponds to the subgroups defined by a certain centrality metric. In each cluster, the bars labeled from 1 to 5 represent subgroups with decreasing node centrality. Other settings are the same as Figure 1. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            176,
+            104,
+            812,
+            409
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            176,
+            473,
+            823,
+            501
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Experiment results. First, as shown in Figure 1, there is a clear trend that the accuracy of a test subgroup decreases as the aggregated-feature distance between the test subgroup and the training set increases. And the trend is consistent for all 4 GNN models on all the datasets we test on (except for APPNP on Cora). This result verifies the existence of accuracy disparity suggested by Theorem 3. ",
+        "bbox": [
+            174,
+            508,
+            825,
+            564
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Second, we observe in Figure 2 that there is a similar trend when we split subgroups by the geodesic distance. This suggests that the geodesic distance on the graph can sometimes be used as a simpler indicator in practice for machine learning fairness on graph-structured data. Using such a classical graph metric as an indicator also helps us connect graph-based machine learning to network theory, especially to understandings about social networks, to better analyze fairness issues of machine learning on social networks, where high-stake decisions related to human subjects may be involved. ",
+        "bbox": [
+            174,
+            570,
+            825,
+            654
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Furthermore, as shown in Figure 3, there is no clear monotonic trend for test accuracy when we split subgroups by node centrality, except for some particular combinations of GNN model and dataset. Empirically, the common node centrality metrics are not as good as the geodesic distance in terms of capturing the accuracy disparity. This contrast highlights the importance of the insight provided by our analysis: the “distance” to the training set, rather than some graph characteristics of the test nodes alone, is the key predictor of test accuracy. ",
+        "bbox": [
+            174,
+            660,
+            825,
+            744
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Finally, it is intriguing that, in both Figure 1 and 2, the test accuracy of MLP (which does not use the graph structure) also decreases as the distance of a subgroup to the training set increases. This result is perhaps not surprising if the subgroups were defined by distance on the original node features, as MLP can be viewed as a special GNN where the feature aggregation function is an identity mapping, so the “aggregated features” for MLP essentially equal to the original features. Our theoretical analysis can then be similarly applied to MLP. The question is why there is also an accuracy disparity w.r.t. the aggregated-feature distance and the geodesic distance. We suspect this is because these datasets present homophily, i.e., original (non-aggregated) features of geodesically closer nodes tend to be more similar. As a result, a subgroup with smaller geodesic distance may also have closer node features to the training set. To verify this hypothesis, we repeat the experiments in Figure 1, but with independent noises added to node features such that they become less homophilious. As in Figure 4, the decreasing pattern of test accuracy across subgroups remains for the 4 GNNs on all datasets; while for MLP, the pattern disappears on Cora and Pubmed and becomes less sharp on Citeseer. ",
+        "bbox": [
+            173,
+            750,
+            825,
+            876
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "image",
+        "img_path": "images/43a6f9ddd3cd82fb9e4751088ea82fe67ef906373cea7fa9923f126277ed7222.jpg",
+        "image_caption": [
+            "Figure 4: Test accuracy disparity across subgroups by aggregated-feature distance, experimented with noisy features. The experiment and plot settings are the same as Figure 1, except for the node features are perturbed by independent noises such that they are less homophilious. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            181,
+            113,
+            812,
+            233
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "image",
+        "img_path": "images/4443e45c660f7f688ed8bc0cbbbdcea18c303fec1825501f557ef97f0856d03f.jpg",
+        "image_caption": [
+            "Figure 5: Relative ratio between the FPR under biased training node selection and the FPR under uniform training node selection. Each bar in each cluster corresponds to a class (there are 7 classes in total). The red shaded bar indicates the class with high centrality training nodes under the biased setup. Each cluster corresponds to a centrality metric being used for the biased node selection. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            184,
+            284,
+            810,
+            385
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            445,
+            825,
+            501
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "5.2 Impact of Biased Training Node Selection ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            517,
+            501,
+            532
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "In all the previous experiments, we follow the standard GNN training setup where 20 training nodes are uniformly sampled for each class. Next we investigate the impact if the selection of training nodes is biased, verifying our discussions in Section 4.3. We will demonstrate that the node centrality scores of the training nodes play an important role in the learned GNN model. ",
+        "bbox": [
+            174,
+            542,
+            825,
+            598
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "We choose a “dominant class” and construct a manipulated training set. For each class, we still sample 20 training nodes but in a biased way. For the dominant class, the sample is biased towards nodes of high centrality; while for other classes, the sample is biased towards nodes of low centrality. We evaluate the relative ratio of False Positive Rate (FPR) for each class between the setup using manipulated training set and the setup using uniformly sampled training set. ",
+        "bbox": [
+            174,
+            604,
+            825,
+            675
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "As shown in Figure 5, compared to MLP, the GNN models have significantly worse FPR for the dominant class when the training nodes are biased. This is because, after feature aggregation, there will be a larger proportion of test nodes that are closer to the training nodes of higher centrality. And the learned GNN model will be heavily biased towards the training labels of these nodes. ",
+        "bbox": [
+            174,
+            680,
+            825,
+            736
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "6 Conclusion ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            756,
+            299,
+            772
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "We present a novel PAC-Bayesian analysis for the generalization ability of GNNs on node-level semi-supervised learning tasks. As far as we know, this is the first generalization bound for GNNs for non-IID node-level tasks without strong assumptions on the data generating mechanism. One advantage of our analysis is that it can be applied to arbitrary subgroups of the test nodes, which allows us to investigate an accuracy-disparity style of fairness for GNNs. Both the theoretical and empirical results suggest that there is an accuracy disparity across subgroups of test nodes that have varying distance to the training set, and nodes with larger distance to the training nodes suffer from a lower classification accuracy. In the future, we would like to utilize our theory to analyze the fairness of GNNs on real-world applications and develop principled methods to mitigate the unfairness. ",
+        "bbox": [
+            174,
+            786,
+            825,
+            911
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Acknowledgements ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            92,
+            310,
+            106
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "This work was in part supported by the National Science Foundation under grant number 1633370.   \nThe authors claim no competing interests.   \nReferences   \n[1] Chirag Agarwal, Himabindu Lakkaraju, and Marinka Zitnik. Towards a unified framework for fair and stable graph representation learning. CoRR, abs/2102.13186, 2021. URL https: //arxiv.org/abs/2102.13186.   \n[2] Pierre Alquier, James Ridgway, and Nicolas Chopin. On the properties of variational approximations of gibbs posteriors. The Journal of Machine Learning Research, 17(1):8374–8414, 2016.   \n[3] Aseem Baranwal, Kimon Fountoulakis, and Aukosh Jagannath. Graph convolution for semisupervised classification: Improved linear separability and out-of-distribution generalization. arXiv preprint arXiv:2102.06966, 2021.   \n[4] Luc Bégin, Pascal Germain, François Laviolette, and Jean-Francis Roy. Pac-bayesian theory for transductive learning. In Artificial Intelligence and Statistics, pages 105–113. PMLR, 2014.   \n[5] Avishek Joey Bose and William L. Hamilton. Compositional fairness constraints for graph embeddings. CoRR, abs/1905.10674, 2019. URL http://arxiv.org/abs/1905.10674.   \n[6] Maarten Buyl and Tijl De Bie. The kl-divergence between a graph model and its fair i-projection as a fairness regularizer. CoRR, abs/2103.01846, 2021. URL https://arxiv.org/abs/2103. 01846.   \n[7] Enyan Dai and Suhang Wang. Say no to the discrimination: Learning fair graph neural networks with limited sensitive attribute information. In Proceedings of the 14th ACM International Conference on Web Search and Data Mining, WSDM ’21, page 680–688, New York, NY, USA, 2021. Association for Computing Machinery. ISBN 9781450382977. doi: 10.1145/3437963. 3441752. URL https://doi.org/10.1145/3437963.3441752.   \n[8] Yash Deshpande, Subhabrata Sen, Andrea Montanari, and Elchanan Mossel. Contextual stochastic block models. In NeurIPS, 2018.   \n[9] Simon S Du, Kangcheng Hou, Barnabás Póczos, Ruslan Salakhutdinov, Ruosong Wang, and Keyulu Xu. Graph neural tangent kernel: Fusing graph neural networks with graph kernels. arXiv preprint arXiv:1905.13192, 2019.   \n[10] Gintare Karolina Dziugaite, Kyle Hsu, Waseem Gharbieh, Gabriel Arpino, and Daniel Roy. On the role of data in pac-bayes. In International Conference on Artificial Intelligence and Statistics, pages 604–612. PMLR, 2021.   \n[11] Vikas Garg, Stefanie Jegelka, and Tommi Jaakkola. Generalization and representational limits of graph neural networks. In International Conference on Machine Learning, pages 3419–3430. PMLR, 2020.   \n[12] Pascal Germain, Alexandre Lacasse, Francois Laviolette, Mario March, and Jean-Francis Roy. Risk bounds for the majority vote: From a pac-bayesian analysis to a learning algorithm. Journal of Machine Learning Research, 16(26):787–860, 2015.   \n[13] Marco Gori, Gabriele Monfardini, and Franco Scarselli. A new model for learning in graph domains. In Proceedings. 2005 IEEE International Joint Conference on Neural Networks, 2005., volume 2, pages 729–734. IEEE, 2005.   \n[14] Benjamin Guedj. A primer on pac-bayesian learning. arXiv preprint arXiv:1901.05353, 2019.   \n[15] Wassily Hoeffding. Probability inequalities for sums of bounded random variables. In The Collected Works of Wassily Hoeffding, pages 409–426. Springer, 1994. ",
+        "bbox": [
+            173,
+            117,
+            826,
+            145
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            165,
+            828,
+            916
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "[16] Yifan Hou, Jian Zhang, James Cheng, Kaili Ma, Richard TB Ma, Hongzhi Chen, and MingChang Yang. Measuring and improving the use of graph information in graph neural networks. In International Conference on Learning Representations, 2019. ",
+        "bbox": [
+            171,
+            90,
+            823,
+            133
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "[17] Weihua Hu, Matthias Fey, Marinka Zitnik, Yuxiao Dong, Hongyu Ren, Bowen Liu, Michele Catasta, and Jure Leskovec. Open graph benchmark: Datasets for machine learning on graphs. arXiv preprint arXiv:2005.00687, 2020. ",
+        "bbox": [
+            171,
+            142,
+            823,
+            185
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "[18] Wengong Jin, Regina Barzilay, and Tommi Jaakkola. Junction tree variational autoencoder for molecular graph generation. In International Conference on Machine Learning, pages 2323–2332. PMLR, 2018. ",
+        "bbox": [
+            173,
+            194,
+            823,
+            236
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "[19] Ahmad Khajehnejad, Moein Khajehnejad, Mahmoudreza Babaei, Krishna P. Gummadi, Adrian Weller, and Baharan Mirzasoleiman. Crosswalk: Fairness-enhanced node representation learning, 2021. ",
+        "bbox": [
+            171,
+            244,
+            823,
+            287
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "[20] Thomas N Kipf and Max Welling. Semi-supervised classification with graph convolutional networks. arXiv preprint arXiv:1609.02907, 2016. ",
+        "bbox": [
+            173,
+            296,
+            823,
+            327
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "[21] Johannes Klicpera, Aleksandar Bojchevski, and Stephan Günnemann. Predict then propagate: Graph neural networks meet personalized pagerank. In ICLR, 2019. ",
+        "bbox": [
+            174,
+            333,
+            823,
+            364
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "[22] Charlotte Laclau, Ievgen Redko, Manvi Choudhary, and Christine Largeron. All of the fairness for edge prediction with optimal transport. CoRR, abs/2010.16326, 2020. URL https: //arxiv.org/abs/2010.16326. ",
+        "bbox": [
+            173,
+            372,
+            821,
+            415
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "[23] John Langford and John Shawe-Taylor. Pac-bayes & margins. Advances in neural information processing systems, pages 439–446, 2003. ",
+        "bbox": [
+            173,
+            422,
+            823,
+            453
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "[24] Qimai Li, Zhichao Han, and Xiao-Ming Wu. Deeper insights into graph convolutional networks for semi-supervised learning. In Proceedings of the AAAI Conference on Artificial Intelligence, volume 32, 2018. ",
+        "bbox": [
+            176,
+            460,
+            823,
+            503
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "[25] Renjie Liao, Raquel Urtasun, and Richard Zemel. A pac-bayesian approach to generalization bounds for graph neural networks. In ICLR, 2021. ",
+        "bbox": [
+            176,
+            512,
+            823,
+            542
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "[26] Yao Ma, Xiaorui Liu, Neil Shah, and Jiliang Tang. Is homophily a necessity for graph neural networks? arXiv preprint arXiv:2106.06134, 2021. ",
+        "bbox": [
+            174,
+            550,
+            823,
+            579
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "[27] David McAllester. Simplified pac-bayesian margin bounds. In Learning theory and Kernel machines, pages 203–215. Springer, 2003. ",
+        "bbox": [
+            176,
+            588,
+            825,
+            617
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "[28] Miller McPherson, Lynn Smith-Lovin, and James M Cook. Birds of a feather: Homophily in social networks. Annual review of sociology, 27(1):415–444, 2001. ",
+        "bbox": [
+            173,
+            626,
+            823,
+            655
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "[29] Federico Monti, Davide Boscaini, Jonathan Masci, Emanuele Rodola, Jan Svoboda, and Michael M Bronstein. Geometric deep learning on graphs and manifolds using mixture model cnns. In Proceedings of the IEEE conference on computer vision and pattern recognition, pages 5115–5124, 2017. ",
+        "bbox": [
+            176,
+            662,
+            823,
+            719
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "[30] Behnam Neyshabur, Srinadh Bhojanapalli, and Nathan Srebro. A pac-bayesian approach to spectrally-normalized margin bounds for neural networks. 2018. ",
+        "bbox": [
+            171,
+            728,
+            823,
+            757
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "[31] Hoang NT and Takanori Maehara. Revisiting graph neural networks: All we have is low-pass filters. arXiv preprint arXiv:1905.09550, 2019. ",
+        "bbox": [
+            173,
+            766,
+            823,
+            795
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "[32] Tahleen Rahman, Bartlomiej Surma, Michael Backes, and Yang Zhang. Fairwalk: Towards fair graph embedding. In Proceedings of the Twenty-Eighth International Joint Conference on Artificial Intelligence, IJCAI-19, pages 3289–3295. International Joint Conferences on Artificial Intelligence Organization, 7 2019. doi: 10.24963/ijcai.2019/456. URL https: //doi.org/10.24963/ijcai.2019/456. ",
+        "bbox": [
+            174,
+            804,
+            825,
+            873
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "[33] Omar Rivasplata. Subgaussian random variables: An expository note. Internet publication, PDF, 2012. ",
+        "bbox": [
+            171,
+            883,
+            821,
+            911
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "[34] Ryoma Sato. A survey on the expressive power of graph neural networks. arXiv preprint arXiv:2003.04078, 2020.   \n[35] Franco Scarselli, Marco Gori, Ah Chung Tsoi, Markus Hagenbuchner, and Gabriele Monfardini. The graph neural network model. IEEE transactions on neural networks, 20(1):61–80, 2008.   \n[36] Franco Scarselli, Ah Chung Tsoi, and Markus Hagenbuchner. The vapnik–chervonenkis dimension of graph and recursive neural networks. Neural Networks, 108:248–259, 2018.   \n[37] Prithviraj Sen, Galileo Namata, Mustafa Bilgic, Lise Getoor, Brian Galligher, and Tina EliassiRad. Collective classification in network data. AI magazine, 29(3):93–93, 2008.   \n[38] Oleksandr Shchur, Maximilian Mumme, Aleksandar Bojchevski, and Stephan Günnemann. Pitfalls of graph neural network evaluation. CoRR, abs/1811.05868, 2018. URL http:// arxiv.org/abs/1811.05868.   \n[39] Indro Spinelli, Simone Scardapane, Amir Hussain, and Aurelio Uncini. Biased edge dropout for enhancing fairness in graph representation learning, 2021.   \n[40] Joel A Tropp. An introduction to matrix concentration inequalities. Foundations and Trends in Machine Learning, 8(1-2):1–230, 2015.   \n[41] Petar Velickovi ˇ c, Guillem Cucurull, Arantxa Casanova, Adriana Romero, Pietro Liò, and Yoshua ´ Bengio. Graph attention networks. In ICLR, 2018.   \n[42] Saurabh Verma and Zhi-Li Zhang. Stability and generalization of graph convolutional neural networks. In Proceedings of the 25th ACM SIGKDD International Conference on Knowledge Discovery & Data Mining, pages 1539–1548, 2019.   \n[43] Minjie Wang, Da Zheng, Zihao Ye, Quan Gan, Mufei Li, Xiang Song, Jinjing Zhou, Chao Ma, Lingfan Yu, Yu Gai, et al. Deep graph library: A graph-centric, highly-performant package for graph neural networks. arXiv preprint arXiv:1909.01315, 2019.   \n[44] Duncan J Watts and Steven H Strogatz. Collective dynamics of ‘small-world’networks. nature, 393(6684):440–442, 1998.   \n[45] Felix Wu, Amauri Souza, Tianyi Zhang, Christopher Fifty, Tao Yu, and Kilian Weinberger. Simplifying graph convolutional networks. In International conference on machine learning, pages 6861–6871. PMLR, 2019.   \n[46] Zonghan Wu, Shirui Pan, Fengwen Chen, Guodong Long, Chengqi Zhang, and S Yu Philip. A comprehensive survey on graph neural networks. IEEE transactions on neural networks and learning systems, 2020.   \n[47] Zhilin Yang, William Cohen, and Ruslan Salakhudinov. Revisiting semi-supervised learning with graph embeddings. In International conference on machine learning, pages 40–48. PMLR, 2016.   \n[48] Rex Ying, Ruining He, Kaifeng Chen, Pong Eksombatchai, William L Hamilton, and Jure Leskovec. Graph convolutional neural networks for web-scale recommender systems. In Proceedings of the 24th ACM SIGKDD International Conference on Knowledge Discovery & Data Mining, pages 974–983, 2018.   \n[49] Bing Yu, Haoteng Yin, and Zhanxing Zhu. Spatio-temporal graph convolutional networks: a deep learning framework for traffic forecasting. In Proceedings of the 27th International Joint Conference on Artificial Intelligence, pages 3634–3640, 2018.   \n[50] Ziqian Zeng, Rashidul Islam, Kamrun Naher Keya, James R. Foulds, Yangqiu Song, and Shimei Pan. Fair representation learning for heterogeneous information networks. CoRR, abs/2104.08769, 2021. URL https://arxiv.org/abs/2104.08769.   \n[51] Wenda Zhou, Victor Veitch, Morgane Austern, Ryan P Adams, and Peter Orbanz. Nonvacuous generalization bounds at the imagenet scale: a pac-bayesian compression approach. In International Conference on Learning Representations, 2018. ",
+        "bbox": [
+            171,
+            51,
+            828,
+            921
+        ],
+        "page_idx": 12
+    }
+]

parse/train/HJx7l309Fm/HJx7l309Fm.md

@@ -0,0 +1,393 @@
+# ACTOR-ATTENTION-CRITIC FOR MULTI-AGENT REINFORCEMENT LEARNING
+
+Anonymous authors Paper under double-blind review
+
+# ABSTRACT
+
+Reinforcement learning in multi-agent scenarios is important for real-world applications but presents challenges beyond those seen in single-agent settings. We present an actor-critic algorithm that trains decentralized policies in multi-agent settings, using centrally computed critics that share an attention mechanism which selects relevant information for each agent at every timestep. This attention mechanism enables more effective and scalable learning in complex multi-agent environments, when compared to recent approaches. Our approach is applicable not only to cooperative settings with shared rewards, but also individualized reward settings, including adversarial settings, and it makes no assumptions about the action spaces of the agents. As such, it is flexible enough to be applied to most multi-agent learning problems.
+
+# 1 INTRODUCTION
+
+Reinforcement learning has recently made exciting progress in many domains, including Atari games (Mnih et al., 2015), the ancient Chinese board game, Go (Silver et al., 2016), and complex continuous control tasks involving locomotion (Lillicrap et al., 2016; Schulman et al., 2015; 2017; Heess et al., 2017). While most reinforcement learning paradigms focus on single agents acting in a static environment (or against themselves in the case of Go), real-world agents often compete or cooperate with other agents in a dynamically shifting environment. In order to learn effectively in multi-agent environments, agents must not only learn the dynamics of their environment, but also those of the other learning agents present.
+
+To this end, several approaches for multi-agent reinforcement learning have been developed. The simplest approach is to train each agent independently to maximize their individual reward, while treating other agents as part of the environment. However, this approach violates the basic assumption underlying reinforcement learning, that the environment should be stationary and Markovian. Any single agent’s environment is dynamic and nonstationary due to other agents’ changing policies. As such, standard algorithms developed for stationary Markov decision processes fail.
+
+At the other end of the spectrum, all agents can be collectively modeled as a single-agent whose action space is the joint action space of all agents (Bus¸oniu et al., 2010). While allowing coordinated behaviors across agents, this approach is not scalable due to the action space size increasing exponentially with the number of agents. It also demands a high degree of communication during execution, as the central policy must collect observations from and distribute actions to the individual agents. In real-world settings, this demand can be problematic.
+
+Recent work (Lowe et al., 2017; Foerster et al., 2018) attempts to combine the strengths of these two approaches. In particular, a critic (or a number of critics) is centrally learned with information from all agents. The actors, however, receive information only from their corresponding agents. Thus, during testing, executing the policies does not require the knowledge of other agents’ actions. This paradigm circumvents the challenge of non-Markovian and non-stationary environments during learning. Despite those progresses, however, algorithms for multi-agent reinforcement learning are still far from being scalable (to a larger number of agents) and being generically applicable to environments and tasks that are co-operative (sharing a global reward), competitive, or mixed.
+
+Our approach extends these prior works in several directions. The main idea is to centrally learn a critic with an attention mechanism. The intuition behind our idea is that in many real-world environments, it is beneficial for agents to know what other agents it should pay attention to. For example, a soccer defender needs to pay attention to attackers in their vicinity as well as the player with the ball, while she/he rarely needs to pay attention to the opposing team’s goalie. The specific attackers that the defender is paying attention to can change at different parts of the game, depending on the formation and strategy of the opponent. A typical centralized approach to multi-agent reinforcement learning does not take these dynamics into account, instead simply considering all agents at all timepoints. Our attention mechanism is able to dynamically select which agents to attend to at each time point, improving performance in multi-agent domains with complex interactions.
+
+The proposed approach has an input space linearly increasing with respect to the number of agents, as opposed to the quadratic increase in a previous approach Lowe et al. (2017). It also works well in co-operative, competitive, and mixed environments, exceeding the capability of some prior work that focuses only on co-operative environments Foerster et al. (2018).
+
+We have validated our approach on two simulated environments and tasks. We plan to release the code for both the model and the environments after the reviewing period ends.
+
+The rest of the paper is organized as follows. In section 2, we discuss related work, followed by a detailed description of our approach in section 3. We report experimental studies in section 4 and conclude in section 5.
+
+# 2 RELATED WORK
+
+Multi-Agent Reinforcement Learning (MARL) is a long studied problem (Bus¸oniu et al., 2010). Topics within MARL are diverse, ranging from learning communication between cooperative agents (Tan, 1993; Fischer et al., 2004) to algorithms for optimal play in competitive settings (Littman, 1994), though, until recently, they have been focused on simple gridworld environments with tabular learning methods.
+
+As deep learning based approaches to reinforcement learning have grown more popular, they have, naturally, been applied to the MARL setting (Tampuu et al., 2017; Gupta et al., 2017), allowing multi-agent learning in high-dimensional/continuous state spaces; however, naive applications of Deep RL methods to MARL naturally encounter some limitations, such as nonstationarity of the environment from the perspective of individual agents (Foerster et al., 2017; Lowe et al., 2017; Foerster et al., 2018), lack of coordination/communication in cooperative settings (Sukhbaatar et al., 2016; Mordatch & Abbeel, 2018; Lowe et al., 2017; Foerster et al., 2016), credit assignment in cooperative settings with global rewards (Rashid et al., 2018; Sunehag et al., 2018; Foerster et al., 2018), and the failure to take opponent strategies into account when learning agent policies (He et al., 2016).
+
+Most relevant to this work are recent, non-attention approaches that propose an actor-critic framework consisting of centralized training with decentralized execution (Lowe et al., 2017; Foerster et al., 2018), as well as some approaches that utilize attention in a fully centralized multi-agent setting (Choi et al., 2017; Jiang & Lu, 2018). Lowe et al. (2017) investigate the challenges of multiagent learning in mixed reward environments (Bus¸oniu et al., 2010). They propose an actor-critic method that uses separate centralized critics for each agent which take in all other agents’ actions and observations as input, while training policies that are conditioned only on local information. This practice reduces the non-stationarity of multi-agent environments, as considering the actions of other agents to be part of the environment makes the state transition dynamics stable from the perspective of one agent. In practice, these ideas greatly stabilize learning, due to reduced variance in the value function estimates.
+
+Similarly Foerster et al. (2018) introduce a centralized critic for cooperative settings with shared rewards. Their method incorporates a ”counterfactual baseline” for calculating the advantage function which is able to marginalize a single agent’s actions while keeping others fixed. This method allows for complex multi-agent credit assignment, as the advantage function only encourages actions that directly influence an agent’s rewards.
+
+Attention models have recently emerged as a successful approach to intelligently selecting contextual information, with applications in computer vision (Ba et al., 2015; Mnih et al., 2014), natural language processing(Vaswani et al., 2017; Bahdanau et al., 2015; Lin et al., 2017), and reinforcement learning (Oh et al., 2016).
+
+In a similar vein, Jiang & Lu (2018) proposed an attention-based actor-critic algorithm for MARL. This work follows the alternative paradigm of centralizing policies while keeping the critics decentralized. Their focus is on learning an attention model for sharing information between the policies. As such, this approach is complementary to ours, and a combination of both approaches could yield further performance benefits in cases where centralized policies are desirable.
+
+Our proposed approach is more flexible than the aformentioned approaches for MARL. Our algorithm is able to train policies in environments with any reward setup, different action spaces for each agent, a variance-reducing baseline that only marginalizes the relevant agent’s actions, and with a set of centralized critics that dynamically attend to the relevant information for each agent at each time point. As such, our approach is more scalable to the number of agents, and is more broadly applicable to different types of environments.
+
+# 3 OUR APPROACH
+
+We start by introducing the necessary notation and basic building blocks for our approach. We then describe our ideas in detail.
+
+# 3.1 NOTATION AND BACKGROUND
+
+We consider the framework of Markov Games (Littman, 1994), which is a multi-agent extension of Markov Decision Processes. They are defined by a set of states, $S$ , action sets for each of $N$ agents, $A _ { 1 } , . . . , A _ { N }$ , a state transition function, $T : S \times A _ { 1 } \times . . . \times A _ { N }  P ( S )$ , which defines the probability distribution over possible next states, given the current state and actions for each agent, and a reward function for each agent that also depends on the global state and actions of all agents, $R _ { i } : S \times A _ { 1 } \times . . . \times A _ { N } \to \mathbb { R }$ . We will specifically be considering a partially observable variant in which an agent, $i$ receives an observation, $o _ { i }$ , which contains partial information from the global state, $s \in S$ . Each agent learns a policy, $\pi _ { i } : O _ { i } \to P ( A _ { i } )$ which maps each agent’s observation to a distribution over it’s set of actions. The agents aim to learn a policy that maximizes their expected discounted returns, $J _ { i } ( \pi _ { i } ) = \mathbb { E } _ { a _ { 1 } \sim \pi _ { 1 } , \dots , a _ { N } \sim \pi _ { N } , s \sim T } [ \sum _ { t = 0 } ^ { \infty } \gamma ^ { t } \hat { r _ { i t } } ( s _ { t } , a _ { 1 t } , . . , a _ { N t } ) ]$ , where $\gamma \in [ 0 , 1 ]$ is the discount factor that determines how much the policy favors immediate reward over long-term gain.
+
+Policy Gradients Policy gradient techniques (Sutton et al., 2000; Williams, 1992) aim to estimate the gradient of an agent’s expected returns with respect to the parameters of its policy. This gradient estimate takes the following form:
+
+$$
+\nabla _ { \theta } J ( \pi _ { \theta } ) = \mathbb { E } _ { a \sim \pi _ { \theta } } \left[ \nabla _ { \theta } \log ( \pi _ { \theta } ( a _ { t } \vert s _ { t } ) ) \sum _ { t ^ { \prime } = t } ^ { \infty } \gamma ^ { t ^ { \prime } - t } r _ { t ^ { \prime } } ( s _ { t ^ { \prime } } , a _ { t ^ { \prime } } ) \right]
+$$
+
+Actor-Critic and Soft Actor-Critic The term P∞t0=t γ $\begin{array} { r } { \sum _ { t ^ { \prime } = t } ^ { \infty } \gamma ^ { t ^ { \prime } - t } r _ { t ^ { \prime } } ( s _ { t ^ { \prime } } , a _ { t ^ { \prime } } ) } \end{array}$ in the policy gradient estimator leads to high variance, as these returns can vary drastically between episodes. Actor-critic methods (Konda & Tsitsiklis, 2000) aim to ameliorate this issue by using a function approximation of the expected returns, and replacing the original return term in the policy gradient estimator with this function. One specific instance of actor-critic methods learns a function to estimate expected discounted returns, given a state and action, $\begin{array} { r } { Q _ { \psi } ( s _ { t } , a _ { t } ) = \mathbb { E } [ \sum _ { t ^ { \prime } = t } ^ { \infty } \gamma ^ { t ^ { \prime } - t } r _ { t ^ { \prime } } ( s _ { t ^ { \prime } } , a _ { t ^ { \prime } } ) ] } \end{array}$ , learned through temporal-difference learning by minimizing the regression loss:
+
+$$
+\begin{array} { r } { \mathcal { L } _ { Q } ( \psi ) = \mathbb { E } _ { s , a , r , s ^ { \prime } } \left[ ( Q _ { \psi } ( s , a ) - y ) ^ { 2 } \right] \mathrm { , w h e r e ~ } y = r ( s , a ) + \gamma \mathbb { E } _ { a ^ { \prime } \sim \pi ( s ^ { \prime } ) } \left[ Q _ { \bar { \psi } } ( s ^ { \prime } , a ^ { \prime } ) \right] } \end{array}
+$$
+
+where $Q _ { \bar { \psi } }$ is the target Q-value function.
+
+To encourage exploration and avoid converging to non-optimal deterministic policies, recent approaches of maximum entropy reinforcement learning learn a soft value function by modifying the policy gradient to incorporate an entropy term (Haarnoja et al., 2018):
+
+$$
+\nabla _ { \theta } J ( \pi _ { \theta } ) = \mathbb { E } _ { a \sim \pi _ { \theta } } \left[ \nabla _ { \theta } \log ( \pi _ { \theta } ( a | s ) ) ( \alpha \log ( \pi _ { \theta } ( a | s ) ) - Q _ { \psi } ( s , a ) + b ( s ) ) \right]
+$$
+
+where $b ( s )$ is a state-dependent baseline (for the $\mathbf { Q }$ -value function). The loss function for temporaldifference learning of the value function is also revised accordingly with a new target:
+
+$$
+y = r ( s , a ) + \gamma \mathbb { E } _ { a ^ { \prime } \sim \pi ( s ^ { \prime } ) } \left[ Q _ { \bar { \psi } } ( s ^ { \prime } , a ^ { \prime } ) - \alpha \ \log ( \pi _ { \theta } ( a ^ { \prime } | s ^ { \prime } ) ) \right]
+$$
+
+While an estimate of the value function $V _ { \phi } ( s )$ can be used a baseline, we provide an alternative that further reduces variance and addresses credit assignment in the multi-agent setting in section 3.2.
+
+# 3.2 MULTIPLE-ACTOR-ATTENTION-CRITIC (MAAC)
+
+The main idea behind our multi-agent learning approach is to learn the critic for each agent by selectively paying attention to other agents’ actions. This is the same paradigm of training critics centrally (to overcome the challenge of non-stationary non-Markovian environments) and executing learned policies distributedly. Figure 1 illustrates the main components of our approach.
+
+Attention The attention mechanism functions in a manner similar to a differentiable key-value memory model (Graves et al., 2014; Oh et al., 2016). Intuitively, each agent queries the other agents for information about their observations and actions and incorporates that information into the estimate of its value function. This paradigm was chosen, in contrast to other attention-based approaches, as it doesn’t make any assumptions about the temporal or spatial locality of the inputs, as opposed to approaches taken in the natural language processing and computer vision fields.
+
+To calculate the Q-value function $Q _ { i } ^ { \psi } ( o , a )$ for the agent $i$ , the critic receives the observations, $o = \left( o _ { 1 } , . . . , o _ { N } \right)$ , and actions, $a = ( a _ { 1 } , . . . , a _ { N } )$ , for all agents indexed by $i \in \{ 1 \ldots N \}$ . We represent the set of all agents except $i$ as $\backslash i$ and we index this set with $j$ . $Q _ { i } ^ { \psi } ( o , a )$ is a function of agent $i$ ’s observation and action, as well as other agents’ contributions:
+
+$$
+Q _ { i } ^ { \psi } ( o , a ) = f _ { i } ( g _ { i } ( o _ { i } , a _ { i } ) , x _ { i } )
+$$
+
+where $f _ { i }$ is a two-layer multi-layer perceptron (MLP), while $g _ { i }$ is a one-layer MLP embedding function. The contribution from other agents, $x _ { i }$ , is a weighted sum of each agent’s value:
+
+![](images/1b63afec914c8275c439d4f59e0a54ef9030be274d1a28a8b7ef0cc5169eda6a.jpg)  
+Figure 1: Calculating $Q _ { i } ^ { \psi } ( o , a )$ with attention for agent $i$ .
+
+$$
+x _ { i } = \sum _ { j \neq i } \alpha _ { j } v _ { j } = \sum _ { j \neq i } \alpha _ { j } h ( V g _ { j } ( o _ { j } , a _ { j } ) )
+$$
+
+where the value, $v _ { j }$ is a function of agent $j$ ’s
+
+embedding, encoded with an embedding function and then linearly transformed by a shared matrix $V , h$ is an element-wise nonlinearity (we have used leaky ReLU).
+
+The attention weight $\alpha _ { j }$ compares the embedding $e _ { j }$ with $e _ { i } = g _ { i } ( o _ { i } , a _ { i } )$ , using a bilinear mapping (ie, the query-key system) and passes the similarity value between these two embeddings into a softmax
+
+$$
+\alpha _ { j } \propto \exp ( e _ { j } ^ { \operatorname { T } } W _ { k } ^ { \operatorname { T } } W _ { q } e _ { i } )
+$$
+
+where $W _ { q }$ transforms $e _ { i }$ into a “query” and $W _ { k }$ transforms $e _ { j }$ into a “key”. The matching is then scaled by the dimensionality of these two matrices to prevent vanishing gradients (Vaswani et al., 2017).
+
+In our experiments, we have used multiple attention heads (Vaswani et al., 2017). In this case, each head, using a separate set of parameters $( W _ { k } , W _ { q } , V )$ , gives rise to an aggregated contribution from all other agents to the agent $i$ and we simply concatenate the contributions from all heads as a single vector. Crucially, each head can focus on a different weighted mixture of agents.
+
+Note that the weights for extracting selectors, keys, and values are shared across all agents, which encourages a common embedding space. The sharing of critic parameters between agents is possible, even in adversarial settings, because multi-agent value-function approximation is, essentially, a multi-task regression problem. This method can easily be extended to include additional information, beyond local observations and actions, at training time, including the global state if it is available, simply by adding additional encoders, $e$ . (We do not consider this case in our experiments, however, as our approach is effective in combining local observations to predict expected returns in environments where the global state may not be available).
+
+Learning with Attentive Critics All critics are updated together to minimize a joint regression loss function, due to the parameter sharing:
+
+$$
+\begin{array} { l } { { \displaystyle { \mathcal L } _ { Q } ( \psi ) = \sum _ { i = 1 } ^ { N } \mathbb E _ { ( o , a , r , o ^ { \prime } ) \sim D } \Big [ ( Q _ { i } ^ { \psi } ( o , a ) - y _ { i } ) ^ { 2 } \Big ] , \mathrm { w h e r e } } } \\ { { \displaystyle y _ { i } = r _ { i } + \gamma \mathbb E _ { a ^ { \prime } \sim \pi _ { \bar { \theta } } ( o ^ { \prime } ) } \Big [ Q _ { i } ^ { \bar { \psi } } ( o ^ { \prime } , a ^ { \prime } ) - \alpha \ \log ( \pi _ { \bar { \theta } _ { i } } ( a _ { i } ^ { ' } | o _ { i } ^ { ' } ) ) \Big ] } } \end{array}
+$$
+
+where $\bar { \psi }$ and $\bar { \theta }$ are the parameters of the target critics and target policies respectively. Note that $Q _ { i } ^ { \psi }$ , the action-value estimate for agent $i$ , receives observations and actions for all agents. $\alpha$ is the temperature parameter determining the balance between maximizing entropy and rewards. The individual policies are updated with the following gradient:
+
+$$
+\nabla _ { \theta _ { i } } J ( \pi _ { \theta } ) = \mathbb { E } _ { a \sim \pi _ { \theta } } \left[ \nabla _ { \theta _ { i } } \log ( \pi _ { \theta _ { i } } ( a _ { i } | o _ { i } ) ) ( \alpha \ \log ( \pi _ { \theta _ { i } } ( a _ { i } | o _ { i } ) ) - Q _ { i } ^ { \psi } ( o , a ) + b ( o , a \setminus i ) ) \right]
+$$
+
+where $b ( o , a _ { \backslash i } )$ is the multi-agent baseline used to calculate the advantage function decribed in the following section. Note that we are sampling all actions, $a$ , from all agents’ current policies in order to calculate the gradient estimate for agent $i$ , unlike in the MADDPG algorithm Lowe et al. (2017), where the other agents’ actions are sampled from the replay buffer, potentially causing overgeneralization where agents fail to coordinate based on their current policies Wei et al. (2018). Full training details and hyperparameters can be found in the appendix 6.1.
+
+Multi-Agent Advantage Function As shown in Foerster et al. (2018), an advantage function using a baseline that only marginalizes out the actions of the given agent from $Q _ { i } ^ { \psi } ( o , a )$ , can help solve the multi-agent credit assignment problem. In other words, by comparing the value of a specific action to the value of the average action for the agent, with all other agents fixed, we can learn whether said action will cause an increase in expected return or whether any increase in reward is attributed to the actions of other agents. The form of this advantage function is shown below:
+
+$$
+\begin{array} { r } { A _ { i } ( o , a ) = Q _ { i } ^ { \psi } ( o , a ) - b ( o , a _ { \backslash i } ) ) , \mathrm { ~ w h e r e ~ } } \\ { b ( o , a _ { \backslash i } ) ) = \mathbb { E } _ { a _ { i } \sim \pi _ { i } ( o _ { i } ) } \left[ Q _ { i } ^ { \psi } ( o , ( a _ { i } , a _ { \backslash i } ) ) \right] } \end{array}
+$$
+
+Using our attention mechanism, we can implement a more general and flexible form of a multiagent baseline that, unlike the advantage function proposed in Foerster et al. (2018), doesn’t assume the same action space for each agent, doesn’t require a global reward, and attends dynamically to other agents, as in our $\mathrm { Q }$ -function. This is made simple by the natural decomposition of an agents encoding, $e _ { i }$ , and the weighted sum of encodings of other agents, $x _ { i }$ , in our attention model.
+
+Concretely, in the case of discrete policies, we can calculate our baseline in a single forward pass by outputting the expected return $Q _ { i } { \big ( } o , { \big ( } a _ { i } , a _ { \backslash i } { \big ) } { \big ) }$ for every possible action, $a _ { i } \in A _ { i }$ , that agent $i$ can take. We can then calculate the expectation exactly:
+
+$$
+\mathbb { E } _ { a _ { i } \sim \pi _ { i } ( o _ { i } ) } \left[ Q _ { i } ^ { \psi } ( o , ( a _ { i } , a _ { \setminus i } ) ) \right] = \sum _ { a _ { i } ^ { \prime } \in A _ { i } } \pi ( a _ { i } ^ { \prime } | o _ { i } ) Q _ { i } ( o , ( a _ { i } ^ { \prime } , a _ { \setminus i } ) )
+$$
+
+In order to do so, we must remove $a _ { i }$ from the input of $Q _ { i }$ , and output a value for every action. We add an observation-encoder, $e _ { i } = g _ { i } ^ { o } ( o _ { i } )$ , for each agent, using these encodings in place of the $e _ { i } = g _ { i } ( o _ { i } , a _ { i } )$ described above, and modify $f _ { i }$ such that it outputs a value for each possible action, rather than the single input action. In the case of continuous policies, we do not need to add any parameters, as we can simply estimate the expectation in Equation 9 by sampling actions from our policy and averaging their $\mathbf { Q }$ -values, though, this comes at the cost of multiple expensive passes through the network.
+
+# 4 EXPERIMENTS
+
+# 4.1 SETUP
+
+We construct two environments that test various capabilities of our approach (MAAC) and baselines. We investigate in two main directions. First, we study the scalability of different methods as the number of agents grows. We hypothesize that the current approach of concatenating all agents’ observations (often used as a global state to be shared among agents) and actions in order to centralize critics does not scale well. To this end, we implement a cooperative environment, Cooperative Treasure Collection, with shared rewards where we can vary the total number of agents. The experimental results in sec 4.3 validate our claim.
+
+Secondly, we want to evaluate each method’s ability to attend to information relevant to rewards. Moreover, the relevance (to rewards) can dynamically change during an episode. This is analogous to real-life tasks such as the soccer example presented earlier. To this end, we implement a Rover-Tower task environment where randomly paired agents communicate information and coordinate.
+
+The two environments are implemented in the multi-agent particle environment framework1 introduced by Mordatch & Abbeel (2018), and extended by Lowe et al. (2017). We found this framework useful for creating environments involving complex interaction between agents, while keeping the control and perception problems simple, as we are primarily interested in addressing agent interaction. To further simplify the control problem, we use discrete action spaces, allowing agents to move up, down, left, right, or stay; however, the agents may not immediately move exactly in the specified direction, as the task framework incorporates a basic physics engine where agents’ momentums are taken into account. Fig. 2 illustrates the two environments.
+
+Cooperative Treasure Collection The cooperative environment in Figure 2a) involves 8 total agents, 6 of which are ”treasure hunters” and 2 of which are “treasure banks”, which each correspond to a different color of treasure. The role of the hunters is to collect the treasure of any color, which re-spawn randomly upon being collected (with a total of 6), and then “deposit” the treasure into the correctly colored “bank”. The role of each bank is to simply gather as much treasure as possible from the hunters. All agents are able to see each others’ positions with respect to their own. Hunters receive a global
+
+(a) Cooperative Treasure Collection. The small grey agents are “hunters” who collect the colored treasure, and deposit them with the correctly colored large “bank” agents.
+
+![](images/196f9f5050f478b3d0ff7933669b33756ff258369934bc880ecf228a3588d3f8.jpg)
+
+![](images/af616e275beaa86e10d3b5d5bf56ab295a010c237b388dc0a2148b49ec269525.jpg)  
+Figure 2: Our environments
+
+(b) Rover-Tower. Each grey “Tower” is paired with a “Rover” and a destination (color of rover corresponds to its destination). Their goal is to communicate with the ”Rover” such that it moves toward the destination.
+
+reward for the successful collection of treasure and all agents receive a global reward for the depositing of treasure. Hunters are additionally penalized for colliding with each other. As such, the task contains a mixture of shared and individual rewards and requires different “modes of attention” which depend on the agent’s state and other agents’ potential for affecting its rewards.
+
+Rover-Tower The environment in Figure 2b involves 8 total agents, 4 of which are “rovers” and another 4 which are “towers”. At each episode, rovers and towers are randomly paired. The pair is negatively rewarded by the distance of the rover to its goal. The task can be thought of as a navigation task on an alien planet with limited infrastructure and low visibility. The rovers are unable to see in their surroundings and must rely on communication from the towers, which are able to locate the rovers as well as their destinations and can send one of five discrete communication messages to their paired rover. Note that communication is highly restricted and different from centralized policy approaches Jiang & Lu (2018), which allow for free transfer of continuous information among policies. In our setup, the communication is integrated into the environment (in the tower’s action space and the rover’s observation space), rather than being explicitly part of the model, and is limited to a few discrete signals.
+
+Table 1: Comparison of various methods for multi-agent RL   
+
+<table><tr><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>Base Algorithm</td><td rowspan=1 colspan=1>Attention</td><td rowspan=1 colspan=1>CentralizedCritic(s)</td><td rowspan=1 colspan=1>Numberof Critics</td><td rowspan=1 colspan=1>Multi-taskLearning of Critics</td><td rowspan=1 colspan=1>Multi-AgentAdvantage</td></tr><tr><td rowspan=1 colspan=1>MAAC (ours)</td><td rowspan=1 colspan=1>SAC</td><td rowspan=1 colspan=1>√</td><td rowspan=1 colspan=1>√</td><td rowspan=1 colspan=1>N</td><td rowspan=1 colspan=1>√</td><td rowspan=1 colspan=1>√</td></tr><tr><td rowspan=1 colspan=1>MAAC(Uniform) (ours)</td><td rowspan=1 colspan=1>SAC</td><td rowspan=1 colspan=1>uniform</td><td rowspan=1 colspan=1>√</td><td rowspan=1 colspan=1>N</td><td rowspan=1 colspan=1>√</td><td rowspan=1 colspan=1>√</td></tr><tr><td rowspan=1 colspan=1>COMA*</td><td rowspan=1 colspan=1>Actor-Critic (On-Policy)</td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>√</td><td rowspan=1 colspan=1>1</td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>√</td></tr><tr><td rowspan=1 colspan=1>MADDPG†</td><td rowspan=1 colspan=1>DDPG</td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>√</td><td rowspan=1 colspan=1>N</td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1></td></tr><tr><td rowspan=1 colspan=1>COMA+SAC</td><td rowspan=1 colspan=1>SAC</td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>√</td><td rowspan=1 colspan=1>1</td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>√</td></tr><tr><td rowspan=1 colspan=1>MADDPG+SAC</td><td rowspan=1 colspan=1>SAC</td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>√</td><td rowspan=1 colspan=1>N</td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>√</td></tr><tr><td rowspan=1 colspan=1>DDPG</td><td rowspan=1 colspan=1>DDPG</td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>N</td><td rowspan=1 colspan=1>N/A</td><td rowspan=1 colspan=1>N/A</td></tr></table>
+
+Centralized $C r i t i c ( s )$ : each agent’s estimate of $Q _ { i }$ takes the actions and observations of the other agents into account. Number of Critics: number of separate networks used for predicting $Q _ { i }$ for all $N$ agents. Multi-task Learning of Critics: all agents’ estimates of $Q _ { i }$ share information in intermediate layers, benefiting from multi-task learning. Multi-Agent Advantage: cf. Sec 3.2 for details. ∗(Foerster et al., 2018), †(Lowe et al., 2017), ‡(Lillicrap et al., 2016)
+
+# 4.2 BASELINES
+
+We compare to two recently proposed approaches for centralized training of decentralized policies: MADDPG (Lowe et al., 2017) and COMA (Foerster et al., 2018), as well as a single-agent RL approach, DDPG, trained separately for each agent.
+
+In order to enable learning in discrete action spaces for both MADDPG and DDPG, where deterministic policies are not possible, we use the Gumbel-Softmax reparametrization trick (Jang et al., 2017). We will refer to these modified versions as MADDPG (Discrete) and DDPG (Discrete). For a detailed description of this reparametrization, see the appendix 6.2. We use soft actor critic to optimize. Thus, in order to have fair comparisons, we additionally implement MADDPG and COMA with Soft Actor-Critic, named as MADDPG $^ +$ SAC and COMA $^ +$ SAC.
+
+We also consider an ablated version of our model as a variant of our approach. In this model, we use uniform attention by fixing the attention weight $\alpha _ { j }$ (Eq. 6) to be $1 / ( N - 1 )$ . This restriction prevents the model from focusing its attention on specific agents.
+
+All methods are implemented such that their approximate total number of parameters (across agents) are equal to our method, and each model is trained with 6 random seeds each. Hyperparameters for each underlying algorithm are tuned based on performance and kept constant across all variants of critic architectures for that algorithm. A thorough comparison of all baselines is summarized in Table 1.
+
+# 4.3 RESULTS AND ANALYSIS
+
+Fig. 3 illustrates averaged rewards per episode by various methods. The proposed approach (MAAC) is competitive with other approaches being compared. In what follows, we provide detailed analysis.
+
+Impact of Rewards and Required Attention Uniform attention is competitive with our approach in the Cooperative Treasure Collection (CTC) environment, but not in Rover-Tower. On the other hand, both MADDPG (Discrete) and MADDPG $^ +$ SAC perform well on Rover-Tower, though they do not on CTC. Both variants of COMA do not fare well in our environments. DDPG, arguably a weaker baseline, performs surprisingly well in CTC, but does poorly in Rover-Tower.
+
+In CTC, the rewards are shared across agents thus an agent’s critic does not need to focus on information from specific agents in order to calculate its expected rewards. Moreover, each agent’s local observation provides enough information to make a decent prediction of its expected rewards. This might explain why MAAC (uniform) which attends to other agents equally, and DDPG (being very unattentive to other agents) perform well.
+
+On the other hand, rewards in the Rover-Tower environment for a specific agent are tied to another single agent’s observations. This environment exemplifies a class of scenarios where dynamic attention can be beneficial: when subgroups of agents are interacting and performing coordinated tasks with separate rewards, but the groups do not remain static. This explains why MAAC (uniform)
+
+![](images/3ea705bb380bed2beaacfcdfa36922d6441291f128b93b1c4d14848b1219e9f7.jpg)  
+Figure 3: (Left) Average Rewards on Cooperative Treasure Collection. (Right) Average Rewards on RoverTower. Our model (MAAC) is competitive in both environments. Error bars are a $9 5 \%$ confidence interval across 6 runs.
+
+perform poorly and DDPG completely breaks down, as knowing information from another specific agent is crucial in predicting expected rewards.
+
+COMA uses a single centralized network for predicting Q-values for all agents with separate forward passes. Thus, this approach may perform best in environments with global rewards and agents with similar action spaces. However, our environments have agents with differing roles (and non-global rewards in the case of Rover-Tower). Thus both variants of COMA do not fare well.
+
+MADDPG (and its variant) is a very strong method. However, we suspect its low performance in CTC is due to this environment’s relatively large observation spaces for all agents, as the MADDPG critic concatenates observations for all agents into a single input vector for each agent’s critic. Our next experiments confirm this hypothesis.
+
+Scalability We compare the average rewards attained by both approaches (normalized by the range of rewards attained in the environment, as differing the number of agents changes the nature of rewards in each environment), and show that the improvement of our approach MAAC over MADDPG $^ +$ SAC grows with respect to the number of agents. As suspected, MADDPG-like critics use all information non-selectively, while our approach can learn which agents to pay more attention through the attention mechanism. Thus our approach scales better when the number of agents increases. In future research we will continue to improve the scalability when the number of agents further increases by sharing policies among agents, and performing attention on sub-groups (of agents).
+
+Table 2: MAAC improves over MADDPG $^ +$ SAC   
+
+<table><tr><td rowspan=1 colspan=1>#agents</td><td rowspan=1 colspan=1>4</td><td rowspan=1 colspan=1>8</td><td rowspan=1 colspan=1>16</td></tr><tr><td rowspan=1 colspan=1>Percentage</td><td rowspan=1 colspan=1>20</td><td rowspan=1 colspan=1>49</td><td rowspan=1 colspan=1>53</td></tr></table>
+
+While the Rover-Tower task has a lot of agents, each agent only gets information about its paired agent – in other words, the task itself has an intrinsically smaller number of “other agents” (conditioned on each agent) than the CTC environment. As a future direction, we are creating more complicated environments where each agent needs to cope with a large group of agents where selective attention is needed. This naturally models real-life scenarios that multiple agents are organized in clusters/sub-societies (school, work, family, etc) where the agent needs to interact with a small number of agents from many groups. We anticipate that in such complicated scenarios, our approach, combined with some advantages exhibited by other approaches would do well.
+
+# 5 CONCLUSION
+
+We propose an algorithm for training decentralized policies in multi-agent settings. The key idea is to utilize attention in order to select relevant information for estimating critics. We analyze the performance of the proposed approach with respect to the number of agents, different configurations of rewards, and the span of relevant observational information. Empirical results are promising and we intend to extend to highly complicated and dynamic environments.
+
+# REFERENCES
+
+Jimmy Ba, Volodymyr Mnih, and Koray Kavukcuoglu. Multiple object recognition with visual attention. In International Conference on Learning Representations, 2015.
+
+Dzmitry Bahdanau, Kyunghyun Cho, and Yoshua Bengio. Neural machine translation by jointly learning to align and translate. In International Conference on Learning Representations, 2015.
+
+Lucian Bus¸oniu, Robert Babuska, and Bart De Schutter. Multi-agent reinforcement learning: Anˇ overview. In Innovations in multi-agent systems and applications-1, pp. 183–221. Springer, 2010.
+
+Jinyoung Choi, Beom-Jin Lee, and Byoung-Tak Zhang. Multi-focus attention network for efficient deep reinforcement learning. arXiv preprint arXiv:1712.04603, December 2017.
+
+Felix Fischer, Michael Rovatsos, and Gerhard Weiss. Hierarchical reinforcement learning in communication-mediated multiagent coordination. In Proceedings of the Third International Joint Conference on Autonomous Agents and Multiagent Systems-Volume 3, pp. 1334–1335. IEEE Computer Society, 2004.
+
+Jakob Foerster, Ioannis Alexandros Assael, Nando de Freitas, and Shimon Whiteson. Learning to communicate with deep multi-agent reinforcement learning. In Advances in Neural Information Processing Systems, pp. 2137–2145, 2016.
+
+Jakob Foerster, Nantas Nardelli, Gregory Farquhar, Triantafyllos Afouras, Philip H. S. Torr, Pushmeet Kohli, and Shimon Whiteson. Stabilising experience replay for deep multi-agent reinforcement learning. In Proceedings of the 34th International Conference on Machine Learning, volume 70 of Proceedings of Machine Learning Research, pp. 1146–1155, International Convention Centre, Sydney, Australia, 06–11 Aug 2017.
+
+Jakob Foerster, Gregory Farquhar, Triantafyllos Afouras, Nantas Nardelli, and Shimon Whiteson. Counterfactual multi-agent policy gradients, 2018.
+
+Alex Graves, Greg Wayne, and Ivo Danihelka. Neural turing machines. arXiv preprint arXiv:1410.5401, 2014.
+
+Jayesh K Gupta, Maxim Egorov, and Mykel Kochenderfer. Cooperative multi-agent control using deep reinforcement learning. In Autonomous Agents and Multiagent Systems, Lecture Notes in Computer Science, pp. 66–83. Springer, Cham, May 2017.
+
+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, volume 80 of Proceedings of Machine Learning Research, pp. 1861–1870, Stockholmsmssan, Stockholm Sweden, 10–15 Jul 2018.
+
+He He, Jordan Boyd-Graber, Kevin Kwok, and Hal Daume III. Opponent modeling in deep rein- ´ forcement learning. In International Conference on Machine Learning, pp. 1804–1813, 2016.
+
+Nicolas Heess, Srinivasan Sriram, Jay Lemmon, Josh Merel, Greg Wayne, Yuval Tassa, Tom Erez, Ziyu Wang, Ali Eslami, Martin Riedmiller, et al. Emergence of locomotion behaviours in rich environments. arXiv preprint arXiv:1707.02286, 2017.
+
+Eric Jang, Shixiang Gu, and Ben Poole. Categorical reparameterization with gumbel-softmax. In International Conference on Learning Representations, 2017.
+
+Jiechuan Jiang and Zongqing Lu. Learning attentional communication for multi-agent cooperation. arXiv preprint arXiv:1805.07733, 2018.
+
+Diederik P Kingma and Jimmy Ba. Adam: A method for stochastic optimization. In International Conference on Learning Representations, 2014.
+
+Vijay R Konda and John N Tsitsiklis. Actor-critic algorithms. In Advances in neural information processing systems, pp. 1008–1014, 2000.
+
+Timothy P Lillicrap, Jonathan J Hunt, Alexander Pritzel, Nicolas Heess, Tom Erez, Yuval Tassa, David Silver, and Daan Wierstra. Continuous control with deep reinforcement learning. In International Conference on Learning Representations, 2016.
+
+Zhouhan Lin, Minwei Feng, Cicero Nogueira dos Santos, Mo Yu, Bing Xiang, Bowen Zhou, and Yoshua Bengio. A structured self-attentive sentence embedding. In International Conference on Learning Representations, 2017.
+
+Michael L Littman. Markov games as a framework for multi-agent reinforcement learning. In Machine Learning Proceedings 1994, pp. 157–163. Elsevier, 1994.
+
+Ryan Lowe, Yi Wu, Aviv Tamar, Jean Harb, OpenAI Pieter Abbeel, and Igor Mordatch. Multi-agent actor-critic for mixed cooperative-competitive environments. In Advances in Neural Information Processing Systems, pp. 6382–6393, 2017.
+
+Volodymyr Mnih, Nicolas Heess, Alex Graves, et al. Recurrent models of visual attention. In Advances in neural information processing systems, pp. 2204–2212, 2014.
+
+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, 2015.
+
+Igor Mordatch and Pieter Abbeel. Emergence of grounded compositional language in multi-agent populations, 2018.
+
+Junhyuk Oh, Valliappa Chockalingam, Honglak Lee, et al. Control of memory, active perception, and action in minecraft. In International Conference on Machine Learning, pp. 2790–2799, 2016.
+
+Tabish Rashid, Mikayel Samvelyan, Christian Schroeder, Gregory Farquhar, Jakob Foerster, and Shimon Whiteson. QMIX: Monotonic value function factorisation for deep multi-agent reinforcement learning. In Proceedings of the 35th International Conference on Machine Learning, volume 80 of Proceedings of Machine Learning Research, pp. 4295–4304, Stockholmsmssan, Stockholm Sweden, 10–15 Jul 2018.
+
+John Schulman, Sergey Levine, Pieter Abbeel, Michael Jordan, and Philipp Moritz. Trust region policy optimization. In International Conference on Machine Learning, pp. 1889–1897, 2015.
+
+John Schulman, Filip Wolski, Prafulla Dhariwal, Alec Radford, and Oleg Klimov. Proximal policy optimization algorithms. arXiv preprint arXiv:1707.06347, 2017.
+
+David Silver, Aja Huang, Chris J Maddison, Arthur Guez, Laurent Sifre, George Van Den Driessche, Julian Schrittwieser, Ioannis Antonoglou, Veda Panneershelvam, Marc Lanctot, et al. Mastering the game of go with deep neural networks and tree search. nature, 529(7587):484–489, 2016.
+
+Sainbayar Sukhbaatar, Rob Fergus, et al. Learning multiagent communication with backpropagation. In Advances in Neural Information Processing Systems, pp. 2244–2252, 2016.
+
+Peter Sunehag, Guy Lever, Audrunas Gruslys, Wojciech Marian Czarnecki, Vinicius Zambaldi, Max Jaderberg, Marc Lanctot, Nicolas Sonnerat, Joel Z. Leibo, Karl Tuyls, and Thore Graepel. Valuedecomposition networks for cooperative multi-agent learning based on team reward. In Proceedings of the 17th International Conference on Autonomous Agents and MultiAgent Systems, AAMAS ’18, pp. 2085–2087, Richland, SC, 2018. International Foundation for Autonomous Agents and Multiagent Systems.
+
+Richard S Sutton, David A McAllester, Satinder P Singh, and Yishay Mansour. Policy gradient methods for reinforcement learning with function approximation. In Advances in neural information processing systems, pp. 1057–1063, 2000.
+
+Ardi Tampuu, Tambet Matiisen, Dorian Kodelja, Ilya Kuzovkin, Kristjan Korjus, Juhan Aru, Jaan Aru, and Raul Vicente. Multiagent cooperation and competition with deep reinforcement learning. PLoS One, 12(4):e0172395, April 2017.
+
+Ming Tan. Multi-agent reinforcement learning: independent versus cooperative agents. In Proceedings of the Tenth International Conference on International Conference on Machine Learning, pp. 330–337. Morgan Kaufmann Publishers Inc., 1993.
+
+Ashish Vaswani, Noam Shazeer, Niki Parmar, Jakob Uszkoreit, Llion Jones, Aidan N Gomez, Łukasz Kaiser, and Illia Polosukhin. Attention is all you need. In Advances in Neural Information Processing Systems, pp. 6000–6010, 2017.
+
+Ermo Wei, Drew Wicke, David Freelan, and Sean Luke. Multiagent soft q-learning. arXiv preprint arXiv:1804.09817, 2018.
+
+Ronald J Williams. Simple statistical gradient-following algorithms for connectionist reinforcement learning. In Reinforcement Learning, pp. 5–32. Springer, 1992.
+
+# 6 APPENDIX
+
+# Algorithm 1 Training Procedure for Attention-Actor-Critic
+
+1: Initialize $E$ parallel environments with $N$ agents, each   
+2: Initialize replay buffer, $D$   
+3: $T _ { \mathrm { u p d a t e } } \gets 0$   
+4: for $i _ { \mathrm { e p } } = 1 \ldots$ num episodes do   
+5: Reset environments, and get initial $o _ { i } ^ { e }$ for each agent, $i$   
+6: for $t = 1$ . . . steps per episode do   
+7: Select actions $a _ { i } ^ { e } \sim \pi _ { i } ( \cdot | o _ { i } ^ { e } )$ for each agent, $i$ , in each environment, $e$   
+8: Send actions to all parallel environments and get $\boldsymbol { o ^ { \prime } } _ { i } ^ { e }$ , $\boldsymbol { r } _ { i } ^ { e }$ for all agents in all environments   
+9: Store transitions $\left( o _ { 1 \dots N } , a _ { 1 \dots N } , r _ { 1 \dots N } , o _ { 1 \dots N } ^ { \prime } \right)$ for all environments in $D$   
+10: $T _ { \mathrm { u p d a t e } } = T _ { \mathrm { u p d a t e } } + E$   
+11: if $T _ { \mathrm { u p d a t e } } \geq \mathrm { \bar { m i n } }$ steps per update then   
+12: for $j = 1$ . . . num critic updates do   
+13: Sample minibatch $B \gets m \times ( o _ { 1 . . . N } , a _ { 1 . . . N } , r _ { 1 . . . N } , o _ { 1 . . . N } ^ { \prime } ) \sim D$   
+14: UPDATECRITIC $( B )$   
+15: end for   
+16: for $j = 1 \ldots \mathrm { n u m }$ policy updates do   
+17: 18: Sample UPDAT $m \times \left( o _ { 1 \dots N } \right) \sim D$ $( \acute { o } _ { 1 \dots N } ^ { B } )$   
+19: end for   
+20: Update target critic and policy parameters:
+
+$$
+\begin{array} { c } { { \bar { \psi } = \tau \bar { \psi } + ( 1 - \tau ) \psi } } \\ { { { } } } \\ { { \bar { \theta } = \tau \bar { \theta } + ( 1 - \tau ) \theta } } \end{array}
+$$
+
+21: $T _ { \mathrm { u p d a t e } } \gets 0$   
+22: end if   
+23: end for   
+24: end for   
+25:   
+26: 27: function UPDATECRIUnpack minibatch $( B )$   
+$( o _ { 1 \dots N } ^ { B } , a _ { 1 \dots N } ^ { B } , r _ { 1 \dots N } ^ { B } , o _ { 1 \dots N } ^ { ' B } )  B$   
+28: Calculate $Q _ { i } ^ { \psi } ( o _ { 1 \ldots N } ^ { B } , a _ { 1 \ldots N } ^ { B } )$ for all $i$ in parallel   
+29: Calculate $a _ { i } ^ { ' B } \sim \pi _ { i } ^ { \bar { \theta } } ( o _ { i } ^ { ' B } )$ using target policies   
+30: Calculate $Q _ { i } ^ { \bar { \psi } } ( o _ { 1 \dots N } ^ { ' B } , a _ { 1 \dots N } ^ { ' B } )$ for all $i$ in parallel, using target critic   
+31: Update critic:
+
+$$
+\begin{array} { l } { \displaystyle \mathcal { L } _ { Q } ( \psi ) = \sum _ { i = 1 } ^ { N } \mathbb { E } _ { ( o , a , r , o ^ { \prime } ) \sim D } \Big [ ( Q _ { i } ^ { \psi } ( o , a ) - y _ { i } ) ^ { 2 } \Big ] , \mathrm { w h e r e } } \\ { \displaystyle y _ { i } = r _ { i } + \gamma \mathbb { E } _ { a ^ { \prime } \sim \bar { \pi _ { i } } ( o ^ { \prime } ) } \Big [ Q _ { i } ^ { \bar { \psi } } ( o ^ { \prime } , a ^ { \prime } ) - \alpha l o g ( \pi _ { \bar { \theta _ { i } } } ( a _ { i } ^ { ' } | o _ { i } ^ { ' } ) ) \Big ] } \end{array}
+$$
+
+32: end function
+
+34: function UPDATEPOLICIES $( o _ { 1 \dots N } ^ { B } )$
+
+35: Calculate $a _ { 1 \dots N } ^ { B } \sim \pi _ { i } ^ { \bar { \theta } } ( o _ { i } ^ { ' B } ) , i \in 1 \dots N$
+
+36: Calculate $Q _ { i } ^ { \psi } ( o _ { 1 \ldots N } ^ { B } , a _ { 1 \ldots N } ^ { B } )$ for all $i$ in parallel
+
+37: Update policies:
+
+$$
+\nabla _ { \theta _ { i } } J ( \pi _ { \theta } ) = \mathbb { E } _ { a \sim \pi _ { \theta } } \left[ \nabla _ { \theta _ { i } } l o g ( \pi _ { \theta _ { i } } ( a _ { i } | o _ { i } ) ) ( \alpha l o g ( \pi _ { \theta _ { i } } ( a _ { i } | o _ { i } ) ) - Q _ { i } ^ { \psi } ( o , a ) + b ( o , \bar { a } ) ) \right]
+$$
+
+# 38: end function
+
+# 6.1 TRAINING PROCEDURE
+
+We train using Soft Actor-Critic (Haarnoja et al., 2018), an off-policy, actor-critic method for maximum entropy reinforcement learning. Our training procedure consists of performing 12 parallel rollouts, and adding a tuple of $\big ( o _ { t } , a _ { t } , r _ { t } , o _ { t + 1 } \big ) _ { 1 \dots N }$ to a replay buffer (with maximum length 1e6) for each timepoint. We reset each environment after every 100 steps (an episode). After 100 steps (across all rollouts), we perform 4 updates for the attention critic and for all policies. For each update we sample minibatches of 1024 timepoints from the replay buffer and then perform gradient descent on the Q-function loss objective (7), as well as the policy objective (8), using Adam (Kingma & Ba, 2014) as the optimizer for both with a learning rate of 0.001. These updates can be computed efficiently in parallel (across agents) using a GPU. After the updates are complete, we update the parameters $\dot { \psi }$ of our target critic $Q _ { \bar { \psi } }$ to move toward our learned critic’s parameters, $\psi$ , as in Lillicrap et al. (2016); Haarnoja et al. (2018): $\bar { \psi } = ( 1 - \tau ) \bar { \psi } + \tau \psi$ , where $\tau$ is the update rate (set to 0.002 for attention parameters and 0.04 for all other parameters). Using a target critic has been shown to stabilize the use of experience replay for off-policy reinforcement learning with neural network function approximators (Mnih et al., 2015; Lillicrap et al., 2016). We update the parameters of the target policies, $\bar { \theta }$ in the same manner. We use a discount factor, $\gamma$ , of 0.99. All networks (separate policies and contained within the centralized critics) use a hidden dimension of 128 and Leaky Rectified Linear Units as the nonlinearity. We use 0.2 as our temperature setting for Soft Actor-Critic. Additionally, we typically use 4 attention heads in our attention critics unless otherwise specified.
+
+# 6.2 REPARAMETRIZATION OF DDPG/MADDPG FOR DISCRETE ACTION SPACES
+
+In order to compare to DDPG and MADDPG in our environments with discrete action spaces, we must make a slight modification to the basic algorithm. This modification is first suggested by Lowe et al. (2017) in order to enable policies that output discrete communication messages. Consider the original DDPG policy gradient which takes advantage of the fact that you can easily calculate the gradient of the output of a deterministic policy with respect to its parameters.
+
+$$
+\nabla _ { \theta } J = \mathbb { E } _ { s \sim \rho } \left[ \nabla _ { a } Q ( s , a ) | _ { a = \mu ( s ) } \nabla _ { \theta } \mu ( s | \theta ) \right]
+$$
+
+Rather than policies that deterministically output an action from within a continuous action space, we use policies that produce differentiable samples through a Gumbel-Softmax distribution (Jang et al., 2017). Using differentiable samples allows us to use the gradient of expected returns to train policies without using the log derivative trick, just as in DDPG.
+
+$$
+\nabla _ { \theta } J = \mathbb { E } _ { s \sim \rho , a \sim \pi ( s ) } \left[ \nabla _ { a } Q ( s , a ) \nabla _ { \theta } a \right]
+$$
+
+# 6.3 VISUALIZING ATTENTION
+
+In order to understand how the use of attention evolves over the course of training, we examine the ”entropy” of the attention weights for each agent for each of the four attention heads that we use in both tasks (Figures 4 and 5). The black bars indicate the maximum possible entropy (i.e. uniform attention across all agents). Lower entropy indicates that the head is focusing on specific agents, with an entropy of 0 indicating attention focusing on one agent. In Rover-Tower, we plot the attention entropy for each rover. Interestingly, each agent appears to use a different combination of the four heads, but their use is not mutually exclusive, indicating that the inclusion of separate attention heads for each agent is not necessary. This differential use of attention heads is sensible due to the nature of rewards in this environment (i.e. individualized rewards). In the case of Treasure Collection, we find that all agents use the attention heads similarly, which is unsurprising considering that rewards are shared in that environment.
+
+In order to inspect how the attention mechanism is working on a more fine-grained level, we visualize the attention weights for one of the rovers in Rover-Tower (Figure 6), from the head that the agent appears to use the most (determined by looking at Figure 4), while changing the tower that said rover is paired to. In these plots, we ignore the weights over other rovers for simplicity since these are always near zero. We find that the rover learns to strongly attend to the tower that it is paired with, without any explicit supervision signal to do so. The model implicitly learns which agent is most relevant to estimating the rover’s expecture future returns, and said agent can change dynamically without affecting the performance of the algorithm.
+
+![](images/dd6d226b64964d0586712c101b05f8f35f4c98b43b49eba256d1ac3e6721a78c.jpg)  
+Figure 4: Attention ”entropy” for each head over the course of training for the four rovers in the Rover-Tower environment
+
+![](images/3b64d8a5ae6a830193dffa365d2dc696f9bf36d1a08a6a75ed444b65375a6deb.jpg)  
+Figure 5: Attention ”entropy” for each head over the course of training for two collectors in the Treasure Collection Environment
+
+# 6.4 CONTINUOUS ACTION SPACES
+
+In order to test our model’s ability to handle continuous action spaces, we add a network for each agent to learn a state-value function $V _ { i } ( o , a _ { \backslash i } )$ , which uses the same weighted attention embedding over other agents as $Q _ { i } ( o , a )$ . The loss functions to learn both networks are provided by Haarnoja et al. (2018). We test on an environment introduced in Lowe et al. (2017) called Cooperative Navigation and compare to MADDPG. Our results are presented in Table 3. This task does not require attention, as all agents are relevant to each others rewards at each time step. As such, it is unsurprising that our approach matches but does not surpass the performance of MADDPG. It is notable, however, both that attention does not harm performance in simple cases and that our approach handles continuous action spaces as well.
+
+Table 3: Cooperative Navigation (Continuous)   
+
+<table><tr><td>MADDPG</td><td>MAAC</td></tr><tr><td>-2.47 ± 0.05</td><td>-2.49 ±0.11</td></tr></table>
+
+![](images/202b9b1da1f524d817219da2b216af9549b8bbb38788d6852c92299fca0b6d58.jpg)  
+Figure 6: Attention weights when subjected to different Tower pairings for Rover 1 in Rover-Tower environment

parse/train/HJx7l309Fm/HJx7l309Fm_content_list.json

@@ -0,0 +1,1956 @@
+[
+    {
+        "type": "text",
+        "text": "ACTOR-ATTENTION-CRITIC FOR MULTI-AGENT REINFORCEMENT LEARNING ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            98,
+            821,
+            146
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Anonymous authors Paper under double-blind review ",
+        "bbox": [
+            183,
+            171,
+            398,
+            198
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "ABSTRACT ",
+        "text_level": 1,
+        "bbox": [
+            454,
+            236,
+            544,
+            251
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Reinforcement learning in multi-agent scenarios is important for real-world applications but presents challenges beyond those seen in single-agent settings. We present an actor-critic algorithm that trains decentralized policies in multi-agent settings, using centrally computed critics that share an attention mechanism which selects relevant information for each agent at every timestep. This attention mechanism enables more effective and scalable learning in complex multi-agent environments, when compared to recent approaches. Our approach is applicable not only to cooperative settings with shared rewards, but also individualized reward settings, including adversarial settings, and it makes no assumptions about the action spaces of the agents. As such, it is flexible enough to be applied to most multi-agent learning problems. ",
+        "bbox": [
+            233,
+            267,
+            764,
+            419
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 INTRODUCTION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            445,
+            336,
+            462
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Reinforcement learning has recently made exciting progress in many domains, including Atari games (Mnih et al., 2015), the ancient Chinese board game, Go (Silver et al., 2016), and complex continuous control tasks involving locomotion (Lillicrap et al., 2016; Schulman et al., 2015; 2017; Heess et al., 2017). While most reinforcement learning paradigms focus on single agents acting in a static environment (or against themselves in the case of Go), real-world agents often compete or cooperate with other agents in a dynamically shifting environment. In order to learn effectively in multi-agent environments, agents must not only learn the dynamics of their environment, but also those of the other learning agents present. ",
+        "bbox": [
+            174,
+            477,
+            825,
+            589
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "To this end, several approaches for multi-agent reinforcement learning have been developed. The simplest approach is to train each agent independently to maximize their individual reward, while treating other agents as part of the environment. However, this approach violates the basic assumption underlying reinforcement learning, that the environment should be stationary and Markovian. Any single agent’s environment is dynamic and nonstationary due to other agents’ changing policies. As such, standard algorithms developed for stationary Markov decision processes fail. ",
+        "bbox": [
+            174,
+            595,
+            825,
+            679
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "At the other end of the spectrum, all agents can be collectively modeled as a single-agent whose action space is the joint action space of all agents (Bus¸oniu et al., 2010). While allowing coordinated behaviors across agents, this approach is not scalable due to the action space size increasing exponentially with the number of agents. It also demands a high degree of communication during execution, as the central policy must collect observations from and distribute actions to the individual agents. In real-world settings, this demand can be problematic. ",
+        "bbox": [
+            174,
+            686,
+            823,
+            770
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Recent work (Lowe et al., 2017; Foerster et al., 2018) attempts to combine the strengths of these two approaches. In particular, a critic (or a number of critics) is centrally learned with information from all agents. The actors, however, receive information only from their corresponding agents. Thus, during testing, executing the policies does not require the knowledge of other agents’ actions. This paradigm circumvents the challenge of non-Markovian and non-stationary environments during learning. Despite those progresses, however, algorithms for multi-agent reinforcement learning are still far from being scalable (to a larger number of agents) and being generically applicable to environments and tasks that are co-operative (sharing a global reward), competitive, or mixed. ",
+        "bbox": [
+            174,
+            776,
+            825,
+            888
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Our approach extends these prior works in several directions. The main idea is to centrally learn a critic with an attention mechanism. The intuition behind our idea is that in many real-world environments, it is beneficial for agents to know what other agents it should pay attention to. For example, a soccer defender needs to pay attention to attackers in their vicinity as well as the player with the ball, while she/he rarely needs to pay attention to the opposing team’s goalie. The specific attackers that the defender is paying attention to can change at different parts of the game, depending on the formation and strategy of the opponent. A typical centralized approach to multi-agent reinforcement learning does not take these dynamics into account, instead simply considering all agents at all timepoints. Our attention mechanism is able to dynamically select which agents to attend to at each time point, improving performance in multi-agent domains with complex interactions. ",
+        "bbox": [
+            174,
+            895,
+            823,
+            924
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            103,
+            825,
+            215
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "The proposed approach has an input space linearly increasing with respect to the number of agents, as opposed to the quadratic increase in a previous approach Lowe et al. (2017). It also works well in co-operative, competitive, and mixed environments, exceeding the capability of some prior work that focuses only on co-operative environments Foerster et al. (2018). ",
+        "bbox": [
+            174,
+            222,
+            825,
+            277
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "We have validated our approach on two simulated environments and tasks. We plan to release the code for both the model and the environments after the reviewing period ends. ",
+        "bbox": [
+            174,
+            285,
+            820,
+            313
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "The rest of the paper is organized as follows. In section 2, we discuss related work, followed by a detailed description of our approach in section 3. We report experimental studies in section 4 and conclude in section 5. ",
+        "bbox": [
+            174,
+            319,
+            825,
+            362
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2 RELATED WORK ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            396,
+            344,
+            412
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Multi-Agent Reinforcement Learning (MARL) is a long studied problem (Bus¸oniu et al., 2010). Topics within MARL are diverse, ranging from learning communication between cooperative agents (Tan, 1993; Fischer et al., 2004) to algorithms for optimal play in competitive settings (Littman, 1994), though, until recently, they have been focused on simple gridworld environments with tabular learning methods. ",
+        "bbox": [
+            174,
+            435,
+            823,
+            506
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "As deep learning based approaches to reinforcement learning have grown more popular, they have, naturally, been applied to the MARL setting (Tampuu et al., 2017; Gupta et al., 2017), allowing multi-agent learning in high-dimensional/continuous state spaces; however, naive applications of Deep RL methods to MARL naturally encounter some limitations, such as nonstationarity of the environment from the perspective of individual agents (Foerster et al., 2017; Lowe et al., 2017; Foerster et al., 2018), lack of coordination/communication in cooperative settings (Sukhbaatar et al., 2016; Mordatch & Abbeel, 2018; Lowe et al., 2017; Foerster et al., 2016), credit assignment in cooperative settings with global rewards (Rashid et al., 2018; Sunehag et al., 2018; Foerster et al., 2018), and the failure to take opponent strategies into account when learning agent policies (He et al., 2016). ",
+        "bbox": [
+            174,
+            513,
+            825,
+            651
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Most relevant to this work are recent, non-attention approaches that propose an actor-critic framework consisting of centralized training with decentralized execution (Lowe et al., 2017; Foerster et al., 2018), as well as some approaches that utilize attention in a fully centralized multi-agent setting (Choi et al., 2017; Jiang & Lu, 2018). Lowe et al. (2017) investigate the challenges of multiagent learning in mixed reward environments (Bus¸oniu et al., 2010). They propose an actor-critic method that uses separate centralized critics for each agent which take in all other agents’ actions and observations as input, while training policies that are conditioned only on local information. This practice reduces the non-stationarity of multi-agent environments, as considering the actions of other agents to be part of the environment makes the state transition dynamics stable from the perspective of one agent. In practice, these ideas greatly stabilize learning, due to reduced variance in the value function estimates. ",
+        "bbox": [
+            174,
+            659,
+            825,
+            810
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Similarly Foerster et al. (2018) introduce a centralized critic for cooperative settings with shared rewards. Their method incorporates a ”counterfactual baseline” for calculating the advantage function which is able to marginalize a single agent’s actions while keeping others fixed. This method allows for complex multi-agent credit assignment, as the advantage function only encourages actions that directly influence an agent’s rewards. ",
+        "bbox": [
+            174,
+            819,
+            823,
+            888
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Attention models have recently emerged as a successful approach to intelligently selecting contextual information, with applications in computer vision (Ba et al., 2015; Mnih et al., 2014), natural language processing(Vaswani et al., 2017; Bahdanau et al., 2015; Lin et al., 2017), and reinforcement learning (Oh et al., 2016). ",
+        "bbox": [
+            174,
+            895,
+            821,
+            924
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            103,
+            823,
+            132
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "In a similar vein, Jiang & Lu (2018) proposed an attention-based actor-critic algorithm for MARL. This work follows the alternative paradigm of centralizing policies while keeping the critics decentralized. Their focus is on learning an attention model for sharing information between the policies. As such, this approach is complementary to ours, and a combination of both approaches could yield further performance benefits in cases where centralized policies are desirable. ",
+        "bbox": [
+            174,
+            138,
+            823,
+            208
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Our proposed approach is more flexible than the aformentioned approaches for MARL. Our algorithm is able to train policies in environments with any reward setup, different action spaces for each agent, a variance-reducing baseline that only marginalizes the relevant agent’s actions, and with a set of centralized critics that dynamically attend to the relevant information for each agent at each time point. As such, our approach is more scalable to the number of agents, and is more broadly applicable to different types of environments. ",
+        "bbox": [
+            174,
+            215,
+            825,
+            299
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3 OUR APPROACH",
+        "text_level": 1,
+        "bbox": [
+            176,
+            319,
+            341,
+            335
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "We start by introducing the necessary notation and basic building blocks for our approach. We then describe our ideas in detail. ",
+        "bbox": [
+            174,
+            351,
+            823,
+            378
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3.1 NOTATION AND BACKGROUND",
+        "text_level": 1,
+        "bbox": [
+            176,
+            395,
+            426,
+            410
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "We consider the framework of Markov Games (Littman, 1994), which is a multi-agent extension of Markov Decision Processes. They are defined by a set of states, $S$ , action sets for each of $N$ agents, $A _ { 1 } , . . . , A _ { N }$ , a state transition function, $T : S \\times A _ { 1 } \\times . . . \\times A _ { N }  P ( S )$ , which defines the probability distribution over possible next states, given the current state and actions for each agent, and a reward function for each agent that also depends on the global state and actions of all agents, $R _ { i } : S \\times A _ { 1 } \\times . . . \\times A _ { N } \\to \\mathbb { R }$ . We will specifically be considering a partially observable variant in which an agent, $i$ receives an observation, $o _ { i }$ , which contains partial information from the global state, $s \\in S$ . Each agent learns a policy, $\\pi _ { i } : O _ { i } \\to P ( A _ { i } )$ which maps each agent’s observation to a distribution over it’s set of actions. The agents aim to learn a policy that maximizes their expected discounted returns, $J _ { i } ( \\pi _ { i } ) = \\mathbb { E } _ { a _ { 1 } \\sim \\pi _ { 1 } , \\dots , a _ { N } \\sim \\pi _ { N } , s \\sim T } [ \\sum _ { t = 0 } ^ { \\infty } \\gamma ^ { t } \\hat { r _ { i t } } ( s _ { t } , a _ { 1 t } , . . , a _ { N t } ) ]$ , where $\\gamma \\in [ 0 , 1 ]$ is the discount factor that determines how much the policy favors immediate reward over long-term gain. ",
+        "bbox": [
+            173,
+            421,
+            825,
+            588
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Policy Gradients Policy gradient techniques (Sutton et al., 2000; Williams, 1992) aim to estimate the gradient of an agent’s expected returns with respect to the parameters of its policy. This gradient estimate takes the following form: ",
+        "bbox": [
+            174,
+            603,
+            823,
+            646
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/44abfc5bd83f84432365025338e4536bc141e6e8f8c9435852e5e3bc3603ef60.jpg",
+        "text": "$$\n\\nabla _ { \\theta } J ( \\pi _ { \\theta } ) = \\mathbb { E } _ { a \\sim \\pi _ { \\theta } } \\left[ \\nabla _ { \\theta } \\log ( \\pi _ { \\theta } ( a _ { t } \\vert s _ { t } ) ) \\sum _ { t ^ { \\prime } = t } ^ { \\infty } \\gamma ^ { t ^ { \\prime } - t } r _ { t ^ { \\prime } } ( s _ { t ^ { \\prime } } , a _ { t ^ { \\prime } } ) \\right]\n$$",
+        "text_format": "latex",
+        "bbox": [
+            294,
+            651,
+            702,
+            695
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Actor-Critic and Soft Actor-Critic The term P∞t0=t γ $\\begin{array} { r } { \\sum _ { t ^ { \\prime } = t } ^ { \\infty } \\gamma ^ { t ^ { \\prime } - t } r _ { t ^ { \\prime } } ( s _ { t ^ { \\prime } } , a _ { t ^ { \\prime } } ) } \\end{array}$ in the policy gradient estimator leads to high variance, as these returns can vary drastically between episodes. Actor-critic methods (Konda & Tsitsiklis, 2000) aim to ameliorate this issue by using a function approximation of the expected returns, and replacing the original return term in the policy gradient estimator with this function. One specific instance of actor-critic methods learns a function to estimate expected discounted returns, given a state and action, $\\begin{array} { r } { Q _ { \\psi } ( s _ { t } , a _ { t } ) = \\mathbb { E } [ \\sum _ { t ^ { \\prime } = t } ^ { \\infty } \\gamma ^ { t ^ { \\prime } - t } r _ { t ^ { \\prime } } ( s _ { t ^ { \\prime } } , a _ { t ^ { \\prime } } ) ] } \\end{array}$ , learned through temporal-difference learning by minimizing the regression loss: ",
+        "bbox": [
+            173,
+            708,
+            825,
+            810
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/4f9200a85c73de71161a839b8e912110c3e82cd247174a88e9746bc2e9723657.jpg",
+        "text": "$$\n\\begin{array} { r } { \\mathcal { L } _ { Q } ( \\psi ) = \\mathbb { E } _ { s , a , r , s ^ { \\prime } } \\left[ ( Q _ { \\psi } ( s , a ) - y ) ^ { 2 } \\right] \\mathrm { , w h e r e ~ } y = r ( s , a ) + \\gamma \\mathbb { E } _ { a ^ { \\prime } \\sim \\pi ( s ^ { \\prime } ) } \\left[ Q _ { \\bar { \\psi } } ( s ^ { \\prime } , a ^ { \\prime } ) \\right] } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            218,
+            814,
+            777,
+            834
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "where $Q _ { \\bar { \\psi } }$ is the target Q-value function. ",
+        "bbox": [
+            176,
+            838,
+            439,
+            854
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "To encourage exploration and avoid converging to non-optimal deterministic policies, recent approaches of maximum entropy reinforcement learning learn a soft value function by modifying the policy gradient to incorporate an entropy term (Haarnoja et al., 2018): ",
+        "bbox": [
+            174,
+            859,
+            823,
+            902
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/237841cd52604e344a39fb2d5324d225775d66f34bb312ee4e76c6dfc98a2571.jpg",
+        "text": "$$\n\\nabla _ { \\theta } J ( \\pi _ { \\theta } ) = \\mathbb { E } _ { a \\sim \\pi _ { \\theta } } \\left[ \\nabla _ { \\theta } \\log ( \\pi _ { \\theta } ( a | s ) ) ( \\alpha \\log ( \\pi _ { \\theta } ( a | s ) ) - Q _ { \\psi } ( s , a ) + b ( s ) ) \\right]\n$$",
+        "text_format": "latex",
+        "bbox": [
+            253,
+            907,
+            743,
+            925
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "where $b ( s )$ is a state-dependent baseline (for the $\\mathbf { Q }$ -value function). The loss function for temporaldifference learning of the value function is also revised accordingly with a new target: ",
+        "bbox": [
+            171,
+            103,
+            821,
+            132
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/3d6e9a6cb479b17784368062c8208d16c2a4b99de992cb1002c6ba077dd31ada.jpg",
+        "text": "$$\ny = r ( s , a ) + \\gamma \\mathbb { E } _ { a ^ { \\prime } \\sim \\pi ( s ^ { \\prime } ) } \\left[ Q _ { \\bar { \\psi } } ( s ^ { \\prime } , a ^ { \\prime } ) - \\alpha \\ \\log ( \\pi _ { \\theta } ( a ^ { \\prime } | s ^ { \\prime } ) ) \\right]\n$$",
+        "text_format": "latex",
+        "bbox": [
+            305,
+            138,
+            691,
+            159
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "While an estimate of the value function $V _ { \\phi } ( s )$ can be used a baseline, we provide an alternative that further reduces variance and addresses credit assignment in the multi-agent setting in section 3.2. ",
+        "bbox": [
+            171,
+            165,
+            823,
+            194
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3.2 MULTIPLE-ACTOR-ATTENTION-CRITIC (MAAC) ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            212,
+            557,
+            227
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "The main idea behind our multi-agent learning approach is to learn the critic for each agent by selectively paying attention to other agents’ actions. This is the same paradigm of training critics centrally (to overcome the challenge of non-stationary non-Markovian environments) and executing learned policies distributedly. Figure 1 illustrates the main components of our approach. ",
+        "bbox": [
+            174,
+            238,
+            825,
+            295
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Attention The attention mechanism functions in a manner similar to a differentiable key-value memory model (Graves et al., 2014; Oh et al., 2016). Intuitively, each agent queries the other agents for information about their observations and actions and incorporates that information into the estimate of its value function. This paradigm was chosen, in contrast to other attention-based approaches, as it doesn’t make any assumptions about the temporal or spatial locality of the inputs, as opposed to approaches taken in the natural language processing and computer vision fields. ",
+        "bbox": [
+            173,
+            309,
+            825,
+            395
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "To calculate the Q-value function $Q _ { i } ^ { \\psi } ( o , a )$ for the agent $i$ , the critic receives the observations, $o = \\left( o _ { 1 } , . . . , o _ { N } \\right)$ , and actions, $a = ( a _ { 1 } , . . . , a _ { N } )$ , for all agents indexed by $i \\in \\{ 1 \\ldots N \\}$ . We represent the set of all agents except $i$ as $\\backslash i$ and we index this set with $j$ . $Q _ { i } ^ { \\psi } ( o , a )$ is a function of agent $i$ ’s observation and action, as well as other agents’ contributions: ",
+        "bbox": [
+            173,
+            404,
+            485,
+            517
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/bf8d2c79e10f2bcb65b42000a4d17e1740f935b5cd39344eb971c8d279ccab95.jpg",
+        "text": "$$\nQ _ { i } ^ { \\psi } ( o , a ) = f _ { i } ( g _ { i } ( o _ { i } , a _ { i } ) , x _ { i } )\n$$",
+        "text_format": "latex",
+        "bbox": [
+            232,
+            525,
+            426,
+            545
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "where $f _ { i }$ is a two-layer multi-layer perceptron (MLP), while $g _ { i }$ is a one-layer MLP embedding function. The contribution from other agents, $x _ { i }$ , is a weighted sum of each agent’s value: ",
+        "bbox": [
+            173,
+            553,
+            485,
+            608
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "image",
+        "img_path": "images/1b63afec914c8275c439d4f59e0a54ef9030be274d1a28a8b7ef0cc5169eda6a.jpg",
+        "image_caption": [
+            "Figure 1: Calculating $Q _ { i } ^ { \\psi } ( o , a )$ with attention for agent $i$ . "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            496,
+            425,
+            823,
+            608
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/828cb50af7d007c1fbafcded257cb44cbf3366b15b4a53a79666305d1b9a328a.jpg",
+        "text": "$$\nx _ { i } = \\sum _ { j \\neq i } \\alpha _ { j } v _ { j } = \\sum _ { j \\neq i } \\alpha _ { j } h ( V g _ { j } ( o _ { j } , a _ { j } ) )\n$$",
+        "text_format": "latex",
+        "bbox": [
+            196,
+            616,
+            460,
+            651
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "where the value, $v _ { j }$ is a function of agent $j$ ’s ",
+        "bbox": [
+            176,
+            657,
+            485,
+            672
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "embedding, encoded with an embedding function and then linearly transformed by a shared matrix $V , h$ is an element-wise nonlinearity (we have used leaky ReLU). ",
+        "bbox": [
+            174,
+            672,
+            821,
+            700
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "The attention weight $\\alpha _ { j }$ compares the embedding $e _ { j }$ with $e _ { i } = g _ { i } ( o _ { i } , a _ { i } )$ , using a bilinear mapping (ie, the query-key system) and passes the similarity value between these two embeddings into a softmax ",
+        "bbox": [
+            174,
+            707,
+            825,
+            747
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/f3d04670f0d5d31caf9864b39f52dd4c105337a57fb8847b57039d7134dbf861.jpg",
+        "text": "$$\n\\alpha _ { j } \\propto \\exp ( e _ { j } ^ { \\operatorname { T } } W _ { k } ^ { \\operatorname { T } } W _ { q } e _ { i } )\n$$",
+        "text_format": "latex",
+        "bbox": [
+            419,
+            747,
+            578,
+            767
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "where $W _ { q }$ transforms $e _ { i }$ into a “query” and $W _ { k }$ transforms $e _ { j }$ into a “key”. The matching is then scaled by the dimensionality of these two matrices to prevent vanishing gradients (Vaswani et al., 2017). ",
+        "bbox": [
+            174,
+            770,
+            825,
+            811
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "In our experiments, we have used multiple attention heads (Vaswani et al., 2017). In this case, each head, using a separate set of parameters $( W _ { k } , W _ { q } , V )$ , gives rise to an aggregated contribution from all other agents to the agent $i$ and we simply concatenate the contributions from all heads as a single vector. Crucially, each head can focus on a different weighted mixture of agents. ",
+        "bbox": [
+            173,
+            818,
+            825,
+            875
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Note that the weights for extracting selectors, keys, and values are shared across all agents, which encourages a common embedding space. The sharing of critic parameters between agents is possible, even in adversarial settings, because multi-agent value-function approximation is, essentially, a multi-task regression problem. This method can easily be extended to include additional information, beyond local observations and actions, at training time, including the global state if it is available, simply by adding additional encoders, $e$ . (We do not consider this case in our experiments, however, as our approach is effective in combining local observations to predict expected returns in environments where the global state may not be available). ",
+        "bbox": [
+            174,
+            882,
+            823,
+            924
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            102,
+            825,
+            174
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Learning with Attentive Critics All critics are updated together to minimize a joint regression loss function, due to the parameter sharing: ",
+        "bbox": [
+            173,
+            188,
+            823,
+            217
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/9f3ecbf20bda06d9edb1a06fff14706ea5adb0e3a537f81e3435d567e7becb12.jpg",
+        "text": "$$\n\\begin{array} { l } { { \\displaystyle { \\mathcal L } _ { Q } ( \\psi ) = \\sum _ { i = 1 } ^ { N } \\mathbb E _ { ( o , a , r , o ^ { \\prime } ) \\sim D } \\Big [ ( Q _ { i } ^ { \\psi } ( o , a ) - y _ { i } ) ^ { 2 } \\Big ] , \\mathrm { w h e r e } } } \\\\ { { \\displaystyle y _ { i } = r _ { i } + \\gamma \\mathbb E _ { a ^ { \\prime } \\sim \\pi _ { \\bar { \\theta } } ( o ^ { \\prime } ) } \\Big [ Q _ { i } ^ { \\bar { \\psi } } ( o ^ { \\prime } , a ^ { \\prime } ) - \\alpha \\ \\log ( \\pi _ { \\bar { \\theta } _ { i } } ( a _ { i } ^ { ' } | o _ { i } ^ { ' } ) ) \\Big ] } } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            313,
+            219,
+            687,
+            292
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "where $\\bar { \\psi }$ and $\\bar { \\theta }$ are the parameters of the target critics and target policies respectively. Note that $Q _ { i } ^ { \\psi }$ , the action-value estimate for agent $i$ , receives observations and actions for all agents. $\\alpha$ is the temperature parameter determining the balance between maximizing entropy and rewards. The individual policies are updated with the following gradient: ",
+        "bbox": [
+            173,
+            295,
+            826,
+            354
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/89241b550583eaaf418ef49f694138bbf3fdd88528b5737ed608554fb653d050.jpg",
+        "text": "$$\n\\nabla _ { \\theta _ { i } } J ( \\pi _ { \\theta } ) = \\mathbb { E } _ { a \\sim \\pi _ { \\theta } } \\left[ \\nabla _ { \\theta _ { i } } \\log ( \\pi _ { \\theta _ { i } } ( a _ { i } | o _ { i } ) ) ( \\alpha \\ \\log ( \\pi _ { \\theta _ { i } } ( a _ { i } | o _ { i } ) ) - Q _ { i } ^ { \\psi } ( o , a ) + b ( o , a \\setminus i ) ) \\right]\n$$",
+        "text_format": "latex",
+        "bbox": [
+            215,
+            369,
+            781,
+            397
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "where $b ( o , a _ { \\backslash i } )$ is the multi-agent baseline used to calculate the advantage function decribed in the following section. Note that we are sampling all actions, $a$ , from all agents’ current policies in order to calculate the gradient estimate for agent $i$ , unlike in the MADDPG algorithm Lowe et al. (2017), where the other agents’ actions are sampled from the replay buffer, potentially causing overgeneralization where agents fail to coordinate based on their current policies Wei et al. (2018). Full training details and hyperparameters can be found in the appendix 6.1. ",
+        "bbox": [
+            173,
+            398,
+            825,
+            483
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Multi-Agent Advantage Function As shown in Foerster et al. (2018), an advantage function using a baseline that only marginalizes out the actions of the given agent from $Q _ { i } ^ { \\psi } ( o , a )$ , can help solve the multi-agent credit assignment problem. In other words, by comparing the value of a specific action to the value of the average action for the agent, with all other agents fixed, we can learn whether said action will cause an increase in expected return or whether any increase in reward is attributed to the actions of other agents. The form of this advantage function is shown below: ",
+        "bbox": [
+            173,
+            496,
+            825,
+            583
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/8e1349cff5b570357dfbbb18a4cee282c8b132de0854b5a3afa2c466e2da1998.jpg",
+        "text": "$$\n\\begin{array} { r } { A _ { i } ( o , a ) = Q _ { i } ^ { \\psi } ( o , a ) - b ( o , a _ { \\backslash i } ) ) , \\mathrm { ~ w h e r e ~ } } \\\\ { b ( o , a _ { \\backslash i } ) ) = \\mathbb { E } _ { a _ { i } \\sim \\pi _ { i } ( o _ { i } ) } \\left[ Q _ { i } ^ { \\psi } ( o , ( a _ { i } , a _ { \\backslash i } ) ) \\right] } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            359,
+            603,
+            640,
+            655
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Using our attention mechanism, we can implement a more general and flexible form of a multiagent baseline that, unlike the advantage function proposed in Foerster et al. (2018), doesn’t assume the same action space for each agent, doesn’t require a global reward, and attends dynamically to other agents, as in our $\\mathrm { Q }$ -function. This is made simple by the natural decomposition of an agents encoding, $e _ { i }$ , and the weighted sum of encodings of other agents, $x _ { i }$ , in our attention model. ",
+        "bbox": [
+            173,
+            662,
+            825,
+            734
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Concretely, in the case of discrete policies, we can calculate our baseline in a single forward pass by outputting the expected return $Q _ { i } { \\big ( } o , { \\big ( } a _ { i } , a _ { \\backslash i } { \\big ) } { \\big ) }$ for every possible action, $a _ { i } \\in A _ { i }$ , that agent $i$ can take. We can then calculate the expectation exactly: ",
+        "bbox": [
+            174,
+            739,
+            823,
+            782
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/1d9077932b455aa3d8b73bf783fe76c0790c134b39444f0dcf1039051085a36e.jpg",
+        "text": "$$\n\\mathbb { E } _ { a _ { i } \\sim \\pi _ { i } ( o _ { i } ) } \\left[ Q _ { i } ^ { \\psi } ( o , ( a _ { i } , a _ { \\setminus i } ) ) \\right] = \\sum _ { a _ { i } ^ { \\prime } \\in A _ { i } } \\pi ( a _ { i } ^ { \\prime } | o _ { i } ) Q _ { i } ( o , ( a _ { i } ^ { \\prime } , a _ { \\setminus i } ) )\n$$",
+        "text_format": "latex",
+        "bbox": [
+            292,
+            785,
+            704,
+            823
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "In order to do so, we must remove $a _ { i }$ from the input of $Q _ { i }$ , and output a value for every action. We add an observation-encoder, $e _ { i } = g _ { i } ^ { o } ( o _ { i } )$ , for each agent, using these encodings in place of the $e _ { i } = g _ { i } ( o _ { i } , a _ { i } )$ described above, and modify $f _ { i }$ such that it outputs a value for each possible action, rather than the single input action. In the case of continuous policies, we do not need to add any parameters, as we can simply estimate the expectation in Equation 9 by sampling actions from our policy and averaging their $\\mathbf { Q }$ -values, though, this comes at the cost of multiple expensive passes through the network. ",
+        "bbox": [
+            173,
+            825,
+            825,
+            924
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "4 EXPERIMENTS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            102,
+            326,
+            117
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "4.1 SETUP ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            133,
+            261,
+            147
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "We construct two environments that test various capabilities of our approach (MAAC) and baselines. We investigate in two main directions. First, we study the scalability of different methods as the number of agents grows. We hypothesize that the current approach of concatenating all agents’ observations (often used as a global state to be shared among agents) and actions in order to centralize critics does not scale well. To this end, we implement a cooperative environment, Cooperative Treasure Collection, with shared rewards where we can vary the total number of agents. The experimental results in sec 4.3 validate our claim. ",
+        "bbox": [
+            174,
+            160,
+            627,
+            297
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Secondly, we want to evaluate each method’s ability to attend to information relevant to rewards. Moreover, the relevance (to rewards) can dynamically change during an episode. This is analogous to real-life tasks such as the soccer example presented earlier. To this end, we implement a Rover-Tower task environment where randomly paired agents communicate information and coordinate. ",
+        "bbox": [
+            174,
+            305,
+            625,
+            388
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "The two environments are implemented in the multi-agent particle environment framework1 introduced by Mordatch & Abbeel (2018), and extended by Lowe et al. (2017). We found this framework useful for creating environments involving complex interaction between agents, while keeping the control and perception problems simple, as we are primarily interested in addressing agent interaction. To further simplify the control problem, we use discrete action spaces, allowing agents to move up, down, left, right, or stay; however, the agents may not immediately move exactly in the specified direction, as the task framework incorporates a basic physics engine where agents’ momentums are taken into account. Fig. 2 illustrates the two environments. ",
+        "bbox": [
+            174,
+            396,
+            627,
+            561
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Cooperative Treasure Collection The cooperative environment in Figure 2a) involves 8 total agents, 6 of which are ”treasure hunters” and 2 of which are “treasure banks”, which each correspond to a different color of treasure. The role of the hunters is to collect the treasure of any color, which re-spawn randomly upon being collected (with a total of 6), and then “deposit” the treasure into the correctly colored “bank”. The role of each bank is to simply gather as much treasure as possible from the hunters. All agents are able to see each others’ positions with respect to their own. Hunters receive a global ",
+        "bbox": [
+            174,
+            578,
+            625,
+            703
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "(a) Cooperative Treasure Collection. The small grey agents are “hunters” who collect the colored treasure, and deposit them with the correctly colored large “bank” agents. ",
+        "bbox": [
+            648,
+            306,
+            813,
+            395
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "image",
+        "img_path": "images/196f9f5050f478b3d0ff7933669b33756ff258369934bc880ecf228a3588d3f8.jpg",
+        "image_caption": [],
+        "image_footnote": [],
+        "bbox": [
+            648,
+            412,
+            815,
+            540
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "image",
+        "img_path": "images/af616e275beaa86e10d3b5d5bf56ab295a010c237b388dc0a2148b49ec269525.jpg",
+        "image_caption": [
+            "Figure 2: Our environments "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            648,
+            172,
+            816,
+            301
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "(b) Rover-Tower. Each grey “Tower” is paired with a “Rover” and a destination (color of rover corresponds to its destination). Their goal is to communicate with the ”Rover” such that it moves toward the destination. ",
+        "bbox": [
+            648,
+            546,
+            813,
+            660
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "reward for the successful collection of treasure and all agents receive a global reward for the depositing of treasure. Hunters are additionally penalized for colliding with each other. As such, the task contains a mixture of shared and individual rewards and requires different “modes of attention” which depend on the agent’s state and other agents’ potential for affecting its rewards. ",
+        "bbox": [
+            174,
+            704,
+            823,
+            758
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Rover-Tower The environment in Figure 2b involves 8 total agents, 4 of which are “rovers” and another 4 which are “towers”. At each episode, rovers and towers are randomly paired. The pair is negatively rewarded by the distance of the rover to its goal. The task can be thought of as a navigation task on an alien planet with limited infrastructure and low visibility. The rovers are unable to see in their surroundings and must rely on communication from the towers, which are able to locate the rovers as well as their destinations and can send one of five discrete communication messages to their paired rover. Note that communication is highly restricted and different from centralized policy approaches Jiang & Lu (2018), which allow for free transfer of continuous information among policies. In our setup, the communication is integrated into the environment (in the tower’s action space and the rover’s observation space), rather than being explicitly part of the model, and is limited to a few discrete signals. ",
+        "bbox": [
+            173,
+            775,
+            825,
+            900
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "table",
+        "img_path": "images/1213142260f71685ed880fa2ba317aec40f6b9910d640dae1bfa7a77668b4e2f.jpg",
+        "table_caption": [
+            "Table 1: Comparison of various methods for multi-agent RL "
+        ],
+        "table_footnote": [
+            "Centralized $C r i t i c ( s )$ : each agent’s estimate of $Q _ { i }$ takes the actions and observations of the other agents into account. Number of Critics: number of separate networks used for predicting $Q _ { i }$ for all $N$ agents. Multi-task Learning of Critics: all agents’ estimates of $Q _ { i }$ share information in intermediate layers, benefiting from multi-task learning. Multi-Agent Advantage: cf. Sec 3.2 for details. ∗(Foerster et al., 2018), †(Lowe et al., 2017), ‡(Lillicrap et al., 2016) "
+        ],
+        "table_body": "<table><tr><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>Base Algorithm</td><td rowspan=1 colspan=1>Attention</td><td rowspan=1 colspan=1>CentralizedCritic(s)</td><td rowspan=1 colspan=1>Numberof Critics</td><td rowspan=1 colspan=1>Multi-taskLearning of Critics</td><td rowspan=1 colspan=1>Multi-AgentAdvantage</td></tr><tr><td rowspan=1 colspan=1>MAAC (ours)</td><td rowspan=1 colspan=1>SAC</td><td rowspan=1 colspan=1>√</td><td rowspan=1 colspan=1>√</td><td rowspan=1 colspan=1>N</td><td rowspan=1 colspan=1>√</td><td rowspan=1 colspan=1>√</td></tr><tr><td rowspan=1 colspan=1>MAAC(Uniform) (ours)</td><td rowspan=1 colspan=1>SAC</td><td rowspan=1 colspan=1>uniform</td><td rowspan=1 colspan=1>√</td><td rowspan=1 colspan=1>N</td><td rowspan=1 colspan=1>√</td><td rowspan=1 colspan=1>√</td></tr><tr><td rowspan=1 colspan=1>COMA*</td><td rowspan=1 colspan=1>Actor-Critic (On-Policy)</td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>√</td><td rowspan=1 colspan=1>1</td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>√</td></tr><tr><td rowspan=1 colspan=1>MADDPG†</td><td rowspan=1 colspan=1>DDPG</td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>√</td><td rowspan=1 colspan=1>N</td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1></td></tr><tr><td rowspan=1 colspan=1>COMA+SAC</td><td rowspan=1 colspan=1>SAC</td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>√</td><td rowspan=1 colspan=1>1</td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>√</td></tr><tr><td rowspan=1 colspan=1>MADDPG+SAC</td><td rowspan=1 colspan=1>SAC</td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>√</td><td rowspan=1 colspan=1>N</td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>√</td></tr><tr><td rowspan=1 colspan=1>DDPG</td><td rowspan=1 colspan=1>DDPG</td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>N</td><td rowspan=1 colspan=1>N/A</td><td rowspan=1 colspan=1>N/A</td></tr></table>",
+        "bbox": [
+            174,
+            127,
+            823,
+            227
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            291,
+            823,
+            319
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "4.2 BASELINES",
+        "text_level": 1,
+        "bbox": [
+            174,
+            338,
+            294,
+            352
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "We compare to two recently proposed approaches for centralized training of decentralized policies: MADDPG (Lowe et al., 2017) and COMA (Foerster et al., 2018), as well as a single-agent RL approach, DDPG, trained separately for each agent. ",
+        "bbox": [
+            178,
+            364,
+            821,
+            406
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "In order to enable learning in discrete action spaces for both MADDPG and DDPG, where deterministic policies are not possible, we use the Gumbel-Softmax reparametrization trick (Jang et al., 2017). We will refer to these modified versions as MADDPG (Discrete) and DDPG (Discrete). For a detailed description of this reparametrization, see the appendix 6.2. We use soft actor critic to optimize. Thus, in order to have fair comparisons, we additionally implement MADDPG and COMA with Soft Actor-Critic, named as MADDPG $^ +$ SAC and COMA $^ +$ SAC. ",
+        "bbox": [
+            174,
+            412,
+            825,
+            497
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "We also consider an ablated version of our model as a variant of our approach. In this model, we use uniform attention by fixing the attention weight $\\alpha _ { j }$ (Eq. 6) to be $1 / ( N - 1 )$ . This restriction prevents the model from focusing its attention on specific agents. ",
+        "bbox": [
+            176,
+            503,
+            821,
+            546
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "All methods are implemented such that their approximate total number of parameters (across agents) are equal to our method, and each model is trained with 6 random seeds each. Hyperparameters for each underlying algorithm are tuned based on performance and kept constant across all variants of critic architectures for that algorithm. A thorough comparison of all baselines is summarized in Table 1. ",
+        "bbox": [
+            174,
+            553,
+            825,
+            622
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "4.3 RESULTS AND ANALYSIS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            642,
+            387,
+            656
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Fig. 3 illustrates averaged rewards per episode by various methods. The proposed approach (MAAC) is competitive with other approaches being compared. In what follows, we provide detailed analysis. ",
+        "bbox": [
+            171,
+            669,
+            823,
+            696
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Impact of Rewards and Required Attention Uniform attention is competitive with our approach in the Cooperative Treasure Collection (CTC) environment, but not in Rover-Tower. On the other hand, both MADDPG (Discrete) and MADDPG $^ +$ SAC perform well on Rover-Tower, though they do not on CTC. Both variants of COMA do not fare well in our environments. DDPG, arguably a weaker baseline, performs surprisingly well in CTC, but does poorly in Rover-Tower. ",
+        "bbox": [
+            174,
+            714,
+            823,
+            784
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "In CTC, the rewards are shared across agents thus an agent’s critic does not need to focus on information from specific agents in order to calculate its expected rewards. Moreover, each agent’s local observation provides enough information to make a decent prediction of its expected rewards. This might explain why MAAC (uniform) which attends to other agents equally, and DDPG (being very unattentive to other agents) perform well. ",
+        "bbox": [
+            174,
+            791,
+            823,
+            861
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "On the other hand, rewards in the Rover-Tower environment for a specific agent are tied to another single agent’s observations. This environment exemplifies a class of scenarios where dynamic attention can be beneficial: when subgroups of agents are interacting and performing coordinated tasks with separate rewards, but the groups do not remain static. This explains why MAAC (uniform) ",
+        "bbox": [
+            174,
+            867,
+            823,
+            924
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/3ea705bb380bed2beaacfcdfa36922d6441291f128b93b1c4d14848b1219e9f7.jpg",
+        "image_caption": [
+            "Figure 3: (Left) Average Rewards on Cooperative Treasure Collection. (Right) Average Rewards on RoverTower. Our model (MAAC) is competitive in both environments. Error bars are a $9 5 \\%$ confidence interval across 6 runs. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            192,
+            103,
+            805,
+            273
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "perform poorly and DDPG completely breaks down, as knowing information from another specific agent is crucial in predicting expected rewards. ",
+        "bbox": [
+            173,
+            338,
+            823,
+            367
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "COMA uses a single centralized network for predicting Q-values for all agents with separate forward passes. Thus, this approach may perform best in environments with global rewards and agents with similar action spaces. However, our environments have agents with differing roles (and non-global rewards in the case of Rover-Tower). Thus both variants of COMA do not fare well. ",
+        "bbox": [
+            174,
+            375,
+            825,
+            429
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "MADDPG (and its variant) is a very strong method. However, we suspect its low performance in CTC is due to this environment’s relatively large observation spaces for all agents, as the MADDPG critic concatenates observations for all agents into a single input vector for each agent’s critic. Our next experiments confirm this hypothesis. ",
+        "bbox": [
+            174,
+            436,
+            825,
+            492
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Scalability We compare the average rewards attained by both approaches (normalized by the range of rewards attained in the environment, as differing the number of agents changes the nature of rewards in each environment), and show that the improvement of our approach MAAC over MADDPG $^ +$ SAC grows with respect to the number of agents. As suspected, MADDPG-like critics use all information non-selectively, while our approach can learn which agents to pay more attention through the attention mechanism. Thus our approach scales better when the number of agents increases. In future research we will continue to improve the scalability when the number of agents further increases by sharing policies among agents, and performing attention on sub-groups (of agents). ",
+        "bbox": [
+            174,
+            517,
+            614,
+            627
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "table",
+        "img_path": "images/b2d37685bac034501e6168a5448eb1f74fd0b682be02d542418474509edd9a6e.jpg",
+        "table_caption": [
+            "Table 2: MAAC improves over MADDPG $^ +$ SAC "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=1 colspan=1>#agents</td><td rowspan=1 colspan=1>4</td><td rowspan=1 colspan=1>8</td><td rowspan=1 colspan=1>16</td></tr><tr><td rowspan=1 colspan=1>Percentage</td><td rowspan=1 colspan=1>20</td><td rowspan=1 colspan=1>49</td><td rowspan=1 colspan=1>53</td></tr></table>",
+        "bbox": [
+            627,
+            574,
+            826,
+            606
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            176,
+            628,
+            825,
+            670
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "While the Rover-Tower task has a lot of agents, each agent only gets information about its paired agent – in other words, the task itself has an intrinsically smaller number of “other agents” (conditioned on each agent) than the CTC environment. As a future direction, we are creating more complicated environments where each agent needs to cope with a large group of agents where selective attention is needed. This naturally models real-life scenarios that multiple agents are organized in clusters/sub-societies (school, work, family, etc) where the agent needs to interact with a small number of agents from many groups. We anticipate that in such complicated scenarios, our approach, combined with some advantages exhibited by other approaches would do well. ",
+        "bbox": [
+            174,
+            676,
+            825,
+            787
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "5 CONCLUSION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            816,
+            318,
+            833
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "We propose an algorithm for training decentralized policies in multi-agent settings. The key idea is to utilize attention in order to select relevant information for estimating critics. We analyze the performance of the proposed approach with respect to the number of agents, different configurations of rewards, and the span of relevant observational information. Empirical results are promising and we intend to extend to highly complicated and dynamic environments. ",
+        "bbox": [
+            174,
+            853,
+            823,
+            924
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "REFERENCES ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            102,
+            287,
+            118
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Jimmy Ba, Volodymyr Mnih, and Koray Kavukcuoglu. Multiple object recognition with visual attention. In International Conference on Learning Representations, 2015. ",
+        "bbox": [
+            173,
+            126,
+            823,
+            155
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Dzmitry Bahdanau, Kyunghyun Cho, and Yoshua Bengio. Neural machine translation by jointly learning to align and translate. In International Conference on Learning Representations, 2015. ",
+        "bbox": [
+            173,
+            165,
+            823,
+            195
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Lucian Bus¸oniu, Robert Babuska, and Bart De Schutter. Multi-agent reinforcement learning: Anˇ overview. In Innovations in multi-agent systems and applications-1, pp. 183–221. Springer, 2010. ",
+        "bbox": [
+            174,
+            204,
+            823,
+            234
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Jinyoung Choi, Beom-Jin Lee, and Byoung-Tak Zhang. Multi-focus attention network for efficient deep reinforcement learning. arXiv preprint arXiv:1712.04603, December 2017. ",
+        "bbox": [
+            173,
+            244,
+            823,
+            273
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Felix Fischer, Michael Rovatsos, and Gerhard Weiss. Hierarchical reinforcement learning in communication-mediated multiagent coordination. In Proceedings of the Third International Joint Conference on Autonomous Agents and Multiagent Systems-Volume 3, pp. 1334–1335. IEEE Computer Society, 2004. ",
+        "bbox": [
+            173,
+            284,
+            826,
+            340
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Jakob Foerster, Ioannis Alexandros Assael, Nando de Freitas, and Shimon Whiteson. Learning to communicate with deep multi-agent reinforcement learning. In Advances in Neural Information Processing Systems, pp. 2137–2145, 2016. ",
+        "bbox": [
+            174,
+            351,
+            823,
+            393
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Jakob Foerster, Nantas Nardelli, Gregory Farquhar, Triantafyllos Afouras, Philip H. S. Torr, Pushmeet Kohli, and Shimon Whiteson. Stabilising experience replay for deep multi-agent reinforcement learning. In Proceedings of the 34th International Conference on Machine Learning, volume 70 of Proceedings of Machine Learning Research, pp. 1146–1155, International Convention Centre, Sydney, Australia, 06–11 Aug 2017. ",
+        "bbox": [
+            173,
+            404,
+            825,
+            474
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Jakob Foerster, Gregory Farquhar, Triantafyllos Afouras, Nantas Nardelli, and Shimon Whiteson. Counterfactual multi-agent policy gradients, 2018. ",
+        "bbox": [
+            174,
+            484,
+            821,
+            513
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Alex Graves, Greg Wayne, and Ivo Danihelka. Neural turing machines. arXiv preprint arXiv:1410.5401, 2014. ",
+        "bbox": [
+            171,
+            525,
+            823,
+            553
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Jayesh K Gupta, Maxim Egorov, and Mykel Kochenderfer. Cooperative multi-agent control using deep reinforcement learning. In Autonomous Agents and Multiagent Systems, Lecture Notes in Computer Science, pp. 66–83. Springer, Cham, May 2017. ",
+        "bbox": [
+            173,
+            563,
+            823,
+            607
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "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, volume 80 of Proceedings of Machine Learning Research, pp. 1861–1870, Stockholmsmssan, Stockholm Sweden, 10–15 Jul 2018. ",
+        "bbox": [
+            173,
+            617,
+            825,
+            674
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "He He, Jordan Boyd-Graber, Kevin Kwok, and Hal Daume III. Opponent modeling in deep rein- ´ forcement learning. In International Conference on Machine Learning, pp. 1804–1813, 2016. ",
+        "bbox": [
+            171,
+            684,
+            823,
+            713
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Nicolas Heess, Srinivasan Sriram, Jay Lemmon, Josh Merel, Greg Wayne, Yuval Tassa, Tom Erez, Ziyu Wang, Ali Eslami, Martin Riedmiller, et al. Emergence of locomotion behaviours in rich environments. arXiv preprint arXiv:1707.02286, 2017. ",
+        "bbox": [
+            173,
+            723,
+            825,
+            766
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Eric Jang, Shixiang Gu, and Ben Poole. Categorical reparameterization with gumbel-softmax. In International Conference on Learning Representations, 2017. ",
+        "bbox": [
+            169,
+            776,
+            823,
+            806
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Jiechuan Jiang and Zongqing Lu. Learning attentional communication for multi-agent cooperation. arXiv preprint arXiv:1805.07733, 2018. ",
+        "bbox": [
+            168,
+            816,
+            823,
+            845
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Diederik P Kingma and Jimmy Ba. Adam: A method for stochastic optimization. In International Conference on Learning Representations, 2014. ",
+        "bbox": [
+            169,
+            856,
+            823,
+            885
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Vijay R Konda and John N Tsitsiklis. Actor-critic algorithms. In Advances in neural information processing systems, pp. 1008–1014, 2000. ",
+        "bbox": [
+            174,
+            895,
+            823,
+            924
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Timothy P Lillicrap, Jonathan J Hunt, Alexander Pritzel, Nicolas Heess, Tom Erez, Yuval Tassa, David Silver, and Daan Wierstra. Continuous control with deep reinforcement learning. In International Conference on Learning Representations, 2016. ",
+        "bbox": [
+            176,
+            103,
+            823,
+            146
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Zhouhan Lin, Minwei Feng, Cicero Nogueira dos Santos, Mo Yu, Bing Xiang, Bowen Zhou, and Yoshua Bengio. A structured self-attentive sentence embedding. In International Conference on Learning Representations, 2017. ",
+        "bbox": [
+            173,
+            156,
+            826,
+            199
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Michael L Littman. Markov games as a framework for multi-agent reinforcement learning. In Machine Learning Proceedings 1994, pp. 157–163. Elsevier, 1994. ",
+        "bbox": [
+            171,
+            210,
+            823,
+            239
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Ryan Lowe, Yi Wu, Aviv Tamar, Jean Harb, OpenAI Pieter Abbeel, and Igor Mordatch. Multi-agent actor-critic for mixed cooperative-competitive environments. In Advances in Neural Information Processing Systems, pp. 6382–6393, 2017. ",
+        "bbox": [
+            174,
+            251,
+            823,
+            294
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Volodymyr Mnih, Nicolas Heess, Alex Graves, et al. Recurrent models of visual attention. In Advances in neural information processing systems, pp. 2204–2212, 2014. ",
+        "bbox": [
+            171,
+            304,
+            823,
+            334
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "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, 2015. ",
+        "bbox": [
+            174,
+            343,
+            825,
+            387
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Igor Mordatch and Pieter Abbeel. Emergence of grounded compositional language in multi-agent populations, 2018. ",
+        "bbox": [
+            173,
+            397,
+            823,
+            426
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Junhyuk Oh, Valliappa Chockalingam, Honglak Lee, et al. Control of memory, active perception, and action in minecraft. In International Conference on Machine Learning, pp. 2790–2799, 2016. ",
+        "bbox": [
+            173,
+            438,
+            825,
+            467
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Tabish Rashid, Mikayel Samvelyan, Christian Schroeder, Gregory Farquhar, Jakob Foerster, and Shimon Whiteson. QMIX: Monotonic value function factorisation for deep multi-agent reinforcement learning. In Proceedings of the 35th International Conference on Machine Learning, volume 80 of Proceedings of Machine Learning Research, pp. 4295–4304, Stockholmsmssan, Stockholm Sweden, 10–15 Jul 2018. ",
+        "bbox": [
+            173,
+            477,
+            825,
+            547
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "John Schulman, Sergey Levine, Pieter Abbeel, Michael Jordan, and Philipp Moritz. Trust region policy optimization. In International Conference on Machine Learning, pp. 1889–1897, 2015. ",
+        "bbox": [
+            173,
+            559,
+            821,
+            588
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "John Schulman, Filip Wolski, Prafulla Dhariwal, Alec Radford, and Oleg Klimov. Proximal policy optimization algorithms. arXiv preprint arXiv:1707.06347, 2017. ",
+        "bbox": [
+            173,
+            598,
+            823,
+            628
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "David Silver, Aja Huang, Chris J Maddison, Arthur Guez, Laurent Sifre, George Van Den Driessche, Julian Schrittwieser, Ioannis Antonoglou, Veda Panneershelvam, Marc Lanctot, et al. Mastering the game of go with deep neural networks and tree search. nature, 529(7587):484–489, 2016. ",
+        "bbox": [
+            174,
+            638,
+            823,
+            681
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Sainbayar Sukhbaatar, Rob Fergus, et al. Learning multiagent communication with backpropagation. In Advances in Neural Information Processing Systems, pp. 2244–2252, 2016. ",
+        "bbox": [
+            171,
+            691,
+            823,
+            722
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Peter Sunehag, Guy Lever, Audrunas Gruslys, Wojciech Marian Czarnecki, Vinicius Zambaldi, Max Jaderberg, Marc Lanctot, Nicolas Sonnerat, Joel Z. Leibo, Karl Tuyls, and Thore Graepel. Valuedecomposition networks for cooperative multi-agent learning based on team reward. In Proceedings of the 17th International Conference on Autonomous Agents and MultiAgent Systems, AAMAS ’18, pp. 2085–2087, Richland, SC, 2018. International Foundation for Autonomous Agents and Multiagent Systems. ",
+        "bbox": [
+            173,
+            732,
+            825,
+            816
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Richard S Sutton, David A McAllester, Satinder P Singh, and Yishay Mansour. Policy gradient methods for reinforcement learning with function approximation. In Advances in neural information processing systems, pp. 1057–1063, 2000. ",
+        "bbox": [
+            173,
+            827,
+            823,
+            871
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Ardi Tampuu, Tambet Matiisen, Dorian Kodelja, Ilya Kuzovkin, Kristjan Korjus, Juhan Aru, Jaan Aru, and Raul Vicente. Multiagent cooperation and competition with deep reinforcement learning. PLoS One, 12(4):e0172395, April 2017. ",
+        "bbox": [
+            176,
+            881,
+            823,
+            924
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Ming Tan. Multi-agent reinforcement learning: independent versus cooperative agents. In Proceedings of the Tenth International Conference on International Conference on Machine Learning, pp. 330–337. Morgan Kaufmann Publishers Inc., 1993. ",
+        "bbox": [
+            176,
+            103,
+            823,
+            146
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Ashish Vaswani, Noam Shazeer, Niki Parmar, Jakob Uszkoreit, Llion Jones, Aidan N Gomez, Łukasz Kaiser, and Illia Polosukhin. Attention is all you need. In Advances in Neural Information Processing Systems, pp. 6000–6010, 2017. ",
+        "bbox": [
+            176,
+            155,
+            823,
+            198
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Ermo Wei, Drew Wicke, David Freelan, and Sean Luke. Multiagent soft q-learning. arXiv preprint arXiv:1804.09817, 2018. ",
+        "bbox": [
+            171,
+            207,
+            823,
+            234
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Ronald J Williams. Simple statistical gradient-following algorithms for connectionist reinforcement learning. In Reinforcement Learning, pp. 5–32. Springer, 1992. ",
+        "bbox": [
+            173,
+            244,
+            823,
+            273
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "6 APPENDIX ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            102,
+            294,
+            117
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Algorithm 1 Training Procedure for Attention-Actor-Critic ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            160,
+            563,
+            174
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "1: Initialize $E$ parallel environments with $N$ agents, each   \n2: Initialize replay buffer, $D$   \n3: $T _ { \\mathrm { u p d a t e } } \\gets 0$   \n4: for $i _ { \\mathrm { e p } } = 1 \\ldots$ num episodes do   \n5: Reset environments, and get initial $o _ { i } ^ { e }$ for each agent, $i$   \n6: for $t = 1$ . . . steps per episode do   \n7: Select actions $a _ { i } ^ { e } \\sim \\pi _ { i } ( \\cdot | o _ { i } ^ { e } )$ for each agent, $i$ , in each environment, $e$   \n8: Send actions to all parallel environments and get $\\boldsymbol { o ^ { \\prime } } _ { i } ^ { e }$ , $\\boldsymbol { r } _ { i } ^ { e }$ for all agents in all environments   \n9: Store transitions $\\left( o _ { 1 \\dots N } , a _ { 1 \\dots N } , r _ { 1 \\dots N } , o _ { 1 \\dots N } ^ { \\prime } \\right)$ for all environments in $D$   \n10: $T _ { \\mathrm { u p d a t e } } = T _ { \\mathrm { u p d a t e } } + E$   \n11: if $T _ { \\mathrm { u p d a t e } } \\geq \\mathrm { \\bar { m i n } }$ steps per update then   \n12: for $j = 1$ . . . num critic updates do   \n13: Sample minibatch $B \\gets m \\times ( o _ { 1 . . . N } , a _ { 1 . . . N } , r _ { 1 . . . N } , o _ { 1 . . . N } ^ { \\prime } ) \\sim D$   \n14: UPDATECRITIC $( B )$   \n15: end for   \n16: for $j = 1 \\ldots \\mathrm { n u m }$ policy updates do   \n17: 18: Sample UPDAT $m \\times \\left( o _ { 1 \\dots N } \\right) \\sim D$ $( \\acute { o } _ { 1 \\dots N } ^ { B } )$   \n19: end for   \n20: Update target critic and policy parameters: ",
+        "bbox": [
+            174,
+            181,
+            825,
+            457
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "equation",
+        "img_path": "images/21124c7e5702770fb457cd8453133802792e9b791639b14f9472f5c7f8e24bb4.jpg",
+        "text": "$$\n\\begin{array} { c } { { \\bar { \\psi } = \\tau \\bar { \\psi } + ( 1 - \\tau ) \\psi } } \\\\ { { { } } } \\\\ { { \\bar { \\theta } = \\tau \\bar { \\theta } + ( 1 - \\tau ) \\theta } } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            442,
+            462,
+            581,
+            505
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "21: $T _ { \\mathrm { u p d a t e } } \\gets 0$   \n22: end if   \n23: end for   \n24: end for   \n25:   \n26: 27: function UPDATECRIUnpack minibatch $( B )$   \n$( o _ { 1 \\dots N } ^ { B } , a _ { 1 \\dots N } ^ { B } , r _ { 1 \\dots N } ^ { B } , o _ { 1 \\dots N } ^ { ' B } )  B$   \n28: Calculate $Q _ { i } ^ { \\psi } ( o _ { 1 \\ldots N } ^ { B } , a _ { 1 \\ldots N } ^ { B } )$ for all $i$ in parallel   \n29: Calculate $a _ { i } ^ { ' B } \\sim \\pi _ { i } ^ { \\bar { \\theta } } ( o _ { i } ^ { ' B } )$ using target policies   \n30: Calculate $Q _ { i } ^ { \\bar { \\psi } } ( o _ { 1 \\dots N } ^ { ' B } , a _ { 1 \\dots N } ^ { ' B } )$ for all $i$ in parallel, using target critic   \n31: Update critic: ",
+        "bbox": [
+            168,
+            506,
+            665,
+            672
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "equation",
+        "img_path": "images/616a4df6c6006f495a3ae7f04044518adba48f475409e9bd6eb348aa7b7ccb5a.jpg",
+        "text": "$$\n\\begin{array} { l } { \\displaystyle \\mathcal { L } _ { Q } ( \\psi ) = \\sum _ { i = 1 } ^ { N } \\mathbb { E } _ { ( o , a , r , o ^ { \\prime } ) \\sim D } \\Big [ ( Q _ { i } ^ { \\psi } ( o , a ) - y _ { i } ) ^ { 2 } \\Big ] , \\mathrm { w h e r e } } \\\\ { \\displaystyle y _ { i } = r _ { i } + \\gamma \\mathbb { E } _ { a ^ { \\prime } \\sim \\bar { \\pi _ { i } } ( o ^ { \\prime } ) } \\Big [ Q _ { i } ^ { \\bar { \\psi } } ( o ^ { \\prime } , a ^ { \\prime } ) - \\alpha l o g ( \\pi _ { \\bar { \\theta _ { i } } } ( a _ { i } ^ { ' } | o _ { i } ^ { ' } ) ) \\Big ] } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            326,
+            678,
+            699,
+            750
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "32: end function ",
+        "bbox": [
+            174,
+            755,
+            292,
+            768
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            176,
+            770,
+            196,
+            781
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "34: function UPDATEPOLICIES $( o _ { 1 \\dots N } ^ { B } )$ ",
+        "bbox": [
+            174,
+            781,
+            437,
+            797
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "35: Calculate $a _ { 1 \\dots N } ^ { B } \\sim \\pi _ { i } ^ { \\bar { \\theta } } ( o _ { i } ^ { ' B } ) , i \\in 1 \\dots N$ ",
+        "bbox": [
+            173,
+            797,
+            490,
+            815
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "36: Calculate $Q _ { i } ^ { \\psi } ( o _ { 1 \\ldots N } ^ { B } , a _ { 1 \\ldots N } ^ { B } )$ for all $i$ in parallel ",
+        "bbox": [
+            173,
+            815,
+            535,
+            832
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "37: Update policies: ",
+        "bbox": [
+            174,
+            832,
+            334,
+            844
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "equation",
+        "img_path": "images/03010c3dbf4f6fd8a2953218712beee39d61204a64d4bd1a347657193b8db94f.jpg",
+        "text": "$$\n\\nabla _ { \\theta _ { i } } J ( \\pi _ { \\theta } ) = \\mathbb { E } _ { a \\sim \\pi _ { \\theta } } \\left[ \\nabla _ { \\theta _ { i } } l o g ( \\pi _ { \\theta _ { i } } ( a _ { i } | o _ { i } ) ) ( \\alpha l o g ( \\pi _ { \\theta _ { i } } ( a _ { i } | o _ { i } ) ) - Q _ { i } ^ { \\psi } ( o , a ) + b ( o , \\bar { a } ) ) \\right]\n$$",
+        "text_format": "latex",
+        "bbox": [
+            223,
+            851,
+            772,
+            878
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "38: end function ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            883,
+            292,
+            898
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "6.1 TRAINING PROCEDURE ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            103,
+            377,
+            117
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "We train using Soft Actor-Critic (Haarnoja et al., 2018), an off-policy, actor-critic method for maximum entropy reinforcement learning. Our training procedure consists of performing 12 parallel rollouts, and adding a tuple of $\\big ( o _ { t } , a _ { t } , r _ { t } , o _ { t + 1 } \\big ) _ { 1 \\dots N }$ to a replay buffer (with maximum length 1e6) for each timepoint. We reset each environment after every 100 steps (an episode). After 100 steps (across all rollouts), we perform 4 updates for the attention critic and for all policies. For each update we sample minibatches of 1024 timepoints from the replay buffer and then perform gradient descent on the Q-function loss objective (7), as well as the policy objective (8), using Adam (Kingma & Ba, 2014) as the optimizer for both with a learning rate of 0.001. These updates can be computed efficiently in parallel (across agents) using a GPU. After the updates are complete, we update the parameters $\\dot { \\psi }$ of our target critic $Q _ { \\bar { \\psi } }$ to move toward our learned critic’s parameters, $\\psi$ , as in Lillicrap et al. (2016); Haarnoja et al. (2018): $\\bar { \\psi } = ( 1 - \\tau ) \\bar { \\psi } + \\tau \\psi$ , where $\\tau$ is the update rate (set to 0.002 for attention parameters and 0.04 for all other parameters). Using a target critic has been shown to stabilize the use of experience replay for off-policy reinforcement learning with neural network function approximators (Mnih et al., 2015; Lillicrap et al., 2016). We update the parameters of the target policies, $\\bar { \\theta }$ in the same manner. We use a discount factor, $\\gamma$ , of 0.99. All networks (separate policies and contained within the centralized critics) use a hidden dimension of 128 and Leaky Rectified Linear Units as the nonlinearity. We use 0.2 as our temperature setting for Soft Actor-Critic. Additionally, we typically use 4 attention heads in our attention critics unless otherwise specified. ",
+        "bbox": [
+            173,
+            130,
+            825,
+            382
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "6.2 REPARAMETRIZATION OF DDPG/MADDPG FOR DISCRETE ACTION SPACES ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            398,
+            746,
+            415
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "In order to compare to DDPG and MADDPG in our environments with discrete action spaces, we must make a slight modification to the basic algorithm. This modification is first suggested by Lowe et al. (2017) in order to enable policies that output discrete communication messages. Consider the original DDPG policy gradient which takes advantage of the fact that you can easily calculate the gradient of the output of a deterministic policy with respect to its parameters. ",
+        "bbox": [
+            174,
+            425,
+            825,
+            496
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "equation",
+        "img_path": "images/d9337ab0401554c9f434892cf8e12165ac05605496530072774c13dc81bbdf93.jpg",
+        "text": "$$\n\\nabla _ { \\theta } J = \\mathbb { E } _ { s \\sim \\rho } \\left[ \\nabla _ { a } Q ( s , a ) | _ { a = \\mu ( s ) } \\nabla _ { \\theta } \\mu ( s | \\theta ) \\right]\n$$",
+        "text_format": "latex",
+        "bbox": [
+            354,
+            515,
+            643,
+            535
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Rather than policies that deterministically output an action from within a continuous action space, we use policies that produce differentiable samples through a Gumbel-Softmax distribution (Jang et al., 2017). Using differentiable samples allows us to use the gradient of expected returns to train policies without using the log derivative trick, just as in DDPG. ",
+        "bbox": [
+            174,
+            544,
+            825,
+            601
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "equation",
+        "img_path": "images/6bdb58d05691785993428f50fd86affe8e994310723df5c20d11cd9bb13bb204.jpg",
+        "text": "$$\n\\nabla _ { \\theta } J = \\mathbb { E } _ { s \\sim \\rho , a \\sim \\pi ( s ) } \\left[ \\nabla _ { a } Q ( s , a ) \\nabla _ { \\theta } a \\right]\n$$",
+        "text_format": "latex",
+        "bbox": [
+            372,
+            619,
+            624,
+            638
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "6.3 VISUALIZING ATTENTION ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            654,
+            393,
+            667
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "In order to understand how the use of attention evolves over the course of training, we examine the ”entropy” of the attention weights for each agent for each of the four attention heads that we use in both tasks (Figures 4 and 5). The black bars indicate the maximum possible entropy (i.e. uniform attention across all agents). Lower entropy indicates that the head is focusing on specific agents, with an entropy of 0 indicating attention focusing on one agent. In Rover-Tower, we plot the attention entropy for each rover. Interestingly, each agent appears to use a different combination of the four heads, but their use is not mutually exclusive, indicating that the inclusion of separate attention heads for each agent is not necessary. This differential use of attention heads is sensible due to the nature of rewards in this environment (i.e. individualized rewards). In the case of Treasure Collection, we find that all agents use the attention heads similarly, which is unsurprising considering that rewards are shared in that environment. ",
+        "bbox": [
+            173,
+            680,
+            825,
+            833
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "In order to inspect how the attention mechanism is working on a more fine-grained level, we visualize the attention weights for one of the rovers in Rover-Tower (Figure 6), from the head that the agent appears to use the most (determined by looking at Figure 4), while changing the tower that said rover is paired to. In these plots, we ignore the weights over other rovers for simplicity since these are always near zero. We find that the rover learns to strongly attend to the tower that it is paired with, without any explicit supervision signal to do so. The model implicitly learns which agent is most relevant to estimating the rover’s expecture future returns, and said agent can change dynamically without affecting the performance of the algorithm. ",
+        "bbox": [
+            174,
+            840,
+            823,
+            924
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "image",
+        "img_path": "images/dd6d226b64964d0586712c101b05f8f35f4c98b43b49eba256d1ac3e6721a78c.jpg",
+        "image_caption": [
+            "Figure 4: Attention ”entropy” for each head over the course of training for the four rovers in the Rover-Tower environment "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            176,
+            92,
+            820,
+            450
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "image",
+        "img_path": "images/3b64d8a5ae6a830193dffa365d2dc696f9bf36d1a08a6a75ed444b65375a6deb.jpg",
+        "image_caption": [
+            "Figure 5: Attention ”entropy” for each head over the course of training for two collectors in the Treasure Collection Environment "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            178,
+            492,
+            816,
+            662
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            176,
+            726,
+            821,
+            755
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "6.4 CONTINUOUS ACTION SPACES ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            771,
+            426,
+            785
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "In order to test our model’s ability to handle continuous action spaces, we add a network for each agent to learn a state-value function $V _ { i } ( o , a _ { \\backslash i } )$ , which uses the same weighted attention embedding over other agents as $Q _ { i } ( o , a )$ . The loss functions to learn both networks are provided by Haarnoja et al. (2018). We test on an environment introduced in Lowe et al. (2017) called Cooperative Navigation and compare to MADDPG. Our results are presented in Table 3. This task does not require attention, as all agents are relevant to each others rewards at each time step. As such, it is unsurprising that our approach matches but does not surpass the performance of MADDPG. It is notable, however, both that attention does not harm performance in simple cases and that our approach handles continuous action spaces as well. ",
+        "bbox": [
+            174,
+            796,
+            588,
+            920
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "table",
+        "img_path": "images/7d14c8053c110be92140d4f026110c025028537004811bb892faeff906b68b66.jpg",
+        "table_caption": [
+            "Table 3: Cooperative Navigation (Continuous) "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>MADDPG</td><td>MAAC</td></tr><tr><td>-2.47 ± 0.05</td><td>-2.49 ±0.11</td></tr></table>",
+        "bbox": [
+            606,
+            854,
+            815,
+            886
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            910,
+            820,
+            924
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "image",
+        "img_path": "images/202b9b1da1f524d817219da2b216af9549b8bbb38788d6852c92299fca0b6d58.jpg",
+        "image_caption": [
+            "Figure 6: Attention weights when subjected to different Tower pairings for Rover 1 in Rover-Tower environment "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            176,
+            93,
+            823,
+            481
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            544,
+            825,
+            587
+        ],
+        "page_idx": 14
+    }
+]

parse/train/Hk4fpoA5Km/Hk4fpoA5Km.md

@@ -0,0 +1,270 @@
+# DISCRIMINATOR-ACTOR-CRITIC:ADDRESSING SAMPLE INEFFICIENCY AND REWARDBIAS IN ADVERSARIAL IMITATION LEARNING
+
+Ilya Kostrikov1,2,\*, Kumar Krishna Agrawal2, †, Debidatta Dwibedi2, †, Sergey Levine2, and Jonathan Tompson2
+
+1Courant Institute of Mathematical Sciences, New York University, New York, NY 2Google Brain, Mountain View, CA
+
+# ABSTRACT
+
+Algorithms for imitation learning based on adversarial optimization, such as generative adversarial imitation learning (GAIL) and adversarial inverse reinforcement learning (AIRL), can effectively mimic demonstrated behaviours by employing both reward and reinforcement learning (RL). However, applications of such algorithms are challenged by the inherent instability and poor sample efficiency of on-policy RL. In particular, the inadequate handling of absorbing states in canonical implementations of RL environments causes an implicit bias in reward functions used by these algorithms. While these biases might work well for some environments, they lead to sub-optimal behaviors in others. Moreover, despite the ability of these algorithms to learn from a few demonstrations, they require a prohibitively large number of the environment interactions for many real-world applications. To address these issues, we first propose to extend the environment MDP with absorbing states which leads to task-independent, and more importantly, unbiased rewards. Secondly, we introduce an off-policy learning algorithm, which we refer to as Discriminator-Actor-Critic. We demonstrate the effectiveness of proper handling of absorbing states, while empirically improving the sample efficiency by an average factor of 10. Our implementation is available online 1.
+
+# 1 INTRODUCTION
+
+The Adversarial Imitation Learning (AIL) class of algorithms learns a policy that robustly imitates an expert’s actions via a collection of expert demonstrations, an adversarial discriminator and a reinforcement learning method. For example, the Generative Adversarial Imitation Learning (GAIL) algorithm (Ho & Ermon, 2016) uses a discriminator reward and a policy gradient algorithm to imitate an expert RL policy. Similarly, the Adversarial Inverse Reinforcement Learning (AIRL) algorithm (Fu et al., 2017) makes use of a modified GAIL discriminator to recover a reward function to perform Inverse Reinforcement Learning (IRL) (Abbeel & Ng, 2004). Additionally, this subsequent dense reward is robust to changes in dynamics or environment properties. Importantly, AIL algorithms such as GAIL and AIRL, obtain higher performance than supervised Behavioral Cloning (BC) when using a small number of expert demonstrations; experimentally suggesting that AIL algorithms alleviate some of the distributional drift (Ross et al., 2011) issues associated with BC. However, these AIL methods suffer from two important issues that will be addressed by this work: 1) a large number of policy interactions with the learning environment is required for policy convergence and 2) although in principle these methods can learn rewards for absorbing states, the original implementations suffer from improper handling of the environment terminal states. This introduces implicit rewards priors which can either improve or degrade policy performance.
+
+![](images/1de8cf30d798c6c776834bfece5450f74e76287380d82db216a4e24c0a81ab5b.jpg)  
+Figure 1: The Discriminator-Actor-Critic imitation learning framework combined with a method to explicitly learn rewards for the absorbing states.
+
+While GAIL requires as little as 200 expert frame transitions (from 4 expert trajectories) to learn a robust reward function on most MuJoCo (Todorov et al., 2012) tasks, the number of policy frame transitions sampled from the environment can be as high as 25 million in order to reach convergence. If PPO (Schulman et al., 2017) is used in place of TRPO (Schulman et al., 2015), the sample complexity can be improved (for example, as in Figure 3, 25 million steps reduces to approximately 10 million steps), however it is still intractable for many robotics or real-world applications. In this work we address this issue by incorporating an off-policy RL algorithm (TD3 (Fujimoto et al., 2018)) and an off-policy discriminator to dramatically decrease the sample complexity by orders of magnitude.
+
+In this work, we also illustrate how specific design choices for AIL algorithms and MDPs used in practice, have a large impact on agent performance for environments with absorbing states. For instance, as we will demonstrate, if the implementation assigns zero rewards for absorbing states, a strictly positive reward function can prevent the agent from solving tasks with a minimal number of steps, while a strictly negative reward function is unable to emulate a survival bonus. Therefore, one must have some knowledge of the true environment reward and incorporate such priors to choose a suitable reward function for successful application of GAIL and AIRL. We will discuss these issues formally, and present a simple - yet effective - solution that drastically improves policy performance for environments with absorbing states; we explicitly handle absorbing state transitions by learning the reward associated with these states.
+
+First we propose a new algorithm, which we call Discriminator-Actor-Critic (DAC) (Figure 1), that is compatible with the GAIL and AIRL frameworks by extending them with an off-policy discriminator and an off-policy actor-critic reinforcement learning algorithm. Then we propose a general approach to handling absorbing states in inverse reinforcement learning and reward learning methods. We experimentally demonstrate that this removes the bias due to incorrect absorbing state handling in both GAIL-like and AIRL-like variants of our DAC algorithm. In our experiments, we demonstrate that DAC achieves state-of-the-art AIL performance for a number of difficult imitation learning tasks, where proper handling of terminal states is crucial for matching expert performance in the presence of absorbing states. More specifically, in this work we:
+
+• Identify, and propose solutions for the problem of handling terminal states of policy rollouts in standard RL benchmarks in the context of AIL algorithms. • Accelerate learning from demonstrations by providing an off-policy variant for AIL algorithms, which significantly reduces the number of agent-environment interactions. • Illustrate the robustness of DAC to noisy, multi-modal and constrained expert demonstrations, by performing experiments with human demonstrations on non-trivial robotic tasks.
+
+# 2 RELATED WORK
+
+Imitation learning has been broadly studied under the twin umbrellas of Behavioral Cloning (BC) (Bain & Sommut, 1999; Ross et al., 2011) and Inverse Reinforcement Learning (IRL) (Ng & Russell, 2000). To recover the underlying policy, IRL performs an intermediate step of estimating the reward function followed by RL on this function (Abbeel & Ng, 2004; Ratliff et al., 2006). Operating in the Maximum Entropy IRL formulation (Ziebart et al., 2008), Finn et al. (2016b) introduce an iterativesampling based estimator for the partition function, deriving an algorithm for recovering non-linear reward functions in high-dimensional state and action spaces. Finn et al. (2016a) and $\mathrm { F u }$ et al.
+
+(2017) further extend this by exploring the theoretical and practical considerations of an adversarial IRL framework, and draw connections between IRL and cost learning in GANs (Goodfellow et al., 2014).
+
+In practical scenarios, we are often interested in recovering the expert’s policy, rather than the reward function. Following Syed et al. (2008), and by treating imitation learning as an occupancy matching problem, Ho & Ermon (2016) proposed a Generative Adversarial Imitation Learning (GAIL) framework for learning a policy from demonstrations, which bypasses the need to recover the expert’s reward function. More recent work extends the framework by improving on stability and robustness (Wang et al., 2017; Kim & Park, 2018) and making connections to model-based imitation learning (Baram et al., 2017). These approaches generally use on-policy algorithms for policy optimization, trading off sample efficiency for training stability.
+
+Learning complex behaviors from sparse reward signals poses a significant challenge in reinforcement learning. In this context, expert demonstrations or template trajectories have been successfully used (Peters & Schaal, 2008) for initializing RL policies. There has been a growing interest in combining extrinsic sparse reward signals with imitation learning for guided exploration (Zhu et al., 2018; Kang et al., 2018; Le et al., 2018; Vecer´ık et al., 2017). Off policy learning from demonstration has been previously studied under the umbrella of accelerating reinforcement learning by structured exploration (Nair et al., 2017; Hester et al., 2017) An implicit assumption of these approaches is access to demonstrations and reward from the environment; our approach requires access only to expert demonstrations.
+
+Biases associated with specific MDP benchmarks also arise in the standard RL setup. In particular, Pardo et al. (2017) and Tucker et al. (2018) discuss handling of time limits in RL specifically with MDPs where time limits make the problems non-Markovian and might affect optimality of the training policy and value function estimation. The problem with the biases associated with episode terminations also prove to be severe for AIL algorithms because for specific RL benchmarks the absorbing states might not even be adequately taken into consideration. We discuss this in more detail in Section 4.1.
+
+Our work is most related to AIL algorithms (Ho & Ermon, 2016; Fu et al., 2017; Torabi et al., 2018). In contrast to Ho & Ermon (2016) which assumes (state-action-state’) transition tuples, Torabi et al. (2018) has weaker assumptions, by relying only on observations and removing the dependency on actions. The contributions in this work are complementary (and compatible) to Torabi et al. (2018).
+
+Concurrent to our work, several other papers introduced algorithms for sample efficient imitation learning. Blonde & Kalousis (2018) introduced Sample-efficient Adversarial Mimic (SAM) algo- ´ rithm that combines Deep Deterministic Policy Gradients (DDPG) from Lillicrap et al. (2015) with GAIL. While Reddy et al. (2019) and Sasaki et al. (2019) proposed imitation learning algorithms based on off-policy reinforcement learning that does not require to learn rewards.
+
+# 3 BACKGROUND
+
+# 3.1 MARKOV DECISION PROCESS
+
+We consider problems that satisfy the definition of a Markov Decision Process (MDP), formalized by the tuple: $( \bar { S ^ { , } } A , p ( s ) , p ( s ^ { \prime } \vert s , a ) , r ( s , a , s ^ { \prime } ) , \gamma )$ . Here $s$ , $\mathcal { A }$ represent the state and action spaces respectively, $p ( s )$ is the initial state distribution, $p ( s ^ { \prime } | s , a )$ defines environment dynamics represented as a conditional state distribution, $r ( s , a , s ^ { \prime } )$ is reward function and $\gamma$ the return discount factor.
+
+In continuing tfor a trajectory $\tau = \{ ( s _ { t } , a _ { t } ) \} _ { t = 0 } ^ { \infty }$ nment interactio, are defined as $\begin{array} { r } { R _ { t } = \sum _ { k = t } ^ { \infty } \gamma ^ { k - t } r \bigl ( s _ { k } , \dot { a } _ { k } , s _ { k + 1 } \bigr ) } \end{array}$ ngth, the returns. In order to use the same notation for tasks with absorbing states, whose finite length episodes end when reaching a terminal state, we can define a set of absorbing states $s _ { a }$ (Sutton et al., 1998) that an agent enters after the end of episode, has zero reward and transitions to itself for all agent actions: $s _ { a } \sim p ( \cdot | s _ { T } , a _ { T } )$ , can be defined simply as learn a policy that maxim $r ( s _ { a } , \cdot , \cdot ) = 0$ and $s _ { a } \sim p ( \cdot | s _ { a } , \cdot )$ $\begin{array} { r } { R _ { t } = \sum _ { k = t } ^ { T } \gamma ^ { k - t } r \big ( s _ { k } , a _ { k } , s _ { k + 1 } \big ) } \end{array}$ (see Figure 2). With this above absorbing state notation, returns . In reinforcement learning, the goal is to
+
+![](images/e65c3a8e2b5c5b30543feb3d8c12d649047ee7a7c8e15dcb6ed33447bf464c25.jpg)  
+Figure 2: We depict an episode of MDP with an absorbing state. The absorbing state transitions to itself with zero reward.
+
+In many imitation learning and IRL algorithms a common assumption is to assign zero reward value, often implicitly, to absorbing states. Moreover, standard benchmark MDPs, such as the tasks in OpenAI Gym, omit absorbing states and corresponding transitions from rollouts. Under this omission and a de-facto reward of 0 to absorbing states, the standard AIL algorithms do not have access to absorbing states in the buffer, which biases the reward learning process. We propose a modification that enables our DAC algorithm to assign a learned, potentially non-zero, reward for absorbing states. We discuss this in detail in Section 4.1, and demonstrate empirically in Section 5.2 that it is extremely important to properly handle the absorbing states for algorithms where rewards are learned.
+
+Considering the implications of adequate handling of terminal states, it is worth mentioning that practical implementations of MDP benchmarks terminate episodes after a specific number of steps. We refer to this as time dependent termination, which makes the tasks non-Markovian, since the returns are now time-dependent as observed in Pardo et al. (2017), Tucker et al. (2018). These works propose to fix this problem by using a time-dependent value function, or by bootstrapping after the terminal state instead of masking the returns, which can be achieved using an algorithm that incorporates value function learning (Fujimoto et al., 2018). Because our solution is derived for infinite horizon problems, we do not treat states that occur after time-dependent termination as absorbing states and assume that after explicitly adding absorbing states and transitions all tasks have infinite horizon (for example, see Figure 2). For this reason, in our implementation we use the latter approach and perform bootstrapping for the terminal states (for elaborate discussion on time limits in MDPs, we refer the reader to Pardo et al. (2017)).
+
+# 3.2 ADVERSARIAL IMITATION LEARNING
+
+In order to learn a robust reward function we use the GAIL framework (Ho & Ermon, 2016). Inspired by maximum entropy IRL (Ziebart et al., 2008) and Generative Adversarial Networks (GANs) (Goodfellow et al., 2014), GAIL trains a binary classifier, $D ( s , a )$ , referred to as the discriminator, to distinguish between transitions sampled from an expert and those generated by the trained policy. In standard GAN frameworks, a generator gradient is calculated by backprop through the learned discriminator. However, in GAIL the policy is instead provided a reward for confusing the discriminator, which is then maximized via some on-policy RL optimization scheme (e.g. TRPO (Schulman et al., 2015)):
+
+$$
+\operatorname* { m i n } _ { \pi } \operatorname* { m a x } _ { D } \mathbb { E } _ { \pi } [ \log ( D ( s , a ) ) ] + \mathbb { E } _ { \pi _ { E } } [ \log ( 1 - D ( s , a ) ) ] - \lambda H ( \pi )
+$$
+
+where $H ( \pi )$ is an entropy regularization term and $\pi _ { E }$ is a policy provided by an expert.
+
+The rewards learned by GAIL might not correspond to a true reward ( $\mathrm { F u }$ et al., 2017) but can be used to match the expert occupancy measure, which is defined as $\begin{array} { r } { \rho _ { \pi _ { E } } ( s , a ) = \sum _ { t = 0 } ^ { \infty } \gamma ^ { t } p ( s _ { t } = } \end{array}$ $s , a _ { t } = a | \pi _ { E } )$ ). Ho & Ermon (2016) draw analogies between distribution matching using GANs and occupancy matching with GAIL. They demonstrate that by maximizing the above reward, the algorithm matches occupancy measures of the expert and trained policies with some regularization term defined by the choice of GAN loss function.
+
+In principle, GAIL can be incorporated with any on-policy RL algorithm. However, in this work we adapt it for off-policy training (discussed in Section 4.3). As can be seen from Equation 1, the algorithm requires state-action pairs to be sampled from the learned policy. In Section 4.3 we will discuss what modifications are necessary to adapt the algorithm to off-policy training.
+
+# 4 DISCRIMINATOR-ACTOR-CRITIC
+
+In this section we first elaborate on specific instances of biased rewards in AIL algorithms due to insufficient handling of terminal states. Following that in Section 4.2, we present an approach for unbiasing rewards for existing AIL algorithms. Then, we derive an off-policy formulation of AIL in Section 4.3, which we name Discriminator-Actor-Critic (DAC). A high level pictorial representation of this algorithm is shown in Figure 1, and it is formally summarized in Appendix A.
+
+# 4.1 BIAS IN REWARDS
+
+In the following section, we present examples of bias present in implementations of different AIL algorithms as they assign zero rewards to absorbing states:
+
+• Absorbing states in MDPs: In the GAIL framework (and follow-up methods, such as GMMIL (Kim & Park, 2018), OptionGAN (Henderson et al., 2017a), AIRL and the widely used implementation of GAIL from OpenAI Baselines (Dhariwal et al., 2017)), for some benchmarks such as MuJoCo locomotion tasks from OpenAI Gym, a reward function $r ( s , a )$ assigns rewards to intermediate states depending on properties of a task. At the same time, policies executed on these MDPs generate rollouts that ignore absorbing states. Subsequently, the algorithms do not have access to these absorbing states in the buffer, cannot learn proper rewards, and therefore do not perform bootstrapping after terminal states; thus, 0 reward is implicitly assigned for absorbing states. For certain environments, a survival bonus in the form of per-step positive reward is added to the rewards received by the agent. This encourages agents to survive longer in the environment to collect more rewards. We observe that a commonly used form of the reward function: $r ( s , a ) = - \log ( 1 - D ( s , a ) )$ has worked well for environments that require a survival bonus. Under the implicit assumption of zero rewards for absorbing states in the MDP implementation, this strictly positive estimator cannot recover the true reward function for environments where an agent is required to solve the task as quickly as possible. Using this form of the reward function will lead to sub-optimal solutions. The agent is now incentivized to move in loops or take small actions (in continuous action spaces) that keep it close to the states in the expert’s trajectories. The agent keeps collecting positive rewards without actually attempting to solve the task demonstrated by the expert.2 Another reward formulation is $r ( s , a ) = \log ( D ( s , a ) )$ . This is often used for tasks with a per step penalty, when a part of a reward function consists of a negative constant assigned unconditionally of states and actions. However, this variant assigns only negative rewards and cannot learn a survival bonus. Such strong priors might lead to good results even with no expert trajectories (as shown in Figure 4).
+
+From an end-user’s perspective, it is undesirable to have to craft a different reward function for every new task. In the next section, we propose a method to handle absorbing states of the standard benchmark MDPs in such a way that AIL algorithms are able to recover different reward functions without adjusting the form of reward estimator.
+
+# 4.2 UNBIASING REWARDS
+
+In order to resolve the issues described in Section 4.1, we suggest explicitly learning rewards for absorbing states for expert demonstrations and trajectories produced by a policy. Thus, the returns episode that consists o with a learned reward $T$ nsitions are defiinstead of just $R _ { T } = r ( s _ { T } , a _ { T } ) \ : +$ $\scriptstyle \sum _ { t = T + 1 } ^ { \infty } \gamma ^ { t - T } r ( s _ { a } , \cdot )$ $r ( s _ { a } , \cdot )$ $R _ { T } = r ( s _ { T } , a _ { T } )$ used due to issues described in Section 4.2. This formulation allows the algorithms to correctly estimate returns for the final transitions and optimize the policy accordingly.
+
+In order to enable the AIL algorithms to learn the rewards for absorbing states and RL algorithms to take into account learned rewards, we suggest to update rollouts sampled from MDPs in the following way. After terminating an episode, we explicitly add a transition from the terminal state of the episode to an absorbing state $\left( { { s _ { T } } , { s _ { a } } } \right)$ and a transition from an absorbing state to itself $( s _ { a } , s _ { a } )$ .
+
+Thus, when sample from the replay buffer AIL algorithms will be able to see absorbing states there were previous hidden, while RL algorithms will be able to properly estimate values for terminal states using transitions $\left( { { s _ { T } } , { s _ { a } } } \right)$ and $( s _ { a } , s _ { a } )$ using the following recursions:
+
+$$
+\begin{array} { c } { { Q ( s _ { T } , a ) = r ( s _ { T } , a ) + \gamma Q ( s _ { a } , \cdot ) } } \\ { { Q ( s _ { a } , \cdot ) = r ( s _ { a } , \cdot ) + \gamma Q ( s _ { a } , \cdot ) } } \end{array}
+$$
+
+We implemented these absorbing states by adding an extra indicator dimension that indicates whether the state is absorbing or not, for absorbing states we set the indicator dimension to one and all other dimensions to zero. The GAIL discriminator can distinguish whether reaching an absorbing state is a desirable behavior from the expert’s perspective and assign the rewards accordingly.
+
+# 4.3 ADDRESSING SAMPLE INEFFICIENCY
+
+As previously mentioned, GAIL requires a significant number of interactions with a learning environment in order to imitate an expert policy. To address the sample inefficiency of GAIL, we use an off-policy RL algorithm and perform off-policy training of the GAIL discriminator performed in the following way: instead of sampling trajectories from a policy directly, we sample transitions from a replay buffer $\mathcal { R }$ collected while performing off-policy training:
+
+$$
+\operatorname* { m a x } _ { D } \mathbb { E } _ { \mathcal { R } } [ \log ( D ( s , a ) ) ] + \mathbb { E } _ { \pi _ { E } } [ \log ( 1 - D ( s , a ) ) ] - \lambda H ( \pi ) .
+$$
+
+Equation 2 tries to match the occupancy measures between the expert and the distribution induced by the replay buffer $\mathcal { R }$ , which can be seen as a mixture of all policy distributions that appeared during training, instead of the latest trained policy $\pi$ . In order to recover the original on-policy expectation, one needs to use importance sampling:
+
+$$
+\operatorname* { m a x } _ { D } \mathbb { E } _ { \mathcal { R } } \left[ \frac { p _ { \pi _ { \theta } } ( s , a ) } { p _ { \mathcal { R } } ( s , a ) } \log ( D ( s , a ) ) \right] + \mathbb { E } _ { \pi _ { E } } [ \log ( 1 - D ( s , a ) ) ] - \lambda H ( \pi ) .
+$$
+
+However, it can be challenging to properly estimate these densities and the discriminator updates might have large variance. We found that the algorithm works well in practice with the importance weight omitted.
+
+We use the GAIL discriminator in order to define rewards for training a policy using TD3; we update per-step rewards every time when we pull transitions from the replay buffer using the latest discriminator. The TD3 algorithm provides a good balance between sample complexity and simplicity of implementation and so is a good candidate for practical applications. Additionally, depending on the distribution of expert demonstrations and properties of the task, off-policy RL algorithms can effectively handle multi-modal action distributions; for example, this can be achieved for the Soft Actor Critic algorithm (Haarnoja et al., 2018b) using the reparametrization trick (Kingma & Ba, 2014) with a normalizing flow (Rezende & Mohamed, 2015) as described in Haarnoja et al. (2018a).
+
+# 5 EXPERIMENTS
+
+We implemented the DAC algorithm described in Section 4.3 using TensorFlow Eager (Abadi et al., 2015) and we evaluated it on popular benchmarks for continuous control simulated in MuJoCo (Todorov et al., 2012). We also define a new set of robotic continuous control tasks (described in detail below) simulated in PyBullet (Coumans & Bai, 2016), and a Virtual Reality (VR) system for capturing human examples in this environment; human examples constitute a particularly challenging demonstration source due to their noisy, multi-modal and potentially sub-optimal nature, and we define multi-task environments as a challenging setup for adversarial imitation learning.
+
+For the critic and policy networks we used the same architecture as in Fujimoto et al. (2018): a 2 layer MLP with ReLU activations and 400 and 300 hidden units correspondingly. We also add gradient clipping (Pascanu et al., 2013) to the actor network with clipping value of 40. For the discriminator we used the same architecture as in Ho & Ermon (2016): a 2 layer MLP with 100 hidden units and tanh activations. We trained all networks with the Adam optimizer (Kingma & Ba, 2014) and decay learning rate by starting with initial learning rate of $1 0 ^ { - 3 }$ and decaying it by 0.5 every $1 0 ^ { 5 }$ training steps for the actor network.
+
+![](images/63831734656c3d784b2bd775b6fde185329f704567069ef963c5441987fb2419.jpg)  
+Figure 3: Comparisons of algorithms using 4 expert demonstrations. y-axis corresponds to normalized reward (0 corresponds to a random policy, while 1 corresponds to an expert policy).
+
+In order to make the algorithm more stable, especially in the off-policy regime when the discriminator can easily over-fit to training data, we use regularization in the form of gradient penalties (Gulrajani et al., 2017) for the discriminator. Originally, this was introduced as an alternative to weight clipping for Wasserstein GANs (Arjovsky et al., 2017), but later it was shown that it helps to make JS-based GANs more stable as well (Lucic et al., 2017).
+
+We replicate the experimental setup of Ho & Ermon (2016): expert trajectories are sub-sampled by retaining every 20 time steps starting with a random offset (and fixed stride). It is worth mentioning that, as in Ho & Ermon (2016), this procedure is done in order to make the imitation learning task harder. With full trajectories, behavioral cloning provides competitive results to GAIL.
+
+Following Henderson et al. (2017b) and Fujimoto et al. (2018), we perform evaluation using 10 different random seeds. For each seed, we compute average episode reward using 10 episodes and running the policy without random noise. As in Ho & Ermon (2016) we plot reward normalized in such a way that zero corresponds to a random reward while one corresponds to expert rewards. We compute mean over all seeds and visualize half standard deviations. In order to produce the same evaluation for GAIL we used the original implementation3 of the algorithm.
+
+# 5.1 OFF POLICY DAC ALGORITHM
+
+Evaluation results of the DAC algorithm on a suite of MuJoCo tasks are shown in Figure 3, as are the GAIL (TRPO) and BC basline results. In the top-left plot, we show DAC is an order of magnitude more sample efficent than then TRPO and PPO based GAIL baselines. In the other plots, we show that by using a significantly smaller number of environment steps (orders of magnitude fewer), our DAC algorithm reaches comparable expected reward as the GAIL baseline. Furthermore, DAC outperforms the GAIL baseline on all environments within a 1 million step threshold. We obtained slightly worse results for Walker2d. However, as mentioned earlier, GAIL uses a reward function that already has some biases encoded in it that aids training on this specific environment. A comprehensive suit of results can be found in Appendix B, Figure 7.
+
+# 5.2 REWARD BIAS
+
+As discussed in Section 4.1, the reward function variants used with GAIL can have implicit biases when used without handling absorbing states. Figure 4 demonstrates how bias affects results on an environment with survival bonus when using the reward function of Ho & Ermon (2016): $r ( s , a ) =$ $- \log ( 1 - D ( s , a ) )$ . Surprisingly, when using a fixed and untrained GAIL discriminator that outputs 0.5 for every state-action pair, we were able to reach episode rewards of around 1000 on the Hopper environment, corresponding to approximately one third of the expert performance. Without any reward learning, and using no expert demonstrations, the agent can learn a policy that outperforms behavioral cloning (Figure 4). Therefore, the choice of a specific reward function might already provide strong prior knowledge that helps the RL algorithm to move towards recovering the expert policy, irrespective of the quality of the learned reward.
+
+![](images/20efb2c433e451e3882df5a3213393f3045bd0dfe602a94c2aeb08ef956f4fdc.jpg)
+
+![](images/f27a4b0f4225210951edf48b03b0d9121fd8d1bf32fe83bfae02f883ce474e37.jpg)  
+Figure 4: Even without training, some reward functions can perform well on some tasks.   
+Figure 5: Effect of absorbing state handling on Kuka environments. For these environments, we use human demonstrations as expert trajectories, and GAIL framework with a positive reward function.
+
+Additionally, we evaluated our method on two environments with per-step penalty (see Figure 5). These environment are simulated in PyBullet and consist of a Kuka IIWA arm and 3 blocks on a virtual table. A rendering of the environment can be found in Appendix C, Figure 8. Using a Cartesian displacement action for the gripper end-effector and a compact observation-space (consisting of each block’s 6DOF pose and the Kuka’s end-effector pose), the agent must either a) reach one of the 3 blocks in the shortest number of frames possible (the target block is provided to the policy as a one-hot vector), which we call Kuka-Reach, or b) push one block along the table so that it is adjacent to another block, which we call Kuka-PushNext. For evaluation, we define a sparse reward indicating successful task completion (within some threshold). For these imitation learning experiments, we use human demonstrations collected with a VR setup, where the participant wears a VR headset and controls in real-time the gripper end-effector using a 6DOF controller.
+
+Using the reward defined as $r ( s , a ) = - l o g ( 1 - D ( s , a ) )$ and without absorbing state handling, the agent completely fails to recover the expert policy given 600 expert trajectories without subsampling (as shown in Figure 4). In contrast, our DAC algorithm quickly learns to imitate the expert, despite using noisy and potentially sub-optimal human demonstrations.
+
+As discussed, alternative reward functions do not have this positive bias but still require proper handling of the absorbing states as well in order to avoid early termination due to incorrectly assigned per-frame penalty. Figure 6 illustrates results for AIRL with and without learning rewards for absorbing states. For these experiments we use the discriminator structure from $\mathrm { F u }$ et al. (2017) in combination with the TD3 algorithm.
+
+# 6 CONCLUSION
+
+In this work we address several important issues associated with the popular GAIL framework. In particular, we address 1) sample inefficiency with respect to policy transitions in the environment and 2) we demonstrate a number of reward biases that can either implicitly impose prior knowledge about the true reward, or alternatively, prevent the policy from imitating the optimal expert. To address reward bias, we propose a simple mechanism whereby the rewards for absorbing states are also learned, which negates the need to hand-craft a discriminator reward function for the properties of the task at hand. In order to improve sample efficiency, we perform off-policy training of the discriminator and use an off-policy RL algorithm. We show that our algorithm reaches state-of-theart performance for an imitation learning algorithm on several standard RL benchmarks, and is able to recover the expert policy given a significantly smaller number of samples than in recent GAIL work.
+
+![](images/6fee1a4b0187eb33856999252f719d3b3a7323edb7c8a270e64e4cead5914dd8.jpg)  
+Figure 6: Effect of learning absorbing state rewards when using an AIRL discriminator within the DAC Framework in OpenAI Gym environments.
+
+# ACKNOWLEDGMENTS
+
+We would like to thank Justin Fu and the ICLR Reproducibility Workshop team for insightful discussions and feedback.
+
+# REFERENCES
+
+Mart´ın Abadi, Ashish Agarwal, Paul Barham, Eugene Brevdo, Zhifeng Chen, Craig Citro, Greg S. Corrado, Andy Davis, Jeffrey Dean, Matthieu Devin, Sanjay Ghemawat, Ian Goodfellow, Andrew Harp, Geoffrey Irving, Michael Isard, Yangqing Jia, Rafal Jozefowicz, Lukasz Kaiser, Manjunath Kudlur, Josh Levenberg, Dandelion Mane, Rajat Monga, Sherry Moore, Derek Murray, Chris ´ Olah, Mike Schuster, Jonathon Shlens, Benoit Steiner, Ilya Sutskever, Kunal Talwar, Paul Tucker, Vincent Vanhoucke, Vijay Vasudevan, Fernanda Viegas, Oriol Vinyals, Pete Warden, Martin Wat- ´ tenberg, Martin Wicke, Yuan Yu, and Xiaoqiang Zheng. TensorFlow: Large-scale machine learning on heterogeneous systems, 2015. URL https://www.tensorflow.org/. Software available from tensorflow.org.
+
+Pieter Abbeel and Andrew Y Ng. Apprenticeship learning via inverse reinforcement learning. In Proceedings of the twenty-first international conference on Machine learning, pp. 1. ACM, 2004.
+
+Martin Arjovsky, Soumith Chintala, and Leon Bottou. Wasserstein gan. ´ arXiv preprint arXiv:1701.07875, 2017.
+
+Michael Bain and Claude Sommut. A framework for behavioural cloning. Machine intelligence, 15 (15):103, 1999.
+
+Nir Baram, Oron Anschel, Itai Caspi, and Shie Mannor. End-to-end differentiable adversarial imitation learning. In International Conference on Machine Learning, pp. 390–399, 2017.
+
+Lionel Blonde and Alexandros Kalousis. Sample-efficient imitation learning via generative adver- ´ sarial nets. arXiv preprint arXiv:1809.02064, 2018.
+
+E Coumans and Y Bai. Pybullet, a python module for physics simulation for games, robotics and machine learning. GitHub repository, 2016.
+
+Prafulla Dhariwal, Christopher Hesse, Oleg Klimov, Alex Nichol, Matthias Plappert, Alec Radford, John Schulman, Szymon Sidor, Yuhuai Wu, and Peter Zhokhov. Openai baselines. https: //github.com/openai/baselines, 2017.
+
+Chelsea Finn, Paul Christiano, Pieter Abbeel, and Sergey Levine. A connection between generative adversarial networks, inverse reinforcement learning, and energy-based models. NIPS Workshop on Adversarial Training, 2016a.
+
+Chelsea Finn, Sergey Levine, and Pieter Abbeel. Guided cost learning: Deep inverse optimal control via policy optimization. In International Conference on Machine Learning, pp. 49–58, 2016b.
+
+Justin Fu, Katie Luo, and Sergey Levine. Learning robust rewards with adversarial inverse reinforcement learning. arXiv preprint arXiv:1710.11248, 2017.
+
+Scott Fujimoto, Herke van Hoof, and Dave Meger. Addressing function approximation error in actor-critic methods. arXiv preprint arXiv:1802.09477, 2018.
+
+Ian Goodfellow, Jean Pouget-Abadie, Mehdi Mirza, Bing Xu, David Warde-Farley, Sherjil Ozair, Aaron Courville, and Yoshua Bengio. Generative adversarial nets. In Advances in neural information processing systems, pp. 2672–2680, 2014.
+
+Ishaan Gulrajani, Faruk Ahmed, Martin Arjovsky, Vincent Dumoulin, and Aaron C Courville. Improved training of wasserstein gans. In Advances in Neural Information Processing Systems, pp. 5767–5777, 2017.
+
+Tuomas Haarnoja, Kristian Hartikainen, Pieter Abbeel, and Sergey Levine. Latent space policies for hierarchical reinforcement learning. arXiv preprint arXiv:1804.02808, 2018a.
+
+Tuomas Haarnoja, Aurick Zhou, Pieter Abbeel, and Sergey Levine. Soft actor-critic: Offpolicy maximum entropy deep reinforcement learning with a stochastic actor. arXiv preprint arXiv:1801.01290, 2018b.
+
+Peter Henderson, Wei-Di Chang, Pierre-Luc Bacon, David Meger, Joelle Pineau, and Doina Precup. Optiongan: Learning joint reward-policy options using generative adversarial inverse reinforcement learning. arXiv preprint arXiv:1709.06683, 2017a.
+
+Peter Henderson, Riashat Islam, Philip Bachman, Joelle Pineau, Doina Precup, and David Meger. Deep reinforcement learning that matters. arXiv preprint arXiv:1709.06560, 2017b.
+
+Todd Hester, Matej Vecerik, Olivier Pietquin, Marc Lanctot, Tom Schaul, Bilal Piot, Dan Horgan, John Quan, Andrew Sendonaris, Gabriel Dulac-Arnold, et al. Deep q-learning from demonstrations. arXiv preprint arXiv:1704.03732, 2017.
+
+Jonathan Ho and Stefano Ermon. Generative adversarial imitation learning. In Advances in Neural Information Processing Systems, pp. 4565–4573, 2016.
+
+Bingyi Kang, Zequn Jie, and Jiashi Feng. Policy optimization with demonstrations. In Proceedings of the 35th International Conference on Machine Learning, volume 80 of Proceedings of Machine Learning Research, pp. 2469–2478. PMLR, 2018.
+
+Kee-Eung Kim and Hyun Soo Park. Imitation learning via kernel mean embedding. AAAI, 2018.
+
+Diederik P Kingma and Jimmy Ba. Adam: A method for stochastic optimization. arXiv preprint arXiv:1412.6980, 2014.
+
+Hoang M Le, Nan Jiang, Alekh Agarwal, Miroslav Dud´ık, Yisong Yue, and Hal Daume III. Hierar- ´ chical imitation and reinforcement learning. arXiv preprint arXiv:1803.00590, 2018.
+
+Timothy P Lillicrap, Jonathan J Hunt, Alexander Pritzel, Nicolas Heess, Tom Erez, Yuval Tassa, David Silver, and Daan Wierstra. Continuous control with deep reinforcement learning. arXiv preprint arXiv:1509.02971, 2015.
+
+Mario Lucic, Karol Kurach, Marcin Michalski, Sylvain Gelly, and Olivier Bousquet. Are gans created equal? a large-scale study. arXiv preprint arXiv:1711.10337, 2017.
+
+Ashvin Nair, Bob McGrew, Marcin Andrychowicz, Wojciech Zaremba, and Pieter Abbeel. Overcoming exploration in reinforcement learning with demonstrations. arXiv preprint arXiv:1709.10089, 2017.
+
+Andrew Y. $\mathrm { N g }$ and Stuart Russell. Algorithms for inverse reinforcement learning. In in Proc. 17th International Conf. on Machine Learning, pp. 663–670. Morgan Kaufmann, 2000.
+
+Andrew $\mathrm { ~ Y ~ N ~ g ~ }$ , Daishi Harada, and Stuart Russell. Policy invariance under reward transformations: Theory and application to reward shaping. In ICML, volume 99, pp. 278–287, 1999.
+
+Fabio Pardo, Arash Tavakoli, Vitaly Levdik, and Petar Kormushev. Time limits in reinforcement learning. arXiv preprint arXiv:1712.00378, 2017.
+
+Razvan Pascanu, Tomas Mikolov, and Yoshua Bengio. On the difficulty of training recurrent neural networks. In International Conference on Machine Learning, pp. 1310–1318, 2013.
+
+Jan Peters and Stefan Schaal. Reinforcement learning of motor skills with policy gradients. Neural networks, 21(4):682–697, 2008.
+
+Nathan D Ratliff, J Andrew Bagnell, and Martin A Zinkevich. Maximum margin planning. In Proceedings of the 23rd international conference on Machine learning, pp. 729–736. ACM, 2006.
+
+Siddharth Reddy, Anca D. Dragan, and Sergey Levine. What would pi\* do?: Imitation learning via off-policy reinforcement learning, 2019. URL https://openreview.net/forum?id $\underline { { \underline { { \mathbf { \Pi } } } } } =$ B1excoAqKQ.
+
+Danilo Jimenez Rezende and Shakir Mohamed. Variational inference with normalizing flows. arXiv preprint arXiv:1505.05770, 2015.
+
+Stephane Ross, Geoffrey Gordon, and Drew Bagnell. A reduction of imitation learning and struc- ´ tured prediction to no-regret online learning. In Proceedings of the fourteenth international conference on artificial intelligence and statistics, pp. 627–635, 2011.
+
+Fumihiro Sasaki, Tetsuya Yohira, and Atsuo Kawaguchi. Sample efficient imitation learning for continuous control. In International Conference on Learning Representations, 2019. URL https://openreview.net/forum?id $\underline { { \underline { { \mathbf { \Pi } } } } } =$ BkN5UoAqF7.
+
+John Schulman, Sergey Levine, Pieter Abbeel, Michael Jordan, and Philipp Moritz. Trust region policy optimization. In International Conference on Machine Learning, pp. 1889–1897, 2015.
+
+John Schulman, Filip Wolski, Prafulla Dhariwal, Alec Radford, and Oleg Klimov. Proximal policy optimization algorithms. arXiv preprint arXiv:1707.06347, 2017.
+
+Richard S Sutton, Andrew G Barto, et al. Reinforcement learning: An introduction. MIT press, 1998.
+
+Umar Syed, Michael Bowling, and Robert E Schapire. Apprenticeship learning using linear programming. In Proceedings of the 25th international conference on Machine learning, pp. 1032– 1039. ACM, 2008.
+
+Emanuel Todorov, Tom Erez, and Yuval Tassa. Mujoco: A physics engine for model-based control. In Intelligent Robots and Systems (IROS), 2012 IEEE/RSJ International Conference on, pp. 5026– 5033. IEEE, 2012.
+
+Faraz Torabi, Garrett Warnell, and Peter Stone. Generative adversarial imitation from observation. arXiv preprint arXiv:1807.06158, 2018.
+
+Matej Vecer´ık, Todd Hester, Jonathan Scholz, Fumin Wang, Olivier Pietquin, Bilal Piot, Nicolas Heess, Thomas Rothorl, Thomas Lampe, and Martin A Riedmiller. Leveraging demonstrations for ¨ deep reinforcement learning on robotics problems with sparse rewards. CoRR, abs/1707.08817, 2017.
+
+Ziyu Wang, Josh S Merel, Scott E Reed, Nando de Freitas, Gregory Wayne, and Nicolas Heess. Robust imitation of diverse behaviors. In Advances in Neural Information Processing Systems, pp. 5320–5329, 2017.
+
+Yuke Zhu, Ziyu Wang, Josh Merel, Andrei Rusu, Tom Erez, Serkan Cabi, Saran Tunyasuvunakool, Janos Kram ´ ar, Raia Hadsell, Nando de Freitas, et al. Reinforcement and imitation learning for ´ diverse visuomotor skills. arXiv preprint arXiv:1802.09564, 2018.
+
+Brian D Ziebart, Andrew L Maas, J Andrew Bagnell, and Anind K Dey. Maximum entropy inverse reinforcement learning. In AAAI, volume 8, pp. 1433–1438. Chicago, IL, USA, 2008.
+
+# A DAC ALGORITHM
+
+# Algorithm 1 Discriminative-Actor-Critic Adversarial Imitation Learning Algorithm
+
+<table><tr><td>nput:expert replay buffer RE procedure WRAPFORABSORBINGSTATES(T)</td></tr><tr><td>if sT is a terminal state not caused by time limits then T ←T\{(st,aT,:,st)}U{(st,aT,:,Sa)} T←TU{(sa,,:,sa)}</td></tr><tr><td>end if return T</td></tr><tr><td>end procedure</td></tr><tr><td></td></tr><tr><td>Initialize replaybufferR←@ for T={(St,at,,st)}T=1 ∈REdo</td></tr><tr><td>T ←WrapForAbsorbingState(T) Wrap expert rollouts with absorbing states end for</td></tr><tr><td></td></tr><tr><td>for n = 1,...,do</td></tr><tr><td>Sample T = {(st,at,:,st)}T=1 with π0 R ←RU WrapForAbsorbingState(τ) Update Policy Replay Buffer</td></tr></table>
+
+![](images/b3571dd47a884af45bdecca1273f0671b42c431d444710ab08254166537fed2f.jpg)  
+B SUPPLEMENTARY RESULTS ON MUJOCO ENVIRONMENTS   
+Figure 7: Comparisons of different algorithms given the same number of expert demonstrations. y-axis corresponds to normalized reward (0 corresponds to a random policy, while 1 corresponds to an expert policy).
+
+# C KUKA-IIWA SIMULATED ENVIRONMENT
+
+![](images/19b746b7ce5e603b62f5f309187dd95f7891096815c19481338661b775f8874f.jpg)  
+Figure 8: Renderings of our Kuka-IIWA environment. Using a VR headset and 6DOF controller, a human participant can control the 6DOF end-effector pose in order to record expert demonstrations. In the Kuka-Reach tasks, the agent must bring the robot gripper to 1 of the 3 blocks (where the state contains a 1-hot encoding of the task) and for the Kuka-PushNext tasks, the agent must use the robot gripper to push one block next to another.

parse/train/Hk4fpoA5Km/Hk4fpoA5Km_content_list.json

@@ -0,0 +1,1495 @@
+[
+    {
+        "type": "text",
+        "text": "DISCRIMINATOR-ACTOR-CRITIC:ADDRESSING SAMPLE INEFFICIENCY AND REWARDBIAS IN ADVERSARIAL IMITATION LEARNING",
+        "text_level": 1,
+        "bbox": [
+            174,
+            99,
+            821,
+            172
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Ilya Kostrikov1,2,\\*, Kumar Krishna Agrawal2, †, Debidatta Dwibedi2, †, Sergey Levine2, and Jonathan Tompson2 ",
+        "bbox": [
+            184,
+            199,
+            815,
+            229
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1Courant Institute of Mathematical Sciences, New York University, New York, NY 2Google Brain, Mountain View, CA ",
+        "bbox": [
+            228,
+            241,
+            767,
+            270
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "ABSTRACT ",
+        "text_level": 1,
+        "bbox": [
+            454,
+            311,
+            544,
+            327
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Algorithms for imitation learning based on adversarial optimization, such as generative adversarial imitation learning (GAIL) and adversarial inverse reinforcement learning (AIRL), can effectively mimic demonstrated behaviours by employing both reward and reinforcement learning (RL). However, applications of such algorithms are challenged by the inherent instability and poor sample efficiency of on-policy RL. In particular, the inadequate handling of absorbing states in canonical implementations of RL environments causes an implicit bias in reward functions used by these algorithms. While these biases might work well for some environments, they lead to sub-optimal behaviors in others. Moreover, despite the ability of these algorithms to learn from a few demonstrations, they require a prohibitively large number of the environment interactions for many real-world applications. To address these issues, we first propose to extend the environment MDP with absorbing states which leads to task-independent, and more importantly, unbiased rewards. Secondly, we introduce an off-policy learning algorithm, which we refer to as Discriminator-Actor-Critic. We demonstrate the effectiveness of proper handling of absorbing states, while empirically improving the sample efficiency by an average factor of 10. Our implementation is available online 1. ",
+        "bbox": [
+            233,
+            343,
+            764,
+            592
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 INTRODUCTION ",
+        "text_level": 1,
+        "bbox": [
+            178,
+            619,
+            334,
+            636
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "The Adversarial Imitation Learning (AIL) class of algorithms learns a policy that robustly imitates an expert’s actions via a collection of expert demonstrations, an adversarial discriminator and a reinforcement learning method. For example, the Generative Adversarial Imitation Learning (GAIL) algorithm (Ho & Ermon, 2016) uses a discriminator reward and a policy gradient algorithm to imitate an expert RL policy. Similarly, the Adversarial Inverse Reinforcement Learning (AIRL) algorithm (Fu et al., 2017) makes use of a modified GAIL discriminator to recover a reward function to perform Inverse Reinforcement Learning (IRL) (Abbeel & Ng, 2004). Additionally, this subsequent dense reward is robust to changes in dynamics or environment properties. Importantly, AIL algorithms such as GAIL and AIRL, obtain higher performance than supervised Behavioral Cloning (BC) when using a small number of expert demonstrations; experimentally suggesting that AIL algorithms alleviate some of the distributional drift (Ross et al., 2011) issues associated with BC. However, these AIL methods suffer from two important issues that will be addressed by this work: 1) a large number of policy interactions with the learning environment is required for policy convergence and 2) although in principle these methods can learn rewards for absorbing states, the original implementations suffer from improper handling of the environment terminal states. This introduces implicit rewards priors which can either improve or degrade policy performance. ",
+        "bbox": [
+            174,
+            651,
+            825,
+            873
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "image",
+        "img_path": "images/1de8cf30d798c6c776834bfece5450f74e76287380d82db216a4e24c0a81ab5b.jpg",
+        "image_caption": [
+            "Figure 1: The Discriminator-Actor-Critic imitation learning framework combined with a method to explicitly learn rewards for the absorbing states. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            186,
+            98,
+            808,
+            189
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "While GAIL requires as little as 200 expert frame transitions (from 4 expert trajectories) to learn a robust reward function on most MuJoCo (Todorov et al., 2012) tasks, the number of policy frame transitions sampled from the environment can be as high as 25 million in order to reach convergence. If PPO (Schulman et al., 2017) is used in place of TRPO (Schulman et al., 2015), the sample complexity can be improved (for example, as in Figure 3, 25 million steps reduces to approximately 10 million steps), however it is still intractable for many robotics or real-world applications. In this work we address this issue by incorporating an off-policy RL algorithm (TD3 (Fujimoto et al., 2018)) and an off-policy discriminator to dramatically decrease the sample complexity by orders of magnitude. ",
+        "bbox": [
+            174,
+            258,
+            825,
+            383
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "In this work, we also illustrate how specific design choices for AIL algorithms and MDPs used in practice, have a large impact on agent performance for environments with absorbing states. For instance, as we will demonstrate, if the implementation assigns zero rewards for absorbing states, a strictly positive reward function can prevent the agent from solving tasks with a minimal number of steps, while a strictly negative reward function is unable to emulate a survival bonus. Therefore, one must have some knowledge of the true environment reward and incorporate such priors to choose a suitable reward function for successful application of GAIL and AIRL. We will discuss these issues formally, and present a simple - yet effective - solution that drastically improves policy performance for environments with absorbing states; we explicitly handle absorbing state transitions by learning the reward associated with these states. ",
+        "bbox": [
+            174,
+            391,
+            825,
+            530
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "First we propose a new algorithm, which we call Discriminator-Actor-Critic (DAC) (Figure 1), that is compatible with the GAIL and AIRL frameworks by extending them with an off-policy discriminator and an off-policy actor-critic reinforcement learning algorithm. Then we propose a general approach to handling absorbing states in inverse reinforcement learning and reward learning methods. We experimentally demonstrate that this removes the bias due to incorrect absorbing state handling in both GAIL-like and AIRL-like variants of our DAC algorithm. In our experiments, we demonstrate that DAC achieves state-of-the-art AIL performance for a number of difficult imitation learning tasks, where proper handling of terminal states is crucial for matching expert performance in the presence of absorbing states. More specifically, in this work we: ",
+        "bbox": [
+            174,
+            536,
+            825,
+            662
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "• Identify, and propose solutions for the problem of handling terminal states of policy rollouts in standard RL benchmarks in the context of AIL algorithms. • Accelerate learning from demonstrations by providing an off-policy variant for AIL algorithms, which significantly reduces the number of agent-environment interactions. • Illustrate the robustness of DAC to noisy, multi-modal and constrained expert demonstrations, by performing experiments with human demonstrations on non-trivial robotic tasks. ",
+        "bbox": [
+            215,
+            674,
+            823,
+            768
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2 RELATED WORK ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            794,
+            344,
+            810
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Imitation learning has been broadly studied under the twin umbrellas of Behavioral Cloning (BC) (Bain & Sommut, 1999; Ross et al., 2011) and Inverse Reinforcement Learning (IRL) (Ng & Russell, 2000). To recover the underlying policy, IRL performs an intermediate step of estimating the reward function followed by RL on this function (Abbeel & Ng, 2004; Ratliff et al., 2006). Operating in the Maximum Entropy IRL formulation (Ziebart et al., 2008), Finn et al. (2016b) introduce an iterativesampling based estimator for the partition function, deriving an algorithm for recovering non-linear reward functions in high-dimensional state and action spaces. Finn et al. (2016a) and $\\mathrm { F u }$ et al. ",
+        "bbox": [
+            173,
+            825,
+            825,
+            924
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "(2017) further extend this by exploring the theoretical and practical considerations of an adversarial IRL framework, and draw connections between IRL and cost learning in GANs (Goodfellow et al., 2014). ",
+        "bbox": [
+            174,
+            103,
+            823,
+            145
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "In practical scenarios, we are often interested in recovering the expert’s policy, rather than the reward function. Following Syed et al. (2008), and by treating imitation learning as an occupancy matching problem, Ho & Ermon (2016) proposed a Generative Adversarial Imitation Learning (GAIL) framework for learning a policy from demonstrations, which bypasses the need to recover the expert’s reward function. More recent work extends the framework by improving on stability and robustness (Wang et al., 2017; Kim & Park, 2018) and making connections to model-based imitation learning (Baram et al., 2017). These approaches generally use on-policy algorithms for policy optimization, trading off sample efficiency for training stability. ",
+        "bbox": [
+            174,
+            152,
+            825,
+            263
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Learning complex behaviors from sparse reward signals poses a significant challenge in reinforcement learning. In this context, expert demonstrations or template trajectories have been successfully used (Peters & Schaal, 2008) for initializing RL policies. There has been a growing interest in combining extrinsic sparse reward signals with imitation learning for guided exploration (Zhu et al., 2018; Kang et al., 2018; Le et al., 2018; Vecer´ık et al., 2017). Off policy learning from demonstration has been previously studied under the umbrella of accelerating reinforcement learning by structured exploration (Nair et al., 2017; Hester et al., 2017) An implicit assumption of these approaches is access to demonstrations and reward from the environment; our approach requires access only to expert demonstrations. ",
+        "bbox": [
+            174,
+            270,
+            825,
+            396
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Biases associated with specific MDP benchmarks also arise in the standard RL setup. In particular, Pardo et al. (2017) and Tucker et al. (2018) discuss handling of time limits in RL specifically with MDPs where time limits make the problems non-Markovian and might affect optimality of the training policy and value function estimation. The problem with the biases associated with episode terminations also prove to be severe for AIL algorithms because for specific RL benchmarks the absorbing states might not even be adequately taken into consideration. We discuss this in more detail in Section 4.1. ",
+        "bbox": [
+            174,
+            402,
+            825,
+            500
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Our work is most related to AIL algorithms (Ho & Ermon, 2016; Fu et al., 2017; Torabi et al., 2018). In contrast to Ho & Ermon (2016) which assumes (state-action-state’) transition tuples, Torabi et al. (2018) has weaker assumptions, by relying only on observations and removing the dependency on actions. The contributions in this work are complementary (and compatible) to Torabi et al. (2018). ",
+        "bbox": [
+            174,
+            507,
+            823,
+            564
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Concurrent to our work, several other papers introduced algorithms for sample efficient imitation learning. Blonde & Kalousis (2018) introduced Sample-efficient Adversarial Mimic (SAM) algo- ´ rithm that combines Deep Deterministic Policy Gradients (DDPG) from Lillicrap et al. (2015) with GAIL. While Reddy et al. (2019) and Sasaki et al. (2019) proposed imitation learning algorithms based on off-policy reinforcement learning that does not require to learn rewards. ",
+        "bbox": [
+            174,
+            570,
+            825,
+            640
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3 BACKGROUND ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            674,
+            326,
+            690
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3.1 MARKOV DECISION PROCESS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            714,
+            419,
+            729
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "We consider problems that satisfy the definition of a Markov Decision Process (MDP), formalized by the tuple: $( \\bar { S ^ { , } } A , p ( s ) , p ( s ^ { \\prime } \\vert s , a ) , r ( s , a , s ^ { \\prime } ) , \\gamma )$ . Here $s$ , $\\mathcal { A }$ represent the state and action spaces respectively, $p ( s )$ is the initial state distribution, $p ( s ^ { \\prime } | s , a )$ defines environment dynamics represented as a conditional state distribution, $r ( s , a , s ^ { \\prime } )$ is reward function and $\\gamma$ the return discount factor. ",
+        "bbox": [
+            174,
+            746,
+            823,
+            803
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "In continuing tfor a trajectory $\\tau = \\{ ( s _ { t } , a _ { t } ) \\} _ { t = 0 } ^ { \\infty }$ nment interactio, are defined as $\\begin{array} { r } { R _ { t } = \\sum _ { k = t } ^ { \\infty } \\gamma ^ { k - t } r \\bigl ( s _ { k } , \\dot { a } _ { k } , s _ { k + 1 } \\bigr ) } \\end{array}$ ngth, the returns. In order to use the same notation for tasks with absorbing states, whose finite length episodes end when reaching a terminal state, we can define a set of absorbing states $s _ { a }$ (Sutton et al., 1998) that an agent enters after the end of episode, has zero reward and transitions to itself for all agent actions: $s _ { a } \\sim p ( \\cdot | s _ { T } , a _ { T } )$ , can be defined simply as learn a policy that maxim $r ( s _ { a } , \\cdot , \\cdot ) = 0$ and $s _ { a } \\sim p ( \\cdot | s _ { a } , \\cdot )$ $\\begin{array} { r } { R _ { t } = \\sum _ { k = t } ^ { T } \\gamma ^ { k - t } r \\big ( s _ { k } , a _ { k } , s _ { k + 1 } \\big ) } \\end{array}$ (see Figure 2). With this above absorbing state notation, returns . In reinforcement learning, the goal is to ",
+        "bbox": [
+            174,
+            809,
+            825,
+            924
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "image",
+        "img_path": "images/e65c3a8e2b5c5b30543feb3d8c12d649047ee7a7c8e15dcb6ed33447bf464c25.jpg",
+        "image_caption": [
+            "Figure 2: We depict an episode of MDP with an absorbing state. The absorbing state transitions to itself with zero reward. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            269,
+            97,
+            736,
+            164
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "In many imitation learning and IRL algorithms a common assumption is to assign zero reward value, often implicitly, to absorbing states. Moreover, standard benchmark MDPs, such as the tasks in OpenAI Gym, omit absorbing states and corresponding transitions from rollouts. Under this omission and a de-facto reward of 0 to absorbing states, the standard AIL algorithms do not have access to absorbing states in the buffer, which biases the reward learning process. We propose a modification that enables our DAC algorithm to assign a learned, potentially non-zero, reward for absorbing states. We discuss this in detail in Section 4.1, and demonstrate empirically in Section 5.2 that it is extremely important to properly handle the absorbing states for algorithms where rewards are learned. ",
+        "bbox": [
+            174,
+            233,
+            825,
+            358
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Considering the implications of adequate handling of terminal states, it is worth mentioning that practical implementations of MDP benchmarks terminate episodes after a specific number of steps. We refer to this as time dependent termination, which makes the tasks non-Markovian, since the returns are now time-dependent as observed in Pardo et al. (2017), Tucker et al. (2018). These works propose to fix this problem by using a time-dependent value function, or by bootstrapping after the terminal state instead of masking the returns, which can be achieved using an algorithm that incorporates value function learning (Fujimoto et al., 2018). Because our solution is derived for infinite horizon problems, we do not treat states that occur after time-dependent termination as absorbing states and assume that after explicitly adding absorbing states and transitions all tasks have infinite horizon (for example, see Figure 2). For this reason, in our implementation we use the latter approach and perform bootstrapping for the terminal states (for elaborate discussion on time limits in MDPs, we refer the reader to Pardo et al. (2017)). ",
+        "bbox": [
+            174,
+            366,
+            825,
+            532
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3.2 ADVERSARIAL IMITATION LEARNING ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            555,
+            475,
+            569
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "In order to learn a robust reward function we use the GAIL framework (Ho & Ermon, 2016). Inspired by maximum entropy IRL (Ziebart et al., 2008) and Generative Adversarial Networks (GANs) (Goodfellow et al., 2014), GAIL trains a binary classifier, $D ( s , a )$ , referred to as the discriminator, to distinguish between transitions sampled from an expert and those generated by the trained policy. In standard GAN frameworks, a generator gradient is calculated by backprop through the learned discriminator. However, in GAIL the policy is instead provided a reward for confusing the discriminator, which is then maximized via some on-policy RL optimization scheme (e.g. TRPO (Schulman et al., 2015)): ",
+        "bbox": [
+            173,
+            583,
+            825,
+            695
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/bc533a374eae2e01f2d9aa562e216d7ff1a09da6653a949060a23bf3e5e89767.jpg",
+        "text": "$$\n\\operatorname* { m i n } _ { \\pi } \\operatorname* { m a x } _ { D } \\mathbb { E } _ { \\pi } [ \\log ( D ( s , a ) ) ] + \\mathbb { E } _ { \\pi _ { E } } [ \\log ( 1 - D ( s , a ) ) ] - \\lambda H ( \\pi )\n$$",
+        "text_format": "latex",
+        "bbox": [
+            290,
+            722,
+            709,
+            744
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "where $H ( \\pi )$ is an entropy regularization term and $\\pi _ { E }$ is a policy provided by an expert. ",
+        "bbox": [
+            173,
+            756,
+            746,
+            771
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "The rewards learned by GAIL might not correspond to a true reward ( $\\mathrm { F u }$ et al., 2017) but can be used to match the expert occupancy measure, which is defined as $\\begin{array} { r } { \\rho _ { \\pi _ { E } } ( s , a ) = \\sum _ { t = 0 } ^ { \\infty } \\gamma ^ { t } p ( s _ { t } = } \\end{array}$ $s , a _ { t } = a | \\pi _ { E } )$ ). Ho & Ermon (2016) draw analogies between distribution matching using GANs and occupancy matching with GAIL. They demonstrate that by maximizing the above reward, the algorithm matches occupancy measures of the expert and trained policies with some regularization term defined by the choice of GAN loss function. ",
+        "bbox": [
+            174,
+            776,
+            825,
+            861
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "In principle, GAIL can be incorporated with any on-policy RL algorithm. However, in this work we adapt it for off-policy training (discussed in Section 4.3). As can be seen from Equation 1, the algorithm requires state-action pairs to be sampled from the learned policy. In Section 4.3 we will discuss what modifications are necessary to adapt the algorithm to off-policy training. ",
+        "bbox": [
+            174,
+            867,
+            823,
+            924
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "4 DISCRIMINATOR-ACTOR-CRITIC ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            102,
+            477,
+            117
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "In this section we first elaborate on specific instances of biased rewards in AIL algorithms due to insufficient handling of terminal states. Following that in Section 4.2, we present an approach for unbiasing rewards for existing AIL algorithms. Then, we derive an off-policy formulation of AIL in Section 4.3, which we name Discriminator-Actor-Critic (DAC). A high level pictorial representation of this algorithm is shown in Figure 1, and it is formally summarized in Appendix A. ",
+        "bbox": [
+            174,
+            133,
+            825,
+            203
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "4.1 BIAS IN REWARDS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            219,
+            343,
+            233
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "In the following section, we present examples of bias present in implementations of different AIL algorithms as they assign zero rewards to absorbing states: ",
+        "bbox": [
+            174,
+            246,
+            821,
+            275
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "• Absorbing states in MDPs: In the GAIL framework (and follow-up methods, such as GMMIL (Kim & Park, 2018), OptionGAN (Henderson et al., 2017a), AIRL and the widely used implementation of GAIL from OpenAI Baselines (Dhariwal et al., 2017)), for some benchmarks such as MuJoCo locomotion tasks from OpenAI Gym, a reward function $r ( s , a )$ assigns rewards to intermediate states depending on properties of a task. At the same time, policies executed on these MDPs generate rollouts that ignore absorbing states. Subsequently, the algorithms do not have access to these absorbing states in the buffer, cannot learn proper rewards, and therefore do not perform bootstrapping after terminal states; thus, 0 reward is implicitly assigned for absorbing states. For certain environments, a survival bonus in the form of per-step positive reward is added to the rewards received by the agent. This encourages agents to survive longer in the environment to collect more rewards. We observe that a commonly used form of the reward function: $r ( s , a ) = - \\log ( 1 - D ( s , a ) )$ has worked well for environments that require a survival bonus. Under the implicit assumption of zero rewards for absorbing states in the MDP implementation, this strictly positive estimator cannot recover the true reward function for environments where an agent is required to solve the task as quickly as possible. Using this form of the reward function will lead to sub-optimal solutions. The agent is now incentivized to move in loops or take small actions (in continuous action spaces) that keep it close to the states in the expert’s trajectories. The agent keeps collecting positive rewards without actually attempting to solve the task demonstrated by the expert.2 Another reward formulation is $r ( s , a ) = \\log ( D ( s , a ) )$ . This is often used for tasks with a per step penalty, when a part of a reward function consists of a negative constant assigned unconditionally of states and actions. However, this variant assigns only negative rewards and cannot learn a survival bonus. Such strong priors might lead to good results even with no expert trajectories (as shown in Figure 4). ",
+        "bbox": [
+            215,
+            285,
+            825,
+            642
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "From an end-user’s perspective, it is undesirable to have to craft a different reward function for every new task. In the next section, we propose a method to handle absorbing states of the standard benchmark MDPs in such a way that AIL algorithms are able to recover different reward functions without adjusting the form of reward estimator. ",
+        "bbox": [
+            176,
+            655,
+            825,
+            709
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "4.2 UNBIASING REWARDS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            727,
+            370,
+            741
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "In order to resolve the issues described in Section 4.1, we suggest explicitly learning rewards for absorbing states for expert demonstrations and trajectories produced by a policy. Thus, the returns episode that consists o with a learned reward $T$ nsitions are defiinstead of just $R _ { T } = r ( s _ { T } , a _ { T } ) \\ : +$ $\\scriptstyle \\sum _ { t = T + 1 } ^ { \\infty } \\gamma ^ { t - T } r ( s _ { a } , \\cdot )$ $r ( s _ { a } , \\cdot )$ $R _ { T } = r ( s _ { T } , a _ { T } )$ used due to issues described in Section 4.2. This formulation allows the algorithms to correctly estimate returns for the final transitions and optimize the policy accordingly. ",
+        "bbox": [
+            174,
+            752,
+            823,
+            837
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "In order to enable the AIL algorithms to learn the rewards for absorbing states and RL algorithms to take into account learned rewards, we suggest to update rollouts sampled from MDPs in the following way. After terminating an episode, we explicitly add a transition from the terminal state of the episode to an absorbing state $\\left( { { s _ { T } } , { s _ { a } } } \\right)$ and a transition from an absorbing state to itself $( s _ { a } , s _ { a } )$ . ",
+        "bbox": [
+            174,
+            843,
+            823,
+            900
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Thus, when sample from the replay buffer AIL algorithms will be able to see absorbing states there were previous hidden, while RL algorithms will be able to properly estimate values for terminal states using transitions $\\left( { { s _ { T } } , { s _ { a } } } \\right)$ and $( s _ { a } , s _ { a } )$ using the following recursions: ",
+        "bbox": [
+            174,
+            103,
+            825,
+            147
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "equation",
+        "img_path": "images/02b6d476a742208cad871bd4028410afcbeed4841d84f7bba62a48b036380c7e.jpg",
+        "text": "$$\n\\begin{array} { c } { { Q ( s _ { T } , a ) = r ( s _ { T } , a ) + \\gamma Q ( s _ { a } , \\cdot ) } } \\\\ { { Q ( s _ { a } , \\cdot ) = r ( s _ { a } , \\cdot ) + \\gamma Q ( s _ { a } , \\cdot ) } } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            387,
+            172,
+            609,
+            212
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "We implemented these absorbing states by adding an extra indicator dimension that indicates whether the state is absorbing or not, for absorbing states we set the indicator dimension to one and all other dimensions to zero. The GAIL discriminator can distinguish whether reaching an absorbing state is a desirable behavior from the expert’s perspective and assign the rewards accordingly. ",
+        "bbox": [
+            174,
+            223,
+            825,
+            280
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "4.3 ADDRESSING SAMPLE INEFFICIENCY ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            296,
+            472,
+            311
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "As previously mentioned, GAIL requires a significant number of interactions with a learning environment in order to imitate an expert policy. To address the sample inefficiency of GAIL, we use an off-policy RL algorithm and perform off-policy training of the GAIL discriminator performed in the following way: instead of sampling trajectories from a policy directly, we sample transitions from a replay buffer $\\mathcal { R }$ collected while performing off-policy training: ",
+        "bbox": [
+            174,
+            321,
+            825,
+            393
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "equation",
+        "img_path": "images/217062f9db10c6e8d727ade963b2a0a40382eab25f7425f536bcf8b598d8cb23.jpg",
+        "text": "$$\n\\operatorname* { m a x } _ { D } \\mathbb { E } _ { \\mathcal { R } } [ \\log ( D ( s , a ) ) ] + \\mathbb { E } _ { \\pi _ { E } } [ \\log ( 1 - D ( s , a ) ) ] - \\lambda H ( \\pi ) .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            302,
+            412,
+            699,
+            435
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Equation 2 tries to match the occupancy measures between the expert and the distribution induced by the replay buffer $\\mathcal { R }$ , which can be seen as a mixture of all policy distributions that appeared during training, instead of the latest trained policy $\\pi$ . In order to recover the original on-policy expectation, one needs to use importance sampling: ",
+        "bbox": [
+            174,
+            446,
+            825,
+            503
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "equation",
+        "img_path": "images/02b888260085e5a60c698e2ba58c367e3c1094fca6269a92402482d74fd0e4e1.jpg",
+        "text": "$$\n\\operatorname* { m a x } _ { D } \\mathbb { E } _ { \\mathcal { R } } \\left[ \\frac { p _ { \\pi _ { \\theta } } ( s , a ) } { p _ { \\mathcal { R } } ( s , a ) } \\log ( D ( s , a ) ) \\right] + \\mathbb { E } _ { \\pi _ { E } } [ \\log ( 1 - D ( s , a ) ) ] - \\lambda H ( \\pi ) .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            263,
+            520,
+            736,
+            554
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "However, it can be challenging to properly estimate these densities and the discriminator updates might have large variance. We found that the algorithm works well in practice with the importance weight omitted. ",
+        "bbox": [
+            176,
+            564,
+            825,
+            606
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "We use the GAIL discriminator in order to define rewards for training a policy using TD3; we update per-step rewards every time when we pull transitions from the replay buffer using the latest discriminator. The TD3 algorithm provides a good balance between sample complexity and simplicity of implementation and so is a good candidate for practical applications. Additionally, depending on the distribution of expert demonstrations and properties of the task, off-policy RL algorithms can effectively handle multi-modal action distributions; for example, this can be achieved for the Soft Actor Critic algorithm (Haarnoja et al., 2018b) using the reparametrization trick (Kingma & Ba, 2014) with a normalizing flow (Rezende & Mohamed, 2015) as described in Haarnoja et al. (2018a). ",
+        "bbox": [
+            173,
+            612,
+            825,
+            726
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "5 EXPERIMENTS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            746,
+            326,
+            761
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "We implemented the DAC algorithm described in Section 4.3 using TensorFlow Eager (Abadi et al., 2015) and we evaluated it on popular benchmarks for continuous control simulated in MuJoCo (Todorov et al., 2012). We also define a new set of robotic continuous control tasks (described in detail below) simulated in PyBullet (Coumans & Bai, 2016), and a Virtual Reality (VR) system for capturing human examples in this environment; human examples constitute a particularly challenging demonstration source due to their noisy, multi-modal and potentially sub-optimal nature, and we define multi-task environments as a challenging setup for adversarial imitation learning. ",
+        "bbox": [
+            173,
+            776,
+            825,
+            875
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "For the critic and policy networks we used the same architecture as in Fujimoto et al. (2018): a 2 layer MLP with ReLU activations and 400 and 300 hidden units correspondingly. We also add gradient clipping (Pascanu et al., 2013) to the actor network with clipping value of 40. For the discriminator we used the same architecture as in Ho & Ermon (2016): a 2 layer MLP with 100 hidden units and tanh activations. We trained all networks with the Adam optimizer (Kingma & Ba, 2014) and decay learning rate by starting with initial learning rate of $1 0 ^ { - 3 }$ and decaying it by 0.5 every $1 0 ^ { 5 }$ training steps for the actor network. ",
+        "bbox": [
+            176,
+            882,
+            825,
+            924
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "image",
+        "img_path": "images/63831734656c3d784b2bd775b6fde185329f704567069ef963c5441987fb2419.jpg",
+        "image_caption": [
+            "Figure 3: Comparisons of algorithms using 4 expert demonstrations. y-axis corresponds to normalized reward (0 corresponds to a random policy, while 1 corresponds to an expert policy). "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            194,
+            99,
+            805,
+            297
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            367,
+            825,
+            422
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "In order to make the algorithm more stable, especially in the off-policy regime when the discriminator can easily over-fit to training data, we use regularization in the form of gradient penalties (Gulrajani et al., 2017) for the discriminator. Originally, this was introduced as an alternative to weight clipping for Wasserstein GANs (Arjovsky et al., 2017), but later it was shown that it helps to make JS-based GANs more stable as well (Lucic et al., 2017). ",
+        "bbox": [
+            174,
+            430,
+            823,
+            501
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "We replicate the experimental setup of Ho & Ermon (2016): expert trajectories are sub-sampled by retaining every 20 time steps starting with a random offset (and fixed stride). It is worth mentioning that, as in Ho & Ermon (2016), this procedure is done in order to make the imitation learning task harder. With full trajectories, behavioral cloning provides competitive results to GAIL. ",
+        "bbox": [
+            174,
+            507,
+            823,
+            563
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Following Henderson et al. (2017b) and Fujimoto et al. (2018), we perform evaluation using 10 different random seeds. For each seed, we compute average episode reward using 10 episodes and running the policy without random noise. As in Ho & Ermon (2016) we plot reward normalized in such a way that zero corresponds to a random reward while one corresponds to expert rewards. We compute mean over all seeds and visualize half standard deviations. In order to produce the same evaluation for GAIL we used the original implementation3 of the algorithm. ",
+        "bbox": [
+            174,
+            569,
+            825,
+            654
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "5.1 OFF POLICY DAC ALGORITHM ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            672,
+            431,
+            685
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Evaluation results of the DAC algorithm on a suite of MuJoCo tasks are shown in Figure 3, as are the GAIL (TRPO) and BC basline results. In the top-left plot, we show DAC is an order of magnitude more sample efficent than then TRPO and PPO based GAIL baselines. In the other plots, we show that by using a significantly smaller number of environment steps (orders of magnitude fewer), our DAC algorithm reaches comparable expected reward as the GAIL baseline. Furthermore, DAC outperforms the GAIL baseline on all environments within a 1 million step threshold. We obtained slightly worse results for Walker2d. However, as mentioned earlier, GAIL uses a reward function that already has some biases encoded in it that aids training on this specific environment. A comprehensive suit of results can be found in Appendix B, Figure 7. ",
+        "bbox": [
+            174,
+            698,
+            825,
+            824
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "5.2 REWARD BIAS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            842,
+            315,
+            856
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "As discussed in Section 4.1, the reward function variants used with GAIL can have implicit biases when used without handling absorbing states. Figure 4 demonstrates how bias affects results on an environment with survival bonus when using the reward function of Ho & Ermon (2016): $r ( s , a ) =$ $- \\log ( 1 - D ( s , a ) )$ . Surprisingly, when using a fixed and untrained GAIL discriminator that outputs 0.5 for every state-action pair, we were able to reach episode rewards of around 1000 on the Hopper environment, corresponding to approximately one third of the expert performance. Without any reward learning, and using no expert demonstrations, the agent can learn a policy that outperforms behavioral cloning (Figure 4). Therefore, the choice of a specific reward function might already provide strong prior knowledge that helps the RL algorithm to move towards recovering the expert policy, irrespective of the quality of the learned reward. ",
+        "bbox": [
+            176,
+            869,
+            823,
+            897
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/20efb2c433e451e3882df5a3213393f3045bd0dfe602a94c2aeb08ef956f4fdc.jpg",
+        "image_caption": [],
+        "image_footnote": [],
+        "bbox": [
+            397,
+            99,
+            599,
+            195
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "image",
+        "img_path": "images/f27a4b0f4225210951edf48b03b0d9121fd8d1bf32fe83bfae02f883ce474e37.jpg",
+        "image_caption": [
+            "Figure 4: Even without training, some reward functions can perform well on some tasks. ",
+            "Figure 5: Effect of absorbing state handling on Kuka environments. For these environments, we use human demonstrations as expert trajectories, and GAIL framework with a positive reward function. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            295,
+            238,
+            699,
+            334
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            404,
+            825,
+            515
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Additionally, we evaluated our method on two environments with per-step penalty (see Figure 5). These environment are simulated in PyBullet and consist of a Kuka IIWA arm and 3 blocks on a virtual table. A rendering of the environment can be found in Appendix C, Figure 8. Using a Cartesian displacement action for the gripper end-effector and a compact observation-space (consisting of each block’s 6DOF pose and the Kuka’s end-effector pose), the agent must either a) reach one of the 3 blocks in the shortest number of frames possible (the target block is provided to the policy as a one-hot vector), which we call Kuka-Reach, or b) push one block along the table so that it is adjacent to another block, which we call Kuka-PushNext. For evaluation, we define a sparse reward indicating successful task completion (within some threshold). For these imitation learning experiments, we use human demonstrations collected with a VR setup, where the participant wears a VR headset and controls in real-time the gripper end-effector using a 6DOF controller. ",
+        "bbox": [
+            173,
+            522,
+            825,
+            675
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Using the reward defined as $r ( s , a ) = - l o g ( 1 - D ( s , a ) )$ and without absorbing state handling, the agent completely fails to recover the expert policy given 600 expert trajectories without subsampling (as shown in Figure 4). In contrast, our DAC algorithm quickly learns to imitate the expert, despite using noisy and potentially sub-optimal human demonstrations. ",
+        "bbox": [
+            174,
+            681,
+            823,
+            738
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "As discussed, alternative reward functions do not have this positive bias but still require proper handling of the absorbing states as well in order to avoid early termination due to incorrectly assigned per-frame penalty. Figure 6 illustrates results for AIRL with and without learning rewards for absorbing states. For these experiments we use the discriminator structure from $\\mathrm { F u }$ et al. (2017) in combination with the TD3 algorithm. ",
+        "bbox": [
+            174,
+            744,
+            825,
+            814
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "6 CONCLUSION ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            835,
+            318,
+            852
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "In this work we address several important issues associated with the popular GAIL framework. In particular, we address 1) sample inefficiency with respect to policy transitions in the environment and 2) we demonstrate a number of reward biases that can either implicitly impose prior knowledge about the true reward, or alternatively, prevent the policy from imitating the optimal expert. To address reward bias, we propose a simple mechanism whereby the rewards for absorbing states are also learned, which negates the need to hand-craft a discriminator reward function for the properties of the task at hand. In order to improve sample efficiency, we perform off-policy training of the discriminator and use an off-policy RL algorithm. We show that our algorithm reaches state-of-theart performance for an imitation learning algorithm on several standard RL benchmarks, and is able to recover the expert policy given a significantly smaller number of samples than in recent GAIL work. ",
+        "bbox": [
+            174,
+            867,
+            825,
+            924
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "image",
+        "img_path": "images/6fee1a4b0187eb33856999252f719d3b3a7323edb7c8a270e64e4cead5914dd8.jpg",
+        "image_caption": [
+            "Figure 6: Effect of learning absorbing state rewards when using an AIRL discriminator within the DAC Framework in OpenAI Gym environments. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            295,
+            98,
+            705,
+            199
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            266,
+            825,
+            363
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "ACKNOWLEDGMENTS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            378,
+            326,
+            392
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "We would like to thank Justin Fu and the ICLR Reproducibility Workshop team for insightful discussions and feedback. ",
+        "bbox": [
+            176,
+            402,
+            821,
+            430
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "REFERENCES ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            452,
+            285,
+            467
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Mart´ın Abadi, Ashish Agarwal, Paul Barham, Eugene Brevdo, Zhifeng Chen, Craig Citro, Greg S. Corrado, Andy Davis, Jeffrey Dean, Matthieu Devin, Sanjay Ghemawat, Ian Goodfellow, Andrew Harp, Geoffrey Irving, Michael Isard, Yangqing Jia, Rafal Jozefowicz, Lukasz Kaiser, Manjunath Kudlur, Josh Levenberg, Dandelion Mane, Rajat Monga, Sherry Moore, Derek Murray, Chris ´ Olah, Mike Schuster, Jonathon Shlens, Benoit Steiner, Ilya Sutskever, Kunal Talwar, Paul Tucker, Vincent Vanhoucke, Vijay Vasudevan, Fernanda Viegas, Oriol Vinyals, Pete Warden, Martin Wat- ´ tenberg, Martin Wicke, Yuan Yu, and Xiaoqiang Zheng. TensorFlow: Large-scale machine learning on heterogeneous systems, 2015. URL https://www.tensorflow.org/. Software available from tensorflow.org. ",
+        "bbox": [
+            176,
+            474,
+            825,
+            599
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Pieter Abbeel and Andrew Y Ng. Apprenticeship learning via inverse reinforcement learning. In Proceedings of the twenty-first international conference on Machine learning, pp. 1. ACM, 2004. ",
+        "bbox": [
+            174,
+            608,
+            823,
+            637
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Martin Arjovsky, Soumith Chintala, and Leon Bottou. Wasserstein gan. ´ arXiv preprint arXiv:1701.07875, 2017. ",
+        "bbox": [
+            173,
+            645,
+            823,
+            674
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Michael Bain and Claude Sommut. A framework for behavioural cloning. Machine intelligence, 15 (15):103, 1999. ",
+        "bbox": [
+            174,
+            683,
+            821,
+            710
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Nir Baram, Oron Anschel, Itai Caspi, and Shie Mannor. End-to-end differentiable adversarial imitation learning. In International Conference on Machine Learning, pp. 390–399, 2017. ",
+        "bbox": [
+            174,
+            719,
+            820,
+            748
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Lionel Blonde and Alexandros Kalousis. Sample-efficient imitation learning via generative adver- ´ sarial nets. arXiv preprint arXiv:1809.02064, 2018. ",
+        "bbox": [
+            171,
+            756,
+            823,
+            785
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "E Coumans and Y Bai. Pybullet, a python module for physics simulation for games, robotics and machine learning. GitHub repository, 2016. ",
+        "bbox": [
+            173,
+            792,
+            823,
+            823
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Prafulla Dhariwal, Christopher Hesse, Oleg Klimov, Alex Nichol, Matthias Plappert, Alec Radford, John Schulman, Szymon Sidor, Yuhuai Wu, and Peter Zhokhov. Openai baselines. https: //github.com/openai/baselines, 2017. ",
+        "bbox": [
+            176,
+            830,
+            821,
+            872
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Chelsea Finn, Paul Christiano, Pieter Abbeel, and Sergey Levine. A connection between generative adversarial networks, inverse reinforcement learning, and energy-based models. NIPS Workshop on Adversarial Training, 2016a. ",
+        "bbox": [
+            174,
+            882,
+            823,
+            922
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Chelsea Finn, Sergey Levine, and Pieter Abbeel. Guided cost learning: Deep inverse optimal control via policy optimization. In International Conference on Machine Learning, pp. 49–58, 2016b. ",
+        "bbox": [
+            171,
+            103,
+            823,
+            133
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Justin Fu, Katie Luo, and Sergey Levine. Learning robust rewards with adversarial inverse reinforcement learning. arXiv preprint arXiv:1710.11248, 2017. ",
+        "bbox": [
+            171,
+            142,
+            821,
+            171
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Scott Fujimoto, Herke van Hoof, and Dave Meger. Addressing function approximation error in actor-critic methods. arXiv preprint arXiv:1802.09477, 2018. ",
+        "bbox": [
+            171,
+            180,
+            823,
+            209
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Ian Goodfellow, Jean Pouget-Abadie, Mehdi Mirza, Bing Xu, David Warde-Farley, Sherjil Ozair, Aaron Courville, and Yoshua Bengio. Generative adversarial nets. In Advances in neural information processing systems, pp. 2672–2680, 2014. ",
+        "bbox": [
+            173,
+            218,
+            823,
+            262
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Ishaan Gulrajani, Faruk Ahmed, Martin Arjovsky, Vincent Dumoulin, and Aaron C Courville. Improved training of wasserstein gans. In Advances in Neural Information Processing Systems, pp. 5767–5777, 2017. ",
+        "bbox": [
+            173,
+            271,
+            826,
+            314
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Tuomas Haarnoja, Kristian Hartikainen, Pieter Abbeel, and Sergey Levine. Latent space policies for hierarchical reinforcement learning. arXiv preprint arXiv:1804.02808, 2018a. ",
+        "bbox": [
+            173,
+            324,
+            821,
+            353
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Tuomas Haarnoja, Aurick Zhou, Pieter Abbeel, and Sergey Levine. Soft actor-critic: Offpolicy maximum entropy deep reinforcement learning with a stochastic actor. arXiv preprint arXiv:1801.01290, 2018b. ",
+        "bbox": [
+            173,
+            362,
+            823,
+            405
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Peter Henderson, Wei-Di Chang, Pierre-Luc Bacon, David Meger, Joelle Pineau, and Doina Precup. Optiongan: Learning joint reward-policy options using generative adversarial inverse reinforcement learning. arXiv preprint arXiv:1709.06683, 2017a. ",
+        "bbox": [
+            178,
+            415,
+            823,
+            458
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Peter Henderson, Riashat Islam, Philip Bachman, Joelle Pineau, Doina Precup, and David Meger. Deep reinforcement learning that matters. arXiv preprint arXiv:1709.06560, 2017b. ",
+        "bbox": [
+            171,
+            467,
+            823,
+            497
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Todd Hester, Matej Vecerik, Olivier Pietquin, Marc Lanctot, Tom Schaul, Bilal Piot, Dan Horgan, John Quan, Andrew Sendonaris, Gabriel Dulac-Arnold, et al. Deep q-learning from demonstrations. arXiv preprint arXiv:1704.03732, 2017. ",
+        "bbox": [
+            176,
+            506,
+            823,
+            549
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Jonathan Ho and Stefano Ermon. Generative adversarial imitation learning. In Advances in Neural Information Processing Systems, pp. 4565–4573, 2016. ",
+        "bbox": [
+            173,
+            559,
+            823,
+            588
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Bingyi Kang, Zequn Jie, and Jiashi Feng. Policy optimization with demonstrations. In Proceedings of the 35th International Conference on Machine Learning, volume 80 of Proceedings of Machine Learning Research, pp. 2469–2478. PMLR, 2018. ",
+        "bbox": [
+            173,
+            597,
+            825,
+            640
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Kee-Eung Kim and Hyun Soo Park. Imitation learning via kernel mean embedding. AAAI, 2018. ",
+        "bbox": [
+            169,
+            648,
+            807,
+            665
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Diederik P Kingma and Jimmy Ba. Adam: A method for stochastic optimization. arXiv preprint arXiv:1412.6980, 2014. ",
+        "bbox": [
+            173,
+            674,
+            820,
+            703
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Hoang M Le, Nan Jiang, Alekh Agarwal, Miroslav Dud´ık, Yisong Yue, and Hal Daume III. Hierar- ´ chical imitation and reinforcement learning. arXiv preprint arXiv:1803.00590, 2018. ",
+        "bbox": [
+            171,
+            712,
+            823,
+            742
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Timothy P Lillicrap, Jonathan J Hunt, Alexander Pritzel, Nicolas Heess, Tom Erez, Yuval Tassa, David Silver, and Daan Wierstra. Continuous control with deep reinforcement learning. arXiv preprint arXiv:1509.02971, 2015. ",
+        "bbox": [
+            174,
+            751,
+            823,
+            795
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Mario Lucic, Karol Kurach, Marcin Michalski, Sylvain Gelly, and Olivier Bousquet. Are gans created equal? a large-scale study. arXiv preprint arXiv:1711.10337, 2017. ",
+        "bbox": [
+            169,
+            804,
+            823,
+            833
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Ashvin Nair, Bob McGrew, Marcin Andrychowicz, Wojciech Zaremba, and Pieter Abbeel. Overcoming exploration in reinforcement learning with demonstrations. arXiv preprint arXiv:1709.10089, 2017. ",
+        "bbox": [
+            173,
+            843,
+            823,
+            885
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Andrew Y. $\\mathrm { N g }$ and Stuart Russell. Algorithms for inverse reinforcement learning. In in Proc. 17th International Conf. on Machine Learning, pp. 663–670. Morgan Kaufmann, 2000. ",
+        "bbox": [
+            171,
+            895,
+            821,
+            924
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Andrew $\\mathrm { ~ Y ~ N ~ g ~ }$ , Daishi Harada, and Stuart Russell. Policy invariance under reward transformations: Theory and application to reward shaping. In ICML, volume 99, pp. 278–287, 1999. ",
+        "bbox": [
+            173,
+            103,
+            823,
+            133
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Fabio Pardo, Arash Tavakoli, Vitaly Levdik, and Petar Kormushev. Time limits in reinforcement learning. arXiv preprint arXiv:1712.00378, 2017. ",
+        "bbox": [
+            173,
+            142,
+            823,
+            171
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Razvan Pascanu, Tomas Mikolov, and Yoshua Bengio. On the difficulty of training recurrent neural networks. In International Conference on Machine Learning, pp. 1310–1318, 2013. ",
+        "bbox": [
+            174,
+            181,
+            823,
+            212
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Jan Peters and Stefan Schaal. Reinforcement learning of motor skills with policy gradients. Neural networks, 21(4):682–697, 2008. ",
+        "bbox": [
+            173,
+            220,
+            823,
+            251
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Nathan D Ratliff, J Andrew Bagnell, and Martin A Zinkevich. Maximum margin planning. In Proceedings of the 23rd international conference on Machine learning, pp. 729–736. ACM, 2006. ",
+        "bbox": [
+            173,
+            260,
+            825,
+            290
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Siddharth Reddy, Anca D. Dragan, and Sergey Levine. What would pi\\* do?: Imitation learning via off-policy reinforcement learning, 2019. URL https://openreview.net/forum?id $\\underline { { \\underline { { \\mathbf { \\Pi } } } } } =$ B1excoAqKQ. ",
+        "bbox": [
+            173,
+            299,
+            823,
+            343
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Danilo Jimenez Rezende and Shakir Mohamed. Variational inference with normalizing flows. arXiv preprint arXiv:1505.05770, 2015. ",
+        "bbox": [
+            171,
+            352,
+            825,
+            382
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Stephane Ross, Geoffrey Gordon, and Drew Bagnell. A reduction of imitation learning and struc- ´ tured prediction to no-regret online learning. In Proceedings of the fourteenth international conference on artificial intelligence and statistics, pp. 627–635, 2011. ",
+        "bbox": [
+            174,
+            391,
+            821,
+            435
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Fumihiro Sasaki, Tetsuya Yohira, and Atsuo Kawaguchi. Sample efficient imitation learning for continuous control. In International Conference on Learning Representations, 2019. URL https://openreview.net/forum?id $\\underline { { \\underline { { \\mathbf { \\Pi } } } } } =$ BkN5UoAqF7. ",
+        "bbox": [
+            176,
+            444,
+            821,
+            488
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "John Schulman, Sergey Levine, Pieter Abbeel, Michael Jordan, and Philipp Moritz. Trust region policy optimization. In International Conference on Machine Learning, pp. 1889–1897, 2015. ",
+        "bbox": [
+            173,
+            497,
+            821,
+            527
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "John Schulman, Filip Wolski, Prafulla Dhariwal, Alec Radford, and Oleg Klimov. Proximal policy optimization algorithms. arXiv preprint arXiv:1707.06347, 2017. ",
+        "bbox": [
+            173,
+            536,
+            823,
+            566
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Richard S Sutton, Andrew G Barto, et al. Reinforcement learning: An introduction. MIT press, 1998. ",
+        "bbox": [
+            169,
+            575,
+            825,
+            606
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Umar Syed, Michael Bowling, and Robert E Schapire. Apprenticeship learning using linear programming. In Proceedings of the 25th international conference on Machine learning, pp. 1032– 1039. ACM, 2008. ",
+        "bbox": [
+            173,
+            616,
+            823,
+            659
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Emanuel Todorov, Tom Erez, and Yuval Tassa. Mujoco: A physics engine for model-based control. In Intelligent Robots and Systems (IROS), 2012 IEEE/RSJ International Conference on, pp. 5026– 5033. IEEE, 2012. ",
+        "bbox": [
+            173,
+            667,
+            821,
+            712
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Faraz Torabi, Garrett Warnell, and Peter Stone. Generative adversarial imitation from observation. arXiv preprint arXiv:1807.06158, 2018. ",
+        "bbox": [
+            171,
+            722,
+            823,
+            751
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Matej Vecer´ık, Todd Hester, Jonathan Scholz, Fumin Wang, Olivier Pietquin, Bilal Piot, Nicolas Heess, Thomas Rothorl, Thomas Lampe, and Martin A Riedmiller. Leveraging demonstrations for ¨ deep reinforcement learning on robotics problems with sparse rewards. CoRR, abs/1707.08817, 2017. ",
+        "bbox": [
+            174,
+            814,
+            825,
+            869
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Ziyu Wang, Josh S Merel, Scott E Reed, Nando de Freitas, Gregory Wayne, and Nicolas Heess. Robust imitation of diverse behaviors. In Advances in Neural Information Processing Systems, pp. 5320–5329, 2017. ",
+        "bbox": [
+            174,
+            881,
+            825,
+            924
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Yuke Zhu, Ziyu Wang, Josh Merel, Andrei Rusu, Tom Erez, Serkan Cabi, Saran Tunyasuvunakool, Janos Kram ´ ar, Raia Hadsell, Nando de Freitas, et al. Reinforcement and imitation learning for ´ diverse visuomotor skills. arXiv preprint arXiv:1802.09564, 2018. ",
+        "bbox": [
+            176,
+            103,
+            825,
+            146
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Brian D Ziebart, Andrew L Maas, J Andrew Bagnell, and Anind K Dey. Maximum entropy inverse reinforcement learning. In AAAI, volume 8, pp. 1433–1438. Chicago, IL, USA, 2008. ",
+        "bbox": [
+            173,
+            155,
+            823,
+            184
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "A DAC ALGORITHM ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            102,
+            364,
+            118
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Algorithm 1 Discriminative-Actor-Critic Adversarial Imitation Learning Algorithm ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            148,
+            722,
+            164
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "table",
+        "img_path": "images/03db262ede4f4603e06539803dba80d6b35f1f7a27e20878b8a0b223460578f9.jpg",
+        "table_caption": [],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>nput:expert replay buffer RE procedure WRAPFORABSORBINGSTATES(T)</td></tr><tr><td>if sT is a terminal state not caused by time limits then T ←T\\{(st,aT,:,st)}U{(st,aT,:,Sa)} T←TU{(sa,,:,sa)}</td></tr><tr><td>end if return T</td></tr><tr><td>end procedure</td></tr><tr><td></td></tr><tr><td>Initialize replaybufferR←@ for T={(St,at,,st)}T=1 ∈REdo</td></tr><tr><td>T ←WrapForAbsorbingState(T) Wrap expert rollouts with absorbing states end for</td></tr><tr><td></td></tr><tr><td>for n = 1,...,do</td></tr><tr><td>Sample T = {(st,at,:,st)}T=1 with π0 R ←RU WrapForAbsorbingState(τ) Update Policy Replay Buffer</td></tr></table>",
+        "bbox": [
+            181,
+            164,
+            826,
+            595
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "image",
+        "img_path": "images/b3571dd47a884af45bdecca1273f0671b42c431d444710ab08254166537fed2f.jpg",
+        "image_caption": [
+            "B SUPPLEMENTARY RESULTS ON MUJOCO ENVIRONMENTS ",
+            "Figure 7: Comparisons of different algorithms given the same number of expert demonstrations. y-axis corresponds to normalized reward (0 corresponds to a random policy, while 1 corresponds to an expert policy). "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            192,
+            136,
+            807,
+            625
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "C KUKA-IIWA SIMULATED ENVIRONMENT ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            102,
+            553,
+            118
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "image",
+        "img_path": "images/19b746b7ce5e603b62f5f309187dd95f7891096815c19481338661b775f8874f.jpg",
+        "image_caption": [
+            "Figure 8: Renderings of our Kuka-IIWA environment. Using a VR headset and 6DOF controller, a human participant can control the 6DOF end-effector pose in order to record expert demonstrations. In the Kuka-Reach tasks, the agent must bring the robot gripper to 1 of the 3 blocks (where the state contains a 1-hot encoding of the task) and for the Kuka-PushNext tasks, the agent must use the robot gripper to push one block next to another. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            232,
+            138,
+            764,
+            340
+        ],
+        "page_idx": 14
+    }
+]

parse/train/RSU17UoKfJF/RSU17UoKfJF.md

@@ -0,0 +1,376 @@
+# R-GAP: RECURSIVE GRADIENT ATTACK ON PRIVACY
+
+Junyi Zhu and Matthew Blaschko
+
+Dept. ESAT, Center for Processing Speech and Images KU Leuven, Belgium {junyi.zhu,matthew.blaschko}@esat.kuleuven.be
+
+# ABSTRACT
+
+Federated learning frameworks have been regarded as a promising approach to break the dilemma between demands on privacy and the promise of learning from large collections of distributed data. Many such frameworks only ask collaborators to share their local update of a common model, i.e. gradients, instead of exposing their raw data to other collaborators. However, recent optimization-based gradient attacks show that raw data can often be accurately recovered from gradients. It has been shown that minimizing the Euclidean distance between true gradients and those calculated from estimated data is often effective in fully recovering private data. However, there is a fundamental lack of theoretical understanding of how and when gradients can lead to unique recovery of original data. Our research fills this gap by providing a closed-form recursive procedure to recover data from gradients in deep neural networks. We name it Recursive Gradient Attack on Privacy (R-GAP). Experimental results demonstrate that R-GAP works as well as or even better than optimization-based approaches at a fraction of the computation under certain conditions. Additionally, we propose a Rank Analysis method, which can be used to estimate the risk of gradient attacks inherent in certain network architectures, regardless of whether an optimization-based or closed-form-recursive attack is used. Experimental results demonstrate the utility of the rank analysis towards improving the network’s security. Source code is available for download from https://github.com/JunyiZhu-AI/R-GAP.
+
+# 1 INTRODUCTION
+
+Distributed and federated learning have become common strategies for training neural networks without transferring data (Jochems et al., 2016; 2017; Konecnˇ y et al., 2016; McMahan et al., 2017). ´ Instead, model updates, often in the form of gradients, are exchanged between participating nodes. These are then used to update at each node a copy of the model. This has been widely applied for privacy purposes (Rigaki & Garcia, 2020; Cristofaro, 2020), including with medical data (Jochems et al., 2016; 2017). Recently, it has been demonstrated that this family of approaches is susceptible to attacks that can in some circumstances recover the training data from the gradient information exchanged in such federated learning approaches, calling into question their suitability for privacy preserving distributed machine learning (Phong et al., 2018; Wang et al., 2019; Zhu et al., 2019; Zhao et al., 2020; Geiping et al., 2020; Wei et al., 2020). To date these attack strategies have broadly fallen into two groups: (i) an analytical attack based on the use of gradients with respect to a bias term (Phong et al., 2018), and (ii) an optimization-based attack (Zhu et al., 2019) that can in some circumstances recover individual training samples in a batch, but that involves a difficult nonconvex optimization that doesn’t always converge to a correct solution (Geiping et al., 2020), and that provides comparatively little insights into the information that is being exploited in the attack.
+
+The development of privacy attacks is most important because they inform strategies for protecting against them. This is achieved by perturbations to the transferred gradients, and the form of the attack can give insights into the type of perturbation that can effectively protect the data (Fan et al., 2020). As such, the development of novel closed-form attacks is essential to the analysis of privacy in federated learning. More broadly, the existence of model inversion attacks (He et al., 2019; Wang et al., 2019; Yang et al., 2019; Zhang et al., 2020) calls into question whether transferring a fully trained model can be considered privacy preserving. As the weights of a model trained by (stochastic) gradient descent are the summation of individual gradients, understanding gradient attacks can assist in the analysis of and protection against model inversion attacks in and outside of a federated learning setting.
+
+In this work, we develop a novel third family of attacks, recursive gradient attack on privacy (RGAP), that is based on a recursive, depth-wise algorithm for recovering training data from gradient information. Different from the analytical attack using the bias term, R-GAP utilizes much more information and is the first closed-form algorithm that works on both convolutional networks and fully connected networks with or without bias term. Compared to optimization-based attacks, it is not susceptible to local optima, and is orders of magnitude faster to run with a deterministic running time. Furthermore, we show that under certain conditions our recursive attack can fully recover training data in cases where optimization attacks fail. Additionally, the insights gained from the closed form of our recursive attack have lead to a refined rank analysis that predicts which network architectures enable full recovery, and which lead to provable noisy recovery due to rankdeficiency. This explains well the performance of both closed-form and optimization-based attacks. We also demonstrate that using rank analysis we are able to make small modifications to network architectures to increase the network’s security without sacrificing its accuracy.
+
+# 1.1 RELATED WORK
+
+Bias attacks: The original discovery of the existence of an analytical attack based on gradients with respect to the bias term is due to Phong et al. (2018). Fan et al. (2020) also analyzed the bias attack as a system of linear equations, and proposed a method of perturbing the gradients to protect against it. Their work considers convolutional and fully-connected networks as equivalent, but this ignores the aggregation of gradients in convolutional networks. Similar to our work, they also perform a rank analysis, but it considers fewer constraints than is included in our analysis (Section 4).
+
+Optimization attacks: The first attack that utilized an optimization approach to minimize the distance between gradients appears to be due to Wang et al. (2019). In this work, optimization is adopted as a submodule in their GAN-style framework. Subsequently, Zhu et al. (2019) proposed a method called deep leakage from gradients (DLG) which relies entirely on minimization of the difference of gradients (Section 2). They propose the use of L-BFGS (Liu & Nocedal, 1989) to perform the optimization. Zhao et al. (2020) further analyzed label inference in this setting, proposing an analytic way to reconstruct the one-hot label of multi-class classification in terms of a single input. Wei et al. (2020) show that DLG is sensitive to initialization and proposed that the same class image is an optimal initialization. They proposed to use SSIM as image similarity metric, which can then be used to guide optimization by DLG. Geiping et al. (2020) point out that as DLG requires second-order derivatives, L-BFGS actually requires third-order derivatives, which leads to challenging optimzation for networks with activation functions such as ReLU and LeakyReLU. They therefore propose to replace L-BFGS with Adam (Kingma & Ba, 2015). Similar to the work of Wei et al. (2020), Geiping et al. (2020) propose to incorporate an image prior, in this case total variation, while using PSNR as a quality measurement.
+
+# 2 OPTIMIZATION-BASED GRADIENT ATTACKS ON PRIVACY (O-GAP)
+
+Optimization-based gradient attacks on privacy (O-GAP) take the real gradients as its ground-truth label and utilizes optimization to decrease the distance between the real gradients $\nabla { \mathbf W }$ and the dummy gradients $\nabla { \mathbf W } ^ { \prime }$ generated by a pair of randomly initialized dummy data and dummy label. The objective function of O-GAP can be generally expressed as:
+
+$$
+\arg \operatorname* { m i n } _ { x ^ { \prime } , y ^ { \prime } } \| \nabla \mathbf { W } - \nabla \mathbf { W } ^ { \prime } \| ^ { 2 } = \arg \operatorname* { m i n } _ { x ^ { \prime } , y ^ { \prime } } \sum _ { i = 1 } ^ { d } \| \nabla \mathbf { W } _ { i } - \nabla \mathbf { W } _ { i } ^ { \prime } \| ^ { 2 } ,
+$$
+
+where the summation is taken over the layers of a network of depth $d$ , and $( x ^ { \prime } , y ^ { \prime } )$ is the dummy training data and label used to generate $\nabla W ^ { \prime }$ . The idea of O-GAP was proposed by Wang et al. (2019). However, they have adopted it as a part of their GAN-style framework and did not realize that O-GAP is able to preform a more accurate attack by itself. Later in the work of Zhu et al. (2019), O-GAP has been proposed as a stand alone approach, the framework has been named as Deep Leakage from Gradients (DLG).
+
+The approach is intuitively simple, and in practice has been shown to give surprisingly good results (Zhu et al., 2019). However, it is sensitive to initialization and prone to fail (Zhao et al., 2020). The choice of optimizer is therefore important, and convergence can be very slow (Geiping et al., 2020). Perhaps most importantly, Equation 1 gives little insight into what information in the gradients is being exploited to recover the data. Analysis in Zhu et al. (2019) is limited to empirical insights, and fundamental open questions remain: What are sufficient conditions for arg $\begin{array} { r l } { { \bf \operatorname* { m i n } } _ { x ^ { \prime } , y ^ { \prime } } \sum _ { i = 1 } ^ { d ^ { - } } \| \nabla { \bf W } _ { i } - \nabla { \bf W } _ { i } ^ { \prime } \| ^ { 2 } } & { { } } \end{array}$ to have a unique minimizer? We address this question in Section 4, and subsequently validate our findings empirically.
+
+# 3 CLOSED-FORM GRADIENT ATTACKS ON PRIVACY
+
+The first attempt of closed-form GAP was proposed in a research of privacy-preserving deep learning by Phong et al. (2018).
+
+Theorem 1 (Phong et al. (2018)). Assume a layer of a fully connected network with a bias term, expressed as:
+
+$$
+W x + b = z ,
+$$
+
+where $W , b$ denote the weight matrix and bias vector, and $x , z$ denote the input vector and output vector of this layer. If the loss function $\ell$ of the network can be expressed as:
+
+$$
+\ell = \ell ( f ( \pmb { x } ) , y )
+$$
+
+where $f$ indicates a nested function of $\boldsymbol { x }$ including activation function and all subsequent layers, $y$ is the ground-truth label. Then $x$ can be derived from gradients w.r.t. $W$ and gradients w.r.t. $\pmb { b }$ , i.e.:
+
+$$
+\begin{array} { l } { \displaystyle { \frac { \partial \ell } { \partial W } = \frac { \partial \ell } { \partial z } \pmb { x } ^ { \top } , \quad \frac { \partial \ell } { \partial \pmb { b } } = \frac { \partial \ell } { \partial z } } } \\ { \displaystyle { \boldsymbol { x } ^ { \top } = \frac { \partial \ell } { \partial W _ { j } } / \frac { \partial \ell } { \partial b _ { j } } } } \end{array}
+$$
+
+where $j$ denotes the $j$ -th row, note that in fact from each row we can compute a copy of $\mathbf { \dot { x } } ^ { \top }$ .
+
+When this layer is the first layer of a network, it is possible to reconstruct the data, i.e. $\mathbf { X }$ , using this approach. In the case of noisy gradients, we can make use of the redundancy in estimating $\mathbf { X }$ by averaging over noisy estimates: $\begin{array} { r } { \bar { \mathbf { x } } ^ { \top } = \sum _ { j } \frac { \partial \ell } { \partial \mathbf { W } _ { j } } / \frac { \partial \ell } { \partial \mathbf { b } _ { j } } } \end{array}$ \`W / ∂\`∂b . However, simply removing the bias term can disable this attack. Besides, this approach does not work on convolutional neural networks due to a dimension mismatch in Equation 3. Both of these two problems have been resolved in our approach.
+
+# 3.1 RECURSIVE GRADIENT ATTACK ON PRIVACY (R-GAP)
+
+For simplicity we derive the R-GAP in terms of binary classification with a single image as input. In this setting we can generally describe the network and loss function as:
+
+$$
+\begin{array} { r l } & { \mu = y \mathbf { w } _ { d } \sigma _ { d - 1 } \left( \mathbf { W } _ { d - 1 } \underbrace { \sigma _ { d - 1 } ( \mathbf { x } ) } _ { = : f _ { d - 2 } ( \mathbf { x } ) } \right) } \\ & { \ell = \log ( 1 + e ^ { - \mu } ) } \end{array}
+$$
+
+where $y \in \{ - 1 , 1 \}$ , $d$ denotes the $d$ -th layer, $\phi$ represents all layers previous to $d - 2$ , and $\sigma$ denotes the activation function. Note that, although our notation omits the bias term in our approach, with an augmented matrix and augmented vector it is able to represent both of the linear map and the translation, e.g. Equation 2, using matrix multiplication as shown in Equation 4. So our formulation also includes the approach proposed by Phong et al. (2018). Moreover, if the $i$ -th layer is a convolutional layer, then $\mathbf { W } _ { i }$ is an extended circulant matrix representing the convolutional kernel (Golub & Van Loan, 1996), and data $\mathbf { X }$ as well as input of each layer are represented by a flattened vector in Equation 4.
+
+![](images/fed99db4e928a8180276c6754c68aeedbb818b5e3b7f27e504ce25596dd8bd9e.jpg)  
+\`: Logistic loss
+
+![](images/0f0d36f93676cb1c0d0c785f4bf1bda998a50c3954c1b623c1c4cc58bad256a3.jpg)  
+\`: Exponential loss
+
+![](images/a6fcea03c613b3e25dd35857db2aa92f683ba111632438c7c372bd900d5cba23.jpg)  
+\`: Hinge loss
+
+Figure 1: In consideration of logistic loss, exponential loss and hinge loss, $\textstyle { \frac { \partial \ell } { \partial \mu } } \mu$ is not monotonic w.r.t. $\mu$ . It is equal to 0 at $\mu = 0$ , after that it either approximates $0 ^ { - }$ , or equals to 0 after decreasing to $\mu = 1$ .
+
+# 3.1.1 RECOVERING DATA FROM GRADIENTS
+
+From Equation 4 and Equation 5 we can derive following gradients:
+
+$$
+\begin{array} { r l } & { \quad \quad \displaystyle \frac { \partial \ell } { \partial \mathbf { w } _ { d } } = y \frac { \partial \ell } { \partial \mu } f _ { d - 1 } ^ { \top } } \\ & { \quad \quad \displaystyle \frac { \partial \ell } { \partial \mathbf { W } _ { d - 1 } } = \left( \left( \mathbf { w } _ { d } ^ { \top } \left( y \frac { \partial \ell } { \partial \mu } \right) \right) \odot \sigma _ { d - 1 } ^ { \prime } \right) f _ { d - 2 } ^ { \top } } \\ & { \quad \quad \displaystyle \frac { \partial \ell } { \partial \mathbf { W } _ { d - 2 } } = \left( \left( \mathbf { W } _ { d - 1 } ^ { \top } \left( \left( \mathbf { w } _ { d } ^ { \top } \left( y \frac { \partial \ell } { \partial \mu } \right) \right) \odot \sigma _ { d - 1 } ^ { \prime } \right) \right) \odot \sigma _ { d - 2 } ^ { \prime } \right) \phi ^ { \top } } \end{array}
+$$
+
+where $\sigma ^ { \prime }$ denotes the derivative of $\sigma$ , for more details of deriving the gradients refer to Appendix $_ \mathrm { H }$ The first observation of these gradients is that:
+
+$$
+\frac { \partial \ell } { \partial \mathbf { w } _ { d } } \cdot \mathbf { w } _ { d } = \frac { \partial \ell } { \partial \mu } \mu
+$$
+
+Additionally, if $\sigma _ { 1 } , \ldots , \sigma _ { d - 1 }$ are ReLU or LeakyRelu, the dot product of the gradients and weights of each layer will be the same, i.e.:
+
+$$
+\frac { \partial \ell } { \partial \mathbf { w } _ { d } } \cdot \mathbf { w } _ { d } = \frac { \partial \ell } { \partial \mathbf { W } _ { d - 1 } } \cdot \mathbf { W } _ { d - 1 } = \ldots = \frac { \partial \ell } { \partial \mathbf { W } _ { 1 } } \cdot \mathbf { W } _ { 1 } = \frac { \partial \ell } { \partial \mu } \mu
+$$
+
+Since gradients and weights of each layer are known, we can obtain $\textstyle { \frac { \partial \ell } { \partial \mu } } \mu$ . If loss function $\ell$ is logistic loss (Equation 5), we obtain:
+
+$$
+\frac { \partial \ell } { \partial \mu } \mu = \frac { - \mu } { 1 + e ^ { \mu } } .
+$$
+
+In order to perform R-GAP, we need to derive $\mu$ from $\textstyle { \frac { \partial \ell } { \partial \mu } } \mu$ . As we can see, $\textstyle { \frac { \partial \ell } { \partial \mu } } \mu$ is non-monotonic, which means knowing $\textstyle { \frac { \partial \ell } { \partial \mu } } \mu$ does not always allow us to uniquely recover $\mu$ . However, even in the case that we cannot uniquely recover $\mu$ , there are only two possible values to consider. Figure 1 illustrates $\textstyle { \frac { \partial \ell } { \partial \mu } } \mu$ of logistic, exponential, and hinge losses, showing when we can uniquely recover $\mu$ from $\textstyle { \frac { \partial \ell } { \partial \mu } } \mu$ . The non-uniqueness of $\mu$ inspires us to find a sort of data that can trigger exactly the same gradients as the real data, which we name twin data, denoted by $\tilde { \mathbf { x } }$ . The existence of twin data demonstrates that the objective function of DLG could have more than one global minimum, which explains at least in part why DLG is sensitive to initialization, for more information and experiments about the twin data refer to Appendix B.
+
+The second observation on Equations 6-8 is that the gradients of each layer have a repeated format:
+
+$$
+\begin{array} { r l r } {  { \frac { \partial \ell } { \partial \mathbf { w } _ { d } } = \mathbf { k } _ { d } f _ { d - 1 } ^ { \top } ; \mathbf { k } _ { d } : = y \frac { \partial \ell } { \partial \mu } } } \\ & { } & { \frac { \partial \ell } { \partial \mathbf { W } _ { d - 1 } } = \mathbf { k } _ { d - 1 } f _ { d - 2 } ^ { \top } ; \mathbf { k } _ { d - 1 } : = ( \mathbf { w } _ { d } ^ { \top } \mathbf { k } _ { d } ) \odot \sigma _ { d - 1 } ^ { \prime } } \\ & { } & { \frac { \partial \ell } { \partial \mathbf { W } _ { d - 2 } } = \mathbf { k } _ { d - 2 } \boldsymbol { \phi } ^ { \top } ; \mathbf { k } _ { d - 2 } : = ( \mathbf { W } _ { d - 1 } ^ { \top } \mathbf { k } _ { d - 1 } ) \odot \sigma _ { d - 2 } ^ { \prime } } \end{array}
+$$
+
+In Equation 12, the value of $y$ can be derived from the sign of the gradients at this layer if the activation function of previous layer is ReLU or Sigmoid, i.e. $f _ { d - 1 } > 0$ . For multi-class classification, $y$ can always be analytically derived as proved by Zhao et al. (2020). From Equations 12-14 we can see that gradients are actually linear constraints on the output of the previous layer, also the input of the current layer. We name these gradient constraints, which can be generally described as:
+
+$$
+\mathbf { K } _ { i } \mathbf { x } _ { i } = \mathrm { f l a t t e n } ( \frac { \partial \ell } { \partial \mathbf { W } _ { i } } ) ,
+$$
+
+where $i$ denotes $i$ -th layer, $\mathbf { x } _ { i }$ denotes the input and $\mathbf { K } _ { i }$ is a coefficient matrix containing all gradient constraints at the $i$ -th layer.
+
+# 3.1.2 IMPLEMENTATION OF R-GAP
+
+To reconstruct the input $\mathbf { x } _ { i }$ from the gradients $\frac { \partial \ell } { \partial \mathbf { W } _ { i } }$ at the $i$ -th layer, we need to determine $\mathbf { K } _ { i }$ or $\mathbf { k } _ { i }$ . The coefficient vector $\mathbf { k } _ { i }$ solely relies on the reconstruction of the subsequent layer. For example in Equation 13, $\mathbf { k } _ { d - 1 }$ consists of $\mathbf { w } _ { d } , \mathbf { k } _ { d } , \sigma _ { d - 1 } ^ { \prime }$ , where ${ \bf w } _ { d }$ is known, and $\mathbf { k } _ { d }$ and $\sigma _ { d - 1 } ^ { \prime }$ are products of the reconstruction at the $d$ -th layer. More specifically, $\mathbf { k } _ { d }$ can be calculated by deriving $y$ and $\mu$ as described in Section 3.1.1, $\sigma _ { d - 1 } ^ { \prime }$ can be derived from the reconstructed $f _ { d - 1 }$ . The condition for recovering $\mathbf { x } _ { i }$ under gradient constraints $\mathbf { k } _ { i }$ is that the rank of the coefficient matrix equals the number of entries of the input, $\mathrm { r a n k } ( \mathbf { K } _ { i } ) = | \mathbf { x } _ { i } |$ . Furthermore, if this rank condition holds for $i = 1 , . . . , d$ , we are able to reconstruct the input at each layer and do this recursively back to the input of the first layer.
+
+The number of gradient constraints is the same as the number of weights, i.e. ro $\mathrm { v s } ( \mathbf { K } _ { i } ) = | \mathbf { W } _ { i } |$ ; $i =$ $1 , . . . , d$ . Specifically, in the case of a fully connected layer we always have $\mathrm { r a n k } ( \mathbf { K } _ { i } ) = \lvert \mathbf { x } _ { i } \rvert$ , which implies the reconstruction over FCNs is always feasible. However in the case of a convolutional layer the matrix could possibly be rank-deficient to derive $\mathbf { X }$ . Fortunately, from the view of recursive reconstruction and assuming we know the input of the subsequent layer, i.e. the output of the current layer, there is a new group of linear constraints which we name weight constraints:
+
+$$
+\mathbf { W } _ { i } \mathbf { x } _ { i } = \mathbf { z } _ { i } ; \quad \mathbf { z } _ { i } \gets f _ { i }
+$$
+
+For a convolution layer, the $\mathbf { W } _ { i }$ we use in this paper is the corresponding circulant matrix representing the convolutional kernel (Golub & Van Loan, 1996), so we can express the convolution in the form of Equation 16. In order to derive $\mathbf { z } _ { i }$ from $f _ { i }$ , the activation function $\sigma _ { i }$ should be monotonic. Commonly used activation functions satisfy this requirement. Note that for the ReLU activation function, a 0 value in $f _ { i }$ will remove a constraint in $\mathbf { W } _ { i }$ . Otherwise, the number of weights constraints is equal to the number of entries in output, i.e. $\mathrm { r o w s } ( \mathbf { W } _ { i } ) = | \mathbf { z } _ { i } | ; ~ i = 1 , . . . , d$ . In CNNs the number of weight constraints $\left| \mathbf { z } _ { i } \right|$ is much larger than the number of gradient constraints $| \mathbf { W } _ { i } |$ in bottom layers, and well compensate for the lack of gradient constraints in those layers. It is worth noting that, due to the transformation from a CNN to a FCN using the circulant matrix, a CNN has been regarded equivalent to a FCN in the parallel work of Fan et al. (2020). However, we would like to point out that in consideration of the gradients w.r.t. the circulant matrix, what we obtain from a CNN are the aggregated gradients. Therefore, the number of valid gradient constraints in a CNN are much smaller than its corresponding FCN. Therefore, the conclusion of a rank analysis derived from a FCN cannot be directly applied to a CNN.
+
+Moreover, padding in the $i$ -th convolutional layer increases $\left| { { \bf { x } } _ { i } } \right|$ , but also involves the same number of constraints, so we omit this detail in the subsequent discussion. However, we have incorporated the corresponding constraints in our approach. Based on gradient constraints and weight constraints, we break the gradient attacks down to a recursive process of solving systems of linear equations, which we name R-GAP . The approach is detailed in Algorithm 1.
+
+# 4 RANK ANALYSIS
+
+For optimization-based gradient attacks such as DLG, it is hard to estimate whether it will converge to a unique solution given a network’s architecture other than performing an empirical test. An intuitive assumption would be that the more parameters in the model, the greater the chance of unique recovery, since there will be more terms in the objective function constraining the solution. We provide here an analytic approach, with which it is easy to estimate the feasibility of performing the recursive gradient attack, which in turn is a good proxy to estimate when DLG converges to a good solution (see Figure 2).
+
+Algorithm 1: R-GAP (Notation is consistent with Equation 6 to Equation 15)   
+
+<table><tr><td colspan="2">Data: i: i-th layer; Wi: weights; VWi: gradients; Result: X1</td></tr><tr><td colspan="2">fori←d to1 do if i=d then</td></tr><tr><td colspan="2">μ = VWi·Wi; al μ↑ al</td></tr><tr><td colspan="2">比：</td></tr><tr><td colspan="2">y</td></tr><tr><td colspan="2">else /* Derive σ&#x27; and zi from fi. Note that Xi+1= fi. */</td></tr><tr><td colspan="2">←Xi+1;Zi←Xi+1;</td></tr><tr><td colspan="2">ki :=(Wi+1 ki+1) ① σ&#x27;;</td></tr><tr><td colspan="2">end</td></tr><tr><td colspan="2">Ki ←ki; Vwi := flatten(VWi);</td></tr><tr><td colspan="2">[Wi] ; bi := Zi A:= K Vw i</td></tr></table>
+
+Since R-GAP solves a sequence of linear equations, it is infeasible when the number of unknown parameters is more than the number of constraints at any $i$ -th layer, i.e. $\left| \mathbf { x } _ { i } \right| - \left| \mathbf { W } _ { i } \right| - \left| \mathbf { z } _ { i } \right| > 0 .$ . More precisely, R-GAP requires that the rank of $\mathbf { A } _ { i }$ , which consists of $\mathbf { W } _ { i }$ and $\mathbf { K } _ { i }$ as shown in Algorithm 1, is equal to the number of input entries $\left| { { \bf { x } } _ { i } } \right|$ . However, $\mathbf { A } _ { i } \mathbf { x } _ { i } = \mathbf { z } _ { i }$ does not include all effective constraints over $\mathbf { x } _ { i }$ . Because $\mathbf { x } _ { i }$ is unique to $\mathbf { z } _ { i - 1 }$ or partly unique in terms of the ReLU activation function, any constraint over $\mathbf { z } _ { i - 1 }$ will limit the possible value of $\mathbf { x } _ { i }$ . On that note, suppose $| { \bf x } _ { i - 1 } | =$ $m$ , $| { \bf z } _ { i - 1 } | = n$ and the weight constraints at the $i - 1$ layer is overdetermined, i.e. $\mathbf { W } _ { i - 1 } \mathbf { x } _ { i - 1 } =$ $\mathbf { z } _ { i - 1 }$ ; $m < n$ , $r a n k ( \mathbf { W } _ { i - 1 } ) = m$ . Without the loss of generality, let the first $m$ entries of $\mathbf { z } _ { i - 1 }$ be linearly independent, the $m + 1$ , . . . , $n$ entries of $\mathbf { z } _ { i - 1 }$ can be expressed as linear combination of the first $m$ entries, i.e. $\mathbf { M } \mathbf { z } _ { i - 1 } ^ { 1 , . . . , m } = \mathbf { z } _ { i - 1 } ^ { m + 1 , . . . , n }$ . In other words, if the previous layers are overdetermined by weight constraints, the subsequent layer will have additional constraints, not merely its local weight constraints and gradient constraints. Since this type of additional constraint is not derived from the parameters of the layer that under reconstruction, we name them virtual constraints denoted by $\nu$ . When the activation function is the identity function, the virtual constraints are linear and can be readily derived. For the derivative of the activation function not being a constant, the virtual constraints will become non-linear. For more details about deriving the virtual constraints, refer to Appendix C. Optimization based attacks such as DLG are iterative algorithms based on gradient descent, and are able to implicitly utilize the non-linear virtual constraints. Therefore to provide a comprehensive estimate of the data vulnerability under gradient attacks, we also have to count the number of virtual constraints. It is worth noticing that virtual constraints can be passed along through the linear equation systems chain, but only in one direction that is to the subsequent layers. Next, we will informally use $| \nu _ { i } |$ to denote the number of virtual constraints at the $i$ -th layer, which can be approximated by $\begin{array} { r } { \sum _ { n = 1 } ^ { i - 1 } m a x ( | \mathbf { z } _ { n } | - | \mathbf { x } _ { n } | , 0 ) - m a x ( | \mathbf { x } _ { n } | - | \mathbf { z } _ { n } | - | \mathbf { W } _ { n } | , 0 ) . } \end{array}$ . For more details refer to Appendix C. In practice, the real number of such constraints is dependent on the data, current weights, and choice of activation function.
+
+These three types of constraints, gradient, weight and virtual constraints, are effective for predicting the risk of gradient attack. To conclude, we propose that $\left| \mathbf { x } _ { i } \right| - \left| \mathbf { W } _ { i } \right| - \left| \mathbf { z } _ { i } \right| - \left| \mathcal { V } _ { i } \right|$ is a good index to estimate the feasibility of fully recovering the input using gradient attacks at the $i$ -th layer. We denote this value rank analysis index $( R A - i )$ . Particularly, $| \mathbf { \bar { x } } _ { i } | - | \mathbf { W } _ { i } | - | \mathbf { z } _ { i } | - | \mathcal { V } _ { i } | > 0$ indicates it is not possible to perform a complete reconstruction of the input, and the larger this index is, the poorer the quality of reconstruction will be. If the constraints in a particular problem are linearly independent, $| \mathbf { x } _ { i } | - | \mathbf { W } _ { i } | - | \mathbf { z } _ { i } | - | \mathcal { V } _ { i } | < 0$ implies the ability to fully recover the input. The quality of reconstruction of data is well estimated by the maximal RA-i of all layers, as shown in Figure 2. In practice, the layers close to the data usually have smaller RA-i due to fewer virtual constraints.
+
+![](images/3ffeb6beee80a9c7109d68b2d0d0a5b2d77031089ffb317e8ad3dafe0e875d2e.jpg)  
+Figure 2: Estimating the privacy leakage of network through rank analysis. The critical layer for reconstruction has been red colored. First three columns show that even though bigger network has much more parameters denoted by $| \mathbf { W } |$ , which means we can collect more gradients to reconstruct the data, but if the layer close to data is rank-deficient, we are not able to fully recover the data. Despite that in the objective function of DLG, distance between all gradients will be reduced at the same time, redundant constraints in subsequent layer certainly cannot compensate the lack of constraints in previous layer. The fourth column shows that if rank-deficiency happens at the intermediate layer, redundant weight constraints in previous layer, i.e. virtual constraints, is able to compensate the deficiency at the intermediate layer. If a layer is rank-deficient after taking virtual constraints into account, fully recovery is again not possible as shown in the fifth column. However, as the rank analysis index of last column is smaller than the one of the second and third column, the reconstruction at the fifth column has a better quality. This figure demonstrates that rank analysis can correctly estimate the feasibility of performing DLG, for statistic result refer to Appendix A.
+
+On top of that we analyse the residual block in ResNet, which shows some interesting traits of the skip connection in terms of the rank-deficiency, for more details refer to Appendix D.
+
+A valuable observation we obtain through the rank analysis is that the architecture rather than the number of parameters is critical to gradient attacks, as shown in Figure 2. This observation is not obvious from simply specifying the DLG optimization problem(see Equation 1). Furthermore, since the data vulnerability of a network depends on the layer with maximal RA-i, we can design rank-deficiency into the architecture to improve the security of a network (see Figure 4).
+
+# 5 RESULTS
+
+Our novel approach R-GAP successfully extends the analytic gradient attack (Phong et al., 2018) from attacking a FCN with bias terms to attacking FCNs and $\mathrm { C N N s ^ { 1 } }$ with or without bias terms. To test its performance, we use a CNN6 network as shown in Figure 3, which is full-rank considering gradient constraints and weight constraints. Additionally, we report results using a CNN6-d network, which is rank-deficient without consideration of virtual constraints, in order to to fairly compare the performance of DLG and R-GAP. CNN6-d has a CNN6 backbone and just decreases the output channel of the second convolutional layer to 20. The activation function is a LeakyReLU except the last layer, which is a Sigmoid. We have randomly initialized the network, as DLG is prone to fail if the network is at a late stage of training (Geiping et al., 2020). Furthermore, as the label can be analytically recovered by R-GAP, we always provide DLG the ground-truth label and let it recover the image only. Therefore the experiment actually compares R-GAP with iDLG (Zhao et al., 2020). The experimental results show that, due to an analytic one-shot process, run-time of R-GAP is orders of magnitude shorter than DLG. Moreover, R-GAP can recover the data more accurately, while optimization-based methods like DLG recover the data with artifacts, as shown in Figure 3. The statistical results in Table 1 also show that the reconstruction of R-GAP has a much lower MSE than DLG on the CNN6 network. However, as R-GAP only considers gradient constraints and weight constraints in the current implementation, it does not work well on the CNN6-d network. Nonetheless, we find that it is easy to assess the quality of reconstruction of gradient attack without knowing the original image. As the better reconstruction has less salt-and-pepper type noise. We measure this by the difference of the image and its smoothed version (achieved by a simple $3 \mathrm { x } 3$ averaging) and select the output with the smaller norm. This hybrid approach which we name HGAP combines the strengths of R-GAP and DLG, and obtains the best results.
+
+![](images/e8004e093647378683796cc1a237b9026e1344529d0b43b9c25590ba89d375e9.jpg)  
+Figure 3: Performance of our approach and DLG over a CNN6 architecture. The diagram on the left demonstrates the network architecture on which we perform attack. The activation functions are LeakyReLU, except the last one which is Sigmoid.
+
+<table><tr><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>CNN6*</td><td rowspan=1 colspan=1>CNN6-d*</td><td rowspan=1 colspan=1>CNN6**</td><td rowspan=1 colspan=1>CNN6-d**</td></tr><tr><td rowspan=1 colspan=1>R-GAP</td><td rowspan=1 colspan=1>0.010± 0.0017</td><td rowspan=1 colspan=1>1.4 ± 0.073</td><td rowspan=1 colspan=1>1.9×10-4±7.0×10-5</td><td rowspan=1 colspan=1>0.0090±9.3×10-4</td></tr><tr><td rowspan=1 colspan=1>DLG</td><td rowspan=1 colspan=1>0.050±0.0014</td><td rowspan=1 colspan=1>0.053±0.0016</td><td rowspan=1 colspan=1>4.2×10 ±5.9×10-5</td><td rowspan=1 colspan=1>0.0012±1.8×10-4</td></tr><tr><td rowspan=1 colspan=1>H-GAP</td><td rowspan=1 colspan=1>0.0069±0.0012</td><td rowspan=1 colspan=1>0.053± 0.0016</td><td rowspan=1 colspan=1>1.4×10-4±2.3×10-5</td><td rowspan=1 colspan=1>0.0012±1.8×10</td></tr></table>
+
+\*:CIFAR10 \*\*:MNIST
+
+Table 1: Comparison of the performance of R-GAP, DLG and H-GAP. MSE has been used to measure the quality of the reconstruction.
+
+Moreover, we compare R-GAP with DLG on LeNet which has been benchmarked in DLG(Zhu et al., 2019), the statistical results are shown in Table 2. Both DLG and R-GAP perform well on LeNet. Empirically, if the MSE is around or below $1 \times 1 0 ^ { - 4 }$ , the difference of the reconstruction will be visually undetectable. However, we surprisingly find that by replacing the Sigmoid function with the Leaky ReLU, the reconstruction of DLG becomes much poorer. The condition number of matrix A (from Algorithm 1) changes significantly in this case. Since the Sigmoid function leads to a higher condition number at each convolutional layer, reconstruction error in the subsequent layer could be amplified in the previous layer, therefore DLG is forced to converge to a better result. In contrast, R-GAP has an accumulated error and naturally performs much better on LeNet\*. Additionally, we find R-GAP could be a good initialization tool for DLG. As shown in the last column of Table 2, by initializing DLG with the reconstruction of R-GAP, and running $8 \%$ of the previous iterations, we achieve a visually indistinguishable result. However, for LeNet\*, we find that DLG reduces the reconstruction quality obtained by R-GAP, which further shows the instability of DLG.
+
+Our rank analysis is a useful offline tool to understand the risk inherent in certain network architectures. More precisely, we can use the rank analysis to find out the critical layer for the success of
+
+<table><tr><td rowspan=2 colspan=1></td><td rowspan=1 colspan=3>Condition number</td><td rowspan=1 colspan=3>MSE</td></tr><tr><td rowspan=1 colspan=1>conv1</td><td rowspan=1 colspan=1>conv2</td><td rowspan=1 colspan=1>conv3</td><td rowspan=1 colspan=1>DLG</td><td rowspan=1 colspan=1>R-GAP</td><td rowspan=1 colspan=1>R-GAP→DLG</td></tr><tr><td rowspan=1 colspan=1>LeNet</td><td rowspan=1 colspan=1>1.8×104±2.9</td><td rowspan=1 colspan=1>6.1×10±0.3</td><td rowspan=1 colspan=1>32.4±2.9×10-4</td><td rowspan=1 colspan=1>3.7×10-8±8.6×10-10</td><td rowspan=1 colspan=1>1.1×10-4±7.8× 10-6</td><td rowspan=1 colspan=1>1.1×10-6±1.1 ×10-6</td></tr><tr><td rowspan=1 colspan=1>LeNet*</td><td rowspan=1 colspan=1>1.2×10±19.7</td><td rowspan=1 colspan=1>1.3×10±22.5</td><td rowspan=1 colspan=1>14.2±0.05</td><td rowspan=1 colspan=1>5.2×10-2±2.9 ×10-3</td><td rowspan=1 colspan=1>1.5×10-10±2.5 × 10-11</td><td rowspan=1 colspan=1>4.8×10±9.1 × 10-5</td></tr></table>
+
+LeNet\* is identical to LeNet but uses Leaky ReLU activation function instead of Sigmoid
+
+Table 2: Comparison of R-GAP and DLG on LeNet benchmarked in DLG(Zhu et al., 2019).
+
+gradient attacks and take precision measurements to improve the network’s defendability. We report results on the ResNet-18, where the third residual block is critical since by cutting its skip connection the RA-i increases substantially. To perform the experiments, we use the approach proposed by Geiping et al. (2020), which extends DLG to incorporate image priors and performs better on deep networks. As shown in Figure 4, by cutting the skip connection of the third residual block, reconstructions become significantly poorer and more unstable. As a control test, cutting the skip connection of a non-critical residual block does not increase defendability noticeably. Note that two variants have the same or even slightly better performance on the classification task compared with the backbone. In previous works (Zhu et al., 2019; Wei et al., 2020), trade-off between accuracy and defendability of adding noise to gradients has been discussed. We show that using the rank analysis we are able to increase the defendability of a network with no cost in accuracy.
+
+![](images/5fa0a025688877ce8766998d2f10b77056a94bd7984d7acbbeb45f014d8f1cc6.jpg)  
+Figure 4: Left: Architectures of the ResNet18 with base width 16 and two variants. Variant 1 cuts the skip connection of the third residual block. Variant 2 cuts the skip connection of the eighth residual block. Upper right: Reconstruction examples of three networks. Lower right: Accuracy and reconstruction error of three networks. Training 200 epochs on CIFAR10 and saving the model with the best performance on the validation set, three networks achieve a close accuracy. Two variants perform even slightly better. In terms of gradient attacks, MSE of reconstructions from ResNet18 and Variant 2 are similar, since Variant 2 cut the skip connection of a non-critical layer and the RA-i does not change. Whereas, by cuting the skip connection of a critical layer, according to the rank analysis, increases RA-i substantially. MSE of the reconstructions from Variant 1 increases by nearly a factor of three with higher variance.
+
+# 6 DISCUSSION AND CONCLUSIONS
+
+R-GAP makes the first step towards a general analytic gradient attack and provides a framework to answer questions about the functioning of optimization-based attacks. It also opens new questions, such as how to analytically reconstruct a minibatch of images, especially considering nonuniqueness due to permutation of the image indices. Nonetheless, we believe that by studying these questions, we can gain deeper insights into gradient attacks and privacy secure federated learning.
+
+In this paper, we propose a novel approach R-GAP, which has achieved an analytic gradient attack for CNNs for the first time. Through analysing the recursive reconstruction process, we propose a novel rank analysis to estimate the feasibility of performing gradient based privacy attacks given a network architecture. Our rank analysis can be applied to the analysis of both closed-form and optimization-based attacks such as DLG. Using our rank analysis, we are able to determine network modifications that maximally improve the network’s security, empirically without sacrificing its accuracy. Furthermore, we have analyzed the existence of twin data using R-GAP, which can explain at least in part why DLG is sensitive to initialization and what type of initialization is optimal. In summary, our work proposes a novel type of gradient attack, a risk estimation tool and advances the understanding of optimization-based gradient attacks.
+
+# ACKNOWLEDGEMENTS
+
+This research received funding from the Flemish Government (AI Research Program).
+
+# REFERENCES
+
+Peter L Bartlett, Michael I Jordan, and Jon D McAuliffe. Convexity, classification, and risk bounds. Journal of the American Statistical Association, 101(473):138–156, 2006.
+
+Emiliano De Cristofaro. An overview of privacy in machine learning. arXiv:2005.08679, 2020.
+
+Lixin Fan, Kam Woh Ng, Ce Ju, Tianyu Zhang, Chang Liu, Chee Seng Chan, and Qiang Yang. Rethinking privacy preserving deep learning: How to evaluate and thwart privacy attacks. In Qiang Yang, Lixin Fan, and Han Yu (eds.), Federated Learning: Privacy and Incentive, pp. 32– 50. Springer, 2020.
+
+Jonas Geiping, Hartmut Bauermeister, Hannah Droge, and Michael Moeller. Inverting gradients: ¨ How easy is it to break privacy in federated learning? In Hugo Larochelle, Marc’Aurelio Ranzato, Raia Hadsell, Maria-Florina Balcan, and Hsuan-Tien Lin (eds.), Advances in Neural Information Processing Systems 33, 2020.
+
+Gene H. Golub and Charles F. Van Loan. Matrix Computations. Johns Hopkins University Press, 1996.
+
+Zecheng He, Tianwei Zhang, and Ruby B. Lee. Model inversion attacks against collaborative inference. In Proceedings of the 35th Annual Computer Security Applications Conference, ACSAC ’19, pp. 148–162, 2019.
+
+Arthur Jochems, Timo M. Deist, Johan van Soest, Michael Eble, Paul Bulens, Philippe Coucke, Wim Dries, Philippe Lambin, and Andre Dekker. Distributed learning: Developing a predictive model based on data from multiple hospitals without data leaving the hospital – a real life proof of concept. Radiotherapy and Oncology, 121(3):459 – 467, 2016.
+
+Arthur Jochems, Timo Deist, Issam El Naqa, Marc Kessler, Chuck Mayo, Jackson Reeves, Shruti Jolly, Martha Matuszak, Randall Ten Haken, Johan Soest, Cary Oberije, Corinne Faivre-Finn, Gareth Price, Dirk Ruysscher, Philippe Lambin, and Andre Dekker. Developing and validating ´ a survival prediction model for nsclc patients through distributed learning across three countries. International Journal of Radiation Oncology\*Biology\*Physics, 99, 04 2017.
+
+Diederik P. Kingma and Jimmy Ba. Adam: A method for stochastic optimization. In Yoshua Bengio and Yann LeCun (eds.), 3rd International Conference on Learning Representations, 2015.
+
+Jakub Konecnˇ y, H. Brendan McMahan, Felix X. Yu, Peter Richtarik, Ananda Theertha Suresh, and´ Dave Bacon. Federated learning: Strategies for improving communication efficiency. In NIPS Workshop on Private Multi-Party Machine Learning, 2016.
+
+Dong C. Liu and Jorge Nocedal. On the limited memory BFGS method for large scale optimization. Math. Program., 45(1–3):503–528, August 1989.
+
+Brendan McMahan, Eider Moore, Daniel Ramage, Seth Hampson, and Blaise Aguera y Arcas. Communication-efficient learning of deep networks from decentralized data. In Aarti Singh and Jerry Zhu (eds.), Proceedings of the 20th International Conference on Artificial Intelligence and Statistics, volume 54 of Proceedings of Machine Learning Research, pp. 1273–1282, 2017.
+
+L. T. Phong, Y. Aono, T. Hayashi, L. Wang, and S. Moriai. Privacy-preserving deep learning via additively homomorphic encryption. IEEE Transactions on Information Forensics and Security, 13(5):1333–1345, 2018.
+
+Maria Rigaki and Sebastian Garcia. A survey of privacy attacks in machine learning. CoRR, abs/2007.07646, 2020.
+
+Z. Wang, M. Song, Z. Zhang, Y. Song, Q. Wang, and H. Qi. Beyond inferring class representatives: User-level privacy leakage from federated learning. In IEEE INFOCOM 2019 - IEEE Conference on Computer Communications, pp. 2512–2520, 2019.
+
+Wenqi Wei, Ling Liu, Margaret Loper, Ka-Ho Chow, Mehmet Emre Gursoy, Stacey Truex, and Yanzhao Wu. A framework for evaluating client privacy leakages in federated learning. In Liqun Chen, Ninghui Li, Kaitai Liang, and Steve Schneider (eds.), Computer Security – ESORICS, pp. 545–566. Springer, 2020.
+
+Ziqi Yang, Jiyi Zhang, Ee-Chien Chang, and Zhenkai Liang. Neural network inversion in adversarial setting via background knowledge alignment. In Proceedings of the 2019 ACM SIGSAC Conference on Computer and Communications Security, pp. 225–240, 2019.
+
+Yuheng Zhang, Ruoxi Jia, Hengzhi Pei, Wenxiao Wang, Bo Li, and Dawn Song. The secret revealer: Generative model-inversion attacks against deep neural networks. In IEEE/CVF Conference on Computer Vision and Pattern Recognition, pp. 250–258, 2020.
+
+Bo Zhao, Konda Reddy Mopuri, and Hakan Bilen. iDLG: Improved deep leakage from gradients. arXiv:2001.02610, 2020.
+
+Ligeng Zhu, Zhijian Liu, and Song Han. Deep leakage from gradients. In H. Wallach, H. Larochelle, A. Beygelzimer, F. d’Alche Buc, E. Fox, and R. Garnett (eds.),´ Advances in Neural Information Processing Systems 32, pp. 14774–14784, 2019.
+
+# A QUANTITATIVE RESULTS OF RANK ANALYSIS
+
+A quantitative analysis of the predictive performance of the rank analysis index for the mean squared error of reconstruction is shown in Table 3.
+
+$$
+\frac { \mathrm { R A - i } } { \mathrm { M S E } } \| \begin{array} { c } { 4 8 4 } \\ { 4 . 2 \times 1 0 ^ { - 9 } } \\ { \pm 2 . 2 \times 1 0 ^ { - 9 } } \end{array} | \begin{array} { c } { 4 0 5 } \\ { 0 . 0 5 6 \pm 0 . 0 0 3 5 } \\ { 0 . 0 6 3 \pm 0 . 0 0 4 } \\ { \pm 2 . 0 \times 1 0 ^ { - 5 } } \end{array} \| \begin{array} { c } { 4 0 5 } \\ { 2 . 7 \times 1 0 ^ { - 4 } } \\ { 2 . 2 \times 1 0 ^ { - 5 } } \end{array} \frac { 3 1 6 } { \begin{array} { c } { 0 . 1 8 } \\ { 0 . 0 1 3 } \\ { \pm 7 . 2 \times 1 0 ^ { - 4 } } \end{array} } .
+$$
+
+Table 3: Mean square error of the reconstruction over test set of CIFAR10. The corresponding network architecture has been shown in Figure 2 in the same order. Rank analysis index (RA-i) clearly predicts the reconstruction error. We can also regard RA-i as the security level of a network. A negative value indicates that the gradients of the network are able to fully expose the data, i.e. insecure, while a positive value indicates that completely recover the data from gradients is not possible. On top of that, higher RA-i indicate higher reconstruction error, therefore the network is more secure. According to our experiment, if the order of magnitude of MSE is equal to or less than $1 0 ^ { - 4 }$ , we could barely visually distinguish the recovered and real data, as shown in the fourth column of Figure 2. Note that, as the network gets deeper, DLG will become vulnerable, R-GAP will also be effected by numerical error. Besides that, DLG is sensitive to the initialization of dummy data, while R-GAP also needs to confirm the $\mu$ if it is not unique. Therefore, RA-i provides a reasonable upper bound of the privacy risk rather than quality prediction of one reconstruction.
+
+# B TWIN DATA
+
+As we know $\textstyle { \frac { \partial \ell } { \partial \mu } } \mu$ is non-monotonic as shown in Figure 1, which means knowing $\textstyle { \frac { \partial \ell } { \partial \mu } } \mu$ does not always allow us to uniquely recover $\mu$ . It is relatively straightforward to show that for monotonic convex losses (Bartlett et al., 2006), $\textstyle { \frac { \partial \ell } { \partial \mu } } \mu$ is invertible for $\mu \ < \ 0$ , $\textstyle { \frac { \partial \ell } { \partial \mu } } \mu \ \leq \ 0$ for $\mu \geq 0$ , and $\begin{array} { r } { \operatorname* { l i m } _ { \mu \to \infty } \frac { \partial \ell } { \partial \mu } \mu = 0 . } \end{array}$ . Due to the non-uniqueness of $\mu$ w.r.t to ∂\`∂µ µ, we have:
+
+$$
+\exists \mathrm { \bf ~ x } , \tilde { \bf x } \mathrm { s } . \mathrm { t } . \mu \neq \tilde { \mu } ; \frac { \partial \ell } { \partial \mu } \mu = \frac { \partial \ell } { \partial \tilde { \mu } } \tilde { \mu }
+$$
+
+where $\mathbf { X }$ is the real data.
+
+Taking the common setting that activation functions are ReLU or LeakyReLU, we can derive from Eq. 10 that:
+
+$$
+\frac { \partial \ell } { \partial \mathbf { W } _ { i } } \cdot \mathbf { W } _ { i } = \frac { \partial \ell } { \partial \tilde { \mathbf { W } } } \cdot \tilde { \mathbf { W } } _ { i } ; \quad i = 1 , \ldots , d
+$$
+
+if there is a $\tilde { \mathbf { W } } _ { i }$ is equal to $\mathbf { W } _ { i }$ , whereas the corresponding $\tilde { \mathbf { x } }$ is not same as $\mathbf { X }$ since $\mu \ne \tilde { \mu }$ , we can find a data point that differs from the true data but leads to the same gradients. We name such data twin data, denoted by $\tilde { \mathbf { x } }$ . As we know the gradients and $\mu$ of the twin data $\tilde { \mathbf { x } }$ , by just giving them to R-GAP, we are able to easily find out the twin data. As shown in in Figure 5, twin data is actually proportional to the real data and smaller than it, which can also be straightforwardly derived from Equation 6 to Equation 8. Since the twin data and the real data trigger the same gradients, by decreasing the distance of gradients as Equation 1, DLG is suppose to converge to either of these data. As shown in Figure 5, we initialize DLG with a data close to the twin data $\tilde { \mathbf { x } }$ , DLG converges to the twin data. In the work of Wei et al. (2020), the authors argue that using an image from the same class as the real data would be the optimal initialization and empirically prove that. We want to point out that twin data is one important factor why DLG is so sensitive to the initialization and prone to fail with random initialization of dummy data particularly after some training steps of the network. Since DLG converges either to the twin data or the real data depends on the distance between these two data and the initialization, an image of the same class is usually close to the real data, therefore, DLG works better with that. While, with respect to $\mu$ or the prediction of the network, a random initialization is close to the twin data, so DLG converges to the twin data. However, the twin data has extremely small value, so any noise that comes up with optimization process stands out in the last result as shown in Figure 5.
+
+![](images/9b6fef79d5d81033d374f17967849f22b977cd98f7a428bf99cd94f7cf371a2f.jpg)  
+Figure 5: Twin data. The left figure demonstrates a twin data $\tilde { \mathbf { x } }$ , which will trigger exactly the same gradients as the real data $\mathbf { X }$ does. Therefore, from the perspective of DLG, these two data are global minimum for the objective function. The right figure shows that by adding noise to shift the twin data a little and using it as an initialization, DLG will converge to the twin data rather than real data.
+
+It is worth noting that the twin data can be fully reconstructed only if $\mathrm { { R A } } \mathrm { { - i } } < 0$ . In other words, if complete reconstruction is feasible and the twin data exits, R-GAP and DLG can recover either the twin data or real data depend on the initialization. But both of them lead to privacy leakage.
+
+# C VIRTUAL CONSTRAINTS
+
+In this section we investigate the virtual constraints as proposed in the rank analysis. To the beginning, let us derive the explicit virtual constraints from the $i - 1$ layer at the reconstruction of the $i$ layer by assuming the activation function is an identity function. The weight constraints of the $i - 1$ layer can be expressed as:
+
+$$
+\mathbf { W } \mathbf { x } _ { i - 1 } = \mathbf { z } ;
+$$
+
+Split $\mathbf { W } , \mathbf { z }$ into two parts coherently, i.e.:
+
+$$
+\begin{array} { r } { [ \mathbf { W } _ { + } ] _ { \mathbf { W } _ { - } } = [ \mathbf { z } _ { + } ] } \\ { \mathbf { W } _ { - } ] \mathbf { x } _ { i - 1 } = [ \mathbf { z } _ { - } ] } \end{array}
+$$
+
+Assume the upper part of the weights ${ \bf W } _ { + }$ is already full rank, therefore:
+
+$$
+\begin{array} { c } { \mathbf { z } _ { + } = \mathbf { I } _ { + } \mathbf { z } } \\ { \mathbf { x } _ { i - 1 } = \mathbf { W } _ { + } ^ { - 1 } \mathbf { I } _ { + } \mathbf { z } } \\ { \mathbf { z } _ { - } = \mathbf { I } _ { - } \mathbf { z } } \\ { \mathbf { W } _ { - } \mathbf { x } _ { i - 1 } = \mathbf { I } _ { - } \mathbf { z } } \end{array}
+$$
+
+Substituting Equation 21 into Equation 23, we can derive the following constraints over $\mathbf { z }$ after rearranging:
+
+$$
+( \mathbf { W } _ { - } \mathbf { W } _ { + } ^ { - 1 } \mathbf { I } _ { + } - \mathbf { I } _ { - } ) \mathbf { z } = \mathbf { 0 }
+$$
+
+Since the activation function is the identity function, i.e. $\mathbf { z } = \mathbf { x } _ { i }$ , the virtual constraints $\nu$ that the $i$ -th layer has inherited from the weight constraints of $i - 1$ layer are:
+
+$$
+\mathcal { V } \mathbf { { x } } _ { i } = \mathbf { 0 } ; ~ \mathcal { V } = \mathbf { W } _ { - } \mathbf { W } _ { + } ^ { - 1 } \mathbf { I } _ { + } - \mathbf { I } _ { - }
+$$
+
+Virtual constraints as external constraints are able to compensate the local rank-deficiency of an intermediate layer. For other strictly monotonic activation function like Leaky ReLU, Sigmoid, Tanh, the virtual constraints over $\mathbf { x } _ { i }$ can be expressed as:
+
+$$
+\gamma \sigma _ { i - 1 } ^ { - 1 } ( \mathbf { x } _ { i } ) = \mathbf { 0 }
+$$
+
+This is not a linear equation system w.r.t. $\mathbf { x } _ { i }$ , therefore it is hard to be incorporated in R-GAP. In terms of ReLU the virtual constraints could become further more complicated which will reduce its efficacy. Nevertheless, the reconstruction of the $i$ -th layer must take the virtual constraints into account. Otherwise, it will trigger a non-negligible reconstruction error later on. From this perspective, we can see that iterative algorithms like optimization-based attacks can inherently utilize such virtual constraints, which is a strength of O-GAP.
+
+We would like to point out that theoretically the gradient constraints also have the same effect as the weight constraints in the virtual constraints but in a more sophisticated way. Empirical results show that the gradient constraints of previous layers do not have an evident impact on the subsequent layer in the O-GAP, so we have not taken it into account. The number of virtual constraints at $i$ -th layer can therefore be approximated by $\begin{array} { r } { \sum _ { n = 1 } ^ { i - 1 } m a x ( | \mathbf { z } _ { n } | - | \mathbf { x } _ { n } | , 0 ) - m a x ( | \mathbf { x } _ { n } | - | \mathbf { z } _ { n } | - | \mathbf { W } _ { n } | , 0 ) , } \end{array}$ .
+
+# D RANK ANALYSIS OF THE SKIP CONNECTION
+
+If the skip connection skips one layer, for simplicity assuming the activation function is the identity function, then the layer can be expressed as:
+
+$$
+f = \mathbf { W } ^ { * } \mathbf { x } ; \ \mathbf { W } ^ { * } = \mathbf { W } + \mathbf { I }
+$$
+
+where $f$ is the output of this layer, the weight matrix $\mathbf { W } ^ { * }$ is clear and the number of weight constraints is equal to $| f |$ . While the expression of gradients are the same as without skip connection, since:
+
+$$
+\nabla \mathbf { W } ^ { * } = \nabla \mathbf { W }
+$$
+
+Therefore the number of gradient constraints is equal to $| \mathbf { W } |$ . In other words, without consideration of the virtual constraints, if $| f | + | \mathbf { W } | < | x |$ this layer is locally rank-deficient, otherwise it is full rank. This is the same as removing the skip connection.
+
+If the skip connection skips over two layers, for simplicity assuming the activation function is identity function, then the residual block can be expressed as:
+
+$$
+\mathbf { x } _ { 2 } = \mathbf { W } _ { 1 } \mathbf { x } _ { 1 } ; ~ f = \mathbf { W } _ { 2 } \mathbf { x } _ { 2 } + \mathbf { x } _ { 1 }
+$$
+
+Whereas, the residual block has its equivalent fully connected format, i.e.:
+
+$$
+\begin{array} { r l } & { \mathbf { W } _ { 1 } ^ { * } = \left[ \begin{array} { l } { \mathbf { W } _ { 1 } } \\ { \mathbf { I } } \end{array} \right] ; ~ \mathbf { W } _ { 2 } ^ { * } = [ \mathbf { W } _ { 2 } \quad \mathbf { I } ] } \\ & { ~ \mathbf { x } _ { 2 } ^ { * } = \mathbf { W } _ { 1 } ^ { * } \mathbf { x } _ { 1 } = \left[ \begin{array} { l } { \mathbf { W } _ { 1 } \mathbf { x } _ { 1 } } \\ { \mathbf { x } _ { 1 } } \end{array} \right] } \\ & { ~ \boldsymbol { f } = \mathbf { W } _ { 2 } ^ { * } \mathbf { W } _ { 1 } ^ { * } \mathbf { x } _ { 1 } } \end{array}
+$$
+
+From the perspective of a recursive reconstruction, $f$ is clear, so after the reconstruction of $\mathbf { X } _ { 2 }$ , the input of this block $\mathbf { X } _ { 1 }$ can be directly calculated by subtracting ${ \bf W } _ { \mathrm { 2 } } { \bf x } _ { \mathrm { 2 } }$ from $f$ as shown in Equation 29. Back to the Equation 31 that means only $\mathbf { x } _ { 2 } ^ { * }$ needs to be recovered. Similar to the analysis for one layer, in terms of the reconstruction of $\mathbf { x } _ { 2 } ^ { * }$ , the number of weight constraints is $| f |$ and the number of gradient constraints is $| \mathbf { W } _ { 2 } |$ . On top of that the upper part and lower part of $\mathbf { x } _ { 2 } ^ { * }$ are related, which actually represents the virtual constraints from the first layer. Taking these into account, there are $| \mathbf { W } _ { 2 } | + | f | + | \mathbf { x } _ { 2 } |$ constraints for the reconstruction of $\mathbf { x } _ { 2 } ^ { * }$ . However, $\mathbf { x } _ { 2 } ^ { * }$ is also augmented compared with $\mathbf { X } _ { 2 }$ and the number of entries is $| \mathbf { x } _ { 1 } | + | \mathbf { x } _ { 2 } |$ . To conclude, if $| f | + | \mathbf { \bar { W } } _ { 2 } | < | \mathbf { x } _ { 1 } |$ the residual block is locally rank-deficient, otherwise it is full rank. Seemingly, the constraints of the last layer have been used to reconstruct the input of the residual block due to the skip connection2. This is an interesting trait, because the skip connection is able to make the rank-deficient layers like bottlenecks again full rank, as shown in Figure 6. It is worth noticing that the bottlenecks have been commonly used for residual blocks. Further, downsampling residual blocks also have this characteristic of rank condition, as the gradient constraints in the last layer are much more than the first layer due to the number of channels.
+
+![](images/69865edfc6cf046cf3e4015a94e9b13274313233517281f3c5bdf2292ba16c20.jpg)  
+Figure 6: Comparison of optimization-based gradient attacks over architectures with or without the skip connection. The width of blue bars represents the number of features at each layer. The first row shows that there is no impact on the reconstruction if the skip connection skips one layer. The second row shows if the skip connection skips a bottleneck block, which is rank-deficient, the resulting network can still be full rank and enable full recovery of the data. The third row shows the reconstructions of two full-rank architectures. Since the skip connection aids in the optimization process, the quality of its reconstruction is marginally better.
+
+# E IMPROVING DEFENDABILITY OF RESNET101
+
+We also apply the rank analysis to ResNet101 and try to improve its defendability. However, we find that this network is too redundant. It is not possible to decrease the RA-i by cutting a single skip connection as was done in Figure 4. Nevertheless, we devise two variants, the first of which cuts the skip connection of the third residual block and generates a layer that is locally rank-deficient and requires a large number of virtual constraints. Additionally, we devise a second variant, which cuts the skip connection of the first residual block and reduces the redundancy of two layers. The accuracy and reconstruction error of these networks can be found in Table 4.
+
+<table><tr><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>RA-i</td><td rowspan=1 colspan=1>Accuracy on val.</td><td rowspan=1 colspan=1>MSE of reconstructions</td></tr><tr><td rowspan=1 colspan=1>ResNet101</td><td rowspan=1 colspan=1>-1.4×104</td><td rowspan=1 colspan=1>91.04%</td><td rowspan=1 colspan=1>0.96 ± 0.091</td></tr><tr><td rowspan=1 colspan=1>Variant 1</td><td rowspan=1 colspan=1>-1.4 × 104</td><td rowspan=1 colspan=1>90.36%</td><td rowspan=1 colspan=1>1.8 ± 0.14</td></tr><tr><td rowspan=1 colspan=1>Variant 2</td><td rowspan=1 colspan=1>-1.4×104</td><td rowspan=1 colspan=1>90.16%</td><td rowspan=1 colspan=1>1.3 ± 0.14</td></tr></table>
+
+Table 4: Training 200 epochs on CIFAR10 and saving the model with the best performance on the validation set, ResNet101 with base width 16 and its two variants achieve similar accuracy on the classification task. The two modified variants which are designed to introduce rank deficiency perform almost as well as the original, but better protect the training data. We conduct a gradient attack with the state-of-the-art approach proposed by Geiping et al. (2020). MSE of the reconstructions of the two rank-deficient variants is significantly higher, which indicates that for deep networks, we can also improve the defendability by decreasing local redundancy or even making layers locally rank-deficient.
+
+# F R-GAP IN THE BATCH SETTING RETURNS A LINEAR COMBINATION OF TRAINING IMAGES
+
+It can be verified straightforwardly that R-GAP in the batch setting will return a linear combination of the training data. This is due to the fact that in the batch setting the gradients are simply accumulated. The weighting coefficients of the data in this linear mixture are dependent on the various values of $\mu$ for the different training data (see Figure 1). Figures 7 and 8 illustrate the results vs. batch DLG (Zhu et al., 2019) on examples from MNIST.
+
+![](images/088a93806030b47b5452de42caa498005871111c80b463569c11c7b49f36bf2a.jpg)  
+Figure 7: Reconstruction over a FCN3 network with batch-size equal to 2. For FCN network, RGAP is able to reconstruct sort of a linear combination of the input images. DLG will also works perfectly on such architecture.
+
+# G ADDING NOISE TO THE GRADIENTS
+
+The effect on reconstruction of adding noise to the gradients is illustrated in Figure 9.
+
+![](images/1f289429ba363de7501e6c13d495ba690273da26f4771f8a19774b8db699df6e.jpg)  
+Figure 8: Reconstruction over a FCN3 network with batch-size equal to 5. Sometimes DLG will converge to a image similar to the one reconstructed by the R-GAP.
+
+![](images/68ec11a96f955133e7540ed78bb4eac80891244e2fc33ae7357cdd38cef3dde2.jpg)  
+Figure 9: In terms of least square as what we have used for R-GAP, overall increasing the width of the network will involve more constraints and hence enhance the denoising ability of the gradient attack. For O-GAP this also means a more stable optimization process and less noise in the reconstructed image, which has been empirically proven by Geiping et al. (2020). Increasing the width of every layer will definitely decrease the RA-i, so the quality of reconstruction has been improved. Whereas, increasing the width of some layers may not change RA-i of a network, since the RA-i of a network is equal to the largest RA-i among all the layers, i,e, the reconstruction will not get better. However, it is widely believed that more parameter means less secure.
+
+# H DERIVING GRADIENTS
+
+$$
+\begin{array} { r l } & { \quad _ { 1 } - \kappa _ { 4 } \kappa _ { 1 } + \kappa _ { 1 } ^ { 2 } } \\ & { \quad _ { 2 } + \kappa _ { 2 } ^ { 3 } - \kappa _ { 3 } ^ { 3 } } \\ & { \quad _ { 3 } - \kappa _ { 1 } ^ { 3 } - \kappa _ { 2 } ^ { 3 } } \\ & { \quad _ { 4 } - \kappa _ { 3 } ^ { 3 } - \kappa _ { 3 } ^ { 3 } \kappa _ { 1 } ^ { 3 } \kappa _ { 2 } ^ { 3 } \kappa _ { 3 } ^ { 3 } \kappa _ { 1 } ^ { 3 } \kappa _ { 1 } ^ { 3 } \kappa _ { 2 } ^ { 3 } } \\ & { \quad _ { 4 } - \kappa _ { 1 } ^ { 3 } \kappa _ { 2 } ^ { 3 } \kappa _ { 3 } ^ { 3 } \kappa _ { 1 } ^ { 3 } \kappa _ { 1 } ^ { 3 } \kappa _ { 1 } ^ { 3 } \kappa _ { 1 } ^ { 3 } \kappa _ { 1 } ^ { 3 } \kappa _ { 1 } ^ { 3 } \kappa _ { 1 } ^ { 3 } \kappa _ { 1 } ^ { 3 } \kappa _ { 1 } ^ { 3 } \kappa _ { 1 } ^ { 3 } } \\ & { \quad _ { 4 } - \kappa _ { 2 } ^ { 3 } \kappa _ { 3 } ^ { 3 } \kappa _ { 1 } ^ { 3 } \kappa _ { 1 } ^ { 3 } \kappa _ { 1 } ^ { 3 } \kappa _ { 1 } ^ { 3 } \kappa _ { 1 } ^ { 3 } \kappa _ { 1 } ^ { 3 } \kappa _ { 1 } ^ { 3 } \kappa _ { 1 } ^ { 3 } \kappa _ { 1 } ^ { 3 } \kappa _ { 1 } ^ { 3 } \kappa _ { 1 } ^ { 3 } \kappa _ { 1 } ^ { 3 } \kappa _ { 1 } ^ { 3 } } \\ & { \quad _ { 4 } - \kappa _ { 4 } ^ { 3 } \kappa _ { 2 } ^ { 3 } \kappa _ { 1 } ^ { 3 } \kappa _ { 1 } ^ { 3 } \kappa _ { 1 } ^ { 3 } \kappa _ { 1 } ^ { 3 } \kappa _ { 1 } ^ { 3 } \kappa _ { 1 } ^ { 3 } \kappa _ { 1 } ^ { 3 } \kappa _ { 1 } ^ { 3 } \kappa _ { 1 } ^ { 3 } \kappa _ { 1 } ^ { 3 } \kappa _ { 1 } ^ { 3 } \kappa _ { 1 } ^ { 3 } \kappa _ { 1 } ^ { 3 } \kappa _ { 1 } ^ { 3 } } \\ &  \quad \partial _ { t } \kappa _ { 1 } ^ { 3 } - \kappa _ { 1 } ^ { 3 } \kappa _ { 1 } ^  \end{array}
+$$

parse/train/dOcQK-f4byz/dOcQK-f4byz.md

@@ -0,0 +1,374 @@
+# TEACHING TEMPORAL LOGICS TO NEURAL NETWORKS∗
+
+Christopher Hahn CISPA Helmholtz Center for Information Security Saarbrucken, 66123 Saarland, Germany ¨ christopher.hahn@cispa.de
+
+Frederik Schmitt CISPA Helmholtz Center for Information Security Saarbrucken, 66123 Saarland, Germany ¨ frederik.schmitt@cispa.de
+
+Jens U. Kreber   
+Saarland University   
+Saarbrucken, 66123 Saarland, Germany ¨ kreber@react.uni-saarland.de
+
+Markus N. Rabe Google Research Mountain View, CA, USA mrabe@google.com
+
+Bernd Finkbeiner   
+CISPA Helmholtz Center for Information Security   
+Saarbrucken, 66123 Saarland, Germany ¨   
+finkbeiner@cispa.de
+
+# ABSTRACT
+
+We study two fundamental questions in neuro-symbolic computing: can deep learning tackle challenging problems in logics end-to-end, and can neural networks learn the semantics of logics. In this work we focus on linear-time temporal logic (LTL), as it is widely used in verification. We train a Transformer on the problem to directly predict a solution, i.e. a trace, to a given LTL formula. The training data is generated with classical solvers, which, however, only provide one of many possible solutions to each formula. We demonstrate that it is sufficient to train on those particular solutions to formulas, and that Transformers can predict solutions even to formulas from benchmarks from the literature on which the classical solver timed out. Transformers also generalize to the semantics of the logics: while they often deviate from the solutions found by the classical solvers, they still predict correct solutions to most formulas.
+
+# 1 INTRODUCTION
+
+Machine learning has revolutionized several areas of computer science, such as image recognition (He et al., 2015), face recognition (Taigman et al., 2014), translation (Wu et al., 2016), and board games (Moravc´ık et al., 2017; Silver et al., 2017). For complex tasks that involve symbolic reasoning, however, deep learning techniques are still considered as insufficient. Applications of deep learning in logical reasoning problems have therefore focused on sub-problems within larger logical frameworks, such as computing heuristics in solvers (Lederman et al., 2020; Balunovic et al., 2018; Selsam & Bjørner, 2019) or predicting individual proof steps (Loos et al., 2017; Gauthier et al., 2018; Bansal et al., 2019; Huang et al., 2018). Recently, however, the assumption that deep learning is not yet ready to tackle hard logical questions was drawn into question. Lample & Charton (2020) demonstrated that Transformer models (Vaswani et al., 2017) perform surprisingly well on symbolic integration, Rabe et al. (2020) demonstrated that self-supervised training leads to mathematical reasoning abilities, and Brown et al. (2020) demonstrated that large-enough language models learn basic arithmetic despite being trained on mostly natural language sources.
+
+This poses the question if other problems that are thought to require symbolic reasoning lend themselves to a direct learning approach. We study the application of Transformer models to challenging logical problems in verification. We thus consider linear-time temporal logic (LTL) (Pnueli, 1977), which is widely used in the academic verification community (Dwyer et al., 1998; Li et al., 2013; Duret-Lutz et al., 2016; Rozier & Vardi, 2007; Schuppan & Darmawan, 2011; Li et al., 2013; 2014; Schwendimann, 1998) and is the basis for industrial hardware specification languages like the IEEE standard PSL (IEEE-Commission et al., 2005). LTL specifies infinite sequences and is typically used to describe system behaviors. For example, LTL can specify that some proposition $P$ must hold at every point in time $( \sqsubseteq P )$ or that $P$ must hold at some future point of time $( \diamondsuit P )$ . By combining these operators, one can specify that $P$ must occur infinitely often $( \bigtriangledown \bigcirc P )$ .
+
+![](images/301c79ae99306bb6a4dc1e4abba53793ed59f9631a3c837ea4b8c111578b7338.jpg)  
+Figure 1: Performance of our best models trained on practical pattern formulas. The $\mathbf { X }$ -axis shows the formula size. Syntactic accuracy, i.e., where the Transformer agrees with the generator are displayed in dark green. Instances where the Transformer deviates from the generators output but still provides correct output are displayed in light green; incorrect predictions in orange.
+
+In this work, we apply a direct learning approach to the fundamental problem of LTL to find a satisfying trace to a formula. In applications, solutions to LTL formulas can represent (counter) examples for a specified system behavior, and over the last decades, generations of advanced algorithms have been developed to solve this question automatically. We start from the standard benchmark distribution of LTL formulas, consisting of conjunctions of patterns typically encountered in practice (Dwyer et al., 1998). We then use classical algorithms, notably spot by Duret-Lutz et al. (2016), that implement a competitive classical algorithm, to generate solutions to formulas from this distribution and train a Transformer model to predict these solutions directly.
+
+Relatively small Transformers perform very well on this task and we predict correct solutions to $9 6 . 8 \%$ of the formulas from a held-out test set (see Figure 1). Impressive enough, Transformers hold up pretty well and predict correct solutions in $83 \%$ of the cases, even when we focus on formulas on which spot timed out. This means that, already today, direct machine learning approaches may be useful to augment classical algorithms in logical reasoning tasks.
+
+We also study two generalization properties of the Transformer architecture, important to logical problems: We present detailed analyses on the generalization to longer formulas. It turns out that transformers trained with tree-positional encodings (Shiv & Quirk, 2019) generalize to much longer formulas than they were trained on, while Transformers trained with the standard positional encoding (as expected) do not generalize to longer formulas. The second generalization property studied here is the question whether Transformers learn to imitate the generator of the training data, or whether they learn to solve the formulas according to the semantics of the logics. This is possible, as for most formulas there are many possible satisfying traces. In Figure 1 we highlight the fact that our models often predicted traces that satisfy the formulas, but predict different traces than the one found by the classical algorithm with which we generated the data. Especially when testing the models out-of-distribution we observed that almost no predicted trace equals the solution proposed by the classical solver.
+
+To demonstrate that these generalization behaviors are not specific to the benchmark set of LTL formulas, we also present experimental results on random LTL formulas. Further, we exclude that spot, the tool with which we generate example traces, is responsible for these behaviors, by repeating the experiments on propositional formulas for which we generate the solutions by SAT solvers.
+
+The remainder of this paper is structured as follows. We give an overview over related work in Section 2. We describe the problem definitions and present our data generation in Section 3. Our experimental setup is described in Section 4 and our findings in Section 5, before concluding in Section 6.
+
+# 2 RELATED WORK
+
+Datasets for mathematical reasoning. While we focus on a classical task from verification, other works have studied datasets derived from automated theorem provers (Blanchette et al., 2016; Loos et al., 2017; Gauthier et al., 2018), interactive theorem provers (Kaliszyk et al., 2017; Bansal et al., 2019; Huang et al., 2018; Yang & Deng, 2019; Polu & Sutskever, 2020; Wu et al., 2020; Li et al., 2020; Lee et al., 2020; Urban & Jakubuv, 2020; Rabe et al., 2020), symbolic mathematics (Lample ˚ & Charton, 2020), and mathematical problems in natural language (Saxton et al., 2019; Schlag et al., 2019). Probably the closest work to this paper are the applications of Transformers to directly solve differential equations (Lample & Charton, 2020) and directly predict missing assumptions and types of formal mathematical statements (Rabe et al., 2020). We focus on a different problem domain, verification, and demonstrate that Transformers are roughly competitive with classical algorithms in that domain on their dataset. Learning has been applied to mathematics long before the rise of deep learning. Earlier works focused on ranking premises or clauses Cairns (2004); Urban (2004; 2007); Urban et al. (2008); Meng & Paulson (2009); Schulz (2013); Kaliszyk & Urban (2014).
+
+Neural architectures for logical reasoning. (Paliwal et al., 2020) demonstrate significant improvements in theorem proving through the use of graph neural networks to represent higher-order logic terms. Selsam et al. (2019) presented NeuroSAT, a graph neural network (Scarselli et al., 2008; Li et al., 2017; Gilmer et al., 2017; Wu et al., 2019) for solving the propositional satisfiability problem. In contrast, we apply a generic sequence-to-sequence model to predict the solutions to formulas, not only whether there is a solution. This allows us to apply the approach to a wider set of logics (logics without a CNF). A simplified NeuroSAT architecture was trained for unsat-core predictions (Selsam & Bjørner, 2019). Lederman et al. (2020) have used graph neural networks on CNF to learn better heuristics for a 2QBF solver. Evans et al. (2018) study the problem of logical entailment in propositional logic using tree-RNNs. Entailment is a subproblem of satisfiability and (besides being a classification problem) could be encoded in the same form as our propositional formulas. The formulas considered in their dataset are much smaller than in this work.
+
+Language models applied to programs. Transformers have also been applied to programs for tasks such as summarizing code (Fernandes et al., 2018) or variable naming and misuse (Hellendoorn et al., 2020). Other works focused on recurrent neural networks or graph neural networks for code analysis, e.g. (Piech et al., 2015; Gupta et al., 2017; Bhatia et al., 2018; Wang et al., 2018; Allamanis et al., 2017). Another area in the intersection of formal methods and machine learning is the verification of neural networks (Seshia & Sadigh, 2016; Seshia et al., 2018; Singh et al., 2019; Gehr et al., 2018; Huang et al., 2017; Dreossi et al., 2019).
+
+# 3 DATASETS
+
+To demonstrate the generalization properties of the Transformer on logical tasks, we generated several datasets in three different fashions. We will describe the underlying logical problems and our data generation in the following.
+
+# 3.1 TRACE GENERATION FOR LINEAR-TIME TEMPORAL LOGIC
+
+Linear-time temporal logic (LTL, Pnueli, 1977) combines propositional connectives with temporal operators such as the Next operator $\bigcirc$ and the Until operator $\mathcal { U }$ . $\bigcirc \varphi$ means that $\varphi$ holds in the next position of a sequence; $\varphi _ { 1 } \mathcal { U } \varphi _ { 2 }$ means that $\varphi _ { 1 }$ holds until $\varphi _ { 2 }$ holds. For example, the LTL formula $\mathsf { \bar { ( } } b \mathsf { \mathcal { U } } a ) \wedge ( c \mathsf { \mathcal { U } } \neg \bar { a } )$ states that $b$ has to hold along the trace until $a$ holds and $c$ has to hold until $a$ does not hold anymore. There also exist derived operators. For example, consider the following specification of an arbiter: $\square ( \mathrm { r e q u e s t }  \odot \mathrm { g r a n t } )$ ) states that, at every point in time $\sqsubset$ -operator), if there is a request signal, then a grant signal must follow at some future point in time ( $\bigcirc$ -operator).
+
+The full semantics and an explanation of the operators can be found in Appendix A. We consider infinite sequences, that are finitely represented in the form of a “lasso” $u v ^ { \omega }$ , where $u$ , called prefix, and $v$ , called period, are finite sequences of propositional formulas. We call such sequences (symbolic) traces. For example, the symbolic trace $( a \wedge b ) ^ { \omega }$ defines the infinite sequence where $a$ and $b$ evaluate to true on every position. Symbolic traces allow us to underspecify propositions when they do not matter. For example, the LTL formula $\bigcirc \bigcirc \sqsupset a$ is satisfied by the symbolic trace: true true $( a ) ^ { \omega }$ , which allow for any combination of propositions on the first two positions.
+
+Our datasets consist of pairs of satisfiable LTL formulas and satisfying symbolic traces generated with tools and automata constructions from the spot framework (Duret-Lutz et al., 2016). We use a compact syntax for ultimately periodic symbolic traces: Each position in the trace is separated by the delimiter “;”. True and False are represented by “1” and $ { ^ { 6 } } 0 ^ { 9 }$ , respectively. The beginning of the period $v$ is signaled by the character “ $\{ \} ^ { , , }$ and analogously its end by $\mathbf { \bar { \Sigma } } ^ { 6 6 } \mathbf { \bar { \Sigma } } ^ { 5 }$ . For example, the ultimately periodic symbolic trace denoted by $a ; a ; a ; \{ b \}$ , describes all infinite traces where on the first 3 positions $a$ must hold followed by an infinite period on which $b$ must hold on every position.
+
+Given a satisfiable LTL formula $\varphi$ , our trace generator constructs a Buchi automaton ¨ $A _ { \varphi }$ that accepts exactly the language defined by the LTL formula, i.e., $\mathcal { L } ( A _ { \varphi } ) = \mathcal { L } ( \varphi )$ . From this automaton, we construct an arbitrary accepted symbolic trace, by searching for an accepting run in $A _ { \varphi }$ .
+
+# 3.1.1 SPECIFICATION PATTERN
+
+Our main dataset is constructed from formulas following $5 5 \mathrm { L T L }$ specification patterns identified by the literature (Dwyer et al., 1998). For example, the arbiter property $( \bigcirc p _ { 0 } ) \ \bar { {  } } \ ( p _ { 1 } { \mathcal { U } } p _ { 0 } )$ , stating that if $p _ { 0 }$ is scheduled at some point in time, $p _ { 1 }$ is scheduled until this point. The largest specification pattern is of size 40 consisting of 6 atomic propositions. It has been shown that conjunctions of such patterns are challenging for LTL satisfiability tools that rely on classical methods, such as automata constructions (Li et al., 2013). They start coming to their limits when more than 8 pattern formulas are conjoined. We decided to build our dataset in a similar way from these patterns only to allow for a better comparison.
+
+We conjoined random specification patterns with randomly chosen variables (from a supply of 6 variables) until one of the following four conditions are met: 1) the formula size succeeds 126, 2) more than 8 formulas would be conjoined, 3) our automaton-based generator timed out $( > 1 s )$ while computing the solution trace, or 4) the formula would become unsatisfiable. In total, we generated 1664487 formula-trace pairs in 24 hours on 20 CPUs. While generating, approximately $4 \bar { 1 } \%$ of the instances ran into the first termination condition, $2 1 \%$ into the second, $3 7 \%$ into the third and $1 \%$ into the fourth. We split this set into an $8 0 \%$ training set, a $1 0 \%$ validation set, and a $1 0 \%$ test set. The size distribution of the dataset can be found in Appendix B.
+
+For studying how the Transformer performs on longer specification patterns, we accumulated pattern formulas where spot timed out $( > 6 0 s )$ while searching for a satisfying trace. We call this dataset LTLUnsolved254 . We capped the maximum length at 254, which is twice as large as the formulas the model saw during training. The size distribution of the generated formulas can be found in Appendix B.
+
+In the following table, we illustrate the complexity of our training dataset with two examples from the above described set LTLPattern126, where the subsequent number of the notation of our datasets denotes the maximum size of a formula’s syntax tree. The first line shows the LTL formula and the symbolic trace in mathematical notation. The second line shows the input and output representation of the Transformer (in Polish notation):
+
+<table><tr><td rowspan=1 colspan=1>LTL formula</td><td rowspan=1 colspan=1>satisfying symbolic trace</td></tr><tr><td rowspan=1 colspan=1>(a→d)&gt;-fWfw-fWfw-f(c→-cu(c&gt;-bWbW-bWbW□-b))&amp;&amp;G&gt;aFdW!fWfW!fWfG!f&gt;FcU!c&amp;cW!bWbW!bWbG!b</td><td rowspan=1 colspan=1>(-a&gt;-c∧-fV-c△d∧-f){!a&amp;!c&amp;!f|!c&amp;d&amp;!f}</td></tr><tr><td rowspan=1 colspan=1>□b&gt;-a△a→cua)△□a→□c)△(&lt;b→-bu(b&gt;-fWfW-fWfW□-f))^(&lt;a→(c^O(-aue)→O(-au(e△&lt;f)))ua)&gt;△c&gt;□(a□e→-(-e&gt;fO(-eu(-e&gt;d)))u(evc))^(□-av△(a&gt;-fWd))△□(e→□-c)&amp;&amp;&amp;&amp;&amp;&amp;&amp;G&gt;&amp;&amp;b!aFaUcaG&gt;aGc&gt;FbU!b&amp;bW!fWfW!fWfG!f&gt;FaU&gt;&amp;cXU!aeXU!a&amp;eFfaFcG&gt;&amp;aFeU!&amp;&amp;!efXU!e&amp;!edlec|G!aF&amp;aW!fdG&gt;eG!c</td><td rowspan=1 colspan=1>(-a△b∧-c∧-e∧f)(-a△-c△-e&gt;-f)(-a∧-c∧-e△f)(-a△c∧-e△-f)(-a&gt;e∧-f)ω&amp;&amp;&amp;&amp;!ab!c!ef;&amp;&amp;&amp;!a!c!e!f;&amp;&amp;&amp;!a!c!ef;&amp;&amp;&amp;!ac!e!f;{&amp;&amp;!a!e!f}</td></tr></table>
+
+# 3.1.2 RANDOM FORMULAS
+
+To show that the generalization properties of the Transformer are not specific to our data generation, we also generated a dataset of random formulas. Our dataset of random formulas consist of 1 million generated formulas and their solutions, i.e., a satisfying symbolic trace. The number of different propositions is fixed to 5. Each dataset is split into a training set of $8 0 0 \mathrm { K }$ formulas, a validation set of 100K formulas, and a test set of 100K formulas. All datasets are uniformly distributed in size, apart from the lower-sized end due to the limited number of unique small formulas. The formula and trace distribution of the dataset LTLRandom35, as well as three randomly drawn example instances can be found in Appendix B. Note that we filtered out examples with traces larger than 62 (less than $0 . 0 5 \%$ of the original set).
+
+To generate the formulas, we used the randltl tool of the spot framework, which builds unique formulas in a specified size interval, following a supplied node probability distribution. During the building process, the actual distribution occasionally differs from the given distribution in order to meet the size constraints, e.g., by masking out all binary operators. The distribution between all $k$ -ary nodes always remains the same. To furthermore achieve a (quasi) uniform distribution in size, we subsequently filtered the generated formulas. Our node distribution puts equal weight on all operators $\neg , \land , \bigcirc$ and $\mathcal { U }$ . Constants True and False are allowed with 2.5 times less probability than propositions.
+
+# 3.2 ASSIGNMENT GENERATION FOR PROPOSITIONAL LOGIC
+
+To show that the generalization of the Transformer to the semantics of logics is not a unique attribute of LTL, we also generated a dataset for propositional logic (SAT). A propositional formula consists of Boolean operators $\wedge$ (and), $\vee$ (or), $\neg$ (not), and variables also called literals or propositions. We consider the derived operators $\varphi _ { 1 }  \varphi _ { 2 } \equiv \lnot \varphi _ { 1 } \lor \varphi _ { 2 }$ (implication), $\varphi _ { 1 }  \varphi _ { 2 } \equiv ( \varphi _ { 1 }  \varphi _ { 2 } ) \wedge ( \varphi _ { 2 } $ $\varphi _ { 1 }$ ) (equivalence), and $\varphi _ { 1 } \oplus \varphi _ { 2 } \equiv \lnot ( \varphi _ { 1 }  \varphi _ { 2 } )$ (xor). Given a propositional Boolean formula $\varphi$ , the satisfiability problem asks if there exists a Boolean assignment $\Pi : \mathcal { V } \mapsto \mathbb { B }$ for every literal in $\varphi$ such that $\varphi$ evaluates to true. For example, consider the following propositional formula, given in conjunctive normal form (CNF): $( x _ { 1 } \lor x _ { 2 } \lor \neg x _ { 3 } ) \land ( \neg x _ { 1 } \lor x _ { 3 } )$ . A possible satisfying assignment for this formula would be $\{ ( x _ { 1 } , t r u e ) , ( x _ { 2 } , f a l s e ) , ( x _ { 3 } , t r u e ) \} .$ . We allow a satisfying assignment to be partial, i.e., if the truth value of a propositions can be arbitrary, it will be omitted. For example, $\{ ( x _ { 1 } , t r u e ) , ( x _ { 3 } , t r u e ) \}$ would be a satisfying partial assignment for the formula above. We define a minimal unsatisfiable core of an unsatisfiable formula $\varphi$ , given in CNF, as an unsatisfiable subset of clauses $\varphi _ { c o r e }$ of $\varphi$ , such that every proper subset of clauses of $\varphi _ { c o r e }$ is still satisfiable.
+
+We, again, generated 1 million random formulas. For the generation of propositional formulas, the specified node distribution puts equal weight on $\wedge , \vee$ , and $\neg$ operators and half as much weight on the derived operators and $\oplus$ individually. In contrast to previous work (Selsam et al., 2019), which is restricted to formulas in CNF, we allow an arbitrary formula structure and derived operators.
+
+A satisfying assignment is represented as an alternating sequence of propositions and truth values, given as 0 and 1. The sequence $a 0 b 1 c 0$ , for example, represents the partial assignment $\{ ( a , f a l s e ) , ( b , t r u e ) , ( c , f a l s e ) \}$ , meaning that the truth values of propositions $d$ and $e$ can be chosen arbitrarily (note that we allow five propositions). We used pyaiger (Vazquez-Chanlatte, 2018), which builds on Glucose 4 (Audemard & Simon, 2018) as its underlying SAT solver. We construct the partial assignments with a standard method in SAT solving: We query the SAT solver for a minimal unsatisfiable core of the negation of the formula. To give the interested reader an idea of the level of difficulty of the dataset, the following table shows three random examples from our training set PropRandom35. The first line shows the formula and the assignment in mathematical notation. The second line shows the syntactic representation (in Polish notation):
+
+<table><tr><td rowspan=1 colspan=1>propositional formula</td><td rowspan=1 colspan=1>satisfying partial assignment</td></tr><tr><td rowspan=1 colspan=1>（（d△-e）∧(-aV-e)）←→（（-④(-b↔-e)）v((e④(b^d))④-(-cv(-a←e))))&lt;-&gt;&amp;&amp;d!e|!a!e|xor!b&lt;-&gt;!b!exorxore&amp;bd!|!c&lt;-&gt;!ae</td><td rowspan=1 colspan=1>{(a,0),(b,0)，(c,1),(d,1),(e,0))a0b0cldle0</td></tr><tr><td rowspan=1 colspan=1>(cVe)v(-a&gt;-b)Ilce&lt;-&gt;!a!b</td><td rowspan=1 colspan=1>{c,1)}c1</td></tr><tr><td rowspan=1 colspan=1>-((bve)④((-av(-d&gt;-e))v(-bν(((-a&gt;b)&gt;-b)&gt;d))))!xor!bell!a&lt;-&gt;!d!e!I!b&amp;&amp;&amp;!ab!b!d</td><td rowspan=1 colspan=1>{(d,1)，(e,1)}dle1</td></tr></table>
+
+![](images/fdb9dc311abf6b49d3346e87fc32c0b3886ed4d43286bb4853abef7d9b063e0d.jpg)  
+Figure 2: Overview of our main experimental results: the performance of our best performing models on our different datasets. The percentage of a dark green bar refers to the syntactic accuracy, the percentage of a light green bar to the semantic accuracy without the syntactic accuracy, and the incorrect predictions are visualized in orange.
+
+To test the Transformer on even more challenging formulas, we constructed a dataset of CNF formulas using the generation script of Selsam et al. (2019) from their publicly available implementation. A random CNF formula is built by adding clauses until the addition of a further clause would lead to an unsatisfiable formula. We used the parameters $p _ { g e o } = 0 . 9$ and $p _ { k 2 } = 0 . 7 5$ to generate formulas that contain up to 15 variables and have a maximum size of 250. We call this dataset PropCNF 250.
+
+# 4 EXPERIMENTAL SETUP
+
+We have implemented the Transformer architecture (Vaswani et al., 2017). Our implementation processes the input and output sequences token-by-token. We trained on a single GPU (NVIDIA P100 or V100). All training has been done with a dropout rate of 0.1 and early stopping on the validation set. Note that the embedding size will automatically be floored to be divisible by the number of attention heads. The training of the best models took up to 50 hours. For the output decoding, we utilized a beam search (Wu et al., 2016), with a beam size of 3 and an $\alpha$ of 1.
+
+Since the solution of a logical formula is not necessarily unique, we use two different measures of accuracy to evaluate the generalization to the semantics of the logics: we distinguish between the syntactic accuracy, i.e., the percentage where the Transformers prediction syntactically matches the output of our generator and the semantic accuracy, i.e., the percentage where the Transformer produced a different solution. We also differentiate between incorrect predictions and syntactically invalid outputs which, in fact, happens only in $0 . 1 \%$ of the cases in LTLUnsolved254 .
+
+In general, our best performing models used 8 layers, 8 attention heads, and an FC size of 1024. We used a batch size of 400 and trained for $4 5 0 K$ steps (130 epochs) for our specification pattern dataset, and a batch size of 768 and trained for $5 0 K$ steps (48 epochs) for our random formula dataset. A hyperparameter study can be found in Appendix C.
+
+# 5 EXPERIMENTAL RESULTS
+
+In this section, we describe our experimental results. First, we show that a Transformer can indeed solve the task of providing a solution, i.e., a trace for a linear-time temporal logical (LTL) formula. For this, we describe the results from training on the dataset LTLPattern126 of specification patterns that are commonly used in the context of verification. Secondly, we show two generalization properties that the Transformer evinces on logic reasoning tasks: 1) the generalization to larger formulas (even so large that our data generator timed out) and 2) the generalization to the semantics of the logic. We strengthen this observation by considering a different dataset of random LTL formulas. Thirdly, we provide results for a model trained on a different logic and with a different data generator. We thereby demonstrate that the generalization behaviors of the Transformer are not specific to LTL and the LTL solver implemented with spot that we used to generate the data. An overview of our training results is displayed in Figure 2.
+
+![](images/259e39d68cfc075f12cd17aab8094a0d4b8f12fbb027b4d69c70ab5cd9828641.jpg)  
+Figure 3: Predictions of our best performing model, trained on LTLUnsolved254 , on 5704 specification patterns for which spot timed out $( > 6 0 s )$ . Semantic accuracy is displayed in green; incorrect traces in orange; syntactically invalid traces in red.
+
+5.1 SOLVING LINEAR-TIME TEMPORAL LOGICAL FORMULAS
+
+We trained a Transformer on our specification on LTLPattern126 . Figure 1 in the introduction displays the performance of our best model on this dataset. We observed a syntactic accuracy of $6 9 . 1 \%$ and a semantic accuracy of $9 6 . 8 \%$ . With this experiment we can already deduce that it seems easier for the Transformer to learn the underlying semantics of LTL than to learn the particularities of the generator. Further we can see that as the formula length grows, the syntactic accuracy begins to drop. However, that drop is much smaller in the semantic accuracy—the model still mostly predicts correct traces for long formulas.
+
+As a challenging benchmark, we tested our best performing model on LTLUnsolved254 . It predicted correct solutions in $8 3 \%$ of the cases, taking on average $1 5 s$ on a single CPU. The syntactic accuracy is $0 \%$ as there was no output produced by spot within the timeout. The results of the experiments are visualized in Figure 3. Note that this does not mean that our Transformer models necessariy outperform classical algorithms across the board. However, since verifying solutions to LTL formulas is much easier than finding solutions $( \mathbf { A C } ^ { 1 } ( \log \mathrm { D C F L } )$ vs PSPACE), this experiment shows that the predictions of a deep neural network can be a valuable extension to the verification tool box.
+
+# 5.2 GENERALIZATION PROPERTIES
+
+To prove that the generalization to the semantics is independent of the data generation, we also trained a model on a dataset of randomly generated formulas. The unshaded part of Figure 4 displays the performance of our best model on the LTLRandom35 dataset. The Transformers were solely trained on formulas of size less or equal to 35. We observe that in this range the exact syntactic accuracy decreases when the formulas grow in size. The semantic accuracy, however, stays, again, high. The model achieves a syntactic accuracy of $8 3 . 8 \%$ and a semantic accuracy of ${ \dot { 9 } } 8 . 5 \%$ on LTLRandom35, i.e., in $1 4 . 7 \%$ of the cases, the Transformer deviates from our automaton-based data generator. The evolution of the syntactic and the semantic accuracy during training can be found in Appendix D.
+
+To show that the generalization to larger formulas is independent from the data generation method, we also tested how well the Transformer generalizes to randomly generated LTL formulas of a size it has never seen before. We used our model trained on LTLRandom35 and observed the performance on LTLRandom50. The model preserves the semantic generalization, displayed in the shaded part of Figure 4. It outputs exact syntactic matches in $6 7 . 6 \%$ of the cases and achieves a semantic accuracy of $9 2 . 2 \%$ . For the generalization to larger formulas we utilized a positional encoding based on the tree representation of the formula (Shiv & Quirk, 2019). When using the standard positional encoding instead, the accuracy drops, as expected, significantly. A visualization of this experiments can be found in Appendix E.
+
+In a further experiment, we tested the out-of-distribution (OOD) generalization of the Transformer on the trace generation task. We generated a new dataset LTLRandom126 to match the formula sizes and the vocabulary of LTLPattern126. A model trained on LTLRandom126 achieves a semantic accuracy of $2 4 . 7 \%$ (and a syntactic accuracy of only $1 . 0 \%$ ) when tested on LTLPattern126. Vice versa, a model trained on LTLPattern126 achieves a semantic accuracy of $3 8 . 5 \%$ (and a semantic accuracy of only $0 . 5 \%$ ) when tested on LTLRandom126. Testing the models OOD increases the gap between syntactic and semantic correctness dramatically. This underlines that the models learned the nature of the LTL semantics rather than the generator process. Note that the two distributions are very different.
+
+Following these observations, we also tested the performance of our models on other patterns from the literature. We observe a higher semantic accuracy for our model trained on random formulas and a higher gap between semantic and syntactic accuracy for our model trained on pattern formulas:
+
+<table><tr><td>Patterns</td><td>Number of Patterns</td><td>Trained on</td><td>Syn. Acc.</td><td>Sem. Acc.</td></tr><tr><td>dac (Dwyer et al., 1998) eh (Etessami &amp; Holzmann,2000) hkrss (Holeek et al., 2004)</td><td>55 11 49</td><td>LTLRandom126 LTLRandom126 LTLRandom126</td><td>49.1% 81.8% 71.4%</td><td>81.8% 90.9% 83.7%</td></tr><tr><td>p (Pelanek,2007) eh (Etessami &amp; Holzmann,2000) hkrss (Holecek et al.,2004) p (Pelanek,2007)</td><td>20 11 49 20</td><td>LTLRandom126 LTLPattern126 LTLPattern126 LTLPattern126</td><td>65.0% 0.0% 14.3% 10.0%</td><td>90.0% 36.4% 49.0% 60.0%</td></tr></table>
+
+In a last experiment on LTL, we tested the performance of our models on handcrafted formulas. We observed that formulas with multiple until statements that describe overlapping intervals were the most challenging. This is no surprise as these formulas are the source of PSPACE-hardness of LTL.
+
+$$
+\begin{array} { c c } { { \begin{array} { r l } { - a \mathcal { U } b \wedge a \mathcal { U } \neg b } \end{array} } } & { { \begin{array} { r l } { ( a \wedge \neg b ) ( b ) ( t r u e ) ^ { \omega } } } & { { } } \\ { \& \mathrm { a : b : b : \left\{ 1 \right\} } } \end{array} }  \end{array}
+$$
+
+While the above formula can be solved by most models, when scaling this formula to four overlapping until intervals, all of our models fail: For example, a model trained on LTLRandom35 predicted the trace $( a \wedge b \wedge c ) ( a \wedge \neg b \wedge \neg c ) ( b \wedge c ) ( t r u e ) ^ { \omega }$ , which does not satisfy the LTL formula.
+
+<table><tr><td>(aub^c) ^ (au-b∧c) ^ (aub^-c) ^ (au-b^ -c) )(a∧b∧c)(a∧-b∧-c)(b∧c)(true)ä</td></tr><tr><td>&amp;&amp;&amp;Ua&amp;bcUa&amp;!bcUa&amp;b!cUa&amp;!b!c &amp;&amp;abc;&amp;&amp;a!b!c;&amp;bc;1</td></tr></table>
+
+# 5.3 PREDICTING ASSIGNMENTS FOR PROPOSITIONAL LOGIC
+
+To show that the generalization to the semantic is not a specific property of LTL, we trained a Transformer to solve the assignment generation problem for propositional logic, which is a substantially different logical problem.
+
+As a baseline for our generalization experiments on propositional logic, we trained and tested a Transformer model with the following hyperparameter on PropRandom35:   
+
+<table><tr><td>Embedding size</td><td>Layers</td><td>Heads</td><td>FC size</td><td>Batch Size Train Steps</td><td>Syn. Acc. Sem. Acc.</td></tr><tr><td>enc:128, dec:64</td><td>6</td><td>6</td><td>512 1024</td><td>50K</td><td>58.1% 96.5%</td></tr></table>
+
+We observe a striking $3 8 . 4 \%$ gap between predictions that were syntactical matches of our DPLLbased generator and correct predictions of the Transformer. Only ${ \dot { 3 } } . 5 \%$ of the time, the Transformer outputs an incorrect assignment. Note that we allow the derived operators $\oplus$ and in these experiments, which succinctly represent complicated logical constructs.
+
+The formula $b \lor \neg ( a \land d )$ occurs in our dataset PropRandom35 and its corresponding assignment is $\{ ( a , 0 ) \}$ . The Transformer, however, outputs $\mathtt { d 0 }$ , i.e., it goes with the assignment of setting $d$ to false, which is also a correct solution. A visualization of this example can be found in Appendix F. When the formulas get larger, the solutions where the Transformer differs from the DPLL algorithm accumulate. Consider, for example, the formula $\lnot b \lor ( e  b \lor c \lor \lnot d ) \lor ( c \land ( b \oplus ( a \oplus \lnot d ) ) \lnot ( \lnot c $ $d ) \wedge ( a  ( b \oplus ( b \oplus e ) ) )$ ), which is also in the dataset PropRandom35. The generator suggests the assignment $\{ ( a , 1 ) , ( c , 1 ) , ( d , 0 ) \}$ . The Transformer, however, outputs $e 0$ , i.e., the singleton assignment of setting $e$ to false, which turns out to be a (very small) solution as well.
+
+![](images/f3c2414b6c96721bb0325493dc03744acf0e638251d4a1f2fa2029c6edf4b63c.jpg)  
+Figure 4: Syntactic and semantic accuracy of our best performing model (only trained on LTLRandom35 ) on LTLRandom50 . Dark green is syntactically correct; light green is semantically correct, orange is incorrect.
+
+We achieved stable training in this experiment by setting the decoder embedding size to either 64 or even 32. Keeping the decoder embedding size at 128 led to very unstable training.
+
+We also tested whether the generalization to the semantics is preserved when the Transformer encounters propositional formulas of a larger size than it ever saw during training. We, again, utilized the tree positional encoding. When challenged with formulas of size 35 to 50, our best performing model trained on PropRandom35 achieves a syntactic accuracy of $3 5 . 8 \%$ and a semantic accuracy of $8 6 . 1 \%$ . In comparison, without the tree positional encoding, the Transformer achieves a syntactic match of only $2 9 . 0 \%$ and an overall accuracy of only $7 5 . 7 \%$ . Note that both positional encodings work equally well when not considering larger formulas.
+
+In a last experiment, we tested how the Transformer performs on more challenging propositional formulas in CNF. We thus trained a model on PropCNF 250, where it achieved a semantic accuracy of $6 5 . 1 \%$ and a syntactic accuracy of $5 6 . 6 \%$ . We observe a slightly lower gap compared to our LTL experiments. The Transformer, however, still deviates even on such formulas from the generator.
+
+# 6 CONCLUSION
+
+We trained a Transformer to predict solutions to linear-time temporal logical (LTL) formulas. We observed that our trained models evince powerful generalization properties, namely, the generalization to the semantics of the logic, and the generalization to larger formulas than seen during training. We showed that these generalizations do not depend on the underlying logical problem nor on the data generator. Regarding the performance of the trained models, we observed that they can compete with classical algorithms for generating solutions to LTL formulas. We built a test set that contained only formulas that were generated out of practical verification patterns, on which even our data generator timed out. Our best performing model, although it was trained on much smaller formulas, predicts correct traces $8 3 \%$ of the time.
+
+The results of this paper suggest that deep learning can already augment combinatorial approaches in automatic verification and the broader formal methods community. With the results of this paper, we can, for example, derive novel algorithms for trace generation or satisfiability checking of LTL that first query a Transformer for trace predictions. These predictions can be checked efficiently. Classical methods can serve as a fall back or check partial solutions providing guidance to the Transformer. The potential that arises from the advent of deep learning in logical reasoning is immense. Deep learning holds the promise to empower researchers in the automated reasoning and formal methods communities to make bigger jumps in the development of new automated verification methods, but also brings new challenges, such as the acquisition of large amounts of data.
+
+# ACKNOWLEDGEMENTS
+
+We thank Christian Szegedy, Jesko Hecking-Harbusch, and Niklas Metzger for their valuable feedback on an earlier version of this paper.
+
+# REFERENCES
+
+Miltiadis Allamanis, Marc Brockschmidt, and Mahmoud Khademi. Learning to represent programs with graphs. arXiv preprint arXiv:1711.00740, 2017.
+
+Gilles Audemard and Laurent Simon. On the glucose SAT solver. Int. J. Artif. Intell. Tools, 27 (1):1840001:1–1840001:25, 2018. doi: 10.1142/S0218213018400018. URL https://doi. org/10.1142/S0218213018400018.
+
+Mislav Balunovic, Pavol Bielik, and Martin Vechev. Learning to solve smt formulas. In S. Bengio, H. Wallach, H. Larochelle, K. Grauman, N. Cesa-Bianchi, and R. Garnett (eds.), Advances in Neural Information Processing Systems 31, pp. 10317– 10328. Curran Associates, Inc., 2018. URL http://papers.nips.cc/paper/ 8233-learning-to-solve-smt-formulas.pdf.
+
+Kshitij Bansal, Sarah M Loos, Markus N Rabe, Christian Szegedy, and Stewart Wilcox. HOList: An environment for machine learning of higher-order theorem proving. In arXiv preprint arXiv:1904.03241, 2019.
+
+S. Bhatia, P. Kohli, and R. Singh. Neuro-symbolic program corrector for introductory programming assignments. In 2018 IEEE/ACM 40th International Conference on Software Engineering (ICSE), pp. 60–70, May 2018. doi: 10.1145/3180155.3180219.
+
+Jasmin Christian Blanchette, Cezary Kaliszyk, Lawrence C Paulson, and Josef Urban. Hammering towards QED. Journal of Formalized Reasoning, 9(1):101–148, 2016.
+
+Tom B. Brown, Benjamin Mann, Nick Ryder, Melanie Subbiah, Jared Kaplan, Prafulla Dhariwal, Arvind Neelakantan, Pranav Shyam, Girish Sastry, Amanda Askell, Sandhini Agarwal, Ariel Herbert-Voss, Gretchen Krueger, Tom Henighan, Rewon Child, Aditya Ramesh, Daniel M. Ziegler, Jeffrey Wu, Clemens Winter, Christopher Hesse, Mark Chen, Eric Sigler, Mateusz Litwin, Scott Gray, Benjamin Chess, Jack Clark, Christopher Berner, Sam McCandlish, Alec Radford, Ilya Sutskever, and Dario Amodei. Language models are few-shot learners. 2020.
+
+Paul Cairns. Informalising formal mathematics: Searching the mizar library with latent semantics. In International Conference on Mathematical Knowledge Management, pp. 58–72. Springer, 2004.
+
+Tommaso Dreossi, Alexandre Donze, and Sanjit A Seshia. Compositional falsification of cyber- ´ physical systems with machine learning components. Journal of Automated Reasoning, 63(4): 1031–1053, 2019.
+
+Alexandre Duret-Lutz, Alexandre Lewkowicz, Amaury Fauchille, Thibaud Michaud, Etienne Renault, and Laurent Xu. Spot 2.0—a framework for ltl and $\omega$ -automata manipulation. In International Symposium on Automated Technology for Verification and Analysis, pp. 122–129. Springer, 2016.
+
+Matthew B. Dwyer, George S. Avrunin, and James C. Corbett. Property specification patterns for finite-state verification. In Mark A. Ardis and Joanne M. Atlee (eds.), Proceedings of the Second Workshop on Formal Methods in Software Practice, March 4-5, 1998, Clearwater Beach, Florida, USA, pp. 7–15. ACM, 1998. doi: 10.1145/298595.298598. URL https://doi.org/10. 1145/298595.298598.
+
+Kousha Etessami and Gerard J. Holzmann. Optimizing buchi automata. In Catuscia Palamidessi ¨ (ed.), CONCUR 2000 - Concurrency Theory, 11th International Conference, University Park, PA, USA, August 22-25, 2000, Proceedings, volume 1877 of Lecture Notes in Computer Science, pp. 153–167. Springer, 2000. doi: 10.1007/3-540-44618-4\ 13. URL https://doi.org/10. 1007/3-540-44618-4_13.
+
+Richard Evans, David Saxton, David Amos, Pushmeet Kohli, and Edward Grefenstette. Can neural networks understand logical entailment? arXiv preprint arXiv:1802.08535, 2018.
+
+Patrick Fernandes, Miltiadis Allamanis, and Marc Brockschmidt. Structured neural summarization. arXiv preprint arXiv:1811.01824, 2018.
+
+Thibault Gauthier, Cezary Kaliszyk, and Josef Urban. Tactictoe: Learning to reason with hol4 tactics. arXiv preprint arXiv:1804.00595, 2018.
+
+Timon Gehr, Matthew Mirman, Dana Drachsler-Cohen, Petar Tsankov, Swarat Chaudhuri, and Martin Vechev. Ai2: Safety and robustness certification of neural networks with abstract interpretation. In 2018 IEEE Symposium on Security and Privacy (SP), pp. 3–18. IEEE, 2018.
+
+Justin Gilmer, Samuel S Schoenholz, Patrick F Riley, Oriol Vinyals, and George E Dahl. Neural message passing for quantum chemistry. In Proceedings of the 34th International Conference on Machine Learning-Volume 70, pp. 1263–1272. JMLR. org, 2017.
+
+Rahul Gupta, Soham Pal, Aditya Kanade, and Shirish Shevade. Deepfix: Fixing common C language errors by deep learning. In Thirty-First AAAI Conference on Artificial Intelligence, 2017.
+
+Kaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. Delving deep into rectifiers: Surpassing human-level performance on imagenet classification. In 2015 IEEE International Conference on Computer Vision, ICCV 2015, Santiago, Chile, December 7-13, 2015, pp. 1026–1034, 2015. doi: 10.1109/ICCV.2015.123. URL https://doi.org/10.1109/ICCV.2015.123.
+
+Vincent J. Hellendoorn, Charles Sutton, Rishabh Singh, and Petros Maniatis. Global relational models of source code. In International Conference on Learning Representations, 2020. URL https://openreview.net/forum?id $\underline { { \underline { { \mathbf { \Pi } } } } } =$ B1lnbRNtwr.
+
+Jan Holecek, Tom ˇ a´s Kratochv ˇ ´ıla, Vojtech ˇ Reh ˇ ak, David ´ Safr ˇ anek, Pavel ´ Sime ˇ cek, et al. Verification ˇ results in liberouter project, 2004.
+
+Daniel Huang, Prafulla Dhariwal, Dawn Song, and Ilya Sutskever. Gamepad: A learning environment for theorem proving. arXiv preprint arXiv:1806.00608, 2018.
+
+Xiaowei Huang, Marta Kwiatkowska, Sen Wang, and Min Wu. Safety verification of deep neural networks. In International Conference on Computer Aided Verification, pp. 3–29. Springer, 2017.
+
+IEEE-Commission et al. Ieee standard for property specification language (psl). IEEE Std 1850- 2005, 2005.
+
+Cezary Kaliszyk and Josef Urban. Learning-assisted automated reasoning with flyspeck. Journal of Automated Reasoning, 53(2):173–213, 2014.
+
+Cezary Kaliszyk, Franc¸ois Chollet, and Christian Szegedy. HolStep: A Machine Learning Dataset for Higher-order Logic Theorem Proving. In Proceedings of International Conference on Learning Representations (ICLR), 2017.
+
+Guillaume Lample and Franc¸ois Charton. Deep learning for symbolic mathematics. In ICLR, 2020.
+
+Gil Lederman, Markus N. Rabe, Edward A. Lee, and Sanjit A. Seshia. Learning heuristics for quantified boolean formulas through deep reinforcement learning. 2020. URL http://arxiv. org/abs/1807.08058.
+
+Dennis Lee, Christian Szegedy, Markus N. Rabe, Sarah M. Loos, and Kshitij Bansal. Mathematical reasoning in latent space. 2020.
+
+Jianwen Li, Lijun Zhang, Geguang Pu, Moshe Y. Vardi, and Jifeng He. LTL satisfiability checking revisited. In Cesar S ´ anchez, Kristen Brent Venable, and Esteban Zim ´ anyi (eds.), ´ 2013 20th International Symposium on Temporal Representation and Reasoning, Pensacola, FL, USA, September 26-28, 2013, pp. 91–98. IEEE Computer Society, 2013. doi: 10.1109/TIME.2013.19. URL https://doi.org/10.1109/TIME.2013.19.
+
+Jianwen Li, Yinbo Yao, Geguang Pu, Lijun Zhang, and Jifeng He. Aalta: an ltl satisfiability checker over infinite/finite traces. In Proceedings of the 22nd ACM SIGSOFT international symposium on foundations of software engineering, pp. 731–734, 2014.
+
+Wenda Li, Lei Yu, Yuhuai Wu, and Lawrence C. Paulson. Modelling high-level mathematical reasoning in mechanised declarative proofs. arXiv preprint arXiv:2006.09265, 2020.
+
+Yaguang Li, Rose Yu, Cyrus Shahabi, and Yan Liu. Diffusion convolutional recurrent neural network: Data-driven traffic forecasting. arXiv preprint arXiv:1707.01926, 2017.
+
+Sarah Loos, Geoffrey Irving, Christian Szegedy, and Cezary Kaliszyk. Deep network guided proof search. In LPAR, 2017.
+
+Jia Meng and Lawrence C Paulson. Lightweight relevance filtering for machine-generated resolution problems. Journal of Applied Logic, 7(1):41–57, 2009.
+
+Matej Moravc´ık, Martin Schmid, Neil Burch, Viliam Lisy, Dustin Morrill, Nolan Bard, Trevor ´ Davis, Kevin Waugh, Michael Johanson, and Michael H. Bowling. Deepstack: Expert-level artificial intelligence in no-limit poker. CoRR, abs/1701.01724, 2017. URL http://arxiv. org/abs/1701.01724.
+
+Aditya Paliwal, Sarah M. Loos, Markus N. Rabe, Kshitij Bansal, and Christian Szegedy. Graph representations for higher-order logic and theorem proving. In AAAI, 2020.
+
+Radek Pelanek. BEEM: benchmarks for explicit model checkers. In Dragan Bosnacki and Stefan ´ Edelkamp (eds.), Model Checking Software, 14th International SPIN Workshop, Berlin, Germany, July 1-3, 2007, Proceedings, volume 4595 of Lecture Notes in Computer Science, pp. 263–267. Springer, 2007. doi: 10.1007/978-3-540-73370-6\ 17. URL https://doi.org/10.1007/ 978-3-540-73370-6_17.
+
+Chris Piech, Jonathan Huang, Andy Nguyen, Mike Phulsuksombati, Mehran Sahami, and Leonidas Guibas. Learning program embeddings to propagate feedback on student code. In International Conference on Machine Learning, pp. 1093–1102, 2015.
+
+Amir Pnueli. The temporal logic of programs. In 18th Annual Symposium on Foundations of Computer Science, Providence, Rhode Island, USA, 31 October - 1 November 1977, pp. 46–57, 1977. doi: 10.1109/SFCS.1977.32. URL https://doi.org/10.1109/SFCS.1977.32.
+
+Stanislas Polu and Ilya Sutskever. Generative language modeling for automated theorem proving, 2020.
+
+Markus N. Rabe, Dennis Lee, Kshitij Bansal, and Christian Szegedy. Mathematical reasoning via self-supervised skip-tree training. 2020.
+
+Kristin Y Rozier and Moshe Y Vardi. Ltl satisfiability checking. In International SPIN Workshop on Model Checking of Software, pp. 149–167. Springer, 2007.
+
+David Saxton, Edward Grefenstette, Felix Hill, and Pushmeet Kohli. Analysing mathematical reasoning abilities of neural models. CoRR, abs/1904.01557, 2019. URL http://arxiv.org/ abs/1904.01557.
+
+Franco Scarselli, Marco Gori, Ah Chung Tsoi, Markus Hagenbuchner, and Gabriele Monfardini. The graph neural network model. IEEE Transactions on Neural Networks, 20(1):61–80, 2008.
+
+Imanol Schlag, Paul Smolensky, Roland Fernandez, Nebojsa Jojic, Jurgen Schmidhuber, and Jian- ¨ feng Gao. Enhancing the transformer with explicit relational encoding for math problem solving. arXiv preprint arXiv:1910.06611, 2019.
+
+Stephan Schulz. System description: E 1.8. In International Conference on Logic for Programming Artificial Intelligence and Reasoning, pp. 735–743. Springer, 2013.
+
+Viktor Schuppan and Luthfi Darmawan. Evaluating ltl satisfiability solvers. In International Symposium on Automated Technology for Verification and Analysis, pp. 397–413. Springer, 2011.
+
+Stefan Schwendimann. A new one-pass tableau calculus for pltl. In International Conference on Automated Reasoning with Analytic Tableaux and Related Methods, pp. 277–291. Springer, 1998.
+
+Daniel Selsam and Nikolaj Bjørner. Guiding high-performance SAT solvers with unsat-core predictions. In Theory and Applications of Satisfiability Testing - SAT 2019 - 22nd International Conference, SAT 2019, Lisbon, Portugal, July 9-12, 2019, Proceedings, pp. 336– 353, 2019. doi: 10.1007/978-3-030-24258-9\ 24. URL https://doi.org/10.1007/ 978-3-030-24258-9_24.
+
+Daniel Selsam, Matthew Lamm, Benedikt Bunz, Percy Liang, Leonardo de Moura, and David L. ¨ Dill. Learning a SAT solver from single-bit supervision. In 7th International Conference on Learning Representations, ICLR 2019, New Orleans, LA, USA, May 6-9, 2019, 2019. URL https://openreview.net/forum?id $\underline { { \underline { { \mathbf { \Pi } } } } } =$ HJMC_iA5tm.
+
+Sanjit A. Seshia and Dorsa Sadigh. Towards verified artificial intelligence. CoRR, abs/1606.08514, 2016. URL http://arxiv.org/abs/1606.08514.
+
+Sanjit A Seshia, Ankush Desai, Tommaso Dreossi, Daniel J Fremont, Shromona Ghosh, Edward Kim, Sumukh Shivakumar, Marcell Vazquez-Chanlatte, and Xiangyu Yue. Formal specification for deep neural networks. In International Symposium on Automated Technology for Verification and Analysis, pp. 20–34. Springer, 2018.
+
+Vighnesh Leonardo Shiv and Chris Quirk. Novel positional encodings to enable tree-based transformers. In NeurIPS 2019, 2019. URL https://www.microsoft.com/en-us/research/publication/ novel-positional-encodings-to-enable-tree-based-transformers/.
+
+David Silver, Julian Schrittwieser, Karen Simonyan, Ioannis Antonoglou, Aja Huang, Arthur Guez, Thomas Hubert, Lucas Baker, Matthew Lai, Adrian Bolton, et al. Mastering the game of go without human knowledge. Nature, 550(7676):354–359, 2017.
+
+Gagandeep Singh, Timon Gehr, Markus Puschel, and Martin Vechev. An abstract domain for cer- ¨ tifying neural networks. Proceedings of the ACM on Programming Languages, 3(POPL):1–30, 2019.
+
+Yaniv Taigman, Ming Yang, Marc’Aurelio Ranzato, and Lior Wolf. Deepface: Closing the gap to human-level performance in face verification. In 2014 IEEE Conference on Computer Vision and Pattern Recognition, CVPR 2014, Columbus, OH, USA, June 23-28, 2014, pp. 1701–1708, 2014. doi: 10.1109/CVPR.2014.220. URL https://doi.org/10.1109/CVPR.2014.220.
+
+Josef Urban. MPTP–motivation, implementation, first experiments. Journal of Automated Reasoning, 33(3-4):319–339, 2004.
+
+Josef Urban. Malarea: a metasystem for automated reasoning in large theories. ESARLT, 257, 2007.
+
+Josef Urban and Jan Jakubuv. First neural conjecturing datasets and experiments. In ˚ Conference on Intelligent Computer Mathematics, 2020.
+
+Josef Urban, Geoff Sutcliffe, Petr Pudlak, and Ji ´ ˇr´ı Vyskocil. Malarea sg1-machine learner for auto- ˇ mated reasoning with semantic guidance. In International Joint Conference on Automated Reasoning, pp. 441–456. Springer, 2008.
+
+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 30: Annual Conference on Neural Information Processing Systems 2017, 4-9 December 2017, Long Beach, CA, USA, pp. 5998–6008, 2017. URL http: //papers.nips.cc/paper/7181-attention-is-all-you-need.
+
+Marcell Vazquez-Chanlatte. mvcisback/py-aiger, August 2018. URL https://doi.org/10. 5281/zenodo.1326224.
+
+Ke Wang, Rishabh Singh, and Zhendong Su. Dynamic neural program embedding for program repair. In ICLR, 2018.
+
+Yonghui Wu, Mike Schuster, Zhifeng Chen, Quoc V. Le, Mohammad Norouzi, Wolfgang Macherey, Maxim Krikun, Yuan Cao, Qin Gao, Klaus Macherey, Jeff Klingner, Apurva Shah, Melvin Johnson, Xiaobing Liu, Lukasz Kaiser, Stephan Gouws, Yoshikiyo Kato, Taku Kudo, Hideto Kazawa, Keith Stevens, George Kurian, Nishant Patil, Wei Wang, Cliff Young, Jason Smith, Jason Riesa, Alex Rudnick, Oriol Vinyals, Greg Corrado, Macduff Hughes, and Jeffrey Dean. Google’s neural machine translation system: Bridging the gap between human and machine translation. CoRR, abs/1609.08144, 2016. URL http://arxiv.org/abs/1609.08144.
+
+Yuhuai Wu, Albert Jiang, Jimmy Ba, and Roger Grosse. INT: An Inequality Benchmark for Evaluating Generalization in Theorem Proving. arXiv preprint arXiv:2007.02924, 2020.
+
+Zonghan Wu, Shirui Pan, Fengwen Chen, Guodong Long, Chengqi Zhang, and Philip S Yu. A comprehensive survey on graph neural networks. arXiv preprint arXiv:1901.00596, 2019.
+
+Kaiyu Yang and Jia Deng. Learning to prove theorems via interacting with proof assistants. arXiv preprint arXiv:1905.09381, 2019.
+
+# APPENDIX
+
+# A LINEAR-TIME TEMPORAL LOGIC (LTL)
+
+In this section, we provide the formal syntax and semantics of Linear-time Temporal Logic (LTL). The formal syntax of LTL is given by the following grammar:
+
+$$
+\varphi : = p \mid \neg \varphi \mid \varphi \land \varphi \mid \bigcirc \varphi \mid \varphi \mathcal { U } \varphi ,
+$$
+
+where $p \in A P$ is an atomic proposition. Let $A P$ be a set of atomic propositions. A (explicit) trace $t$ is an infinite sequence over subsets of the atomic propositions. We define the set of traces $T R : = ( 2 ^ { A P } ) ^ { \omega }$ . We use the following notation to manipulate traces: Let $t ~ \in ~ T R$ be a trace and $i \in \mathbb N$ be a natural number. With $t [ i ]$ we denote the set of propositions at $i$ -th position of $t$ . Therefore, $t [ 0 ]$ represents the starting element of the trace. Let $j \in \mathbb N$ and $j \geq i$ . Then $t [ i , j ]$ denotes the sequence $t$ [i] $t [ i + 1 ] \ldots i [ j - 1 ] \ : t [ j ]$ and $t [ i , \infty ]$ denotes the infinite suffix of $t$ starting at position $i$ .
+
+Let $p \in A P$ and $t \in T R$ . The semantics of an LTL formula is defined as the smallest relation $\vDash$ that satisfies the following conditions:
+
+$\begin{array} { r l r l } & { t = p } & & { \mathrm { i f f } \qquad p \in t [ 0 ] } \\ & { t \mathbin { | = \neg { \varphi }  } } & & { \mathrm { i f f } \qquad t \mathbin { | \neq \varphi  } } \\ & { t \mathbin { | = \varphi _ { 1 } \wedge \varphi _ { 2 } \qquad } } & & { \mathrm { i f f } \qquad t \mathbin { | = \varphi _ { 1 } \mathrm { ~ a n d ~ } t | } \mathop { | = \varphi _ { 2 }  } } \\ & { t \mathbin { | = \bigcirc \varphi  } } & & { \mathrm { i f f } \qquad t [ 1 , \infty ] \mathbin { | = \varphi  } } \\ & { t \mathbin { | = \varphi _ { 1 } \mathcal { U } \varphi _ { 2 } \qquad } } & & { \mathrm { i f f } \qquad \mathrm { t h e r e ~ e x i s t s ~ } i \ge 0 : t } \end{array}$ $i \geq 0 : t [ i , \infty ] \models \varphi _ { 2 }$ and for all $0 \le j < i$ we have $t [ j , \infty ] \ v = \varphi _ { 1 }$
+
+There are several derived operators, such as $\bigcirc \varphi \equiv t r u e l l \varphi$ and $\sqcup \varphi \equiv \lnot \bigcirc \lnot \varphi . \bigotimes \varphi$ states that $\varphi$ will eventually hold in the future and $\sqsubset \varphi$ states that $\varphi$ holds globally. Operators can be nested: $\square \bigcirc \varphi$ , for example, states that $\varphi$ has to occur infinitely often.
+
+# B SIZE DISTRIBUTION IN THE DATASETS
+
+In this section, we provide insight into the size distribution of our datasets. Figure 5 shows the size distribution of the formulas in our dataset LTLPattern126 .
+
+Figure 6 shows the size distribution of our generated formulas and their traces in the dataset LTLRandom35. Table 1 shows three randomly drawn example instances of the dataset LTLRandom35.
+
+Lastly, Figure 7 shows the size distribution of formulas in our dataset LTLUnsolved 254.
+
+![](images/0288f3e833153530fb6426c58fd2464f6de66ab52bd5d574aafb829a1fb2cf62.jpg)  
+Figure 5: Size distributions in the LTLPattern126 test set: on the $\mathbf { X }$ -axis is the size of the formulas; on the y-axis the number of formulas.
+
+![](images/3eb9ccf964e1fd9bb4b953034e79b6c10fde1a7b82c505e53ef3102135fafce9.jpg)  
+Figure 6: Size distributions in the LTLRandom35 training set: on the $\mathbf { X }$ -axis is the size of the formulas/traces; on the y-axis the number of formulas/traces.
+
+Table 1: Three random examples from LTLRandom35 training set. The first line shows the LTL formula and the symbolic trace in mathematical notation. The second line shows the syntactic representation (in Polish notation):   
+
+<table><tr><td rowspan=1 colspan=1>LTL formula</td><td rowspan=1 colspan=1>satisfying symbolic trace</td></tr><tr><td rowspan=1 colspan=1>O((du c)uOOd) ^ O(b^ -(-duc))&amp;XUUdcXXdX&amp;b!U!dc</td><td rowspan=1 colspan=1>true (b^-c^ -d) (-c^d)d(true)ω1;&amp;&amp;b!c!d;&amp;!cd;d;{1}</td></tr><tr><td rowspan=1 colspan=1>-O(Oe ^ (trueub) ^Oc)uc)!XU&amp;&amp;XeU1bXcc</td><td rowspan=1 colspan=1>true(-b^-c)(-b)w1;&amp;!b!c;{!b}</td></tr><tr><td rowspan=1 colspan=1>O-((-c∧d)uOd)X!U&amp;!cdXd</td><td rowspan=1 colspan=1>true (cV-d)(-d) (true)w1;|c!d;!d;{1}</td></tr></table>
+
+![](images/7e4454d31a8f5abd5e8264b1f163e25993d6efc0eb0d5cd785f219dab7972544.jpg)  
+Figure 7: Size distributions in the LTLUnsolved254 test set: on the $\mathbf { X }$ -axis is the size of the formulas; on the y-axis the number of formulas.
+
+# C HYPERPARAMETER ANALYSIS
+
+Table 2 shows the effect of the most significant parameters on the performance of Transformers. The performance largely benefits from an increased number of layers, with 8 yielding the best results. Increasing the number further, even with much more training time, did not result in better or even led to worse results. A slightly less important role plays the number of heads and the dimension of the intermediate fully-connected feed-forward networks (FC). While a certain FC size is important, increasing it alone will not improve results. Changing the number of heads alone has also almost no impact on performance. Increasing both simultaneously, however, will result in a small gain.
+
+Table 2: Syntactic accuracy and semantic accuracy of different Transformers, tested on LTLRandom35: Layers refer to the size of the encoder and decoder stacks; Heads refer to the number of attention heads; FC size refers to the size of the fully-connected neural networks inside the encoder and decoders.   
+
+<table><tr><td>Embedding size</td><td>Layers</td><td>Heads</td><td>FC size</td><td>Batch Size</td><td>Train Steps</td><td>Syn. Acc.</td><td>Sem. Acc.</td></tr><tr><td>128</td><td>3</td><td>4</td><td>512</td><td>512</td><td>45K</td><td>78.0%</td><td>97.1%</td></tr><tr><td>128</td><td>5</td><td>2</td><td>512</td><td>512</td><td>45K</td><td>80.4%</td><td>97.4%</td></tr><tr><td>128</td><td>5</td><td>4</td><td>256</td><td>512</td><td>45K</td><td>81.0%</td><td>97.4%</td></tr><tr><td>128</td><td>5</td><td>4</td><td>512</td><td>512</td><td>45K</td><td>82.0%</td><td>97.9%</td></tr><tr><td>128</td><td>5</td><td>4</td><td>1024</td><td>512</td><td>45K</td><td>80.3%</td><td>97.3%</td></tr><tr><td>128</td><td>5</td><td>6</td><td>1024</td><td>512</td><td>45K</td><td>81.8%</td><td>97.7%</td></tr><tr><td>128</td><td>5</td><td>8</td><td>512</td><td>512</td><td>45K</td><td>82.0%</td><td>97.8%</td></tr><tr><td>128</td><td>5</td><td>8</td><td>1024</td><td>512</td><td>45K</td><td>82.5%</td><td>97.9%</td></tr><tr><td>128</td><td>5</td><td>8</td><td>1500</td><td>512</td><td>45K</td><td>82.6%</td><td>97.8%</td></tr><tr><td>128</td><td>5</td><td>12</td><td>1024</td><td>512</td><td>45K</td><td>81.9%</td><td>97.5%</td></tr><tr><td>128</td><td>8</td><td>4</td><td>512</td><td>512</td><td>45K</td><td>83.2%</td><td>98.3%</td></tr><tr><td>128</td><td>8</td><td>8</td><td>1024</td><td>768</td><td>50K</td><td>83.8%</td><td>98.5 %</td></tr><tr><td>128</td><td>10</td><td>4</td><td>512</td><td>512</td><td>75K</td><td>82.9%</td><td>97.6%</td></tr><tr><td>256</td><td>5</td><td>4</td><td>512</td><td>512</td><td>45K</td><td>82.3%</td><td>97.9%</td></tr></table>
+
+This seems reasonable, since more heads can provide more distinct information to the subsequent processing by the fully-connected feed-forward network. Increasing the embeddings size from 128 to 256 very slightly improves the syntactic accuracy. But likewise it also degrades the semantic accuracy, so we therefore stuck with the former setting.
+
+# D ACCURACY DURING TRAINING
+
+In Figure 8 we show the evolution of both the syntactic accuracy and the semantic accuracy during the training process. Note the significant difference right from the beginning. This demonstrates the importance of a suitable performance measure when evaluating machine learning algorithms on logical reasoning tasks.
+
+![](images/abf06e6c3dba60461ef5f14a0da3e90dc543dc516389917e3a2910a39edc3228.jpg)  
+Figure 8: Syntactic accuracy (blue) and semantic accuracy (red) of our best performing model, evaluated on a subset of 5K samples of LTLRandom35 per epoch.
+
+# E DIFFERENT POSITIONAL ENCODINGS
+
+![](images/ce515aefca784f7918c53561fbbc8f07f8373bc2ed923f3d58f53f7050cf415e.jpg)  
+Figure 9: Performance of our best model (only trained on LTLRandom35) on LTLRandom50 with a standard positional encoding (top) and a tree positional encoding (bottom). The syntactic accuracy is displayed in green, the semantic accuracy in light green and the incorrect predictions in orange. The shaded area indicates the formula sizes the model was not trained on.
+
+# F HANDCRAFTED EXAMPLES
+
+![](images/ef07a34ff1bb206f4dc99481b68b544352a3ce096aa5580d8af80817cd727bff.jpg)  
+Figure 10: Self-attention of the example propositional formula $b \lor \neg ( a \land d )$ in dataset PropRandom35 (left). Encoder-decoder-attention of the example LTL formula $( b \mathcal { U } a ) \wedge ( a \mathcal { U } \neg a )$ in dataset LTLRandom35 (right).
+
+The LTL formula $( b \mathcal { U } a ) \wedge ( a \mathcal { U } \neg a )$ states that $b$ has to hold along the trace until $a$ holds and $a$ has to hold until $a$ does not hold anymore. The automaton-based generator suggests the trace $( \neg a \land$ b) $\textit { a } ( t r u e ) ^ { \omega }$ , i.e., to first satisfy the second until by immediately disallowing $a$ . The satisfaction of the first until is then postponed to the second position of trace, which forces $b$ to hold on the first position. The Transformer, however, chooses the following more general trace $a \left( \neg a \right) \left( t r u e \right) ^ { \omega }$ , by satisfying the until operators in order (see Figure 10).

parse/train/dOcQK-f4byz/dOcQK-f4byz_content_list.json

@@ -0,0 +1,2054 @@
+[
+    {
+        "type": "text",
+        "text": "TEACHING TEMPORAL LOGICS TO NEURAL NETWORKS∗ ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            98,
+            823,
+            145
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Christopher Hahn CISPA Helmholtz Center for Information Security Saarbrucken, 66123 Saarland, Germany ¨ christopher.hahn@cispa.de ",
+        "bbox": [
+            183,
+            170,
+            513,
+            226
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Frederik Schmitt CISPA Helmholtz Center for Information Security Saarbrucken, 66123 Saarland, Germany ¨ frederik.schmitt@cispa.de ",
+        "bbox": [
+            531,
+            170,
+            861,
+            226
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Jens U. Kreber   \nSaarland University   \nSaarbrucken, 66123 Saarland, Germany ¨ kreber@react.uni-saarland.de ",
+        "bbox": [
+            184,
+            247,
+            459,
+            303
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Markus N. Rabe Google Research Mountain View, CA, USA mrabe@google.com ",
+        "bbox": [
+            638,
+            247,
+            813,
+            303
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Bernd Finkbeiner   \nCISPA Helmholtz Center for Information Security   \nSaarbrucken, 66123 Saarland, Germany ¨   \nfinkbeiner@cispa.de ",
+        "bbox": [
+            183,
+            324,
+            513,
+            380
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "ABSTRACT ",
+        "text_level": 1,
+        "bbox": [
+            454,
+            416,
+            544,
+            431
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "We study two fundamental questions in neuro-symbolic computing: can deep learning tackle challenging problems in logics end-to-end, and can neural networks learn the semantics of logics. In this work we focus on linear-time temporal logic (LTL), as it is widely used in verification. We train a Transformer on the problem to directly predict a solution, i.e. a trace, to a given LTL formula. The training data is generated with classical solvers, which, however, only provide one of many possible solutions to each formula. We demonstrate that it is sufficient to train on those particular solutions to formulas, and that Transformers can predict solutions even to formulas from benchmarks from the literature on which the classical solver timed out. Transformers also generalize to the semantics of the logics: while they often deviate from the solutions found by the classical solvers, they still predict correct solutions to most formulas. ",
+        "bbox": [
+            233,
+            448,
+            764,
+            614
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 INTRODUCTION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            641,
+            336,
+            657
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Machine learning has revolutionized several areas of computer science, such as image recognition (He et al., 2015), face recognition (Taigman et al., 2014), translation (Wu et al., 2016), and board games (Moravc´ık et al., 2017; Silver et al., 2017). For complex tasks that involve symbolic reasoning, however, deep learning techniques are still considered as insufficient. Applications of deep learning in logical reasoning problems have therefore focused on sub-problems within larger logical frameworks, such as computing heuristics in solvers (Lederman et al., 2020; Balunovic et al., 2018; Selsam & Bjørner, 2019) or predicting individual proof steps (Loos et al., 2017; Gauthier et al., 2018; Bansal et al., 2019; Huang et al., 2018). Recently, however, the assumption that deep learning is not yet ready to tackle hard logical questions was drawn into question. Lample & Charton (2020) demonstrated that Transformer models (Vaswani et al., 2017) perform surprisingly well on symbolic integration, Rabe et al. (2020) demonstrated that self-supervised training leads to mathematical reasoning abilities, and Brown et al. (2020) demonstrated that large-enough language models learn basic arithmetic despite being trained on mostly natural language sources. ",
+        "bbox": [
+            174,
+            672,
+            825,
+            853
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "This poses the question if other problems that are thought to require symbolic reasoning lend themselves to a direct learning approach. We study the application of Transformer models to challenging logical problems in verification. We thus consider linear-time temporal logic (LTL) (Pnueli, 1977), which is widely used in the academic verification community (Dwyer et al., 1998; Li et al., 2013; Duret-Lutz et al., 2016; Rozier & Vardi, 2007; Schuppan & Darmawan, 2011; Li et al., 2013; 2014; Schwendimann, 1998) and is the basis for industrial hardware specification languages like the IEEE standard PSL (IEEE-Commission et al., 2005). LTL specifies infinite sequences and is typically used to describe system behaviors. For example, LTL can specify that some proposition $P$ must hold at every point in time $( \\sqsubseteq P )$ or that $P$ must hold at some future point of time $( \\diamondsuit P )$ . By combining these operators, one can specify that $P$ must occur infinitely often $( \\bigtriangledown \\bigcirc P )$ . ",
+        "bbox": [
+            176,
+            861,
+            820,
+            888
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "image",
+        "img_path": "images/301c79ae99306bb6a4dc1e4abba53793ed59f9631a3c837ea4b8c111578b7338.jpg",
+        "image_caption": [
+            "Figure 1: Performance of our best models trained on practical pattern formulas. The $\\mathbf { X }$ -axis shows the formula size. Syntactic accuracy, i.e., where the Transformer agrees with the generator are displayed in dark green. Instances where the Transformer deviates from the generators output but still provides correct output are displayed in light green; incorrect predictions in orange. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            251,
+            117,
+            735,
+            280
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            381,
+            825,
+            492
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "In this work, we apply a direct learning approach to the fundamental problem of LTL to find a satisfying trace to a formula. In applications, solutions to LTL formulas can represent (counter) examples for a specified system behavior, and over the last decades, generations of advanced algorithms have been developed to solve this question automatically. We start from the standard benchmark distribution of LTL formulas, consisting of conjunctions of patterns typically encountered in practice (Dwyer et al., 1998). We then use classical algorithms, notably spot by Duret-Lutz et al. (2016), that implement a competitive classical algorithm, to generate solutions to formulas from this distribution and train a Transformer model to predict these solutions directly. ",
+        "bbox": [
+            174,
+            498,
+            825,
+            611
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Relatively small Transformers perform very well on this task and we predict correct solutions to $9 6 . 8 \\%$ of the formulas from a held-out test set (see Figure 1). Impressive enough, Transformers hold up pretty well and predict correct solutions in $83 \\%$ of the cases, even when we focus on formulas on which spot timed out. This means that, already today, direct machine learning approaches may be useful to augment classical algorithms in logical reasoning tasks. ",
+        "bbox": [
+            174,
+            617,
+            825,
+            688
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "We also study two generalization properties of the Transformer architecture, important to logical problems: We present detailed analyses on the generalization to longer formulas. It turns out that transformers trained with tree-positional encodings (Shiv & Quirk, 2019) generalize to much longer formulas than they were trained on, while Transformers trained with the standard positional encoding (as expected) do not generalize to longer formulas. The second generalization property studied here is the question whether Transformers learn to imitate the generator of the training data, or whether they learn to solve the formulas according to the semantics of the logics. This is possible, as for most formulas there are many possible satisfying traces. In Figure 1 we highlight the fact that our models often predicted traces that satisfy the formulas, but predict different traces than the one found by the classical algorithm with which we generated the data. Especially when testing the models out-of-distribution we observed that almost no predicted trace equals the solution proposed by the classical solver. ",
+        "bbox": [
+            174,
+            694,
+            825,
+            861
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "To demonstrate that these generalization behaviors are not specific to the benchmark set of LTL formulas, we also present experimental results on random LTL formulas. Further, we exclude that spot, the tool with which we generate example traces, is responsible for these behaviors, by repeating the experiments on propositional formulas for which we generate the solutions by SAT solvers. ",
+        "bbox": [
+            174,
+            867,
+            823,
+            924
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "The remainder of this paper is structured as follows. We give an overview over related work in Section 2. We describe the problem definitions and present our data generation in Section 3. Our experimental setup is described in Section 4 and our findings in Section 5, before concluding in Section 6. ",
+        "bbox": [
+            174,
+            103,
+            825,
+            159
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "2 RELATED WORK ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            179,
+            344,
+            196
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Datasets for mathematical reasoning. While we focus on a classical task from verification, other works have studied datasets derived from automated theorem provers (Blanchette et al., 2016; Loos et al., 2017; Gauthier et al., 2018), interactive theorem provers (Kaliszyk et al., 2017; Bansal et al., 2019; Huang et al., 2018; Yang & Deng, 2019; Polu & Sutskever, 2020; Wu et al., 2020; Li et al., 2020; Lee et al., 2020; Urban & Jakubuv, 2020; Rabe et al., 2020), symbolic mathematics (Lample ˚ & Charton, 2020), and mathematical problems in natural language (Saxton et al., 2019; Schlag et al., 2019). Probably the closest work to this paper are the applications of Transformers to directly solve differential equations (Lample & Charton, 2020) and directly predict missing assumptions and types of formal mathematical statements (Rabe et al., 2020). We focus on a different problem domain, verification, and demonstrate that Transformers are roughly competitive with classical algorithms in that domain on their dataset. Learning has been applied to mathematics long before the rise of deep learning. Earlier works focused on ranking premises or clauses Cairns (2004); Urban (2004; 2007); Urban et al. (2008); Meng & Paulson (2009); Schulz (2013); Kaliszyk & Urban (2014). ",
+        "bbox": [
+            174,
+            212,
+            825,
+            392
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Neural architectures for logical reasoning. (Paliwal et al., 2020) demonstrate significant improvements in theorem proving through the use of graph neural networks to represent higher-order logic terms. Selsam et al. (2019) presented NeuroSAT, a graph neural network (Scarselli et al., 2008; Li et al., 2017; Gilmer et al., 2017; Wu et al., 2019) for solving the propositional satisfiability problem. In contrast, we apply a generic sequence-to-sequence model to predict the solutions to formulas, not only whether there is a solution. This allows us to apply the approach to a wider set of logics (logics without a CNF). A simplified NeuroSAT architecture was trained for unsat-core predictions (Selsam & Bjørner, 2019). Lederman et al. (2020) have used graph neural networks on CNF to learn better heuristics for a 2QBF solver. Evans et al. (2018) study the problem of logical entailment in propositional logic using tree-RNNs. Entailment is a subproblem of satisfiability and (besides being a classification problem) could be encoded in the same form as our propositional formulas. The formulas considered in their dataset are much smaller than in this work. ",
+        "bbox": [
+            174,
+            409,
+            825,
+            574
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Language models applied to programs. Transformers have also been applied to programs for tasks such as summarizing code (Fernandes et al., 2018) or variable naming and misuse (Hellendoorn et al., 2020). Other works focused on recurrent neural networks or graph neural networks for code analysis, e.g. (Piech et al., 2015; Gupta et al., 2017; Bhatia et al., 2018; Wang et al., 2018; Allamanis et al., 2017). Another area in the intersection of formal methods and machine learning is the verification of neural networks (Seshia & Sadigh, 2016; Seshia et al., 2018; Singh et al., 2019; Gehr et al., 2018; Huang et al., 2017; Dreossi et al., 2019). ",
+        "bbox": [
+            174,
+            592,
+            825,
+            688
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3 DATASETS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            708,
+            292,
+            724
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "To demonstrate the generalization properties of the Transformer on logical tasks, we generated several datasets in three different fashions. We will describe the underlying logical problems and our data generation in the following. ",
+        "bbox": [
+            176,
+            739,
+            821,
+            782
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3.1 TRACE GENERATION FOR LINEAR-TIME TEMPORAL LOGIC ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            799,
+            624,
+            814
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Linear-time temporal logic (LTL, Pnueli, 1977) combines propositional connectives with temporal operators such as the Next operator $\\bigcirc$ and the Until operator $\\mathcal { U }$ . $\\bigcirc \\varphi$ means that $\\varphi$ holds in the next position of a sequence; $\\varphi _ { 1 } \\mathcal { U } \\varphi _ { 2 }$ means that $\\varphi _ { 1 }$ holds until $\\varphi _ { 2 }$ holds. For example, the LTL formula $\\mathsf { \\bar { ( } } b \\mathsf { \\mathcal { U } } a ) \\wedge ( c \\mathsf { \\mathcal { U } } \\neg \\bar { a } )$ states that $b$ has to hold along the trace until $a$ holds and $c$ has to hold until $a$ does not hold anymore. There also exist derived operators. For example, consider the following specification of an arbiter: $\\square ( \\mathrm { r e q u e s t }  \\odot \\mathrm { g r a n t } )$ ) states that, at every point in time $\\sqsubset$ -operator), if there is a request signal, then a grant signal must follow at some future point in time ( $\\bigcirc$ -operator). ",
+        "bbox": [
+            174,
+            825,
+            825,
+            924
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "The full semantics and an explanation of the operators can be found in Appendix A. We consider infinite sequences, that are finitely represented in the form of a “lasso” $u v ^ { \\omega }$ , where $u$ , called prefix, and $v$ , called period, are finite sequences of propositional formulas. We call such sequences (symbolic) traces. For example, the symbolic trace $( a \\wedge b ) ^ { \\omega }$ defines the infinite sequence where $a$ and $b$ evaluate to true on every position. Symbolic traces allow us to underspecify propositions when they do not matter. For example, the LTL formula $\\bigcirc \\bigcirc \\sqsupset a$ is satisfied by the symbolic trace: true true $( a ) ^ { \\omega }$ , which allow for any combination of propositions on the first two positions. ",
+        "bbox": [
+            174,
+            103,
+            825,
+            202
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Our datasets consist of pairs of satisfiable LTL formulas and satisfying symbolic traces generated with tools and automata constructions from the spot framework (Duret-Lutz et al., 2016). We use a compact syntax for ultimately periodic symbolic traces: Each position in the trace is separated by the delimiter “;”. True and False are represented by “1” and $ { ^ { 6 } } 0 ^ { 9 }$ , respectively. The beginning of the period $v$ is signaled by the character “ $\\{ \\} ^ { , , }$ and analogously its end by $\\mathbf { \\bar { \\Sigma } } ^ { 6 6 } \\mathbf { \\bar { \\Sigma } } ^ { 5 }$ . For example, the ultimately periodic symbolic trace denoted by $a ; a ; a ; \\{ b \\}$ , describes all infinite traces where on the first 3 positions $a$ must hold followed by an infinite period on which $b$ must hold on every position. ",
+        "bbox": [
+            174,
+            208,
+            825,
+            306
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Given a satisfiable LTL formula $\\varphi$ , our trace generator constructs a Buchi automaton ¨ $A _ { \\varphi }$ that accepts exactly the language defined by the LTL formula, i.e., $\\mathcal { L } ( A _ { \\varphi } ) = \\mathcal { L } ( \\varphi )$ . From this automaton, we construct an arbitrary accepted symbolic trace, by searching for an accepting run in $A _ { \\varphi }$ . ",
+        "bbox": [
+            176,
+            313,
+            825,
+            354
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3.1.1 SPECIFICATION PATTERN ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            373,
+            400,
+            387
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Our main dataset is constructed from formulas following $5 5 \\mathrm { L T L }$ specification patterns identified by the literature (Dwyer et al., 1998). For example, the arbiter property $( \\bigcirc p _ { 0 } ) \\ \\bar { {  } } \\ ( p _ { 1 } { \\mathcal { U } } p _ { 0 } )$ , stating that if $p _ { 0 }$ is scheduled at some point in time, $p _ { 1 }$ is scheduled until this point. The largest specification pattern is of size 40 consisting of 6 atomic propositions. It has been shown that conjunctions of such patterns are challenging for LTL satisfiability tools that rely on classical methods, such as automata constructions (Li et al., 2013). They start coming to their limits when more than 8 pattern formulas are conjoined. We decided to build our dataset in a similar way from these patterns only to allow for a better comparison. ",
+        "bbox": [
+            174,
+            398,
+            825,
+            510
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "We conjoined random specification patterns with randomly chosen variables (from a supply of 6 variables) until one of the following four conditions are met: 1) the formula size succeeds 126, 2) more than 8 formulas would be conjoined, 3) our automaton-based generator timed out $( > 1 s )$ while computing the solution trace, or 4) the formula would become unsatisfiable. In total, we generated 1664487 formula-trace pairs in 24 hours on 20 CPUs. While generating, approximately $4 \\bar { 1 } \\%$ of the instances ran into the first termination condition, $2 1 \\%$ into the second, $3 7 \\%$ into the third and $1 \\%$ into the fourth. We split this set into an $8 0 \\%$ training set, a $1 0 \\%$ validation set, and a $1 0 \\%$ test set. The size distribution of the dataset can be found in Appendix B. ",
+        "bbox": [
+            174,
+            517,
+            825,
+            628
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "For studying how the Transformer performs on longer specification patterns, we accumulated pattern formulas where spot timed out $( > 6 0 s )$ while searching for a satisfying trace. We call this dataset LTLUnsolved254 . We capped the maximum length at 254, which is twice as large as the formulas the model saw during training. The size distribution of the generated formulas can be found in Appendix B. ",
+        "bbox": [
+            174,
+            636,
+            823,
+            705
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "In the following table, we illustrate the complexity of our training dataset with two examples from the above described set LTLPattern126, where the subsequent number of the notation of our datasets denotes the maximum size of a formula’s syntax tree. The first line shows the LTL formula and the symbolic trace in mathematical notation. The second line shows the input and output representation of the Transformer (in Polish notation): ",
+        "bbox": [
+            174,
+            712,
+            823,
+            781
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "table",
+        "img_path": "images/47a5813dbbdde8b8fdb2ce89ef382b7685bee46feea3481a6c58502911853e3e.jpg",
+        "table_caption": [],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=1 colspan=1>LTL formula</td><td rowspan=1 colspan=1>satisfying symbolic trace</td></tr><tr><td rowspan=1 colspan=1>(a→d)&gt;-fWfw-fWfw-f(c→-cu(c&gt;-bWbW-bWbW□-b))&amp;&amp;G&gt;aFdW!fWfW!fWfG!f&gt;FcU!c&amp;cW!bWbW!bWbG!b</td><td rowspan=1 colspan=1>(-a&gt;-c∧-fV-c△d∧-f){!a&amp;!c&amp;!f|!c&amp;d&amp;!f}</td></tr><tr><td rowspan=1 colspan=1>□b&gt;-a△a→cua)△□a→□c)△(&lt;b→-bu(b&gt;-fWfW-fWfW□-f))^(&lt;a→(c^O(-aue)→O(-au(e△&lt;f)))ua)&gt;△c&gt;□(a□e→-(-e&gt;fO(-eu(-e&gt;d)))u(evc))^(□-av△(a&gt;-fWd))△□(e→□-c)&amp;&amp;&amp;&amp;&amp;&amp;&amp;G&gt;&amp;&amp;b!aFaUcaG&gt;aGc&gt;FbU!b&amp;bW!fWfW!fWfG!f&gt;FaU&gt;&amp;cXU!aeXU!a&amp;eFfaFcG&gt;&amp;aFeU!&amp;&amp;!efXU!e&amp;!edlec|G!aF&amp;aW!fdG&gt;eG!c</td><td rowspan=1 colspan=1>(-a△b∧-c∧-e∧f)(-a△-c△-e&gt;-f)(-a∧-c∧-e△f)(-a△c∧-e△-f)(-a&gt;e∧-f)ω&amp;&amp;&amp;&amp;!ab!c!ef;&amp;&amp;&amp;!a!c!e!f;&amp;&amp;&amp;!a!c!ef;&amp;&amp;&amp;!ac!e!f;{&amp;&amp;!a!e!f}</td></tr></table>",
+        "bbox": [
+            176,
+            795,
+            823,
+            928
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3.1.2 RANDOM FORMULAS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            103,
+            377,
+            117
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "To show that the generalization properties of the Transformer are not specific to our data generation, we also generated a dataset of random formulas. Our dataset of random formulas consist of 1 million generated formulas and their solutions, i.e., a satisfying symbolic trace. The number of different propositions is fixed to 5. Each dataset is split into a training set of $8 0 0 \\mathrm { K }$ formulas, a validation set of 100K formulas, and a test set of 100K formulas. All datasets are uniformly distributed in size, apart from the lower-sized end due to the limited number of unique small formulas. The formula and trace distribution of the dataset LTLRandom35, as well as three randomly drawn example instances can be found in Appendix B. Note that we filtered out examples with traces larger than 62 (less than $0 . 0 5 \\%$ of the original set). ",
+        "bbox": [
+            174,
+            127,
+            825,
+            253
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "To generate the formulas, we used the randltl tool of the spot framework, which builds unique formulas in a specified size interval, following a supplied node probability distribution. During the building process, the actual distribution occasionally differs from the given distribution in order to meet the size constraints, e.g., by masking out all binary operators. The distribution between all $k$ -ary nodes always remains the same. To furthermore achieve a (quasi) uniform distribution in size, we subsequently filtered the generated formulas. Our node distribution puts equal weight on all operators $\\neg , \\land , \\bigcirc$ and $\\mathcal { U }$ . Constants True and False are allowed with 2.5 times less probability than propositions. ",
+        "bbox": [
+            174,
+            260,
+            825,
+            372
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "3.2 ASSIGNMENT GENERATION FOR PROPOSITIONAL LOGIC ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            387,
+            606,
+            402
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "To show that the generalization of the Transformer to the semantics of logics is not a unique attribute of LTL, we also generated a dataset for propositional logic (SAT). A propositional formula consists of Boolean operators $\\wedge$ (and), $\\vee$ (or), $\\neg$ (not), and variables also called literals or propositions. We consider the derived operators $\\varphi _ { 1 }  \\varphi _ { 2 } \\equiv \\lnot \\varphi _ { 1 } \\lor \\varphi _ { 2 }$ (implication), $\\varphi _ { 1 }  \\varphi _ { 2 } \\equiv ( \\varphi _ { 1 }  \\varphi _ { 2 } ) \\wedge ( \\varphi _ { 2 } $ $\\varphi _ { 1 }$ ) (equivalence), and $\\varphi _ { 1 } \\oplus \\varphi _ { 2 } \\equiv \\lnot ( \\varphi _ { 1 }  \\varphi _ { 2 } )$ (xor). Given a propositional Boolean formula $\\varphi$ , the satisfiability problem asks if there exists a Boolean assignment $\\Pi : \\mathcal { V } \\mapsto \\mathbb { B }$ for every literal in $\\varphi$ such that $\\varphi$ evaluates to true. For example, consider the following propositional formula, given in conjunctive normal form (CNF): $( x _ { 1 } \\lor x _ { 2 } \\lor \\neg x _ { 3 } ) \\land ( \\neg x _ { 1 } \\lor x _ { 3 } )$ . A possible satisfying assignment for this formula would be $\\{ ( x _ { 1 } , t r u e ) , ( x _ { 2 } , f a l s e ) , ( x _ { 3 } , t r u e ) \\} .$ . We allow a satisfying assignment to be partial, i.e., if the truth value of a propositions can be arbitrary, it will be omitted. For example, $\\{ ( x _ { 1 } , t r u e ) , ( x _ { 3 } , t r u e ) \\}$ would be a satisfying partial assignment for the formula above. We define a minimal unsatisfiable core of an unsatisfiable formula $\\varphi$ , given in CNF, as an unsatisfiable subset of clauses $\\varphi _ { c o r e }$ of $\\varphi$ , such that every proper subset of clauses of $\\varphi _ { c o r e }$ is still satisfiable. ",
+        "bbox": [
+            173,
+            414,
+            825,
+            594
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "We, again, generated 1 million random formulas. For the generation of propositional formulas, the specified node distribution puts equal weight on $\\wedge , \\vee$ , and $\\neg$ operators and half as much weight on the derived operators and $\\oplus$ individually. In contrast to previous work (Selsam et al., 2019), which is restricted to formulas in CNF, we allow an arbitrary formula structure and derived operators. ",
+        "bbox": [
+            174,
+            602,
+            825,
+            657
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "A satisfying assignment is represented as an alternating sequence of propositions and truth values, given as 0 and 1. The sequence $a 0 b 1 c 0$ , for example, represents the partial assignment $\\{ ( a , f a l s e ) , ( b , t r u e ) , ( c , f a l s e ) \\}$ , meaning that the truth values of propositions $d$ and $e$ can be chosen arbitrarily (note that we allow five propositions). We used pyaiger (Vazquez-Chanlatte, 2018), which builds on Glucose 4 (Audemard & Simon, 2018) as its underlying SAT solver. We construct the partial assignments with a standard method in SAT solving: We query the SAT solver for a minimal unsatisfiable core of the negation of the formula. To give the interested reader an idea of the level of difficulty of the dataset, the following table shows three random examples from our training set PropRandom35. The first line shows the formula and the assignment in mathematical notation. The second line shows the syntactic representation (in Polish notation): ",
+        "bbox": [
+            173,
+            664,
+            825,
+            804
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "table",
+        "img_path": "images/072d20b6a106f608f1a178a4eac98451c4f09b99a2a8070fa36168e9e1c0d9b1.jpg",
+        "table_caption": [],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=1 colspan=1>propositional formula</td><td rowspan=1 colspan=1>satisfying partial assignment</td></tr><tr><td rowspan=1 colspan=1>（（d△-e）∧(-aV-e)）←→（（-④(-b↔-e)）v((e④(b^d))④-(-cv(-a←e))))&lt;-&gt;&amp;&amp;d!e|!a!e|xor!b&lt;-&gt;!b!exorxore&amp;bd!|!c&lt;-&gt;!ae</td><td rowspan=1 colspan=1>{(a,0),(b,0)，(c,1),(d,1),(e,0))a0b0cldle0</td></tr><tr><td rowspan=1 colspan=1>(cVe)v(-a&gt;-b)Ilce&lt;-&gt;!a!b</td><td rowspan=1 colspan=1>{c,1)}c1</td></tr><tr><td rowspan=1 colspan=1>-((bve)④((-av(-d&gt;-e))v(-bν(((-a&gt;b)&gt;-b)&gt;d))))!xor!bell!a&lt;-&gt;!d!e!I!b&amp;&amp;&amp;!ab!b!d</td><td rowspan=1 colspan=1>{(d,1)，(e,1)}dle1</td></tr></table>",
+        "bbox": [
+            196,
+            814,
+            805,
+            928
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "image",
+        "img_path": "images/fdb9dc311abf6b49d3346e87fc32c0b3886ed4d43286bb4853abef7d9b063e0d.jpg",
+        "image_caption": [
+            "Figure 2: Overview of our main experimental results: the performance of our best performing models on our different datasets. The percentage of a dark green bar refers to the syntactic accuracy, the percentage of a light green bar to the semantic accuracy without the syntactic accuracy, and the incorrect predictions are visualized in orange. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            207,
+            106,
+            789,
+            258
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "To test the Transformer on even more challenging formulas, we constructed a dataset of CNF formulas using the generation script of Selsam et al. (2019) from their publicly available implementation. A random CNF formula is built by adding clauses until the addition of a further clause would lead to an unsatisfiable formula. We used the parameters $p _ { g e o } = 0 . 9$ and $p _ { k 2 } = 0 . 7 5$ to generate formulas that contain up to 15 variables and have a maximum size of 250. We call this dataset PropCNF 250. ",
+        "bbox": [
+            174,
+            361,
+            825,
+            431
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "4 EXPERIMENTAL SETUP ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            452,
+            398,
+            467
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "We have implemented the Transformer architecture (Vaswani et al., 2017). Our implementation processes the input and output sequences token-by-token. We trained on a single GPU (NVIDIA P100 or V100). All training has been done with a dropout rate of 0.1 and early stopping on the validation set. Note that the embedding size will automatically be floored to be divisible by the number of attention heads. The training of the best models took up to 50 hours. For the output decoding, we utilized a beam search (Wu et al., 2016), with a beam size of 3 and an $\\alpha$ of 1. ",
+        "bbox": [
+            174,
+            482,
+            825,
+            565
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Since the solution of a logical formula is not necessarily unique, we use two different measures of accuracy to evaluate the generalization to the semantics of the logics: we distinguish between the syntactic accuracy, i.e., the percentage where the Transformers prediction syntactically matches the output of our generator and the semantic accuracy, i.e., the percentage where the Transformer produced a different solution. We also differentiate between incorrect predictions and syntactically invalid outputs which, in fact, happens only in $0 . 1 \\%$ of the cases in LTLUnsolved254 . ",
+        "bbox": [
+            174,
+            573,
+            823,
+            657
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "In general, our best performing models used 8 layers, 8 attention heads, and an FC size of 1024. We used a batch size of 400 and trained for $4 5 0 K$ steps (130 epochs) for our specification pattern dataset, and a batch size of 768 and trained for $5 0 K$ steps (48 epochs) for our random formula dataset. A hyperparameter study can be found in Appendix C. ",
+        "bbox": [
+            176,
+            664,
+            823,
+            719
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "5 EXPERIMENTAL RESULTS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            739,
+            419,
+            756
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "In this section, we describe our experimental results. First, we show that a Transformer can indeed solve the task of providing a solution, i.e., a trace for a linear-time temporal logical (LTL) formula. For this, we describe the results from training on the dataset LTLPattern126 of specification patterns that are commonly used in the context of verification. Secondly, we show two generalization properties that the Transformer evinces on logic reasoning tasks: 1) the generalization to larger formulas (even so large that our data generator timed out) and 2) the generalization to the semantics of the logic. We strengthen this observation by considering a different dataset of random LTL formulas. Thirdly, we provide results for a model trained on a different logic and with a different data generator. We thereby demonstrate that the generalization behaviors of the Transformer are not specific to LTL and the LTL solver implemented with spot that we used to generate the data. An overview of our training results is displayed in Figure 2. ",
+        "bbox": [
+            173,
+            770,
+            825,
+            924
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "image",
+        "img_path": "images/259e39d68cfc075f12cd17aab8094a0d4b8f12fbb027b4d69c70ab5cd9828641.jpg",
+        "image_caption": [
+            "Figure 3: Predictions of our best performing model, trained on LTLUnsolved254 , on 5704 specification patterns for which spot timed out $( > 6 0 s )$ . Semantic accuracy is displayed in green; incorrect traces in orange; syntactically invalid traces in red. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            223,
+            123,
+            759,
+            306
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "5.1 SOLVING LINEAR-TIME TEMPORAL LOGICAL FORMULAS ",
+        "bbox": [
+            174,
+            397,
+            612,
+            411
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "We trained a Transformer on our specification on LTLPattern126 . Figure 1 in the introduction displays the performance of our best model on this dataset. We observed a syntactic accuracy of $6 9 . 1 \\%$ and a semantic accuracy of $9 6 . 8 \\%$ . With this experiment we can already deduce that it seems easier for the Transformer to learn the underlying semantics of LTL than to learn the particularities of the generator. Further we can see that as the formula length grows, the syntactic accuracy begins to drop. However, that drop is much smaller in the semantic accuracy—the model still mostly predicts correct traces for long formulas. ",
+        "bbox": [
+            174,
+            426,
+            825,
+            523
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "As a challenging benchmark, we tested our best performing model on LTLUnsolved254 . It predicted correct solutions in $8 3 \\%$ of the cases, taking on average $1 5 s$ on a single CPU. The syntactic accuracy is $0 \\%$ as there was no output produced by spot within the timeout. The results of the experiments are visualized in Figure 3. Note that this does not mean that our Transformer models necessariy outperform classical algorithms across the board. However, since verifying solutions to LTL formulas is much easier than finding solutions $( \\mathbf { A C } ^ { 1 } ( \\log \\mathrm { D C F L } )$ vs PSPACE), this experiment shows that the predictions of a deep neural network can be a valuable extension to the verification tool box. ",
+        "bbox": [
+            174,
+            530,
+            825,
+            641
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "5.2 GENERALIZATION PROPERTIES",
+        "text_level": 1,
+        "bbox": [
+            176,
+            665,
+            429,
+            679
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "To prove that the generalization to the semantics is independent of the data generation, we also trained a model on a dataset of randomly generated formulas. The unshaded part of Figure 4 displays the performance of our best model on the LTLRandom35 dataset. The Transformers were solely trained on formulas of size less or equal to 35. We observe that in this range the exact syntactic accuracy decreases when the formulas grow in size. The semantic accuracy, however, stays, again, high. The model achieves a syntactic accuracy of $8 3 . 8 \\%$ and a semantic accuracy of ${ \\dot { 9 } } 8 . 5 \\%$ on LTLRandom35, i.e., in $1 4 . 7 \\%$ of the cases, the Transformer deviates from our automaton-based data generator. The evolution of the syntactic and the semantic accuracy during training can be found in Appendix D. ",
+        "bbox": [
+            174,
+            694,
+            825,
+            819
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "To show that the generalization to larger formulas is independent from the data generation method, we also tested how well the Transformer generalizes to randomly generated LTL formulas of a size it has never seen before. We used our model trained on LTLRandom35 and observed the performance on LTLRandom50. The model preserves the semantic generalization, displayed in the shaded part of Figure 4. It outputs exact syntactic matches in $6 7 . 6 \\%$ of the cases and achieves a semantic accuracy of $9 2 . 2 \\%$ . For the generalization to larger formulas we utilized a positional encoding based on the tree representation of the formula (Shiv & Quirk, 2019). When using the standard positional encoding instead, the accuracy drops, as expected, significantly. A visualization of this experiments can be found in Appendix E. ",
+        "bbox": [
+            174,
+            827,
+            823,
+            924
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            171,
+            103,
+            823,
+            132
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "In a further experiment, we tested the out-of-distribution (OOD) generalization of the Transformer on the trace generation task. We generated a new dataset LTLRandom126 to match the formula sizes and the vocabulary of LTLPattern126. A model trained on LTLRandom126 achieves a semantic accuracy of $2 4 . 7 \\%$ (and a syntactic accuracy of only $1 . 0 \\%$ ) when tested on LTLPattern126. Vice versa, a model trained on LTLPattern126 achieves a semantic accuracy of $3 8 . 5 \\%$ (and a semantic accuracy of only $0 . 5 \\%$ ) when tested on LTLRandom126. Testing the models OOD increases the gap between syntactic and semantic correctness dramatically. This underlines that the models learned the nature of the LTL semantics rather than the generator process. Note that the two distributions are very different. ",
+        "bbox": [
+            174,
+            138,
+            825,
+            263
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Following these observations, we also tested the performance of our models on other patterns from the literature. We observe a higher semantic accuracy for our model trained on random formulas and a higher gap between semantic and syntactic accuracy for our model trained on pattern formulas: ",
+        "bbox": [
+            174,
+            271,
+            825,
+            314
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "table",
+        "img_path": "images/5aed76bf4abe0424a9630cbec6729d50948d731f16bad15d57066dd2c1df6a75.jpg",
+        "table_caption": [],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Patterns</td><td>Number of Patterns</td><td>Trained on</td><td>Syn. Acc.</td><td>Sem. Acc.</td></tr><tr><td>dac (Dwyer et al., 1998) eh (Etessami &amp; Holzmann,2000) hkrss (Holeek et al., 2004)</td><td>55 11 49</td><td>LTLRandom126 LTLRandom126 LTLRandom126</td><td>49.1% 81.8% 71.4%</td><td>81.8% 90.9% 83.7%</td></tr><tr><td>p (Pelanek,2007) eh (Etessami &amp; Holzmann,2000) hkrss (Holecek et al.,2004) p (Pelanek,2007)</td><td>20 11 49 20</td><td>LTLRandom126 LTLPattern126 LTLPattern126 LTLPattern126</td><td>65.0% 0.0% 14.3% 10.0%</td><td>90.0% 36.4% 49.0% 60.0%</td></tr></table>",
+        "bbox": [
+            176,
+            319,
+            805,
+            424
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "In a last experiment on LTL, we tested the performance of our models on handcrafted formulas. We observed that formulas with multiple until statements that describe overlapping intervals were the most challenging. This is no surprise as these formulas are the source of PSPACE-hardness of LTL. ",
+        "bbox": [
+            174,
+            429,
+            825,
+            472
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "equation",
+        "img_path": "images/97b855a68650edd962ce75da8ec2bb6b8abda03ab895019c192bc4de1dd7b9f5.jpg",
+        "text": "$$\n\\begin{array} { c c } { { \\begin{array} { r l } { - a \\mathcal { U } b \\wedge a \\mathcal { U } \\neg b } \\end{array} } } & { { \\begin{array} { r l } { ( a \\wedge \\neg b ) ( b ) ( t r u e ) ^ { \\omega } } } & { { } } \\\\ { \\& \\mathrm { a : b : b : \\left\\{ 1 \\right\\} } } \\end{array} }  \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            344,
+            479,
+            651,
+            513
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "While the above formula can be solved by most models, when scaling this formula to four overlapping until intervals, all of our models fail: For example, a model trained on LTLRandom35 predicted the trace $( a \\wedge b \\wedge c ) ( a \\wedge \\neg b \\wedge \\neg c ) ( b \\wedge c ) ( t r u e ) ^ { \\omega }$ , which does not satisfy the LTL formula. ",
+        "bbox": [
+            174,
+            522,
+            825,
+            565
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "table",
+        "img_path": "images/7052a84a551350df7e2bca5adddc4fd1b29b7d56f789f4b7685931eb4852d943.jpg",
+        "table_caption": [],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>(aub^c) ^ (au-b∧c) ^ (aub^-c) ^ (au-b^ -c) )(a∧b∧c)(a∧-b∧-c)(b∧c)(true)ä</td></tr><tr><td>&amp;&amp;&amp;Ua&amp;bcUa&amp;!bcUa&amp;b!cUa&amp;!b!c &amp;&amp;abc;&amp;&amp;a!b!c;&amp;bc;1</td></tr></table>",
+        "bbox": [
+            178,
+            585,
+            833,
+            616
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "5.3 PREDICTING ASSIGNMENTS FOR PROPOSITIONAL LOGIC ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            631,
+            607,
+            645
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "To show that the generalization to the semantic is not a specific property of LTL, we trained a Transformer to solve the assignment generation problem for propositional logic, which is a substantially different logical problem. ",
+        "bbox": [
+            174,
+            656,
+            825,
+            699
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "table",
+        "img_path": "images/28f827f34996afeac968e157ae913cd277301e4117d12f6bfff805e8401e7543.jpg",
+        "table_caption": [
+            "As a baseline for our generalization experiments on propositional logic, we trained and tested a Transformer model with the following hyperparameter on PropRandom35: "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Embedding size</td><td>Layers</td><td>Heads</td><td>FC size</td><td>Batch Size Train Steps</td><td>Syn. Acc. Sem. Acc.</td></tr><tr><td>enc:128, dec:64</td><td>6</td><td>6</td><td>512 1024</td><td>50K</td><td>58.1% 96.5%</td></tr></table>",
+        "bbox": [
+            176,
+            741,
+            818,
+            771
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "We observe a striking $3 8 . 4 \\%$ gap between predictions that were syntactical matches of our DPLLbased generator and correct predictions of the Transformer. Only ${ \\dot { 3 } } . 5 \\%$ of the time, the Transformer outputs an incorrect assignment. Note that we allow the derived operators $\\oplus$ and in these experiments, which succinctly represent complicated logical constructs. ",
+        "bbox": [
+            173,
+            777,
+            823,
+            833
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "The formula $b \\lor \\neg ( a \\land d )$ occurs in our dataset PropRandom35 and its corresponding assignment is $\\{ ( a , 0 ) \\}$ . The Transformer, however, outputs $\\mathtt { d 0 }$ , i.e., it goes with the assignment of setting $d$ to false, which is also a correct solution. A visualization of this example can be found in Appendix F. When the formulas get larger, the solutions where the Transformer differs from the DPLL algorithm accumulate. Consider, for example, the formula $\\lnot b \\lor ( e  b \\lor c \\lor \\lnot d ) \\lor ( c \\land ( b \\oplus ( a \\oplus \\lnot d ) ) \\lnot ( \\lnot c $ $d ) \\wedge ( a  ( b \\oplus ( b \\oplus e ) ) )$ ), which is also in the dataset PropRandom35. The generator suggests the assignment $\\{ ( a , 1 ) , ( c , 1 ) , ( d , 0 ) \\}$ . The Transformer, however, outputs $e 0$ , i.e., the singleton assignment of setting $e$ to false, which turns out to be a (very small) solution as well. ",
+        "bbox": [
+            173,
+            839,
+            825,
+            924
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "image",
+        "img_path": "images/f3c2414b6c96721bb0325493dc03744acf0e638251d4a1f2fa2029c6edf4b63c.jpg",
+        "image_caption": [
+            "Figure 4: Syntactic and semantic accuracy of our best performing model (only trained on LTLRandom35 ) on LTLRandom50 . Dark green is syntactically correct; light green is semantically correct, orange is incorrect. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            204,
+            103,
+            776,
+            228
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            305,
+            823,
+            333
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "We achieved stable training in this experiment by setting the decoder embedding size to either 64 or even 32. Keeping the decoder embedding size at 128 led to very unstable training. ",
+        "bbox": [
+            173,
+            340,
+            823,
+            369
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "We also tested whether the generalization to the semantics is preserved when the Transformer encounters propositional formulas of a larger size than it ever saw during training. We, again, utilized the tree positional encoding. When challenged with formulas of size 35 to 50, our best performing model trained on PropRandom35 achieves a syntactic accuracy of $3 5 . 8 \\%$ and a semantic accuracy of $8 6 . 1 \\%$ . In comparison, without the tree positional encoding, the Transformer achieves a syntactic match of only $2 9 . 0 \\%$ and an overall accuracy of only $7 5 . 7 \\%$ . Note that both positional encodings work equally well when not considering larger formulas. ",
+        "bbox": [
+            174,
+            376,
+            825,
+            473
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "In a last experiment, we tested how the Transformer performs on more challenging propositional formulas in CNF. We thus trained a model on PropCNF 250, where it achieved a semantic accuracy of $6 5 . 1 \\%$ and a syntactic accuracy of $5 6 . 6 \\%$ . We observe a slightly lower gap compared to our LTL experiments. The Transformer, however, still deviates even on such formulas from the generator. ",
+        "bbox": [
+            174,
+            481,
+            823,
+            536
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "6 CONCLUSION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            556,
+            318,
+            571
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "We trained a Transformer to predict solutions to linear-time temporal logical (LTL) formulas. We observed that our trained models evince powerful generalization properties, namely, the generalization to the semantics of the logic, and the generalization to larger formulas than seen during training. We showed that these generalizations do not depend on the underlying logical problem nor on the data generator. Regarding the performance of the trained models, we observed that they can compete with classical algorithms for generating solutions to LTL formulas. We built a test set that contained only formulas that were generated out of practical verification patterns, on which even our data generator timed out. Our best performing model, although it was trained on much smaller formulas, predicts correct traces $8 3 \\%$ of the time. ",
+        "bbox": [
+            174,
+            587,
+            825,
+            712
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "The results of this paper suggest that deep learning can already augment combinatorial approaches in automatic verification and the broader formal methods community. With the results of this paper, we can, for example, derive novel algorithms for trace generation or satisfiability checking of LTL that first query a Transformer for trace predictions. These predictions can be checked efficiently. Classical methods can serve as a fall back or check partial solutions providing guidance to the Transformer. The potential that arises from the advent of deep learning in logical reasoning is immense. Deep learning holds the promise to empower researchers in the automated reasoning and formal methods communities to make bigger jumps in the development of new automated verification methods, but also brings new challenges, such as the acquisition of large amounts of data. ",
+        "bbox": [
+            174,
+            719,
+            825,
+            844
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "ACKNOWLEDGEMENTS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            866,
+            366,
+            880
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "We thank Christian Szegedy, Jesko Hecking-Harbusch, and Niklas Metzger for their valuable feedback on an earlier version of this paper. ",
+        "bbox": [
+            174,
+            895,
+            821,
+            924
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "REFERENCES ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            102,
+            287,
+            118
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Miltiadis Allamanis, Marc Brockschmidt, and Mahmoud Khademi. Learning to represent programs with graphs. arXiv preprint arXiv:1711.00740, 2017. ",
+        "bbox": [
+            173,
+            126,
+            823,
+            155
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Gilles Audemard and Laurent Simon. On the glucose SAT solver. Int. J. Artif. Intell. Tools, 27 (1):1840001:1–1840001:25, 2018. doi: 10.1142/S0218213018400018. URL https://doi. org/10.1142/S0218213018400018. ",
+        "bbox": [
+            176,
+            165,
+            823,
+            208
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Mislav Balunovic, Pavol Bielik, and Martin Vechev. Learning to solve smt formulas. In S. Bengio, H. Wallach, H. Larochelle, K. Grauman, N. Cesa-Bianchi, and R. Garnett (eds.), Advances in Neural Information Processing Systems 31, pp. 10317– 10328. Curran Associates, Inc., 2018. URL http://papers.nips.cc/paper/ 8233-learning-to-solve-smt-formulas.pdf. ",
+        "bbox": [
+            173,
+            218,
+            825,
+            287
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Kshitij Bansal, Sarah M Loos, Markus N Rabe, Christian Szegedy, and Stewart Wilcox. HOList: An environment for machine learning of higher-order theorem proving. In arXiv preprint arXiv:1904.03241, 2019. ",
+        "bbox": [
+            173,
+            297,
+            826,
+            340
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "S. Bhatia, P. Kohli, and R. Singh. Neuro-symbolic program corrector for introductory programming assignments. In 2018 IEEE/ACM 40th International Conference on Software Engineering (ICSE), pp. 60–70, May 2018. doi: 10.1145/3180155.3180219. ",
+        "bbox": [
+            173,
+            351,
+            821,
+            393
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Jasmin Christian Blanchette, Cezary Kaliszyk, Lawrence C Paulson, and Josef Urban. Hammering towards QED. Journal of Formalized Reasoning, 9(1):101–148, 2016. ",
+        "bbox": [
+            168,
+            404,
+            823,
+            433
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Tom B. Brown, Benjamin Mann, Nick Ryder, Melanie Subbiah, Jared Kaplan, Prafulla Dhariwal, Arvind Neelakantan, Pranav Shyam, Girish Sastry, Amanda Askell, Sandhini Agarwal, Ariel Herbert-Voss, Gretchen Krueger, Tom Henighan, Rewon Child, Aditya Ramesh, Daniel M. Ziegler, Jeffrey Wu, Clemens Winter, Christopher Hesse, Mark Chen, Eric Sigler, Mateusz Litwin, Scott Gray, Benjamin Chess, Jack Clark, Christopher Berner, Sam McCandlish, Alec Radford, Ilya Sutskever, and Dario Amodei. Language models are few-shot learners. 2020. ",
+        "bbox": [
+            173,
+            443,
+            825,
+            526
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Paul Cairns. Informalising formal mathematics: Searching the mizar library with latent semantics. In International Conference on Mathematical Knowledge Management, pp. 58–72. Springer, 2004. ",
+        "bbox": [
+            173,
+            536,
+            823,
+            566
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Tommaso Dreossi, Alexandre Donze, and Sanjit A Seshia. Compositional falsification of cyber- ´ physical systems with machine learning components. Journal of Automated Reasoning, 63(4): 1031–1053, 2019. ",
+        "bbox": [
+            173,
+            575,
+            821,
+            618
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Alexandre Duret-Lutz, Alexandre Lewkowicz, Amaury Fauchille, Thibaud Michaud, Etienne Renault, and Laurent Xu. Spot 2.0—a framework for ltl and $\\omega$ -automata manipulation. In International Symposium on Automated Technology for Verification and Analysis, pp. 122–129. Springer, 2016. ",
+        "bbox": [
+            174,
+            628,
+            825,
+            685
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Matthew B. Dwyer, George S. Avrunin, and James C. Corbett. Property specification patterns for finite-state verification. In Mark A. Ardis and Joanne M. Atlee (eds.), Proceedings of the Second Workshop on Formal Methods in Software Practice, March 4-5, 1998, Clearwater Beach, Florida, USA, pp. 7–15. ACM, 1998. doi: 10.1145/298595.298598. URL https://doi.org/10. 1145/298595.298598. ",
+        "bbox": [
+            173,
+            695,
+            825,
+            765
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Kousha Etessami and Gerard J. Holzmann. Optimizing buchi automata. In Catuscia Palamidessi ¨ (ed.), CONCUR 2000 - Concurrency Theory, 11th International Conference, University Park, PA, USA, August 22-25, 2000, Proceedings, volume 1877 of Lecture Notes in Computer Science, pp. 153–167. Springer, 2000. doi: 10.1007/3-540-44618-4\\ 13. URL https://doi.org/10. 1007/3-540-44618-4_13. ",
+        "bbox": [
+            173,
+            775,
+            825,
+            847
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Richard Evans, David Saxton, David Amos, Pushmeet Kohli, and Edward Grefenstette. Can neural networks understand logical entailment? arXiv preprint arXiv:1802.08535, 2018. ",
+        "bbox": [
+            169,
+            856,
+            823,
+            886
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Patrick Fernandes, Miltiadis Allamanis, and Marc Brockschmidt. Structured neural summarization. arXiv preprint arXiv:1811.01824, 2018. ",
+        "bbox": [
+            173,
+            895,
+            820,
+            924
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Thibault Gauthier, Cezary Kaliszyk, and Josef Urban. Tactictoe: Learning to reason with hol4 tactics. arXiv preprint arXiv:1804.00595, 2018. ",
+        "bbox": [
+            171,
+            103,
+            823,
+            132
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Timon Gehr, Matthew Mirman, Dana Drachsler-Cohen, Petar Tsankov, Swarat Chaudhuri, and Martin Vechev. Ai2: Safety and robustness certification of neural networks with abstract interpretation. In 2018 IEEE Symposium on Security and Privacy (SP), pp. 3–18. IEEE, 2018. ",
+        "bbox": [
+            174,
+            141,
+            821,
+            185
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Justin Gilmer, Samuel S Schoenholz, Patrick F Riley, Oriol Vinyals, and George E Dahl. Neural message passing for quantum chemistry. In Proceedings of the 34th International Conference on Machine Learning-Volume 70, pp. 1263–1272. JMLR. org, 2017. ",
+        "bbox": [
+            173,
+            194,
+            823,
+            238
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Rahul Gupta, Soham Pal, Aditya Kanade, and Shirish Shevade. Deepfix: Fixing common C language errors by deep learning. In Thirty-First AAAI Conference on Artificial Intelligence, 2017. ",
+        "bbox": [
+            173,
+            246,
+            823,
+            276
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Kaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. Delving deep into rectifiers: Surpassing human-level performance on imagenet classification. In 2015 IEEE International Conference on Computer Vision, ICCV 2015, Santiago, Chile, December 7-13, 2015, pp. 1026–1034, 2015. doi: 10.1109/ICCV.2015.123. URL https://doi.org/10.1109/ICCV.2015.123. ",
+        "bbox": [
+            173,
+            284,
+            825,
+            342
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Vincent J. Hellendoorn, Charles Sutton, Rishabh Singh, and Petros Maniatis. Global relational models of source code. In International Conference on Learning Representations, 2020. URL https://openreview.net/forum?id $\\underline { { \\underline { { \\mathbf { \\Pi } } } } } =$ B1lnbRNtwr. ",
+        "bbox": [
+            176,
+            351,
+            823,
+            393
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Jan Holecek, Tom ˇ a´s Kratochv ˇ ´ıla, Vojtech ˇ Reh ˇ ak, David ´ Safr ˇ anek, Pavel ´ Sime ˇ cek, et al. Verification ˇ results in liberouter project, 2004. ",
+        "bbox": [
+            171,
+            401,
+            823,
+            433
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Daniel Huang, Prafulla Dhariwal, Dawn Song, and Ilya Sutskever. Gamepad: A learning environment for theorem proving. arXiv preprint arXiv:1806.00608, 2018. ",
+        "bbox": [
+            171,
+            440,
+            823,
+            470
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Xiaowei Huang, Marta Kwiatkowska, Sen Wang, and Min Wu. Safety verification of deep neural networks. In International Conference on Computer Aided Verification, pp. 3–29. Springer, 2017. ",
+        "bbox": [
+            171,
+            479,
+            823,
+            510
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "IEEE-Commission et al. Ieee standard for property specification language (psl). IEEE Std 1850- 2005, 2005. ",
+        "bbox": [
+            169,
+            517,
+            823,
+            547
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Cezary Kaliszyk and Josef Urban. Learning-assisted automated reasoning with flyspeck. Journal of Automated Reasoning, 53(2):173–213, 2014. ",
+        "bbox": [
+            173,
+            556,
+            821,
+            585
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Cezary Kaliszyk, Franc¸ois Chollet, and Christian Szegedy. HolStep: A Machine Learning Dataset for Higher-order Logic Theorem Proving. In Proceedings of International Conference on Learning Representations (ICLR), 2017. ",
+        "bbox": [
+            173,
+            594,
+            826,
+            638
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Guillaume Lample and Franc¸ois Charton. Deep learning for symbolic mathematics. In ICLR, 2020. ",
+        "bbox": [
+            171,
+            647,
+            821,
+            664
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Gil Lederman, Markus N. Rabe, Edward A. Lee, and Sanjit A. Seshia. Learning heuristics for quantified boolean formulas through deep reinforcement learning. 2020. URL http://arxiv. org/abs/1807.08058. ",
+        "bbox": [
+            173,
+            671,
+            821,
+            714
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Dennis Lee, Christian Szegedy, Markus N. Rabe, Sarah M. Loos, and Kshitij Bansal. Mathematical reasoning in latent space. 2020. ",
+        "bbox": [
+            171,
+            724,
+            823,
+            753
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Jianwen Li, Lijun Zhang, Geguang Pu, Moshe Y. Vardi, and Jifeng He. LTL satisfiability checking revisited. In Cesar S ´ anchez, Kristen Brent Venable, and Esteban Zim ´ anyi (eds.), ´ 2013 20th International Symposium on Temporal Representation and Reasoning, Pensacola, FL, USA, September 26-28, 2013, pp. 91–98. IEEE Computer Society, 2013. doi: 10.1109/TIME.2013.19. URL https://doi.org/10.1109/TIME.2013.19. ",
+        "bbox": [
+            173,
+            762,
+            825,
+            833
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Jianwen Li, Yinbo Yao, Geguang Pu, Lijun Zhang, and Jifeng He. Aalta: an ltl satisfiability checker over infinite/finite traces. In Proceedings of the 22nd ACM SIGSOFT international symposium on foundations of software engineering, pp. 731–734, 2014. ",
+        "bbox": [
+            173,
+            843,
+            821,
+            886
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Wenda Li, Lei Yu, Yuhuai Wu, and Lawrence C. Paulson. Modelling high-level mathematical reasoning in mechanised declarative proofs. arXiv preprint arXiv:2006.09265, 2020. ",
+        "bbox": [
+            173,
+            895,
+            820,
+            924
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Yaguang Li, Rose Yu, Cyrus Shahabi, and Yan Liu. Diffusion convolutional recurrent neural network: Data-driven traffic forecasting. arXiv preprint arXiv:1707.01926, 2017. ",
+        "bbox": [
+            171,
+            103,
+            823,
+            133
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Sarah Loos, Geoffrey Irving, Christian Szegedy, and Cezary Kaliszyk. Deep network guided proof search. In LPAR, 2017. ",
+        "bbox": [
+            173,
+            140,
+            823,
+            169
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Jia Meng and Lawrence C Paulson. Lightweight relevance filtering for machine-generated resolution problems. Journal of Applied Logic, 7(1):41–57, 2009. ",
+        "bbox": [
+            171,
+            176,
+            823,
+            207
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Matej Moravc´ık, Martin Schmid, Neil Burch, Viliam Lisy, Dustin Morrill, Nolan Bard, Trevor ´ Davis, Kevin Waugh, Michael Johanson, and Michael H. Bowling. Deepstack: Expert-level artificial intelligence in no-limit poker. CoRR, abs/1701.01724, 2017. URL http://arxiv. org/abs/1701.01724. ",
+        "bbox": [
+            173,
+            213,
+            825,
+            270
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Aditya Paliwal, Sarah M. Loos, Markus N. Rabe, Kshitij Bansal, and Christian Szegedy. Graph representations for higher-order logic and theorem proving. In AAAI, 2020. ",
+        "bbox": [
+            171,
+            277,
+            823,
+            308
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Radek Pelanek. BEEM: benchmarks for explicit model checkers. In Dragan Bosnacki and Stefan ´ Edelkamp (eds.), Model Checking Software, 14th International SPIN Workshop, Berlin, Germany, July 1-3, 2007, Proceedings, volume 4595 of Lecture Notes in Computer Science, pp. 263–267. Springer, 2007. doi: 10.1007/978-3-540-73370-6\\ 17. URL https://doi.org/10.1007/ 978-3-540-73370-6_17. ",
+        "bbox": [
+            173,
+            315,
+            825,
+            386
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Chris Piech, Jonathan Huang, Andy Nguyen, Mike Phulsuksombati, Mehran Sahami, and Leonidas Guibas. Learning program embeddings to propagate feedback on student code. In International Conference on Machine Learning, pp. 1093–1102, 2015. ",
+        "bbox": [
+            176,
+            393,
+            821,
+            436
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Amir Pnueli. The temporal logic of programs. In 18th Annual Symposium on Foundations of Computer Science, Providence, Rhode Island, USA, 31 October - 1 November 1977, pp. 46–57, 1977. doi: 10.1109/SFCS.1977.32. URL https://doi.org/10.1109/SFCS.1977.32. ",
+        "bbox": [
+            173,
+            444,
+            826,
+            487
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Stanislas Polu and Ilya Sutskever. Generative language modeling for automated theorem proving, 2020. ",
+        "bbox": [
+            173,
+            494,
+            823,
+            523
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Markus N. Rabe, Dennis Lee, Kshitij Bansal, and Christian Szegedy. Mathematical reasoning via self-supervised skip-tree training. 2020. ",
+        "bbox": [
+            173,
+            531,
+            821,
+            560
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Kristin Y Rozier and Moshe Y Vardi. Ltl satisfiability checking. In International SPIN Workshop on Model Checking of Software, pp. 149–167. Springer, 2007. ",
+        "bbox": [
+            171,
+            568,
+            823,
+            598
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "David Saxton, Edward Grefenstette, Felix Hill, and Pushmeet Kohli. Analysing mathematical reasoning abilities of neural models. CoRR, abs/1904.01557, 2019. URL http://arxiv.org/ abs/1904.01557. ",
+        "bbox": [
+            176,
+            604,
+            823,
+            647
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Franco Scarselli, Marco Gori, Ah Chung Tsoi, Markus Hagenbuchner, and Gabriele Monfardini. The graph neural network model. IEEE Transactions on Neural Networks, 20(1):61–80, 2008. ",
+        "bbox": [
+            173,
+            655,
+            820,
+            685
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Imanol Schlag, Paul Smolensky, Roland Fernandez, Nebojsa Jojic, Jurgen Schmidhuber, and Jian- ¨ feng Gao. Enhancing the transformer with explicit relational encoding for math problem solving. arXiv preprint arXiv:1910.06611, 2019. ",
+        "bbox": [
+            173,
+            691,
+            823,
+            736
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Stephan Schulz. System description: E 1.8. In International Conference on Logic for Programming Artificial Intelligence and Reasoning, pp. 735–743. Springer, 2013. ",
+        "bbox": [
+            169,
+            742,
+            823,
+            773
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Viktor Schuppan and Luthfi Darmawan. Evaluating ltl satisfiability solvers. In International Symposium on Automated Technology for Verification and Analysis, pp. 397–413. Springer, 2011. ",
+        "bbox": [
+            173,
+            780,
+            823,
+            809
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Stefan Schwendimann. A new one-pass tableau calculus for pltl. In International Conference on Automated Reasoning with Analytic Tableaux and Related Methods, pp. 277–291. Springer, 1998. ",
+        "bbox": [
+            173,
+            816,
+            823,
+            847
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Daniel Selsam and Nikolaj Bjørner. Guiding high-performance SAT solvers with unsat-core predictions. In Theory and Applications of Satisfiability Testing - SAT 2019 - 22nd International Conference, SAT 2019, Lisbon, Portugal, July 9-12, 2019, Proceedings, pp. 336– 353, 2019. doi: 10.1007/978-3-030-24258-9\\ 24. URL https://doi.org/10.1007/ 978-3-030-24258-9_24. ",
+        "bbox": [
+            174,
+            854,
+            825,
+            924
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Daniel Selsam, Matthew Lamm, Benedikt Bunz, Percy Liang, Leonardo de Moura, and David L. ¨ Dill. Learning a SAT solver from single-bit supervision. In 7th International Conference on Learning Representations, ICLR 2019, New Orleans, LA, USA, May 6-9, 2019, 2019. URL https://openreview.net/forum?id $\\underline { { \\underline { { \\mathbf { \\Pi } } } } } =$ HJMC_iA5tm. ",
+        "bbox": [
+            174,
+            103,
+            825,
+            160
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Sanjit A. Seshia and Dorsa Sadigh. Towards verified artificial intelligence. CoRR, abs/1606.08514, 2016. URL http://arxiv.org/abs/1606.08514. ",
+        "bbox": [
+            174,
+            170,
+            820,
+            199
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Sanjit A Seshia, Ankush Desai, Tommaso Dreossi, Daniel J Fremont, Shromona Ghosh, Edward Kim, Sumukh Shivakumar, Marcell Vazquez-Chanlatte, and Xiangyu Yue. Formal specification for deep neural networks. In International Symposium on Automated Technology for Verification and Analysis, pp. 20–34. Springer, 2018. ",
+        "bbox": [
+            173,
+            208,
+            825,
+            265
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Vighnesh Leonardo Shiv and Chris Quirk. Novel positional encodings to enable tree-based transformers. In NeurIPS 2019, 2019. URL https://www.microsoft.com/en-us/research/publication/ novel-positional-encodings-to-enable-tree-based-transformers/. ",
+        "bbox": [
+            173,
+            275,
+            825,
+            332
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "David Silver, Julian Schrittwieser, Karen Simonyan, Ioannis Antonoglou, Aja Huang, Arthur Guez, Thomas Hubert, Lucas Baker, Matthew Lai, Adrian Bolton, et al. Mastering the game of go without human knowledge. Nature, 550(7676):354–359, 2017. ",
+        "bbox": [
+            178,
+            342,
+            823,
+            385
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Gagandeep Singh, Timon Gehr, Markus Puschel, and Martin Vechev. An abstract domain for cer- ¨ tifying neural networks. Proceedings of the ACM on Programming Languages, 3(POPL):1–30, 2019. ",
+        "bbox": [
+            176,
+            393,
+            823,
+            435
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Yaniv Taigman, Ming Yang, Marc’Aurelio Ranzato, and Lior Wolf. Deepface: Closing the gap to human-level performance in face verification. In 2014 IEEE Conference on Computer Vision and Pattern Recognition, CVPR 2014, Columbus, OH, USA, June 23-28, 2014, pp. 1701–1708, 2014. doi: 10.1109/CVPR.2014.220. URL https://doi.org/10.1109/CVPR.2014.220. ",
+        "bbox": [
+            173,
+            445,
+            825,
+            503
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Josef Urban. MPTP–motivation, implementation, first experiments. Journal of Automated Reasoning, 33(3-4):319–339, 2004. ",
+        "bbox": [
+            173,
+            512,
+            821,
+            542
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Josef Urban. Malarea: a metasystem for automated reasoning in large theories. ESARLT, 257, 2007. ",
+        "bbox": [
+            171,
+            551,
+            821,
+            568
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Josef Urban and Jan Jakubuv. First neural conjecturing datasets and experiments. In ˚ Conference on Intelligent Computer Mathematics, 2020. ",
+        "bbox": [
+            169,
+            577,
+            823,
+            606
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Josef Urban, Geoff Sutcliffe, Petr Pudlak, and Ji ´ ˇr´ı Vyskocil. Malarea sg1-machine learner for auto- ˇ mated reasoning with semantic guidance. In International Joint Conference on Automated Reasoning, pp. 441–456. Springer, 2008. ",
+        "bbox": [
+            173,
+            614,
+            823,
+            659
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Ashish Vaswani, Noam Shazeer, Niki Parmar, Jakob Uszkoreit, Llion Jones, Aidan N. Gomez, Lukasz Kaiser, and Illia Polosukhin. Attention is all you need. In Advances in Neural Information Processing Systems 30: Annual Conference on Neural Information Processing Systems 2017, 4-9 December 2017, Long Beach, CA, USA, pp. 5998–6008, 2017. URL http: //papers.nips.cc/paper/7181-attention-is-all-you-need. ",
+        "bbox": [
+            173,
+            667,
+            825,
+            739
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Marcell Vazquez-Chanlatte. mvcisback/py-aiger, August 2018. URL https://doi.org/10. 5281/zenodo.1326224. ",
+        "bbox": [
+            173,
+            748,
+            818,
+            777
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Ke Wang, Rishabh Singh, and Zhendong Su. Dynamic neural program embedding for program repair. In ICLR, 2018. ",
+        "bbox": [
+            171,
+            786,
+            821,
+            816
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Yonghui Wu, Mike Schuster, Zhifeng Chen, Quoc V. Le, Mohammad Norouzi, Wolfgang Macherey, Maxim Krikun, Yuan Cao, Qin Gao, Klaus Macherey, Jeff Klingner, Apurva Shah, Melvin Johnson, Xiaobing Liu, Lukasz Kaiser, Stephan Gouws, Yoshikiyo Kato, Taku Kudo, Hideto Kazawa, Keith Stevens, George Kurian, Nishant Patil, Wei Wang, Cliff Young, Jason Smith, Jason Riesa, Alex Rudnick, Oriol Vinyals, Greg Corrado, Macduff Hughes, and Jeffrey Dean. Google’s neural machine translation system: Bridging the gap between human and machine translation. CoRR, abs/1609.08144, 2016. URL http://arxiv.org/abs/1609.08144. ",
+        "bbox": [
+            176,
+            825,
+            825,
+            924
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Yuhuai Wu, Albert Jiang, Jimmy Ba, and Roger Grosse. INT: An Inequality Benchmark for Evaluating Generalization in Theorem Proving. arXiv preprint arXiv:2007.02924, 2020. ",
+        "bbox": [
+            171,
+            103,
+            823,
+            132
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "Zonghan Wu, Shirui Pan, Fengwen Chen, Guodong Long, Chengqi Zhang, and Philip S Yu. A comprehensive survey on graph neural networks. arXiv preprint arXiv:1901.00596, 2019. ",
+        "bbox": [
+            173,
+            141,
+            823,
+            170
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "Kaiyu Yang and Jia Deng. Learning to prove theorems via interacting with proof assistants. arXiv preprint arXiv:1905.09381, 2019. ",
+        "bbox": [
+            173,
+            179,
+            823,
+            208
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "APPENDIX ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            102,
+            264,
+            118
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "A LINEAR-TIME TEMPORAL LOGIC (LTL) ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            133,
+            542,
+            151
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "In this section, we provide the formal syntax and semantics of Linear-time Temporal Logic (LTL). The formal syntax of LTL is given by the following grammar: ",
+        "bbox": [
+            171,
+            165,
+            821,
+            194
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "equation",
+        "img_path": "images/2568c82a2655de566fd922785568b1373d1d9769c75fbe5cbdc1e6a8fbd0824c.jpg",
+        "text": "$$\n\\varphi : = p \\mid \\neg \\varphi \\mid \\varphi \\land \\varphi \\mid \\bigcirc \\varphi \\mid \\varphi \\mathcal { U } \\varphi ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            357,
+            196,
+            635,
+            214
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "where $p \\in A P$ is an atomic proposition. Let $A P$ be a set of atomic propositions. A (explicit) trace $t$ is an infinite sequence over subsets of the atomic propositions. We define the set of traces $T R : = ( 2 ^ { A P } ) ^ { \\omega }$ . We use the following notation to manipulate traces: Let $t ~ \\in ~ T R$ be a trace and $i \\in \\mathbb N$ be a natural number. With $t [ i ]$ we denote the set of propositions at $i$ -th position of $t$ . Therefore, $t [ 0 ]$ represents the starting element of the trace. Let $j \\in \\mathbb N$ and $j \\geq i$ . Then $t [ i , j ]$ denotes the sequence $t$ [i] $t [ i + 1 ] \\ldots i [ j - 1 ] \\ : t [ j ]$ and $t [ i , \\infty ]$ denotes the infinite suffix of $t$ starting at position $i$ . ",
+        "bbox": [
+            173,
+            215,
+            825,
+            314
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "Let $p \\in A P$ and $t \\in T R$ . The semantics of an LTL formula is defined as the smallest relation $\\vDash$ that satisfies the following conditions: ",
+        "bbox": [
+            174,
+            320,
+            820,
+            349
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "$\\begin{array} { r l r l } & { t = p } & & { \\mathrm { i f f } \\qquad p \\in t [ 0 ] } \\\\ & { t \\mathbin { | = \\neg { \\varphi }  } } & & { \\mathrm { i f f } \\qquad t \\mathbin { | \\neq \\varphi  } } \\\\ & { t \\mathbin { | = \\varphi _ { 1 } \\wedge \\varphi _ { 2 } \\qquad } } & & { \\mathrm { i f f } \\qquad t \\mathbin { | = \\varphi _ { 1 } \\mathrm { ~ a n d ~ } t | } \\mathop { | = \\varphi _ { 2 }  } } \\\\ & { t \\mathbin { | = \\bigcirc \\varphi  } } & & { \\mathrm { i f f } \\qquad t [ 1 , \\infty ] \\mathbin { | = \\varphi  } } \\\\ & { t \\mathbin { | = \\varphi _ { 1 } \\mathcal { U } \\varphi _ { 2 } \\qquad } } & & { \\mathrm { i f f } \\qquad \\mathrm { t h e r e ~ e x i s t s ~ } i \\ge 0 : t } \\end{array}$ $i \\geq 0 : t [ i , \\infty ] \\models \\varphi _ { 2 }$ and for all $0 \\le j < i$ we have $t [ j , \\infty ] \\ v = \\varphi _ { 1 }$ ",
+        "bbox": [
+            241,
+            349,
+            750,
+            457
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "There are several derived operators, such as $\\bigcirc \\varphi \\equiv t r u e l l \\varphi$ and $\\sqcup \\varphi \\equiv \\lnot \\bigcirc \\lnot \\varphi . \\bigotimes \\varphi$ states that $\\varphi$ will eventually hold in the future and $\\sqsubset \\varphi$ states that $\\varphi$ holds globally. Operators can be nested: $\\square \\bigcirc \\varphi$ , for example, states that $\\varphi$ has to occur infinitely often. ",
+        "bbox": [
+            174,
+            465,
+            826,
+            508
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "B SIZE DISTRIBUTION IN THE DATASETS ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            529,
+            531,
+            545
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "In this section, we provide insight into the size distribution of our datasets. Figure 5 shows the size distribution of the formulas in our dataset LTLPattern126 . ",
+        "bbox": [
+            174,
+            559,
+            823,
+            587
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "Figure 6 shows the size distribution of our generated formulas and their traces in the dataset LTLRandom35. Table 1 shows three randomly drawn example instances of the dataset LTLRandom35. ",
+        "bbox": [
+            173,
+            593,
+            825,
+            636
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "Lastly, Figure 7 shows the size distribution of formulas in our dataset LTLUnsolved 254. ",
+        "bbox": [
+            174,
+            642,
+            753,
+            659
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "image",
+        "img_path": "images/0288f3e833153530fb6426c58fd2464f6de66ab52bd5d574aafb829a1fb2cf62.jpg",
+        "image_caption": [
+            "Figure 5: Size distributions in the LTLPattern126 test set: on the $\\mathbf { X }$ -axis is the size of the formulas; on the y-axis the number of formulas. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            223,
+            693,
+            761,
+            876
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "image",
+        "img_path": "images/3eb9ccf964e1fd9bb4b953034e79b6c10fde1a7b82c505e53ef3102135fafce9.jpg",
+        "image_caption": [
+            "Figure 6: Size distributions in the LTLRandom35 training set: on the $\\mathbf { X }$ -axis is the size of the formulas/traces; on the y-axis the number of formulas/traces. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            183,
+            112,
+            823,
+            260
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "table",
+        "img_path": "images/2bcb080019099cde0279c98d4f649ee89717b47d6befc89978254fe8d9ea6632.jpg",
+        "table_caption": [
+            "Table 1: Three random examples from LTLRandom35 training set. The first line shows the LTL formula and the symbolic trace in mathematical notation. The second line shows the syntactic representation (in Polish notation): "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=1 colspan=1>LTL formula</td><td rowspan=1 colspan=1>satisfying symbolic trace</td></tr><tr><td rowspan=1 colspan=1>O((du c)uOOd) ^ O(b^ -(-duc))&amp;XUUdcXXdX&amp;b!U!dc</td><td rowspan=1 colspan=1>true (b^-c^ -d) (-c^d)d(true)ω1;&amp;&amp;b!c!d;&amp;!cd;d;{1}</td></tr><tr><td rowspan=1 colspan=1>-O(Oe ^ (trueub) ^Oc)uc)!XU&amp;&amp;XeU1bXcc</td><td rowspan=1 colspan=1>true(-b^-c)(-b)w1;&amp;!b!c;{!b}</td></tr><tr><td rowspan=1 colspan=1>O-((-c∧d)uOd)X!U&amp;!cdXd</td><td rowspan=1 colspan=1>true (cV-d)(-d) (true)w1;|c!d;!d;{1}</td></tr></table>",
+        "bbox": [
+            210,
+            383,
+            790,
+            489
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "image",
+        "img_path": "images/7e4454d31a8f5abd5e8264b1f163e25993d6efc0eb0d5cd785f219dab7972544.jpg",
+        "image_caption": [
+            "Figure 7: Size distributions in the LTLUnsolved254 test set: on the $\\mathbf { X }$ -axis is the size of the formulas; on the y-axis the number of formulas. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            228,
+            540,
+            761,
+            723
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "text",
+        "text": "C HYPERPARAMETER ANALYSIS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            795,
+            460,
+            810
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "text",
+        "text": "Table 2 shows the effect of the most significant parameters on the performance of Transformers. The performance largely benefits from an increased number of layers, with 8 yielding the best results. Increasing the number further, even with much more training time, did not result in better or even led to worse results. A slightly less important role plays the number of heads and the dimension of the intermediate fully-connected feed-forward networks (FC). While a certain FC size is important, increasing it alone will not improve results. Changing the number of heads alone has also almost no impact on performance. Increasing both simultaneously, however, will result in a small gain. ",
+        "bbox": [
+            174,
+            825,
+            825,
+            924
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "table",
+        "img_path": "images/b3d8666eb6fdf6cc268b94574c77ad9835cc5db80f948065eaa79c76ea4632a6.jpg",
+        "table_caption": [
+            "Table 2: Syntactic accuracy and semantic accuracy of different Transformers, tested on LTLRandom35: Layers refer to the size of the encoder and decoder stacks; Heads refer to the number of attention heads; FC size refers to the size of the fully-connected neural networks inside the encoder and decoders. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Embedding size</td><td>Layers</td><td>Heads</td><td>FC size</td><td>Batch Size</td><td>Train Steps</td><td>Syn. Acc.</td><td>Sem. Acc.</td></tr><tr><td>128</td><td>3</td><td>4</td><td>512</td><td>512</td><td>45K</td><td>78.0%</td><td>97.1%</td></tr><tr><td>128</td><td>5</td><td>2</td><td>512</td><td>512</td><td>45K</td><td>80.4%</td><td>97.4%</td></tr><tr><td>128</td><td>5</td><td>4</td><td>256</td><td>512</td><td>45K</td><td>81.0%</td><td>97.4%</td></tr><tr><td>128</td><td>5</td><td>4</td><td>512</td><td>512</td><td>45K</td><td>82.0%</td><td>97.9%</td></tr><tr><td>128</td><td>5</td><td>4</td><td>1024</td><td>512</td><td>45K</td><td>80.3%</td><td>97.3%</td></tr><tr><td>128</td><td>5</td><td>6</td><td>1024</td><td>512</td><td>45K</td><td>81.8%</td><td>97.7%</td></tr><tr><td>128</td><td>5</td><td>8</td><td>512</td><td>512</td><td>45K</td><td>82.0%</td><td>97.8%</td></tr><tr><td>128</td><td>5</td><td>8</td><td>1024</td><td>512</td><td>45K</td><td>82.5%</td><td>97.9%</td></tr><tr><td>128</td><td>5</td><td>8</td><td>1500</td><td>512</td><td>45K</td><td>82.6%</td><td>97.8%</td></tr><tr><td>128</td><td>5</td><td>12</td><td>1024</td><td>512</td><td>45K</td><td>81.9%</td><td>97.5%</td></tr><tr><td>128</td><td>8</td><td>4</td><td>512</td><td>512</td><td>45K</td><td>83.2%</td><td>98.3%</td></tr><tr><td>128</td><td>8</td><td>8</td><td>1024</td><td>768</td><td>50K</td><td>83.8%</td><td>98.5 %</td></tr><tr><td>128</td><td>10</td><td>4</td><td>512</td><td>512</td><td>75K</td><td>82.9%</td><td>97.6%</td></tr><tr><td>256</td><td>5</td><td>4</td><td>512</td><td>512</td><td>45K</td><td>82.3%</td><td>97.9%</td></tr></table>",
+        "bbox": [
+            178,
+            167,
+            821,
+            369
+        ],
+        "page_idx": 16
+    },
+    {
+        "type": "text",
+        "text": "This seems reasonable, since more heads can provide more distinct information to the subsequent processing by the fully-connected feed-forward network. Increasing the embeddings size from 128 to 256 very slightly improves the syntactic accuracy. But likewise it also degrades the semantic accuracy, so we therefore stuck with the former setting. ",
+        "bbox": [
+            174,
+            421,
+            825,
+            479
+        ],
+        "page_idx": 16
+    },
+    {
+        "type": "text",
+        "text": "D ACCURACY DURING TRAINING ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            529,
+            470,
+            545
+        ],
+        "page_idx": 16
+    },
+    {
+        "type": "text",
+        "text": "In Figure 8 we show the evolution of both the syntactic accuracy and the semantic accuracy during the training process. Note the significant difference right from the beginning. This demonstrates the importance of a suitable performance measure when evaluating machine learning algorithms on logical reasoning tasks. ",
+        "bbox": [
+            173,
+            579,
+            825,
+            635
+        ],
+        "page_idx": 16
+    },
+    {
+        "type": "image",
+        "img_path": "images/abf06e6c3dba60461ef5f14a0da3e90dc543dc516389917e3a2910a39edc3228.jpg",
+        "image_caption": [
+            "Figure 8: Syntactic accuracy (blue) and semantic accuracy (red) of our best performing model, evaluated on a subset of 5K samples of LTLRandom35 per epoch. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            292,
+            678,
+            702,
+            876
+        ],
+        "page_idx": 16
+    },
+    {
+        "type": "text",
+        "text": "E DIFFERENT POSITIONAL ENCODINGS ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            102,
+            517,
+            118
+        ],
+        "page_idx": 17
+    },
+    {
+        "type": "image",
+        "img_path": "images/ce515aefca784f7918c53561fbbc8f07f8373bc2ed923f3d58f53f7050cf415e.jpg",
+        "image_caption": [
+            "Figure 9: Performance of our best model (only trained on LTLRandom35) on LTLRandom50 with a standard positional encoding (top) and a tree positional encoding (bottom). The syntactic accuracy is displayed in green, the semantic accuracy in light green and the incorrect predictions in orange. The shaded area indicates the formula sizes the model was not trained on. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            171,
+            140,
+            807,
+            422
+        ],
+        "page_idx": 17
+    },
+    {
+        "type": "text",
+        "text": "F HANDCRAFTED EXAMPLES ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            527,
+            434,
+            544
+        ],
+        "page_idx": 17
+    },
+    {
+        "type": "image",
+        "img_path": "images/ef07a34ff1bb206f4dc99481b68b544352a3ce096aa5580d8af80817cd727bff.jpg",
+        "image_caption": [
+            "Figure 10: Self-attention of the example propositional formula $b \\lor \\neg ( a \\land d )$ in dataset PropRandom35 (left). Encoder-decoder-attention of the example LTL formula $( b \\mathcal { U } a ) \\wedge ( a \\mathcal { U } \\neg a )$ in dataset LTLRandom35 (right). "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            243,
+            565,
+            751,
+            707
+        ],
+        "page_idx": 17
+    },
+    {
+        "type": "text",
+        "text": "The LTL formula $( b \\mathcal { U } a ) \\wedge ( a \\mathcal { U } \\neg a )$ states that $b$ has to hold along the trace until $a$ holds and $a$ has to hold until $a$ does not hold anymore. The automaton-based generator suggests the trace $( \\neg a \\land$ b) $\\textit { a } ( t r u e ) ^ { \\omega }$ , i.e., to first satisfy the second until by immediately disallowing $a$ . The satisfaction of the first until is then postponed to the second position of trace, which forces $b$ to hold on the first position. The Transformer, however, chooses the following more general trace $a \\left( \\neg a \\right) \\left( t r u e \\right) ^ { \\omega }$ , by satisfying the until operators in order (see Figure 10). ",
+        "bbox": [
+            173,
+            790,
+            825,
+            875
+        ],
+        "page_idx": 17
+    }
+]