Add files using upload-large-folder tool

parse/train/Hkx6hANtwH/Hkx6hANtwH.md

@@ -0,0 +1,266 @@
+# LAMBDANET: PROBABILISTIC TYPE INFERENCE USING GRAPH NEURAL NETWORKS
+
+Jiayi Wei, Maruth Goyal, Greg Durrett, Isil Dillig
+
+Department of Computer Science   
+University of Texas at Austin   
+{jiayi, maruth, gdurrett, isil}@cs.utexas.edu
+
+# ABSTRACT
+
+As gradual typing becomes increasingly popular in languages like Python and TypeScript, there is a growing need to infer type annotations automatically. While type annotations help with tasks like code completion and static error catching, these annotations cannot be fully determined by compilers and are tedious to annotate by hand. This paper proposes a probabilistic type inference scheme for TypeScript based on a graph neural network. Our approach first uses lightweight source code analysis to generate a program abstraction called a type dependency graph, which links type variables with logical constraints as well as name and usage information. Given this program abstraction, we then use a graph neural network to propagate information between related type variables and eventually make type predictions. Our neural architecture can predict both standard types, like number or string, as well as user-defined types that have not been encountered during training. Our experimental results show that our approach outperforms prior work in this space by $1 4 \%$ (absolute) on library types, while having the ability to make type predictions that are out of scope for existing techniques.
+
+# 1 INTRODUCTION
+
+Dynamically typed languages like Python, Ruby, and Javascript have gained enormous popularity over the last decade, yet their lack of a static type system comes with certain disadvantages in terms of maintainability (Hanenberg et al., 2013), the ability to catch errors at compile time, and code completion support (Gao et al., 2017). Gradual typing can address these shortcomings: program variables have optional type annotations so that the type system can perform static type checking whenever possible (Siek & Taha, 2007; Chung et al., 2018). Support for gradual typing now exists in many popular programming languages (Bierman et al., 2014; Vitousek et al., 2014), but due to their heavy use of dynamic language constructs and the absence of principal types (Ancona & Zucca, 2004), compilers cannot perform type inference using standard algorithms from the programming languages community (Bierman et al., 2014; Traytel et al., 2011; Pierce & Turner, 2000), and manually adding type annotations to existing codebases is a tedious and error-prone task. As a result, legacy programs in these languages do not reap all the benefits of gradual typing.
+
+To reduce the human effort involved in transitioning from untyped to statically typed code, this work focuses on a learning-based approach to automatically inferring likely type annotations for untyped (or partially typed) codebases. Specifically, we target TypeScript, a gradually-typed variant of Javascript for which plenty of training data is available in terms of type-annotated programs. While there has been some prior work on inferring type annotations for TypeScript using machine learning (Hellendoorn et al., 2018; Raychev et al., 2015), prior work in this space has several shortcomings. First, inference is restricted to a finite dictionary of types that have been observed during training time—i.e., they cannot predict any user-defined data types. Second, even without considering user-defined types, the accuracy of these systems is relatively low, with the current state-of-theart achieving $5 6 . 9 \%$ accuracy for primitive/library types (Hellendoorn et al., 2018). Finally, these techniques can produce inconsistent results in that they may predict different types for different token-level occurrences of the same variable.
+
+![](images/76a4914e3ed97a06eaeb1df44f451c9eadd1a690c6cdf2fa9da57ca02985eee1.jpg)  
+Figure 1: A motivating example: Given an unannotated version of this TypeScript program, a traditional rule-based type inference algorithm cannot soundly deduce the true type annotations (shown in green).
+
+In this paper, we propose a new probabilistic type inference algorithm for TypeScript to address these shortcomings using a graph neural network architecture (GNN) (Velickovi ˇ c et al., 2018; Li et al., ´ 2016; Mou et al., 2016). Our method uses lightweight source code analysis to transform the program into a new representation called a type dependency graph, where nodes represent type variables and labeled hyperedges encode relationships between them. In addition to expressing logical constraints (e.g., subtyping relations) as in traditional type inference, a type dependency graph also incorporates contextual hints involving naming and variable usage.
+
+Given such a type dependency graph, our approach uses a GNN to compute a vector embedding for each type variable and then performs type prediction using a pointer-network-like architecture (Vinyals et al., 2015). The graph neural network itself requires handling a variety of hyperedge types—some with variable numbers of arguments—for which we define appropriate graph propagation operators. Our prediction layer compares the vector embedding of a type variable with vector representations of candidate types, allowing us to flexibly handle user-defined types that have not been observed during training. Moreover, our model predicts consistent type assignments by construction because it makes variable-level rather than token-level predictions.
+
+We implemented our new architecture as a tool called LAMBDANET and evaluated its performance on real-world TypeScript projects from Github. When only predicting library types, LAMBDANET has a top1 accuracy of $7 5 . 6 \%$ , achieving a significant improvement over DeepTyper $( 6 1 . 5 \% )$ . In terms of overall accuracy (including user-defined types), LAMBDANET achieves a top1 accuracy of around $6 4 . 2 \%$ , which is $5 5 . 2 \%$ (absolute) higher than the TypeScript compiler.
+
+Contributions. This paper makes the following contributions: (1) We propose a probabilistic type inference algorithm for TypeScript that uses deep learning to make predictions from the type dependency graph representation of the program. (2) We describe a technique for computing vector embeddings of type variables using GNNs and propose a pointer-network-like method to predict user-defined types. (3) We experimentally evaluate our approach on hundreds of real-world TypeScript projects and show that our method significantly improves upon prior work.
+
+# 2 MOTIVATING EXAMPLE AND PROBLEM SETTING
+
+Figure 1 shows a (type-annotated) TypeScript program. Our goal in this work is to infer the types shown in the figure, given an unannotated version of this code. We now justify various aspects of our solution using this example.
+
+Typing constraints. The use of certain functions/operators in Figure 1 imposes hard constraints on the types that can be assigned to program variables. For example, in the forward function, variables $_ \textrm { x }$ , y must be assigned a type that supports a concat operation; hence, x, y could have types like string, array, or Tensor, but not, for example, boolean. This observation motivates us to incorporate typing constraints into our model.
+
+Contextual hints. Typing constraints are not always sufficient for determining the intended type of a variable. For example, for variable network in function restore, the typing constraints require network’s type to be a class with a field called time, but there can be many classes that have such an attribute (e.g., Date). However, the similarity between the variable name network
+
+1 var c1: $\tau _ { 8 } =$ class MyNetwork {   
+2 name: τ1; time: $\tau _ { 2 }$ ;   
+3 var m1: $\begin{array} { r l } { \tau _ { 9 } } & { { } = } \end{array}$ function forward(x: $\tau _ { 3 }$ , $y : \ \tau _ { 4 } ) : \tau _ { 5 }$ {   
+4 var v1: $\tau _ { 1 0 } ~ = ~ \mathrm { ~ x ~ }$ .concat; var v2: $\tau _ { 1 1 } ~ = ~ \mathrm { { v } 1 }$ (y);   
+5 var v3: $\tau _ { 1 2 } =$ v2.TIMES_OP; var v4: $\tau _ { 1 3 } ~ = ~ \mathrm { ~ v ~ } 3$ (NUMBER);   
+6 return v4;   
+7 }   
+8 // more classes..   
+9 var $\pm 1 : \tau _ { 1 4 } =$ function restore (network: $\tau _ { 6 } ) : \tau _ { 7 }$ {   
+10 var v3: $\tau _ { 1 5 } ~ =$ network.time;   
+11 var v4: $\tau _ { 1 6 } ~ =$ readNumber(STRING);   
+12 network.time $\qquad = \quad \mathtt { v 4 }$ ; // more code...   
+13 }
+
+![](images/c379e43ee1c078f294bc4ea605359a81dff643be05acb373a176d554360d5b82.jpg)  
+Figure 2: An intermediate representation of the (unannotated version) program from Figure 1. The $\tau _ { i }$ represent type variables, among which $\tau _ { 8 } - \tau _ { 1 6 }$ are newly introduced for intermediate expressions.   
+Figure 3: Example hyperedges for Figure 2. Edge labels in gray (resp. red) are positional arguments (resp. identifiers). (A) The return statement at line 6 induces a subtype relationship between $\tau _ { 1 3 }$ and $\tau _ { 5 }$ . $\mathbf { ( B ) }$ MyNetwork $\tau _ { 8 }$ declares attributes name $\tau _ { 1 }$ and time $\tau _ { 2 }$ and method forward $\tau _ { 9 }$ . (C) $\tau _ { 1 4 }$ is associated with a variable whose named is restore. $\mathbf { \eta } ^ { ( \mathbf { D } ) }$ Usage hyperedge for line 10 connects $\tau _ { 6 }$ and $\tau _ { 1 5 }$ to all classes with a time attribute.
+
+and the class name MyNetwork hints that network might have type MyNetwork. Based on this belief, we can further propagate the return type of the library function readNumber (assuming we know it is number) to infer that the type of the time field in MyNetwork is likely to be number.
+
+Need for type dependency graph. There are many ways to view programs—e.g., as token sequences, abstract syntax trees, control flow graphs, etc. However, none of these representations is particularly helpful for inferring the most likely type annotations. Thus, our method uses static analysis to infer a set of predicates that are relevant to the type inference problem and represents these predicates using a program abstraction called the type dependency graph.
+
+Handling user-defined types. As mentioned in Section 1, prior techniques can only predict types seen during training. However, the code from Figure 1 defines its own class called MyNetwork and later uses a variables of type MyNetwork in the restore method. A successful model for this task therefore must dynamically make inferences about user-defined types based on their definitions.
+
+# 2.1 PROBLEM SETTING
+
+Our goal is to train a type inference model that can take as input an entirely (or partially) unannotated TypeScript project $g$ and output a probability distribution of types for each missing annotation. The prediction space is $\mathcal { V } ( g ) = \mathcal { V } _ { \mathrm { l i b } } \cup \mathcal { V } _ { \mathrm { u s e r } } ( g )$ , where $\mathcal { V } _ { \mathrm { u s e r } } ( g )$ is the set of all user-defined types (classes/interfaces) declared within $g$ , and ${ \mathcal { N } } _ { \mathrm { l i b } }$ is a fixed set of commonly-used library types.
+
+Following prior work in this space (Hellendoorn et al., 2018; Raychev et al., 2015; Xu et al., 2016), we limit the scope of our prediction to non-polymorphic and non-function types. That is, we do not distinguish between types such as List<T>, List<number>, List<string> etc., and consider them all to be of type List. Similarly, we also collapse function types like number string and string string into a single type called Function. We leave the extension of predicting structured types as future work.
+
+Table 1: Different types of hyperedges used in a type dependency graph.   
+
+<table><tr><td>Type</td><td>Edge</td><td>Description</td></tr><tr><td colspan="2">Logical α is used as boolean</td></tr><tr><td>FIXED</td><td>Bool(α)</td></tr><tr><td>FIXED</td><td>Subtype(α, β) α is a subtype of β</td></tr><tr><td>FIXED</td><td>Assign(α, β)t β is assigned to α α=(β1,...,βk)→β*</td></tr><tr><td>NARY NARY</td><td>Function(α,βi,...,βk, β*)</td></tr><tr><td>NARY</td><td>Call(a,β*,β1,..., βk) α=β*(β1,...,βk)</td></tr><tr><td>FIXED</td><td>Object.,(α,βi,...,βk)） α={l1:β1,...,lk :βk} Accesst(a,β) α= β.l</td></tr><tr><td colspan="2">αhas name l</td></tr><tr><td>FIXED</td><td>Contextual</td></tr><tr><td>Namet(α) FIXED</td><td>NameSimilar(α, β) α,βhave similar names</td></tr></table>
+
+† Although assignment is a special case of a subtype constraint, we differentiate them because these edges appear in different contexts and having uncoupled parameters for these two edge types is beneficial.
+
+# 3 TYPE DEPENDENCY GRAPH
+
+A type dependency graph $\mathcal { G } = ( N , E )$ is a hypergraph where nodes $N$ represent type variables and labeled hyperedges $E$ encode relationships between them. We extract the type dependency graph of a given TypeScript program by performing static analysis on an intermediate representation of its source code, which allows us to associate a unique variable with each program sub-expression. As an illustration, Figure 2 shows the intermediate representation of the code from Figure 1.
+
+Intuitively, a type dependency graph encodes properties of type variables as well as relationships between them. Each hyperedge corresponds to one of the predicates shown in Table 1. We partition our predicates (i.e., hyperedges) into two classes, namely Logical and Contextual, where the former category can be viewed as imposing hard constraints on type variables and the latter category encodes useful hints extracted from names of variables, functions, and classes.
+
+Figure 3 shows some of the hyperedges in the type dependency graph $\mathcal { G }$ extracted from the intermediate representation in Figure 2. As shown in Figure 3(A), our analysis extracts a predicate Subtype $( \tau _ { 1 3 } , \tau _ { 5 } )$ from this code because the type variable associated with the returned expression $\mathtt { v 4 }$ must be a subtype of the enclosing function’s return type. Similarly, as shown in Figure 3(B), our analysis extracts a predicate $\mathrm { O b j e c t } _ { \mathrm { n a m e , t i m e , f o r w a r d } } ( \tau _ { 8 } , \tau _ { 1 } , \tau _ { 2 } , \tau _ { 9 } )$ because $\tau _ { 8 }$ is an object type whose name, time, and forward members are associated with type variables $\tau _ { 1 } , \tau _ { 2 } , \tau _ { 9 }$ , respectively.
+
+In contrast to the Subtype and Object predicates that impose hard constraints on type variables, the next two hyperedges shown in Figure 3 encode contextual clues obtained from variable names. Figure 3(C) indicates that type variable $\tau _ { 1 4 }$ is associated with an expression named restore. While this kind of naming information is invisible to TypeScript’s structural type system (?), it serves as a useful input feature for our GNN architecture described in Section 4.
+
+In addition to storing the unique variable name associated with each type variable, the type dependency graph also encodes similarity between variable and class names. The names of many program variables mimic their types: for example, instances of a class called MyNetwork might often be called network or network1. To capture this correspondence, our type dependency graph also contains a hyperedge called NameSimilar that connects type variables $\alpha$ and $\beta$ if their corresponding tokenized names have a non-empty intersection.1
+
+As shown in Table 1, there is a final type of hyperedge called Usage that facilitates type inference of object types. In particular, if there is an object access var $\mathrm { ~ y ~ } = \mathrm { ~ x ~ . ~ } \bot$ , we extract the predicate $\operatorname { U s a g e } _ { l } ( ( \tau _ { x } , \tau _ { y } ) , ( \alpha _ { 1 } , \beta _ { 1 } ) , \dots , ( \alpha _ { k } , \beta _ { k } ) )$ to connect $_ \textrm { x }$ and y’s type variables with all classes $\alpha _ { i }$ that contain an attribute/method $\beta _ { i }$ whose name is l. Figure 3 shows a Usage hyperedge extracted from the code in Figure 2. As we will see in the next section, our GNN architecture utilizes a special attention mechanism to pass information along these usage edges.
+
+# 4 NEURAL ARCHITECTURE
+
+Our neural architecture for making type predictions consists of two main parts. First, a graph neural network passes information along the type dependency graph to produce a vector-valued embedding for each type variable based on its neighbors. Second, a pointer network compares each variable’s type embedding to the embedding vectors of candidate types (both computed from the previous phase) to place a distribution over possible type assignments.
+
+Given a type dependency graph $\mathcal { G } = ( N , E )$ , we first to compute a vector embedding $\mathbf { v } _ { n }$ for each $n \in N$ such that these vectors implicitly encode type information. Because our program abstraction is a graph, a natural choice is to use a graph neural network architecture. From a high level, this architecture takes in initial vectors $ { \mathbf { v } } _ { n } ^ { 0 }$ for each node $n$ , performs $K$ rounds of message-passing in the graph neural network, and returns the final representation for each type variable.
+
+In more detail, let $\mathbf { v } _ { n } ^ { t }$ denote the vector representation of node $n$ at the tth step, where each round consists of a message passing and an aggregation step. The message passing step computes a vectorvalued update to send to the $j$ th argument of each hyper-edge $e \in E$ connecting nodes $p _ { 1 } , \ldots , p _ { a }$ . Then, once all the messages have been computed, the aggregation step computes a new embedding $\mathbf { v } _ { n } ^ { t }$ for each $n$ by combining all messages sent to $n$ :
+
+$$
+\begin{array} { r } { \mathbf { m } _ { e , p _ { j } } ^ { t } = \mathrm { M s g } _ { e , j } \bigl ( \mathbf { v } _ { p _ { 1 } } ^ { t - 1 } , \ldots , \mathbf { v } _ { p _ { a } } ^ { t - 1 } \bigr ) \quad \mathbf { v } _ { n } ^ { t } = \mathrm { A g g r } ( \mathbf { v } _ { n } ^ { t - 1 } , \{ \mathbf { m } _ { e , n } ^ { t } | e \in \mathcal { N } ( n ) \} ) } \end{array}
+$$
+
+Here, $\mathcal { N }$ is the neighborhood function, and $\mathrm { M s g } _ { e }$ denotes a particular neural operation that depends on the type of the edge (FIXED, NARY, or NPAIRS), which we will describe later.
+
+Initialization. In our GNN, nodes correspond to type variables and each type variable is associated either with a program variable or a constant. We refer to nodes representing constants (resp. variables) as constant (resp. variable) nodes, and our initialization procedure works differently depending on whether or not $n$ is a constant node. Since the types of each constant are known, we set the initial embedding for each constant node of type $\tau$ (e.g., string) to be a trainable vector $\mathbf { c } _ { \tau }$ and do not update it during GNN iterations (i.e., $\forall t , \mathbf { v } _ { n } ^ { t } = \mathbf { c } _ { \tau } )$ ). On the other hand, if $n$ is a variable node, then we have no information about its type during initialization; hence, we initialize all variable nodes using a generic trainable initial vector (i.e., they are initialized to the same vector but updated to different values during GNN iterations).
+
+Message passing. Our Msg operator depends on the category of edge it corresponds to (see Table 1); however, weights are shared between all instances of the same hyperedge type. In what follows, we describe the neural layer that is used to compute messages for each type of hyperedge:
+
+• FIXED: Since these edges correspond to fixed arity predicates (and the position of each argument matters), we compute the message of the $j$ th argument by first concatenating the embedding vector of all arguments and then feed the result vector to a 2-layer MLP for the $j$ th argument. In addition, since hyperedges of type Access have an identifier, we also embed the identifier as a vector and treat it as an extra argument. (We describe the details of identifier embedding later in this section.) • NARY: Since NARY edges connect a variable number of nodes, we need an architecture that can deal with this challenge. In our current implementation of LAMBDANET, we use a simple architecture that is amenable to batching. Specifically, given an NARY edge $E _ { l _ { 1 } , \dots , l _ { k } } ( \alpha , \beta _ { 1 } , \dots , \beta _ { k } )$ (for Function and $C a l l$ , the labels $l _ { j }$ are argument positions), the set of messages for $\alpha$ is computed as $\{ \mathrm { M L P } _ { \alpha } ( \mathbf { v } _ { l _ { j } } \| \mathbf { v } _ { \beta _ { j } } ) \vert j = 1 \dots k \}$ , and the message for each $\beta _ { j }$ is computed as $\mathrm { M L P } _ { \beta } ( \mathbf { v } _ { l _ { j } } \| \mathbf { v } _ { \alpha } )$ . Observe that we compute $k$ different messages for $\alpha$ , and the message for each $\beta _ { j }$ only depends on the vector embedding of $\alpha$ and its position $j$ , but not the vector embeddings of other $\beta _ { j }$ ’s.2 • NPAIRS: This is a special category associated with $\operatorname { U s a g e } _ { l } ( ( \alpha ^ { * } , \beta ^ { * } ) , ( \alpha _ { 1 } , \beta _ { 1 } ) , \dots , ( \alpha _ { k } , \beta _ { k } ) )$ . Recall that this kind of edge arises from expressions of the form $b = a . l$ and is used to connect $a$ and $b$ ’s type variables with all classes $\alpha _ { i }$ that contain an attribute/method $\beta _ { i }$ with label $l$ . Intuitively, if $a$ ’s type embedding is very similar to a type $C$ , then $b$ ’s type will likely be the same as $C . l$ ’s type. Following this reasoning, we use dot-product based attention to compute the messages for $\alpha ^ { * }$ and $\beta ^ { * }$ . Specifically, we use $\alpha ^ { * }$ and $\alpha _ { j }$ ’s as attention keys and $\beta _ { j }$ ’s as attention values to compute the message for $\beta ^ { * }$ (and switch the key-value roles to compute the message for $\alpha ^ { * }$ ):
+
+$$
+\mathbf { m } _ { e , \beta ^ { * } } ^ { t } = \sum _ { j } w _ { j } \mathbf { v } _ { \beta _ { j } } ^ { t - 1 } \quad \quad \mathbf { w } = \mathrm { s o f t m a x } ( \mathbf { a } ) \quad \quad a _ { j } = \mathbf { v } _ { \alpha _ { j } } \cdot \mathbf { v } _ { \alpha ^ { * } }
+$$
+
+Aggregation. Recall that the aggregation step combines all messages sent to node $n$ to compute the new embedding $\boldsymbol { v } _ { n } ^ { t }$ . To achieve this goal, we use a variant of the attention-based aggregation operator proposed in graph attention networks (Velickovi ˇ c et al., 2018). ´
+
+$$
+v _ { n } ^ { t } = \operatorname { A g g r } ( v _ { n } ^ { t - 1 } , \{ m _ { e , n } ^ { t } | e \in \mathcal { N } ( n ) \} ) = v _ { n } ^ { t - 1 } + \sum _ { e \in \mathcal { N } ( n ) } w _ { e } \mathbf { M } _ { 1 } m _ { e , n } ^ { t }
+$$
+
+where $w _ { e }$ is the attention weight for the message coming from edge $e$ . Specifically, the weights $w _ { e }$ are computed as softmax(a), where $a _ { e } = \mathrm { L e a k y R e L } \mathbf { \bar { u } } ( v _ { n } ^ { t - 1 } \cdot \bar { \mathbf { M } } _ { 2 } m _ { e , n } ^ { t } )$ , and ${ { \bf { M } } _ { 1 } }$ and $\mathbf { M } _ { 2 }$ are trainable matrices. Similar to the original GAT architecture, we set the slope of the LeakyReLu to be 0.2, but we use dot-product to compute the attention weights instead of a linear model.
+
+Identifier embedding. Like in Allamanis et al. (2017), we break variable names into word tokens according to camel case and underscore rules and assign a trainable vector for all word tokens that appear more than once in the training set. For all other tokens, unlike Allamanis et al. (2017), which maps them all into one single <Unknown $>$ token, we randomly mapped them into one of the <Unknown $- \dot { \textrm { \scriptsize 1 } } >$ tokens, where $i$ ranges from 0 to 50 in our current implementation. This mapping is randomly constructed every time we run the GNN and hence helps our neural networks to distinguish different tokens even if they are rare tokens. We train these identifier embeddings end-to-end along with the rest of our architecture.
+
+Prediction Layer. For each type variable $n$ and each candidate type $c \in \mathcal { V } ( g )$ , we use a MLP to compute a compatibility score $s _ { n , c } = \mathrm { M L P } ( \mathbf { v } _ { n } , \mathbf { u } _ { c } )$ , where $\mathbf { u } _ { c }$ is the embedding vector for $c$ . If $c \in \mathcal { V } _ { \mathrm { l i b } }$ , ${ \bf v } _ { c }$ is a trainable vector for each library type $c$ ; if $c \in \mathcal { V } _ { \mathrm { u s e r } } ( g )$ , then it corresponds to a node $n _ { c }$ in the type dependency graph of $g$ , so we just use the embedding vector for $n _ { c }$ and set $\mathbf { u } _ { c } = \mathbf { v } _ { n _ { c } }$ . Formally, this approach looks like a pointer network (Vinyals et al., 2015), where we use the embeddings computed during the forward pass to predict “pointers” to those types.
+
+Given these compatibility scores, we apply a softmax layer to turn them into a probability distribution. i.e., $\begin{array} { r } { P _ { n } ( c | g ) = \exp ( s _ { n , c } ) / \sum _ { c ^ { \prime } } \exp ( s _ { n , c ^ { \prime } } ) } \end{array}$ . During test time, we max over the probabilities to compute the most likely (or top-N) type assignments.
+
+# 5 EVALUATION
+
+In this section, we describe the results of our experimental evaluation, which is designed to answer the following questions: (1) How does our approach compare to previous work? (2) How well can our model predict user-defined types? (3) How useful is each of our model’s components?
+
+Dataset. Similar to Hellendoorn et al. (2018), we train and evaluate our model on popular opensource TypeScript projects taken from Github. Specifically, we collect 300 popular TypeScript projects from Github that contain between 500 to 10, 000 lines of code and where at least $1 0 \%$ of type annotations are user-defined types. Note that each project typically contains hundreds to thousands of type variables to predict, and these projects in total contain about 1.2 million lines of TypeScript code. Among these 300 projects, we use 60 for testing, 40 for validation, and the remainder for training.
+
+Code Duplication. We ran jscpd3 on our entire data set and found that only $2 . 7 \%$ of the code is duplicated. Furthermore, most of these duplicates are intra-project. Thus, we believe that code duplication is not a severe problem in our dataset.
+
+Preprocessing. Because some of the projects in our benchmark suite are only sparsely type annotated, we augment our labeled training data by using the forward type inference functionality provided by the TypeScript compiler.4 The compiler cannot infer the type of every variable and leaves many labeled as any during failed inference; thus, we exclude any labels in our data set.
+
+Furthermore, at test time, we evaluate our technique only on annotations that are manually added by developers. This is the same methodology used by Hellendoorn et al. (2018), and, since developers often add annotations where code is most unclear, this constitutes a challenging setting for type prediction.
+
+Prediction Space. As mentioned in Section 2.1, our approach takes an entire TypeScript project $g$ as its input, and the corresponding type prediction space is $\mathcal { V } ( g ) = \mathcal { V } _ { \mathrm { l i b } } \cup \mathcal { V } _ { \mathrm { u s e r } } ( g )$ . In our experiments, we set $\mathcal { V } _ { \mathrm { u s e r } } ( g )$ to be all classes/interfaces defined in $g$ (except when comparing with DeepTyper, where we set $\mathcal { V } _ { \mathrm { u s e r } } ( g )$ to be empty), and for ${ \mathcal { N } } _ { \mathrm { l i b } }$ , we select the top-100 most common types in our training set. Note that this covers $9 8 \%$ (resp. $9 7 . 5 \%$ ) of the non-any annotations for the training (resp. test) set.
+
+Hyperparameters We selected hyperparameters by tuning on a validation set as we were developing our model. We use 32-dimensional type embedding vectors, and all MLP transformations in our model use one hidden layer of 32 units, except the MLP for computing scores in the prediction layer, which uses three hidden layers of sizes 32,16, and 8 (and size 1 for output). GNN message-passing layers from different time steps have independent weights.
+
+We train our model using Adam (Kingma & Ba, 2014) with default parameters ( $\alpha = 0 . 9$ , $\beta = 0 . 9 9 9 \mathrm { \Omega }$ ) and set the learning rate to be $1 0 ^ { - 3 }$ initially but linearly decrease it to $1 0 ^ { - 4 }$ until the 30th epoch. We use a weight decay of $1 0 ^ { - 4 }$ for regularization and stop the training once the loss on validation set starts to increase (which usually happens around 30 epochs). We use the type annotations from a single project as a minibatch and limit the maximal batch size (via downsampling) to be the median of our training set to prevent any single project from having too much influence.
+
+Implementation Details. We implemented LAMBDANET in Scala, building on top of the Java high-performance Tensor library Nd4j(nd4), and used a custom automatic differentiation library to implement our GNN. Our GNN implementation does not use an adjacency matrix to represent GNN layers; instead, we build the hyperedge connections directly from our type dependency graph and perform batching when computing the messages for all hyperedges of the same type.
+
+Code Repository. We have made our code publicly available on Github.5
+
+# 5.1 COMPARISON WITH DEEPTYPER
+
+In this experiment, we compare LAMBDANET’s performance with DeepTyper (Hellendoorn et al., 2018), which treats programs as sequences of tokens and uses a bidirectional RNN to make type predictions. Since DeepTyper can only predict types from a fixed vocabulary, we fix both LAMBDANET and DeepTyper’s prediction space to ${ \mathcal { N } } _ { \mathrm { l i b } }$ and measure their corresponding top-1 accuracy.
+
+The original DeepTyper model makes predictions for each variable occurrence rather than declaration. In order to conduct a meaningful comparison between DeepTyper and LAMBDANET, we implemented a variant of DeepTyper that makes a single prediction for each variable (by averaging over the RNN internal states of all occurrences of the same variable before making the prediction). Moreover, for a fair comparison, we made sure both DeepTyper and LAMBDANET are using the same improved naming feature that splits words into tokens.
+
+Our main results are summarized below, where the Declaration (resp. Occurrence) column shows accuracy per variable declaration (resp. token-level occurrence). Note that we obtain occurrence-level accuracy from declaration-level accuracy by weighting each variable by its number of occurrences.
+
+<table><tr><td>Model</td><td colspan="2">Top1 Accuracy (%) Declaration Occurrence</td></tr><tr><td>DeepTyper</td><td>61.5</td><td>67.4</td></tr><tr><td>LAMBDANETlib (K=6)</td><td>75.6</td><td>77.0</td></tr></table>
+
+program. Instead, they only need to annotate some key places (e.g., function parameters and return types, class members) and let the forward inference algorithm to figure out the rest of the types. Therefore, in our training set, we can keep the user annotations on these key places and run the TS compiler to recover these implicitly specified types as additional labels.
+
+Table 2: Accuracy when predicting all types.   
+
+<table><tr><td>Model</td><td colspan="3">Top1 Accuracy (%)</td><td colspan="3">Top5 Accuracy (%)</td></tr><tr><td></td><td>Yuser</td><td>Vlib</td><td>Overall</td><td>Vuser</td><td>Vlib</td><td>Overall</td></tr><tr><td>TS COMPILER</td><td>2.66</td><td>14.39</td><td>8.98</td><td>=</td><td>1</td><td>=</td></tr><tr><td>SIMILARNAME</td><td>24.1</td><td>0.78</td><td>15.7</td><td>42.5</td><td>3.19</td><td>28.4</td></tr><tr><td>LAMBDANET (K=6)</td><td>53.4</td><td>66.9</td><td>64.2</td><td>77.7</td><td>86.2</td><td>84.5</td></tr></table>
+
+Table 3: Performance of different GNN iterations (left) and ablations (right).   
+
+<table><tr><td>K</td><td colspan="2">Top1 Accuracy (%) Yuser Vlib</td></tr><tr><td>6</td><td>53.4</td><td>Overall 64.2</td></tr><tr><td>4</td><td>48.4</td><td>66.9 65.5 62.0</td></tr><tr><td>2</td><td>47.3 61.7</td><td>58.8</td></tr><tr><td>1</td><td>16.8 48.2</td><td>41.9</td></tr><tr><td>0</td><td>0.0 17.0</td><td>13.6</td></tr></table>
+
+<table><tr><td>Ablation (K= 4)</td><td colspan="2">Top1 Accuracy (%) Vuser Ylib Overall</td></tr><tr><td>LAMBDANET</td><td>48.4 65.5</td><td>62.0</td></tr><tr><td>No Attention in NPAIR</td><td>44.1</td><td>57.6 54.9</td></tr><tr><td>No Contextual</td><td>27.2</td><td>52.6 47.5</td></tr><tr><td>No Logical*</td><td>24.7</td><td>36.2</td></tr><tr><td>Simple Aggregation</td><td>40.2</td><td>61.5</td></tr></table>
+
+∗ Training was unstable and experienced gradient explosion.
+
+As we can see from the table, LAMBDANET achieves significantly better results compared to DeepTyper. In particular, LAMBDANET outperforms DeepTyper by $1 4 . 1 \%$ (absolute) for declarationlevel accuracy and by $9 . 6 \%$ for occurrence-level accuracy.
+
+Note that the accuracy we report for DeepTyper $( 6 7 . 4 \% )$ is not directly comparable to the original accuracy reported in Hellendoorn et al. (2018) $( 5 6 . 9 \% )$ for the following reasons. While we perform static analysis and have a strict distinction of library vs. user-defined types and only evaluate both tools on library type annotations in this experiment, their implementation treat types as tokens and does not have this distinctions. Hence, their model also considers a much larger prediction space consisting of many user-defined types—most of which are never used outside of the project in which they are defined—and is also evaluated on a different set of annotations than ours.
+
+# 5.2 PREDICTING USER-DEFINED TYPES
+
+As mentioned earlier, our approach differs from prior work in that it is capable of predicting userdefined types; thus, in our second experiment, we extend LAMBDANET’s prediction space to also include user-defined types. However, since such types are not in the prediction space of prior work (Hellendoorn et al., 2018), we implemented two simpler baselines that can be used to calibrate our model’s performance. Our first baseline is the type inference performed by the TypeScript compiler, which is sound but incomplete (i.e., if it infers a type, it is guaranteed to be correct, but it infers type any for most variables).6 Our second baseline, called SIMILARNAME, is inspired by the similarity between variable names and their corresponding types; it predicts the type of each variable $v$ to be the type whose name shares the most number of common word tokens with $v$ .
+
+The results of this experiment are shown in Table 2, which shows the top-1 and top-5 accuracy for both user-defined and library types individually as well as overall accuracy. In terms of overall prediction accuracy, LAMBDANET achieves $6 4 . 2 \%$ for top-1 and $8 4 . 5 \%$ for top-5, significantly outperforming both baselines. Our results suggest that our fusion of logical and contextual information to predict types is far more effective than rule-based incorporation of these in isolation.
+
+# 5.3 ABLATION STUDY
+
+Table 3 shows the results of an ablation study in which (a) we vary the number of message-passing iterations (left) and (b) disable various features of our architecture design (right). As we can see from the left table, accuracy continues to improve as we increase the number of message passing iterations as high as 6; this gain indicates that our network learns to perform inference over long distances. The right table shows the impact of several of our design choices on the overall result.
+
+For example, if we do not use Contextual edges (resp. Logical edges), overall accuracy drops by $1 4 . 5 \%$ (resp. $2 5 . 8 \%$ ). These drops indicate that both kinds of predicates are crucial for achieving good accuracy. We also see that the attention layer for NPAIR makes a significant difference for both library and user-defined types. Finally, Simple Aggregation is a variant of LAMBDANET that uses a simpler aggregation operation which replaces the attention-based weighed sum in $\mathrm { E q ~ } 1$ with a simple average. As indicated by the last row of Table 3 (right), attention-based aggregation makes a substantial difference for user-defined types.
+
+# 5.4 COMPARISON WITH JSNICE
+
+Since JSNice (Raychev et al., 2015) cannot properly handle class definitions and user-defined types, for a meaningful comparison, we compared both tools’ performance on top-level functions randomly sampled from our test set. We filtered out functions whose parameters are not library types and manually ensured that all all the dependency definitions are also included. In this way, we constructed a small benchmark suite consisting of 41 functions. Among the 107 function parameter and return type annotations, LAMBDANET correctly predicted 77 of them, while JSNice only got 48 of them right. These results suggest that LAMBDANET outperforms JSNice, even when evaluated only on the places where JSNice is applicable.
+
+# 6 RELATED WORK
+
+Type Inference using Statistical Methods. There are several previous works on predicting likely type annotations for dynamically typed languages: Raychev et al. (2015) and Xu et al. (2016) use structured inference models for Javascript and Python, but their approaches do not take advantage of deep learning and are limited to a very restricted prediction space. Hellendoorn et al. (2018) and Jangda & Anand (2019) model programs as sequences and AST trees and apply deep learning models (RRNs and Tree-RNNs) for TypeScript and Python programs. Malik et al. (2019) make use of a different source of information and take documentation strings as part of their input. However, all these previous works are limited to predicting types from a fixed vocabulary.
+
+Graph Embedding of Programs. Allamanis et al. (2017) are the first to use GNNs to obtain deep embedding of programs, but they focus on predicting variable names and misuses for $C ^ { \sharp }$ and rely on static type information to construct the program graph. Wang et al. (2017) use GNNs to encode mathematical formulas for premise selection in automated theorem proving. The way we encode types has some similarity to how they encode quantified formulas, but while their focus is on higherorder formulas, our problem requires encoding object types. Velickovi ˇ c et al. (2018) are the first to ´ use an attention mechanism in GNNs. While they use attention to compute node embeddings from messages, we use attention to compute certain messages from node embeddings.
+
+Predicting from an Open Vocabulary. Predicting unseen labels at test time poses a challenge for traditional machine learning methods. For computer vision applications, solutions might involve looking at object attributes (Farhadi et al., 2017) or label similarity Wang et al. (2018); for natural language, similar techniques are applied to generalize across semantic properties of utterances (Dauphin et al., 2013), entities (Eshel et al., 2017), or labels (Ren et al., 2016). Formally, most of these approaches compare an embedding of an input to some embedding of the label; what makes our approach a pointer network (Vinyals et al., 2015) is that our type encodings are derived during the forward pass on the input, similar to unknown words for machine translation (Gulcehre et al., 2016).
+
+# 7 CONCLUSIONS
+
+We have presented LAMBDANET, a neural architecture for type inference that combines the strength of explicit program analysis with graph neural networks. LAMBDANET not only outperforms other state-of-the-art tools when predicting library types, but can also effectively predict user-defined types that have not been encountered during training. Our ablation studies demonstrate the usefulness of our proposed logical and contextual hyperedges.
+
+For future work, there are several potential improvements and extensions to our current system. One limitation of our current architecture is the simplified treatment of function types and generic types (i.e., collapsing them into their non-generic counterparts). Extending the prediction space to also include structured types would allow us to make full use of the rich type systems many modern languages such as TypeScript provide. Another important direction is to enforce hard constraints during inference such that the resulting type assignments are guaranteed to be consistent.
+
+# ACKNOWLEDGMENTS
+
+We would like to thank DeepTyper authors, Vincent J. Hellendoorn, Christian Bird, Earl T. Barr, and Miltiadis Allamanis, for sharing their data set and helping us set up our experimental comparisons. We also thank the ICLR reviewers for their insightful comments and constructive suggestions. Finally, we would also like to thank Shankara Pailoor, Yuepeng Wang, Jocelyn Chen, and other UToPiA group members for their kind support and useful feedback. This project was supported in part by NSF grant CCF-1762299.
+
+# REFERENCES
+
+Deeplearning4j. https://github.com/eclipse/deeplearning4j. Accessed: 2019- 09-24.
+
+Miltiadis Allamanis, Marc Brockschmidt, and Mahmoud Khademi. Learning to represent programs with graphs. ICLR, 2017.
+
+Davide Ancona and Elena Zucca. Principal typings for java-like languages. In ACM SIGPLAN Notices, volume 39, pp. 306–317. ACM, 2004.
+
+Gavin Bierman, Mart´ın Abadi, and Mads Torgersen. Understanding typescript. In Richard Jones (ed.), ECOOP 2014 – Object-Oriented Programming, pp. 257–281, Berlin, Heidelberg, 2014. Springer Berlin Heidelberg. ISBN 978-3-662-44202-9.
+
+Benjamin Chung, Paley Li, Francesco Zappa Nardelli, and Jan Vitek. Kafka: Gradual typing for objects. In ECOOP 2018-2018 European Conference on Object-Oriented Programming, 2018.
+
+Yann Dauphin, Gokhan Tur, Dilek Z. Hakkani-Tur, and Larry P. Heck. Zero-shot learning for semantic utterance classification. In ICLR, 2013.
+
+Yotam Eshel, Noam Cohen, Kira Radinsky, Shaul Markovitch, Ikuya Yamada, and Omer Levy. Named entity disambiguation for noisy text. In CoNLL, 2017.
+
+Ali Farhadi, Ian Endres, Derek Hoiem, and David Forsyth. Describing objects by their attributes. In CVPR, 2017.
+
+Zheng Gao, Christian Bird, and Earl T. Barr. To type or not to type: Quantifying detectable bugs in javascript. In Proceedings of the 39th International Conference on Software Engineering, ICSE ’17, pp. 758–769, Piscataway, NJ, USA, 2017. IEEE Press. ISBN 978-1-5386-3868-2. doi: 10.1109/ICSE.2017.75. URL https://doi.org/10.1109/ICSE.2017.75.
+
+Caglar Gulcehre, Sungjin Ahn, Ramesh Nallapati, Bowen Zhou, and Yoshua Bengio. Pointing the unknown words. In Proceedings of the ACL, 2016.
+
+Stefan Hanenberg, Sebastian Kleinschmager, Romain Robbes, Eric Tanter, and Andreas Stefik. An ´ empirical study on the impact of static typing on software maintainability. Empirical Software Engineering, 19:1335–1382, 2013.
+
+Vincent J. Hellendoorn, Christian Bird, Earl T. Barr, and Miltiadis Allamanis. Deep learning type inference. In Proceedings of the 2018 26th ACM Joint Meeting on European Software Engineering Conference and Symposium on the Foundations of Software Engineering, ESEC/FSE 2018, pp. 152–162, New York, NY, USA, 2018. ACM. ISBN 978-1-4503-5573-5. doi: 10.1145/3236024. 3236051. URL http://doi.acm.org/10.1145/3236024.3236051.
+
+Abhinav Jangda and Gaurav Anand. Predicting variable types in dynamically typed programming languages. arXiv preprint arXiv:1901.05138, 2019.
+
+Diederik P. Kingma and Jimmy Ba. Adam: A method for stochastic optimization. In ICLR, 2014.
+
+Yujia Li, Daniel Tarlow, Marc Brockschmidt, and Richard S. Zemel. Gated graph sequence neural networks. ICLR, abs/1511.05493, 2016.
+
+Rabee Sohail Malik, Jibesh Patra, and Michael Pradel. Nl2type: inferring javascript function types from natural language information. In Proceedings of the 41st International Conference on Software Engineering, pp. 304–315. IEEE Press, 2019.
+
+Lili Mou, Ge Li, Lu Zhang, Tao Wang, and Zhi Jin. Convolutional neural networks over tree structures for programming language processing. In AAAI, volume 2, pp. 4, 2016.
+
+Benjamin C Pierce and David N Turner. Local type inference. ACM Transactions on Programming Languages and Systems (TOPLAS), 22(1):1–44, 2000.
+
+Veselin Raychev, Martin Vechev, and Andreas Krause. Predicting program properties from ”big code”. In Proceedings of the 42Nd Annual ACM SIGPLAN-SIGACT Symposium on Principles of Programming Languages, POPL ’15, pp. 111–124, New York, NY, USA, 2015. ACM.
+
+Xiang Ren, Wenqi He, Meng Qu, Clare R Voss, Heng Ji, and Jiawei Han. Label noise reduction in entity typing by heterogeneous partial-label embedding. In Proceedings of the 22nd ACM SIGKDD International Conference on Knowledge Discovery and Data Mining, pp. 1825–1834. ACM, 2016.
+
+Jeremy G. Siek and Walid Taha. Gradual typing for objects. In ECOOP, 2007.
+
+Dmitriy Traytel, Stefan Berghofer, and Tobias Nipkow. Extending hindley-milner type inference with coercive structural subtyping. In Asian Symposium on Programming Languages and Systems, pp. 89–104. Springer, 2011.
+
+Petar Velickovi ˇ c, Guillem Cucurull, Arantxa Casanova, Adriana Romero, Pietro Li ´ o, and Yoshua \` Bengio. Graph Attention Networks. International Conference on Learning Representations, 2018. accepted as poster.
+
+Oriol Vinyals, Meire Fortunato, and Navdeep Jaitly. Pointer networks. In NeurIPS, 2015.
+
+Michael M Vitousek, Andrew M Kent, Jeremy G Siek, and Jim Baker. Design and evaluation of gradual typing for python. In ACM SIGPLAN Notices, volume 50, pp. 45–56. ACM, 2014.
+
+Mingzhe Wang, Yihe Tang, Jian Wang, and Jia Deng. Premise selection for theorem proving by deep graph embedding. In Advances in Neural Information Processing Systems, pp. 2786–2796, 2017.
+
+Xiaolong Wang, Yufei Ye, and Abhinav Gupta. Zero-shot recognition via semantic embeddings and knowledge graphs. In CVPR, 2018.
+
+Zhaogui Xu, Xiangyu Zhang, Lin Chen, Kexin Pei, and Baowen Xu. Python probabilistic type inference with natural language support. In Proceedings of the 2016 24th ACM SIGSOFT International Symposium on Foundations of Software Engineering, pp. 607–618. ACM, 2016.

parse/train/Hkx6hANtwH/Hkx6hANtwH_content_list.json

@@ -0,0 +1,1367 @@
+[
+    {
+        "type": "text",
+        "text": "LAMBDANET: PROBABILISTIC TYPE INFERENCE USING GRAPH NEURAL NETWORKS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            98,
+            758,
+            146
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Jiayi Wei, Maruth Goyal, Greg Durrett, Isil Dillig ",
+        "bbox": [
+            184,
+            169,
+            532,
+            184
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Department of Computer Science   \nUniversity of Texas at Austin   \n{jiayi, maruth, gdurrett, isil}@cs.utexas.edu ",
+        "bbox": [
+            184,
+            185,
+            619,
+            226
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "ABSTRACT ",
+        "text_level": 1,
+        "bbox": [
+            454,
+            262,
+            544,
+            277
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "As gradual typing becomes increasingly popular in languages like Python and TypeScript, there is a growing need to infer type annotations automatically. While type annotations help with tasks like code completion and static error catching, these annotations cannot be fully determined by compilers and are tedious to annotate by hand. This paper proposes a probabilistic type inference scheme for TypeScript based on a graph neural network. Our approach first uses lightweight source code analysis to generate a program abstraction called a type dependency graph, which links type variables with logical constraints as well as name and usage information. Given this program abstraction, we then use a graph neural network to propagate information between related type variables and eventually make type predictions. Our neural architecture can predict both standard types, like number or string, as well as user-defined types that have not been encountered during training. Our experimental results show that our approach outperforms prior work in this space by $1 4 \\%$ (absolute) on library types, while having the ability to make type predictions that are out of scope for existing techniques. ",
+        "bbox": [
+            233,
+            299,
+            764,
+            507
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 INTRODUCTION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            547,
+            334,
+            563
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Dynamically typed languages like Python, Ruby, and Javascript have gained enormous popularity over the last decade, yet their lack of a static type system comes with certain disadvantages in terms of maintainability (Hanenberg et al., 2013), the ability to catch errors at compile time, and code completion support (Gao et al., 2017). Gradual typing can address these shortcomings: program variables have optional type annotations so that the type system can perform static type checking whenever possible (Siek & Taha, 2007; Chung et al., 2018). Support for gradual typing now exists in many popular programming languages (Bierman et al., 2014; Vitousek et al., 2014), but due to their heavy use of dynamic language constructs and the absence of principal types (Ancona & Zucca, 2004), compilers cannot perform type inference using standard algorithms from the programming languages community (Bierman et al., 2014; Traytel et al., 2011; Pierce & Turner, 2000), and manually adding type annotations to existing codebases is a tedious and error-prone task. As a result, legacy programs in these languages do not reap all the benefits of gradual typing. ",
+        "bbox": [
+            174,
+            583,
+            825,
+            750
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "To reduce the human effort involved in transitioning from untyped to statically typed code, this work focuses on a learning-based approach to automatically inferring likely type annotations for untyped (or partially typed) codebases. Specifically, we target TypeScript, a gradually-typed variant of Javascript for which plenty of training data is available in terms of type-annotated programs. While there has been some prior work on inferring type annotations for TypeScript using machine learning (Hellendoorn et al., 2018; Raychev et al., 2015), prior work in this space has several shortcomings. First, inference is restricted to a finite dictionary of types that have been observed during training time—i.e., they cannot predict any user-defined data types. Second, even without considering user-defined types, the accuracy of these systems is relatively low, with the current state-of-theart achieving $5 6 . 9 \\%$ accuracy for primitive/library types (Hellendoorn et al., 2018). Finally, these techniques can produce inconsistent results in that they may predict different types for different token-level occurrences of the same variable. ",
+        "bbox": [
+            174,
+            757,
+            825,
+            922
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "image",
+        "img_path": "images/76a4914e3ed97a06eaeb1df44f451c9eadd1a690c6cdf2fa9da57ca02985eee1.jpg",
+        "image_caption": [
+            "Figure 1: A motivating example: Given an unannotated version of this TypeScript program, a traditional rule-based type inference algorithm cannot soundly deduce the true type annotations (shown in green). "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            209,
+            80,
+            691,
+            219
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "In this paper, we propose a new probabilistic type inference algorithm for TypeScript to address these shortcomings using a graph neural network architecture (GNN) (Velickovi ˇ c et al., 2018; Li et al., ´ 2016; Mou et al., 2016). Our method uses lightweight source code analysis to transform the program into a new representation called a type dependency graph, where nodes represent type variables and labeled hyperedges encode relationships between them. In addition to expressing logical constraints (e.g., subtyping relations) as in traditional type inference, a type dependency graph also incorporates contextual hints involving naming and variable usage. ",
+        "bbox": [
+            173,
+            301,
+            825,
+            400
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Given such a type dependency graph, our approach uses a GNN to compute a vector embedding for each type variable and then performs type prediction using a pointer-network-like architecture (Vinyals et al., 2015). The graph neural network itself requires handling a variety of hyperedge types—some with variable numbers of arguments—for which we define appropriate graph propagation operators. Our prediction layer compares the vector embedding of a type variable with vector representations of candidate types, allowing us to flexibly handle user-defined types that have not been observed during training. Moreover, our model predicts consistent type assignments by construction because it makes variable-level rather than token-level predictions. ",
+        "bbox": [
+            174,
+            406,
+            825,
+            518
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "We implemented our new architecture as a tool called LAMBDANET and evaluated its performance on real-world TypeScript projects from Github. When only predicting library types, LAMBDANET has a top1 accuracy of $7 5 . 6 \\%$ , achieving a significant improvement over DeepTyper $( 6 1 . 5 \\% )$ . In terms of overall accuracy (including user-defined types), LAMBDANET achieves a top1 accuracy of around $6 4 . 2 \\%$ , which is $5 5 . 2 \\%$ (absolute) higher than the TypeScript compiler. ",
+        "bbox": [
+            174,
+            525,
+            825,
+            594
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Contributions. This paper makes the following contributions: (1) We propose a probabilistic type inference algorithm for TypeScript that uses deep learning to make predictions from the type dependency graph representation of the program. (2) We describe a technique for computing vector embeddings of type variables using GNNs and propose a pointer-network-like method to predict user-defined types. (3) We experimentally evaluate our approach on hundreds of real-world TypeScript projects and show that our method significantly improves upon prior work. ",
+        "bbox": [
+            174,
+            602,
+            825,
+            685
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2 MOTIVATING EXAMPLE AND PROBLEM SETTING",
+        "text_level": 1,
+        "bbox": [
+            174,
+            708,
+            611,
+            724
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Figure 1 shows a (type-annotated) TypeScript program. Our goal in this work is to infer the types shown in the figure, given an unannotated version of this code. We now justify various aspects of our solution using this example. ",
+        "bbox": [
+            174,
+            741,
+            823,
+            784
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Typing constraints. The use of certain functions/operators in Figure 1 imposes hard constraints on the types that can be assigned to program variables. For example, in the forward function, variables $_ \\textrm { x }$ , y must be assigned a type that supports a concat operation; hence, x, y could have types like string, array, or Tensor, but not, for example, boolean. This observation motivates us to incorporate typing constraints into our model. ",
+        "bbox": [
+            174,
+            791,
+            825,
+            861
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Contextual hints. Typing constraints are not always sufficient for determining the intended type of a variable. For example, for variable network in function restore, the typing constraints require network’s type to be a class with a field called time, but there can be many classes that have such an attribute (e.g., Date). However, the similarity between the variable name network ",
+        "bbox": [
+            174,
+            867,
+            823,
+            924
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "1 var c1: $\\tau _ { 8 } =$ class MyNetwork {   \n2 name: τ1; time: $\\tau _ { 2 }$ ;   \n3 var m1: $\\begin{array} { r l } { \\tau _ { 9 } } & { { } = } \\end{array}$ function forward(x: $\\tau _ { 3 }$ , $y : \\ \\tau _ { 4 } ) : \\tau _ { 5 }$ {   \n4 var v1: $\\tau _ { 1 0 } ~ = ~ \\mathrm { ~ x ~ }$ .concat; var v2: $\\tau _ { 1 1 } ~ = ~ \\mathrm { { v } 1 }$ (y);   \n5 var v3: $\\tau _ { 1 2 } =$ v2.TIMES_OP; var v4: $\\tau _ { 1 3 } ~ = ~ \\mathrm { ~ v ~ } 3$ (NUMBER);   \n6 return v4;   \n7 }   \n8 // more classes..   \n9 var $\\pm 1 : \\tau _ { 1 4 } =$ function restore (network: $\\tau _ { 6 } ) : \\tau _ { 7 }$ {   \n10 var v3: $\\tau _ { 1 5 } ~ =$ network.time;   \n11 var v4: $\\tau _ { 1 6 } ~ =$ readNumber(STRING);   \n12 network.time $\\qquad = \\quad \\mathtt { v 4 }$ ; // more code...   \n13 } ",
+        "bbox": [
+            243,
+            74,
+            805,
+            238
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "image",
+        "img_path": "images/c379e43ee1c078f294bc4ea605359a81dff643be05acb373a176d554360d5b82.jpg",
+        "image_caption": [
+            "Figure 2: An intermediate representation of the (unannotated version) program from Figure 1. The $\\tau _ { i }$ represent type variables, among which $\\tau _ { 8 } - \\tau _ { 1 6 }$ are newly introduced for intermediate expressions. ",
+            "Figure 3: Example hyperedges for Figure 2. Edge labels in gray (resp. red) are positional arguments (resp. identifiers). (A) The return statement at line 6 induces a subtype relationship between $\\tau _ { 1 3 }$ and $\\tau _ { 5 }$ . $\\mathbf { ( B ) }$ MyNetwork $\\tau _ { 8 }$ declares attributes name $\\tau _ { 1 }$ and time $\\tau _ { 2 }$ and method forward $\\tau _ { 9 }$ . (C) $\\tau _ { 1 4 }$ is associated with a variable whose named is restore. $\\mathbf { \\eta } ^ { ( \\mathbf { D } ) }$ Usage hyperedge for line 10 connects $\\tau _ { 6 }$ and $\\tau _ { 1 5 }$ to all classes with a time attribute. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            209,
+            308,
+            784,
+            411
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "and the class name MyNetwork hints that network might have type MyNetwork. Based on this belief, we can further propagate the return type of the library function readNumber (assuming we know it is number) to infer that the type of the time field in MyNetwork is likely to be number. ",
+        "bbox": [
+            174,
+            526,
+            825,
+            568
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Need for type dependency graph. There are many ways to view programs—e.g., as token sequences, abstract syntax trees, control flow graphs, etc. However, none of these representations is particularly helpful for inferring the most likely type annotations. Thus, our method uses static analysis to infer a set of predicates that are relevant to the type inference problem and represents these predicates using a program abstraction called the type dependency graph. ",
+        "bbox": [
+            174,
+            574,
+            823,
+            645
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Handling user-defined types. As mentioned in Section 1, prior techniques can only predict types seen during training. However, the code from Figure 1 defines its own class called MyNetwork and later uses a variables of type MyNetwork in the restore method. A successful model for this task therefore must dynamically make inferences about user-defined types based on their definitions. ",
+        "bbox": [
+            174,
+            651,
+            825,
+            708
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "2.1 PROBLEM SETTING ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            743,
+            348,
+            757
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Our goal is to train a type inference model that can take as input an entirely (or partially) unannotated TypeScript project $g$ and output a probability distribution of types for each missing annotation. The prediction space is $\\mathcal { V } ( g ) = \\mathcal { V } _ { \\mathrm { l i b } } \\cup \\mathcal { V } _ { \\mathrm { u s e r } } ( g )$ , where $\\mathcal { V } _ { \\mathrm { u s e r } } ( g )$ is the set of all user-defined types (classes/interfaces) declared within $g$ , and ${ \\mathcal { N } } _ { \\mathrm { l i b } }$ is a fixed set of commonly-used library types. ",
+        "bbox": [
+            174,
+            776,
+            825,
+            833
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Following prior work in this space (Hellendoorn et al., 2018; Raychev et al., 2015; Xu et al., 2016), we limit the scope of our prediction to non-polymorphic and non-function types. That is, we do not distinguish between types such as List<T>, List<number>, List<string> etc., and consider them all to be of type List. Similarly, we also collapse function types like number string and string string into a single type called Function. We leave the extension of predicting structured types as future work. ",
+        "bbox": [
+            173,
+            840,
+            825,
+            924
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "table",
+        "img_path": "images/adcd764ac59db7fadd7cdac465302b9dd68de82aa6212801e6625211229c7a48.jpg",
+        "table_caption": [
+            "Table 1: Different types of hyperedges used in a type dependency graph. "
+        ],
+        "table_footnote": [
+            "† Although assignment is a special case of a subtype constraint, we differentiate them because these edges appear in different contexts and having uncoupled parameters for these two edge types is beneficial. "
+        ],
+        "table_body": "<table><tr><td>Type</td><td>Edge</td><td>Description</td></tr><tr><td colspan=\"2\">Logical α is used as boolean</td></tr><tr><td>FIXED</td><td>Bool(α)</td></tr><tr><td>FIXED</td><td>Subtype(α, β) α is a subtype of β</td></tr><tr><td>FIXED</td><td>Assign(α, β)t β is assigned to α α=(β1,...,βk)→β*</td></tr><tr><td>NARY NARY</td><td>Function(α,βi,...,βk, β*)</td></tr><tr><td>NARY</td><td>Call(a,β*,β1,..., βk) α=β*(β1,...,βk)</td></tr><tr><td>FIXED</td><td>Object.,(α,βi,...,βk)） α={l1:β1,...,lk :βk} Accesst(a,β) α= β.l</td></tr><tr><td colspan=\"2\">αhas name l</td></tr><tr><td>FIXED</td><td>Contextual</td></tr><tr><td>Namet(α) FIXED</td><td>NameSimilar(α, β) α,βhave similar names</td></tr></table>",
+        "bbox": [
+            227,
+            119,
+            772,
+            297
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3 TYPE DEPENDENCY GRAPH ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            358,
+            437,
+            375
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "A type dependency graph $\\mathcal { G } = ( N , E )$ is a hypergraph where nodes $N$ represent type variables and labeled hyperedges $E$ encode relationships between them. We extract the type dependency graph of a given TypeScript program by performing static analysis on an intermediate representation of its source code, which allows us to associate a unique variable with each program sub-expression. As an illustration, Figure 2 shows the intermediate representation of the code from Figure 1. ",
+        "bbox": [
+            174,
+            390,
+            825,
+            460
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Intuitively, a type dependency graph encodes properties of type variables as well as relationships between them. Each hyperedge corresponds to one of the predicates shown in Table 1. We partition our predicates (i.e., hyperedges) into two classes, namely Logical and Contextual, where the former category can be viewed as imposing hard constraints on type variables and the latter category encodes useful hints extracted from names of variables, functions, and classes. ",
+        "bbox": [
+            174,
+            467,
+            823,
+            536
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Figure 3 shows some of the hyperedges in the type dependency graph $\\mathcal { G }$ extracted from the intermediate representation in Figure 2. As shown in Figure 3(A), our analysis extracts a predicate Subtype $( \\tau _ { 1 3 } , \\tau _ { 5 } )$ from this code because the type variable associated with the returned expression $\\mathtt { v 4 }$ must be a subtype of the enclosing function’s return type. Similarly, as shown in Figure 3(B), our analysis extracts a predicate $\\mathrm { O b j e c t } _ { \\mathrm { n a m e , t i m e , f o r w a r d } } ( \\tau _ { 8 } , \\tau _ { 1 } , \\tau _ { 2 } , \\tau _ { 9 } )$ because $\\tau _ { 8 }$ is an object type whose name, time, and forward members are associated with type variables $\\tau _ { 1 } , \\tau _ { 2 } , \\tau _ { 9 }$ , respectively. ",
+        "bbox": [
+            173,
+            544,
+            825,
+            627
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "In contrast to the Subtype and Object predicates that impose hard constraints on type variables, the next two hyperedges shown in Figure 3 encode contextual clues obtained from variable names. Figure 3(C) indicates that type variable $\\tau _ { 1 4 }$ is associated with an expression named restore. While this kind of naming information is invisible to TypeScript’s structural type system (?), it serves as a useful input feature for our GNN architecture described in Section 4. ",
+        "bbox": [
+            174,
+            635,
+            825,
+            704
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "In addition to storing the unique variable name associated with each type variable, the type dependency graph also encodes similarity between variable and class names. The names of many program variables mimic their types: for example, instances of a class called MyNetwork might often be called network or network1. To capture this correspondence, our type dependency graph also contains a hyperedge called NameSimilar that connects type variables $\\alpha$ and $\\beta$ if their corresponding tokenized names have a non-empty intersection.1 ",
+        "bbox": [
+            174,
+            712,
+            825,
+            795
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "As shown in Table 1, there is a final type of hyperedge called Usage that facilitates type inference of object types. In particular, if there is an object access var $\\mathrm { ~ y ~ } = \\mathrm { ~ x ~ . ~ } \\bot$ , we extract the predicate $\\operatorname { U s a g e } _ { l } ( ( \\tau _ { x } , \\tau _ { y } ) , ( \\alpha _ { 1 } , \\beta _ { 1 } ) , \\dots , ( \\alpha _ { k } , \\beta _ { k } ) )$ to connect $_ \\textrm { x }$ and y’s type variables with all classes $\\alpha _ { i }$ that contain an attribute/method $\\beta _ { i }$ whose name is l. Figure 3 shows a Usage hyperedge extracted from the code in Figure 2. As we will see in the next section, our GNN architecture utilizes a special attention mechanism to pass information along these usage edges. ",
+        "bbox": [
+            174,
+            801,
+            825,
+            886
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "4 NEURAL ARCHITECTURE ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            102,
+            416,
+            118
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Our neural architecture for making type predictions consists of two main parts. First, a graph neural network passes information along the type dependency graph to produce a vector-valued embedding for each type variable based on its neighbors. Second, a pointer network compares each variable’s type embedding to the embedding vectors of candidate types (both computed from the previous phase) to place a distribution over possible type assignments. ",
+        "bbox": [
+            173,
+            133,
+            825,
+            204
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Given a type dependency graph $\\mathcal { G } = ( N , E )$ , we first to compute a vector embedding $\\mathbf { v } _ { n }$ for each $n \\in N$ such that these vectors implicitly encode type information. Because our program abstraction is a graph, a natural choice is to use a graph neural network architecture. From a high level, this architecture takes in initial vectors $ { \\mathbf { v } } _ { n } ^ { 0 }$ for each node $n$ , performs $K$ rounds of message-passing in the graph neural network, and returns the final representation for each type variable. ",
+        "bbox": [
+            173,
+            210,
+            825,
+            281
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "In more detail, let $\\mathbf { v } _ { n } ^ { t }$ denote the vector representation of node $n$ at the tth step, where each round consists of a message passing and an aggregation step. The message passing step computes a vectorvalued update to send to the $j$ th argument of each hyper-edge $e \\in E$ connecting nodes $p _ { 1 } , \\ldots , p _ { a }$ . Then, once all the messages have been computed, the aggregation step computes a new embedding $\\mathbf { v } _ { n } ^ { t }$ for each $n$ by combining all messages sent to $n$ : ",
+        "bbox": [
+            174,
+            287,
+            825,
+            358
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/0704bc0c7e8c893792ec823fb48f17a51aad7e1fc559005791ffd19d40365088.jpg",
+        "text": "$$\n\\begin{array} { r } { \\mathbf { m } _ { e , p _ { j } } ^ { t } = \\mathrm { M s g } _ { e , j } \\bigl ( \\mathbf { v } _ { p _ { 1 } } ^ { t - 1 } , \\ldots , \\mathbf { v } _ { p _ { a } } ^ { t - 1 } \\bigr ) \\quad \\mathbf { v } _ { n } ^ { t } = \\mathrm { A g g r } ( \\mathbf { v } _ { n } ^ { t - 1 } , \\{ \\mathbf { m } _ { e , n } ^ { t } | e \\in \\mathcal { N } ( n ) \\} ) } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            251,
+            366,
+            745,
+            387
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Here, $\\mathcal { N }$ is the neighborhood function, and $\\mathrm { M s g } _ { e }$ denotes a particular neural operation that depends on the type of the edge (FIXED, NARY, or NPAIRS), which we will describe later. ",
+        "bbox": [
+            173,
+            395,
+            821,
+            422
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Initialization. In our GNN, nodes correspond to type variables and each type variable is associated either with a program variable or a constant. We refer to nodes representing constants (resp. variables) as constant (resp. variable) nodes, and our initialization procedure works differently depending on whether or not $n$ is a constant node. Since the types of each constant are known, we set the initial embedding for each constant node of type $\\tau$ (e.g., string) to be a trainable vector $\\mathbf { c } _ { \\tau }$ and do not update it during GNN iterations (i.e., $\\forall t , \\mathbf { v } _ { n } ^ { t } = \\mathbf { c } _ { \\tau } )$ ). On the other hand, if $n$ is a variable node, then we have no information about its type during initialization; hence, we initialize all variable nodes using a generic trainable initial vector (i.e., they are initialized to the same vector but updated to different values during GNN iterations). ",
+        "bbox": [
+            173,
+            429,
+            825,
+            556
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Message passing. Our Msg operator depends on the category of edge it corresponds to (see Table 1); however, weights are shared between all instances of the same hyperedge type. In what follows, we describe the neural layer that is used to compute messages for each type of hyperedge: ",
+        "bbox": [
+            174,
+            563,
+            825,
+            604
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "• FIXED: Since these edges correspond to fixed arity predicates (and the position of each argument matters), we compute the message of the $j$ th argument by first concatenating the embedding vector of all arguments and then feed the result vector to a 2-layer MLP for the $j$ th argument. In addition, since hyperedges of type Access have an identifier, we also embed the identifier as a vector and treat it as an extra argument. (We describe the details of identifier embedding later in this section.) • NARY: Since NARY edges connect a variable number of nodes, we need an architecture that can deal with this challenge. In our current implementation of LAMBDANET, we use a simple architecture that is amenable to batching. Specifically, given an NARY edge $E _ { l _ { 1 } , \\dots , l _ { k } } ( \\alpha , \\beta _ { 1 } , \\dots , \\beta _ { k } )$ (for Function and $C a l l$ , the labels $l _ { j }$ are argument positions), the set of messages for $\\alpha$ is computed as $\\{ \\mathrm { M L P } _ { \\alpha } ( \\mathbf { v } _ { l _ { j } } \\| \\mathbf { v } _ { \\beta _ { j } } ) \\vert j = 1 \\dots k \\}$ , and the message for each $\\beta _ { j }$ is computed as $\\mathrm { M L P } _ { \\beta } ( \\mathbf { v } _ { l _ { j } } \\| \\mathbf { v } _ { \\alpha } )$ . Observe that we compute $k$ different messages for $\\alpha$ , and the message for each $\\beta _ { j }$ only depends on the vector embedding of $\\alpha$ and its position $j$ , but not the vector embeddings of other $\\beta _ { j }$ ’s.2 • NPAIRS: This is a special category associated with $\\operatorname { U s a g e } _ { l } ( ( \\alpha ^ { * } , \\beta ^ { * } ) , ( \\alpha _ { 1 } , \\beta _ { 1 } ) , \\dots , ( \\alpha _ { k } , \\beta _ { k } ) )$ . Recall that this kind of edge arises from expressions of the form $b = a . l$ and is used to connect $a$ and $b$ ’s type variables with all classes $\\alpha _ { i }$ that contain an attribute/method $\\beta _ { i }$ with label $l$ . Intuitively, if $a$ ’s type embedding is very similar to a type $C$ , then $b$ ’s type will likely be the same as $C . l$ ’s type. Following this reasoning, we use dot-product based attention to compute the messages for $\\alpha ^ { * }$ and $\\beta ^ { * }$ . Specifically, we use $\\alpha ^ { * }$ and $\\alpha _ { j }$ ’s as attention keys and $\\beta _ { j }$ ’s as attention values to compute the message for $\\beta ^ { * }$ (and switch the key-value roles to compute the message for $\\alpha ^ { * }$ ): ",
+        "bbox": [
+            173,
+            618,
+            825,
+            883
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            186,
+            103,
+            710,
+            118
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "equation",
+        "img_path": "images/b74803a52c6327a0394255bf6d75a77a568af1f66436189ff151a0ca70cb8ef8.jpg",
+        "text": "$$\n\\mathbf { m } _ { e , \\beta ^ { * } } ^ { t } = \\sum _ { j } w _ { j } \\mathbf { v } _ { \\beta _ { j } } ^ { t - 1 } \\quad \\quad \\mathbf { w } = \\mathrm { s o f t m a x } ( \\mathbf { a } ) \\quad \\quad a _ { j } = \\mathbf { v } _ { \\alpha _ { j } } \\cdot \\mathbf { v } _ { \\alpha ^ { * } }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            297,
+            123,
+            714,
+            159
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Aggregation. Recall that the aggregation step combines all messages sent to node $n$ to compute the new embedding $\\boldsymbol { v } _ { n } ^ { t }$ . To achieve this goal, we use a variant of the attention-based aggregation operator proposed in graph attention networks (Velickovi ˇ c et al., 2018). ´ ",
+        "bbox": [
+            173,
+            164,
+            825,
+            207
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "equation",
+        "img_path": "images/8b366af6a97aff66356802892132639cec7f2785168c58d8368fa5d044531487.jpg",
+        "text": "$$\nv _ { n } ^ { t } = \\operatorname { A g g r } ( v _ { n } ^ { t - 1 } , \\{ m _ { e , n } ^ { t } | e \\in \\mathcal { N } ( n ) \\} ) = v _ { n } ^ { t - 1 } + \\sum _ { e \\in \\mathcal { N } ( n ) } w _ { e } \\mathbf { M } _ { 1 } m _ { e , n } ^ { t }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            290,
+            212,
+            705,
+            244
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "where $w _ { e }$ is the attention weight for the message coming from edge $e$ . Specifically, the weights $w _ { e }$ are computed as softmax(a), where $a _ { e } = \\mathrm { L e a k y R e L } \\mathbf { \\bar { u } } ( v _ { n } ^ { t - 1 } \\cdot \\bar { \\mathbf { M } } _ { 2 } m _ { e , n } ^ { t } )$ , and ${ { \\bf { M } } _ { 1 } }$ and $\\mathbf { M } _ { 2 }$ are trainable matrices. Similar to the original GAT architecture, we set the slope of the LeakyReLu to be 0.2, but we use dot-product to compute the attention weights instead of a linear model. ",
+        "bbox": [
+            174,
+            250,
+            825,
+            306
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Identifier embedding. Like in Allamanis et al. (2017), we break variable names into word tokens according to camel case and underscore rules and assign a trainable vector for all word tokens that appear more than once in the training set. For all other tokens, unlike Allamanis et al. (2017), which maps them all into one single <Unknown $>$ token, we randomly mapped them into one of the <Unknown $- \\dot { \\textrm { \\scriptsize 1 } } >$ tokens, where $i$ ranges from 0 to 50 in our current implementation. This mapping is randomly constructed every time we run the GNN and hence helps our neural networks to distinguish different tokens even if they are rare tokens. We train these identifier embeddings end-to-end along with the rest of our architecture. ",
+        "bbox": [
+            174,
+            311,
+            825,
+            424
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Prediction Layer. For each type variable $n$ and each candidate type $c \\in \\mathcal { V } ( g )$ , we use a MLP to compute a compatibility score $s _ { n , c } = \\mathrm { M L P } ( \\mathbf { v } _ { n } , \\mathbf { u } _ { c } )$ , where $\\mathbf { u } _ { c }$ is the embedding vector for $c$ . If $c \\in \\mathcal { V } _ { \\mathrm { l i b } }$ , ${ \\bf v } _ { c }$ is a trainable vector for each library type $c$ ; if $c \\in \\mathcal { V } _ { \\mathrm { u s e r } } ( g )$ , then it corresponds to a node $n _ { c }$ in the type dependency graph of $g$ , so we just use the embedding vector for $n _ { c }$ and set $\\mathbf { u } _ { c } = \\mathbf { v } _ { n _ { c } }$ . Formally, this approach looks like a pointer network (Vinyals et al., 2015), where we use the embeddings computed during the forward pass to predict “pointers” to those types. ",
+        "bbox": [
+            173,
+            431,
+            825,
+            515
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Given these compatibility scores, we apply a softmax layer to turn them into a probability distribution. i.e., $\\begin{array} { r } { P _ { n } ( c | g ) = \\exp ( s _ { n , c } ) / \\sum _ { c ^ { \\prime } } \\exp ( s _ { n , c ^ { \\prime } } ) } \\end{array}$ . During test time, we max over the probabilities to compute the most likely (or top-N) type assignments. ",
+        "bbox": [
+            174,
+            522,
+            825,
+            564
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "5 EVALUATION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            584,
+            315,
+            601
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "In this section, we describe the results of our experimental evaluation, which is designed to answer the following questions: (1) How does our approach compare to previous work? (2) How well can our model predict user-defined types? (3) How useful is each of our model’s components? ",
+        "bbox": [
+            176,
+            614,
+            821,
+            657
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Dataset. Similar to Hellendoorn et al. (2018), we train and evaluate our model on popular opensource TypeScript projects taken from Github. Specifically, we collect 300 popular TypeScript projects from Github that contain between 500 to 10, 000 lines of code and where at least $1 0 \\%$ of type annotations are user-defined types. Note that each project typically contains hundreds to thousands of type variables to predict, and these projects in total contain about 1.2 million lines of TypeScript code. Among these 300 projects, we use 60 for testing, 40 for validation, and the remainder for training. ",
+        "bbox": [
+            174,
+            664,
+            825,
+            762
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Code Duplication. We ran jscpd3 on our entire data set and found that only $2 . 7 \\%$ of the code is duplicated. Furthermore, most of these duplicates are intra-project. Thus, we believe that code duplication is not a severe problem in our dataset. ",
+        "bbox": [
+            174,
+            768,
+            825,
+            810
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Preprocessing. Because some of the projects in our benchmark suite are only sparsely type annotated, we augment our labeled training data by using the forward type inference functionality provided by the TypeScript compiler.4 The compiler cannot infer the type of every variable and leaves many labeled as any during failed inference; thus, we exclude any labels in our data set. ",
+        "bbox": [
+            174,
+            818,
+            825,
+            875
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Furthermore, at test time, we evaluate our technique only on annotations that are manually added by developers. This is the same methodology used by Hellendoorn et al. (2018), and, since developers often add annotations where code is most unclear, this constitutes a challenging setting for type prediction. ",
+        "bbox": [
+            174,
+            103,
+            823,
+            159
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Prediction Space. As mentioned in Section 2.1, our approach takes an entire TypeScript project $g$ as its input, and the corresponding type prediction space is $\\mathcal { V } ( g ) = \\mathcal { V } _ { \\mathrm { l i b } } \\cup \\mathcal { V } _ { \\mathrm { u s e r } } ( g )$ . In our experiments, we set $\\mathcal { V } _ { \\mathrm { u s e r } } ( g )$ to be all classes/interfaces defined in $g$ (except when comparing with DeepTyper, where we set $\\mathcal { V } _ { \\mathrm { u s e r } } ( g )$ to be empty), and for ${ \\mathcal { N } } _ { \\mathrm { l i b } }$ , we select the top-100 most common types in our training set. Note that this covers $9 8 \\%$ (resp. $9 7 . 5 \\%$ ) of the non-any annotations for the training (resp. test) set. ",
+        "bbox": [
+            173,
+            166,
+            825,
+            250
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Hyperparameters We selected hyperparameters by tuning on a validation set as we were developing our model. We use 32-dimensional type embedding vectors, and all MLP transformations in our model use one hidden layer of 32 units, except the MLP for computing scores in the prediction layer, which uses three hidden layers of sizes 32,16, and 8 (and size 1 for output). GNN message-passing layers from different time steps have independent weights. ",
+        "bbox": [
+            174,
+            257,
+            825,
+            327
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "We train our model using Adam (Kingma & Ba, 2014) with default parameters ( $\\alpha = 0 . 9$ , $\\beta = 0 . 9 9 9 \\mathrm { \\Omega }$ ) and set the learning rate to be $1 0 ^ { - 3 }$ initially but linearly decrease it to $1 0 ^ { - 4 }$ until the 30th epoch. We use a weight decay of $1 0 ^ { - 4 }$ for regularization and stop the training once the loss on validation set starts to increase (which usually happens around 30 epochs). We use the type annotations from a single project as a minibatch and limit the maximal batch size (via downsampling) to be the median of our training set to prevent any single project from having too much influence. ",
+        "bbox": [
+            174,
+            333,
+            825,
+            417
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Implementation Details. We implemented LAMBDANET in Scala, building on top of the Java high-performance Tensor library Nd4j(nd4), and used a custom automatic differentiation library to implement our GNN. Our GNN implementation does not use an adjacency matrix to represent GNN layers; instead, we build the hyperedge connections directly from our type dependency graph and perform batching when computing the messages for all hyperedges of the same type. ",
+        "bbox": [
+            174,
+            424,
+            825,
+            494
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Code Repository. We have made our code publicly available on Github.5 ",
+        "bbox": [
+            174,
+            501,
+            663,
+            515
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "5.1 COMPARISON WITH DEEPTYPER ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            537,
+            439,
+            553
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "In this experiment, we compare LAMBDANET’s performance with DeepTyper (Hellendoorn et al., 2018), which treats programs as sequences of tokens and uses a bidirectional RNN to make type predictions. Since DeepTyper can only predict types from a fixed vocabulary, we fix both LAMBDANET and DeepTyper’s prediction space to ${ \\mathcal { N } } _ { \\mathrm { l i b } }$ and measure their corresponding top-1 accuracy. ",
+        "bbox": [
+            174,
+            566,
+            825,
+            622
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "The original DeepTyper model makes predictions for each variable occurrence rather than declaration. In order to conduct a meaningful comparison between DeepTyper and LAMBDANET, we implemented a variant of DeepTyper that makes a single prediction for each variable (by averaging over the RNN internal states of all occurrences of the same variable before making the prediction). Moreover, for a fair comparison, we made sure both DeepTyper and LAMBDANET are using the same improved naming feature that splits words into tokens. ",
+        "bbox": [
+            174,
+            628,
+            825,
+            713
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Our main results are summarized below, where the Declaration (resp. Occurrence) column shows accuracy per variable declaration (resp. token-level occurrence). Note that we obtain occurrence-level accuracy from declaration-level accuracy by weighting each variable by its number of occurrences. ",
+        "bbox": [
+            176,
+            719,
+            823,
+            762
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "table",
+        "img_path": "images/31c68df64eb2110e4109736d455d3ea9cdaa31a6f60c0b757ace4acc03bab5d8.jpg",
+        "table_caption": [],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Model</td><td colspan=\"2\">Top1 Accuracy (%) Declaration Occurrence</td></tr><tr><td>DeepTyper</td><td>61.5</td><td>67.4</td></tr><tr><td>LAMBDANETlib (K=6)</td><td>75.6</td><td>77.0</td></tr></table>",
+        "bbox": [
+            315,
+            768,
+            681,
+            840
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "program. Instead, they only need to annotate some key places (e.g., function parameters and return types, class members) and let the forward inference algorithm to figure out the rest of the types. Therefore, in our training set, we can keep the user annotations on these key places and run the TS compiler to recover these implicitly specified types as additional labels. ",
+        "bbox": [
+            176,
+            859,
+            823,
+            910
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "table",
+        "img_path": "images/9c0591eac7853e28eaa2e94a9188412913e417de04594be75f5393ad2cb70643.jpg",
+        "table_caption": [
+            "Table 2: Accuracy when predicting all types. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Model</td><td colspan=\"3\">Top1 Accuracy (%)</td><td colspan=\"3\">Top5 Accuracy (%)</td></tr><tr><td></td><td>Yuser</td><td>Vlib</td><td>Overall</td><td>Vuser</td><td>Vlib</td><td>Overall</td></tr><tr><td>TS COMPILER</td><td>2.66</td><td>14.39</td><td>8.98</td><td>=</td><td>1</td><td>=</td></tr><tr><td>SIMILARNAME</td><td>24.1</td><td>0.78</td><td>15.7</td><td>42.5</td><td>3.19</td><td>28.4</td></tr><tr><td>LAMBDANET (K=6)</td><td>53.4</td><td>66.9</td><td>64.2</td><td>77.7</td><td>86.2</td><td>84.5</td></tr></table>",
+        "bbox": [
+            246,
+            114,
+            751,
+            200
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "table",
+        "img_path": "images/c050fe5203c0a63cdaa3b27dd12048cc5c4310fdfaf2384df0fc2667797885f5.jpg",
+        "table_caption": [
+            "Table 3: Performance of different GNN iterations (left) and ablations (right). "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>K</td><td colspan=\"2\">Top1 Accuracy (%) Yuser Vlib</td></tr><tr><td>6</td><td>53.4</td><td>Overall 64.2</td></tr><tr><td>4</td><td>48.4</td><td>66.9 65.5 62.0</td></tr><tr><td>2</td><td>47.3 61.7</td><td>58.8</td></tr><tr><td>1</td><td>16.8 48.2</td><td>41.9</td></tr><tr><td>0</td><td>0.0 17.0</td><td>13.6</td></tr></table>",
+        "bbox": [
+            215,
+            238,
+            419,
+            352
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "table",
+        "img_path": "images/867f9b5b9beb63cf9bb4e93c830c897a5e7d7f696a1ca14d863c872dea0aa122.jpg",
+        "table_caption": [],
+        "table_footnote": [
+            "∗ Training was unstable and experienced gradient explosion. "
+        ],
+        "table_body": "<table><tr><td>Ablation (K= 4)</td><td colspan=\"2\">Top1 Accuracy (%) Vuser Ylib Overall</td></tr><tr><td>LAMBDANET</td><td>48.4 65.5</td><td>62.0</td></tr><tr><td>No Attention in NPAIR</td><td>44.1</td><td>57.6 54.9</td></tr><tr><td>No Contextual</td><td>27.2</td><td>52.6 47.5</td></tr><tr><td>No Logical*</td><td>24.7</td><td>36.2</td></tr><tr><td>Simple Aggregation</td><td>40.2</td><td>61.5</td></tr></table>",
+        "bbox": [
+            439,
+            239,
+            782,
+            353
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "As we can see from the table, LAMBDANET achieves significantly better results compared to DeepTyper. In particular, LAMBDANET outperforms DeepTyper by $1 4 . 1 \\%$ (absolute) for declarationlevel accuracy and by $9 . 6 \\%$ for occurrence-level accuracy. ",
+        "bbox": [
+            174,
+            383,
+            823,
+            425
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Note that the accuracy we report for DeepTyper $( 6 7 . 4 \\% )$ is not directly comparable to the original accuracy reported in Hellendoorn et al. (2018) $( 5 6 . 9 \\% )$ for the following reasons. While we perform static analysis and have a strict distinction of library vs. user-defined types and only evaluate both tools on library type annotations in this experiment, their implementation treat types as tokens and does not have this distinctions. Hence, their model also considers a much larger prediction space consisting of many user-defined types—most of which are never used outside of the project in which they are defined—and is also evaluated on a different set of annotations than ours. ",
+        "bbox": [
+            174,
+            431,
+            825,
+            530
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "5.2 PREDICTING USER-DEFINED TYPES ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            546,
+            464,
+            560
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "As mentioned earlier, our approach differs from prior work in that it is capable of predicting userdefined types; thus, in our second experiment, we extend LAMBDANET’s prediction space to also include user-defined types. However, since such types are not in the prediction space of prior work (Hellendoorn et al., 2018), we implemented two simpler baselines that can be used to calibrate our model’s performance. Our first baseline is the type inference performed by the TypeScript compiler, which is sound but incomplete (i.e., if it infers a type, it is guaranteed to be correct, but it infers type any for most variables).6 Our second baseline, called SIMILARNAME, is inspired by the similarity between variable names and their corresponding types; it predicts the type of each variable $v$ to be the type whose name shares the most number of common word tokens with $v$ . ",
+        "bbox": [
+            174,
+            571,
+            825,
+            698
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "The results of this experiment are shown in Table 2, which shows the top-1 and top-5 accuracy for both user-defined and library types individually as well as overall accuracy. In terms of overall prediction accuracy, LAMBDANET achieves $6 4 . 2 \\%$ for top-1 and $8 4 . 5 \\%$ for top-5, significantly outperforming both baselines. Our results suggest that our fusion of logical and contextual information to predict types is far more effective than rule-based incorporation of these in isolation. ",
+        "bbox": [
+            174,
+            705,
+            823,
+            775
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "5.3 ABLATION STUDY ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            791,
+            341,
+            806
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Table 3 shows the results of an ablation study in which (a) we vary the number of message-passing iterations (left) and (b) disable various features of our architecture design (right). As we can see from the left table, accuracy continues to improve as we increase the number of message passing iterations as high as 6; this gain indicates that our network learns to perform inference over long distances. The right table shows the impact of several of our design choices on the overall result. ",
+        "bbox": [
+            174,
+            818,
+            825,
+            887
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "For example, if we do not use Contextual edges (resp. Logical edges), overall accuracy drops by $1 4 . 5 \\%$ (resp. $2 5 . 8 \\%$ ). These drops indicate that both kinds of predicates are crucial for achieving good accuracy. We also see that the attention layer for NPAIR makes a significant difference for both library and user-defined types. Finally, Simple Aggregation is a variant of LAMBDANET that uses a simpler aggregation operation which replaces the attention-based weighed sum in $\\mathrm { E q ~ } 1$ with a simple average. As indicated by the last row of Table 3 (right), attention-based aggregation makes a substantial difference for user-defined types. ",
+        "bbox": [
+            174,
+            103,
+            825,
+            202
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "5.4 COMPARISON WITH JSNICE ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            217,
+            406,
+            232
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Since JSNice (Raychev et al., 2015) cannot properly handle class definitions and user-defined types, for a meaningful comparison, we compared both tools’ performance on top-level functions randomly sampled from our test set. We filtered out functions whose parameters are not library types and manually ensured that all all the dependency definitions are also included. In this way, we constructed a small benchmark suite consisting of 41 functions. Among the 107 function parameter and return type annotations, LAMBDANET correctly predicted 77 of them, while JSNice only got 48 of them right. These results suggest that LAMBDANET outperforms JSNice, even when evaluated only on the places where JSNice is applicable. ",
+        "bbox": [
+            174,
+            243,
+            825,
+            354
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "6 RELATED WORK ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            375,
+            343,
+            391
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Type Inference using Statistical Methods. There are several previous works on predicting likely type annotations for dynamically typed languages: Raychev et al. (2015) and Xu et al. (2016) use structured inference models for Javascript and Python, but their approaches do not take advantage of deep learning and are limited to a very restricted prediction space. Hellendoorn et al. (2018) and Jangda & Anand (2019) model programs as sequences and AST trees and apply deep learning models (RRNs and Tree-RNNs) for TypeScript and Python programs. Malik et al. (2019) make use of a different source of information and take documentation strings as part of their input. However, all these previous works are limited to predicting types from a fixed vocabulary. ",
+        "bbox": [
+            174,
+            405,
+            825,
+            517
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Graph Embedding of Programs. Allamanis et al. (2017) are the first to use GNNs to obtain deep embedding of programs, but they focus on predicting variable names and misuses for $C ^ { \\sharp }$ and rely on static type information to construct the program graph. Wang et al. (2017) use GNNs to encode mathematical formulas for premise selection in automated theorem proving. The way we encode types has some similarity to how they encode quantified formulas, but while their focus is on higherorder formulas, our problem requires encoding object types. Velickovi ˇ c et al. (2018) are the first to ´ use an attention mechanism in GNNs. While they use attention to compute node embeddings from messages, we use attention to compute certain messages from node embeddings. ",
+        "bbox": [
+            174,
+            523,
+            825,
+            636
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Predicting from an Open Vocabulary. Predicting unseen labels at test time poses a challenge for traditional machine learning methods. For computer vision applications, solutions might involve looking at object attributes (Farhadi et al., 2017) or label similarity Wang et al. (2018); for natural language, similar techniques are applied to generalize across semantic properties of utterances (Dauphin et al., 2013), entities (Eshel et al., 2017), or labels (Ren et al., 2016). Formally, most of these approaches compare an embedding of an input to some embedding of the label; what makes our approach a pointer network (Vinyals et al., 2015) is that our type encodings are derived during the forward pass on the input, similar to unknown words for machine translation (Gulcehre et al., 2016). ",
+        "bbox": [
+            174,
+            642,
+            825,
+            767
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "7 CONCLUSIONS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            787,
+            328,
+            804
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "We have presented LAMBDANET, a neural architecture for type inference that combines the strength of explicit program analysis with graph neural networks. LAMBDANET not only outperforms other state-of-the-art tools when predicting library types, but can also effectively predict user-defined types that have not been encountered during training. Our ablation studies demonstrate the usefulness of our proposed logical and contextual hyperedges. ",
+        "bbox": [
+            174,
+            819,
+            825,
+            888
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "For future work, there are several potential improvements and extensions to our current system. One limitation of our current architecture is the simplified treatment of function types and generic types (i.e., collapsing them into their non-generic counterparts). Extending the prediction space to also include structured types would allow us to make full use of the rich type systems many modern languages such as TypeScript provide. Another important direction is to enforce hard constraints during inference such that the resulting type assignments are guaranteed to be consistent. ",
+        "bbox": [
+            174,
+            895,
+            823,
+            924
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            103,
+            823,
+            160
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "ACKNOWLEDGMENTS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            181,
+            356,
+            195
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "We would like to thank DeepTyper authors, Vincent J. Hellendoorn, Christian Bird, Earl T. Barr, and Miltiadis Allamanis, for sharing their data set and helping us set up our experimental comparisons. We also thank the ICLR reviewers for their insightful comments and constructive suggestions. Finally, we would also like to thank Shankara Pailoor, Yuepeng Wang, Jocelyn Chen, and other UToPiA group members for their kind support and useful feedback. This project was supported in part by NSF grant CCF-1762299. ",
+        "bbox": [
+            174,
+            212,
+            825,
+            295
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "REFERENCES ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            316,
+            285,
+            332
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Deeplearning4j. https://github.com/eclipse/deeplearning4j. Accessed: 2019- 09-24. ",
+        "bbox": [
+            173,
+            340,
+            821,
+            369
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Miltiadis Allamanis, Marc Brockschmidt, and Mahmoud Khademi. Learning to represent programs with graphs. ICLR, 2017. ",
+        "bbox": [
+            173,
+            377,
+            823,
+            406
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Davide Ancona and Elena Zucca. Principal typings for java-like languages. In ACM SIGPLAN Notices, volume 39, pp. 306–317. ACM, 2004. ",
+        "bbox": [
+            173,
+            416,
+            825,
+            445
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Gavin Bierman, Mart´ın Abadi, and Mads Torgersen. Understanding typescript. In Richard Jones (ed.), ECOOP 2014 �� Object-Oriented Programming, pp. 257–281, Berlin, Heidelberg, 2014. Springer Berlin Heidelberg. ISBN 978-3-662-44202-9. ",
+        "bbox": [
+            178,
+            454,
+            823,
+            497
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Benjamin Chung, Paley Li, Francesco Zappa Nardelli, and Jan Vitek. Kafka: Gradual typing for objects. In ECOOP 2018-2018 European Conference on Object-Oriented Programming, 2018. ",
+        "bbox": [
+            173,
+            506,
+            823,
+            535
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Yann Dauphin, Gokhan Tur, Dilek Z. Hakkani-Tur, and Larry P. Heck. Zero-shot learning for semantic utterance classification. In ICLR, 2013. ",
+        "bbox": [
+            174,
+            544,
+            823,
+            573
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Yotam Eshel, Noam Cohen, Kira Radinsky, Shaul Markovitch, Ikuya Yamada, and Omer Levy. Named entity disambiguation for noisy text. In CoNLL, 2017. ",
+        "bbox": [
+            174,
+            582,
+            821,
+            611
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Ali Farhadi, Ian Endres, Derek Hoiem, and David Forsyth. Describing objects by their attributes. In CVPR, 2017. ",
+        "bbox": [
+            174,
+            619,
+            823,
+            648
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Zheng Gao, Christian Bird, and Earl T. Barr. To type or not to type: Quantifying detectable bugs in javascript. In Proceedings of the 39th International Conference on Software Engineering, ICSE ’17, pp. 758–769, Piscataway, NJ, USA, 2017. IEEE Press. ISBN 978-1-5386-3868-2. doi: 10.1109/ICSE.2017.75. URL https://doi.org/10.1109/ICSE.2017.75. ",
+        "bbox": [
+            173,
+            657,
+            825,
+            715
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Caglar Gulcehre, Sungjin Ahn, Ramesh Nallapati, Bowen Zhou, and Yoshua Bengio. Pointing the unknown words. In Proceedings of the ACL, 2016. ",
+        "bbox": [
+            174,
+            724,
+            823,
+            753
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Stefan Hanenberg, Sebastian Kleinschmager, Romain Robbes, Eric Tanter, and Andreas Stefik. An ´ empirical study on the impact of static typing on software maintainability. Empirical Software Engineering, 19:1335–1382, 2013. ",
+        "bbox": [
+            174,
+            763,
+            825,
+            806
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Vincent J. Hellendoorn, Christian Bird, Earl T. Barr, and Miltiadis Allamanis. Deep learning type inference. In Proceedings of the 2018 26th ACM Joint Meeting on European Software Engineering Conference and Symposium on the Foundations of Software Engineering, ESEC/FSE 2018, pp. 152–162, New York, NY, USA, 2018. ACM. ISBN 978-1-4503-5573-5. doi: 10.1145/3236024. 3236051. URL http://doi.acm.org/10.1145/3236024.3236051. ",
+        "bbox": [
+            174,
+            815,
+            825,
+            886
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Abhinav Jangda and Gaurav Anand. Predicting variable types in dynamically typed programming languages. arXiv preprint arXiv:1901.05138, 2019. ",
+        "bbox": [
+            174,
+            895,
+            821,
+            924
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Diederik P. Kingma and Jimmy Ba. Adam: A method for stochastic optimization. In ICLR, 2014. ",
+        "bbox": [
+            168,
+            103,
+            812,
+            119
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Yujia Li, Daniel Tarlow, Marc Brockschmidt, and Richard S. Zemel. Gated graph sequence neural networks. ICLR, abs/1511.05493, 2016. ",
+        "bbox": [
+            169,
+            127,
+            821,
+            156
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Rabee Sohail Malik, Jibesh Patra, and Michael Pradel. Nl2type: inferring javascript function types from natural language information. In Proceedings of the 41st International Conference on Software Engineering, pp. 304–315. IEEE Press, 2019. ",
+        "bbox": [
+            173,
+            165,
+            821,
+            208
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Lili Mou, Ge Li, Lu Zhang, Tao Wang, and Zhi Jin. Convolutional neural networks over tree structures for programming language processing. In AAAI, volume 2, pp. 4, 2016. ",
+        "bbox": [
+            171,
+            215,
+            823,
+            246
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Benjamin C Pierce and David N Turner. Local type inference. ACM Transactions on Programming Languages and Systems (TOPLAS), 22(1):1–44, 2000. ",
+        "bbox": [
+            171,
+            253,
+            823,
+            284
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Veselin Raychev, Martin Vechev, and Andreas Krause. Predicting program properties from ”big code”. In Proceedings of the 42Nd Annual ACM SIGPLAN-SIGACT Symposium on Principles of Programming Languages, POPL ’15, pp. 111–124, New York, NY, USA, 2015. ACM. ",
+        "bbox": [
+            176,
+            291,
+            825,
+            335
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Xiang Ren, Wenqi He, Meng Qu, Clare R Voss, Heng Ji, and Jiawei Han. Label noise reduction in entity typing by heterogeneous partial-label embedding. In Proceedings of the 22nd ACM SIGKDD International Conference on Knowledge Discovery and Data Mining, pp. 1825–1834. ACM, 2016. ",
+        "bbox": [
+            173,
+            343,
+            826,
+            400
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Jeremy G. Siek and Walid Taha. Gradual typing for objects. In ECOOP, 2007. ",
+        "bbox": [
+            171,
+            409,
+            691,
+            425
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Dmitriy Traytel, Stefan Berghofer, and Tobias Nipkow. Extending hindley-milner type inference with coercive structural subtyping. In Asian Symposium on Programming Languages and Systems, pp. 89–104. Springer, 2011. ",
+        "bbox": [
+            174,
+            433,
+            826,
+            476
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Petar Velickovi ˇ c, Guillem Cucurull, Arantxa Casanova, Adriana Romero, Pietro Li ´ o, and Yoshua \\` Bengio. Graph Attention Networks. International Conference on Learning Representations, 2018. accepted as poster. ",
+        "bbox": [
+            173,
+            484,
+            825,
+            527
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Oriol Vinyals, Meire Fortunato, and Navdeep Jaitly. Pointer networks. In NeurIPS, 2015. ",
+        "bbox": [
+            171,
+            535,
+            759,
+            551
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Michael M Vitousek, Andrew M Kent, Jeremy G Siek, and Jim Baker. Design and evaluation of gradual typing for python. In ACM SIGPLAN Notices, volume 50, pp. 45–56. ACM, 2014. ",
+        "bbox": [
+            173,
+            559,
+            825,
+            589
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Mingzhe Wang, Yihe Tang, Jian Wang, and Jia Deng. Premise selection for theorem proving by deep graph embedding. In Advances in Neural Information Processing Systems, pp. 2786–2796, 2017. ",
+        "bbox": [
+            173,
+            597,
+            825,
+            640
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Xiaolong Wang, Yufei Ye, and Abhinav Gupta. Zero-shot recognition via semantic embeddings and knowledge graphs. In CVPR, 2018. ",
+        "bbox": [
+            173,
+            648,
+            823,
+            679
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Zhaogui Xu, Xiangyu Zhang, Lin Chen, Kexin Pei, and Baowen Xu. Python probabilistic type inference with natural language support. In Proceedings of the 2016 24th ACM SIGSOFT International Symposium on Foundations of Software Engineering, pp. 607–618. ACM, 2016. ",
+        "bbox": [
+            174,
+            686,
+            825,
+            731
+        ],
+        "page_idx": 10
+    }
+]

parse/train/LJjC6DmSkgT/LJjC6DmSkgT.md

@@ -0,0 +1,302 @@
+# Continual Learning via Local Module Composition
+
+Oleksiy Ostapenko12 Pau Rodríguez3 Massimo Caccia123 Laurent Charlin145 1Mila - Quebec AI Institute, 2Université de Montréal, 3ServiceNow, 4HEC Montréal, 5Canada CIFAR AI Chair
+
+# Abstract
+
+Modularity is a compelling solution to continual learning (CL), the problem of modeling sequences of related tasks. Learning and then composing modules to solve different tasks provides an abstraction to address the principal challenges of CL including catastrophic forgetting, backward and forward transfer across tasks, and sub-linear model growth. We introduce local module composition (LMC), an approach to modular CL where each module is provided a local structural component that estimates a module’s relevance to the input. Dynamic module composition is performed layer-wise based on local relevance scores. We demonstrate that agnosticity to task identities (IDs) arises from (local) structural learning that is module-specific as opposed to the task- and/or model-specific as in previous works, making LMC applicable to more CL settings compared to previous works. In addition, LMC also tracks statistics about the input distribution and adds new modules when outlier samples are detected. In the first set of experiments, LMC performs favorably compared to existing methods on the recent Continual Transfer-learning Benchmark without requiring task identities. In another study, we show that the locality of structural learning allows LMC to interpolate to related but unseen tasks (OOD), as well as to compose modular networks trained independently on different task sequences into a third modular network without any fine-tuning. Finally, in search for limitations of LMC we study it on more challenging sequences of 30 and 100 tasks, demonstrating that local module selection becomes much more challenging in presence of a large number of candidate modules. In this setting best performing LMC spawns much fewer modules compared to an oracle based baseline, however it reaches a lower overall accuracy. The codebase is available under https://github.com/oleksost/LMC.
+
+# 1 Introduction
+
+The goal of continual learning (CL) is to learn efficiently from a non-stationary stream of tasks without (catastrophically) forgetting previous tasks [62]. CL is often modeled as a trade-off between knowledge retention (stability) and knowledge expansion (plasticity) [26, 64]. Parameter sharing can provide control over this trade-off. For example, learning a single model shared across tasks results in better knowledge transfer and faster learning at the expense of forgetting [46, 57]. Conversely, learning a separate model per task eliminates forgetting but minimizes transfer and data efficiency [2, 41].
+
+Modular learning aims at balancing transfer and forgetting by learning a set of specialized modules that can be recomposed to solve (new) tasks while only updating a subset of relevant modules or adding new modules [6, 47, 27]. In principle, a modular learner capable of composing modules in meaningful structures can provide additional benefits including (i) computational gains due to only executing modules that are relevant to a task [47, 4]; (ii) memory gains due to instantiating a sub-linear number of modules w.r.t. the number of tasks; (iii) systematic [8] and out-of-distribution (OOD) generalization [18] through knowledge recombination; and (iv) biological plausibility [91, 90, 96].
+
+Designing modular methods for CL comes with two main challenges. The first is how and when to add new modules to ensure sufficient plasticity to learn new tasks. Existing modular methods use greedy search variants, expanding the model when it improves validation performance [92, 63]. The second challenge is how to compose that is, retrieve task-specific structural knowledge given a new task (previously seen or not).
+
+Existing methods rely on a task’s identifier (ID) to retrieve task-specific structural knowledge, which comes either in the form of an optimal module layout [92] or as a model- and task-specific controller network that generates modular layouts [63]. Unfortunately, in many realistic CL scenarios task identities are unavailable at test time [23, 35, 14]. Lifting this limitation is challenging since standard mechanisms for task inference, for example, leveraging a task-inference model, could be subject to forgetting themselves.
+
+To address both challenges, we equip each module with a local structural component that predicts a score indicating how relevant the module is for a given input. In-distribution inputs result in high scores, while out-of-distribution inputs result in low scores. In other words, modules self-determine their relevance given an input.
+
+This local component is used for composing modules: for each datum, modules are combined at each layer according to their normalized scores without requiring a task’s ID (§3). The local component is also used for module expansion: a new module is instantiated if all the current modules flag their input as being locally out-of-distribution (§3.1). Further, new shallow modules (i.e. closer to the input) are first trained in a projection phase to maximize the relatedness scores of subsequent, deeper, modules (§3.2). This process projects the output of new modules into the representation space expected by the subsequent modules and ensures the compatibility between low- and high-level modules.
+
+In a set of studies, we explore the performance and versatility of our local structural approach, which we call Local Module Composer (LMC). First, we show that LMC reaches superior or comparable performance to existing modular and non-modular methods without requiring task IDs at test time using the Continual Transfer Learning (CTrL) benchmark, designed to evaluate transfer and forgetting in CL [92] (§4.1). Then, we demonstrate how LMC, relying on its projection phase, can solve out-ofdistribution (OOD) tasks not seen during the continual training (§4.2). We also show it is possible to combine modules from independently trained models into a new model to solve tasks seen by each of the independent models without any finetuning (§4.3). Finally, an analysis of longer task sequences (30 and 100 tasks) reveals that LMC tends to spawn much fewer modules to reach good performance than the fully task-aware MNTDP [92] counterpart. However, LMC reaches slightly lower accuracy on longer sequences than MNTDP, which highlights the difficulty of automatic task-ID agnostic module selection in the presence of a large number of candidate modules. In Appendix F we demonstrate the applicability of LMC in the meta-continual learning (meta-CL) setting, a task-agnostic setting by nature.
+
+We highlight that by relying on a local (per-module) structural component, LMC offers a modular CL approach that i) does not require task IDs during test in the standard task incremental settings; ii) balances parameter sharing to yield strong CL performances compared to baselines that require access to the task ID; iii) in our experiments instantiates a sub-linear number of modules; iv) permits recombination of modules at test time enabling OOD generalization as well as (v) the ability to combine independently trained models in a third model without fine-tuning. Notably, the OOD generalization is only possible if the agent is task-agnostic in the module selection process, since OOD tasks were not observed at training, the learner has to interpolate between the learned tasks, and a (categorial) task ID is of no use.
+
+# 2 Background: Modular Continual Learning
+
+Let $\mathcal { F } ( x ; \theta ) : \mathcal { X }  \mathcal { Y }$ be a learner parametrized with a set of parameters $\theta$ . In task-incremental CL, the learner is exposed to a sequence of tasks. Each task is composed of a training set $D _ { t }$ of $( x , y )$ pairs and a task identifier (ID) $t$ [92, 46]. The goal is to learn an optimal $\theta ^ { * }$ that minimizes the loss $\mathcal { L }$ for all observed tasks:
+
+$$
+\theta ^ { * } = \underset { \theta } { \arg \operatorname* { m i n } } \sum _ { t = 1 } ^ { T } \mathbb { E } _ { ( x , y ) \sim D _ { t } } [ \mathcal { L } ( \mathcal { F } ( x ; \theta ) , y ) ] .
+$$
+
+![](images/79e5610f1b14f8153e55f838afeb9202b2b770be5adfa97cac2fc32f449df0f7.jpg)  
+Figure 1: Modular Layer Scheme. Each black rectangle is a module. Inside each module, the functional component receives the input $x ^ { ( l - 1 ) }$ and feeds its output to the structural component . m The output of the structural component is used to calculate the importance score $\gamma _ { m } ^ { ( l ) }$ using Eq. 5, which are normalized to obtain the attention vector . The layer output is the weighted sum of the functional outputs of each module. $\mu$ and $\sigma$ are the running mean and variance of the scores $\gamma _ { m } ^ { ( l ) }$ used to detect outlier inputs and to trigger module addition.
+
+The parameter sharing trade-off between tasks can be addressed through different architectural design choices for $\mathcal { F }$ . For example, $\mathcal { F }$ can be a monolithic network that shares parameters $\theta$ across all tasks. Most existing task incremental CL methods use a task-specific output head, requiring the task ID to select the output head corresponding to the task at hand [46, 87, 1].
+
+At the other end of the spectrum are the expert based solutions that learn an independent model, a.k.a.   
+expert, for each task [2, 83]. In this case, each expert trains task-specific parameters $\boldsymbol { \theta } = \{ \boldsymbol { \theta } ^ { ( t ) } \} _ { t = 1 } ^ { T }$ .
+
+To balance parameter sharing and transfer, modular methods organize their parameters in a series of modules $M = \{ m _ { k } ^ { ( l ) } \}$ with parameters $\boldsymbol { \theta } = \{ \boldsymbol { \theta } _ { k } ^ { ( l ) } \}$ , where $\theta _ { k } ^ { ( l ) }$ denotes the parameters of module at layer in $\mathcal { F }$ . In general, a module can be any parametric function. In our experiments, unless otherwise stated, a module consists of a single convolutional layer followed by batch-norm, ReLU activation, and a max-pooling operation.
+
+Modules can be composed conditioned on a sample, a batch of samples, or a task. Let $\psi$ denote a specific composition of modules that gives rise to a distinct prediction function; we make this dependence explicit: $\mathcal { F } ( x ; \theta , \psi )$ . Importantly, sharing modules across tasks should lead to desirable transfer properties.
+
+Veniat et al. [92] frames modular CL as finding an optimal layout $\psi ^ { ( t ) }$ for each task, where each layout selects a single module per layer per task (hard selection):
+
+$$
+\theta ^ { * } , \Psi ^ { * } = \underset { \theta , \Psi } { \arg \operatorname* { m i n } } \sum _ { t = 1 } ^ { T } \mathbb { E } _ { ( x , y ) \sim D _ { t } } [ \mathcal { L } ( \mathcal { F } ( x ; \theta , \psi ^ { ( t ) } ) , y ) ] .
+$$
+
+In this case the set of layouts $\Psi = \{ \psi ^ { ( t ) } \}$ grows with the number of tasks, while modules can be reused across different task-specific layouts resulting in sub-linear growth pattern. They design a method called MNTDP to search the exponentially large space of modular layouts by only considering layouts resulting from adding a new module per layer to the best prior path (past task’s path with the highest nearest neighbor accuracy on a new task) starting at the top layer. This solution relies on task IDs to retrieve $\psi ^ { ( t ) }$ at test time.
+
+Another way of composing modules uses dynamic routing [63, 82, 47, 65]. The module layout is generated by a structural function $\psi = s ( x )$ , hence different inputs take different routes through $\mathcal { F }$ . It is standard to approximate the structural function using a neural network $\psi = s ( x ; \phi )$ with structural parameters $\phi$ . This framework has been applied to CL in [63] by learning a separate structural function per task $\psi ^ { ( t ) } = s ( x ; \phi ^ { ( t ) } )$ . The task IDs are used to retrieve the correct structural function:
+
+$$
+\theta ^ { * } , \Phi ^ { * } = \underset { \theta , \Phi } { \arg \operatorname* { m i n } } \sum _ { t = 1 } ^ { T } \mathbb { E } _ { ( x , y ) \sim D _ { t } } [ \mathcal { L } ( \mathcal { F } ( x ; \theta , s ( x ; \phi ^ { ( t ) } ) ) , y ) ] ,
+$$
+
+where $\Phi = \{ \phi ^ { ( t ) } \}$ is the set of structural parameters for all tasks.
+
+![](images/637696b9b75108d43c64f5d8d33137e3bcbb1fc4d129dee043a64ee8e9ade9f4.jpg)  
+Figure 2: Two-phase training. Each module contains a functional (rectangle) and structural (trapezoid) component. Their color intensity denotes the strength of their activation. Components with dashed contours are trained, solid contours represent fixed components, arrows show the gradient flow: black arrow — functional signal, pink — structural signal. (A) All modules are trained on task 0. (B) Task 1 arrives, a new module is added at layer 1, which is first trained to project its output into the representation of the modules above via the structural signal (the functional signal is optional). No module addition is allowed during the projection phase. (C) Module addition is allowed again, both signals are used for training. (D) As task 3 arrives, a new module is added at layer 1 again, projection phase is triggered. (E) A new module is added at the layer 2, both new modules are now trained in the second projection phase. (F) Both new modules are trained using both signals.
+
+The above methods require task IDs at both training and testing time. Next we introduce our modular CL approach that only relies on task IDs during training.
+
+# 3 Local Module Composer (LMC)
+
+We propose LMC, a modular approach where each module consists of a functional component $f ( x ; \theta _ { m } ^ { ( \bar { l } ) } )$ and a structural component $s ( x ; \phi _ { m } ^ { ( l ) } )$ , see Figure 1. The functional components are responsible for learning to solve the prediction task and are trained via the usual task loss $\mathcal { L }$ (e.g. cross-entropy loss for classification). The structural components receive the corresponding functional output as their input (see Figure 1) and are responsible for dynamic routing through $\mathcal { F }$ . Structural parameters $\phi$ are trained using a structural loss $\bar { \mathcal { L } } ^ { ( s t . ) }$ computed locally at each module.
+
+Intuitively, the structural component of a module should serve as a density estimator of the outputs of the functional component. The module’s contribution to the layer’s output is proportional to the likelihood of the input sample under the estimated density. In our instantiation, the structural component produces a relatedness score: a lower score for inputs that are more likely to belong to the distribution on which a given module was trained, and a higher score for inputs that are out-of-distribution for the given module. Hence, the likelihood of the input sample is approximated by the negative relatedness score.
+
+Given an input data sample $x ^ { ( 0 ) } = x$ , the output $x ^ { ( l ) }$ of a layer $l$ is defined as the weighted sum of the functional outputs of all $| M ^ { ( l ) } |$ local modules and used as input to the subsequent layer $l + 1$ :
+
+$$
+\boldsymbol { x } ^ { ( l ) } = \sum _ { m = 1 } ^ { | M ^ { ( l ) } | } w _ { m } ^ { ( l ) } \cdot f ( \boldsymbol { x } ^ { ( l - 1 ) } ; \boldsymbol { \theta } _ { m } ^ { ( l ) } ) .
+$$
+
+The functional output of the network is equal to the output of the final layer: $\mathcal { F } ( x ; \theta , \phi ) = x ^ { ( L ) }$ . In the last layer $\mathcal { F }$ implements a single output-head per task. At training time, the task ID is available and we update only the output-head corresponding to the currently learned task. At test time, the task ID is not available and we select the output head with the highest activation weight $w _ { m } ^ { ( L ) }$ , i.e., the last layer performs hard module selection.
+
+The module activation weights $w _ { m } ^ { ( l ) }$ are computed by normalizing the vector of local relatedness scores $\gamma ^ { ( l ) } \in \mathbb { R } ^ { | M ^ { ( l ) } | }$ . Each element of $\gamma ^ { ( l ) }$ is obtained from the negative structural loss which approximates the likelihood of each module:
+
+$$
+\begin{array} { r l } & { \gamma _ { m } ^ { ( l ) } = - \mathcal { L } ^ { ( s t . ) } \Bigl ( s \bigl [ f ( x ^ { ( l - 1 ) } ; \theta _ { m } ^ { ( l ) } ) ; \phi _ { m } ^ { ( l ) } \bigr ] \Bigr ) , } \\ & { w _ { m } ^ { ( l ) } = \mathrm { s o f t m a x } ( \gamma ^ { ( l ) } ) _ { m } . } \end{array}
+$$
+
+Modules with lower structural loss get higher activation weights. Note that in practice, it can be useful to bias the module selection towards the expected module selection in a batch, assuming that samples within a batch are likely to belong to the same task. We discuss this point further in $\ S \operatorname { A . 1 }$ .
+
+Instead of using the softmax function, it is possible perform hard selection taking the module with the highest score [82], or alternatively selecting top-k modules [88]. In both cases, LMC’s structural parameters stay differentiable due to the local nature of structural learning. Note that in the case of global structural objective, hard module selection would require applying tools for non-differentiable learning such as Expectation Maximization [47] or reinforcement-learning based methods [82, 5].
+
+The overall LMC objective consists of optimizing both functional and structural losses:
+
+$$
+\theta ^ { * } , \phi ^ { * } = \underset { \theta , \phi } { \operatorname { a r g m i n } } \sum _ { t = 1 } ^ { T } \mathbb { E } _ { ( x , y ) \sim D _ { t } } \Big [ \mathcal { L } \big ( \mathcal { F } ( x ; \theta , \phi ) , y \big ) + \sum _ { l = 0 } ^ { L } \sum _ { m = 0 } ^ { | M ^ { ( l ) } | } \mathcal { L } _ { m } ^ { ( s t . ) } \big ( s [ f ( x ^ { ( l - 1 ) } ; \theta _ { m } ^ { ( l ) } ) ; \phi _ { m } ^ { ( l ) } ] \big ) \Big ] .
+$$
+
+As in [92], learning is performed w.r.t. only newly introduced modules to prevent forgetting.
+
+Structural component. We test two instantiations of the structural component $s$ and loss $\mathcal { L } _ { m } ^ { ( s t . ) }$ . In the first one, $s$ is an invertible neural network [80]. Here we use the invertible architecture proposed by Dinh et al. [21]. As shown by Hocquet et al. [37], for this invertible architecture the structural objective can be defined as from collapsing to an all-ze $\mathcal { L } _ { m } ^ { ( s t . ) } ( x ) = | | x | | _ { 2 }$ . Intuitively, an invertible architecture prevents $\mathcal { L } _ { m } ^ { ( s t . ) }$
+
+In the second instantiation, $s$ and $f$ form an autoencoder and $\mathcal { L } _ { m } ^ { ( s t . ) } ( x ) = | | x ^ { ( l - 1 ) } - x | | ^ { 2 }$ is the reconstruction error with respect to the module’s input $x ^ { ( l - 1 ) }$ . Aljundi et al. [2] used a similar idea was for selecting the most relevant expert network conditioned on a task. Unless stated otherwise, modules in the feature extractor use the autoencoder as their structural component, while output heads use invertible $s$ — these combinations worked well in practice.
+
+# 3.1 Expansion strategy
+
+It is necessary to expand $\mathcal { F }$ as new tasks arrive to acquire new knowledge. A new module is added to a layer when all modules in this layer detect an outlier input. To this end, we track the running statistics of the relatedness score $\gamma$ for each module — mean $\mu$ and variance $\sigma$ (see Figure 1), and calculate a z-score for each sample in the batch and each module at a layer:
+
+$$
+z _ { m } = \frac { w _ { m } - \mu _ { m } } { \sigma _ { m } } .
+$$
+
+An input is considered an outlier if its $\mathbf { Z }$ -score is larger than a predefined threshold $z ^ { \prime }$ (see Appendix B.6 for an ablation study of $z ^ { \prime }$ values). The expansion decision can be made on the per-sample (i.e., if an outlier sample is detected) or a per-batch basis (i.e., $z$ is averaged over the mini-batch). Unless stated otherwise, in our experiments, the decision was made on a per-batch basis. Additionally, at training the parameters of existing modules are fixed once the task changes. If during a forward pass through $\mathcal { F }$ module addition is triggered at multiple layers, we start adding modules at the layer closest to the input.
+
+# 3.2 Training
+
+Each module in LMC receives two types of learning signal: a structural signal resulting from minimizing $\mathcal { L } _ { m } ^ { ( s t . ) }$ , and a functional signal resulting from minimizing the global functional loss $\mathcal { L }$ All structural components $s$ are trained only with the structural signal that is calculated locally to each module.
+
+The training of functional components proceeds in two phases: projection and accumulation. Whenever the expansion strategy triggers the addition of a new module (i.e., $z _ { m } > z ^ { \prime } \forall m \in$ $\{ 0 , \ldots , | M ^ { ( l ) } | \} )$ , starting with layers closest to the input, LMC initiates the projection phase. During this phase, the new module is trained to minimize the structural loss from all the layers above and no new-module addition is allowed. This procedure makes the representation of new modules compatible with subsequent modules and enables their composition. This procedure “encourages” already-learned modules to be reused, preventing over-spawning new modules. The functional signal is optional during projection (we kept it in all experiments unless otherwise stated).
+
+Table 1: CTrL results: we report accuracy $( \uparrow \mathcal { A } )$ , forgetting $( \uparrow \mathcal { F } )$ with standard deviations calculated over 6 different runs. We report the mean number of modules (M) over these runs, where ∗ marks methods with fixed capacity. The first block comprises a set of standard CL baselines including regularization and replay based methods. The second block are the modular methods, third – modular and replay based methods that are task ID agnostic (A), and the last block are the two finetuning baselines. (H) indicates hard module selection. (S) indicates single-head as detailed in the main text.   
+
+<table><tr><td></td><td colspan="3">si</td><td colspan="3">S+</td><td colspan="3">Sin</td><td colspan="3">Sout</td><td colspan="3">Spl</td></tr><tr><td>MODEL</td><td>A</td><td>F</td><td>M</td><td>A</td><td>F</td><td>M</td><td>A</td><td>F</td><td>M</td><td>A</td><td>F</td><td>M</td><td>A</td><td>F</td><td>M</td></tr><tr><td>HAT[87]</td><td>63.7±0.7</td><td>-1.3±0.6</td><td>24*</td><td>61.4±0.5</td><td>-0.2±0.2</td><td>24*</td><td>50.1±0.8</td><td>0.0±0.1</td><td>24*</td><td>61.9±1.3</td><td>-3.2±1.3</td><td>24*</td><td>61.2±0.7</td><td>-0.1±0.2</td><td>20*</td></tr><tr><td>EWC[46]</td><td>62.7±0.7</td><td>-3.6±0.9</td><td>24*</td><td>53.4±1.8</td><td>-2.3±0.4</td><td>24*</td><td>56.3±2.5</td><td>-9.1±3.3</td><td>24*</td><td>62.5±0.9</td><td>-3.6±0.9</td><td>24*</td><td>54.2±3.1</td><td>-4.2±2.7</td><td>20*</td></tr><tr><td>O-EWC[85]</td><td>62.0±0.7</td><td>-3.2±0.7</td><td>24*</td><td>54.6±0.7</td><td>-1.3±1.0</td><td>24*</td><td>54.2±3.1</td><td>-10.8±3.1</td><td>24*</td><td>62.4±0.6</td><td>-3.0±0.9</td><td>24*</td><td>52.3±1.4</td><td>-5.7±1.3</td><td>20*</td></tr><tr><td>ER[81,16]</td><td>60.6±0.7</td><td>-2.1±0.9</td><td>4*</td><td>63.0±0.6</td><td>3.8±0.8</td><td>4*</td><td>63.8±1.4</td><td>-1.9±0.6</td><td>4*</td><td>60.7±1.0</td><td>-1.5±0.5</td><td>4*</td><td>60.5±1.0</td><td>0.5±0.9</td><td>4*</td></tr><tr><td>EXPERTS</td><td>62.7±0.9</td><td>0.0</td><td>24</td><td>63.2±0.8</td><td>0.0</td><td>24</td><td>63.1±0.7</td><td>0.0</td><td>24</td><td>63.1±0.7</td><td>0.0</td><td>24</td><td>63.9±0.5</td><td>0.0</td><td>20</td></tr><tr><td>MNTDP[92]</td><td>66.3±0.8</td><td>0.0</td><td>13.7</td><td>62.6±0.7</td><td>0.0</td><td>21.0</td><td>67.9±0.9</td><td>0.0</td><td>16.0</td><td>65.8±0.9</td><td>0.0</td><td>15.0</td><td>64.0±0.2</td><td>0.0</td><td>17.2</td></tr><tr><td>SG-F[63]</td><td>63.6±1.5</td><td>0.0</td><td>14.7</td><td>61.5±0.6</td><td>0.0</td><td>20.8</td><td>65.5±1.8</td><td>0.0</td><td>17.5</td><td>64.1±1.3</td><td>0.0</td><td>16.2</td><td>62.0±1.3</td><td>0.0</td><td>16.0</td></tr><tr><td>LMC(- A)</td><td>66.6±1.5 -0.0±0.1</td><td></td><td>15.3</td><td>60.1±2.7</td><td>-1.4±2.4</td><td>21.3</td><td>69.5±1.0</td><td>0.0±0.1</td><td>20.0</td><td>66.7±2.2</td><td>-0.1±0.1</td><td>15.5</td><td>61.6±4.8</td><td>-3.5±3.1</td><td>18.2</td></tr><tr><td>MNTDP(A)</td><td>41.9±2.5</td><td>-2.8±0.6</td><td>14.8</td><td>43.2±1.3-10.8±2.020.7|3</td><td></td><td></td><td></td><td>|32.7±13.6-15.2±13.2]</td><td>17.2</td><td>37.9±2.7</td><td>-5.8±3.5</td><td>13.3</td><td>35.1±3.6</td><td>5-16.4±4.6 15.8</td><td></td></tr><tr><td>LMC(A)</td><td>67.2±1.5</td><td>-0.5±0.4</td><td>15.7</td><td>62.2±4.5</td><td>2.3±1.6</td><td>22.3</td><td>68.5±1.7</td><td>-0.1±0.1</td><td>19.7</td><td>55.1±3.4</td><td>-7.1±4.0</td><td>15.5</td><td>63.5±1.9</td><td>-1.0±1.5</td><td>19.0</td></tr><tr><td>LMC(A,H)</td><td>64.9±1.5 -0.2±0.2</td><td></td><td>16.2</td><td>55.8±2.5</td><td>-0.3±1.2</td><td>15.3</td><td>67.6±2.7</td><td>-0.8±1.0</td><td>21.5</td><td>54.2±3.6</td><td>-2.9±2.0</td><td>15.9</td><td>53.8��5.7</td><td>3.1±5.5</td><td>10.8</td></tr><tr><td>SG-F(A)</td><td>29.5±3.5 -35.3±4.0 14.3</td><td></td><td></td><td>20.4±4.4</td><td>-39.3±6.716.0</td><td></td><td>24.4±5.6</td><td>-38.7±4.0</td><td>18.7</td><td>30.5±4.5</td><td>-34.0±5.512.2</td><td></td><td>19.4±1.0</td><td>-41.8±1.6</td><td>15.5</td></tr><tr><td>ER(A,S)[81,16]</td><td>60.4±1.0 -0.5±0.7</td><td></td><td>4*</td><td>65.3±0.9</td><td>6.0±1.0</td><td>4*</td><td>58.8±3.2</td><td>-4.2±3.7</td><td>4*</td><td>47.6±1.5</td><td>-7.6±1.6</td><td>4*</td><td>58.6±1.3</td><td>-1.2±1.5</td><td>4*</td></tr><tr><td>FINETUNE</td><td>47.5±1.5 -14.9±1.4</td><td></td><td>4*</td><td>31.4±3.7 -29.3±3.84*</td><td></td><td></td><td>39.7±5.0</td><td>-23.9±5.7</td><td>4*</td><td>45.4±4.0 -15.5±3.7</td><td></td><td>4*</td><td>29.1±3.1 - 29.2±3.2</td><td></td><td>4*</td></tr><tr><td>FINETUNE L</td><td>52.1±1.4 -15.7±1.7 24*</td><td></td><td></td><td>38.2±3.2</td><td>2-25.8±3.324*</td><td></td><td>49.3±2.0</td><td>-18.4±2.0</td><td>24*</td><td>49.3±2.1</td><td>-18.4±2.0</td><td>24*</td><td>37.1±2.1</td><td>-26.0±2.2</td><td>20*</td></tr></table>
+
+In the accumulation phase, new module addition is allowed again and all non-frozen modules are trained with both signals. The functional components of new modules still receive a signal from the structural components of modules above. The two-phase training is explained schematically in Figure 2 and implementation details are provided in Appendix A.
+
+# 4 Experiments
+
+We now evaluate the performance, empirical capabilities, and properties of LMC in four different CL settings. First, in $\ S 4 . 1$ we study a standard task-incremental CL setting (task-ID agnostic and aware) using the Continual Transfer Learning Benchmark (CTrL) [92]. Next, we explore the properties of LMC through other CL settings. In $\ S 4 . 2$ we evaluate the continual OOD generalization ability of the proposed LMC. In $\ S 4 . 3$ we show the ability of LMC to combine modules form independently trained models. In Appendix F, we evaluate LMC in the Continual Meta-Learning setting.
+
+# 4.1 Continual transfer learning using the CTrL benchmark
+
+The CTrL benchmark was proposed to systematically evaluate properties of CL methods with a focus on modular architectures [92]. It consists of 5 streams of visual image classification tasks. The first stream $S ^ { - } = ( t _ { 1 } ^ { + } , t _ { 2 } , t _ { 3 } , t _ { 4 } , t _ { 5 } , t _ { 1 } )$ consists of a sequence of 6 tasks, where the first and last task are the same except the first has an order of magnitude more training samples $( ^ { 6 6 + 7 9 } )$ than other tasks. This stream is designed to evaluate the direct transfer ability of models, i.e. a modular learner should be able to reuse the first task’s modules for the last task. The $S ^ { + } = ( t _ { 1 } , t _ { 2 } , t _ { 3 } , t _ { 4 } , t _ { 5 } , t _ { 1 } ^ { + } )$ stream is similar to $S ^ { - }$ , but now the last task comes with more data than the other tasks (including the first one). Here, the modular learner should be able to update its knowledge, i.e. performance on the first task should improve after learning the last task. In the $S ^ { i n } = ( t _ { 1 } , t _ { 2 } , t _ { 3 } , t _ { 4 } , t _ { 5 } , t _ { 1 } ^ { \prime } )$ stream the first $t _ { 1 }$ and the last $t _ { 1 } ^ { \prime }$ tasks are similar, with a slight input distribution change (e.g. different background color). In the $S ^ { o u t } = ( t _ { 1 } ^ { + } , t _ { 2 } , t _ { 3 } , t _ { 4 } , t _ { 5 } , t _ { 1 } ^ { \prime \prime } )$ stream the first task $t _ { 1 }$ and the last task $t _ { 1 } ^ { \prime \prime }$ differ in the amount of training data and the output distribution, i.e. the labels of the last task are randomly permuted. The plasticity stream $S ^ { p l } = \mathsf { \bar { ( } } t _ { 1 } , t _ { 2 } , t _ { 3 } , t _ { 4 } , t _ { 5 } )$ evaluates the ability to learn a stream of unrelated and potentially interfering tasks, i.e., transfer from unrelated tasks can harm performance. Descriptive statistics for all datasets are in Appendix B.1.
+
+We compare to several baselines. Finetune: trains a single model (wider model marked with L) for all tasks. Experts: trains a model per task. We also compare with the several recently proposed modular CL baselines, which achieve competitive results in CTrL and require task IDs at test time. MNTDP [92]: a recent search-based module selection approach described in more detail in $\ S 2$ . MNTDP requires the task ID to retrieve the previously found best structure for each test task. $\mathbf { M N T D P ( A ) }$ : a task ID agnostic version of MNTDP we created, which selects the path with the lowest entropy in the output distribution. SG-F [63]: Soft-gating with fixed modules, a modular method mentioned in $\ S 2$ . It relies on a task-specific structural network that generates soft-gating vectors for each layer of the modular learner and fixes learned modules when new tasks arrive. We slightly adapted the original expansion strategy of SG-F in order to conform to our experimental setup; details are in Appendix B.2. SG- $\mathbf { F } _ { \left( \mathbf { A } \right) }$ : a version of SG-F with a single structural network shared across tasks. HAT[87]: learns attention masks for activations that gate the gradients to prevent forgetting. The task ID is used to select a task-specific attention mask for inference.
+
+We also compare to several standard CL methods. EWC [46]: trains a single model for all tasks while applying parameter-regularization to minimize forgetting. O-EWC:[85] online version of EWC that does not require storing a separate approximation of the Fisher information matrix per task. ER [16]: trains a single model while replaying samples from previously seen tasks. The size of the replay buffer corresponds to the memory size of the LMC assuming the worse case linear growth pattern (i.e., LMC with 24 modules on a 6-task sequence). ER(A,S): task ID agnostic version of ER that uses a single output head to classify all classes from all tasks: i.e. after learning stream $S ^ { - }$ the output head has 50 output neurons and the output classes of the last task are considered the same as the ones of the first task.
+
+We use several versions of LMC. $\mathbf { L M C } _ { ( \lnot \mathbf { A } ) }$ a version of LMC that uses the task ID for output head selection (not module selection as MNTDP). LMC(A): the default version of LMC. It equips output heads with structural components and is therefore task ID agnostic at test time. LMC(A,H): a version of task ID agnostic LMC that performs hard module selection, i.e., taking the module with the highest relevance score per layer. All methods use the same architecture (described in Appendix A.4) together with the Adam [44] optimizer. HAT is the only method that uses SGD.
+
+Similar to Veniat et al. [92], we use the following evaluation metrics: $( \mathcal { A } )$ average accuracy on all seen tasks at the end of CL training; Forgetting $( \mathcal { F } )$ — difference between accuracy at the end of the training and accuracy after learning the task averaged across tasks [60]; Number of modules (M) at the end of the continual training procedure. Formal definitions of all metrics are in Appendix B.3.
+
+Table 1 reports performance using the CTrL benchmark. Overall, modular methods tend to outperform ER and the regularization based methods (HAT and EWC). Among the modular methods, soft-gating SG-F(A,F) with a single controller shared among all the tasks performed the worst. This baseline showcases the problem of forgetting in the global structural component (a.k.a. controller) of dynamic routing methods such as the one proposed by Mendez and Eaton [63]. A version of LMC performs the best on the $S ^ { - }$ , $S ^ { i n }$ and $S ^ { o u t }$ streams.
+
+Notably, $\mathrm { L M C } _ { ( \mathrm { A } ) }$ , which does not rely on task IDs at test time, outperformed all other task ID agnostic methods such as $\mathbf { M N T D P _ { ( A ) } }$ and ER(A,S) on all streams but $S ^ { + }$ , and always performed on par with task ID aware methods. On the $S ^ { o u t }$ stream low performance is expected for task-ID agnostic methods due to output distribution shift: i.e., at test time we notice that LMC correctly assigns samples from the last task $t _ { 1 } ^ { \prime \prime }$ to the first task’s $t _ { 1 } ^ { + }$ output head. However, the resulting classification accuracy is low because the labels of the last task are randomly permuted in this stream.
+
+The task ID agnostic $\mathrm { L M C } _ { ( \mathrm { A } ) }$ outperforms task ID aware LMC on the $S ^ { - }$ and $S ^ { + }$ streams. Here, LMC(A) selects modules (and the output head) which were predominantly trained on the task that provided more training data (e.g. $t _ { 1 } ^ { + }$ in $S ^ { - }$ stream), hence transferring knowledge between the first and the last tasks. In contrast, $\mathbf { L M C } _ { ( \neg \mathbf { A } ) }$ when tested on the last task $t _ { 1 }$ is forced to select the output head belonging to this task, which was trained on less data than the output head of $t _ { 1 } ^ { + }$ task, leading to lower accuracy. In addition, we observed that versions of LMC often exhibit high variance (e.g. see $S ^ { + }$ , $S ^ { o u t }$ and $S ^ { p l }$ streams). This may be caused by the larger amount of trainable parameters compared to other models and relatively small amount of training data. Finally, low performance of
+
+![](images/0ac0839a77314eef3f415108a944bbd40d71d498bce0e862bb483ebc1931b9d5.jpg)  
+Figure 3: Continual OOD-generalization: matrices show test accuracy on seen and unseen tasks (onand off-diagonal tasks respectively). In each sub-figure $\mathbf { X }$ -axis shows the MNIST class-combination used to build the task, y-axis gives the foreground-background colors. Only diagonal tasks are learned continually. While non-modular EWC (a) and modular MNTDP (b) can prevent forgetting, $\mathbf { L M C _ { ( \neg A ) } }$ (c) is able to generalize to OOD tasks as well. $\mathrm { L M C } _ { \left( \lnot \mathbf { A } \right) }$ without projection phase performs poorly as shown in (d).
+
+LMC(A,H) emphasizes the importance of soft modular attention for LMC. Additional results, including a transfer metric [92], are in Appendix B.4.
+
+# 4.2 Compositional OOD generalization
+
+This second study tests the ability of LMC to recombine modules for OOD generalization. We use a colored-MNIST dataset — a variation of the standard MNIST dataset of hand-written digits from 0 to 9 [43] in which digits are colorized. We design a simple sequence of tasks as follows. First, we define two high-level features: the foreground-background color combination (using the colors red, black, green, blue) and the class (0–9). Then, we create five non-overlapping tasks of two (digit) classes each: $\left\{ 0 - 1 , \quad \ldots , \quad 8 - 9 \right\}$ . At training time the model is continually trained using a sequence of these tasks, however, each task is only seen in one of five different foreground-background combinations {red-black, green-black, blue-black, black-red, black-green}. At test time we measure the generalization ability to seen and unseen combinations of classes and colors.
+
+In Figure 3 we present the accuracy matrices for different learners when tested on all 25 combinations of colors and classes after it has been trained only on the 5 tasks on the diagonal.
+
+We compare the performance of $\mathbf { L M C } _ { ( \neg \mathbf { A } ) }$ with EWC [46], MNTDP [92], and an ablated version of LMC without the projection phase. We observe that the OOD accuracy attained by LMC is significantly higher than EWC and MNTDP. Since the model trained with EWC is monolithic, the digit-background color combinations are entangled with the digits’ shape for each task, hindering OOD generalization. In contrast, modular approaches such as MNTDP and LMC learn a different module combination for each task. In contrast to MNTDP, LMC’s module selection does not rely on task identifiers and each module is selected in a local manner based on its compatibility with the current input. This allows LMC to interpolate between previously seen tasks being able to dynamically compose existing modules to adapt to tasks that have not been seen at training. Because MNTDP’s module selection relies on a database of task-specific structures found to be optimal for the corresponding task at training, this method must reuse the predefined module compositions based on task IDs. This forces MNTDP to use modules that were trained using a different color combination, and results in e.g. a $2 4 \%$ accuracy drop with respect to LMC on [0,1] when the foreground and background colors are inverted w.r.t. the seen combination.
+
+In Figure 3d we report results for LMC without applying the projection phase. The projection phase adapts the representation of newly introduced modules to match the distribution expected by the subsequent modules. As expected, we found that skipping it severely degrades performance. This result validates the usefulness of the projection phase to achieve an efficient local module selection. In Appendix E we plot the average module selection for all 25 test tasks, showing how modules are reused for the OOD tasks.
+
+![](images/02bf370265e6243b99d3e16eb7c0b1722e28c196e9ddfc5d32fc62f7c3c014e1.jpg)  
+Figure 5: Results on $S ^ { l o n g }$ and $S ^ { l o n g 3 0 }$ sequences for different hyperparameter values (we select only runs with reasonably good performance, i.e. $4 \%$ ), same plots plots for all conducted runs can be found in Appendix C).
+
+# 4.3 Combining modular learners
+
+In earlier sections we show cross-task reusability of modules, here we test the cross-model reusability. We motivate the practical importance of this kind of reusability with a federated learning example: a privacy preserving training might be required for LMC1 and LMC2, trained on the premises of customers 1 and 2, after which their modules can be combined in a single central entity — LMC3, located on premises of the cloud service provider. LMC3 is required to perform tasks seen by both independent LMCs but can not be finetuned as it has no access to the original training data distributions.
+
+![](images/13b03e1aec38cbde4911d46835b11fd8b31a69fd07dffdd977f563adc068d68c.jpg)  
+Figure 4: Performance of combining independently trained LMC1 and LMC2 into LMC3.
+
+In Figure 4 we test the ability of LMC to preserve and transfer knowledge in such setting. To this end, we design the following tasks: fMNIST $^ +$ and fMNIST-. Both are sampled from the fashion-MNIST dataset [98] but the latter comes with an order of magnitude less training data. cMNIST-r is a variant of the colored-MNIST dataset where the background of $9 5 \%$ of the training samples is colored in red and $5 \%$ in green. For the cMNIST-g dataset these proportions are inverted and $9 5 \%$ of the training samples is colored in green. The test set contains $50 \%$ of samples with green and $50 \%$ with red background. We trained LMC1 continually on MNIST, fMNIST $^ +$ , and cMNIST-r tasks. We trained LMC2 on fMNIST-, cMNIST- $\mathbf { g }$ , and SVHN. We then combined the modules of both LMCs layer-wise to obtain LMC3.
+
+We observed positive transfer for both cMNIST and fMNIST- tasks with LMC3. We found that LMC3 selects different modules originating from different LMCs conditioned on test samples with different background colors — LMC1’s modules were specialized on red background while LMC2’s on green (selected paths presented in Appendix D). Notably, cross-model reusability without fine-tuning is novel to LMC and can be attributed to the local nature of the structural component. Using a global structural component as in [63] would require tuning a separate structural component specifically for LMC3. In case of task-specific routing of proposed for MNTDP [92], additional search would be needed to discover task-specific paths through the consolidated LMC3 model. In both cases the access to the orinal training data distributions would be required and privacy would not be preserved.
+
+# 4.4 Longer task sequences
+
+Here we study the performance LMC on longer task sequences consisting of $3 0 - S ^ { l o n g 3 0 }$ , and $1 0 0 -$ $S ^ { l o n g }$ tasks. The $S ^ { \bar { l } o n g }$ sequence corresponds to the one proposed by Veniat et al. [92] as part of the CTrL benchmark. $S ^ { l o n g 3 0 }$ is a 30-tasks subset of $S ^ { l o n g }$ (see Appendix B.1 for details).
+
+We first report the average test accuracy $( \mathcal { A } )$ and the total number of modules (M) of the models selected through cross-validation. $S ^ { l o n j 3 0 }$ : MNTDP $\scriptstyle A = 6 4 . 5 8$ , $\scriptstyle \mathbf { M } = 6 4$ ; LMC(¬A): $\scriptstyle A = 6 2 . 4 4$ , ${ \bf M } { = } 5 0$ $S ^ { l o n g }$ : MNTDP $\scriptstyle A = 6 8 . 9 2$ , $\mathbf { M } { = } 1 4 2$ ; $\mathbf { L M C _ { ( \neg A ) } }$ : $\scriptstyle A = 6 3 . 8 8$ , $\mathbf { M } = 3 2$ . While the gap between the accuracy of LMC and MNTDP on $S ^ { l o n g 3 0 }$ is only $1 . 8 6 \%$ -points, in the case of $S ^ { l o n g }$ this gap grows to $6 . 5 8 \%$ - points. It is important to highlight that in contrast to LMC, MNTDP’s module selection is performed by a task ID aware oracle. We further analyze the trade-off between the number of modules and accuracy in Figure 5, where we plot the number of modules (M) against average test accuracy $( \mathcal { A } )$ for models that resulted from training with different hyperparameters. For both streams, we observe that LMC tends to spawn much fewer modules than MNTDP. However, MNTDP shines in the presence of large number of modules and achieves higher overall test accuracy on these streams. Interestingly, as can be clearly observed on the $S ^ { l o n g }$ stream, LMC reaches higher accuracy with smaller number of modules: e.g. ${ \sim } 6 4 \%$ with 32 modules, while adding modules leads to lower accuracy: e.g. ${ \sim } 6 1 \%$ with 98 modules. This result suggests that local task ID agnostic module selection becomes more challenging for LMC in presence of a large number of modules.
+
+# 5 Related work
+
+Modularity in neural networks is studied in the context of scalability [9], and more recently as a way to achieve compositionality and systematic generalization [6, 47, 15, 8, 27, 19] as well as for multi-task learning [65, 82]. From the causal point of view, a data generation process could be thought as a composition of independent causal modules [75]. Researchers model these kinds of systems using a set of independent modules, where each module is invariant to changes in the other modules induced by e.g. distribution shifts [84, 76]. This idea is crystallized by Parascandolo et al. [74], who propose a way to learn a set of causal independent mechanisms as mixture-of-experts. Building up on this ideas, others show evidence of compositional OOD generalization [61]. Recently, [66] argue for a more wholistic view on CL including OOD generalization as an important desiderata.
+
+Continual learning methods typically address the problem of forgetting through parameter regularization [46, 70, 99], replay [89, 78, 3, 73, 54, 12, 97, 39, 81, 13] or dynamic architectures (and MoEs) [83, 87, 52, 85, 53, 41]. Our work falls under the umbrella of the latter and shares its advantage of having the capacity to adapt to a large number of related tasks. Our focus is on improving modular CL approaches, which despite their advantages, have only recently been studied in the CL literature [63, 92]. The main difference with our work is that we use a local composition mechanism instead of a global one. We detail this difference in $\ S 2$ and also compare to these methods in $\ S 4 . 1$ .
+
+Continual-meta learning focuses on fast learning and remembering [25, 35, 33, 41], often emphasising the online performance on OOD tasks [14]. As argued by Jerfel et al. [41] modularity can be useful in this setting to minimize interference between tasks. They proposed a way to train a MoE model, with each expert focusing on a cluster of tasks leveraging Bayesian nonparametrics. LMC aims at decomposing knowledge into layer-wise composable modules further reducing modular granularity. Continual-meta learning is often confused with its counterpart meta-continual learning [40, 11, 93], in which algorithm are learning to continually learn.
+
+The rapid growth of continual learning has lead researchers to work on empirical studies [20, 58, 56], surveys [32, 42, 55, 66, 67] as well as CL-specific software [72, 22, 59].
+
+# 6 Conclusion
+
+We develop LMC, a method to learn and compose a series of modules on a continual stream of tasks fulfilling some of the basic desiderata of modular CL such as module specialization, avoidance of collapse, and sublinear growth. In LMC, structural information is learned and stored locally for each module. It is the locality of the structural component that enables generalization to related but unseen tasks, and that permits combining different LMCs without fine-tuning.
+
+Future work could focus on achieving more efficient sub-linear model growth through OOD generalization and reusability of modules. Additionally, while the benefits of modularity for CL are well understood, the implications of the CL regime on modularity and compositionality have not been studied extensively. It is possible that providing knowledge to the learner in incremental chunks results in the implicit supervision needed to better disentangle it into specialized and composable modules. Another promising direction is removing the need for task boundaries during training and developing more robust architectures for the local structural component (related discussions are in Appendix A.3, and limitations in Appendix G).
+
+References   
+[1] Rahaf Aljundi, Francesca Babiloni, Mohamed Elhoseiny, Marcus Rohrbach, and Tinne Tuytelaars. Memory aware synapses: Learning what (not) to forget. CoRR, abs/1711.09601, 2017.   
+[2] Rahaf Aljundi, Punarjay Chakravarty, and Tinne Tuytelaars. Expert gate: Lifelong learning with a network of experts. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pages 3366–3375, 2017.   
+[3] Rahaf Aljundi, Lucas Caccia, Eugene Belilovsky, Massimo Caccia, Min Lin, Laurent Charlin, and Tinne Tuytelaars. Online continual learning with maximal interfered retrieval. In Advances in Neural Information Processing Systems 32, pages 11849–11860. Curran Associates, Inc., 2019.   
+[4] Mohammed Amer and Tomás Maul. A review of modularization techniques in artificial neural networks. Artificial Intelligence Review, 52(1):527–561, 2019.   
+[5] Jacob Andreas, Marcus Rohrbach, Trevor Darrell, and Dan Klein. Learning to compose neural networks for question answering. arXiv preprint arXiv:1601.01705, 2016.   
+[6] Jacob Andreas, Marcus Rohrbach, Trevor Darrell, and Dan Klein. Neural module networks. In Proceedings of the IEEE conference on computer vision and pattern recognition, pages 39–48, 2016.   
+[7] Antreas Antoniou, Harrison Edwards, and Amos Storkey. How to train your maml. arXiv preprint arXiv:1810.09502, 2018.   
+[8] Dzmitry Bahdanau, Shikhar Murty, Michael Noukhovitch, Thien Huu Nguyen, Harm de Vries, and Aaron Courville. Systematic generalization: What is required and can it be learned? In International Conference on Learning Representations, 2018.   
+[9] Dana H Ballard. Modular learning in neural networks. In AAAI, pages 279–284, 1987.   
+[10] Jens Behrmann, Will Grathwohl, Ricky TQ Chen, David Duvenaud, and Jörn-Henrik Jacobsen. Invertible residual networks. In International Conference on Machine Learning, pages 573–582. PMLR, 2019.   
+[11] Lucas Caccia and Joelle Pineau. Special: Self-supervised pretraining for continual learning. arXiv preprint arXiv:2106.09065, 2021.   
+[12] Lucas Caccia, Eugene Belilovsky, Massimo Caccia, and Joelle Pineau. Online learned continual compression with stacked quantization module. ArXiv, abs/1911.08019, 2019.   
+[13] Lucas Caccia, Rahaf Aljundi, Tinne Tuytelaars, Joelle Pineau, and Eugene Belilovsky. Reducing representation drift in online continual learning. arXiv preprint arXiv:2104.05025, 2021.   
+[14] Massimo Caccia, Pau Rodriguez, Oleksiy Ostapenko, Fabrice Normandin, Min Lin, Lucas Caccia, Issam Laradji, Irina Rish, Alexande Lacoste, David Vazquez, et al. Online fast adaptation and knowledge accumulation: a new approach to continual learning. arXiv preprint arXiv:2003.05856, 2020.   
+[15] Michael Chang, Abhishek Gupta, Sergey Levine, and Thomas L Griffiths. Automatically composing representation transformations as a means for generalization. In International Conference on Learning Representations, 2018.   
+[16] Arslan Chaudhry, Marcus Rohrbach, Mohamed Elhoseiny, Thalaiyasingam Ajanthan, Puneet K Dokania, Philip HS Torr, and M Ranzato. Continual learning with tiny episodic memories. 2019.   
+[17] M. Cimpoi, S. Maji, I. Kokkinos, S. Mohamed, , and A. Vedaldi. Describing textures in the wild. In Proceedings of the IEEE Conf. on Computer Vision and Pattern Recognition (CVPR), 2014.   
+[18] Rodolfo Corona, Daniel Fried, Coline Devin, Dan Klein, and Trevor Darrell. Modularity improves out-of-domain instruction following. arXiv preprint arXiv:2010.12764, 2020.   
+[19] Róbert Csordás, Sjoerd van Steenkiste, and Jürgen Schmidhuber. Are neural nets modular? inspecting functional modularity through differentiable weight masks. In International Conference on Learning Representations, 2021. URL https://openreview.net/forum?id $= ^ { \prime }$ 7uVcpu-gMD.   
+[20] Matthias De Lange, Rahaf Aljundi, Marc Masana, Sarah Parisot, Xu Jia, Ales Leonardis, Gregory Slabaugh, and Tinne Tuytelaars. Continual learning: A comparative study on how to defy forgetting in classification tasks. arXiv preprint arXiv:1909.08383, 2019.   
+[21] Laurent Dinh, David Krueger, and Yoshua Bengio. Nice: Non-linear independent components estimation. arXiv preprint arXiv:1410.8516, 2014.   
+[22] Arthur Douillard and Timothée Lesort. Continuum: Simple management of complex continual learning scenarios. ArXiv, abs/2102.06253, 2021.   
+[23] Sebastian Farquhar and Yarin Gal. Towards robust evaluations of continual learning. arXiv preprint arXiv:1805.09733, 2018.   
+[24] Chelsea Finn, Pieter Abbeel, and Sergey Levine. Model-agnostic meta-learning for fast adaptation of deep networks. In International Conference on Machine Learning (ICML), 2017.   
+[25] Chelsea Finn, Aravind Rajeswaran, Sham Kakade, and Sergey Levine. Online meta-learning. In International Conference on Machine Learning, pages 1920–1930. PMLR, 2019.   
+[26] Robert M French. Pseudo-recurrent connectionist networks: An approach to the’sensitivitystability’dilemma. Connection Science, 9(4):353–380, 1997.   
+[27] Anirudh Goyal, Alex Lamb, Jordan Hoffmann, Shagun Sodhani, Sergey Levine, Yoshua Bengio, and Bernhard Schölkopf. Recurrent independent mechanisms. arXiv preprint arXiv:1909.10893, 2019.   
+[28] Anirudh Goyal, Aniket Didolkar, Alex Lamb, Kartikeya Badola, Nan Rosemary Ke, Nasim Rahaman, Jonathan Binas, Charles Blundell, Michael Mozer, and Yoshua Bengio. Coordination among neural modules through a shared global workspace. arXiv preprint arXiv:2103.01197, 2021.   
+[29] Erin Grant, Chelsea Finn, Sergey Levine, Trevor Darrell, and Thomas Griffiths. Recasting gradient-based meta-learning as hierarchical bayes. arXiv preprint arXiv:1801.08930, 2018.   
+[30] Ishaan Gulrajani and David Lopez-Paz. In search of lost domain generalization. arXiv preprint arXiv:2007.01434, 2020.   
+[31] Sharut Gupta, Praveer Singh, Ken Chang, Mehak Aggarwal, Nishanth Arun, Liangqiong Qu, Katharina Hoebel, Jay Patel, Mishka Gidwani, Ashwin Vaswani, et al. The unreasonable effectiveness of batch-norm statistics in addressing catastrophic forgetting across medical institutions. arXiv preprint arXiv:2011.08096, 2020.   
+[32] Raia Hadsell, Dushyant Rao, Andrei A Rusu, and Razvan Pascanu. Embracing change: Continual learning in deep neural networks. Trends in Cognitive Sciences, 2020.   
+[33] James Harrison, Apoorva Sharma, Chelsea Finn, and Marco Pavone. Continuous meta-learning without tasks. arXiv preprint arXiv:1912.08866, 2019.   
+[34] Xu He, Jakub Sygnowski, Alexandre Galashov, Andrei A. Rusu, Yee Whye Teh, and Razvan Pascanu. Task agnostic continual learning via meta learning. ArXiv, abs/1906.05201, 2019.   
+[35] Xu He, Jakub Sygnowski, Alexandre Galashov, Andrei A Rusu, Yee Whye Teh, and Razvan Pascanu. Task agnostic continual learning via meta learning. arXiv preprint arXiv:1906.05201, 2019.   
+[36] Dan Hendrycks, Mantas Mazeika, and Thomas Dietterich. Deep anomaly detection with outlier exposure. arXiv preprint arXiv:1812.04606, 2018.   
+[37] Guillaume Hocquet, Olivier Bichler, and Damien Querlioz. Ova-inn: Continual learning with invertible neural networks. arXiv preprint arXiv:2006.13772, 2020.   
+[38] Sergey Ioffe and Christian Szegedy. Batch normalization: Accelerating deep network training by reducing internal covariate shift. In International conference on machine learning, pages 448–456. PMLR, 2015.   
+[39] David Isele and Akansel Cosgun. Selective experience replay for lifelong learning. In AAAI conference on artificial intelligence, 2018.   
+[40] Khurram Javed and Martha White. Meta-learning representations for continual learning. In Advances in Neural Information Processing Systems 32, pages 1820– 1830. Curran Associates, Inc., 2019. URL http://papers.nips.cc/paper/ 8458-meta-learning-representations-for-continual-learning.pdf.   
+[41] Ghassen Jerfel, Erin Grant, Tom Griffiths, and Katherine A Heller. Reconciling meta-learning and continual learning with online mixtures of tasks. In Advances in Neural Information Processing Systems, pages 9122–9133, 2019.   
+[42] Khimya Khetarpal, Matthew Riemer, Irina Rish, and Doina Precup. Towards continual reinforcement learning: A review and perspectives, 2020.   
+[43] Byungju Kim, Hyunwoo Kim, Kyungsu Kim, Sungjin Kim, and Junmo Kim. Learning not to learn: Training deep neural networks with biased data. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, pages 9012–9020, 2019.   
+[44] Diederik P. Kingma and Jimmy Ba. Adam: A method for stochastic optimization. In Yoshua Bengio and Yann LeCun, editors, 3rd International Conference on Learning Representations, ICLR 2015, San Diego, CA, USA, May 7-9, 2015, Conference Track Proceedings, 2015. URL http://arxiv.org/ abs/1412.6980.   
+[45] Diederik P Kingma and Max Welling. Auto-encoding variational bayes. arXiv preprint arXiv:1312.6114, 2013.   
+[46] James Kirkpatrick, Razvan Pascanu, Neil Rabinowitz, Joel Veness, Guillaume Desjardins, Andrei A Rusu, Kieran Milan, John Quan, Tiago Ramalho, Agnieszka Grabska-Barwinska, et al. Overcoming catastrophic forgetting in neural networks. Proceedings of the national academy of sciences, 114(13):3521–3526, 2017.   
+[47] Louis Kirsch, Julius Kunze, and David Barber. Modular networks: Learning to decompose neural computation. Advances in Neural Information Processing Systems, 31:2408–2418, 2018.   
+[48] Ivan Kobyzev, Simon Prince, and Marcus Brubaker. Normalizing flows: An introduction and review of current methods. IEEE Transactions on Pattern Analysis and Machine Intelligence, 2020.   
+[49] Alex Krizhevsky, Geoffrey Hinton, et al. Learning multiple layers of features from tiny images. Technical report, Citeseer, 2009.   
+[50] Brenden M Lake, Ruslan Salakhutdinov, and Joshua B Tenenbaum. Human-level concept learning through probabilistic program induction. Science, 350(6266):1332–1338, 2015.   
+[51] Yann LeCun and Corinna Cortes. MNIST handwritten digit database. 2010. URL http://yann. lecun.com/exdb/mnist/.   
+[52] Jeongtae Lee, Jaehong Yoon, Eunho Yang, and Sung Ju Hwang. Lifelong learning with dynamically expandable networks. CoRR, abs/1708.01547, 2017.   
+[53] Soochan Lee, Junsoo Ha, Dongsu Zhang, and Gunhee Kim. A neural dirichlet process mixture model for task-free continual learning. arXiv preprint arXiv:2001.00689, 2020.   
+[54] Timothée Lesort, Hugo Caselles-Dupré, Michael Garcia-Ortiz, Jean-François Goudou, and David Filliat. Generative Models from the perspective of Continual Learning. In International Joint Conference on Neural Networks (IJCNN), 2019.   
+[55] Timothée Lesort, Massimo Caccia, and Irina Rish. Understanding continual learning settings with data distribution drift analysis, 2021.   
+[56] Timothée Lesort, Thomas George, and Irina Rish. Continual learning in deep networks: an analysis of the last layer, 2021.   
+[57] Zhizhong Li and Derek Hoiem. Learning without forgetting. IEEE transactions on pattern analysis and machine intelligence, 40(12):2935–2947, 2017.   
+[58] Vincenzo Lomonaco, Lorenzo Pellegrini, Pau Rodríguez, Massimo Caccia, Qi She, Yu Chen, Quentin Jodelet, Ruiping Wang, Zheda Mai, David Vázquez, German Ignacio Parisi, Nikhil Churamani, Marc Pickett, Issam H. Laradji, and Davide Maltoni. Cvpr 2020 continual learning in computer vision competition: Approaches, results, current challenges and future directions. ArXiv, abs/2009.09929, 2020.   
+[59] Vincenzo Lomonaco, Lorenzo Pellegrini, Andrea Cossu, Antonio Carta, Gabriele Graffieti, Tyler L. Hayes, Matthias De Lange, Marc Masana, Jary Pomponi, Gido van de Ven, Martin Mundt, Qi She, Keiland Cooper, Jeremy Forest, Eden Belouadah, Simone Calderara, German I. Parisi, Fabio Cuzzolin, Andreas Tolias, Simone Scardapane, Luca Antiga, Subutai Amhad, Adrian Popescu, Christopher Kanan, Joost van de Weijer, Tinne Tuytelaars, Davide Bacciu, and Davide Maltoni. Avalanche: an end-to-end library for continual learning. In Proceedings of IEEE Conference on Computer Vision and Pattern Recognition, 2nd Continual Learning in Computer Vision Workshop, 2021.   
+[60] David Lopez-Paz and Marc’Aurelio Ranzato. Gradient episodic memory for continual learning. In Advances in Neural Information Processing Systems, pages 6467–6476, 2017.   
+[61] Kanika Madan, Nan Rosemary Ke, Anirudh Goyal, Bernhard Schölkopf, and Yoshua Bengio. Fast and slow learning of recurrent independent mechanisms. In International Conference on Learning Representations, 2021. URL https://openreview.net/forum?id=Lc28QAB4ypz.   
+[62] Michael McCloskey and Neal J Cohen. Catastrophic interference in connectionist networks: The sequential learning problem. In Psychology of learning and motivation, volume 24, pages 109–165. Elsevier, 1989.   
+[63] Jorge A Mendez and Eric Eaton. Lifelong learning of compositional structures. arXiv preprint arXiv:2007.07732, 2020.   
+[64] Martial Mermillod, Aurélia Bugaiska, and Patrick Bonin. The stability-plasticity dilemma: Investigating the continuum from catastrophic forgetting to age-limited learning effects. Frontiers in psychology, 4:504, 2013.   
+[65] Elliot Meyerson and Risto Miikkulainen. Beyond shared hierarchies: Deep multitask learning through soft layer ordering. arXiv preprint arXiv:1711.00108, 2017.   
+[66] Martin Mundt, Yong Won Hong, Iuliia Pliushch, and Visvanathan Ramesh. A wholistic view of continual learning with deep neural networks: Forgotten lessons and the bridge to active and open world learning, 2020.   
+[67] Martin Mundt, Steven Lang, Quentin Delfosse, and Kristian Kersting. Cleva-compass: A continual learning evaluation assessment compass to promote research transparency and comparability, 2021.   
+[68] Eric Nalisnick, Akihiro Matsukawa, Yee Whye Teh, Dilan Gorur, and Balaji Lakshminarayanan. Do deep generative models know what they don’t know? arXiv preprint arXiv:1810.09136, 2018.   
+[69] Yuval Netzer, Tao Wang, Adam Coates, Alessandro Bissacco, Bo Wu, and Andrew Y Ng. Reading digits in natural images with unsupervised feature learning. 2011.   
+[70] Cuong V. Nguyen, Yingzhen Li, Thang D. Bui, and Richard E. Turner. Variational continual learning. In International Conference on Learning Representations (ICLR), 2018.   
+[71] Alex Nichol, Joshua Achiam, and John Schulman. On first-order meta-learning algorithms. arXiv preprint arXiv:1803.02999, 2018.   
+[72] Fabrice Normandin, Florian Golemo, Oleksiy Ostapenko, Pau Rodriguez, Matthew D Riemer, Julio Hurtado, Khimya Khetarpal, Dominic Zhao, Ryan Lindeborg, Timothée Lesort, Laurent Charlin, Irina Rish, and Massimo Caccia. Sequoia: A software framework to unify continual learning research, 2021.   
+[73] Oleksiy Ostapenko, Mihai Puscas, Tassilo Klein, Patrick Jahnichen, and Moin Nabi. Learning to remember: A synaptic plasticity driven framework for continual learning. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, pages 11321–11329, 2019.   
+[74] Giambattista Parascandolo, Niki Kilbertus, Mateo Rojas-Carulla, and Bernhard Schölkopf. Learning independent causal mechanisms. In International Conference on Machine Learning, pages 4036–4044. PMLR, 2018.   
+[75] Judea Pearl. Causality. Cambridge university press, 2009.   
+[76] Jonas Peters, Dominik Janzing, and Bernhard Schölkopf. Elements of causal inference: foundations and learning algorithms. The MIT Press, 2017.   
+[77] Mohammad Pezeshki, Sékou-Oumar Kaba, Yoshua Bengio, Aaron Courville, Doina Precup, and Guillaume Lajoie. Gradient starvation: A learning proclivity in neural networks. arXiv preprint arXiv:2011.09468, 2020.   
+[78] Sylvestre-Alvise Rebuffi, Alexander Kolesnikov, Georg Sperl, and Christoph H Lampert. icarl: Incremental classifier and representation learning. In Computer Vision and Pattern Recognition (CVPR), 2017.   
+[79] Mengye Ren, Eleni Triantafillou, Sachin Ravi, Jake Snell, Kevin Swersky, Joshua B Tenenbaum, Hugo Larochelle, and Richard S Zemel. Meta-learning for semi-supervised few-shot classification. arXiv preprint arXiv:1803.00676, 2018.   
+[80] Danilo Rezende and Shakir Mohamed. Variational inference with normalizing flows. In International conference on machine learning, pages 1530–1538. PMLR, 2015.   
+[81] David Rolnick, Arun Ahuja, Jonathan Schwarz, Timothy Lillicrap, and Gregory Wayne. Experience replay for continual learning. In Advances in Neural Information Processing Systems, 2019.   
+[82] Clemens Rosenbaum, Ignacio Cases, Matthew Riemer, and Tim Klinger. Routing networks and the challenges of modular and compositional computation. arXiv preprint arXiv:1904.12774, 2019.   
+[83] Andrei A Rusu, Neil C Rabinowitz, Guillaume Desjardins, Hubert Soyer, James Kirkpatrick, Koray Kavukcuoglu, Razvan Pascanu, and Raia Hadsell. Progressive neural networks. arXiv preprint arXiv:1606.04671, 2016.   
+[84] B Schölkopf, D Janzing, J Peters, E Sgouritsa, K Zhang, and J Mooij. On causal and anticausal learning. In 29th International Conference on Machine Learning (ICML 2012), pages 1255–1262. International Machine Learning Society, 2012.   
+[85] Jonathan Schwarz, Jelena Luketina, Wojciech M Czarnecki, Agnieszka Grabska-Barwinska, Yee Whye Teh, Razvan Pascanu, and Raia Hadsell. Progress & compress: A scalable framework for continual learning. arXiv preprint arXiv:1805.06370, 2018.   
+[86] Joan Serra, Didac Suris, Marius Miron, and Alexandros Karatzoglou. Overcoming catastrophic forgetting with hard attention to the task. International Conference on Machine Learning (ICML), 2018.   
+[87] Joan Serra, Didac Suris, Marius Miron, and Alexandros Karatzoglou. Overcoming catastrophic forgetting with hard attention to the task. In International Conference on Machine Learning, pages 4548–4557. PMLR, 2018.   
+[88] Noam Shazeer, Azalia Mirhoseini, Krzysztof Maziarz, Andy Davis, Quoc Le, Geoffrey Hinton, and Jeff Dean. Outrageously large neural networks: The sparsely-gated mixture-of-experts layer, 2017.   
+[89] Andrea Soltoggio. Short-term plasticity as cause–effect hypothesis testing in distal reward learning. Biological cybernetics, 109(1):75–94, 2015.   
+[90] Olaf Sporns and Richard F Betzel. Modular brain networks. Annual review of psychology, 67:613–640, 2016.   
+[91] Saul Sternberg. Modular processes in mind and brain. Cognitive neuropsychology, 28(3-4):156–208, 2011.   
+[92] Tom Veniat, Ludovic Denoyer, and Marc’Aurelio Ranzato. Efficient continual learning with modular networks and task-driven priors. arXiv preprint arXiv:2012.12631, 2020.   
+[93] Johannes von Oswald, Dominic Zhao, Seijin Kobayashi, Simon Schug, Massimo Caccia, Nicolas Zucchet, and João Sacramento. Learning where to learn: Gradient sparsity in meta and continual learning. NeurIPS 2021, 2021.   
+[94] Yaqing Wang, Quanming Yao, James T Kwok, and Lionel M Ni. Generalizing from a few examples: A survey on few-shot learning. ACM Computing Surveys (CSUR), 53(3):1��34, 2020.   
+[95] Ziyu Wang, Bin Dai, David Wipf, and Jun Zhu. Further analysis of outlier detection with deep generative models. arXiv preprint arXiv:2010.13064, 2020.   
+[96] James CR Whittington and Rafal Bogacz. An approximation of the error backpropagation algorithm in a predictive coding network with local hebbian synaptic plasticity. Neural computation, 29(5):1229–1262, 2017.   
+[97] Chenshen Wu, Luis Herranz, Xialei Liu, Joost van de Weijer, Bogdan Raducanu, et al. Memory replay gans: Learning to generate new categories without forgetting. Advances in Neural Information Processing Systems, 31:5962–5972, 2018.   
+[98] Han Xiao, Kashif Rasul, and Roland Vollgraf. Fashion-mnist: a novel image dataset for benchmarking machine learning algorithms. arXiv preprint arXiv:1708.07747, 2017.   
+[99] Chen Zeno, Itay Golan, Elad Hoffer, and Daniel Soudry. Task agnostic continual learning using online variational bayes, 2018.
+
+# Acknowledgments and Disclosure of Funding
+
+Laurent Charlin holds a CIFAR AI Chair Program and acknowledges support from Samsung Electronics Co., Ldt., Google, and NSERC. Massimo Caccia was supported through MITACS during his part time employment with Element AI the ServiceNow company. Massimo Caccia was also supported by Amazon, during his part time employment there. We would like to thank Mila and Compute Canada for providing computational resources. We also would like to thank Irina Rish for useful discussions.

parse/train/LJjC6DmSkgT/LJjC6DmSkgT_content_list.json

@@ -0,0 +1,1134 @@
+[
+    {
+        "type": "text",
+        "text": "Continual Learning via Local Module Composition ",
+        "text_level": 1,
+        "bbox": [
+            186,
+            122,
+            808,
+            148
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Oleksiy Ostapenko12 Pau Rodríguez3 Massimo Caccia123 Laurent Charlin145 1Mila - Quebec AI Institute, 2Université de Montréal, 3ServiceNow, 4HEC Montréal, 5Canada CIFAR AI Chair ",
+        "bbox": [
+            205,
+            199,
+            792,
+            243
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Abstract ",
+        "text_level": 1,
+        "bbox": [
+            462,
+            280,
+            535,
+            296
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Modularity is a compelling solution to continual learning (CL), the problem of modeling sequences of related tasks. Learning and then composing modules to solve different tasks provides an abstraction to address the principal challenges of CL including catastrophic forgetting, backward and forward transfer across tasks, and sub-linear model growth. We introduce local module composition (LMC), an approach to modular CL where each module is provided a local structural component that estimates a module’s relevance to the input. Dynamic module composition is performed layer-wise based on local relevance scores. We demonstrate that agnosticity to task identities (IDs) arises from (local) structural learning that is module-specific as opposed to the task- and/or model-specific as in previous works, making LMC applicable to more CL settings compared to previous works. In addition, LMC also tracks statistics about the input distribution and adds new modules when outlier samples are detected. In the first set of experiments, LMC performs favorably compared to existing methods on the recent Continual Transfer-learning Benchmark without requiring task identities. In another study, we show that the locality of structural learning allows LMC to interpolate to related but unseen tasks (OOD), as well as to compose modular networks trained independently on different task sequences into a third modular network without any fine-tuning. Finally, in search for limitations of LMC we study it on more challenging sequences of 30 and 100 tasks, demonstrating that local module selection becomes much more challenging in presence of a large number of candidate modules. In this setting best performing LMC spawns much fewer modules compared to an oracle based baseline, however it reaches a lower overall accuracy. The codebase is available under https://github.com/oleksost/LMC. ",
+        "bbox": [
+            232,
+            309,
+            766,
+            640
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 Introduction ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            664,
+            310,
+            681
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "The goal of continual learning (CL) is to learn efficiently from a non-stationary stream of tasks without (catastrophically) forgetting previous tasks [62]. CL is often modeled as a trade-off between knowledge retention (stability) and knowledge expansion (plasticity) [26, 64]. Parameter sharing can provide control over this trade-off. For example, learning a single model shared across tasks results in better knowledge transfer and faster learning at the expense of forgetting [46, 57]. Conversely, learning a separate model per task eliminates forgetting but minimizes transfer and data efficiency [2, 41]. ",
+        "bbox": [
+            174,
+            694,
+            825,
+            779
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Modular learning aims at balancing transfer and forgetting by learning a set of specialized modules that can be recomposed to solve (new) tasks while only updating a subset of relevant modules or adding new modules [6, 47, 27]. In principle, a modular learner capable of composing modules in meaningful structures can provide additional benefits including (i) computational gains due to only executing modules that are relevant to a task [47, 4]; (ii) memory gains due to instantiating a sub-linear number of modules w.r.t. the number of tasks; (iii) systematic [8] and out-of-distribution (OOD) generalization [18] through knowledge recombination; and (iv) biological plausibility [91, 90, 96]. ",
+        "bbox": [
+            174,
+            785,
+            825,
+            882
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Designing modular methods for CL comes with two main challenges. The first is how and when to add new modules to ensure sufficient plasticity to learn new tasks. Existing modular methods use greedy search variants, expanding the model when it improves validation performance [92, 63]. The second challenge is how to compose that is, retrieve task-specific structural knowledge given a new task (previously seen or not). ",
+        "bbox": [
+            174,
+            90,
+            825,
+            161
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Existing methods rely on a task’s identifier (ID) to retrieve task-specific structural knowledge, which comes either in the form of an optimal module layout [92] or as a model- and task-specific controller network that generates modular layouts [63]. Unfortunately, in many realistic CL scenarios task identities are unavailable at test time [23, 35, 14]. Lifting this limitation is challenging since standard mechanisms for task inference, for example, leveraging a task-inference model, could be subject to forgetting themselves. ",
+        "bbox": [
+            174,
+            166,
+            825,
+            251
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "To address both challenges, we equip each module with a local structural component that predicts a score indicating how relevant the module is for a given input. In-distribution inputs result in high scores, while out-of-distribution inputs result in low scores. In other words, modules self-determine their relevance given an input. ",
+        "bbox": [
+            174,
+            256,
+            825,
+            313
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "This local component is used for composing modules: for each datum, modules are combined at each layer according to their normalized scores without requiring a task’s ID (§3). The local component is also used for module expansion: a new module is instantiated if all the current modules flag their input as being locally out-of-distribution (§3.1). Further, new shallow modules (i.e. closer to the input) are first trained in a projection phase to maximize the relatedness scores of subsequent, deeper, modules (§3.2). This process projects the output of new modules into the representation space expected by the subsequent modules and ensures the compatibility between low- and high-level modules. ",
+        "bbox": [
+            174,
+            319,
+            825,
+            416
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "In a set of studies, we explore the performance and versatility of our local structural approach, which we call Local Module Composer (LMC). First, we show that LMC reaches superior or comparable performance to existing modular and non-modular methods without requiring task IDs at test time using the Continual Transfer Learning (CTrL) benchmark, designed to evaluate transfer and forgetting in CL [92] (§4.1). Then, we demonstrate how LMC, relying on its projection phase, can solve out-ofdistribution (OOD) tasks not seen during the continual training (§4.2). We also show it is possible to combine modules from independently trained models into a new model to solve tasks seen by each of the independent models without any finetuning (§4.3). Finally, an analysis of longer task sequences (30 and 100 tasks) reveals that LMC tends to spawn much fewer modules to reach good performance than the fully task-aware MNTDP [92] counterpart. However, LMC reaches slightly lower accuracy on longer sequences than MNTDP, which highlights the difficulty of automatic task-ID agnostic module selection in the presence of a large number of candidate modules. In Appendix F we demonstrate the applicability of LMC in the meta-continual learning (meta-CL) setting, a task-agnostic setting by nature. ",
+        "bbox": [
+            174,
+            421,
+            825,
+            616
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "We highlight that by relying on a local (per-module) structural component, LMC offers a modular CL approach that i) does not require task IDs during test in the standard task incremental settings; ii) balances parameter sharing to yield strong CL performances compared to baselines that require access to the task ID; iii) in our experiments instantiates a sub-linear number of modules; iv) permits recombination of modules at test time enabling OOD generalization as well as (v) the ability to combine independently trained models in a third model without fine-tuning. Notably, the OOD generalization is only possible if the agent is task-agnostic in the module selection process, since OOD tasks were not observed at training, the learner has to interpolate between the learned tasks, and a (categorial) task ID is of no use. ",
+        "bbox": [
+            173,
+            621,
+            825,
+            746
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2 Background: Modular Continual Learning ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            768,
+            565,
+            787
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Let $\\mathcal { F } ( x ; \\theta ) : \\mathcal { X }  \\mathcal { Y }$ be a learner parametrized with a set of parameters $\\theta$ . In task-incremental CL, the learner is exposed to a sequence of tasks. Each task is composed of a training set $D _ { t }$ of $( x , y )$ pairs and a task identifier (ID) $t$ [92, 46]. The goal is to learn an optimal $\\theta ^ { * }$ that minimizes the loss $\\mathcal { L }$ for all observed tasks: ",
+        "bbox": [
+            174,
+            803,
+            825,
+            858
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "equation",
+        "img_path": "images/17e4a056bfa4a79f052b0fa9a2bda2d98a0218cf22b906687e416b47a2b6930a.jpg",
+        "text": "$$\n\\theta ^ { * } = \\underset { \\theta } { \\arg \\operatorname* { m i n } } \\sum _ { t = 1 } ^ { T } \\mathbb { E } _ { ( x , y ) \\sim D _ { t } } [ \\mathcal { L } ( \\mathcal { F } ( x ; \\theta ) , y ) ] .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            352,
+            866,
+            645,
+            909
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "image",
+        "img_path": "images/79e5610f1b14f8153e55f838afeb9202b2b770be5adfa97cac2fc32f449df0f7.jpg",
+        "image_caption": [
+            "Figure 1: Modular Layer Scheme. Each black rectangle is a module. Inside each module, the functional component receives the input $x ^ { ( l - 1 ) }$ and feeds its output to the structural component . m The output of the structural component is used to calculate the importance score $\\gamma _ { m } ^ { ( l ) }$ using Eq. 5, which are normalized to obtain the attention vector . The layer output is the weighted sum of the functional outputs of each module. $\\mu$ and $\\sigma$ are the running mean and variance of the scores $\\gamma _ { m } ^ { ( l ) }$ used to detect outlier inputs and to trigger module addition. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            228,
+            87,
+            771,
+            238
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "The parameter sharing trade-off between tasks can be addressed through different architectural design choices for $\\mathcal { F }$ . For example, $\\mathcal { F }$ can be a monolithic network that shares parameters $\\theta$ across all tasks. Most existing task incremental CL methods use a task-specific output head, requiring the task ID to select the output head corresponding to the task at hand [46, 87, 1]. ",
+        "bbox": [
+            174,
+            359,
+            826,
+            417
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "At the other end of the spectrum are the expert based solutions that learn an independent model, a.k.a.   \nexpert, for each task [2, 83]. In this case, each expert trains task-specific parameters $\\boldsymbol { \\theta } = \\{ \\boldsymbol { \\theta } ^ { ( t ) } \\} _ { t = 1 } ^ { T }$ . ",
+        "bbox": [
+            173,
+            422,
+            823,
+            453
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "To balance parameter sharing and transfer, modular methods organize their parameters in a series of modules $M = \\{ m _ { k } ^ { ( l ) } \\}$ with parameters $\\boldsymbol { \\theta } = \\{ \\boldsymbol { \\theta } _ { k } ^ { ( l ) } \\}$ , where $\\theta _ { k } ^ { ( l ) }$ denotes the parameters of module at layer in $\\mathcal { F }$ . In general, a module can be any parametric function. In our experiments, unless otherwise stated, a module consists of a single convolutional layer followed by batch-norm, ReLU activation, and a max-pooling operation. ",
+        "bbox": [
+            174,
+            458,
+            825,
+            532
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Modules can be composed conditioned on a sample, a batch of samples, or a task. Let $\\psi$ denote a specific composition of modules that gives rise to a distinct prediction function; we make this dependence explicit: $\\mathcal { F } ( x ; \\theta , \\psi )$ . Importantly, sharing modules across tasks should lead to desirable transfer properties. ",
+        "bbox": [
+            174,
+            537,
+            825,
+            594
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Veniat et al. [92] frames modular CL as finding an optimal layout $\\psi ^ { ( t ) }$ for each task, where each layout selects a single module per layer per task (hard selection): ",
+        "bbox": [
+            174,
+            601,
+            821,
+            630
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/33a49ca74a1f9f86d0a220ac3ac14cbacf032abb693e719e68854815f2c8c6a9.jpg",
+        "text": "$$\n\\theta ^ { * } , \\Psi ^ { * } = \\underset { \\theta , \\Psi } { \\arg \\operatorname* { m i n } } \\sum _ { t = 1 } ^ { T } \\mathbb { E } _ { ( x , y ) \\sim D _ { t } } [ \\mathcal { L } ( \\mathcal { F } ( x ; \\theta , \\psi ^ { ( t ) } ) , y ) ] .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            321,
+            633,
+            676,
+            676
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "In this case the set of layouts $\\Psi = \\{ \\psi ^ { ( t ) } \\}$ grows with the number of tasks, while modules can be reused across different task-specific layouts resulting in sub-linear growth pattern. They design a method called MNTDP to search the exponentially large space of modular layouts by only considering layouts resulting from adding a new module per layer to the best prior path (past task’s path with the highest nearest neighbor accuracy on a new task) starting at the top layer. This solution relies on task IDs to retrieve $\\psi ^ { ( t ) }$ at test time. ",
+        "bbox": [
+            173,
+            680,
+            825,
+            767
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Another way of composing modules uses dynamic routing [63, 82, 47, 65]. The module layout is generated by a structural function $\\psi = s ( x )$ , hence different inputs take different routes through $\\mathcal { F }$ . It is standard to approximate the structural function using a neural network $\\psi = s ( x ; \\phi )$ with structural parameters $\\phi$ . This framework has been applied to CL in [63] by learning a separate structural function per task $\\psi ^ { ( t ) } = s ( x ; \\phi ^ { ( t ) } )$ . The task IDs are used to retrieve the correct structural function: ",
+        "bbox": [
+            173,
+            772,
+            825,
+            844
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/8867454a7883ef58e59dde60ff69c591f6b66f78c2f2ac5b4e2b6f4612a905dc.jpg",
+        "text": "$$\n\\theta ^ { * } , \\Phi ^ { * } = \\underset { \\theta , \\Phi } { \\arg \\operatorname* { m i n } } \\sum _ { t = 1 } ^ { T } \\mathbb { E } _ { ( x , y ) \\sim D _ { t } } [ \\mathcal { L } ( \\mathcal { F } ( x ; \\theta , s ( x ; \\phi ^ { ( t ) } ) ) , y ) ] ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            303,
+            848,
+            692,
+            891
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "where $\\Phi = \\{ \\phi ^ { ( t ) } \\}$ is the set of structural parameters for all tasks. ",
+        "bbox": [
+            173,
+            896,
+            598,
+            912
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "image",
+        "img_path": "images/637696b9b75108d43c64f5d8d33137e3bcbb1fc4d129dee043a64ee8e9ade9f4.jpg",
+        "image_caption": [
+            "Figure 2: Two-phase training. Each module contains a functional (rectangle) and structural (trapezoid) component. Their color intensity denotes the strength of their activation. Components with dashed contours are trained, solid contours represent fixed components, arrows show the gradient flow: black arrow — functional signal, pink — structural signal. (A) All modules are trained on task 0. (B) Task 1 arrives, a new module is added at layer 1, which is first trained to project its output into the representation of the modules above via the structural signal (the functional signal is optional). No module addition is allowed during the projection phase. (C) Module addition is allowed again, both signals are used for training. (D) As task 3 arrives, a new module is added at layer 1 again, projection phase is triggered. (E) A new module is added at the layer 2, both new modules are now trained in the second projection phase. (F) Both new modules are trained using both signals. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            179,
+            87,
+            823,
+            185
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "The above methods require task IDs at both training and testing time. Next we introduce our modular CL approach that only relies on task IDs during training. ",
+        "bbox": [
+            174,
+            358,
+            823,
+            387
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3 Local Module Composer (LMC) ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            405,
+            475,
+            424
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "We propose LMC, a modular approach where each module consists of a functional component $f ( x ; \\theta _ { m } ^ { ( \\bar { l } ) } )$ and a structural component $s ( x ; \\phi _ { m } ^ { ( l ) } )$ , see Figure 1. The functional components are responsible for learning to solve the prediction task and are trained via the usual task loss $\\mathcal { L }$ (e.g. cross-entropy loss for classification). The structural components receive the corresponding functional output as their input (see Figure 1) and are responsible for dynamic routing through $\\mathcal { F }$ . Structural parameters $\\phi$ are trained using a structural loss $\\bar { \\mathcal { L } } ^ { ( s t . ) }$ computed locally at each module. ",
+        "bbox": [
+            173,
+            436,
+            825,
+            525
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Intuitively, the structural component of a module should serve as a density estimator of the outputs of the functional component. The module’s contribution to the layer’s output is proportional to the likelihood of the input sample under the estimated density. In our instantiation, the structural component produces a relatedness score: a lower score for inputs that are more likely to belong to the distribution on which a given module was trained, and a higher score for inputs that are out-of-distribution for the given module. Hence, the likelihood of the input sample is approximated by the negative relatedness score. ",
+        "bbox": [
+            173,
+            531,
+            825,
+            628
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Given an input data sample $x ^ { ( 0 ) } = x$ , the output $x ^ { ( l ) }$ of a layer $l$ is defined as the weighted sum of the functional outputs of all $| M ^ { ( l ) } |$ local modules and used as input to the subsequent layer $l + 1$ : ",
+        "bbox": [
+            174,
+            633,
+            823,
+            666
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/15e7c403758902bb5ea5868ea8692568be4f804673d45808fabf30d3b81f2ef4.jpg",
+        "text": "$$\n\\boldsymbol { x } ^ { ( l ) } = \\sum _ { m = 1 } ^ { | M ^ { ( l ) } | } w _ { m } ^ { ( l ) } \\cdot f ( \\boldsymbol { x } ^ { ( l - 1 ) } ; \\boldsymbol { \\theta } _ { m } ^ { ( l ) } ) .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            385,
+            670,
+            612,
+            717
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "The functional output of the network is equal to the output of the final layer: $\\mathcal { F } ( x ; \\theta , \\phi ) = x ^ { ( L ) }$ . In the last layer $\\mathcal { F }$ implements a single output-head per task. At training time, the task ID is available and we update only the output-head corresponding to the currently learned task. At test time, the task ID is not available and we select the output head with the highest activation weight $w _ { m } ^ { ( L ) }$ , i.e., the last layer performs hard module selection. ",
+        "bbox": [
+            173,
+            728,
+            825,
+            803
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "The module activation weights $w _ { m } ^ { ( l ) }$ are computed by normalizing the vector of local relatedness scores $\\gamma ^ { ( l ) } \\in \\mathbb { R } ^ { | M ^ { ( l ) } | }$ . Each element of $\\gamma ^ { ( l ) }$ is obtained from the negative structural loss which approximates the likelihood of each module: ",
+        "bbox": [
+            174,
+            809,
+            825,
+            858
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/c54db01831735e8c0e806f91a31128c9c5a56951978e8b26f9c6c8a513e8e144.jpg",
+        "text": "$$\n\\begin{array} { r l } & { \\gamma _ { m } ^ { ( l ) } = - \\mathcal { L } ^ { ( s t . ) } \\Bigl ( s \\bigl [ f ( x ^ { ( l - 1 ) } ; \\theta _ { m } ^ { ( l ) } ) ; \\phi _ { m } ^ { ( l ) } \\bigr ] \\Bigr ) , } \\\\ & { w _ { m } ^ { ( l ) } = \\mathrm { s o f t m a x } ( \\gamma ^ { ( l ) } ) _ { m } . } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            362,
+            861,
+            635,
+            911
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Modules with lower structural loss get higher activation weights. Note that in practice, it can be useful to bias the module selection towards the expected module selection in a batch, assuming that samples within a batch are likely to belong to the same task. We discuss this point further in $\\ S \\operatorname { A . 1 }$ . ",
+        "bbox": [
+            174,
+            90,
+            823,
+            133
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Instead of using the softmax function, it is possible perform hard selection taking the module with the highest score [82], or alternatively selecting top-k modules [88]. In both cases, LMC’s structural parameters stay differentiable due to the local nature of structural learning. Note that in the case of global structural objective, hard module selection would require applying tools for non-differentiable learning such as Expectation Maximization [47] or reinforcement-learning based methods [82, 5]. ",
+        "bbox": [
+            174,
+            138,
+            825,
+            210
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "The overall LMC objective consists of optimizing both functional and structural losses: ",
+        "bbox": [
+            173,
+            215,
+            745,
+            231
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/cee7ef3efed08b2b5b6c43a2e93b94d054c7453ba4a529fb6d49724686ed0844.jpg",
+        "text": "$$\n\\theta ^ { * } , \\phi ^ { * } = \\underset { \\theta , \\phi } { \\operatorname { a r g m i n } } \\sum _ { t = 1 } ^ { T } \\mathbb { E } _ { ( x , y ) \\sim D _ { t } } \\Big [ \\mathcal { L } \\big ( \\mathcal { F } ( x ; \\theta , \\phi ) , y \\big ) + \\sum _ { l = 0 } ^ { L } \\sum _ { m = 0 } ^ { | M ^ { ( l ) } | } \\mathcal { L } _ { m } ^ { ( s t . ) } \\big ( s [ f ( x ^ { ( l - 1 ) } ; \\theta _ { m } ^ { ( l ) } ) ; \\phi _ { m } ^ { ( l ) } ] \\big ) \\Big ] .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            187,
+            236,
+            810,
+            284
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "As in [92], learning is performed w.r.t. only newly introduced modules to prevent forgetting. ",
+        "bbox": [
+            171,
+            309,
+            777,
+            325
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Structural component. We test two instantiations of the structural component $s$ and loss $\\mathcal { L } _ { m } ^ { ( s t . ) }$ . In the first one, $s$ is an invertible neural network [80]. Here we use the invertible architecture proposed by Dinh et al. [21]. As shown by Hocquet et al. [37], for this invertible architecture the structural objective can be defined as from collapsing to an all-ze $\\mathcal { L } _ { m } ^ { ( s t . ) } ( x ) = | | x | | _ { 2 }$ . Intuitively, an invertible architecture prevents $\\mathcal { L } _ { m } ^ { ( s t . ) }$ ",
+        "bbox": [
+            173,
+            342,
+            825,
+            416
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "In the second instantiation, $s$ and $f$ form an autoencoder and $\\mathcal { L } _ { m } ^ { ( s t . ) } ( x ) = | | x ^ { ( l - 1 ) } - x | | ^ { 2 }$ is the reconstruction error with respect to the module’s input $x ^ { ( l - 1 ) }$ . Aljundi et al. [2] used a similar idea was for selecting the most relevant expert network conditioned on a task. Unless stated otherwise, modules in the feature extractor use the autoencoder as their structural component, while output heads use invertible $s$ — these combinations worked well in practice. ",
+        "bbox": [
+            173,
+            421,
+            825,
+            496
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "3.1 Expansion strategy ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            512,
+            346,
+            527
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "It is necessary to expand $\\mathcal { F }$ as new tasks arrive to acquire new knowledge. A new module is added to a layer when all modules in this layer detect an outlier input. To this end, we track the running statistics of the relatedness score $\\gamma$ for each module — mean $\\mu$ and variance $\\sigma$ (see Figure 1), and calculate a z-score for each sample in the batch and each module at a layer: ",
+        "bbox": [
+            174,
+            537,
+            825,
+            593
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/367b2877a665e3be00acd4276a4e3836222c4f9175a235dad79236f82ab43ec4.jpg",
+        "text": "$$\nz _ { m } = \\frac { w _ { m } - \\mu _ { m } } { \\sigma _ { m } } .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            437,
+            599,
+            560,
+            631
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "An input is considered an outlier if its $\\mathbf { Z }$ -score is larger than a predefined threshold $z ^ { \\prime }$ (see Appendix B.6 for an ablation study of $z ^ { \\prime }$ values). The expansion decision can be made on the per-sample (i.e., if an outlier sample is detected) or a per-batch basis (i.e., $z$ is averaged over the mini-batch). Unless stated otherwise, in our experiments, the decision was made on a per-batch basis. Additionally, at training the parameters of existing modules are fixed once the task changes. If during a forward pass through $\\mathcal { F }$ module addition is triggered at multiple layers, we start adding modules at the layer closest to the input. ",
+        "bbox": [
+            173,
+            636,
+            826,
+            734
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "3.2 Training ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            750,
+            274,
+            763
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Each module in LMC receives two types of learning signal: a structural signal resulting from minimizing $\\mathcal { L } _ { m } ^ { ( s t . ) }$ , and a functional signal resulting from minimizing the global functional loss $\\mathcal { L }$ All structural components $s$ are trained only with the structural signal that is calculated locally to each module. ",
+        "bbox": [
+            173,
+            773,
+            825,
+            834
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "The training of functional components proceeds in two phases: projection and accumulation. Whenever the expansion strategy triggers the addition of a new module (i.e., $z _ { m } > z ^ { \\prime } \\forall m \\in$ $\\{ 0 , \\ldots , | M ^ { ( l ) } | \\} )$ , starting with layers closest to the input, LMC initiates the projection phase. During this phase, the new module is trained to minimize the structural loss from all the layers above and no new-module addition is allowed. This procedure makes the representation of new modules compatible with subsequent modules and enables their composition. This procedure “encourages” already-learned modules to be reused, preventing over-spawning new modules. The functional signal is optional during projection (we kept it in all experiments unless otherwise stated). ",
+        "bbox": [
+            174,
+            840,
+            825,
+            911
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "table",
+        "img_path": "images/0f0345f61ac65711d6d305b1481ef67eeec525b956f9ba83de24ca2b119153a6.jpg",
+        "table_caption": [
+            "Table 1: CTrL results: we report accuracy $( \\uparrow \\mathcal { A } )$ , forgetting $( \\uparrow \\mathcal { F } )$ with standard deviations calculated over 6 different runs. We report the mean number of modules (M) over these runs, where ∗ marks methods with fixed capacity. The first block comprises a set of standard CL baselines including regularization and replay based methods. The second block are the modular methods, third – modular and replay based methods that are task ID agnostic (A), and the last block are the two finetuning baselines. (H) indicates hard module selection. (S) indicates single-head as detailed in the main text. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td></td><td colspan=\"3\">si</td><td colspan=\"3\">S+</td><td colspan=\"3\">Sin</td><td colspan=\"3\">Sout</td><td colspan=\"3\">Spl</td></tr><tr><td>MODEL</td><td>A</td><td>F</td><td>M</td><td>A</td><td>F</td><td>M</td><td>A</td><td>F</td><td>M</td><td>A</td><td>F</td><td>M</td><td>A</td><td>F</td><td>M</td></tr><tr><td>HAT[87]</td><td>63.7±0.7</td><td>-1.3±0.6</td><td>24*</td><td>61.4±0.5</td><td>-0.2±0.2</td><td>24*</td><td>50.1±0.8</td><td>0.0±0.1</td><td>24*</td><td>61.9±1.3</td><td>-3.2±1.3</td><td>24*</td><td>61.2±0.7</td><td>-0.1±0.2</td><td>20*</td></tr><tr><td>EWC[46]</td><td>62.7±0.7</td><td>-3.6±0.9</td><td>24*</td><td>53.4±1.8</td><td>-2.3±0.4</td><td>24*</td><td>56.3±2.5</td><td>-9.1±3.3</td><td>24*</td><td>62.5±0.9</td><td>-3.6±0.9</td><td>24*</td><td>54.2±3.1</td><td>-4.2±2.7</td><td>20*</td></tr><tr><td>O-EWC[85]</td><td>62.0±0.7</td><td>-3.2±0.7</td><td>24*</td><td>54.6±0.7</td><td>-1.3±1.0</td><td>24*</td><td>54.2±3.1</td><td>-10.8±3.1</td><td>24*</td><td>62.4±0.6</td><td>-3.0±0.9</td><td>24*</td><td>52.3±1.4</td><td>-5.7±1.3</td><td>20*</td></tr><tr><td>ER[81,16]</td><td>60.6±0.7</td><td>-2.1±0.9</td><td>4*</td><td>63.0±0.6</td><td>3.8±0.8</td><td>4*</td><td>63.8±1.4</td><td>-1.9±0.6</td><td>4*</td><td>60.7±1.0</td><td>-1.5±0.5</td><td>4*</td><td>60.5±1.0</td><td>0.5±0.9</td><td>4*</td></tr><tr><td>EXPERTS</td><td>62.7±0.9</td><td>0.0</td><td>24</td><td>63.2±0.8</td><td>0.0</td><td>24</td><td>63.1±0.7</td><td>0.0</td><td>24</td><td>63.1±0.7</td><td>0.0</td><td>24</td><td>63.9±0.5</td><td>0.0</td><td>20</td></tr><tr><td>MNTDP[92]</td><td>66.3±0.8</td><td>0.0</td><td>13.7</td><td>62.6±0.7</td><td>0.0</td><td>21.0</td><td>67.9±0.9</td><td>0.0</td><td>16.0</td><td>65.8±0.9</td><td>0.0</td><td>15.0</td><td>64.0±0.2</td><td>0.0</td><td>17.2</td></tr><tr><td>SG-F[63]</td><td>63.6±1.5</td><td>0.0</td><td>14.7</td><td>61.5±0.6</td><td>0.0</td><td>20.8</td><td>65.5±1.8</td><td>0.0</td><td>17.5</td><td>64.1±1.3</td><td>0.0</td><td>16.2</td><td>62.0±1.3</td><td>0.0</td><td>16.0</td></tr><tr><td>LMC(- A)</td><td>66.6±1.5 -0.0±0.1</td><td></td><td>15.3</td><td>60.1±2.7</td><td>-1.4±2.4</td><td>21.3</td><td>69.5±1.0</td><td>0.0±0.1</td><td>20.0</td><td>66.7±2.2</td><td>-0.1±0.1</td><td>15.5</td><td>61.6±4.8</td><td>-3.5±3.1</td><td>18.2</td></tr><tr><td>MNTDP(A)</td><td>41.9±2.5</td><td>-2.8±0.6</td><td>14.8</td><td>43.2±1.3-10.8±2.020.7|3</td><td></td><td></td><td></td><td>|32.7±13.6-15.2±13.2]</td><td>17.2</td><td>37.9±2.7</td><td>-5.8±3.5</td><td>13.3</td><td>35.1±3.6</td><td>5-16.4±4.6 15.8</td><td></td></tr><tr><td>LMC(A)</td><td>67.2±1.5</td><td>-0.5±0.4</td><td>15.7</td><td>62.2±4.5</td><td>2.3±1.6</td><td>22.3</td><td>68.5±1.7</td><td>-0.1±0.1</td><td>19.7</td><td>55.1±3.4</td><td>-7.1±4.0</td><td>15.5</td><td>63.5±1.9</td><td>-1.0±1.5</td><td>19.0</td></tr><tr><td>LMC(A,H)</td><td>64.9±1.5 -0.2±0.2</td><td></td><td>16.2</td><td>55.8±2.5</td><td>-0.3±1.2</td><td>15.3</td><td>67.6±2.7</td><td>-0.8±1.0</td><td>21.5</td><td>54.2±3.6</td><td>-2.9±2.0</td><td>15.9</td><td>53.8±5.7</td><td>3.1±5.5</td><td>10.8</td></tr><tr><td>SG-F(A)</td><td>29.5±3.5 -35.3±4.0 14.3</td><td></td><td></td><td>20.4±4.4</td><td>-39.3±6.716.0</td><td></td><td>24.4±5.6</td><td>-38.7±4.0</td><td>18.7</td><td>30.5±4.5</td><td>-34.0±5.512.2</td><td></td><td>19.4±1.0</td><td>-41.8±1.6</td><td>15.5</td></tr><tr><td>ER(A,S)[81,16]</td><td>60.4±1.0 -0.5±0.7</td><td></td><td>4*</td><td>65.3±0.9</td><td>6.0±1.0</td><td>4*</td><td>58.8±3.2</td><td>-4.2±3.7</td><td>4*</td><td>47.6±1.5</td><td>-7.6±1.6</td><td>4*</td><td>58.6±1.3</td><td>-1.2±1.5</td><td>4*</td></tr><tr><td>FINETUNE</td><td>47.5±1.5 -14.9±1.4</td><td></td><td>4*</td><td>31.4±3.7 -29.3±3.84*</td><td></td><td></td><td>39.7±5.0</td><td>-23.9±5.7</td><td>4*</td><td>45.4±4.0 -15.5±3.7</td><td></td><td>4*</td><td>29.1±3.1 - 29.2±3.2</td><td></td><td>4*</td></tr><tr><td>FINETUNE L</td><td>52.1±1.4 -15.7±1.7 24*</td><td></td><td></td><td>38.2±3.2</td><td>2-25.8±3.324*</td><td></td><td>49.3±2.0</td><td>-18.4±2.0</td><td>24*</td><td>49.3±2.1</td><td>-18.4±2.0</td><td>24*</td><td>37.1±2.1</td><td>-26.0±2.2</td><td>20*</td></tr></table>",
+        "bbox": [
+            158,
+            89,
+            843,
+            328
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            449,
+            826,
+            491
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "In the accumulation phase, new module addition is allowed again and all non-frozen modules are trained with both signals. The functional components of new modules still receive a signal from the structural components of modules above. The two-phase training is explained schematically in Figure 2 and implementation details are provided in Appendix A. ",
+        "bbox": [
+            174,
+            497,
+            825,
+            554
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "4 Experiments ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            573,
+            312,
+            590
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "We now evaluate the performance, empirical capabilities, and properties of LMC in four different CL settings. First, in $\\ S 4 . 1$ we study a standard task-incremental CL setting (task-ID agnostic and aware) using the Continual Transfer Learning Benchmark (CTrL) [92]. Next, we explore the properties of LMC through other CL settings. In $\\ S 4 . 2$ we evaluate the continual OOD generalization ability of the proposed LMC. In $\\ S 4 . 3$ we show the ability of LMC to combine modules form independently trained models. In Appendix F, we evaluate LMC in the Continual Meta-Learning setting. ",
+        "bbox": [
+            174,
+            604,
+            825,
+            688
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "4.1 Continual transfer learning using the CTrL benchmark ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            704,
+            599,
+            719
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "The CTrL benchmark was proposed to systematically evaluate properties of CL methods with a focus on modular architectures [92]. It consists of 5 streams of visual image classification tasks. The first stream $S ^ { - } = ( t _ { 1 } ^ { + } , t _ { 2 } , t _ { 3 } , t _ { 4 } , t _ { 5 } , t _ { 1 } )$ consists of a sequence of 6 tasks, where the first and last task are the same except the first has an order of magnitude more training samples $( ^ { 6 6 + 7 9 } )$ than other tasks. This stream is designed to evaluate the direct transfer ability of models, i.e. a modular learner should be able to reuse the first task’s modules for the last task. The $S ^ { + } = ( t _ { 1 } , t _ { 2 } , t _ { 3 } , t _ { 4 } , t _ { 5 } , t _ { 1 } ^ { + } )$ stream is similar to $S ^ { - }$ , but now the last task comes with more data than the other tasks (including the first one). Here, the modular learner should be able to update its knowledge, i.e. performance on the first task should improve after learning the last task. In the $S ^ { i n } = ( t _ { 1 } , t _ { 2 } , t _ { 3 } , t _ { 4 } , t _ { 5 } , t _ { 1 } ^ { \\prime } )$ stream the first $t _ { 1 }$ and the last $t _ { 1 } ^ { \\prime }$ tasks are similar, with a slight input distribution change (e.g. different background color). In the $S ^ { o u t } = ( t _ { 1 } ^ { + } , t _ { 2 } , t _ { 3 } , t _ { 4 } , t _ { 5 } , t _ { 1 } ^ { \\prime \\prime } )$ stream the first task $t _ { 1 }$ and the last task $t _ { 1 } ^ { \\prime \\prime }$ differ in the amount of training data and the output distribution, i.e. the labels of the last task are randomly permuted. The plasticity stream $S ^ { p l } = \\mathsf { \\bar { ( } } t _ { 1 } , t _ { 2 } , t _ { 3 } , t _ { 4 } , t _ { 5 } )$ evaluates the ability to learn a stream of unrelated and potentially interfering tasks, i.e., transfer from unrelated tasks can harm performance. Descriptive statistics for all datasets are in Appendix B.1. ",
+        "bbox": [
+            173,
+            729,
+            826,
+            912
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            92,
+            823,
+            119
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "We compare to several baselines. Finetune: trains a single model (wider model marked with L) for all tasks. Experts: trains a model per task. We also compare with the several recently proposed modular CL baselines, which achieve competitive results in CTrL and require task IDs at test time. MNTDP [92]: a recent search-based module selection approach described in more detail in $\\ S 2$ . MNTDP requires the task ID to retrieve the previously found best structure for each test task. $\\mathbf { M N T D P ( A ) }$ : a task ID agnostic version of MNTDP we created, which selects the path with the lowest entropy in the output distribution. SG-F [63]: Soft-gating with fixed modules, a modular method mentioned in $\\ S 2$ . It relies on a task-specific structural network that generates soft-gating vectors for each layer of the modular learner and fixes learned modules when new tasks arrive. We slightly adapted the original expansion strategy of SG-F in order to conform to our experimental setup; details are in Appendix B.2. SG- $\\mathbf { F } _ { \\left( \\mathbf { A } \\right) }$ : a version of SG-F with a single structural network shared across tasks. HAT[87]: learns attention masks for activations that gate the gradients to prevent forgetting. The task ID is used to select a task-specific attention mask for inference. ",
+        "bbox": [
+            174,
+            126,
+            825,
+            304
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "We also compare to several standard CL methods. EWC [46]: trains a single model for all tasks while applying parameter-regularization to minimize forgetting. O-EWC:[85] online version of EWC that does not require storing a separate approximation of the Fisher information matrix per task. ER [16]: trains a single model while replaying samples from previously seen tasks. The size of the replay buffer corresponds to the memory size of the LMC assuming the worse case linear growth pattern (i.e., LMC with 24 modules on a 6-task sequence). ER(A,S): task ID agnostic version of ER that uses a single output head to classify all classes from all tasks: i.e. after learning stream $S ^ { - }$ the output head has 50 output neurons and the output classes of the last task are considered the same as the ones of the first task. ",
+        "bbox": [
+            174,
+            311,
+            825,
+            436
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "We use several versions of LMC. $\\mathbf { L M C } _ { ( \\lnot \\mathbf { A } ) }$ a version of LMC that uses the task ID for output head selection (not module selection as MNTDP). LMC(A): the default version of LMC. It equips output heads with structural components and is therefore task ID agnostic at test time. LMC(A,H): a version of task ID agnostic LMC that performs hard module selection, i.e., taking the module with the highest relevance score per layer. All methods use the same architecture (described in Appendix A.4) together with the Adam [44] optimizer. HAT is the only method that uses SGD. ",
+        "bbox": [
+            174,
+            443,
+            825,
+            525
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Similar to Veniat et al. [92], we use the following evaluation metrics: $( \\mathcal { A } )$ average accuracy on all seen tasks at the end of CL training; Forgetting $( \\mathcal { F } )$ — difference between accuracy at the end of the training and accuracy after learning the task averaged across tasks [60]; Number of modules (M) at the end of the continual training procedure. Formal definitions of all metrics are in Appendix B.3. ",
+        "bbox": [
+            174,
+            532,
+            823,
+            588
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Table 1 reports performance using the CTrL benchmark. Overall, modular methods tend to outperform ER and the regularization based methods (HAT and EWC). Among the modular methods, soft-gating SG-F(A,F) with a single controller shared among all the tasks performed the worst. This baseline showcases the problem of forgetting in the global structural component (a.k.a. controller) of dynamic routing methods such as the one proposed by Mendez and Eaton [63]. A version of LMC performs the best on the $S ^ { - }$ , $S ^ { i n }$ and $S ^ { o u t }$ streams. ",
+        "bbox": [
+            174,
+            594,
+            825,
+            678
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Notably, $\\mathrm { L M C } _ { ( \\mathrm { A } ) }$ , which does not rely on task IDs at test time, outperformed all other task ID agnostic methods such as $\\mathbf { M N T D P _ { ( A ) } }$ and ER(A,S) on all streams but $S ^ { + }$ , and always performed on par with task ID aware methods. On the $S ^ { o u t }$ stream low performance is expected for task-ID agnostic methods due to output distribution shift: i.e., at test time we notice that LMC correctly assigns samples from the last task $t _ { 1 } ^ { \\prime \\prime }$ to the first task’s $t _ { 1 } ^ { + }$ output head. However, the resulting classification accuracy is low because the labels of the last task are randomly permuted in this stream. ",
+        "bbox": [
+            174,
+            684,
+            825,
+            767
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "The task ID agnostic $\\mathrm { L M C } _ { ( \\mathrm { A } ) }$ outperforms task ID aware LMC on the $S ^ { - }$ and $S ^ { + }$ streams. Here, LMC(A) selects modules (and the output head) which were predominantly trained on the task that provided more training data (e.g. $t _ { 1 } ^ { + }$ in $S ^ { - }$ stream), hence transferring knowledge between the first and the last tasks. In contrast, $\\mathbf { L M C } _ { ( \\neg \\mathbf { A } ) }$ when tested on the last task $t _ { 1 }$ is forced to select the output head belonging to this task, which was trained on less data than the output head of $t _ { 1 } ^ { + }$ task, leading to lower accuracy. In addition, we observed that versions of LMC often exhibit high variance (e.g. see $S ^ { + }$ , $S ^ { o u t }$ and $S ^ { p l }$ streams). This may be caused by the larger amount of trainable parameters compared to other models and relatively small amount of training data. Finally, low performance of ",
+        "bbox": [
+            173,
+            772,
+            825,
+            885
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/0ac0839a77314eef3f415108a944bbd40d71d498bce0e862bb483ebc1931b9d5.jpg",
+        "image_caption": [
+            "Figure 3: Continual OOD-generalization: matrices show test accuracy on seen and unseen tasks (onand off-diagonal tasks respectively). In each sub-figure $\\mathbf { X }$ -axis shows the MNIST class-combination used to build the task, y-axis gives the foreground-background colors. Only diagonal tasks are learned continually. While non-modular EWC (a) and modular MNTDP (b) can prevent forgetting, $\\mathbf { L M C _ { ( \\neg A ) } }$ (c) is able to generalize to OOD tasks as well. $\\mathrm { L M C } _ { \\left( \\lnot \\mathbf { A } \\right) }$ without projection phase performs poorly as shown in (d). "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            178,
+            88,
+            825,
+            239
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "LMC(A,H) emphasizes the importance of soft modular attention for LMC. Additional results, including a transfer metric [92], are in Appendix B.4. ",
+        "bbox": [
+            174,
+            373,
+            823,
+            401
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "4.2 Compositional OOD generalization ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            431,
+            457,
+            446
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "This second study tests the ability of LMC to recombine modules for OOD generalization. We use a colored-MNIST dataset — a variation of the standard MNIST dataset of hand-written digits from 0 to 9 [43] in which digits are colorized. We design a simple sequence of tasks as follows. First, we define two high-level features: the foreground-background color combination (using the colors red, black, green, blue) and the class (0–9). Then, we create five non-overlapping tasks of two (digit) classes each: $\\left\\{ 0 - 1 , \\quad \\ldots , \\quad 8 - 9 \\right\\}$ . At training time the model is continually trained using a sequence of these tasks, however, each task is only seen in one of five different foreground-background combinations {red-black, green-black, blue-black, black-red, black-green}. At test time we measure the generalization ability to seen and unseen combinations of classes and colors. ",
+        "bbox": [
+            174,
+            462,
+            825,
+            588
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "In Figure 3 we present the accuracy matrices for different learners when tested on all 25 combinations of colors and classes after it has been trained only on the 5 tasks on the diagonal. ",
+        "bbox": [
+            176,
+            593,
+            823,
+            622
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "We compare the performance of $\\mathbf { L M C } _ { ( \\neg \\mathbf { A } ) }$ with EWC [46], MNTDP [92], and an ablated version of LMC without the projection phase. We observe that the OOD accuracy attained by LMC is significantly higher than EWC and MNTDP. Since the model trained with EWC is monolithic, the digit-background color combinations are entangled with the digits’ shape for each task, hindering OOD generalization. In contrast, modular approaches such as MNTDP and LMC learn a different module combination for each task. In contrast to MNTDP, LMC’s module selection does not rely on task identifiers and each module is selected in a local manner based on its compatibility with the current input. This allows LMC to interpolate between previously seen tasks being able to dynamically compose existing modules to adapt to tasks that have not been seen at training. Because MNTDP’s module selection relies on a database of task-specific structures found to be optimal for the corresponding task at training, this method must reuse the predefined module compositions based on task IDs. This forces MNTDP to use modules that were trained using a different color combination, and results in e.g. a $2 4 \\%$ accuracy drop with respect to LMC on [0,1] when the foreground and background colors are inverted w.r.t. the seen combination. ",
+        "bbox": [
+            174,
+            627,
+            825,
+            821
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "In Figure 3d we report results for LMC without applying the projection phase. The projection phase adapts the representation of newly introduced modules to match the distribution expected by the subsequent modules. As expected, we found that skipping it severely degrades performance. This result validates the usefulness of the projection phase to achieve an efficient local module selection. In Appendix E we plot the average module selection for all 25 test tasks, showing how modules are reused for the OOD tasks. ",
+        "bbox": [
+            174,
+            828,
+            825,
+            911
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "image",
+        "img_path": "images/02bf370265e6243b99d3e16eb7c0b1722e28c196e9ddfc5d32fc62f7c3c014e1.jpg",
+        "image_caption": [
+            "Figure 5: Results on $S ^ { l o n g }$ and $S ^ { l o n g 3 0 }$ sequences for different hyperparameter values (we select only runs with reasonably good performance, i.e. $4 \\%$ ), same plots plots for all conducted runs can be found in Appendix C). "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            196,
+            89,
+            802,
+            222
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "4.3 Combining modular learners ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            306,
+            415,
+            320
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "In earlier sections we show cross-task reusability of modules, here we test the cross-model reusability. We motivate the practical importance of this kind of reusability with a federated learning example: a privacy preserving training might be required for LMC1 and LMC2, trained on the premises of customers 1 and 2, after which their modules can be combined in a single central entity — LMC3, located on premises of the cloud service provider. LMC3 is required to perform tasks seen by both independent LMCs but can not be finetuned as it has no access to the original training data distributions. ",
+        "bbox": [
+            174,
+            333,
+            485,
+            512
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "image",
+        "img_path": "images/13b03e1aec38cbde4911d46835b11fd8b31a69fd07dffdd977f563adc068d68c.jpg",
+        "image_caption": [
+            "Figure 4: Performance of combining independently trained LMC1 and LMC2 into LMC3. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            504,
+            353,
+            816,
+            460
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "In Figure 4 we test the ability of LMC to preserve and transfer knowledge in such setting. To this end, we design the following tasks: fMNIST $^ +$ and fMNIST-. Both are sampled from the fashion-MNIST dataset [98] but the latter comes with an order of magnitude less training data. cMNIST-r is a variant of the colored-MNIST dataset where the background of $9 5 \\%$ of the training samples is colored in red and $5 \\%$ in green. For the cMNIST-g dataset these proportions are inverted and $9 5 \\%$ of the training samples is colored in green. The test set contains $50 \\%$ of samples with green and $50 \\%$ with red background. We trained LMC1 continually on MNIST, fMNIST $^ +$ , and cMNIST-r tasks. We trained LMC2 on fMNIST-, cMNIST- $\\mathbf { g }$ , and SVHN. We then combined the modules of both LMCs layer-wise to obtain LMC3. ",
+        "bbox": [
+            174,
+            518,
+            826,
+            643
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "We observed positive transfer for both cMNIST and fMNIST- tasks with LMC3. We found that LMC3 selects different modules originating from different LMCs conditioned on test samples with different background colors — LMC1’s modules were specialized on red background while LMC2’s on green (selected paths presented in Appendix D). Notably, cross-model reusability without fine-tuning is novel to LMC and can be attributed to the local nature of the structural component. Using a global structural component as in [63] would require tuning a separate structural component specifically for LMC3. In case of task-specific routing of proposed for MNTDP [92], additional search would be needed to discover task-specific paths through the consolidated LMC3 model. In both cases the access to the orinal training data distributions would be required and privacy would not be preserved. ",
+        "bbox": [
+            173,
+            648,
+            825,
+            773
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "4.4 Longer task sequences ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            795,
+            369,
+            809
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Here we study the performance LMC on longer task sequences consisting of $3 0 - S ^ { l o n g 3 0 }$ , and $1 0 0 -$ $S ^ { l o n g }$ tasks. The $S ^ { \\bar { l } o n g }$ sequence corresponds to the one proposed by Veniat et al. [92] as part of the CTrL benchmark. $S ^ { l o n g 3 0 }$ is a 30-tasks subset of $S ^ { l o n g }$ (see Appendix B.1 for details). ",
+        "bbox": [
+            176,
+            820,
+            825,
+            863
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "We first report the average test accuracy $( \\mathcal { A } )$ and the total number of modules (M) of the models selected through cross-validation. $S ^ { l o n j 3 0 }$ : MNTDP $\\scriptstyle A = 6 4 . 5 8$ , $\\scriptstyle \\mathbf { M } = 6 4$ ; LMC(¬A): $\\scriptstyle A = 6 2 . 4 4$ , ${ \\bf M } { = } 5 0$ $S ^ { l o n g }$ : MNTDP $\\scriptstyle A = 6 8 . 9 2$ , $\\mathbf { M } { = } 1 4 2$ ; $\\mathbf { L M C _ { ( \\neg A ) } }$ : $\\scriptstyle A = 6 3 . 8 8$ , $\\mathbf { M } = 3 2$ . While the gap between the accuracy of LMC and MNTDP on $S ^ { l o n g 3 0 }$ is only $1 . 8 6 \\%$ -points, in the case of $S ^ { l o n g }$ this gap grows to $6 . 5 8 \\%$ - points. It is important to highlight that in contrast to LMC, MNTDP’s module selection is performed by a task ID aware oracle. We further analyze the trade-off between the number of modules and accuracy in Figure 5, where we plot the number of modules (M) against average test accuracy $( \\mathcal { A } )$ for models that resulted from training with different hyperparameters. For both streams, we observe that LMC tends to spawn much fewer modules than MNTDP. However, MNTDP shines in the presence of large number of modules and achieves higher overall test accuracy on these streams. Interestingly, as can be clearly observed on the $S ^ { l o n g }$ stream, LMC reaches higher accuracy with smaller number of modules: e.g. ${ \\sim } 6 4 \\%$ with 32 modules, while adding modules leads to lower accuracy: e.g. ${ \\sim } 6 1 \\%$ with 98 modules. This result suggests that local task ID agnostic module selection becomes more challenging for LMC in presence of a large number of modules. ",
+        "bbox": [
+            176,
+            869,
+            825,
+            911
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            90,
+            825,
+            243
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "5 Related work ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            267,
+            316,
+            284
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Modularity in neural networks is studied in the context of scalability [9], and more recently as a way to achieve compositionality and systematic generalization [6, 47, 15, 8, 27, 19] as well as for multi-task learning [65, 82]. From the causal point of view, a data generation process could be thought as a composition of independent causal modules [75]. Researchers model these kinds of systems using a set of independent modules, where each module is invariant to changes in the other modules induced by e.g. distribution shifts [84, 76]. This idea is crystallized by Parascandolo et al. [74], who propose a way to learn a set of causal independent mechanisms as mixture-of-experts. Building up on this ideas, others show evidence of compositional OOD generalization [61]. Recently, [66] argue for a more wholistic view on CL including OOD generalization as an important desiderata. ",
+        "bbox": [
+            174,
+            300,
+            825,
+            426
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Continual learning methods typically address the problem of forgetting through parameter regularization [46, 70, 99], replay [89, 78, 3, 73, 54, 12, 97, 39, 81, 13] or dynamic architectures (and MoEs) [83, 87, 52, 85, 53, 41]. Our work falls under the umbrella of the latter and shares its advantage of having the capacity to adapt to a large number of related tasks. Our focus is on improving modular CL approaches, which despite their advantages, have only recently been studied in the CL literature [63, 92]. The main difference with our work is that we use a local composition mechanism instead of a global one. We detail this difference in $\\ S 2$ and also compare to these methods in $\\ S 4 . 1$ . ",
+        "bbox": [
+            174,
+            431,
+            825,
+            529
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Continual-meta learning focuses on fast learning and remembering [25, 35, 33, 41], often emphasising the online performance on OOD tasks [14]. As argued by Jerfel et al. [41] modularity can be useful in this setting to minimize interference between tasks. They proposed a way to train a MoE model, with each expert focusing on a cluster of tasks leveraging Bayesian nonparametrics. LMC aims at decomposing knowledge into layer-wise composable modules further reducing modular granularity. Continual-meta learning is often confused with its counterpart meta-continual learning [40, 11, 93], in which algorithm are learning to continually learn. ",
+        "bbox": [
+            174,
+            535,
+            825,
+            632
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "The rapid growth of continual learning has lead researchers to work on empirical studies [20, 58, 56], surveys [32, 42, 55, 66, 67] as well as CL-specific software [72, 22, 59]. ",
+        "bbox": [
+            174,
+            638,
+            825,
+            666
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "6 Conclusion ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            690,
+            299,
+            708
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "We develop LMC, a method to learn and compose a series of modules on a continual stream of tasks fulfilling some of the basic desiderata of modular CL such as module specialization, avoidance of collapse, and sublinear growth. In LMC, structural information is learned and stored locally for each module. It is the locality of the structural component that enables generalization to related but unseen tasks, and that permits combining different LMCs without fine-tuning. ",
+        "bbox": [
+            174,
+            724,
+            825,
+            794
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Future work could focus on achieving more efficient sub-linear model growth through OOD generalization and reusability of modules. Additionally, while the benefits of modularity for CL are well understood, the implications of the CL regime on modularity and compositionality have not been studied extensively. It is possible that providing knowledge to the learner in incremental chunks results in the implicit supervision needed to better disentangle it into specialized and composable modules. Another promising direction is removing the need for task boundaries during training and developing more robust architectures for the local structural component (related discussions are in Appendix A.3, and limitations in Appendix G). ",
+        "bbox": [
+            174,
+            800,
+            825,
+            911
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "References   \n[1] Rahaf Aljundi, Francesca Babiloni, Mohamed Elhoseiny, Marcus Rohrbach, and Tinne Tuytelaars. Memory aware synapses: Learning what (not) to forget. CoRR, abs/1711.09601, 2017.   \n[2] Rahaf Aljundi, Punarjay Chakravarty, and Tinne Tuytelaars. Expert gate: Lifelong learning with a network of experts. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pages 3366–3375, 2017.   \n[3] Rahaf Aljundi, Lucas Caccia, Eugene Belilovsky, Massimo Caccia, Min Lin, Laurent Charlin, and Tinne Tuytelaars. Online continual learning with maximal interfered retrieval. In Advances in Neural Information Processing Systems 32, pages 11849–11860. Curran Associates, Inc., 2019.   \n[4] Mohammed Amer and Tomás Maul. A review of modularization techniques in artificial neural networks. Artificial Intelligence Review, 52(1):527–561, 2019.   \n[5] Jacob Andreas, Marcus Rohrbach, Trevor Darrell, and Dan Klein. Learning to compose neural networks for question answering. arXiv preprint arXiv:1601.01705, 2016.   \n[6] Jacob Andreas, Marcus Rohrbach, Trevor Darrell, and Dan Klein. Neural module networks. In Proceedings of the IEEE conference on computer vision and pattern recognition, pages 39–48, 2016.   \n[7] Antreas Antoniou, Harrison Edwards, and Amos Storkey. How to train your maml. arXiv preprint arXiv:1810.09502, 2018.   \n[8] Dzmitry Bahdanau, Shikhar Murty, Michael Noukhovitch, Thien Huu Nguyen, Harm de Vries, and Aaron Courville. Systematic generalization: What is required and can it be learned? In International Conference on Learning Representations, 2018.   \n[9] Dana H Ballard. Modular learning in neural networks. In AAAI, pages 279–284, 1987.   \n[10] Jens Behrmann, Will Grathwohl, Ricky TQ Chen, David Duvenaud, and Jörn-Henrik Jacobsen. Invertible residual networks. In International Conference on Machine Learning, pages 573–582. PMLR, 2019.   \n[11] Lucas Caccia and Joelle Pineau. Special: Self-supervised pretraining for continual learning. arXiv preprint arXiv:2106.09065, 2021.   \n[12] Lucas Caccia, Eugene Belilovsky, Massimo Caccia, and Joelle Pineau. Online learned continual compression with stacked quantization module. ArXiv, abs/1911.08019, 2019.   \n[13] Lucas Caccia, Rahaf Aljundi, Tinne Tuytelaars, Joelle Pineau, and Eugene Belilovsky. Reducing representation drift in online continual learning. arXiv preprint arXiv:2104.05025, 2021.   \n[14] Massimo Caccia, Pau Rodriguez, Oleksiy Ostapenko, Fabrice Normandin, Min Lin, Lucas Caccia, Issam Laradji, Irina Rish, Alexande Lacoste, David Vazquez, et al. Online fast adaptation and knowledge accumulation: a new approach to continual learning. arXiv preprint arXiv:2003.05856, 2020.   \n[15] Michael Chang, Abhishek Gupta, Sergey Levine, and Thomas L Griffiths. Automatically composing representation transformations as a means for generalization. In International Conference on Learning Representations, 2018.   \n[16] Arslan Chaudhry, Marcus Rohrbach, Mohamed Elhoseiny, Thalaiyasingam Ajanthan, Puneet K Dokania, Philip HS Torr, and M Ranzato. Continual learning with tiny episodic memories. 2019.   \n[17] M. Cimpoi, S. Maji, I. Kokkinos, S. Mohamed, , and A. Vedaldi. Describing textures in the wild. In Proceedings of the IEEE Conf. on Computer Vision and Pattern Recognition (CVPR), 2014.   \n[18] Rodolfo Corona, Daniel Fried, Coline Devin, Dan Klein, and Trevor Darrell. Modularity improves out-of-domain instruction following. arXiv preprint arXiv:2010.12764, 2020.   \n[19] Róbert Csordás, Sjoerd van Steenkiste, and Jürgen Schmidhuber. Are neural nets modular? inspecting functional modularity through differentiable weight masks. In International Conference on Learning Representations, 2021. URL https://openreview.net/forum?id $= ^ { \\prime }$ 7uVcpu-gMD.   \n[20] Matthias De Lange, Rahaf Aljundi, Marc Masana, Sarah Parisot, Xu Jia, Ales Leonardis, Gregory Slabaugh, and Tinne Tuytelaars. Continual learning: A comparative study on how to defy forgetting in classification tasks. arXiv preprint arXiv:1909.08383, 2019.   \n[21] Laurent Dinh, David Krueger, and Yoshua Bengio. Nice: Non-linear independent components estimation. arXiv preprint arXiv:1410.8516, 2014.   \n[22] Arthur Douillard and Timothée Lesort. Continuum: Simple management of complex continual learning scenarios. ArXiv, abs/2102.06253, 2021.   \n[23] Sebastian Farquhar and Yarin Gal. Towards robust evaluations of continual learning. arXiv preprint arXiv:1805.09733, 2018.   \n[24] Chelsea Finn, Pieter Abbeel, and Sergey Levine. Model-agnostic meta-learning for fast adaptation of deep networks. In International Conference on Machine Learning (ICML), 2017.   \n[25] Chelsea Finn, Aravind Rajeswaran, Sham Kakade, and Sergey Levine. Online meta-learning. In International Conference on Machine Learning, pages 1920–1930. PMLR, 2019.   \n[26] Robert M French. Pseudo-recurrent connectionist networks: An approach to the’sensitivitystability’dilemma. Connection Science, 9(4):353–380, 1997.   \n[27] Anirudh Goyal, Alex Lamb, Jordan Hoffmann, Shagun Sodhani, Sergey Levine, Yoshua Bengio, and Bernhard Schölkopf. Recurrent independent mechanisms. arXiv preprint arXiv:1909.10893, 2019.   \n[28] Anirudh Goyal, Aniket Didolkar, Alex Lamb, Kartikeya Badola, Nan Rosemary Ke, Nasim Rahaman, Jonathan Binas, Charles Blundell, Michael Mozer, and Yoshua Bengio. Coordination among neural modules through a shared global workspace. arXiv preprint arXiv:2103.01197, 2021.   \n[29] Erin Grant, Chelsea Finn, Sergey Levine, Trevor Darrell, and Thomas Griffiths. Recasting gradient-based meta-learning as hierarchical bayes. arXiv preprint arXiv:1801.08930, 2018.   \n[30] Ishaan Gulrajani and David Lopez-Paz. In search of lost domain generalization. arXiv preprint arXiv:2007.01434, 2020.   \n[31] Sharut Gupta, Praveer Singh, Ken Chang, Mehak Aggarwal, Nishanth Arun, Liangqiong Qu, Katharina Hoebel, Jay Patel, Mishka Gidwani, Ashwin Vaswani, et al. The unreasonable effectiveness of batch-norm statistics in addressing catastrophic forgetting across medical institutions. arXiv preprint arXiv:2011.08096, 2020.   \n[32] Raia Hadsell, Dushyant Rao, Andrei A Rusu, and Razvan Pascanu. Embracing change: Continual learning in deep neural networks. Trends in Cognitive Sciences, 2020.   \n[33] James Harrison, Apoorva Sharma, Chelsea Finn, and Marco Pavone. Continuous meta-learning without tasks. arXiv preprint arXiv:1912.08866, 2019.   \n[34] Xu He, Jakub Sygnowski, Alexandre Galashov, Andrei A. Rusu, Yee Whye Teh, and Razvan Pascanu. Task agnostic continual learning via meta learning. ArXiv, abs/1906.05201, 2019.   \n[35] Xu He, Jakub Sygnowski, Alexandre Galashov, Andrei A Rusu, Yee Whye Teh, and Razvan Pascanu. Task agnostic continual learning via meta learning. arXiv preprint arXiv:1906.05201, 2019.   \n[36] Dan Hendrycks, Mantas Mazeika, and Thomas Dietterich. Deep anomaly detection with outlier exposure. arXiv preprint arXiv:1812.04606, 2018.   \n[37] Guillaume Hocquet, Olivier Bichler, and Damien Querlioz. Ova-inn: Continual learning with invertible neural networks. arXiv preprint arXiv:2006.13772, 2020.   \n[38] Sergey Ioffe and Christian Szegedy. Batch normalization: Accelerating deep network training by reducing internal covariate shift. In International conference on machine learning, pages 448–456. PMLR, 2015.   \n[39] David Isele and Akansel Cosgun. Selective experience replay for lifelong learning. In AAAI conference on artificial intelligence, 2018.   \n[40] Khurram Javed and Martha White. Meta-learning representations for continual learning. In Advances in Neural Information Processing Systems 32, pages 1820– 1830. Curran Associates, Inc., 2019. URL http://papers.nips.cc/paper/ 8458-meta-learning-representations-for-continual-learning.pdf.   \n[41] Ghassen Jerfel, Erin Grant, Tom Griffiths, and Katherine A Heller. Reconciling meta-learning and continual learning with online mixtures of tasks. In Advances in Neural Information Processing Systems, pages 9122–9133, 2019.   \n[42] Khimya Khetarpal, Matthew Riemer, Irina Rish, and Doina Precup. Towards continual reinforcement learning: A review and perspectives, 2020.   \n[43] Byungju Kim, Hyunwoo Kim, Kyungsu Kim, Sungjin Kim, and Junmo Kim. Learning not to learn: Training deep neural networks with biased data. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, pages 9012–9020, 2019.   \n[44] Diederik P. Kingma and Jimmy Ba. Adam: A method for stochastic optimization. In Yoshua Bengio and Yann LeCun, editors, 3rd International Conference on Learning Representations, ICLR 2015, San Diego, CA, USA, May 7-9, 2015, Conference Track Proceedings, 2015. URL http://arxiv.org/ abs/1412.6980.   \n[45] Diederik P Kingma and Max Welling. Auto-encoding variational bayes. arXiv preprint arXiv:1312.6114, 2013.   \n[46] James Kirkpatrick, Razvan Pascanu, Neil Rabinowitz, Joel Veness, Guillaume Desjardins, Andrei A Rusu, Kieran Milan, John Quan, Tiago Ramalho, Agnieszka Grabska-Barwinska, et al. Overcoming catastrophic forgetting in neural networks. Proceedings of the national academy of sciences, 114(13):3521–3526, 2017.   \n[47] Louis Kirsch, Julius Kunze, and David Barber. Modular networks: Learning to decompose neural computation. Advances in Neural Information Processing Systems, 31:2408–2418, 2018.   \n[48] Ivan Kobyzev, Simon Prince, and Marcus Brubaker. Normalizing flows: An introduction and review of current methods. IEEE Transactions on Pattern Analysis and Machine Intelligence, 2020.   \n[49] Alex Krizhevsky, Geoffrey Hinton, et al. Learning multiple layers of features from tiny images. Technical report, Citeseer, 2009.   \n[50] Brenden M Lake, Ruslan Salakhutdinov, and Joshua B Tenenbaum. Human-level concept learning through probabilistic program induction. Science, 350(6266):1332–1338, 2015.   \n[51] Yann LeCun and Corinna Cortes. MNIST handwritten digit database. 2010. URL http://yann. lecun.com/exdb/mnist/.   \n[52] Jeongtae Lee, Jaehong Yoon, Eunho Yang, and Sung Ju Hwang. Lifelong learning with dynamically expandable networks. CoRR, abs/1708.01547, 2017.   \n[53] Soochan Lee, Junsoo Ha, Dongsu Zhang, and Gunhee Kim. A neural dirichlet process mixture model for task-free continual learning. arXiv preprint arXiv:2001.00689, 2020.   \n[54] Timothée Lesort, Hugo Caselles-Dupré, Michael Garcia-Ortiz, Jean-François Goudou, and David Filliat. Generative Models from the perspective of Continual Learning. In International Joint Conference on Neural Networks (IJCNN), 2019.   \n[55] Timothée Lesort, Massimo Caccia, and Irina Rish. Understanding continual learning settings with data distribution drift analysis, 2021.   \n[56] Timothée Lesort, Thomas George, and Irina Rish. Continual learning in deep networks: an analysis of the last layer, 2021.   \n[57] Zhizhong Li and Derek Hoiem. Learning without forgetting. IEEE transactions on pattern analysis and machine intelligence, 40(12):2935–2947, 2017.   \n[58] Vincenzo Lomonaco, Lorenzo Pellegrini, Pau Rodríguez, Massimo Caccia, Qi She, Yu Chen, Quentin Jodelet, Ruiping Wang, Zheda Mai, David Vázquez, German Ignacio Parisi, Nikhil Churamani, Marc Pickett, Issam H. Laradji, and Davide Maltoni. Cvpr 2020 continual learning in computer vision competition: Approaches, results, current challenges and future directions. ArXiv, abs/2009.09929, 2020.   \n[59] Vincenzo Lomonaco, Lorenzo Pellegrini, Andrea Cossu, Antonio Carta, Gabriele Graffieti, Tyler L. Hayes, Matthias De Lange, Marc Masana, Jary Pomponi, Gido van de Ven, Martin Mundt, Qi She, Keiland Cooper, Jeremy Forest, Eden Belouadah, Simone Calderara, German I. Parisi, Fabio Cuzzolin, Andreas Tolias, Simone Scardapane, Luca Antiga, Subutai Amhad, Adrian Popescu, Christopher Kanan, Joost van de Weijer, Tinne Tuytelaars, Davide Bacciu, and Davide Maltoni. Avalanche: an end-to-end library for continual learning. In Proceedings of IEEE Conference on Computer Vision and Pattern Recognition, 2nd Continual Learning in Computer Vision Workshop, 2021.   \n[60] David Lopez-Paz and Marc’Aurelio Ranzato. Gradient episodic memory for continual learning. In Advances in Neural Information Processing Systems, pages 6467–6476, 2017.   \n[61] Kanika Madan, Nan Rosemary Ke, Anirudh Goyal, Bernhard Schölkopf, and Yoshua Bengio. Fast and slow learning of recurrent independent mechanisms. In International Conference on Learning Representations, 2021. URL https://openreview.net/forum?id=Lc28QAB4ypz.   \n[62] Michael McCloskey and Neal J Cohen. Catastrophic interference in connectionist networks: The sequential learning problem. In Psychology of learning and motivation, volume 24, pages 109–165. Elsevier, 1989.   \n[63] Jorge A Mendez and Eric Eaton. Lifelong learning of compositional structures. arXiv preprint arXiv:2007.07732, 2020.   \n[64] Martial Mermillod, Aurélia Bugaiska, and Patrick Bonin. The stability-plasticity dilemma: Investigating the continuum from catastrophic forgetting to age-limited learning effects. Frontiers in psychology, 4:504, 2013.   \n[65] Elliot Meyerson and Risto Miikkulainen. Beyond shared hierarchies: Deep multitask learning through soft layer ordering. arXiv preprint arXiv:1711.00108, 2017.   \n[66] Martin Mundt, Yong Won Hong, Iuliia Pliushch, and Visvanathan Ramesh. A wholistic view of continual learning with deep neural networks: Forgotten lessons and the bridge to active and open world learning, 2020.   \n[67] Martin Mundt, Steven Lang, Quentin Delfosse, and Kristian Kersting. Cleva-compass: A continual learning evaluation assessment compass to promote research transparency and comparability, 2021.   \n[68] Eric Nalisnick, Akihiro Matsukawa, Yee Whye Teh, Dilan Gorur, and Balaji Lakshminarayanan. Do deep generative models know what they don’t know? arXiv preprint arXiv:1810.09136, 2018.   \n[69] Yuval Netzer, Tao Wang, Adam Coates, Alessandro Bissacco, Bo Wu, and Andrew Y Ng. Reading digits in natural images with unsupervised feature learning. 2011.   \n[70] Cuong V. Nguyen, Yingzhen Li, Thang D. Bui, and Richard E. Turner. Variational continual learning. In International Conference on Learning Representations (ICLR), 2018.   \n[71] Alex Nichol, Joshua Achiam, and John Schulman. On first-order meta-learning algorithms. arXiv preprint arXiv:1803.02999, 2018.   \n[72] Fabrice Normandin, Florian Golemo, Oleksiy Ostapenko, Pau Rodriguez, Matthew D Riemer, Julio Hurtado, Khimya Khetarpal, Dominic Zhao, Ryan Lindeborg, Timothée Lesort, Laurent Charlin, Irina Rish, and Massimo Caccia. Sequoia: A software framework to unify continual learning research, 2021.   \n[73] Oleksiy Ostapenko, Mihai Puscas, Tassilo Klein, Patrick Jahnichen, and Moin Nabi. Learning to remember: A synaptic plasticity driven framework for continual learning. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, pages 11321–11329, 2019.   \n[74] Giambattista Parascandolo, Niki Kilbertus, Mateo Rojas-Carulla, and Bernhard Schölkopf. Learning independent causal mechanisms. In International Conference on Machine Learning, pages 4036–4044. PMLR, 2018.   \n[75] Judea Pearl. Causality. Cambridge university press, 2009.   \n[76] Jonas Peters, Dominik Janzing, and Bernhard Schölkopf. Elements of causal inference: foundations and learning algorithms. The MIT Press, 2017.   \n[77] Mohammad Pezeshki, Sékou-Oumar Kaba, Yoshua Bengio, Aaron Courville, Doina Precup, and Guillaume Lajoie. Gradient starvation: A learning proclivity in neural networks. arXiv preprint arXiv:2011.09468, 2020.   \n[78] Sylvestre-Alvise Rebuffi, Alexander Kolesnikov, Georg Sperl, and Christoph H Lampert. icarl: Incremental classifier and representation learning. In Computer Vision and Pattern Recognition (CVPR), 2017.   \n[79] Mengye Ren, Eleni Triantafillou, Sachin Ravi, Jake Snell, Kevin Swersky, Joshua B Tenenbaum, Hugo Larochelle, and Richard S Zemel. Meta-learning for semi-supervised few-shot classification. arXiv preprint arXiv:1803.00676, 2018.   \n[80] Danilo Rezende and Shakir Mohamed. Variational inference with normalizing flows. In International conference on machine learning, pages 1530–1538. PMLR, 2015.   \n[81] David Rolnick, Arun Ahuja, Jonathan Schwarz, Timothy Lillicrap, and Gregory Wayne. Experience replay for continual learning. In Advances in Neural Information Processing Systems, 2019.   \n[82] Clemens Rosenbaum, Ignacio Cases, Matthew Riemer, and Tim Klinger. Routing networks and the challenges of modular and compositional computation. arXiv preprint arXiv:1904.12774, 2019.   \n[83] Andrei A Rusu, Neil C Rabinowitz, Guillaume Desjardins, Hubert Soyer, James Kirkpatrick, Koray Kavukcuoglu, Razvan Pascanu, and Raia Hadsell. Progressive neural networks. arXiv preprint arXiv:1606.04671, 2016.   \n[84] B Schölkopf, D Janzing, J Peters, E Sgouritsa, K Zhang, and J Mooij. On causal and anticausal learning. In 29th International Conference on Machine Learning (ICML 2012), pages 1255–1262. International Machine Learning Society, 2012.   \n[85] Jonathan Schwarz, Jelena Luketina, Wojciech M Czarnecki, Agnieszka Grabska-Barwinska, Yee Whye Teh, Razvan Pascanu, and Raia Hadsell. Progress & compress: A scalable framework for continual learning. arXiv preprint arXiv:1805.06370, 2018.   \n[86] Joan Serra, Didac Suris, Marius Miron, and Alexandros Karatzoglou. Overcoming catastrophic forgetting with hard attention to the task. International Conference on Machine Learning (ICML), 2018.   \n[87] Joan Serra, Didac Suris, Marius Miron, and Alexandros Karatzoglou. Overcoming catastrophic forgetting with hard attention to the task. In International Conference on Machine Learning, pages 4548–4557. PMLR, 2018.   \n[88] Noam Shazeer, Azalia Mirhoseini, Krzysztof Maziarz, Andy Davis, Quoc Le, Geoffrey Hinton, and Jeff Dean. Outrageously large neural networks: The sparsely-gated mixture-of-experts layer, 2017.   \n[89] Andrea Soltoggio. Short-term plasticity as cause–effect hypothesis testing in distal reward learning. Biological cybernetics, 109(1):75–94, 2015.   \n[90] Olaf Sporns and Richard F Betzel. Modular brain networks. Annual review of psychology, 67:613–640, 2016.   \n[91] Saul Sternberg. Modular processes in mind and brain. Cognitive neuropsychology, 28(3-4):156–208, 2011.   \n[92] Tom Veniat, Ludovic Denoyer, and Marc’Aurelio Ranzato. Efficient continual learning with modular networks and task-driven priors. arXiv preprint arXiv:2012.12631, 2020.   \n[93] Johannes von Oswald, Dominic Zhao, Seijin Kobayashi, Simon Schug, Massimo Caccia, Nicolas Zucchet, and João Sacramento. Learning where to learn: Gradient sparsity in meta and continual learning. NeurIPS 2021, 2021.   \n[94] Yaqing Wang, Quanming Yao, James T Kwok, and Lionel M Ni. Generalizing from a few examples: A survey on few-shot learning. ACM Computing Surveys (CSUR), 53(3):1–34, 2020.   \n[95] Ziyu Wang, Bin Dai, David Wipf, and Jun Zhu. Further analysis of outlier detection with deep generative models. arXiv preprint arXiv:2010.13064, 2020.   \n[96] James CR Whittington and Rafal Bogacz. An approximation of the error backpropagation algorithm in a predictive coding network with local hebbian synaptic plasticity. Neural computation, 29(5):1229–1262, 2017.   \n[97] Chenshen Wu, Luis Herranz, Xialei Liu, Joost van de Weijer, Bogdan Raducanu, et al. Memory replay gans: Learning to generate new categories without forgetting. Advances in Neural Information Processing Systems, 31:5962–5972, 2018.   \n[98] Han Xiao, Kashif Rasul, and Roland Vollgraf. Fashion-mnist: a novel image dataset for benchmarking machine learning algorithms. arXiv preprint arXiv:1708.07747, 2017.   \n[99] Chen Zeno, Itay Golan, Elad Hoffer, and Daniel Soudry. Task agnostic continual learning using online variational bayes, 2018. ",
+        "bbox": [
+            171,
+            83,
+            828,
+            916
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            171,
+            56,
+            828,
+            920
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            171,
+            84,
+            828,
+            914
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            171,
+            66,
+            828,
+            921
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            171,
+            92,
+            828,
+            770
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "Acknowledgments and Disclosure of Funding ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            782,
+            553,
+            800
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "Laurent Charlin holds a CIFAR AI Chair Program and acknowledges support from Samsung Electronics Co., Ldt., Google, and NSERC. Massimo Caccia was supported through MITACS during his part time employment with Element AI the ServiceNow company. Massimo Caccia was also supported by Amazon, during his part time employment there. We would like to thank Mila and Compute Canada for providing computational resources. We also would like to thank Irina Rish for useful discussions. ",
+        "bbox": [
+            174,
+            814,
+            826,
+            883
+        ],
+        "page_idx": 14
+    }
+]

parse/train/jSz59N8NvUP/jSz59N8NvUP.md

@@ -0,0 +1,267 @@
+# RETRIEVE: Coreset Selection for Efficient and Robust Semi-Supervised Learning
+
+Krishnateja Killamsetty Xujiang Zhao Feng Chen Rishabh Iyer
+
+Department of Computer Science The University of Texas at Dallas Richardson, Texas, USA
+
+{krishnateja.killamsetty,xujiang.zhao,feng.chen,rishabh.iyer}@utdallas.edu
+
+# Abstract
+
+Semi-supervised learning (SSL) algorithms have had great success in recent years in limited labeled data regimes. However, the current state-of-the-art SSL algorithms are computationally expensive and entail significant compute time and energy requirements. This can prove to be a huge limitation for many smaller companies and academic groups. Our main insight is that training on a subset of unlabeled data instead of entire unlabeled data enables the current SSL algorithms to converge faster, significantly reducing computational costs. In this work, we propose RETRIEVE1, a coreset selection framework for efficient and robust semi-supervised learning. RETRIEVE selects the coreset by solving a mixed discrete-continuous bi-level optimization problem such that the selected coreset minimizes the labeled set loss. We use a one-step gradient approximation and show that the discrete optimization problem is approximately submodular, enabling simple greedy algorithms to obtain the coreset. We empirically demonstrate on several real-world datasets that existing SSL algorithms like VAT, Mean-Teacher, FixMatch, when used with RETRIEVE, achieve a) faster training times, b) better performance when unlabeled data consists of Out-of-Distribution (OOD) data and imbalance. More specifically, we show that with minimal accuracy degradation, RETRIEVE achieves a speedup of around $3 \times$ in the traditional SSL setting and achieves a speedup of $5 \times$ compared to state-of-the-art (SOTA) robust SSL algorithms in the case of imbalance and OOD data. RETRIEVE is available as a part of the CORDS toolkit: https://github.com/decile-team/cords.
+
+# 1 Introduction
+
+Deep learning algorithms have had great success over the past few years, often achieving human or superhuman performance in various tasks like computer vision [10], speech recognition [18], natural language processing [5], and video games [45]. One of the significant factors attributing to the recent success of deep learning is the availability of large amounts of labeled data [55]. However, creating large labeled datasets is often time-consuming and expensive in terms of costs. Moreover, some domains like medical imaging require a domain expert for labeling, making it nearly impossible to create a large labeled set. In order to reduce the dependency on the availability of labeled data, semi-supervised learning (SSL) algorithms [7] were proposed to train models using large amounts of unlabeled data along with the available labeled data. Recent works [42, 56, 4, 53] show that semi-supervised learning algorithms can achieve similar performance to standard supervised learning using significantly fewer labeled data instances.
+
+However, the current SOTA SSL algorithms are compute-intensive with large training times. For example, from our personal experience, training a WideResNet model [60] on a CIFAR10 [27] dataset with 4000 labels using the SOTA FixMatch algorithm [53] for 500000 iterations takes around four days on a single RTX2080Ti GPU. This also implies increased energy consumption and an associated carbon footprint [54]. Furthermore, it is common to tune these
+
+![](images/36462717557b89b7bb6548f8dd3c22326ea43e9cf8bb2619d18e303e29ba37f0.jpg)  
+Figure 1: (a )Unlabeled set with the same distribution as the labeled set, (b) Unlabeled set containing OOD instances, (c) Unlabeled set where the class distribution is imbalanced
+
+SSL algorithms over a large set of hyper-parameters, which means that the training needs to be done hundreds and sometimes thousands of times. For example, [44] performed hyperparameter tuning by running 1000 trails of Gaussian Process-based Blackbox optimization[16] for each SSL algorithm (which runs for 500000 iterations). This process implies significantly higher experimental turnaround times, energy consumption, and CO2 emissions. Furthermore, this is not something that can be done at most universities and smaller companies. The first problem we try to address in this work is: Can we efficiently train a semi-supervised learning model on coresets of unlabeled data to achieve faster convergence and reduction in training time?
+
+Despite demonstrating encouraging results on standard and clean datasets, current SSL algorithms perform poorly when OOD data or class imbalance is present in the unlabeled set [44, 8]. This performance degradation can be attributed to the fact that the current SSL algorithms assume that both the labeled set and unlabeled set are sampled from the same distribution. A visualization of OOD data and class imbalance in the unlabeled set is shown in Figure 1. Several recent works [59, 8, 17] were proposed to mitigate the effect of OOD in unlabeled data, in turn improving the performance of SSL algorithms. However, the current SOTA robust SSL method [17] is 3X slower than the standard SSL algorithms, further increasing the training times, energy costs, and CO2 emissions. The second problem we try to address in this work is: In the case where OOD data or class imbalance exists in the unlabeled set, can we robustly train an SSL model on coresets of unlabeled data to achieve similar performance to existing robust SSL methods while being significantly faster?
+
+![](images/01b3a40f43eb0a3156bdfa79e1d96e28aaf5c27fd312154845a27f5978e4f461.jpg)  
+Figure 2: Comparison of RETRIEVE with VAT, FixMatch, and MT on CIFAR-10 and SVHN: We contrast the accuracy degradation with speedup compared to the base SSL or robust SSL (DS3L) approach. We observe speedups of $3 \times$ in standard SSL case with $0 . 7 \%$ accuracy drop and $2 \times$ speedup with no accuracy drop. In the robust SSL case, we observe $5 \times$ speedup compared to DS3L [17] while outperforming it in terms of accuracy.
+
+To this end, we propose RETRIEVE, a coreset selection framework that enables faster convergence and robust training of SSL algorithms. RETRIEVE selects coreset of the unlabeled data resulting in minimum labeled set loss when trained upon in a semi-supervised manner. Intuitively, RETRIEVE tries to achieve faster convergence by selecting data instances from the unlabeled set whose gradients are aligned with the labeled set gradients. Furthermore, RETRIEVE also achieves distribution matching by selecting a coreset from the unlabeled set with similar gradients to the labeled set.
+
+# 1.1 Our Contributions
+
+The contributions are our work can be summarized as follows:
+
+• RETRIEVE Framework: We propose a coreset selection algorithm RETRIEVE for efficient and robust semi-supervised learning. RETRIEVE poses the coreset selection as a discrete-continuous bi-level optimization problem and solves it efficiently using an online approximation of single-step gradient updates. Essentially, RETRIEVE selects a coreset of the unlabeled set, which, when trained using the combination of the labeled set and the specific unlabeled data coreset, minimizes the model loss on the labeled dataset. We also discuss several implementation tricks to speed up the coreset selection step significantly $\cdot { c . f . }$ , Section 3.3, Section 3.4)
+
+• RETRIEVE in Traditional SSL: We empirically demonstrate the effectiveness of RETRIEVE in conjunction with several SOTA SSL algorithms like VAT, Mean-Teacher, and FixMatch. The speedups obtained by RETRIEVE are shown in Figure 2a. Specifically, we see that RETRIEVE consistently achieves close to $3 \times$ speedup with accuracy degradation of around $0 . 7 \%$ . RETRIEVE also achieves more than $4 . 2 \times$ speedup with a slightly higher accuracy degradation. Furthermore, when RETRIEVE is trained for more iterations, RETRIEVE can match the performance of VAT while having a $2 \times$ speedup (see VAT Extended bar plot in Figure 2a). RETRIEVE also consistently outperforms simple baselines like early stopping and random sampling.
+
+• RETRIEVE in Robust SSL: We further demonstrate the utility of RETRIEVE for robust SSL in the presence of OOD data and imbalance in the unlabeled set. We observe that with the VAT SSL algorithm, RETRIEVE outperforms SOTA robust SSL method DS3L [17] (with VAT) while being around $5 \times$ faster. RETRIEVE also significantly outperforms just VAT and random sampling.
+
+# 1.2 Related Work
+
+Semi-supervised learning: Several papers have been proposed for semi-supervised learning over the past few years. Due to space constraints, we do not talk about generative [50, 48, 26, 11, 19, 30, 3] and graph-based [62, 33] methods for SSL in this work. We instead focus on the main components of the existing SOTA SSL algorithms, viz., a) consistency regularization and b) entropy minimization. The consistency regularization component forces the model to have consistent prediction given an unlabeled data point and its perturbed (or augmented) version. The Entropy-minimization component forces the model instances to have low-entropy predictions on unlabeled data instances to ensure that the classes are well separated. One can achieve entropy minimization by directly adding the entropy loss component on the unlabeled class prediction or using methods like Pseudo-Labeling to enforce it implicitly. Mean-Teacher [56] approach uses a consistency regularization component that forces the predictions of the exponential moving average of the model to be the same as the model prediction of the augmented unlabeled images. VAT [42] instead computes the perturbation of the unlabeled data point that changes the prediction distribution the most and enforces the model to have the same prediction on both unlabeled data instance and unlabeled data instance with computed perturbation as a form of consistency regularization. MixMatch [4] uses $K$ standard image augmentations for consistency regularization and enforces entropy minimization by using a sharpening function on the average predicted distribution of $K$ augmentations of unlabeled data instances. FixMatch [53] induces consistency regularization by forcing the model to have the same prediction on a weakly augmented and strongly augmented image instance. Furthermore, FixMatch [53] also employs confidence thresholding to mask unlabeled data instances on which the model’s prediction confidence is below a threshold from being used in consistency loss.
+
+Robust Semi-supervised learning: Several methods have been proposed to make the existing semi-supervised learning algorithms robust to label noise in labeled data and robust to OOD data in the unlabeled set. A popular approach [49, 52] to deal with label noises and class imbalance in a supervised learning setting is by reweighing each data instance and jointly learning these weights along with the model parameters. Safe-SSL (DS3L) [17] is a recently proposed SOTA method for robust SSL learning. DS3L is similar to the reweighting in the supervised case and adopts a reweighting approach to deal with OOD data in the unlabeled set. Safe-SSL uses a neural network to predict the weight parameters of unlabeled instances that result in maximum labeled set performance, making it a bi-level optimization problem. In this regard, both RETRIEVE and Safe-SSL approach solves a bi-level optimization problem, except that RETRIEVE solves a discrete optimization problem at the outer level, thereby enabling significant speedup compared to SSL algorithms and an even more considerable speedup compared to safe-SSL (which itself is $3 \times$ slower than SSL algorithms). In contrast to safe-SSL and other robust SSL approaches, RETRIEVE achieves both efficiency and robustness. Other approaches for robust SSL include UASD [9] uses an Uncertainty aware self-distillation with OOD filtering to achieve robust performance and a distributionally robust model to deal with OOD [8].
+
+![](images/8f612b06fefb8df68ce87a482eaf42ad80ea1b7a73259a95f98cd09315cd54be.jpg)  
+Figure 3: Flowchart of RETRIEVE framework, where coreset selection is performed every $R$ epochs and the model is trained on the selected coreset.
+
+Coreset and subset selection methods: Coresets [13] are small and informative weighted data subsets that approximate original data. Several works [57, 39, 24, 23] have studied coresets for efficient training of deep learning models in the supervised learning scenarios. CRAIG [39] selects representative coresets of the training data that closely estimates the full training gradient. Another approach, GLISTER [24] posed the coreset selection as optimizing the validation set loss for efficient learning focused on generalization. Another approach, GRAD-MATCH [23] select subsets that approximately match the full training loss or validation loss gradient using orthogonal matching pursuit. Similarly, coreset selection methods [57, 51, 2, 24] were also used for active learning scenario, where a subset of data instances from the unlabeled set is selected to be labeled. Finally, several recent works have used submodular functions for finding diverse and representative subsets for data subset selection [34, 21, 57, 58].
+
+# 2 Preliminaries
+
+Notation: Denote to be the unlabele $\mathcal { D } = \{ x _ { i } , y _ { i } \} _ { i = 1 } ^ { n }$ to be the la points. Let eled set with be the class $n$ labeled data points, aer model parameters, $\mathcal { U } = \{ x _ { j } \} _ { j = 1 } ^ { m }$ $m$ $\theta$ $l _ { s }$ set loss function (such as cross-entropy loss) and $l _ { u }$ be the unlabeled set loss, e.g. consistencyregularization loss, entropy loss, etc.. Denote $L _ { S } ( \mathcal D , \theta ) = \sum _ { i \in \mathcal D } l _ { s } ( \theta , x _ { i } , y _ { i } )$ and $\bar { L } _ { U } ( \mathcal { U } , \theta , m ) \stackrel { \cdot } { = }$ $\sum _ { j \in \mathcal { U } } m _ { i } l _ { u } ( x _ { j } , \theta )$ where $m \in \{ 0 , 1 \} ^ { m }$ is the binary mask vector for unlabeled set. For notational convenience, we denote $l _ { s i } ( \theta ) = l _ { s } ( x _ { i } , y _ { i } , \theta )$ and denote $l _ { u j } ( \theta ) = l _ { u } ( x _ { j } , \theta )$ .
+
+Semi-supervised loss: Following the above notations, the loss function for many existing SSL algorithms can be written as $L _ { S } ( \bar { D } , \theta ) + \lambda L _ { U } ( \mathcal { U } , \theta , m )$ , where $\lambda$ is the regularization coefficient for the unlabeled set loss. For Mean Teacher [56], VAT[42], MixMatch [4], the mask vector $_ { \mathbf { \nabla } } \mathbf { m }$ is made up entirely of ones, whereas for FixMatch [53], $_ { m }$ is confidence-thresholded binary vector, indicating whether to include an unlabeled data instance or not. Usually, $L _ { S }$ is a cross-entropy loss for classification experiments and squared loss for regression experiments. A detailed formulation of the loss function $L _ { U }$ used in different SSL algorithms is given in Appendix C
+
+Robust Semi-supervised loss: However, for robust semi-supervised loss, the mask vector $_ { m }$ is replaced with a weight vector ${ \pmb w } \in \mathbb { R } ^ { m }$ denoting the contribution of data instances in the unlabeled set. The weight vector $\pmb { w }$ is unknown and needs to be learned. The weighted SSL loss is: $L _ { S } ( \mathcal { D } , \theta ) +$ $\lambda L _ { U } ( \mathcal { U } , \boldsymbol { \theta } , { \boldsymbol { w } } )$ , where $\lambda$ is the regularization coefficient for the unlabeled set loss.
+
+The state-of-the-art robust SSL method, Safe-SSL [17] poses the learning problem as:
+
+$$
+\overbrace { \pmb { w } ^ { * } = \operatorname { a r g m i n } _ { \pmb { w } } L _ { S } ( \mathcal { D } , \underbrace { \mathrm { a r g m i n } \left( L _ { S } ( \mathcal { D } , \theta ) + \lambda L _ { U } ( \mathcal { U } , \theta , w ) \right) } _ { \theta } ) } ^ { o u t e r - l e v e l }
+$$
+
+In order to solve the problem at the inner level efficiently, Safe-SSL [17] method uses a single-gradient step approximation to estimate the inner problem solution. The weight vector learning problem after the one-step approximation is: $\pmb { w } ^ { * } = \mathrm { a r g m i n } ~ L _ { S } ( \mathcal { D } , \pmb { \theta } - \alpha \nabla _ { \theta } L _ { S } ( \bar { \mathcal { D } } , \theta ) - \alpha \lambda \nabla _ { \theta } L _ { U } ( \bar { \mathcal { U } } , \theta , w )$
+
+Safe-SSL also uses a single-step gradient approximation to solve the outer level problem as well. As discussed before, the optimization problem of the Safe-SSL [17] algorithm involves continuous optimization at both inner and outer levels, whereas for RETRIEVE, the outer level involves a discrete optimization problem which makes it significantly faster than Safe-SSL.
+
+# 3 RETRIEVE framework
+
+In RETRIEVE, the coreset selection and classifier model learning on the selected coreset is performed in conjunction. As shown in the Figure 3, RETRIEVE trains the classifier model on the previously selected coreset for $R$ epochs in a semi-supervised manner, and every $R ^ { t h }$ epoch, a new coreset is selected, and the process is repeated until the classifier model reaches convergence, or the required number of epochs is reached. The vital feature of RETRIEVE is that the coresets selected are adapted with the training. Let $\theta _ { t }$ be the classifier model parameters and the $S _ { t }$ be the coreset at time step $t$ . Since coreset selection is done every $R$ epochs, we have ${ S } _ { t } = { S } _ { \lfloor t / R \rfloor }$ , or in other words, the subsets change only after $R$ epochs. The SSL loss function on the selected coreset at iteration $t$ is as follows:
+
+$$
+L _ { S } ( \mathcal { D } , \boldsymbol { \theta } _ { t } ) + \lambda _ { t } \sum _ { j \in \mathcal { S } _ { t } } m _ { j t } l _ { u } ( x _ { j } , \boldsymbol { \theta } _ { t } )
+$$
+
+where $\mathbf { \nabla } m _ { j t }$ is the mask binary value associated with the $j ^ { t h }$ point based on model parameters $\theta _ { t }$ and $\lambda _ { t }$ is the unlabeled loss coefficient at iteration $t$ . Note that objective function given in Equation (2) is dependent on the SSL algorithm used in RETRIEVE framework. If gradient descent is used for learning, the parameter update step from time step $t$ to $t + 1$ is as follows:
+
+$$
+\theta _ { t + 1 } = \theta _ { t } - \alpha _ { t } \nabla _ { \theta } L _ { S } ( \mathcal { D } , \theta _ { t } ) - \alpha _ { t } \lambda _ { t } \sum _ { j \in S _ { t } } m _ { j t } \nabla _ { \theta } l _ { u } ( x _ { j } , \theta _ { t } )
+$$
+
+where $\alpha _ { t }$ is the learning rate at iteration $t$ . The update step for mini-batch SGD is similar, just that it does the above on minibatches of the dataset.
+
+# 3.1 Problem Formulation
+
+The coreset selection problem of RETRIEVE at timestep $t$ is as follows:
+
+$$
+\overbrace { S _ { t } = \underbrace { \mathrm { \ a r g m i n } \ L _ { S } \Big ( \mathcal { D } , \underbrace { \mathrm { a r g m i n } \left( L _ { S } ( \mathcal { D } , \theta _ { t } ) + \lambda _ { t } \sum _ { j \in S } m _ { j t } l _ { u } ( x _ { j } , \theta _ { t } ) \right) } _ { i n n e r - l e v e l } } \Big ) } ^ { o u t e r - l e v e l }  \mathrm { ~ , ~ }
+$$
+
+where $k$ is the size of the coreset and $\mathbf { \nabla } m _ { j t }$ is the binary value associated with the $j ^ { t h }$ instance based on model parameters $\theta _ { t }$ . $k$ is a fraction of the entire dataset (e.g. $20 \%$ or $30 \%$ ), and the goal is to select the best subset of the unlabeled set, which maximizes the labeled loss based. The outer level of the above optimization problem is a discrete subset selection problem. However, solving the inner-optimization problem naively is computationally intractable, and, we need to make some approximations.
+
+# 3.2 One-Step Gradient Approximation
+
+To solve the inner optimization problem efficiently, RETRIEVE adopts a one-step gradient approximation based optimization method similar to [14, 49]. More specifically, RETRIEVE approximates the solution to the inner level problem by taking a single gradient step towards the descent direction of the loss function. The idea here is to jointly optimize the model parameters and the subset as the learning proceeds. After this approximation, the coreset selection optimization problem becomes:
+
+$$
+{ \mathcal { S } } _ { t } = \operatorname * { a r g m i n } _ { S \subseteq { \mathcal { U } } : | S | \leq k } L _ { S } ( { \mathcal { D } } , \theta _ { t } - \alpha _ { t } \nabla _ { \theta } L _ { S } ( { \mathcal { D } } , \theta _ { t } ) - \alpha _ { t } \lambda _ { t } \sum _ { j \in S } m _ { j t } \nabla _ { \theta } l _ { u } ( x _ { j } , \theta _ { t } ) )
+$$
+
+However, even after this approximation, the above optimization problem (Equation (5)) is NP-hard.
+
+Theorem 1 Optimization problem (Equation (5)) is NP hard, even if $\mathit { l } _ { s }$ is a convex loss function. If the labeled set loss function $l _ { s }$ is cross-entropy loss, then the optimization problem give in the Equation (5) can be converted into an instance of cardinality constrained weakly submodular maximization.
+
+The proof is given in Appendix B. The given Theorem 1 holds as long as $l _ { s }$ is a cross-entropy loss irrespective of the form of $l _ { u }$ . Further, Theorem 1 implies that the optimization problem given in Equation (5) can be solved efficiently using greedy algorithms [37, 38] with approximation guarantees. RETRIEVE uses stochastic-greedy algorithm [22, 38] to solve the optimization problem Equation (5) with an approximation guarantee of $1 - 1 / e ^ { \beta } - \epsilon$ in $\mathcal { O } ( m \log ( 1 / \epsilon ) )$ iterations where $m$ is the unlabeled set size and $\beta$ is the weak submodularity coefficient (see Appendix B). And the set function used in stochastic greedy algorithm is as follows:
+
+$$
+f ( \theta _ { t } , S ) = - L _ { S } ( \mathcal { D } , \theta _ { t } - \alpha _ { t } \nabla _ { \theta } L _ { S } ( \mathcal { D } , \theta _ { t } ) - \alpha _ { t } \lambda _ { t } \sum _ { j \in S } m _ { j t } \nabla _ { \theta } l _ { u } ( x _ { j } , \theta _ { t } ) )
+$$
+
+Notice that during each greedy iteration, we need to compute the set function value $f ( \theta _ { t } , S \cup e )$ to find the maximal gain element $e$ that can be added to the set $s$ . This implies that the loss over the entire labeled set needs to be computed multiple times for each greedy iteration, making the entire greedy selection algorithm computationally expensive.
+
+# 3.3 RETRIEVE Algorithm
+
+To make the greedy selection algorithm efficient, we approximate the set function value $f ( \theta _ { t } , S \cup e )$ with the first two terms of it’s Taylor-series expansion Let, $\theta ^ { S } \ = \ \theta _ { t } \ - \ \alpha _ { t } \nabla _ { \theta } \bar { L _ { S } } ( { \mathcal D } , \theta _ { t } ) \ -$ $\alpha _ { t } \lambda _ { t } \sum _ { j \in S } m _ { j t } \nabla _ { \theta } l _ { u } ( x _ { j } , \theta _ { t } )$ . The modified set function value with Taylor-series approximation is as follows:
+
+$$
+\hat { f } ( \theta _ { t } , S \cup e ) = - L _ { S } ( \mathcal { D } , \theta ^ { S } ) + \alpha _ { t } \lambda _ { t } \nabla _ { \theta } L _ { S } \big ( \mathcal { D } , \theta ^ { S } \big ) ^ { T } m _ { e t } \nabla _ { \theta } l _ { u } \big ( x _ { e } , \theta _ { t } \big )
+$$
+
+where ${ \mathbf { } } m _ { e t }$ is the binary mask value associated with element $e$ . Note that the term $m _ { e t } \nabla _ { \boldsymbol { \theta } } l _ { \underline { { u } } } ( x _ { e } , \theta _ { t } )$ can be precomputed at the start of the greedy selection algorithm, and the term $\nabla _ { \theta } L _ { S } ( \mathcal { D } , \theta ^ { S } )$ needs to be computed only once every greedy iteration, thereby reducing the computational complexity of the greedy algorithm.
+
+A detailed pseudo-code of the RETRIEVE algorithm is given in Algorithm 1. RETRIEVE uses a greedy selection algorithm for coreset selection, and the detailed pseudo-code of the greedy algorithm is given in Algorithm 2. RETRIEVE can be easily implemented with popular deep learning frameworks [47, 1] that provide auto differentiation functionalities. In all our experiments, we set $R = 2 0$ , i.e., we update the coreset every 20 epochs.
+
+# Algorithm 1: RETRIEVE Algorithm
+
+# 3.4 Additional Implementation Details:
+
+In this subsection, we discuss additional implementational and practical tricks to make RETRIEVE scalable and efficient.
+
+Input: Labeled Set: $\left\{ \lambda _ { t } \right\} _ { t = 0 } ^ { t = T - 1 }$ $\mathcal { D }$ , Learning rates: , Unlabeled Set: $\{ \alpha _ { t } \} _ { t = 0 } ^ { t = T - 1 }$ $\boldsymbol { u }$ , Reg. Coefficients:   
+Input: Total no of epochs: , Epoch interval for subset selection: $R$ , Size of the coreset: $k$   
+Set $t = 0$ ; Randomly initialize model parameters $\theta _ { 0 }$ and coreset   
+$S _ { 0 } \subseteq \mathcal { U } : | S _ { 0 } | = k$ ;   
+repeat if ( $t \% R = = 0$ ) ∧ $( t > 0 )$ ) then St = GreedySelectio $( \mathcal { D } , \mathcal { U } , \theta _ { t } , \lambda _ { t } , \alpha _ { t } , k )$ else $\_ S { _ t } = S _ { { t - 1 } }$ Compute batches $\mathcal { D } _ { b } = ( ( x _ { b } , y _ { b } ) ; b \in ( 1 \cdot \cdot \cdot B ) )$ from $\mathcal { D }$ Compute batches $S _ { t b } = ( ( x _ { b } ) ; b \in ( 1 \cdot \cdot \cdot B ) )$ from $s$ $^ { * * }$ Mini-batch SGD \*\*\* Set $\theta _ { t 0 } = \theta _ { t }$ for $b = 1$ to $B$ do Compute mask $^ { m _ { t } }$ on $\boldsymbol { S } _ { t b }$ from current model parameters $\theta _ { t ( b - 1 ) }$ $\begin{array} { r } { \boldsymbol { \theta } _ { t b } ^ { \ast } = \boldsymbol { \theta } _ { t ( b - 1 ) } - \alpha _ { t } \nabla _ { \theta } L _ { S } ( \mathcal { D } _ { b } , \boldsymbol { \theta } _ { t } ) - } \end{array}$ αtλt P mjt∇θlu(xj , θt(b − 1)) j∈Stb Set θt+1 = θtB t = t + 1   
+until t ≥ T   
+return θT , ST
+
+Last-layer gradients. Computing the gradients over deep models is time-consuming due to an enormous number of parameters in the model. To address this issue, we adopt a last-layer gradient approximation similar to [2, 39, 24, 23] by
+
+only considering the last classification layer gradients of the classifier model in RETRIEVE. By simply using the last-layer gradients, we achieve significant speedups in RETRIEVE.
+
+Warm-starting data selection: We warm start the classifier model by training it on the entire unlabeled dataset for a few epochs similar to [23]. Warm starting allows the classifier model to have a good starting point to provide informative loss gradients used for coreset selection. More specifically, we train the classifier model on the entire unlabeled set for $\begin{array} { r } { T _ { w } = \frac { \kappa T k } { m } } \end{array}$ epochs where $k$ is coreset size, $T$ is the total number of epochs, $\kappa$ is the fraction of warm start, and $m$ is the size of the unlabeled set. To be fair, we consider all baselines in the standard SSL setting with the same warm start.
+
+![](images/2b8bc3895048c9c9c8db1d4c6dced3334aab1aca3500f15b23687765b6a84924.jpg)  
+Figure 4: A comparison of RETRIEVE with baselines (RANDOM, CRAIG, FULL, and FULLEARLYSTOP in the traditional SSL setting. SpeedUp vs Accuracy Degradation, both compared to SSL for (a) VAT on CIFAR-10, (b) VAT on SVHN, (c) FixMatch on CIFAR-10, (d) MT on CIFAR-10, and (e) MT on SVHN. We observe that RETRIEVE significantly outperforms existing baselines in terms of accuracy degradation and speedup tradeoff compared to SSL. Plot (f) also compares the CO2 emissions among the different approaches on FixMatch, showing again that RETRIEVE achieves the best energy-accuracy tradeoff. Plots (g) and (h) are the convergence results comparing accuracy with the time taken. Again, we see that RETRIEVE achieves much faster convergence than all baselines and full training.
+
+# 3.5 Epochs vs. Iterations
+
+Most of the existing SSL algorithms are trained using a fixed number of iterations instead of epochs. However, for easier comprehension of the RETRIEVE algorithm, we use the epoch notation in our work. A single epoch here meant a pass over random mini-batches of data points, such that the total number of data points encountered is equal to the size of the coreset of the unlabeled data. For example, if the unlabeled set size is 50000 and the unlabeled batch size is 50, then a single epoch over $100 \%$ , $50 \%$ , and $30 \%$ subsets are equivalent to 1000, 500, and 300 iterations, respectively.
+
+# Algorithm 2: GreedySelection
+
+Input: Labeled Set: $\mathcal { D }$ , Unlabeled Set: $\boldsymbol { u }$ , Model Parameters: $\theta _ { t }$ , Learning rate: $\alpha _ { t }$   
+Input: Regularization Coefficient: $\lambda _ { t }$ , Budget: $k$   
+Initialize $s _ { t } = \emptyset$   
+Set $m = | \mathcal { U } |$   
+Compute mask values $_ { \pmb { m } }$ based on current model parameters $\theta _ { t }$   
+for $e \in { \mathcal { U } }$ do   
+Compute $\theta _ { e } = m _ { e } \nabla _ { \theta } l _ { u } \big ( x _ { e } , \theta _ { t } \big )$   
+for $i = 1$ to $k$ do Compute $\theta ^ { S } =$ $\boldsymbol { \theta } _ { t } ^ { \star } - \alpha _ { t } \nabla _ { \theta } L _ { S } ( \mathcal { D } , \boldsymbol { \theta } _ { t } ) - \alpha _ { t } \lambda _ { t } \sum _ { j \in S } \boldsymbol { m } _ { j t } \nabla _ { \theta } l _ { u } ( x _ { j } , \boldsymbol { \theta } _ { t } )$ Compute $\nabla _ { \theta } L _ { S } ( \mathcal { D } , \theta ^ { S } )$ $V \sim$ Sample $\lceil m l o g ( 1 / \epsilon ) \rceil$ instances from $\boldsymbol { u }$ be $s t - g a i n = - \infty$ for $e \in V$ do Compute gain ${ \hat { g } } ( e ) =$ $\alpha _ { t } \lambda _ { t } \nabla _ { \theta } L _ { S } { \left( \mathcal { D } , \theta ^ { S } \right) } ^ { T } \mathbf { m } _ { e } \nabla _ { \theta } l _ { u } { \left( x _ { e } , \theta _ { t } \right) }$ if gˆ(e) > best − gain then Set s = e Set best − gain = ˆg(e) St = St ∪ s U = U \ s   
+return $s _ { t }$
+
+# 4 Experiments
+
+Our experimental section aims to verify the efficiency and effectiveness of RETRIEVE by evalu
+
+ating RETRIEVE through three semi-supervised learning scenarios a) traditional SSL scenario with clean data, b) robust SSL with OOD, and c) robust SSL with class imbalance, to demonstrate the efficiency and the robustness of RETRIEVE. Furthermore, our work’s experimental scenarios are very relevant in terms of research and real-world applications. We have implemented the RETRIEVE algorithmic framework using PyTorch [46]. We repeat the same experiment for three runs with different initialization and report the mean test accuracies in our plots. A detailed table with both mean test accuracy and the standard deviations was given in Appendix (G, H). For a fair comparison, we use the same random seed in each trial for all methods. We explain implementation details, datasets, and baselines used in each scenario in the following subsections.
+
+Baselines in each setting. In this section, we discuss baselines that are used in all the scenarios considered. We begin with the traditional SSL scenario. In this setting, we run RETRIEVE (and all baselines) with warm-start. We incorporate RETRIEVE with three representative SSL methods, including Mean Teacher (MT) [56], Virtual Adversarial Training (VAT) [42] and FixMatch [53]. The baselines considered are RANDOM (where we just randomly select a subset of unlabeled data points of the same size as RETRIEVE), CRAIG [39, 23] and FULL-EARLYSTOP. CRAIG [39, 23] was actually proposed in the supervised learning scenario. We adapt it to SSL by choosing a representative subset of unlabeled points such that the gradients are similar to the unlabeled loss gradients. We run the per-batch variant of CRAIG proposed in [23], where we select a subset of mini-batches instead of data instances for efficiency and scalability. Similarly, we use the per-batch version of GRADMATCH proposed in [23] adapted to SSL setting as another baseline. For more information on the formulation of CRAIG and GRADMATCH in the SSL case, see Appendix D, E. Again, we emphasize that RANDOM, CRAIG, and GRADMATCH are run with early stopping for the same duration as RETRIEVE. In FULL-EARLYSTOP baseline, we train the model on the entire unlabeled set for the time taken by RETRIEVE and report the test accuracy. In the traditional SSL scenario, we use warm variants of RETRIEVE, RANDOM, CRAIG for SSL training because warm variants are better in accuracy and efficiency compared to not performing warm start – see Appendix G for a careful comparison of both. Robust SSL with OOD and Imbalance: In the robust learning scenario for both OOD and imbalance, we analyze the performance of RETRIEVE with the VAT [42] algorithm. Note that for the Robust SSL scenario, we do not warm start the model by training for a few iterations on the full unlabeled set because training on an entire unlabeled set(containing OOD or class imbalance) creates a biased model due to a distribution mismatch between labeled set and unlabeled set. We empirically compare not warm starting the model with warm starting in Appendix H. In the robust SSL case, we compare RETRIEVE with two robust SSL algorithms DS3L [17] and L2RW [49]. DS3L (also called Safe-SSL) is a robust learning approach using a meta-weight network proposed specifically for robust SSL. We adapt L2RW(Learning to Reweight), originally proposed for robust supervised learning, to the SSL case and use it as a baseline. Similarly, we adapt the robust coreset selection method CRUST [40] originally proposed to tackle noisy labels scenario in supervised learning to SSL setting and use it as a baseline in Robust SSL scenario.
+
+Datasets, Model architecture and Experimental Setup: We begin by providing details common across the three scenarios. We perform experiments on the following image classification datasets: CIFAR-10 [28] (60000 instances), SVHN [43] (99289 instances) and the following sentiment analysis datasets: IMDB $[ 3 6 ] ^ { 2 }$ (10000 instances), and ELEC $[ 2 0 ] ^ { 3 }$ (246714 instances) datasets. We use a modified version of the ELEC dataset where the duplicate sentences are removed. For CIFAR-10, we use a labeled set of 4000 instances with 400 instances from each class, an unlabeled set of 50000 instances, a test set of 10000 instances. For SVHN, we used a labeled set of
+
+![](images/bd28cdf21835c75d0dba7b8e63b28e68453c2829ff7cffd08ea7edd112509f93.jpg)  
+Figure 5: Performance comparison of RETRIEVE vs Bayesian Coreset using VAT for $20 \%$ and $30 \%$ CIFAR10 subsets
+
+1000 instances with 100 instances from each class, an unlabeled set of 73257 instances, a test set of 26032 instances. For IMDB and ELEC datasets, we use the labeled and unlabeled splits following the work [41]. For CIFAR10 and SVHN datasets, we use the Wide-ResNet-28-2 [60] model that is commonly used in SSL [44, 53]. For MNIST, we use a variant of LeNet [31] (see Appendix F for details). For IMDB and ELEC datasets, we use a model comprising of Word Embedding layer, LSTM model, and two-layer MLP model following the architecture given in the work [41]. Similar to the work [41], we initialize the embedding matrix and LSTM model weights using a pretrained recurrent language model using both the labeled and unlabeled data. For Image datasets, with RETRIEVE(and baselines like RANDOM, GRADMATCH and CRAIG), we use the Nesterov’s accelerated SGD optimizer with a learning rate of 0.03, weight decay of 5e-4, the momentum of 0.9, and a cosine annealing [35] learning rate scheduler for all the experiments. For the FULL and FULLEARLYSTOP, we use the Adam optimizer [25] and follow the experimental setting from the SSL papers [53, 42, 56].
+
+For Text datasets, with RETRIEVE(and baselines like RANDOM, GRADMATCH and CRAIG), we set the hyperparameter values following the work [41]. Similarly, for the robust SSL baselines, we use the settings from the corresponding papers [17]. For all our experiments using image datasets, we use a batch size of 50 for labeled and unlabeled sets. Next, we discuss the specific settings for the traditional SSL scenario. For CIFAR10, we train the model for 500 epochs, and for SVHN, we train the model for 340 epochs on an unlabeled set. Note that we mention the epochs here because the number of iterations depends on the size of the unlabeled sets since that would determine the number of mini-batches. For a fair comparison, we train all algorithms for a fixed number of epochs. Next, we look at robust SSL for OOD. In this scenario, we consider the presence of OOD in the unlabeled set. We introduce OOD into CIFAR-10 following [44], by adapting it to a 6-class dataset, with 400 labels per class (from the 6 animal classes) as ID and rest of the classes as OOD (ID classes are: "bird", "cat", "deer", "dog", "frog", "horse", and OOD data are from classes: "airline", "automobile", "ship", "truck"). Similarly, we adapt MNIST [32] to a 6-class dataset, with classes 1-6 as ID and classes 7-10 as OOD. We denote the OOD rat $\scriptstyle \mathrm { i o } = { \mathcal { U } } _ { o o d } / ( { \mathcal { U } } _ { o o d } + { \mathcal { U } } _ { i n } )$ where $\mathcal { U } _ { i n }$ is ID unlabeled set, $\mathcal { U } _ { o o d }$ is OOD unlabeled set. For CIFAR10, we use a labeled set of 2400 instances and an unlabeled set of 20000 instances, and for MNIST, we use a labeled set of 60 instances and an unlabeled set of 30000 instances. Finally, for robust SSL for class imbalance, we consider imbalance both in the labeled set and unlabeled set. We introduce imbalance into the CIFAR-10 dataset by considering classes 1-5 as imbalanced classes and a class imbalance ratio. The class imbalance ratio is defined as the ratio of instances from classes 1-5 and the number of instances from classes 6-10. For CIFAR-10, we use a labeled set of 2400 and an unlabeled set of 20000 instances.
+
+Traditional SSL Results: The results comparing the accuracyefficiency tradeoff between the different subset selection approaches are shown in Figure 4. We compare the performance for different subset sizes of the unlabeled data: $10 \%$ , $20 \%$ , and $30 \%$ and three representative SSL algorithms VAT, Mean-Teacher, and FixMatch. For warm-start, we set kappa value to $\kappa \ : \ : = \ : \ : 0 . 5$ (i.e., training for $50 \%$ epochs on the entire unlabeled set and $50 \%$ using coresets). Our experiments use a $R$ value of 20 (i.e., coreset selection every 20 epochs). Sub-figures(4a, 4b, 4d, 4e,
+
+![](images/ab983e7608a0cd9e8df35bcb966d3f574bdd62cc254254795b5a19f77059b08d.jpg)  
+Figure 6: A comparison of RETRIEVE with baselines (RANDOM, CRAIG, GRADMATCH, FULL, and FULLEARLYSTOP in the traditional SSL setting for text datasets. SpeedUp vs Accuracy Degradation, both compared to SSL for (a) VAT on $30 \%$ IMDB, (b) VAT on $30 \%$ ELEC.
+
+4c) shows the plots of relative error vs speedup, both w.r.t full training (i.e., original SSL algorithm). Sub-figure 4f shows the plot of relative error vs CO2 emissions efficiency, both w.r.t full training. CO2 emissions were estimated based on the total compute time using the Machine Learning Impact calculator presented in [29]. From the results, it is evident that RETRIEVE achieved the best speedup vs. accuracy tradeoff and is environmentally friendly based on CO2 emissions compared to other baselines (including CRAIG and FULLEARLYSTOP). In particular, RETRIEVE achieves speedup gains of $2 . 7 \mathbf { x }$ and $4 . 4 \times$ with a performance loss of $0 . 7 \%$ and $0 . 3 \%$ using VAT on CIFAR10 and SVHN datasets. Further, RETRIEVE achieves speedup gains of $2 . 9 \mathbf { x }$ , $3 . 2 \mathrm { x }$ with a performance loss of $0 . 0 2 \%$ and $0 . 5 \%$ using Mean-Teacher on CIFAR10 and SVHN datasets. Additionally, RETRIEVE achieves a speedup of $3 . 8 \mathrm { x }$ with a performance loss of $0 . 7 \%$ using FixMatch on the CIFAR10 dataset. Sub-figures(6a, 6b) shows the plots of relative error vs speedup both w.r.t full training (i.e., original SSL algorithm) on IMDB and ELEC datasets for $30 \%$ subset size. In particular, RETRIEVE achieves speedup gains of $2 . 6 8 \mathrm { x }$ and $2 . 5 \mathrm { x }$ with a performance loss of $0 . 5 \%$ and $0 . 6 \%$ for $30 \%$ subset of IMDB and ELEC datasets. Figure 5 shows the results comparing the BAYESIANCORESET method [6], adapted to the SSL setting with RETRIEVE using the VAT algorithm for $20 \%$ and $30 \%$ CIFAR10 subsets. The results show that RETRIEVE achieves better performance than the SSL extension of the BAYESIANCORESET selection method in terms of model performance and speedup. One possible explanation for it is that the BAYESIANCORESET approach was not developed for efficient learning but instead was developed to capture coresets that try to represent the log-likelihood of the entire dataset that MCMC methods can further use. We would also like to point out that we used the original code implementation of BAYESIANCORESET that is not meant for GPU usage in our experiments. Hence the speedups of the BAYESIANCORESET approach can be further improved with efficient code implementation. Subfigure 4h shows that RETRIEVE achieves faster convergence compared to all other methods on CIFAR10 for $30 \%$ subset with Mean-Teacher. Subfigure $4 \mathrm { g }$ shows the extended convergence of RETRIEVE on CIFAR10 for $20 \%$ and $30 \%$ subsets using VAT, where the RETRIEVE is allowed to train for larger epochs to achieve comparable accuracy with Full training at the cost of losing some efficiency. Note that the points marked by \* in subfigure $4 \mathrm { g }$ denote the actual training endpoint, i.e. the usual number of epochs/iterations used to obtain points in subfigures (4a, 4b, 4d, 4e, 4c). We observe that RETRIEVE matches the performance of VAT while being close to $2 \times$ faster in running times (and correspondingly energy efficiency). We repeat this experiment with MT in the Appendix G. Also, more detailed results with additional convergence plots and tradeoff curves are in Appendix G.
+
+![](images/40ab1abc6353dc009e6215522df2f222c2e4246b190684a7cc4f972009903ee1.jpg)  
+Figure 7: Subfigures (a) to (c) compare the performance of RETRIEVE with baselines (including DS3L and L2RW) for different OOD ratios (a,b) and imbalance ratios (c). We see that RETRIEVE outperforms both baselines in most of the cases. Furthermore, RETRIEVE achieves this while being close to $2 \times$ faster than VAT (the SSL algorithm) and $5 \times$ faster than the robust SSL algorithms (DS3L and L2RW).
+
+Robust SSL Results: We test the performance of RETRIEVE on CIFAR10 and MNIST datasets with OOD in the unlabeled set and CIFAR10 dataset with the class imbalance in both labeled and unlabeled sets. sub-figures 7a, 7b shows the accuracy plots of RETRIEVE for different OOD ratios of $2 5 \%$ , $50 \%$ and $7 5 \%$ . The results show that RETRIEVE with VAT outperforms all other baselines, including DS3L [17], a state-of-the-art robust SSL baseline in the OOD scenario. Next, sub-figure 7c shows the accuracy plots of RETRIEVE for different class imbalance ratios of $10 \%$ , $30 \%$ and $50 \%$ on CIFAR10 dataset. The results show that RETRIEVE with VAT outperforms all other baselines, including DS3L [17] (also run with VAT) in the class imbalance scenario as well. In particular, RETRIEVE outperforms other baselines by at least $1 . 5 \%$ on the CIFAR-10 with imbalance. Sub-figure 7d shows the time taken by different algorithms on the CIFAR10 dataset with a $50 \%$ class imbalance ratio. The results show that CRUST did not perform well in terms of accuracy and speedups achieved compared to RETRIEVE. Except for MixUP, CRUST is similar to CRAIG, which did not perform well compared to RETRIEVE in a traditional SSL setting. Furthermore, the performance gain due to MixUP for coreset selection in the SSL setting is minimal. The minimal gain can be attributed to the fact that the hypothesized labels used for MixUP in the earlier stages of training are noisy. Furthermore, as stated earlier, CRUST was developed to tackle noisy labels in a supervised learning setting and is not developed to deal with OOD or Class Imbalance in general. The results show that RETRIEVE is more efficient compared to the other baselines. In particular, RETRIEVE is $5 \mathbf { x }$ times faster compared to DS3L method. Other detailed results (tradeoff curves and convergence curves) are in Appendix $_ \mathrm { H }$ .
+
+# 5 Conclusion and Broader Impacts
+
+We introduce RETRIEVE, a discrete-continuous bi-level optimization based coreset selection method for efficient and robust semi-supervised learning. We show connections with weak-submodularity, which enables the coreset selection in RETRIEVE to be solved using a scalable stochastic greedy algorithm. Empirically, we show that RETRIEVE is very effective for SSL. In particular, it achieves $3 \times$ speedup on a range of SSL approaches like VAT, MT, and FixMatch with around $0 . 7 \%$ accuracy loss and a $2 \times$ speedup with no accuracy loss. In the case of robust SSL with imbalance and OOD data, RETRIEVE outperforms existing SOTA methods while being $5 \times$ faster. We believe RETRIEVE has a significant positive societal impact by making SSL algorithms (specifically robust SSL) significantly faster and more energy-efficient, thereby reducing the CO2 emissions incurred during training.
+
+# 6 Acknowledgments and Disclosure of Funding
+
+We would like to thank NeurIPS area chairs and anonymous reviewers for their efforts in reviewing this paper and their constructive comments! RI and KK were funded by the National Science Foundation(NSF) under Grant Number 2106937, a startup grant from UT Dallas, and a Google and Adobe research award. FC and XZ were funded by National Science Foundation(NSF) under Grant Numbers 1815696, 1750911, and 2107449. Any opinions, findings, and conclusions or recommendations expressed in this material are those of the author(s) and do not necessarily reflect the views of the National Science Foundation, Google or Adobe.
+
+# References
+
+[1] M. Abadi, P. Barham, J. Chen, Z. Chen, A. Davis, J. Dean, M. Devin, S. Ghemawat, G. Irving, M. Isard, M. Kudlur, J. Levenberg, R. Monga, S. Moore, D. G. Murray, B. Steiner, P. Tucker, V. Vasudevan, P. Warden, M. Wicke, Y. Yu, and X. Zheng. Tensorflow: A system for largescale machine learning. In 12th USENIX Symposium on Operating Systems Design and Implementation (OSDI 16), pages 265–283, 2016.   
+[2] J. T. Ash, C. Zhang, A. Krishnamurthy, J. Langford, and A. Agarwal. Deep batch active learning by diverse, uncertain gradient lower bounds. In International Conference on Learning Representations, 2020.   
+[3] M. Belkin and P. Niyogi. Laplacian eigenmaps and spectral techniques for embedding and clustering. In Proceedings of the 14th International Conference on Neural Information Processing Systems: Natural and Synthetic, NIPS’01, page 585–591, Cambridge, MA, USA, 2001. MIT Press.   
+[4] D. Berthelot, N. Carlini, I. Goodfellow, N. Papernot, A. Oliver, and C. Raffel. Mixmatch: A holistic approach to semi-supervised learning, 2019.   
+[5] O. Bojar, R. Chatterjee, C. Federmann, M. Fishel, Y. Graham, B. Haddow, M. Huck, A. JimenoYepes, P. Koehn, A. Martins, C. Monz, M. Negri, A. Névéol, M. L. Neves, M. Post, M. Turchi, and K. Verspoor, editors. Proceedings of the Fourth Conference on Machine Translation, WMT 2019, Florence, Italy, August 1-2, 2019 - Volume 1: Research Papers. Association for Computational Linguistics, 2019.   
+[6] T. Campbell and T. Broderick. Bayesian coreset construction via greedy iterative geodesic ascent. In J. Dy and A. Krause, editors, Proceedings of the 35th International Conference on Machine Learning, volume 80 of Proceedings of Machine Learning Research, pages 698–706. PMLR, 10–15 Jul 2018.   
+[7] O. Chapelle, B. Schlkopf, and A. Zien. Semi-Supervised Learning. The MIT Press, 1st edition, 2010.   
+[8] K. Chen, L. Yao, D. Zhang, X. Chang, G. Long, and S. Wang. Distributionally robust semisupervised learning for people-centric sensing. In Proceedings of the AAAI Conference on Artificial Intelligence, volume 33, pages 3321–3328, 2019.   
+[9] Y. Chen, X. Zhu, W. Li, and S. Gong. Semi-supervised learning under class distribution mismatch. Proceedings of the AAAI Conference on Artificial Intelligence, 34(04):3569–3576, Apr. 2020.   
+[10] D. Cire¸san, U. Meier, and J. Schmidhuber. Multi-column deep neural networks for image classification, 2012.   
+[11] A. Coates and A. Y. Ng. The importance of encoding versus training with sparse coding and vector quantization. In Proceedings of the 28th International Conference on International Conference on Machine Learning, ICML’11, page 921–928, Madison, WI, USA, 2011. Omnipress.   
+[12] A. Das and D. Kempe. Submodular meets spectral: Greedy algorithms for subset selection, sparse approximation and dictionary selection. In Proceedings of the 28th International Conference on International Conference on Machine Learning, ICML’11, page 1057–1064, Madison, WI, USA, 2011. Omnipress.   
+[13] D. Feldman. Core-sets: Updated survey. In Sampling Techniques for Supervised or Unsupervised Tasks, pages 23–44. Springer, 2020.   
+[14] C. Finn, P. Abbeel, and S. Levine. Model-agnostic meta-learning for fast adaptation of deep networks. In International Conference on Machine Learning, pages 1126–1135. PMLR, 2017.   
+[15] K. Gatmiry and M. Gomez-Rodriguez. On the network visibility problem. CoRR, abs/1811.07863, 2018.   
+[16] D. Golovin, B. Solnik, S. Moitra, G. Kochanski, J. E. Karro, and D. Sculley, editors. Google Vizier: A Service for Black-Box Optimization, 2017.   
+[17] L.-Z. Guo, Z.-Y. Zhang, Y. Jiang, Y.-F. Li, and Z.-H. Zhou. Safe deep semi-supervised learning for unseen-class unlabeled data. In H. D. III and A. Singh, editors, Proceedings of the 37th International Conference on Machine Learning, volume 119 of Proceedings of Machine Learning Research, pages 3897–3906. PMLR, 13–18 Jul 2020.   
+[18] J. R. Hershey, S. J. Rennie, P. A. Olsen, and T. T. Kristjansson. Super-human multi-talker speech recognition: A graphical modeling approach. Comput. Speech Lang., 24(1):45–66, Jan. 2010.   
+[19] G. E. Hinton and R. R. Salakhutdinov. Using deep belief nets to learn covariance kernels for gaussian processes. In J. Platt, D. Koller, Y. Singer, and S. Roweis, editors, Advances in Neural Information Processing Systems, volume 20. Curran Associates, Inc., 2008.   
+[20] R. Johnson and T. Zhang. Semi-supervised convolutional neural networks for text categorization via region embedding. Advances in neural information processing systems, 28:919–927, 2015.   
+[21] V. Kaushal, R. Iyer, S. Kothawade, R. Mahadev, K. Doctor, and G. Ramakrishnan. Learning from less data: A unified data subset selection and active learning framework for computer vision. In 2019 IEEE Winter Conference on Applications of Computer Vision (WACV), pages 1289–1299. IEEE, 2019.   
+[22] R. Khanna, E. Elenberg, A. Dimakis, S. Negahban, and J. Ghosh. Scalable greedy feature selection via weak submodularity. In Artificial Intelligence and Statistics, pages 1560–1568. PMLR, 2017.   
+[23] K. Killamsetty, D. Sivasubramanian, B. Mirzasoleiman, G. Ramakrishnan, A. De, and R. Iyer. Grad-match: A gradient matching based data subset selection for efficient learning, 2021.   
+[24] K. Killamsetty, D. Sivasubramanian, G. Ramakrishnan, and R. Iyer. Glister: Generalization based data subset selection for efficient and robust learning, 2021.   
+[25] D. P. Kingma and J. Ba. Adam: A method for stochastic optimization. arXiv preprint arXiv:1412.6980, 2014.   
+[26] D. P. Kingma, S. Mohamed, D. Jimenez Rezende, and M. Welling. Semi-supervised learning with deep generative models. In Z. Ghahramani, M. Welling, C. Cortes, N. Lawrence, and K. Q. Weinberger, editors, Advances in Neural Information Processing Systems, volume 27. Curran Associates, Inc., 2014.   
+[27] A. Krizhevsky. Learning multiple layers of features from tiny images. Technical report, 2009.   
+[28] A. Krizhevsky, G. Hinton, et al. Learning multiple layers of features from tiny images. 2009.   
+[29] A. Lacoste, A. Luccioni, V. Schmidt, and T. Dandres. Quantifying the carbon emissions of machine learning. arXiv preprint arXiv:1910.09700, 2019.   
+[30] B. Lakshminarayanan, A. Pritzel, and C. Blundell. Simple and scalable predictive uncertainty estimation using deep ensembles. In I. Guyon, U. V. Luxburg, S. Bengio, H. Wallach, R. Fergus, S. Vishwanathan, and R. Garnett, editors, Advances in Neural Information Processing Systems, volume 30. Curran Associates, Inc., 2017.   
+[31] Y. LeCun, B. Boser, J. S. Denker, D. Henderson, R. E. Howard, W. Hubbard, and L. D. Jackel. Backpropagation applied to handwritten zip code recognition. Neural computation, 1(4):541–551, 1989.   
+[32] Y. LeCun and C. Cortes. MNIST handwritten digit database. 2010.   
+[33] B. Liu, Z. Wu, H. Hu, and S. Lin. Deep metric transfer for label propagation with limited annotated data, 2019.   
+[34] Y. Liu, R. Iyer, K. Kirchhoff, and J. Bilmes. SVitchboard II and FiSVer I: High-quality limitedcomplexity corpora of conversational English speech. In Sixteenth Annual Conference of the International Speech Communication Association, 2015.   
+[35] I. Loshchilov and F. Hutter. SGDR: stochastic gradient descent with restarts. CoRR, abs/1608.03983, 2016.   
+[36] A. L. Maas, R. E. Daly, P. T. Pham, D. Huang, A. Y. Ng, and C. Potts. Learning word vectors for sentiment analysis. In Proceedings of the 49th Annual Meeting of the Association for Computational Linguistics: Human Language Technologies, pages 142–150, Portland, Oregon, USA, June 2011. Association for Computational Linguistics.   
+[37] M. Minoux. Accelerated greedy algorithms for maximizing submodular set functions. In Optimization techniques, pages 234–243. Springer, 1978.   
+[38] B. Mirzasoleiman, A. Badanidiyuru, A. Karbasi, J. Vondrák, and A. Krause. Lazier than lazy greedy. In Proceedings of the Twenty-Ninth AAAI Conference on Artificial Intelligence, AAAI’15, page 1812–1818. AAAI Press, 2015.   
+[39] B. Mirzasoleiman, J. Bilmes, and J. Leskovec. Coresets for data-efficient training of machine learning models, 2020.   
+[40] B. Mirzasoleiman, K. Cao, and J. Leskovec. Coresets for robust training of deep neural networks against noisy labels. In H. Larochelle, M. Ranzato, R. Hadsell, M. F. Balcan, and H. Lin, editors, Advances in Neural Information Processing Systems, volume 33, pages 11465–11477. Curran Associates, Inc., 2020.   
+[41] T. Miyato, A. M. Dai, and I. J. Goodfellow. Adversarial training methods for semi-supervised text classification. In 5th International Conference on Learning Representations, ICLR 2017, Toulon, France, April 24-26, 2017, Conference Track Proceedings. OpenReview.net, 2017.   
+[42] T. Miyato, S. ichi Maeda, M. Koyama, and S. Ishii. Virtual adversarial training: A regularization method for supervised and semi-supervised learning, 2018.   
+[43] Y. Netzer, T. Wang, A. Coates, A. Bissacco, B. Wu, and A. Y. Ng. Reading digits in natural images with unsupervised feature learning. 2011.   
+[44] A. Oliver, A. Odena, C. Raffel, E. D. Cubuk, and I. J. Goodfellow. Realistic evaluation of deep semi-supervised learning algorithms, 2019.   
+[45] OpenAI, :, C. Berner, G. Brockman, B. Chan, V. Cheung, P. D˛ebiak, C. Dennison, D. Farhi, Q. Fischer, S. Hashme, C. Hesse, R. Józefowicz, S. Gray, C. Olsson, J. Pachocki, M. Petrov, H. P. d. O. Pinto, J. Raiman, T. Salimans, J. Schlatter, J. Schneider, S. Sidor, I. Sutskever, J. Tang, F. Wolski, and S. Zhang. Dota 2 with large scale deep reinforcement learning, 2019.   
+[46] A. Paszke, S. Gross, S. Chintala, G. Chanan, E. Yang, Z. DeVito, Z. Lin, A. Desmaison, L. Antiga, and A. Lerer. Automatic differentiation in pytorch. 2017.   
+[47] A. Paszke, S. Gross, F. Massa, A. Lerer, J. Bradbury, G. Chanan, T. Killeen, Z. Lin, N. Gimelshein, L. Antiga, A. Desmaison, A. Kopf, E. Yang, Z. DeVito, M. Raison, A. Tejani, S. Chilamkurthy, B. Steiner, L. Fang, J. Bai, and S. Chintala. Pytorch: An imperative style, high-performance deep learning library. In H. Wallach, H. Larochelle, A. Beygelzimer, F. d'Alché-Buc, E. Fox, and R. Garnett, editors, Advances in Neural Information Processing Systems 32, pages 8024–8035. Curran Associates, Inc., 2019.   
+[48] Y. Pu, Z. Gan, R. Henao, X. Yuan, C. Li, A. Stevens, and L. Carin. Variational autoencoder for deep learning of images, labels and captions. In D. Lee, M. Sugiyama, U. Luxburg, I. Guyon, and R. Garnett, editors, Advances in Neural Information Processing Systems, volume 29. Curran Associates, Inc., 2016.   
+[49] M. Ren, W. Zeng, B. Yang, and R. Urtasun. Learning to reweight examples for robust deep learning. In International Conference on Machine Learning, pages 4334–4343. PMLR, 2018.   
+[50] T. Salimans, I. Goodfellow, W. Zaremba, V. Cheung, A. Radford, X. Chen, and X. Chen. Improved techniques for training gans. In D. Lee, M. Sugiyama, U. Luxburg, I. Guyon, and R. Garnett, editors, Advances in Neural Information Processing Systems, volume 29. Curran Associates, Inc., 2016.   
+[51] O. Sener and S. Savarese. Active learning for convolutional neural networks: A core-set approach. In International Conference on Learning Representations, 2018.   
+[52] J. Shu, Q. Xie, L. Yi, Q. Zhao, S. Zhou, Z. Xu, and D. Meng. Meta-weight-net: Learning an explicit mapping for sample weighting. In Advances in Neural Information Processing Systems, 2019.   
+[53] K. Sohn, D. Berthelot, C.-L. Li, Z. Zhang, N. Carlini, E. D. Cubuk, A. Kurakin, H. Zhang, and C. Raffel. Fixmatch: Simplifying semi-supervised learning with consistency and confidence, 2020.   
+[54] E. Strubell, A. Ganesh, and A. McCallum. Energy and policy considerations for deep learning in nlp, 2019.   
+[55] C. Sun, A. Shrivastava, S. Singh, and A. Gupta. Revisiting unreasonable effectiveness of data in deep learning era, 2017.   
+[56] A. Tarvainen and H. Valpola. Mean teachers are better role models: Weight-averaged consistency targets improve semi-supervised deep learning results, 2018.   
+[57] K. Wei, R. Iyer, and J. Bilmes. Submodularity in data subset selection and active learning. In International Conference on Machine Learning, pages 1954–1963, 2015.   
+[58] K. Wei, Y. Liu, K. Kirchhoff, C. Bartels, and J. Bilmes. Submodular subset selection for large-scale speech training data. In 2014 IEEE International Conference on Acoustics, Speech and Signal Processing (ICASSP), pages 3311–3315. IEEE, 2014.   
+[59] Y. Yan, Z. Xu, I. W. Tsang, G. Long, and Y. Yang. Robust semi-supervised learning through label aggregation. In Thirtieth AAAI Conference on Artificial Intelligence, 2016.   
+[60] S. Zagoruyko and N. Komodakis. Wide residual networks, 2017.   
+[61] H. Zhang, M. Cisse, Y. N. Dauphin, and D. Lopez-Paz. mixup: Beyond empirical risk minimization, 2018.   
+[62] X. Zhu, Z. Ghahramani, and J. Lafferty. Semi-supervised learning using gaussian fields and harmonic functions. In Proceedings of the Twentieth International Conference on International Conference on Machine Learning, ICML’03, page 912–919. AAAI Press, 2003.

parse/train/jSz59N8NvUP/jSz59N8NvUP_content_list.json

@@ -0,0 +1,1085 @@
+[
+    {
+        "type": "text",
+        "text": "RETRIEVE: Coreset Selection for Efficient and Robust Semi-Supervised Learning ",
+        "text_level": 1,
+        "bbox": [
+            218,
+            122,
+            781,
+            172
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Krishnateja Killamsetty Xujiang Zhao Feng Chen Rishabh Iyer ",
+        "bbox": [
+            254,
+            226,
+            746,
+            241
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Department of Computer Science The University of Texas at Dallas Richardson, Texas, USA ",
+        "bbox": [
+            388,
+            242,
+            611,
+            281
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "{krishnateja.killamsetty,xujiang.zhao,feng.chen,rishabh.iyer}@utdallas.edu ",
+        "bbox": [
+            187,
+            282,
+            815,
+            296
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Abstract ",
+        "text_level": 1,
+        "bbox": [
+            462,
+            330,
+            535,
+            348
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Semi-supervised learning (SSL) algorithms have had great success in recent years in limited labeled data regimes. However, the current state-of-the-art SSL algorithms are computationally expensive and entail significant compute time and energy requirements. This can prove to be a huge limitation for many smaller companies and academic groups. Our main insight is that training on a subset of unlabeled data instead of entire unlabeled data enables the current SSL algorithms to converge faster, significantly reducing computational costs. In this work, we propose RETRIEVE1, a coreset selection framework for efficient and robust semi-supervised learning. RETRIEVE selects the coreset by solving a mixed discrete-continuous bi-level optimization problem such that the selected coreset minimizes the labeled set loss. We use a one-step gradient approximation and show that the discrete optimization problem is approximately submodular, enabling simple greedy algorithms to obtain the coreset. We empirically demonstrate on several real-world datasets that existing SSL algorithms like VAT, Mean-Teacher, FixMatch, when used with RETRIEVE, achieve a) faster training times, b) better performance when unlabeled data consists of Out-of-Distribution (OOD) data and imbalance. More specifically, we show that with minimal accuracy degradation, RETRIEVE achieves a speedup of around $3 \\times$ in the traditional SSL setting and achieves a speedup of $5 \\times$ compared to state-of-the-art (SOTA) robust SSL algorithms in the case of imbalance and OOD data. RETRIEVE is available as a part of the CORDS toolkit: https://github.com/decile-team/cords. ",
+        "bbox": [
+            233,
+            364,
+            766,
+            654
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 Introduction ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            684,
+            310,
+            700
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Deep learning algorithms have had great success over the past few years, often achieving human or superhuman performance in various tasks like computer vision [10], speech recognition [18], natural language processing [5], and video games [45]. One of the significant factors attributing to the recent success of deep learning is the availability of large amounts of labeled data [55]. However, creating large labeled datasets is often time-consuming and expensive in terms of costs. Moreover, some domains like medical imaging require a domain expert for labeling, making it nearly impossible to create a large labeled set. In order to reduce the dependency on the availability of labeled data, semi-supervised learning (SSL) algorithms [7] were proposed to train models using large amounts of unlabeled data along with the available labeled data. Recent works [42, 56, 4, 53] show that semi-supervised learning algorithms can achieve similar performance to standard supervised learning using significantly fewer labeled data instances. ",
+        "bbox": [
+            174,
+            717,
+            825,
+            868
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "However, the current SOTA SSL algorithms are compute-intensive with large training times. For example, from our personal experience, training a WideResNet model [60] on a CIFAR10 [27] dataset with 4000 labels using the SOTA FixMatch algorithm [53] for 500000 iterations takes around four days on a single RTX2080Ti GPU. This also implies increased energy consumption and an associated carbon footprint [54]. Furthermore, it is common to tune these ",
+        "bbox": [
+            174,
+            92,
+            421,
+            270
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "image",
+        "img_path": "images/36462717557b89b7bb6548f8dd3c22326ea43e9cf8bb2619d18e303e29ba37f0.jpg",
+        "image_caption": [
+            "Figure 1: (a )Unlabeled set with the same distribution as the labeled set, (b) Unlabeled set containing OOD instances, (c) Unlabeled set where the class distribution is imbalanced "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            450,
+            93,
+            805,
+            194
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "SSL algorithms over a large set of hyper-parameters, which means that the training needs to be done hundreds and sometimes thousands of times. For example, [44] performed hyperparameter tuning by running 1000 trails of Gaussian Process-based Blackbox optimization[16] for each SSL algorithm (which runs for 500000 iterations). This process implies significantly higher experimental turnaround times, energy consumption, and CO2 emissions. Furthermore, this is not something that can be done at most universities and smaller companies. The first problem we try to address in this work is: Can we efficiently train a semi-supervised learning model on coresets of unlabeled data to achieve faster convergence and reduction in training time? ",
+        "bbox": [
+            173,
+            271,
+            825,
+            381
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Despite demonstrating encouraging results on standard and clean datasets, current SSL algorithms perform poorly when OOD data or class imbalance is present in the unlabeled set [44, 8]. This performance degradation can be attributed to the fact that the current SSL algorithms assume that both the labeled set and unlabeled set are sampled from the same distribution. A visualization of OOD data and class imbalance in the unlabeled set is shown in Figure 1. Several recent works [59, 8, 17] were proposed to mitigate the effect of OOD in unlabeled data, in turn improving the performance of SSL algorithms. However, the current SOTA robust SSL method [17] is 3X slower than the standard SSL algorithms, further increasing the training times, energy costs, and CO2 emissions. The second problem we try to address in this work is: In the case where OOD data or class imbalance exists in the unlabeled set, can we robustly train an SSL model on coresets of unlabeled data to achieve similar performance to existing robust SSL methods while being significantly faster? ",
+        "bbox": [
+            173,
+            387,
+            825,
+            540
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "image",
+        "img_path": "images/01b3a40f43eb0a3156bdfa79e1d96e28aaf5c27fd312154845a27f5978e4f461.jpg",
+        "image_caption": [
+            "Figure 2: Comparison of RETRIEVE with VAT, FixMatch, and MT on CIFAR-10 and SVHN: We contrast the accuracy degradation with speedup compared to the base SSL or robust SSL (DS3L) approach. We observe speedups of $3 \\times$ in standard SSL case with $0 . 7 \\%$ accuracy drop and $2 \\times$ speedup with no accuracy drop. In the robust SSL case, we observe $5 \\times$ speedup compared to DS3L [17] while outperforming it in terms of accuracy. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            189,
+            575,
+            808,
+            727
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "To this end, we propose RETRIEVE, a coreset selection framework that enables faster convergence and robust training of SSL algorithms. RETRIEVE selects coreset of the unlabeled data resulting in minimum labeled set loss when trained upon in a semi-supervised manner. Intuitively, RETRIEVE tries to achieve faster convergence by selecting data instances from the unlabeled set whose gradients are aligned with the labeled set gradients. Furthermore, RETRIEVE also achieves distribution matching by selecting a coreset from the unlabeled set with similar gradients to the labeled set. ",
+        "bbox": [
+            174,
+            827,
+            825,
+            911
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "1.1 Our Contributions ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            92,
+            343,
+            106
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "The contributions are our work can be summarized as follows: ",
+        "bbox": [
+            173,
+            117,
+            581,
+            132
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "• RETRIEVE Framework: We propose a coreset selection algorithm RETRIEVE for efficient and robust semi-supervised learning. RETRIEVE poses the coreset selection as a discrete-continuous bi-level optimization problem and solves it efficiently using an online approximation of single-step gradient updates. Essentially, RETRIEVE selects a coreset of the unlabeled set, which, when trained using the combination of the labeled set and the specific unlabeled data coreset, minimizes the model loss on the labeled dataset. We also discuss several implementation tricks to speed up the coreset selection step significantly $\\cdot { c . f . }$ , Section 3.3, Section 3.4) ",
+        "bbox": [
+            174,
+            143,
+            825,
+            241
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "• RETRIEVE in Traditional SSL: We empirically demonstrate the effectiveness of RETRIEVE in conjunction with several SOTA SSL algorithms like VAT, Mean-Teacher, and FixMatch. The speedups obtained by RETRIEVE are shown in Figure 2a. Specifically, we see that RETRIEVE consistently achieves close to $3 \\times$ speedup with accuracy degradation of around $0 . 7 \\%$ . RETRIEVE also achieves more than $4 . 2 \\times$ speedup with a slightly higher accuracy degradation. Furthermore, when RETRIEVE is trained for more iterations, RETRIEVE can match the performance of VAT while having a $2 \\times$ speedup (see VAT Extended bar plot in Figure 2a). RETRIEVE also consistently outperforms simple baselines like early stopping and random sampling. ",
+        "bbox": [
+            174,
+            246,
+            825,
+            358
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "• RETRIEVE in Robust SSL: We further demonstrate the utility of RETRIEVE for robust SSL in the presence of OOD data and imbalance in the unlabeled set. We observe that with the VAT SSL algorithm, RETRIEVE outperforms SOTA robust SSL method DS3L [17] (with VAT) while being around $5 \\times$ faster. RETRIEVE also significantly outperforms just VAT and random sampling. ",
+        "bbox": [
+            174,
+            363,
+            825,
+            419
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "1.2 Related Work ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            436,
+            310,
+            450
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Semi-supervised learning: Several papers have been proposed for semi-supervised learning over the past few years. Due to space constraints, we do not talk about generative [50, 48, 26, 11, 19, 30, 3] and graph-based [62, 33] methods for SSL in this work. We instead focus on the main components of the existing SOTA SSL algorithms, viz., a) consistency regularization and b) entropy minimization. The consistency regularization component forces the model to have consistent prediction given an unlabeled data point and its perturbed (or augmented) version. The Entropy-minimization component forces the model instances to have low-entropy predictions on unlabeled data instances to ensure that the classes are well separated. One can achieve entropy minimization by directly adding the entropy loss component on the unlabeled class prediction or using methods like Pseudo-Labeling to enforce it implicitly. Mean-Teacher [56] approach uses a consistency regularization component that forces the predictions of the exponential moving average of the model to be the same as the model prediction of the augmented unlabeled images. VAT [42] instead computes the perturbation of the unlabeled data point that changes the prediction distribution the most and enforces the model to have the same prediction on both unlabeled data instance and unlabeled data instance with computed perturbation as a form of consistency regularization. MixMatch [4] uses $K$ standard image augmentations for consistency regularization and enforces entropy minimization by using a sharpening function on the average predicted distribution of $K$ augmentations of unlabeled data instances. FixMatch [53] induces consistency regularization by forcing the model to have the same prediction on a weakly augmented and strongly augmented image instance. Furthermore, FixMatch [53] also employs confidence thresholding to mask unlabeled data instances on which the model’s prediction confidence is below a threshold from being used in consistency loss. ",
+        "bbox": [
+            174,
+            462,
+            825,
+            752
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Robust Semi-supervised learning: Several methods have been proposed to make the existing semi-supervised learning algorithms robust to label noise in labeled data and robust to OOD data in the unlabeled set. A popular approach [49, 52] to deal with label noises and class imbalance in a supervised learning setting is by reweighing each data instance and jointly learning these weights along with the model parameters. Safe-SSL (DS3L) [17] is a recently proposed SOTA method for robust SSL learning. DS3L is similar to the reweighting in the supervised case and adopts a reweighting approach to deal with OOD data in the unlabeled set. Safe-SSL uses a neural network to predict the weight parameters of unlabeled instances that result in maximum labeled set performance, making it a bi-level optimization problem. In this regard, both RETRIEVE and Safe-SSL approach solves a bi-level optimization problem, except that RETRIEVE solves a discrete optimization problem at the outer level, thereby enabling significant speedup compared to SSL algorithms and an even more considerable speedup compared to safe-SSL (which itself is $3 \\times$ slower than SSL algorithms). In contrast to safe-SSL and other robust SSL approaches, RETRIEVE achieves both efficiency and robustness. Other approaches for robust SSL include UASD [9] uses an Uncertainty aware self-distillation with OOD filtering to achieve robust performance and a distributionally robust model to deal with OOD [8]. ",
+        "bbox": [
+            174,
+            758,
+            825,
+            911
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "image",
+        "img_path": "images/8f612b06fefb8df68ce87a482eaf42ad80ea1b7a73259a95f98cd09315cd54be.jpg",
+        "image_caption": [
+            "Figure 3: Flowchart of RETRIEVE framework, where coreset selection is performed every $R$ epochs and the model is trained on the selected coreset. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            194,
+            88,
+            807,
+            150
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            222,
+            825,
+            279
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Coreset and subset selection methods: Coresets [13] are small and informative weighted data subsets that approximate original data. Several works [57, 39, 24, 23] have studied coresets for efficient training of deep learning models in the supervised learning scenarios. CRAIG [39] selects representative coresets of the training data that closely estimates the full training gradient. Another approach, GLISTER [24] posed the coreset selection as optimizing the validation set loss for efficient learning focused on generalization. Another approach, GRAD-MATCH [23] select subsets that approximately match the full training loss or validation loss gradient using orthogonal matching pursuit. Similarly, coreset selection methods [57, 51, 2, 24] were also used for active learning scenario, where a subset of data instances from the unlabeled set is selected to be labeled. Finally, several recent works have used submodular functions for finding diverse and representative subsets for data subset selection [34, 21, 57, 58]. ",
+        "bbox": [
+            173,
+            285,
+            825,
+            438
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "2 Preliminaries ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            457,
+            318,
+            474
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Notation: Denote to be the unlabele $\\mathcal { D } = \\{ x _ { i } , y _ { i } \\} _ { i = 1 } ^ { n }$ to be the la points. Let eled set with be the class $n$ labeled data points, aer model parameters, $\\mathcal { U } = \\{ x _ { j } \\} _ { j = 1 } ^ { m }$ $m$ $\\theta$ $l _ { s }$ set loss function (such as cross-entropy loss) and $l _ { u }$ be the unlabeled set loss, e.g. consistencyregularization loss, entropy loss, etc.. Denote $L _ { S } ( \\mathcal D , \\theta ) = \\sum _ { i \\in \\mathcal D } l _ { s } ( \\theta , x _ { i } , y _ { i } )$ and $\\bar { L } _ { U } ( \\mathcal { U } , \\theta , m ) \\stackrel { \\cdot } { = }$ $\\sum _ { j \\in \\mathcal { U } } m _ { i } l _ { u } ( x _ { j } , \\theta )$ where $m \\in \\{ 0 , 1 \\} ^ { m }$ is the binary mask vector for unlabeled set. For notational convenience, we denote $l _ { s i } ( \\theta ) = l _ { s } ( x _ { i } , y _ { i } , \\theta )$ and denote $l _ { u j } ( \\theta ) = l _ { u } ( x _ { j } , \\theta )$ . ",
+        "bbox": [
+            173,
+            488,
+            826,
+            595
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Semi-supervised loss: Following the above notations, the loss function for many existing SSL algorithms can be written as $L _ { S } ( \\bar { D } , \\theta ) + \\lambda L _ { U } ( \\mathcal { U } , \\theta , m )$ , where $\\lambda$ is the regularization coefficient for the unlabeled set loss. For Mean Teacher [56], VAT[42], MixMatch [4], the mask vector $_ { \\mathbf { \\nabla } } \\mathbf { m }$ is made up entirely of ones, whereas for FixMatch [53], $_ { m }$ is confidence-thresholded binary vector, indicating whether to include an unlabeled data instance or not. Usually, $L _ { S }$ is a cross-entropy loss for classification experiments and squared loss for regression experiments. A detailed formulation of the loss function $L _ { U }$ used in different SSL algorithms is given in Appendix C ",
+        "bbox": [
+            173,
+            599,
+            825,
+            698
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Robust Semi-supervised loss: However, for robust semi-supervised loss, the mask vector $_ { m }$ is replaced with a weight vector ${ \\pmb w } \\in \\mathbb { R } ^ { m }$ denoting the contribution of data instances in the unlabeled set. The weight vector $\\pmb { w }$ is unknown and needs to be learned. The weighted SSL loss is: $L _ { S } ( \\mathcal { D } , \\theta ) +$ $\\lambda L _ { U } ( \\mathcal { U } , \\boldsymbol { \\theta } , { \\boldsymbol { w } } )$ , where $\\lambda$ is the regularization coefficient for the unlabeled set loss. ",
+        "bbox": [
+            174,
+            704,
+            826,
+            760
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "The state-of-the-art robust SSL method, Safe-SSL [17] poses the learning problem as: ",
+        "bbox": [
+            174,
+            765,
+            736,
+            781
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/bc42f183690147a5522b6b07c852df22694bb03aba97adf9e552b9088e1c2c81.jpg",
+        "text": "$$\n\\overbrace { \\pmb { w } ^ { * } = \\operatorname { a r g m i n } _ { \\pmb { w } } L _ { S } ( \\mathcal { D } , \\underbrace { \\mathrm { a r g m i n } \\left( L _ { S } ( \\mathcal { D } , \\theta ) + \\lambda L _ { U } ( \\mathcal { U } , \\theta , w ) \\right) } _ { \\theta } ) } ^ { o u t e r - l e v e l }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            258,
+            787,
+            656,
+            853
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "In order to solve the problem at the inner level efficiently, Safe-SSL [17] method uses a single-gradient step approximation to estimate the inner problem solution. The weight vector learning problem after the one-step approximation is: $\\pmb { w } ^ { * } = \\mathrm { a r g m i n } ~ L _ { S } ( \\mathcal { D } , \\pmb { \\theta } - \\alpha \\nabla _ { \\theta } L _ { S } ( \\bar { \\mathcal { D } } , \\theta ) - \\alpha \\lambda \\nabla _ { \\theta } L _ { U } ( \\bar { \\mathcal { U } } , \\theta , w )$ ",
+        "bbox": [
+            176,
+            863,
+            823,
+            907
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Safe-SSL also uses a single-step gradient approximation to solve the outer level problem as well. As discussed before, the optimization problem of the Safe-SSL [17] algorithm involves continuous optimization at both inner and outer levels, whereas for RETRIEVE, the outer level involves a discrete optimization problem which makes it significantly faster than Safe-SSL. ",
+        "bbox": [
+            174,
+            90,
+            826,
+            147
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "3 RETRIEVE framework ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            166,
+            397,
+            184
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "In RETRIEVE, the coreset selection and classifier model learning on the selected coreset is performed in conjunction. As shown in the Figure 3, RETRIEVE trains the classifier model on the previously selected coreset for $R$ epochs in a semi-supervised manner, and every $R ^ { t h }$ epoch, a new coreset is selected, and the process is repeated until the classifier model reaches convergence, or the required number of epochs is reached. The vital feature of RETRIEVE is that the coresets selected are adapted with the training. Let $\\theta _ { t }$ be the classifier model parameters and the $S _ { t }$ be the coreset at time step $t$ . Since coreset selection is done every $R$ epochs, we have ${ S } _ { t } = { S } _ { \\lfloor t / R \\rfloor }$ , or in other words, the subsets change only after $R$ epochs. The SSL loss function on the selected coreset at iteration $t$ is as follows: ",
+        "bbox": [
+            173,
+            196,
+            826,
+            309
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/1c8381dc1dc248d217d7d56f44e796043ced99bd5419b0a5cc891905203c9f39.jpg",
+        "text": "$$\nL _ { S } ( \\mathcal { D } , \\boldsymbol { \\theta } _ { t } ) + \\lambda _ { t } \\sum _ { j \\in \\mathcal { S } _ { t } } m _ { j t } l _ { u } ( x _ { j } , \\boldsymbol { \\theta } _ { t } )\n$$",
+        "text_format": "latex",
+        "bbox": [
+            385,
+            315,
+            612,
+            351
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "where $\\mathbf { \\nabla } m _ { j t }$ is the mask binary value associated with the $j ^ { t h }$ point based on model parameters $\\theta _ { t }$ and $\\lambda _ { t }$ is the unlabeled loss coefficient at iteration $t$ . Note that objective function given in Equation (2) is dependent on the SSL algorithm used in RETRIEVE framework. If gradient descent is used for learning, the parameter update step from time step $t$ to $t + 1$ is as follows: ",
+        "bbox": [
+            174,
+            358,
+            825,
+            415
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/43786e0eb492dae93915dedb19372bd94de34c9e31336c2fa47a38e19e95aab2.jpg",
+        "text": "$$\n\\theta _ { t + 1 } = \\theta _ { t } - \\alpha _ { t } \\nabla _ { \\theta } L _ { S } ( \\mathcal { D } , \\theta _ { t } ) - \\alpha _ { t } \\lambda _ { t } \\sum _ { j \\in S _ { t } } m _ { j t } \\nabla _ { \\theta } l _ { u } ( x _ { j } , \\theta _ { t } )\n$$",
+        "text_format": "latex",
+        "bbox": [
+            305,
+            421,
+            692,
+            457
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "where $\\alpha _ { t }$ is the learning rate at iteration $t$ . The update step for mini-batch SGD is similar, just that it does the above on minibatches of the dataset. ",
+        "bbox": [
+            173,
+            463,
+            825,
+            491
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "3.1 Problem Formulation ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            507,
+            364,
+            522
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "The coreset selection problem of RETRIEVE at timestep $t$ is as follows: ",
+        "bbox": [
+            173,
+            532,
+            638,
+            549
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/df6d6c6ea6aa3788e8bab52caac9b19f4b0fe7d1db713bae7e2c1641cba7d385.jpg",
+        "text": "$$\n\\overbrace { S _ { t } = \\underbrace { \\mathrm { \\ a r g m i n } \\ L _ { S } \\Big ( \\mathcal { D } , \\underbrace { \\mathrm { a r g m i n } \\left( L _ { S } ( \\mathcal { D } , \\theta _ { t } ) + \\lambda _ { t } \\sum _ { j \\in S } m _ { j t } l _ { u } ( x _ { j } , \\theta _ { t } ) \\right) } _ { i n n e r - l e v e l } } \\Big ) } ^ { o u t e r - l e v e l }  \\mathrm { ~ , ~ }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            228,
+            563,
+            687,
+            637
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "where $k$ is the size of the coreset and $\\mathbf { \\nabla } m _ { j t }$ is the binary value associated with the $j ^ { t h }$ instance based on model parameters $\\theta _ { t }$ . $k$ is a fraction of the entire dataset (e.g. $20 \\%$ or $30 \\%$ ), and the goal is to select the best subset of the unlabeled set, which maximizes the labeled loss based. The outer level of the above optimization problem is a discrete subset selection problem. However, solving the inner-optimization problem naively is computationally intractable, and, we need to make some approximations. ",
+        "bbox": [
+            173,
+            641,
+            826,
+            724
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "3.2 One-Step Gradient Approximation ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            741,
+            457,
+            757
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "To solve the inner optimization problem efficiently, RETRIEVE adopts a one-step gradient approximation based optimization method similar to [14, 49]. More specifically, RETRIEVE approximates the solution to the inner level problem by taking a single gradient step towards the descent direction of the loss function. The idea here is to jointly optimize the model parameters and the subset as the learning proceeds. After this approximation, the coreset selection optimization problem becomes: ",
+        "bbox": [
+            173,
+            766,
+            825,
+            837
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/5cc90cb8da2aceaf2d07b3bee384f5c4e5bec7f2733a9bd58f550b427aba4a9c.jpg",
+        "text": "$$\n{ \\mathcal { S } } _ { t } = \\operatorname * { a r g m i n } _ { S \\subseteq { \\mathcal { U } } : | S | \\leq k } L _ { S } ( { \\mathcal { D } } , \\theta _ { t } - \\alpha _ { t } \\nabla _ { \\theta } L _ { S } ( { \\mathcal { D } } , \\theta _ { t } ) - \\alpha _ { t } \\lambda _ { t } \\sum _ { j \\in S } m _ { j t } \\nabla _ { \\theta } l _ { u } ( x _ { j } , \\theta _ { t } ) )\n$$",
+        "text_format": "latex",
+        "bbox": [
+            215,
+            852,
+            702,
+            887
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "However, even after this approximation, the above optimization problem (Equation (5)) is NP-hard. ",
+        "bbox": [
+            173,
+            896,
+            821,
+            912
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Theorem 1 Optimization problem (Equation (5)) is NP hard, even if $\\mathit { l } _ { s }$ is a convex loss function. If the labeled set loss function $l _ { s }$ is cross-entropy loss, then the optimization problem give in the Equation (5) can be converted into an instance of cardinality constrained weakly submodular maximization. ",
+        "bbox": [
+            173,
+            90,
+            825,
+            133
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "The proof is given in Appendix B. The given Theorem 1 holds as long as $l _ { s }$ is a cross-entropy loss irrespective of the form of $l _ { u }$ . Further, Theorem 1 implies that the optimization problem given in Equation (5) can be solved efficiently using greedy algorithms [37, 38] with approximation guarantees. RETRIEVE uses stochastic-greedy algorithm [22, 38] to solve the optimization problem Equation (5) with an approximation guarantee of $1 - 1 / e ^ { \\beta } - \\epsilon$ in $\\mathcal { O } ( m \\log ( 1 / \\epsilon ) )$ iterations where $m$ is the unlabeled set size and $\\beta$ is the weak submodularity coefficient (see Appendix B). And the set function used in stochastic greedy algorithm is as follows: ",
+        "bbox": [
+            173,
+            145,
+            826,
+            243
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "equation",
+        "img_path": "images/58ca1d47fbcb25e7433df9e3c688bffbaadce3a4dc4009f011f43c8774c66982.jpg",
+        "text": "$$\nf ( \\theta _ { t } , S ) = - L _ { S } ( \\mathcal { D } , \\theta _ { t } - \\alpha _ { t } \\nabla _ { \\theta } L _ { S } ( \\mathcal { D } , \\theta _ { t } ) - \\alpha _ { t } \\lambda _ { t } \\sum _ { j \\in S } m _ { j t } \\nabla _ { \\theta } l _ { u } ( x _ { j } , \\theta _ { t } ) )\n$$",
+        "text_format": "latex",
+        "bbox": [
+            223,
+            250,
+            694,
+            285
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Notice that during each greedy iteration, we need to compute the set function value $f ( \\theta _ { t } , S \\cup e )$ to find the maximal gain element $e$ that can be added to the set $s$ . This implies that the loss over the entire labeled set needs to be computed multiple times for each greedy iteration, making the entire greedy selection algorithm computationally expensive. ",
+        "bbox": [
+            173,
+            297,
+            825,
+            354
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "3.3 RETRIEVE Algorithm ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            371,
+            366,
+            386
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "To make the greedy selection algorithm efficient, we approximate the set function value $f ( \\theta _ { t } , S \\cup e )$ with the first two terms of it’s Taylor-series expansion Let, $\\theta ^ { S } \\ = \\ \\theta _ { t } \\ - \\ \\alpha _ { t } \\nabla _ { \\theta } \\bar { L _ { S } } ( { \\mathcal D } , \\theta _ { t } ) \\ -$ $\\alpha _ { t } \\lambda _ { t } \\sum _ { j \\in S } m _ { j t } \\nabla _ { \\theta } l _ { u } ( x _ { j } , \\theta _ { t } )$ . The modified set function value with Taylor-series approximation is as follows: ",
+        "bbox": [
+            173,
+            395,
+            825,
+            459
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "equation",
+        "img_path": "images/ee93cef6cc6cc2130375adef678bf9393f780300704deb29c0d593e51c4e4761.jpg",
+        "text": "$$\n\\hat { f } ( \\theta _ { t } , S \\cup e ) = - L _ { S } ( \\mathcal { D } , \\theta ^ { S } ) + \\alpha _ { t } \\lambda _ { t } \\nabla _ { \\theta } L _ { S } \\big ( \\mathcal { D } , \\theta ^ { S } \\big ) ^ { T } m _ { e t } \\nabla _ { \\theta } l _ { u } \\big ( x _ { e } , \\theta _ { t } \\big )\n$$",
+        "text_format": "latex",
+        "bbox": [
+            232,
+            465,
+            687,
+            488
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "where ${ \\mathbf { } } m _ { e t }$ is the binary mask value associated with element $e$ . Note that the term $m _ { e t } \\nabla _ { \\boldsymbol { \\theta } } l _ { \\underline { { u } } } ( x _ { e } , \\theta _ { t } )$ can be precomputed at the start of the greedy selection algorithm, and the term $\\nabla _ { \\theta } L _ { S } ( \\mathcal { D } , \\theta ^ { S } )$ needs to be computed only once every greedy iteration, thereby reducing the computational complexity of the greedy algorithm. ",
+        "bbox": [
+            173,
+            502,
+            826,
+            558
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "A detailed pseudo-code of the RETRIEVE algorithm is given in Algorithm 1. RETRIEVE uses a greedy selection algorithm for coreset selection, and the detailed pseudo-code of the greedy algorithm is given in Algorithm 2. RETRIEVE can be easily implemented with popular deep learning frameworks [47, 1] that provide auto differentiation functionalities. In all our experiments, we set $R = 2 0$ , i.e., we update the coreset every 20 epochs. ",
+        "bbox": [
+            174,
+            564,
+            485,
+            703
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Algorithm 1: RETRIEVE Algorithm ",
+        "text_level": 1,
+        "bbox": [
+            498,
+            555,
+            736,
+            570
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "3.4 Additional Implementation Details: ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            712,
+            459,
+            727
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "In this subsection, we discuss additional implementational and practical tricks to make RETRIEVE scalable and efficient. ",
+        "bbox": [
+            173,
+            738,
+            486,
+            779
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Input: Labeled Set: $\\left\\{ \\lambda _ { t } \\right\\} _ { t = 0 } ^ { t = T - 1 }$ $\\mathcal { D }$ , Learning rates: , Unlabeled Set: $\\{ \\alpha _ { t } \\} _ { t = 0 } ^ { t = T - 1 }$ $\\boldsymbol { u }$ , Reg. Coefficients:   \nInput: Total no of epochs: , Epoch interval for subset selection: $R$ , Size of the coreset: $k$   \nSet $t = 0$ ; Randomly initialize model parameters $\\theta _ { 0 }$ and coreset   \n$S _ { 0 } \\subseteq \\mathcal { U } : | S _ { 0 } | = k$ ;   \nrepeat if ( $t \\% R = = 0$ ) ∧ $( t > 0 )$ ) then St = GreedySelectio $( \\mathcal { D } , \\mathcal { U } , \\theta _ { t } , \\lambda _ { t } , \\alpha _ { t } , k )$ else $\\_ S { _ t } = S _ { { t - 1 } }$ Compute batches $\\mathcal { D } _ { b } = ( ( x _ { b } , y _ { b } ) ; b \\in ( 1 \\cdot \\cdot \\cdot B ) )$ from $\\mathcal { D }$ Compute batches $S _ { t b } = ( ( x _ { b } ) ; b \\in ( 1 \\cdot \\cdot \\cdot B ) )$ from $s$ $^ { * * }$ Mini-batch SGD \\*\\*\\* Set $\\theta _ { t 0 } = \\theta _ { t }$ for $b = 1$ to $B$ do Compute mask $^ { m _ { t } }$ on $\\boldsymbol { S } _ { t b }$ from current model parameters $\\theta _ { t ( b - 1 ) }$ $\\begin{array} { r } { \\boldsymbol { \\theta } _ { t b } ^ { \\ast } = \\boldsymbol { \\theta } _ { t ( b - 1 ) } - \\alpha _ { t } \\nabla _ { \\theta } L _ { S } ( \\mathcal { D } _ { b } , \\boldsymbol { \\theta } _ { t } ) - } \\end{array}$ αtλt P mjt∇θlu(xj , θt(b − 1)) j∈Stb Set θt+1 = θtB t = t + 1   \nuntil t ≥ T   \nreturn θT , ST ",
+        "bbox": [
+            498,
+            573,
+            800,
+            853
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Last-layer gradients. Computing the gradients over deep models is time-consuming due to an enormous number of parameters in the model. To address this issue, we adopt a last-layer gradient approximation similar to [2, 39, 24, 23] by ",
+        "bbox": [
+            173,
+            785,
+            486,
+            854
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "only considering the last classification layer gradients of the classifier model in RETRIEVE. By simply using the last-layer gradients, we achieve significant speedups in RETRIEVE. ",
+        "bbox": [
+            173,
+            854,
+            825,
+            883
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Warm-starting data selection: We warm start the classifier model by training it on the entire unlabeled dataset for a few epochs similar to [23]. Warm starting allows the classifier model to have a good starting point to provide informative loss gradients used for coreset selection. More specifically, we train the classifier model on the entire unlabeled set for $\\begin{array} { r } { T _ { w } = \\frac { \\kappa T k } { m } } \\end{array}$ epochs where $k$ is coreset size, $T$ is the total number of epochs, $\\kappa$ is the fraction of warm start, and $m$ is the size of the unlabeled set. To be fair, we consider all baselines in the standard SSL setting with the same warm start. ",
+        "bbox": [
+            171,
+            883,
+            825,
+            911
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "image",
+        "img_path": "images/2b8bc3895048c9c9c8db1d4c6dced3334aab1aca3500f15b23687765b6a84924.jpg",
+        "image_caption": [
+            "Figure 4: A comparison of RETRIEVE with baselines (RANDOM, CRAIG, FULL, and FULLEARLYSTOP in the traditional SSL setting. SpeedUp vs Accuracy Degradation, both compared to SSL for (a) VAT on CIFAR-10, (b) VAT on SVHN, (c) FixMatch on CIFAR-10, (d) MT on CIFAR-10, and (e) MT on SVHN. We observe that RETRIEVE significantly outperforms existing baselines in terms of accuracy degradation and speedup tradeoff compared to SSL. Plot (f) also compares the CO2 emissions among the different approaches on FixMatch, showing again that RETRIEVE achieves the best energy-accuracy tradeoff. Plots (g) and (h) are the convergence results comparing accuracy with the time taken. Again, we see that RETRIEVE achieves much faster convergence than all baselines and full training. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            192,
+            89,
+            805,
+            332
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            473,
+            826,
+            531
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "3.5 Epochs vs. Iterations ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            547,
+            357,
+            563
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Most of the existing SSL algorithms are trained using a fixed number of iterations instead of epochs. However, for easier comprehension of the RETRIEVE algorithm, we use the epoch notation in our work. A single epoch here meant a pass over random mini-batches of data points, such that the total number of data points encountered is equal to the size of the coreset of the unlabeled data. For example, if the unlabeled set size is 50000 and the unlabeled batch size is 50, then a single epoch over $100 \\%$ , $50 \\%$ , and $30 \\%$ subsets are equivalent to 1000, 500, and 300 iterations, respectively. ",
+        "bbox": [
+            174,
+            574,
+            485,
+            753
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Algorithm 2: GreedySelection ",
+        "text_level": 1,
+        "bbox": [
+            498,
+            546,
+            704,
+            561
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Input: Labeled Set: $\\mathcal { D }$ , Unlabeled Set: $\\boldsymbol { u }$ , Model Parameters: $\\theta _ { t }$ , Learning rate: $\\alpha _ { t }$   \nInput: Regularization Coefficient: $\\lambda _ { t }$ , Budget: $k$   \nInitialize $s _ { t } = \\emptyset$   \nSet $m = | \\mathcal { U } |$   \nCompute mask values $_ { \\pmb { m } }$ based on current model parameters $\\theta _ { t }$   \nfor $e \\in { \\mathcal { U } }$ do   \nCompute $\\theta _ { e } = m _ { e } \\nabla _ { \\theta } l _ { u } \\big ( x _ { e } , \\theta _ { t } \\big )$   \nfor $i = 1$ to $k$ do Compute $\\theta ^ { S } =$ $\\boldsymbol { \\theta } _ { t } ^ { \\star } - \\alpha _ { t } \\nabla _ { \\theta } L _ { S } ( \\mathcal { D } , \\boldsymbol { \\theta } _ { t } ) - \\alpha _ { t } \\lambda _ { t } \\sum _ { j \\in S } \\boldsymbol { m } _ { j t } \\nabla _ { \\theta } l _ { u } ( x _ { j } , \\boldsymbol { \\theta } _ { t } )$ Compute $\\nabla _ { \\theta } L _ { S } ( \\mathcal { D } , \\theta ^ { S } )$ $V \\sim$ Sample $\\lceil m l o g ( 1 / \\epsilon ) \\rceil$ instances from $\\boldsymbol { u }$ be $s t - g a i n = - \\infty$ for $e \\in V$ do Compute gain ${ \\hat { g } } ( e ) =$ $\\alpha _ { t } \\lambda _ { t } \\nabla _ { \\theta } L _ { S } { \\left( \\mathcal { D } , \\theta ^ { S } \\right) } ^ { T } \\mathbf { m } _ { e } \\nabla _ { \\theta } l _ { u } { \\left( x _ { e } , \\theta _ { t } \\right) }$ if gˆ(e) > best − gain then Set s = e Set best − gain = ˆg(e) St = St ∪ s U = U \\ s   \nreturn $s _ { t }$ ",
+        "bbox": [
+            496,
+            564,
+            802,
+            827
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "4 Experiments ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            768,
+            312,
+            785
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Our experimental section aims to verify the efficiency and effectiveness of RETRIEVE by evalu",
+        "bbox": [
+            174,
+            801,
+            486,
+            828
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "ating RETRIEVE through three semi-supervised learning scenarios a) traditional SSL scenario with clean data, b) robust SSL with OOD, and c) robust SSL with class imbalance, to demonstrate the efficiency and the robustness of RETRIEVE. Furthermore, our work’s experimental scenarios are very relevant in terms of research and real-world applications. We have implemented the RETRIEVE algorithmic framework using PyTorch [46]. We repeat the same experiment for three runs with different initialization and report the mean test accuracies in our plots. A detailed table with both mean test accuracy and the standard deviations was given in Appendix (G, H). For a fair comparison, we use the same random seed in each trial for all methods. We explain implementation details, datasets, and baselines used in each scenario in the following subsections. ",
+        "bbox": [
+            174,
+            829,
+            825,
+            911
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            92,
+            825,
+            132
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Baselines in each setting. In this section, we discuss baselines that are used in all the scenarios considered. We begin with the traditional SSL scenario. In this setting, we run RETRIEVE (and all baselines) with warm-start. We incorporate RETRIEVE with three representative SSL methods, including Mean Teacher (MT) [56], Virtual Adversarial Training (VAT) [42] and FixMatch [53]. The baselines considered are RANDOM (where we just randomly select a subset of unlabeled data points of the same size as RETRIEVE), CRAIG [39, 23] and FULL-EARLYSTOP. CRAIG [39, 23] was actually proposed in the supervised learning scenario. We adapt it to SSL by choosing a representative subset of unlabeled points such that the gradients are similar to the unlabeled loss gradients. We run the per-batch variant of CRAIG proposed in [23], where we select a subset of mini-batches instead of data instances for efficiency and scalability. Similarly, we use the per-batch version of GRADMATCH proposed in [23] adapted to SSL setting as another baseline. For more information on the formulation of CRAIG and GRADMATCH in the SSL case, see Appendix D, E. Again, we emphasize that RANDOM, CRAIG, and GRADMATCH are run with early stopping for the same duration as RETRIEVE. In FULL-EARLYSTOP baseline, we train the model on the entire unlabeled set for the time taken by RETRIEVE and report the test accuracy. In the traditional SSL scenario, we use warm variants of RETRIEVE, RANDOM, CRAIG for SSL training because warm variants are better in accuracy and efficiency compared to not performing warm start – see Appendix G for a careful comparison of both. Robust SSL with OOD and Imbalance: In the robust learning scenario for both OOD and imbalance, we analyze the performance of RETRIEVE with the VAT [42] algorithm. Note that for the Robust SSL scenario, we do not warm start the model by training for a few iterations on the full unlabeled set because training on an entire unlabeled set(containing OOD or class imbalance) creates a biased model due to a distribution mismatch between labeled set and unlabeled set. We empirically compare not warm starting the model with warm starting in Appendix H. In the robust SSL case, we compare RETRIEVE with two robust SSL algorithms DS3L [17] and L2RW [49]. DS3L (also called Safe-SSL) is a robust learning approach using a meta-weight network proposed specifically for robust SSL. We adapt L2RW(Learning to Reweight), originally proposed for robust supervised learning, to the SSL case and use it as a baseline. Similarly, we adapt the robust coreset selection method CRUST [40] originally proposed to tackle noisy labels scenario in supervised learning to SSL setting and use it as a baseline in Robust SSL scenario. ",
+        "bbox": [
+            173,
+            140,
+            825,
+            539
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Datasets, Model architecture and Experimental Setup: We begin by providing details common across the three scenarios. We perform experiments on the following image classification datasets: CIFAR-10 [28] (60000 instances), SVHN [43] (99289 instances) and the following sentiment analysis datasets: IMDB $[ 3 6 ] ^ { 2 }$ (10000 instances), and ELEC $[ 2 0 ] ^ { 3 }$ (246714 instances) datasets. We use a modified version of the ELEC dataset where the duplicate sentences are removed. For CIFAR-10, we use a labeled set of 4000 instances with 400 instances from each class, an unlabeled set of 50000 instances, a test set of 10000 instances. For SVHN, we used a labeled set of ",
+        "bbox": [
+            446,
+            541,
+            826,
+            705
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "image",
+        "img_path": "images/bd28cdf21835c75d0dba7b8e63b28e68453c2829ff7cffd08ea7edd112509f93.jpg",
+        "image_caption": [
+            "Figure 5: Performance comparison of RETRIEVE vs Bayesian Coreset using VAT for $20 \\%$ and $30 \\%$ CIFAR10 subsets "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            223,
+            559,
+            383,
+            665
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "1000 instances with 100 instances from each class, an unlabeled set of 73257 instances, a test set of 26032 instances. For IMDB and ELEC datasets, we use the labeled and unlabeled splits following the work [41]. For CIFAR10 and SVHN datasets, we use the Wide-ResNet-28-2 [60] model that is commonly used in SSL [44, 53]. For MNIST, we use a variant of LeNet [31] (see Appendix F for details). For IMDB and ELEC datasets, we use a model comprising of Word Embedding layer, LSTM model, and two-layer MLP model following the architecture given in the work [41]. Similar to the work [41], we initialize the embedding matrix and LSTM model weights using a pretrained recurrent language model using both the labeled and unlabeled data. For Image datasets, with RETRIEVE(and baselines like RANDOM, GRADMATCH and CRAIG), we use the Nesterov’s accelerated SGD optimizer with a learning rate of 0.03, weight decay of 5e-4, the momentum of 0.9, and a cosine annealing [35] learning rate scheduler for all the experiments. For the FULL and FULLEARLYSTOP, we use the Adam optimizer [25] and follow the experimental setting from the SSL papers [53, 42, 56]. ",
+        "bbox": [
+            173,
+            707,
+            826,
+            871
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "For Text datasets, with RETRIEVE(and baselines like RANDOM, GRADMATCH and CRAIG), we set the hyperparameter values following the work [41]. Similarly, for the robust SSL baselines, we use the settings from the corresponding papers [17]. For all our experiments using image datasets, we use a batch size of 50 for labeled and unlabeled sets. Next, we discuss the specific settings for the traditional SSL scenario. For CIFAR10, we train the model for 500 epochs, and for SVHN, we train the model for 340 epochs on an unlabeled set. Note that we mention the epochs here because the number of iterations depends on the size of the unlabeled sets since that would determine the number of mini-batches. For a fair comparison, we train all algorithms for a fixed number of epochs. Next, we look at robust SSL for OOD. In this scenario, we consider the presence of OOD in the unlabeled set. We introduce OOD into CIFAR-10 following [44], by adapting it to a 6-class dataset, with 400 labels per class (from the 6 animal classes) as ID and rest of the classes as OOD (ID classes are: \"bird\", \"cat\", \"deer\", \"dog\", \"frog\", \"horse\", and OOD data are from classes: \"airline\", \"automobile\", \"ship\", \"truck\"). Similarly, we adapt MNIST [32] to a 6-class dataset, with classes 1-6 as ID and classes 7-10 as OOD. We denote the OOD rat $\\scriptstyle \\mathrm { i o } = { \\mathcal { U } } _ { o o d } / ( { \\mathcal { U } } _ { o o d } + { \\mathcal { U } } _ { i n } )$ where $\\mathcal { U } _ { i n }$ is ID unlabeled set, $\\mathcal { U } _ { o o d }$ is OOD unlabeled set. For CIFAR10, we use a labeled set of 2400 instances and an unlabeled set of 20000 instances, and for MNIST, we use a labeled set of 60 instances and an unlabeled set of 30000 instances. Finally, for robust SSL for class imbalance, we consider imbalance both in the labeled set and unlabeled set. We introduce imbalance into the CIFAR-10 dataset by considering classes 1-5 as imbalanced classes and a class imbalance ratio. The class imbalance ratio is defined as the ratio of instances from classes 1-5 and the number of instances from classes 6-10. For CIFAR-10, we use a labeled set of 2400 and an unlabeled set of 20000 instances. ",
+        "bbox": [
+            173,
+            90,
+            826,
+            381
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Traditional SSL Results: The results comparing the accuracyefficiency tradeoff between the different subset selection approaches are shown in Figure 4. We compare the performance for different subset sizes of the unlabeled data: $10 \\%$ , $20 \\%$ , and $30 \\%$ and three representative SSL algorithms VAT, Mean-Teacher, and FixMatch. For warm-start, we set kappa value to $\\kappa \\ : \\ : = \\ : \\ : 0 . 5$ (i.e., training for $50 \\%$ epochs on the entire unlabeled set and $50 \\%$ using coresets). Our experiments use a $R$ value of 20 (i.e., coreset selection every 20 epochs). Sub-figures(4a, 4b, 4d, 4e, ",
+        "bbox": [
+            174,
+            387,
+            421,
+            608
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "image",
+        "img_path": "images/ab983e7608a0cd9e8df35bcb966d3f574bdd62cc254254795b5a19f77059b08d.jpg",
+        "image_caption": [
+            "Figure 6: A comparison of RETRIEVE with baselines (RANDOM, CRAIG, GRADMATCH, FULL, and FULLEARLYSTOP in the traditional SSL setting for text datasets. SpeedUp vs Accuracy Degradation, both compared to SSL for (a) VAT on $30 \\%$ IMDB, (b) VAT on $30 \\%$ ELEC. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            442,
+            405,
+            812,
+            530
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "4c) shows the plots of relative error vs speedup, both w.r.t full training (i.e., original SSL algorithm). Sub-figure 4f shows the plot of relative error vs CO2 emissions efficiency, both w.r.t full training. CO2 emissions were estimated based on the total compute time using the Machine Learning Impact calculator presented in [29]. From the results, it is evident that RETRIEVE achieved the best speedup vs. accuracy tradeoff and is environmentally friendly based on CO2 emissions compared to other baselines (including CRAIG and FULLEARLYSTOP). In particular, RETRIEVE achieves speedup gains of $2 . 7 \\mathbf { x }$ and $4 . 4 \\times$ with a performance loss of $0 . 7 \\%$ and $0 . 3 \\%$ using VAT on CIFAR10 and SVHN datasets. Further, RETRIEVE achieves speedup gains of $2 . 9 \\mathbf { x }$ , $3 . 2 \\mathrm { x }$ with a performance loss of $0 . 0 2 \\%$ and $0 . 5 \\%$ using Mean-Teacher on CIFAR10 and SVHN datasets. Additionally, RETRIEVE achieves a speedup of $3 . 8 \\mathrm { x }$ with a performance loss of $0 . 7 \\%$ using FixMatch on the CIFAR10 dataset. Sub-figures(6a, 6b) shows the plots of relative error vs speedup both w.r.t full training (i.e., original SSL algorithm) on IMDB and ELEC datasets for $30 \\%$ subset size. In particular, RETRIEVE achieves speedup gains of $2 . 6 8 \\mathrm { x }$ and $2 . 5 \\mathrm { x }$ with a performance loss of $0 . 5 \\%$ and $0 . 6 \\%$ for $30 \\%$ subset of IMDB and ELEC datasets. Figure 5 shows the results comparing the BAYESIANCORESET method [6], adapted to the SSL setting with RETRIEVE using the VAT algorithm for $20 \\%$ and $30 \\%$ CIFAR10 subsets. The results show that RETRIEVE achieves better performance than the SSL extension of the BAYESIANCORESET selection method in terms of model performance and speedup. One possible explanation for it is that the BAYESIANCORESET approach was not developed for efficient learning but instead was developed to capture coresets that try to represent the log-likelihood of the entire dataset that MCMC methods can further use. We would also like to point out that we used the original code implementation of BAYESIANCORESET that is not meant for GPU usage in our experiments. Hence the speedups of the BAYESIANCORESET approach can be further improved with efficient code implementation. Subfigure 4h shows that RETRIEVE achieves faster convergence compared to all other methods on CIFAR10 for $30 \\%$ subset with Mean-Teacher. Subfigure $4 \\mathrm { g }$ shows the extended convergence of RETRIEVE on CIFAR10 for $20 \\%$ and $30 \\%$ subsets using VAT, where the RETRIEVE is allowed to train for larger epochs to achieve comparable accuracy with Full training at the cost of losing some efficiency. Note that the points marked by \\* in subfigure $4 \\mathrm { g }$ denote the actual training endpoint, i.e. the usual number of epochs/iterations used to obtain points in subfigures (4a, 4b, 4d, 4e, 4c). We observe that RETRIEVE matches the performance of VAT while being close to $2 \\times$ faster in running times (and correspondingly energy efficiency). We repeat this experiment with MT in the Appendix G. Also, more detailed results with additional convergence plots and tradeoff curves are in Appendix G. ",
+        "bbox": [
+            173,
+            608,
+            826,
+            897
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "image",
+        "img_path": "images/40ab1abc6353dc009e6215522df2f222c2e4246b190684a7cc4f972009903ee1.jpg",
+        "image_caption": [
+            "Figure 7: Subfigures (a) to (c) compare the performance of RETRIEVE with baselines (including DS3L and L2RW) for different OOD ratios (a,b) and imbalance ratios (c). We see that RETRIEVE outperforms both baselines in most of the cases. Furthermore, RETRIEVE achieves this while being close to $2 \\times$ faster than VAT (the SSL algorithm) and $5 \\times$ faster than the robust SSL algorithms (DS3L and L2RW). "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            183,
+            88,
+            836,
+            226
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            303,
+            825,
+            454
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Robust SSL Results: We test the performance of RETRIEVE on CIFAR10 and MNIST datasets with OOD in the unlabeled set and CIFAR10 dataset with the class imbalance in both labeled and unlabeled sets. sub-figures 7a, 7b shows the accuracy plots of RETRIEVE for different OOD ratios of $2 5 \\%$ , $50 \\%$ and $7 5 \\%$ . The results show that RETRIEVE with VAT outperforms all other baselines, including DS3L [17], a state-of-the-art robust SSL baseline in the OOD scenario. Next, sub-figure 7c shows the accuracy plots of RETRIEVE for different class imbalance ratios of $10 \\%$ , $30 \\%$ and $50 \\%$ on CIFAR10 dataset. The results show that RETRIEVE with VAT outperforms all other baselines, including DS3L [17] (also run with VAT) in the class imbalance scenario as well. In particular, RETRIEVE outperforms other baselines by at least $1 . 5 \\%$ on the CIFAR-10 with imbalance. Sub-figure 7d shows the time taken by different algorithms on the CIFAR10 dataset with a $50 \\%$ class imbalance ratio. The results show that CRUST did not perform well in terms of accuracy and speedups achieved compared to RETRIEVE. Except for MixUP, CRUST is similar to CRAIG, which did not perform well compared to RETRIEVE in a traditional SSL setting. Furthermore, the performance gain due to MixUP for coreset selection in the SSL setting is minimal. The minimal gain can be attributed to the fact that the hypothesized labels used for MixUP in the earlier stages of training are noisy. Furthermore, as stated earlier, CRUST was developed to tackle noisy labels in a supervised learning setting and is not developed to deal with OOD or Class Imbalance in general. The results show that RETRIEVE is more efficient compared to the other baselines. In particular, RETRIEVE is $5 \\mathbf { x }$ times faster compared to DS3L method. Other detailed results (tradeoff curves and convergence curves) are in Appendix $_ \\mathrm { H }$ . ",
+        "bbox": [
+            173,
+            459,
+            825,
+            723
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "5 Conclusion and Broader Impacts ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            751,
+            482,
+            767
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "We introduce RETRIEVE, a discrete-continuous bi-level optimization based coreset selection method for efficient and robust semi-supervised learning. We show connections with weak-submodularity, which enables the coreset selection in RETRIEVE to be solved using a scalable stochastic greedy algorithm. Empirically, we show that RETRIEVE is very effective for SSL. In particular, it achieves $3 \\times$ speedup on a range of SSL approaches like VAT, MT, and FixMatch with around $0 . 7 \\%$ accuracy loss and a $2 \\times$ speedup with no accuracy loss. In the case of robust SSL with imbalance and OOD data, RETRIEVE outperforms existing SOTA methods while being $5 \\times$ faster. We believe RETRIEVE has a significant positive societal impact by making SSL algorithms (specifically robust SSL) significantly faster and more energy-efficient, thereby reducing the CO2 emissions incurred during training. ",
+        "bbox": [
+            174,
+            786,
+            825,
+            911
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "6 Acknowledgments and Disclosure of Funding ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            88,
+            583,
+            107
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "We would like to thank NeurIPS area chairs and anonymous reviewers for their efforts in reviewing this paper and their constructive comments! RI and KK were funded by the National Science Foundation(NSF) under Grant Number 2106937, a startup grant from UT Dallas, and a Google and Adobe research award. FC and XZ were funded by National Science Foundation(NSF) under Grant Numbers 1815696, 1750911, and 2107449. Any opinions, findings, and conclusions or recommendations expressed in this material are those of the author(s) and do not necessarily reflect the views of the National Science Foundation, Google or Adobe. ",
+        "bbox": [
+            173,
+            121,
+            826,
+            218
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "References ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            241,
+            266,
+            256
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "[1] M. Abadi, P. Barham, J. Chen, Z. Chen, A. Davis, J. Dean, M. Devin, S. Ghemawat, G. Irving, M. Isard, M. Kudlur, J. Levenberg, R. Monga, S. Moore, D. G. Murray, B. Steiner, P. Tucker, V. Vasudevan, P. Warden, M. Wicke, Y. Yu, and X. Zheng. Tensorflow: A system for largescale machine learning. In 12th USENIX Symposium on Operating Systems Design and Implementation (OSDI 16), pages 265–283, 2016.   \n[2] J. T. Ash, C. Zhang, A. Krishnamurthy, J. Langford, and A. Agarwal. Deep batch active learning by diverse, uncertain gradient lower bounds. In International Conference on Learning Representations, 2020.   \n[3] M. Belkin and P. Niyogi. Laplacian eigenmaps and spectral techniques for embedding and clustering. In Proceedings of the 14th International Conference on Neural Information Processing Systems: Natural and Synthetic, NIPS’01, page 585–591, Cambridge, MA, USA, 2001. MIT Press.   \n[4] D. Berthelot, N. Carlini, I. Goodfellow, N. Papernot, A. Oliver, and C. Raffel. Mixmatch: A holistic approach to semi-supervised learning, 2019.   \n[5] O. Bojar, R. Chatterjee, C. Federmann, M. Fishel, Y. Graham, B. Haddow, M. Huck, A. JimenoYepes, P. Koehn, A. Martins, C. Monz, M. Negri, A. Névéol, M. L. Neves, M. Post, M. Turchi, and K. Verspoor, editors. Proceedings of the Fourth Conference on Machine Translation, WMT 2019, Florence, Italy, August 1-2, 2019 - Volume 1: Research Papers. Association for Computational Linguistics, 2019.   \n[6] T. Campbell and T. Broderick. Bayesian coreset construction via greedy iterative geodesic ascent. In J. Dy and A. Krause, editors, Proceedings of the 35th International Conference on Machine Learning, volume 80 of Proceedings of Machine Learning Research, pages 698–706. PMLR, 10–15 Jul 2018.   \n[7] O. Chapelle, B. Schlkopf, and A. Zien. Semi-Supervised Learning. The MIT Press, 1st edition, 2010.   \n[8] K. Chen, L. Yao, D. Zhang, X. Chang, G. Long, and S. Wang. Distributionally robust semisupervised learning for people-centric sensing. In Proceedings of the AAAI Conference on Artificial Intelligence, volume 33, pages 3321–3328, 2019.   \n[9] Y. Chen, X. Zhu, W. Li, and S. Gong. Semi-supervised learning under class distribution mismatch. Proceedings of the AAAI Conference on Artificial Intelligence, 34(04):3569–3576, Apr. 2020.   \n[10] D. Cire¸san, U. Meier, and J. Schmidhuber. Multi-column deep neural networks for image classification, 2012.   \n[11] A. Coates and A. Y. Ng. The importance of encoding versus training with sparse coding and vector quantization. In Proceedings of the 28th International Conference on International Conference on Machine Learning, ICML’11, page 921–928, Madison, WI, USA, 2011. Omnipress.   \n[12] A. Das and D. Kempe. Submodular meets spectral: Greedy algorithms for subset selection, sparse approximation and dictionary selection. In Proceedings of the 28th International Conference on International Conference on Machine Learning, ICML’11, page 1057–1064, Madison, WI, USA, 2011. Omnipress.   \n[13] D. Feldman. Core-sets: Updated survey. In Sampling Techniques for Supervised or Unsupervised Tasks, pages 23–44. Springer, 2020.   \n[14] C. Finn, P. Abbeel, and S. Levine. Model-agnostic meta-learning for fast adaptation of deep networks. In International Conference on Machine Learning, pages 1126–1135. PMLR, 2017.   \n[15] K. Gatmiry and M. Gomez-Rodriguez. On the network visibility problem. CoRR, abs/1811.07863, 2018.   \n[16] D. Golovin, B. Solnik, S. Moitra, G. Kochanski, J. E. Karro, and D. Sculley, editors. Google Vizier: A Service for Black-Box Optimization, 2017.   \n[17] L.-Z. Guo, Z.-Y. Zhang, Y. Jiang, Y.-F. Li, and Z.-H. Zhou. Safe deep semi-supervised learning for unseen-class unlabeled data. In H. D. III and A. Singh, editors, Proceedings of the 37th International Conference on Machine Learning, volume 119 of Proceedings of Machine Learning Research, pages 3897–3906. PMLR, 13–18 Jul 2020.   \n[18] J. R. Hershey, S. J. Rennie, P. A. Olsen, and T. T. Kristjansson. Super-human multi-talker speech recognition: A graphical modeling approach. Comput. Speech Lang., 24(1):45–66, Jan. 2010.   \n[19] G. E. Hinton and R. R. Salakhutdinov. Using deep belief nets to learn covariance kernels for gaussian processes. In J. Platt, D. Koller, Y. Singer, and S. Roweis, editors, Advances in Neural Information Processing Systems, volume 20. Curran Associates, Inc., 2008.   \n[20] R. Johnson and T. Zhang. Semi-supervised convolutional neural networks for text categorization via region embedding. Advances in neural information processing systems, 28:919–927, 2015.   \n[21] V. Kaushal, R. Iyer, S. Kothawade, R. Mahadev, K. Doctor, and G. Ramakrishnan. Learning from less data: A unified data subset selection and active learning framework for computer vision. In 2019 IEEE Winter Conference on Applications of Computer Vision (WACV), pages 1289–1299. IEEE, 2019.   \n[22] R. Khanna, E. Elenberg, A. Dimakis, S. Negahban, and J. Ghosh. Scalable greedy feature selection via weak submodularity. In Artificial Intelligence and Statistics, pages 1560–1568. PMLR, 2017.   \n[23] K. Killamsetty, D. Sivasubramanian, B. Mirzasoleiman, G. Ramakrishnan, A. De, and R. Iyer. Grad-match: A gradient matching based data subset selection for efficient learning, 2021.   \n[24] K. Killamsetty, D. Sivasubramanian, G. Ramakrishnan, and R. Iyer. Glister: Generalization based data subset selection for efficient and robust learning, 2021.   \n[25] D. P. Kingma and J. Ba. Adam: A method for stochastic optimization. arXiv preprint arXiv:1412.6980, 2014.   \n[26] D. P. Kingma, S. Mohamed, D. Jimenez Rezende, and M. Welling. Semi-supervised learning with deep generative models. In Z. Ghahramani, M. Welling, C. Cortes, N. Lawrence, and K. Q. Weinberger, editors, Advances in Neural Information Processing Systems, volume 27. Curran Associates, Inc., 2014.   \n[27] A. Krizhevsky. Learning multiple layers of features from tiny images. Technical report, 2009.   \n[28] A. Krizhevsky, G. Hinton, et al. Learning multiple layers of features from tiny images. 2009.   \n[29] A. Lacoste, A. Luccioni, V. Schmidt, and T. Dandres. Quantifying the carbon emissions of machine learning. arXiv preprint arXiv:1910.09700, 2019.   \n[30] B. Lakshminarayanan, A. Pritzel, and C. Blundell. Simple and scalable predictive uncertainty estimation using deep ensembles. In I. Guyon, U. V. Luxburg, S. Bengio, H. Wallach, R. Fergus, S. Vishwanathan, and R. Garnett, editors, Advances in Neural Information Processing Systems, volume 30. Curran Associates, Inc., 2017.   \n[31] Y. LeCun, B. Boser, J. S. Denker, D. Henderson, R. E. Howard, W. Hubbard, and L. D. Jackel. Backpropagation applied to handwritten zip code recognition. Neural computation, 1(4):541–551, 1989.   \n[32] Y. LeCun and C. Cortes. MNIST handwritten digit database. 2010.   \n[33] B. Liu, Z. Wu, H. Hu, and S. Lin. Deep metric transfer for label propagation with limited annotated data, 2019.   \n[34] Y. Liu, R. Iyer, K. Kirchhoff, and J. Bilmes. SVitchboard II and FiSVer I: High-quality limitedcomplexity corpora of conversational English speech. In Sixteenth Annual Conference of the International Speech Communication Association, 2015.   \n[35] I. Loshchilov and F. Hutter. SGDR: stochastic gradient descent with restarts. CoRR, abs/1608.03983, 2016.   \n[36] A. L. Maas, R. E. Daly, P. T. Pham, D. Huang, A. Y. Ng, and C. Potts. Learning word vectors for sentiment analysis. In Proceedings of the 49th Annual Meeting of the Association for Computational Linguistics: Human Language Technologies, pages 142–150, Portland, Oregon, USA, June 2011. Association for Computational Linguistics.   \n[37] M. Minoux. Accelerated greedy algorithms for maximizing submodular set functions. In Optimization techniques, pages 234–243. Springer, 1978.   \n[38] B. Mirzasoleiman, A. Badanidiyuru, A. Karbasi, J. Vondrák, and A. Krause. Lazier than lazy greedy. In Proceedings of the Twenty-Ninth AAAI Conference on Artificial Intelligence, AAAI’15, page 1812–1818. AAAI Press, 2015.   \n[39] B. Mirzasoleiman, J. Bilmes, and J. Leskovec. Coresets for data-efficient training of machine learning models, 2020.   \n[40] B. Mirzasoleiman, K. Cao, and J. Leskovec. Coresets for robust training of deep neural networks against noisy labels. In H. Larochelle, M. Ranzato, R. Hadsell, M. F. Balcan, and H. Lin, editors, Advances in Neural Information Processing Systems, volume 33, pages 11465–11477. Curran Associates, Inc., 2020.   \n[41] T. Miyato, A. M. Dai, and I. J. Goodfellow. Adversarial training methods for semi-supervised text classification. In 5th International Conference on Learning Representations, ICLR 2017, Toulon, France, April 24-26, 2017, Conference Track Proceedings. OpenReview.net, 2017.   \n[42] T. Miyato, S. ichi Maeda, M. Koyama, and S. Ishii. Virtual adversarial training: A regularization method for supervised and semi-supervised learning, 2018.   \n[43] Y. Netzer, T. Wang, A. Coates, A. Bissacco, B. Wu, and A. Y. Ng. Reading digits in natural images with unsupervised feature learning. 2011.   \n[44] A. Oliver, A. Odena, C. Raffel, E. D. Cubuk, and I. J. Goodfellow. Realistic evaluation of deep semi-supervised learning algorithms, 2019.   \n[45] OpenAI, :, C. Berner, G. Brockman, B. Chan, V. Cheung, P. D˛ebiak, C. Dennison, D. Farhi, Q. Fischer, S. Hashme, C. Hesse, R. Józefowicz, S. Gray, C. Olsson, J. Pachocki, M. Petrov, H. P. d. O. Pinto, J. Raiman, T. Salimans, J. Schlatter, J. Schneider, S. Sidor, I. Sutskever, J. Tang, F. Wolski, and S. Zhang. Dota 2 with large scale deep reinforcement learning, 2019.   \n[46] A. Paszke, S. Gross, S. Chintala, G. Chanan, E. Yang, Z. DeVito, Z. Lin, A. Desmaison, L. Antiga, and A. Lerer. Automatic differentiation in pytorch. 2017.   \n[47] A. Paszke, S. Gross, F. Massa, A. Lerer, J. Bradbury, G. Chanan, T. Killeen, Z. Lin, N. Gimelshein, L. Antiga, A. Desmaison, A. Kopf, E. Yang, Z. DeVito, M. Raison, A. Tejani, S. Chilamkurthy, B. Steiner, L. Fang, J. Bai, and S. Chintala. Pytorch: An imperative style, high-performance deep learning library. In H. Wallach, H. Larochelle, A. Beygelzimer, F. d'Alché-Buc, E. Fox, and R. Garnett, editors, Advances in Neural Information Processing Systems 32, pages 8024–8035. Curran Associates, Inc., 2019.   \n[48] Y. Pu, Z. Gan, R. Henao, X. Yuan, C. Li, A. Stevens, and L. Carin. Variational autoencoder for deep learning of images, labels and captions. In D. Lee, M. Sugiyama, U. Luxburg, I. Guyon, and R. Garnett, editors, Advances in Neural Information Processing Systems, volume 29. Curran Associates, Inc., 2016.   \n[49] M. Ren, W. Zeng, B. Yang, and R. Urtasun. Learning to reweight examples for robust deep learning. In International Conference on Machine Learning, pages 4334–4343. PMLR, 2018.   \n[50] T. Salimans, I. Goodfellow, W. Zaremba, V. Cheung, A. Radford, X. Chen, and X. Chen. Improved techniques for training gans. In D. Lee, M. Sugiyama, U. Luxburg, I. Guyon, and R. Garnett, editors, Advances in Neural Information Processing Systems, volume 29. Curran Associates, Inc., 2016.   \n[51] O. Sener and S. Savarese. Active learning for convolutional neural networks: A core-set approach. In International Conference on Learning Representations, 2018.   \n[52] J. Shu, Q. Xie, L. Yi, Q. Zhao, S. Zhou, Z. Xu, and D. Meng. Meta-weight-net: Learning an explicit mapping for sample weighting. In Advances in Neural Information Processing Systems, 2019.   \n[53] K. Sohn, D. Berthelot, C.-L. Li, Z. Zhang, N. Carlini, E. D. Cubuk, A. Kurakin, H. Zhang, and C. Raffel. Fixmatch: Simplifying semi-supervised learning with consistency and confidence, 2020.   \n[54] E. Strubell, A. Ganesh, and A. McCallum. Energy and policy considerations for deep learning in nlp, 2019.   \n[55] C. Sun, A. Shrivastava, S. Singh, and A. Gupta. Revisiting unreasonable effectiveness of data in deep learning era, 2017.   \n[56] A. Tarvainen and H. Valpola. Mean teachers are better role models: Weight-averaged consistency targets improve semi-supervised deep learning results, 2018.   \n[57] K. Wei, R. Iyer, and J. Bilmes. Submodularity in data subset selection and active learning. In International Conference on Machine Learning, pages 1954–1963, 2015.   \n[58] K. Wei, Y. Liu, K. Kirchhoff, C. Bartels, and J. Bilmes. Submodular subset selection for large-scale speech training data. In 2014 IEEE International Conference on Acoustics, Speech and Signal Processing (ICASSP), pages 3311–3315. IEEE, 2014.   \n[59] Y. Yan, Z. Xu, I. W. Tsang, G. Long, and Y. Yang. Robust semi-supervised learning through label aggregation. In Thirtieth AAAI Conference on Artificial Intelligence, 2016.   \n[60] S. Zagoruyko and N. Komodakis. Wide residual networks, 2017.   \n[61] H. Zhang, M. Cisse, Y. N. Dauphin, and D. Lopez-Paz. mixup: Beyond empirical risk minimization, 2018.   \n[62] X. Zhu, Z. Ghahramani, and J. Lafferty. Semi-supervised learning using gaussian fields and harmonic functions. In Proceedings of the Twentieth International Conference on International Conference on Machine Learning, ICML’03, page 912–919. AAAI Press, 2003. ",
+        "bbox": [
+            173,
+            265,
+            828,
+            921
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            171,
+            60,
+            828,
+            915
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            171,
+            66,
+            828,
+            917
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            171,
+            77,
+            828,
+            842
+        ],
+        "page_idx": 13
+    }
+]

parse/train/rJeKjwvclx/rJeKjwvclx.md

@@ -0,0 +1,406 @@
+# DYNAMIC COATTENTION NETWORKS FOR QUESTION ANSWERING
+
+Caiming Xiong∗, Victor Zhong∗, Richard Socher
+
+Salesforce Research   
+Palo Alto, CA 94301, USA   
+{cxiong, vzhong, rsocher}@salesforce.com
+
+# ABSTRACT
+
+Several deep learning models have been proposed for question answering. However, due to their single-pass nature, they have no way to recover from local maxima corresponding to incorrect answers. To address this problem, we introduce the Dynamic Coattention Network (DCN) for question answering. The DCN first fuses co-dependent representations of the question and the document in order to focus on relevant parts of both. Then a dynamic pointing decoder iterates over potential answer spans. This iterative procedure enables the model to recover from initial local maxima corresponding to incorrect answers. On the Stanford question answering dataset, a single DCN model improves the previous state of the art from $7 1 . 0 \%$ F1 to $7 5 . 9 \%$ , while a DCN ensemble obtains $8 0 . 4 \%$ F1.
+
+# 1 INTRODUCTION
+
+Question answering (QA) is a crucial task in natural language processing that requires both natural language understanding and world knowledge. Previous QA datasets tend to be high in quality due to human annotation, but small in size (Berant et al., 2014; Richardson et al., 2013). Hence, they did not allow for training data-intensive, expressive models such as deep neural networks.
+
+To address this problem, researchers have developed large-scale datasets through semi-automated techniques (Hermann et al., 2015; Hill et al., 2016). Compared to their smaller, hand-annotated counterparts, these QA datasets allow the training of more expressive models. However, it has been shown that they differ from more natural, human annotated datasets in the types of reasoning required to answer the questions (Chen et al., 2016).
+
+Recently, Rajpurkar et al. (2016) released the Stanford Question Answering dataset (SQuAD), which is orders of magnitude larger than all previous hand-annotated datasets and has a variety of qualities that culminate in a natural QA task. SQuAD has the desirable quality that answers are spans in a reference document. This constrains answers to the space of all possible spans. However, Rajpurkar et al. (2016) show that the dataset retains a diverse set of answers and requires different forms of logical reasoning, including multi-sentence reasoning.
+
+We introduce the Dynamic Coattention Network (DCN), illustrated in Fig. 1, an end-to-end neural network for question answering. The model consists of a coattentive encoder that captures the interactions between the question and the document, as well as a dynamic pointing decoder that alternates between estimating the start and end of the answer span. Our single model obtains an F1 of $7 5 . 9 \%$ compared to the best published result of $7 1 . 0 \%$ (Yu et al., 2016). In addition, our ensemble model obtains an F1 of $8 0 . 4 \%$ compared to the second best result of $78 . 1 \%$ on the official SQuAD leaderboard.1
+
+# 2 DYNAMIC COATTENTION NETWORKS
+
+Figure 1 illustrates an overview of the DCN. We first describe the encoders for the document and the question, followed by the coattention mechanism and the dynamic decoder which produces the answer span.
+
+![](images/366b7e744a65a1c479359e0000da5451a5aa3e0614250d64bb4588d807625476.jpg)  
+Figure 1: Overview of the Dynamic Coattention Network.
+
+# 2.1 DOCUMENT AND QUESTION ENCODER
+
+Let (xQ1 , xQ2 , . . denote the sequence of word vectors corresponding to words in the question and $( x _ { 1 } ^ { D } , x _ { 2 } ^ { D } , \dots , x _ { m } ^ { D } )$ denote the same for words in the document. Using an LSTM (Hochreiter & Schmidhuber, 1997), we encode the document as: $d _ { t } = \mathrm { L S T M } _ { e n c } \left( d _ { t - 1 } , x _ { t } ^ { D } \right)$ . We define the document encoding matrix as $D = [ d _ { 1 } \ . . . \ d _ { m } \ d _ { \mathcal { O } } ] \in \mathbb { R } ^ { \ell \times ( m + 1 ) }$ . We also add a sentinel vector $d _ { \mathcal { O } }$ (Merity et al., 2016), which we later show allows the model to not attend to any particular word in the input.
+
+The question embeddings are computed with the same LSTM to share representation power: $q _ { t } =$ $\mathrm { L S T M } _ { e n c } \left( q _ { t - 1 } , x _ { t } ^ { Q } \right)$ We define an intermediate question representation $Q ^ { \prime } = [ q _ { 1 } \dots q _ { n } q _ { \emptyset } ] \in$ $\mathbb { R } ^ { \ell \times ( n + 1 ) }$ . To allow for variation between the question encoding space and the document encoding space, we introduce a non-linear projection layer on top of the question encoding. The final representation for the question becomes: $\begin{array} { r } { \dot { Q } = \operatorname { t a n h } \left( W ^ { ( Q ) } \bar { Q ^ { \prime } } + b ^ { ( Q ) } \right) \in \mathbb { R } ^ { \ell \times ( n + 1 ) } } \end{array}$ .
+
+# 2.2 COATTENTION ENCODER
+
+We propose a coattention mechanism that attends to the question and document simultaneously, similar to (Lu et al., 2016), and finally fuses both attention contexts. Figure 2 provides an illustration of the coattention encoder.
+
+We first compute the affinity matrix, which contains affinity scores corresponding to all pairs of document words and question words: $L = D ^ { \top } Q \in \mathbb { R } ^ { ( m + 1 ) \times ( n + 1 ) }$ . The affinity matrix is normalized row-wise to produce the attention weights $A ^ { Q }$ across the document for each word in the question, and column-wise to produce the attention weights $A ^ { D }$ across the question for each word in the document:
+
+$$
+A ^ { Q } = \operatorname { s o f t m a x } \left( L \right) \in \mathbb { R } ^ { ( m + 1 ) \times ( n + 1 ) } { \mathrm { ~ a n d ~ } } A ^ { D } = \operatorname { s o f t m a x } \left( L ^ { \top } \right) \in \mathbb { R } ^ { ( n + 1 ) \times ( m + 1 ) }
+$$
+
+Next, we compute the summaries, or attention contexts, of the document in light of each word of the question.
+
+$$
+C ^ { Q } = D A ^ { Q } \in \mathbb { R } ^ { \ell \times ( n + 1 ) } .
+$$
+
+![](images/659657d3664439f5aaf2ad20059c8aff9fa095ee215405eee86563f70a315687.jpg)  
+Figure 2: Coattention encoder. The affinity matrix $L$ is not shown here. We instead directly show the normalized attention weights $A ^ { D }$ and $\dot { A } ^ { Q }$ .
+
+We similarly compute the summaries $Q A ^ { D }$ of the question in light of each word of the document. Similar to Cui et al. (2016), we also compute the summaries $C ^ { \mathcal { { Q } } } A ^ { D }$ of the previous attention contexts in light of each word of the document. These two operations can be done in parallel, as is shown in Eq. 3. One possible interpretation for the operation $C ^ { Q } A ^ { D }$ is the mapping of question encoding into space of document encodings.
+
+$$
+C ^ { D } = \left[ Q ; C ^ { Q } \right] A ^ { D } \in \mathbb { R } ^ { 2 \ell \times ( m + 1 ) } .
+$$
+
+We define $C ^ { D }$ , a co-dependent representation of the question and document, as the coattention context. We use the notation $[ a ; b ]$ for concatenating the vectors $a$ and $b$ horizontally.
+
+The last step is the fusion of temporal information to the coattention context via a bidirectional LSTM:
+
+$$
+\boldsymbol { u } _ { t } = \mathrm { B i - L S T M } \left( u _ { t - 1 } , u _ { t + 1 } , \left[ d _ { t } ; c _ { t } ^ { D } \right] \right) \in \mathbb { R } ^ { 2 \ell } .
+$$
+
+We define $U = [ u _ { 1 } , \dots , u _ { m } ] \in \mathbb { R } ^ { 2 \ell \times m }$ , which provides a foundation for selecting which span may be the best possible answer, as the coattention encoding.
+
+# 2.3 DYNAMIC POINTING DECODER
+
+Due to the nature of SQuAD, an intuitive method for producing the answer span is by predicting the start and end points of the span (Wang & Jiang, 2016b). However, given a question-document pair, there may exist several intuitive answer spans within the document, each corresponding to a local maxima. We propose an iterative technique to select an answer span by alternating between predicting the start point and predicting the end point. This iterative procedure allows the model to recover from initial local maxima corresponding to incorrect answer spans.
+
+Figure 3 provides an illustration of the Dynamic Decoder, which is similar to a state machine whose state is maintained by an LSTM-based sequential model. During each iteration, the decoder updates its state taking into account the coattention encoding corresponding to current estimates of the start and end positions, and produces, via a multilayer neural network, new estimates of the start and end positions.
+
+Let $h _ { i } , s _ { i }$ , and $e _ { i }$ denote the hidden state of the LSTM, the estimate of the position, and the estimate of the end position during iteration $i$ . The LSTM state update is then described by Eq. 5.
+
+$$
+h _ { i } = \mathrm { L S T M } _ { d e c } \left( h _ { i - 1 } , \left[ u _ { s _ { i - 1 } } ; u _ { e _ { i - 1 } } \right] \right)
+$$
+
+where $u _ { s _ { i - 1 } }$ and $u _ { e _ { i - 1 } }$ are the representations corresponding to the previous estimate of the start and end positions in the coattention encoding $U$ .
+
+![](images/6b17096e746bf2a05c497268ea80bc69a1959ba4479008235c346ae565e33292.jpg)  
+Figure 3: Dynamic Decoder. Blue denotes the variables and functions related to estimating the start position whereas red denotes the variables and functions related to estimating the end position.
+
+Given the current hidden state $h _ { i }$ , previous start position $u _ { s _ { i - 1 } }$ , and previous end position $u _ { e _ { i - 1 } }$ , we estimate the current start position and end position via Eq. 6 and Eq. 7.
+
+$$
+\begin{array} { c } { s _ { i } = \underset { t } { \operatorname { a r g m a x } } \left( \alpha _ { 1 } , \ldots , \alpha _ { m } \right) } \\ { \ } \\ { e _ { i } = \underset { t } { \operatorname { a r g m a x } } \left( \beta _ { 1 } , \ldots , \beta _ { m } \right) } \end{array}
+$$
+
+where $\alpha _ { t }$ and $\beta _ { t }$ represent the start score and end score corresponding to the tth word in the document. We compute $\alpha _ { t }$ and $\beta _ { t }$ with separate neural networks. These networks have the same architecture but do not share parameters.
+
+Based on the strong empirical performance of Maxout Networks (Goodfellow et al., 2013) and Highway Networks (Srivastava et al., 2015), especially with regards to deep architectures, we propose a Highway Maxout Network (HMN) to compute $\alpha _ { t }$ as described by Eq. 8. The intuition behind using such model is that the QA task consists of multiple question types and document topics. These variations may require different models to estimate the answer span. Maxout provides a simple and effective way to pool across multiple model variations.
+
+$$
+\alpha _ { t } = \mathrm { H M N } _ { s t a r t } \left( u _ { t } , h _ { i } , u _ { s _ { i - 1 } } , u _ { e _ { i - 1 } } \right)
+$$
+
+Here, $u _ { t }$ is the coattention encoding corresponding to the $t$ th word in the document. $\mathrm { H M N } _ { s t a r t }$ is illustrated in Figure 4. The end score, $\beta _ { t }$ , is computed similarly to the start score $\alpha _ { t }$ , but using a separate $\mathrm { H M N } _ { e n d }$ .
+
+We now describe the HMN model:
+
+$$
+\begin{array} { r c l } { { \mathrm { H M N } \left( u _ { t } , h _ { i } , u _ { s _ { i - 1 } } , u _ { e _ { i - 1 } } \right) } } & { { = } } & { { \operatorname* { m a x } \left( W ^ { ( 3 ) } \left[ m _ { t } ^ { ( 1 ) } ; m _ { t } ^ { ( 2 ) } \right] + b ^ { ( 3 ) } \right) } } \\ { { r } } & { { = } } & { { \operatorname { t a n h } \left( W ^ { ( D ) } \left[ h _ { i } ; u _ { s _ { i - 1 } } ; u _ { e _ { i - 1 } } \right] \right) } } \\ { { m _ { t } ^ { ( 1 ) } } } & { { = } } & { { \operatorname* { m a x } \left( W ^ { ( 1 ) } \left[ u _ { t } ; r \right] + b ^ { ( 1 ) } \right) } } \\ { { m _ { t } ^ { ( 2 ) } } } & { { = } } & { { \operatorname* { m a x } \left( W ^ { ( 2 ) } m _ { t } ^ { ( 1 ) } + b ^ { ( 2 ) } \right) } } \end{array}
+$$
+
+where $r \in \mathbb { R } ^ { \ell }$ is a non-linear projection of the current state with parameters $W ^ { ( D ) } \in \mathbb { R } ^ { \ell \times 5 \ell }$ , $m _ { t } ^ { ( 1 ) }$ is the output of the first maxout layer with parameters $W ^ { ( 1 ) } \in \mathbb { R } ^ { p \times \ell \times 3 \ell }$ and $b ^ { ( 1 ) } \in \mathbb { R } ^ { p \times \ell }$ , and $m _ { t } ^ { ( 2 ) }$ is the output of the second maxout layer with parameters $W ^ { ( 2 ) } \in \mathbb { R } ^ { p \times \ell \times \ell }$ and $b ^ { ( 2 ) } \in \mathbb { R } ^ { p \times \ell }$ . $m _ { t } ^ { ( 1 ) }$ and m(2)t a re fed into the final maxout layer, which has parameters $W ^ { ( 3 ) } \in \mathbb { R } ^ { p \times 1 \times 2 \ell }$ , and $b ^ { ( 3 ) } \in \mathbb { R } ^ { p }$ . $p$ is the pooling size of each maxout layer. The max operation computes the maximum value over the first dimension of a tensor. We note that there is highway connection between the output of the first maxout layer and the last maxout layer.
+
+To train the network, we minimize the cumulative softmax cross entropy of the start and end points across all iterations. The iterative procedure halts when both the estimate of the start position and the estimate of the end position no longer change, or when a maximum number of iterations is reached. Details can be found in Section 4.1
+
+![](images/34c9b1af90d072819538f6780f37239b9e8f6a72c45b555988700cec3a94e07c.jpg)  
+Figure 4: Highway Maxout Network. Dotted lines denote highway connections.
+
+# 3 RELATED WORK
+
+Statistical QA Traditional approaches to question answering typically involve rule-based algorithms or linear classifiers over hand-engineered feature sets. Richardson et al. (2013) proposed two baselines, one that uses simple lexical features such as a sliding window to match bags of words, and another that uses word-distances between words in the question and in the document. Berant et al. (2014) proposed an alternative approach in which one first learns a structured representation of the entities and relations in the document in the form of a knowledge base, then converts the question to a structured query with which to match the content of the knowledge base. Wang et al. (2015) described a statistical model using frame semantic features as well as syntactic features such as part of speech tags and dependency parses. Chen et al. (2016) proposed a competitive statistical baseline using a variety of carefully crafted lexical, syntactic, and word order features.
+
+Neural QA Neural attention models have been widely applied for machine comprehension or question-answering in NLP. Hermann et al. (2015) proposed an AttentiveReader model with the release of the CNN/Daily Mail cloze-style question answering dataset. Hill et al. (2016) released another dataset steming from the children’s book and proposed a window-based memory network. Kadlec et al. (2016) presented a pointer-style attention mechanism but performs only one attention step. Sordoni et al. (2016) introduced an iterative neural attention model and applied it to cloze-style machine comprehension tasks.
+
+Recently, Rajpurkar et al. (2016) released the SQuAD dataset. Different from cloze-style queries, answers include non-entities and longer phrases, and questions are more realistic. For SQuAD, Wang & Jiang (2016b) proposed an end-to-end neural network model that consists of a Match-LSTM encoder, originally introduced in Wang & Jiang (2016a), and a pointer network decoder (Vinyals et al., 2015); Yu et al. (2016) introduced a dynamic chunk reader, a neural reading comprehension model that extracts a set of answer candidates of variable lengths from the document and ranks them to answer the question.
+
+Lu et al. (2016) proposed a hierarchical co-attention model for visual question answering, which achieved state of the art result on the COCO-VQA dataset (Antol et al., 2015). In (Lu et al., 2016), the co-attention mechanism computes a conditional representation of the image given the question, as well as a conditional representation of the question given the image.
+
+Inspired by the above works, we propose a dynamic coattention model (DCN) that consists of a novel coattentive encoder and dynamic decoder. In our model, instead of estimating the start and end positions of the answer span in a single pass (Wang & Jiang, 2016b), we iteratively update the start and end positions in a similar fashion to the Iterative Conditional Modes algorithm (Besag, 1986).
+
+Table 1: Leaderboard performance at the time of writing (Nov 4 2016). ∗ indicates that the model used for submission is unpublished. − indicates that the development scores were not publicly available at the time of writing.   
+
+<table><tr><td>Model</td><td>Dev EM</td><td>Dev F1</td><td>Test EM</td><td>Test F1</td></tr><tr><td>Ensemble</td><td></td><td></td><td></td><td></td></tr><tr><td>DCN (Ours)</td><td>70.3</td><td>79.4</td><td>71.2</td><td>80.4</td></tr><tr><td>Microsoft Research Asia *</td><td>一</td><td>1</td><td>69.4</td><td>78.3</td></tr><tr><td>Allen Institute *</td><td>69.2</td><td>77.8</td><td>69.9</td><td>78.1</td></tr><tr><td>Singapore Management University *</td><td>67.6</td><td>76.8</td><td>67.9</td><td>77.0</td></tr><tr><td>Google NYC *</td><td>68.2</td><td>76.7</td><td>一</td><td></td></tr><tr><td>Single model</td><td></td><td></td><td></td><td></td></tr><tr><td>DCN (Ours)</td><td>65.4</td><td>75.6</td><td>66.2</td><td>75.9</td></tr><tr><td>Microsoft Research Asia *</td><td>65.9</td><td>75.2</td><td>65.5</td><td>75.0</td></tr><tr><td>Google NYC *</td><td>66.4</td><td>74.9</td><td>1</td><td>1</td></tr><tr><td>Singapore Management University *</td><td>1</td><td>1</td><td>64.7</td><td>73.7</td></tr><tr><td>Carnegie Mellon University</td><td>1</td><td>1</td><td>62.5</td><td>73.3</td></tr><tr><td>Dynamic Chunk Reader (Yu et al., 2016)</td><td>62.5</td><td>71.2</td><td>62.5</td><td>71.0</td></tr><tr><td>Match-LSTM (Wang &amp; Jiang,2016b)</td><td>59.1</td><td>70.0</td><td>59.5</td><td>70.3</td></tr><tr><td>Baseline (Rajpurkar et al., 2016)</td><td>40.0</td><td>51.0</td><td>40.4</td><td>51.0</td></tr><tr><td>Human (Rajpurkar et al., 2016)</td><td>81.4</td><td>91.0</td><td>82.3</td><td>91.2</td></tr></table>
+
+# 4 EXPERIMENTS
+
+# 4.1 IMPLEMENTATION DETAILS
+
+We train and evaluate our model on the SQuAD dataset. To preprocess the corpus, we use the tokenizer from Stanford CoreNLP (Manning et al., 2014). We use as GloVe word vectors pretrained on the 840B Common Crawl corpus (Pennington et al., 2014). We limit the vocabulary to words that are present in the Common Crawl corpus and set embeddings for out-of-vocabulary words to zero. Empirically, we found that training the embeddings consistently led to overfitting and subpar performance, and hence only report results with fixed word embeddings.
+
+We use a max sequence length of 600 during training and a hidden state size of 200 for all recurrent units, maxout layers, and linear layers. All LSTMs have randomly initialized parameters and an initial state of zero. Sentinel vectors are randomly initialized and optimized during training. For the dynamic decoder, we set the maximum number of iterations to 4 and use a maxout pool size of 16. We use dropout to regularize our network during training (Srivastava et al., 2014), and optimize the model using ADAM (Kingma & Ba, 2014). All models are implemented and trained with Chainer (Tokui et al., 2015).
+
+# 4.2 RESULTS
+
+Evaluation on the SQuAD dataset consists of two metrics. The exact match score (EM) calculates the exact string match between the predicted answer and a ground truth answer. The F1 score calculates the overlap between words in the predicted answer and a ground truth answer. Because a document-question pair may have several ground truth answers, the EM and F1 for a documentquestion pair is taken to be the maximum value across all ground truth answers. The overall metric is then computed by averaging over all document-question pairs. The offical SQuAD evaluation is hosted on CodaLab 2. The training and development sets are publicly available while the test set is withheld.
+
+The performance of the Dynamic Coattention Network on the SQuAD dataset, compared to other submitted models on the leaderboard 3, is shown in Table 1. At the time of writing, our singlemodel DCN ranks first at $6 6 . 2 \%$ exact match and $7 5 . 9 \%$ F1 on the test data among single-model submissions. Our ensemble DCN ranks first overall at $7 1 . 6 \%$ exact match and $8 0 . 4 \%$ F1 on the test data.
+
+The DCN has the capability to estimate the start and end points of the answer span multiple times, each time conditioned on its previous estimates. By doing so, the model is able to explore local maxima corresponding to multiple plausible answers, as is shown in Figure 5.
+
+![](images/c3102bd8496d3d4cf1baf2bcf5fff89efedb6e23756c3ea7ee32a876b2887df7.jpg)  
+Question 1: Who recovered Tolbert's fumble?
+
+![](images/a845dc12bdf8267e6cba84587670144160e05035c8b5b3713d05e247bc5ea6f6.jpg)
+
+![](images/085444cc5b6dcb9a4ec51b52f4a781f31f790443b465e8a01b0e5d0fd4bca99f.jpg)  
+Question 3: What kind of weapons did Tesla's treatise concern?   
+Figure 5: Examples of the start and end conditional distributions produced by the dynamic decoder. Odd (blue) rows denote the start distributions and even (red) rows denote the end distributions. i indicates the iteration number of the dynamic decoder. Higher probability mass is indicated by darker regions. The offset corresponding to the word with the highest probability mass is shown on the right hand side. The predicted span is underlined in red, and a ground truth answer span is underlined in green.
+
+For example, Question 1 in Figure 5 demonstrates an instance where the model initially guesses an incorrect start point and a correct end point. In subsequent iterations, the model adjusts the start point, ultimately arriving at the correct start point in iteration 3. Similarly, the model gradually shifts probability mass for the end point to the correct word.
+
+Question 2 shows an example in which both the start and end estimates are initially incorrect. The model then settles on the correct answer in the next iteration.
+
+![](images/587fa0e39bc3021fe61bff9f3565c68bc05181a466d0bc36dfea698f3988018c.jpg)  
+Figure 6: Performance of the DCN for various lengths of documents, questions, and answers. The blue dot indicates the mean F1 at given length. The vertical bar represents the standard deviation of F1s at a given length.
+
+While the dynamic nature of the decoder allows the model to escape initial local maxima corresponding to incorrect answers, Question 3 demonstrates a case where the model is unable to decide between multiple local maxima despite several iterations. Namely, the model alternates between the answers “charged particle beam” and “particle beam weapons” indefinitely. Empirically, we observe that the model, trained with a maximum iteration of 4, takes 2.7 iterations to converge to an answer on average.
+
+Model Ablation The performance of our model and its ablations on the SQuAD development set is shown in Table 2. On the decoder side, we experiment with various pool sizes for the HMN maxout layers, using a 2-layer MLP instead of a HMN, and forcing the HMN decoder to a single iteration. Empirically, we achieve the best performance on the development set with an iterative HMN
+
+Table 2: Single model ablations on the development set.   
+
+<table><tr><td>Model</td><td>Dev EM</td><td>Dev F1</td></tr><tr><td>Dynamic Coattention Network (DCN)</td><td></td><td></td></tr><tr><td>pool size 16 HMN</td><td>65.4</td><td>75.6</td></tr><tr><td>pool size 8 HMN</td><td>64.4</td><td>74.9</td></tr><tr><td>pool size 4 HMN</td><td>65.2</td><td>75.2</td></tr><tr><td>DCN with 2-layer MLP instead of HMN</td><td>63.8</td><td>74.4</td></tr><tr><td>DCN with single iteration decoder</td><td>63.7</td><td>74.0</td></tr><tr><td>DCN with Wang &amp; Jiang (2016b) attention</td><td>63.7</td><td>73.7</td></tr></table>
+
+with pool size 16, and find that the model consistently benefits from a deeper, iterative decoder network. The performance improves as the number of maximum allowed iterations increases, with little improvement after 4 iterations. On the encoder side, replacing the coattention mechanism with an attention mechanism similar to Wang & Jiang (2016b) by setting $C ^ { D }$ to $Q A ^ { D }$ in equation 3 results in a 1.9 point F1 drop. This suggests that, at an additional cost of a softmax computation and a dot product, the coattention mechanism provides a simple and effective means to better encode the document and question sequences. Further studies, such as performance without attention and performance on questions requiring different types of reasoning can be found in the appendix.
+
+Performance across length One point of interest is how the performance of the DCN varies with respect to the length of document. Intuitively, we expect the model performance to deteriorate with longer examples, as is the case with neural machine translation (Luong et al., 2015). However, as in shown in Figure 6, there is no notable performance degradation for longer documents and questions contrary to our expectations. This suggests that the coattentive encoder is largely agnostic to long documents, and is able to focus on small sections of relevant text while ignoring the rest of the (potentially very long) document. We do note a performance degradation with longer answers. However, this is intuitive given the nature of the evaluation metric. Namely, it becomes increasingly challenging to compute the correct word span as the number of words increases.
+
+![](images/653f0cc5f5b4e69dc4ebc621a1c337abbcdd7c24b52621540fafc0ac3422a7ea.jpg)  
+Figure 7: Performance of the DCN across question types. The height of each bar represents the mean F1 for the given question type. The lower number denotes how many instances in the dev set are of the corresponding question type.
+
+Performance across question type Another natural way to analyze the performance of the model is to examine its performance across question types. In Figure 7, we note that the mean F1 of DCN exceeds those of previous systems (Wang & Jiang, 2016b; Yu et al., 2016) across all question types. The DCN, like other models, is adept at “when” questions and struggles with the more complex “why” questions.
+
+Breakdown of F1 distribution Finally, we note that the DCN performance is highly bimodal. On the development set, the model perfectly predicts $100 \%$ F1) an answer for $6 2 . 2 \%$ of examples and predicts a completely wrong answer $0 \%$ F1) for $1 6 . 3 \%$ of examples. That is, the model picks out partial answers only $2 1 . 5 \%$ of the time. Upon qualitative inspections of the $0 \%$ F1 answers, some of which are shown in Appendix A.4, we observe that when the model is wrong, its mistakes tend to have the correct “answer type” (eg. person for a “who” question, method for a “how” question) and the answer boundaries encapsulate a well-defined phrase.
+
+# 5 CONCLUSION
+
+We proposed the Dynamic Coattention Network, an end-to-end neural network architecture for question answering. The DCN consists of a coattention encoder which learns co-dependent representations of the question and of the document, and a dynamic decoder which iteratively estimates the answer span. We showed that the iterative nature of the model allows it to recover from initial local maxima corresponding to incorrect predictions. On the SQuAD dataset, the DCN achieves the state of the art results at $7 5 . 9 \%$ F1 with a single model and $8 0 . 4 \%$ F1 with an ensemble. The DCN significantly outperforms all other models.
+
+# ACKNOWLEDGMENTS
+
+We thank Kazuma Hashimoto and Bryan McCann for their help and insights.
+
+# REFERENCES
+
+Stanislaw Antol, Aishwarya Agrawal, Jiasen Lu, Margaret Mitchell, Dhruv Batra, C Lawrence Zitnick, and Devi Parikh. Vqa: Visual question answering. In Proceedings of the IEEE International Conference on Computer Vision, pp. 2425–2433, 2015.
+
+Jonathan Berant, Vivek Srikumar, Pei-Chun Chen, Abby Vander Linden, Brittany Harding, Brad Huang, Peter Clark, and Christopher D Manning. Modeling biological processes for reading comprehension. In EMNLP, 2014.
+
+Julian Besag. On the statistical analysis of dirty pictures. Journal of the Royal Statistical Society. Series B (Methodological), pp. 259–302, 1986.
+
+Danqi Chen, Jason Bolton, and Christopher D. Manning. A thorough examination of the cnn/daily mail reading comprehension task. In Association for Computational Linguistics (ACL), 2016.
+
+Yiming Cui, Zhipeng Chen, Si Wei, Shijin Wang, Ting Liu, and Guoping Hu. Attention-overattention neural networks for reading comprehension. arXiv preprint arXiv:1607.04423, 2016.
+
+Ian J Goodfellow, David Warde-Farley, Mehdi Mirza, Aaron C Courville, and Yoshua Bengio. Maxout networks. ICML (3), 28:1319–1327, 2013.
+
+Karl Moritz Hermann, Tomas Kocisky, Edward Grefenstette, Lasse Espeholt, Will Kay, Mustafa Suleyman, and Phil Blunsom. Teaching machines to read and comprehend. In Advances in Neural Information Processing Systems, pp. 1693–1701, 2015.
+
+Felix Hill, Antoine Bordes, Sumit Chopra, and Jason Weston. The goldilocks principle: Reading children’s books with explicit memory representations. In ICLR, 2016.
+
+Sepp Hochreiter and Jurgen Schmidhuber. Long short-term memory. ¨ Neural computation, 9(8): 1735–1780, 1997.
+
+Rudolf Kadlec, Martin Schmid, Ondrej Bajgar, and Jan Kleindienst. Text understanding with the attention sum reader network. arXiv preprint arXiv:1603.01547, 2016.
+
+Diederik Kingma and Jimmy Ba. Adam: A method for stochastic optimization. arXiv preprint arXiv:1412.6980, 2014.
+
+Jiasen Lu, Jianwei Yang, Dhruv Batra, and Devi Parikh. Hierarchical question-image co-attention for visual question answering. arXiv preprint arXiv:1606.00061, 2016.
+
+Christopher D Manning, Mihai Surdeanu, John Bauer, Jenny Rose Finkel, Steven Bethard, and David McClosky. The stanford corenlp natural language processing toolkit. In ACL (System Demonstrations), pp. 55–60, 2014.
+
+Stephen Merity, Caiming Xiong, James Bradbury, and Richard Socher. Pointer sentinel mixture models. arXiv preprint arXiv:1609.07843, 2016.
+
+Jeffrey Pennington, Richard Socher, and Christopher D Manning. Glove: Global vectors for word representation. In EMNLP, volume 14, pp. 1532–43, 2014.
+
+P. Rajpurkar, J. Zhang, K. Lopyrev, and P. Liang. Squad: $1 0 0 { , } 0 0 0 { + }$ questions for machine comprehension of text. In Empirical Methods in Natural Language Processing (EMNLP), 2016.
+
+Matthew Richardson, Christopher JC Burges, and Erin Renshaw. Mctest: A challenge dataset for the open-domain machine comprehension of text. In EMNLP, volume 3, pp. 4, 2013.
+
+Alessandro Sordoni, Phillip Bachman, and Yoshua Bengio. Iterative alternating neural attention for machine reading. arXiv preprint arXiv:1606.02245, 2016.
+
+Nitish Srivastava, Geoffrey E Hinton, Alex Krizhevsky, Ilya Sutskever, and Ruslan Salakhutdinov. Dropout: a simple way to prevent neural networks from overfitting. Journal of Machine Learning Research, 15(1):1929–1958, 2014.
+
+Rupesh K Srivastava, Klaus Greff, and Juergen Schmidhuber. Training very deep networks. In Advances in Neural Information Processing Systems 28, pp. 2377–2385, 2015.
+
+Seiya Tokui, Kenta Oono, Shohei Hido, and Justin Clayton. Chainer: a next-generation open source framework for deep learning. In Proceedings of Workshop on Machine Learning Systems (LearningSys) in The Twenty-ninth Annual Conference on Neural Information Processing Systems (NIPS), 2015.
+
+Oriol Vinyals, Meire Fortunato, and Navdeep Jaitly. Pointer networks. In Advances in Neural Information Processing Systems, pp. 2692–2700, 2015.
+
+Hai Wang, Mohit Bansal, Kevin Gimpel, and David McAllester. Machine comprehension with syntax, frames, and semantics. In Proceedings of the 53rd Annual Meeting of the Association for Computational Linguistics and the 7th International Joint Conference on Natural Language Processing (Volume 2: Short Papers), pp. 700–706. Association for Computational Linguistics, 2015.
+
+Shuohang Wang and Jing Jiang. Learning natural language inference with LSTM. In Proceedings of the 2016 Conference of the North American Chapter of the Association for Computational Linguistics: Human Language Technologies, pp. 1442–1451. Association for Computational Linguistics, 2016a.
+
+Shuohang Wang and Jing Jiang. Machine comprehension using match-LSTM and answer pointer. arXiv preprint arXiv:1608.07905, 2016b.
+
+Y. Yu, W. Zhang, K. Hasan, M. Yu, B. Xiang, and B. Zhou. End-to-End Reading Comprehension with Dynamic Answer Chunk Ranking. ArXiv e-prints, October 2016.
+
+Yang Yu, Wei Zhang, Kazi Hasan, Mo Yu, Bing Xiang, and Bowen Zhou. End-to-end answer chunk extraction and ranking for reading comprehension. arXiv preprint arXiv:1610.09996v2, 2016.
+
+# A APPENDIX
+
+# A.1 PERFORMANCE WITHOUT ATTENTION
+
+In our experiments, we also investigate a model without any attention mechanism. In this model, the encoder is a simple LSTM network that first ingests the question and then ingests the document. The hidden states corresponding to words in the document is then passed to the decoder. This model achieves $3 3 . 3 \%$ exact match and $4 1 . 9 \%$ F1, significantly worse than models with attention.
+
+# A.2 SAMPLES REQUIRING DIFFERENT TYPES OF REASONING
+
+We generate predictions for examples requiring different types of reasoning, given by Rajpurkar et al. (2016). Because this set of examples is very limited, they do not conclusively demonstrate the effectiveness of the model on different types of reasoning tasks. Nevertheless, these examples show that the DCN is a promising architecture for challenging question answering tasks including those that involve reasoning over multiple sentences.
+
+WHAT IS THE RANKINE CYCLE SOMETIMES CALLED?
+
+The Rankine cycle is sometimes referred to as a practical Carnot cycle because, when an efficient turbine is used, the TS diagram begins to resemble the Carnot cycle.
+
+Type of reasoning Lexical variation (synonymy)
+
+Ground truth practical Carnot cycle
+
+Prediction practical Carnot cycle
+
+WHICH TWO GOVERNING BODIES HAVE LEGISLATIVE VETO POWER?
+
+While the Commision has a monopoly on initiating legislation, the European Parliament and the Council of the European Union have powers of amendment and veto during the legislative progress.
+
+Type of reasoning Lexical variation (world knowledge)
+
+Ground truth the European Parliament and the Council of the European Union
+
+Prediction European Parliament and the Council of the European Union
+
+WHAT SHAKESPEARE SCHOLAR IS CURRENTLY ON THE UNIVERSITYS FACULTY?
+
+Current faculty include the anthropologist Marshall Sahlins, historian Dipesh Chakrabarty, ... Shakespeare scholar David Bevington, and renowned political scientists John Mearsheimer and Robert Pape.
+
+Type of reasoning Syntactic variation
+
+Ground truth David Bevington
+
+Prediction David Bevington
+
+WHAT COLLECTION DOES THE V&A THEATRE & PERFORMANCE GALLERIES HOLD?
+
+The V&A Theatre & Performance galleries, formerly the Theatre Museum, opened in March 2009. The collections are stored by the V&A, and are available for research, exhibitions and other shows. They hold the UK’s biggest national collection of material about live performance in the UK since Shakespeare’s day, covering drama, dance, musical theatre, circus, music hall, rock and pop, and most other forms of live entertainment.
+
+Type of reasoning Multiple sentence reasoning
+
+Ground truth Material about live performance
+
+Prediction UK’s biggest national collection of material about live performance in the UK since Shakespeare’s day
+
+WHAT IS THE MAIN GOAL OF CRIMINAL PUNISHMENT OF CIVIL DISOBEDIENTS?
+
+# Type of reasoning Ambiguous
+
+Along with giving the offender his ”just deserts”, achieving crime control via incapacitation and deterrence is a major goal of crime punishment.
+
+Ground truth achieving crime control via incapacitation and deterrence
+
+Prediction achieving crime control via incapacitation and deterrence
+
+A.3 SAMPLES OF CORRECT SQUAD PREDICTIONS BY THE DYNAMIC COATTENTION NETWORK
+
+HOW DID THE MONGOLS ACQUIRE CHINESE PRINTING TECHNOLOGY?
+
+ID: 572882242ca10214002da420
+
+The Mongol rulers patronized the Yuan printing industry. Chinese printing technology was transferred to the Mongols through Kingdom of Qocho and Tibetan intermediaries. Some Yuan documents such as Wang Zhen’s Nong Shu were printed with earthenware movable type, a technology invented in the 12th century. However, most published works were still produced through traditional block printing techniques. The publication of a Taoist text inscribed with the name of Tregene Khatun, gedei’s wife, is one of the first printed works sponsored by the Mongols. In 1273, the Mongols created the Imperial Library Directorate, a government-sponsored printing office. The Yuan government established centers for printing throughout China. Local schools and government agencies were funded to support the publishing of books.
+
+Ground truth through Kingdom of Qocho and Tibetan intermediaries
+
+Prediction: through Kingdom of Qocho and Tibetan intermediaries
+
+WHO APPOINTS ELDERS?
+
+ID 5730d473b7151e1900c0155b
+
+Elders are called by God, affirmed by the church, and ordained by a bishop to a ministry of Word, Sacrament, Order and Service within the church. They may be appointed to the local church, or to other valid extension ministries of the church. Elders are given the authority to preach the Word of God, administer the sacraments of the church, to provide care and counseling, and to order the life of the church for ministry and mission. Elders may also be assigned as District Superintendents, and they are eligible for election to the episcopacy. Elders serve a term of 23 years as provisional Elders prior to their ordination.
+
+Ground truth bishop, the local church
+
+Prediction a bishop
+
+AN ALGORITHM FOR X WHICH REDUCES TO C WOULD ALLOW US TO DO WHAT?
+
+ID 56e1ce08e3433e14004231a6
+
+This motivates the concept of a problem being hard for a complexity class. A problem X is hard for a class of problems C if every problem in C can be reduced to X. Thus no problem in C is harder than X, since an algorithm for X allows us to solve any problem in C. Of course, the notion of hard problems depends on the type of reduction being used. For complexity classes larger than P, polynomial-time reductions are commonly used. In particular, the set of problems that are hard for NP is the set of NP-hard problems.
+
+Ground truth solve any problem in C
+
+Prediction solve any problem in C
+
+HOW MANY GENERAL QUESTIONS ARE AVAILABLE TO OPPOSITION LEADERS?
+
+ID 572fd7b8947a6a140053cd3e
+
+Parliamentary time is also set aside for question periods in the debating chamber. A ”General Question Time” takes place on a Thursday between $1 1 { : } 4 0 \ \mathrm { a . m }$ . and $1 2 \ \mathrm { p . m }$ . where members can direct questions to any member of the Scottish Government. At $2 . 3 0 \mathrm { p m }$ , a 40-minute long themed ”Question Time” takes place, where members can ask questions of ministers in departments that are selected for questioning that sitting day, such as health and justice or education and transport. Between $1 2 \ \mathrm { p . m }$ . and $1 2 { : } 3 0 ~ \mathrm { p . m }$ . on Thursdays, when Parliament is sitting, First Minister’s Question Time takes place. This gives members an opportunity to question the First Minister directly on issues under their jurisdiction. Opposition leaders ask a general question of the First Minister and then supplementary questions. Such a practice enables a ”lead-in” to the questioner, who then uses their supplementary question to ask the First Minister any issue. The four general questions available to opposition leaders are:
+
+# Ground truth four
+
+# Prediction four
+
+WHAT ARE SOME OF THE ACCEPTED GENERAL PRINCIPLES OF EUROPEAN UNION LAW?
+
+ID 5726a00cf1498d1400e8e551
+
+The principles of European Union law are rules of law which have been developed by the European Court of Justice that constitute unwritten rules which are not expressly provided for in the treaties but which affect how European Union law is interpreted and applies. In formulating these principles, the courts have drawn on a variety of sources, including: public international law and legal doctrines and principles present in the legal systems of European Union member states and in the jurisprudence of the European Court of Human Rights. Accepted general principles of European Union Law include fundamental rights (see human rights), proportionality, legal certainty, equality before the law and subsidiarity.
+
+Ground truth fundamental rights (see human rights), proportionality, legal certainty, equality before the law and subsidiarity
+
+Prediction fundamental rights (see human rights), proportionality, legal certainty, equality before the law and subsidiarity
+
+WHY WAS TESLA RETURNED TO GOSPIC?
+
+ID 56dfaa047aa994140058dfbd
+
+On 24 March 1879, Tesla was returned to Gospi under police guard for not having a residence permit. On 17 April 1879, Milutin Tesla died at the age of 60 after contracting an unspecified illness (although some sources say that he died of a stroke). During that year, Tesla taught a large class of students in his old school, Higher Real Gymnasium, in Gospi.
+
+Ground truth not having a residence permit
+
+Prediction not having a residence permit
+
+A.4 SAMPLES OF INCORRECT SQUAD PREDICTIONS BY THE DYNAMIC COATTENTION NETWORK
+
+WHAT IS ONE SUPPLEMENTARY SOURCE OF EUROPEAN UNION LAW?
+
+ID 5725c3a9ec44d21400f3d506
+
+European Union law is applied by the courts of member states and the Court of Justice of the European Union. Where the laws of member states provide for lesser rights European Union law can be enforced by the courts of member states. In case of European Union law which should have been transposed into the laws of member states, such as Directives, the European Commission can take proceedings against the member state under the Treaty on the Functioning of the European Union. The European Court of Justice is the highest court able to interpret European Union law. Supplementary sources of European Union law include case law by the Court of Justice, international law and general principles of European Union law.
+
+Ground truth international law
+
+Prediction case law by the Court of Justice
+
+Comment The prediction produced by the model is correct, however it was not selected by Mechanical Turk annotators.
+
+WHO DESIGNED THE ILLUMINATION SYSTEMS THAT TESLA ELECTRIC LIGHT & MANUFACTURING INSTALLED?
+
+# ID 56e0d6cf231d4119001ac424
+
+After leaving Edison’s company Tesla partnered with two businessmen in 1886, Robert Lane and Benjamin Vail, who agreed to finance an electric lighting company in Tesla’s name, Tesla Electric Light & Manufacturing. The company installed electrical arc light based illumination systems designed by Tesla and also had designs for dynamo electric machine commutators, the first patents issued to Tesla in the US.
+
+# Ground truth Tesla
+
+Prediction Robert Lane and Benjamin Vail
+
+Comment The model produces an incorrect prediction that corresponds to people that funded Tesla, instead of Tesla who actually designed the illumination system. Empirically, we find that most mistakes made by the model have the correct type (eg. named entity type) despite not including types as prior knowledge to the model. In this case, the incorrect response has the correct type of person.
+
+CYDIPPID ARE TYPICALLY WHAT SHAPE?
+
+# ID 57265746dd62a815002e821a
+
+Cydippid ctenophores have bodies that are more or less rounded, sometimes nearly spherical and other times more cylindrical or egg-shaped; the common coastal ”sea gooseberry,” Pleurobrachia, sometimes has an egg-shaped body with the mouth at the narrow end, although some individuals are more uniformly round. From opposite sides of the body extends a pair of long, slender tentacles, each housed in a sheath into which it can be withdrawn. Some species of cydippids have bodies that are flattened to various extents, so that they are wider in the plane of the tentacles.
+
+Ground truth more or less rounded, egg-shaped
+
+# Prediction spherical
+
+Comment Although the mistake is subtle, the prediction is incorrect. The statement “are more or less rounded, sometimes nearly spherical” suggests that the entity is more often “rounded” than “spherical” or “cylindrical” or “egg-shaped” (an answer given by an annotator). This suggests that the model has trouble discerning among multiple intuitive answers due to a lack of understanding of the relative severity of “more or less” versus “sometimes” and “other times”.

parse/train/rJeKjwvclx/rJeKjwvclx_content_list.json

@@ -0,0 +1,2188 @@
+[
+    {
+        "type": "text",
+        "text": "DYNAMIC COATTENTION NETWORKS FOR QUESTION ANSWERING ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            99,
+            624,
+            146
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Caiming Xiong∗, Victor Zhong∗, Richard Socher ",
+        "bbox": [
+            186,
+            172,
+            508,
+            188
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Salesforce Research   \nPalo Alto, CA 94301, USA   \n{cxiong, vzhong, rsocher}@salesforce.com ",
+        "bbox": [
+            184,
+            189,
+            573,
+            229
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "ABSTRACT ",
+        "text_level": 1,
+        "bbox": [
+            454,
+            266,
+            544,
+            281
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Several deep learning models have been proposed for question answering. However, due to their single-pass nature, they have no way to recover from local maxima corresponding to incorrect answers. To address this problem, we introduce the Dynamic Coattention Network (DCN) for question answering. The DCN first fuses co-dependent representations of the question and the document in order to focus on relevant parts of both. Then a dynamic pointing decoder iterates over potential answer spans. This iterative procedure enables the model to recover from initial local maxima corresponding to incorrect answers. On the Stanford question answering dataset, a single DCN model improves the previous state of the art from $7 1 . 0 \\%$ F1 to $7 5 . 9 \\%$ , while a DCN ensemble obtains $8 0 . 4 \\%$ F1. ",
+        "bbox": [
+            233,
+            308,
+            764,
+            445
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 INTRODUCTION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            496,
+            336,
+            513
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Question answering (QA) is a crucial task in natural language processing that requires both natural language understanding and world knowledge. Previous QA datasets tend to be high in quality due to human annotation, but small in size (Berant et al., 2014; Richardson et al., 2013). Hence, they did not allow for training data-intensive, expressive models such as deep neural networks. ",
+        "bbox": [
+            174,
+            537,
+            823,
+            593
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "To address this problem, researchers have developed large-scale datasets through semi-automated techniques (Hermann et al., 2015; Hill et al., 2016). Compared to their smaller, hand-annotated counterparts, these QA datasets allow the training of more expressive models. However, it has been shown that they differ from more natural, human annotated datasets in the types of reasoning required to answer the questions (Chen et al., 2016). ",
+        "bbox": [
+            174,
+            599,
+            825,
+            670
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Recently, Rajpurkar et al. (2016) released the Stanford Question Answering dataset (SQuAD), which is orders of magnitude larger than all previous hand-annotated datasets and has a variety of qualities that culminate in a natural QA task. SQuAD has the desirable quality that answers are spans in a reference document. This constrains answers to the space of all possible spans. However, Rajpurkar et al. (2016) show that the dataset retains a diverse set of answers and requires different forms of logical reasoning, including multi-sentence reasoning. ",
+        "bbox": [
+            174,
+            676,
+            825,
+            761
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "We introduce the Dynamic Coattention Network (DCN), illustrated in Fig. 1, an end-to-end neural network for question answering. The model consists of a coattentive encoder that captures the interactions between the question and the document, as well as a dynamic pointing decoder that alternates between estimating the start and end of the answer span. Our single model obtains an F1 of $7 5 . 9 \\%$ compared to the best published result of $7 1 . 0 \\%$ (Yu et al., 2016). In addition, our ensemble model obtains an F1 of $8 0 . 4 \\%$ compared to the second best result of $78 . 1 \\%$ on the official SQuAD leaderboard.1 ",
+        "bbox": [
+            174,
+            767,
+            825,
+            864
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "2 DYNAMIC COATTENTION NETWORKS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            102,
+            517,
+            118
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Figure 1 illustrates an overview of the DCN. We first describe the encoders for the document and the question, followed by the coattention mechanism and the dynamic decoder which produces the answer span. ",
+        "bbox": [
+            173,
+            133,
+            825,
+            178
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "image",
+        "img_path": "images/366b7e744a65a1c479359e0000da5451a5aa3e0614250d64bb4588d807625476.jpg",
+        "image_caption": [
+            "Figure 1: Overview of the Dynamic Coattention Network. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            179,
+            194,
+            812,
+            381
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2.1 DOCUMENT AND QUESTION ENCODER ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            454,
+            483,
+            469
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Let (xQ1 , xQ2 , . . denote the sequence of word vectors corresponding to words in the question and $( x _ { 1 } ^ { D } , x _ { 2 } ^ { D } , \\dots , x _ { m } ^ { D } )$ denote the same for words in the document. Using an LSTM (Hochreiter & Schmidhuber, 1997), we encode the document as: $d _ { t } = \\mathrm { L S T M } _ { e n c } \\left( d _ { t - 1 } , x _ { t } ^ { D } \\right)$ . We define the document encoding matrix as $D = [ d _ { 1 } \\ . . . \\ d _ { m } \\ d _ { \\mathcal { O } } ] \\in \\mathbb { R } ^ { \\ell \\times ( m + 1 ) }$ . We also add a sentinel vector $d _ { \\mathcal { O } }$ (Merity et al., 2016), which we later show allows the model to not attend to any particular word in the input. ",
+        "bbox": [
+            173,
+            481,
+            825,
+            573
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "The question embeddings are computed with the same LSTM to share representation power: $q _ { t } =$ $\\mathrm { L S T M } _ { e n c } \\left( q _ { t - 1 } , x _ { t } ^ { Q } \\right)$ We define an intermediate question representation $Q ^ { \\prime } = [ q _ { 1 } \\dots q _ { n } q _ { \\emptyset } ] \\in$ $\\mathbb { R } ^ { \\ell \\times ( n + 1 ) }$ . To allow for variation between the question encoding space and the document encoding space, we introduce a non-linear projection layer on top of the question encoding. The final representation for the question becomes: $\\begin{array} { r } { \\dot { Q } = \\operatorname { t a n h } \\left( W ^ { ( Q ) } \\bar { Q ^ { \\prime } } + b ^ { ( Q ) } \\right) \\in \\mathbb { R } ^ { \\ell \\times ( n + 1 ) } } \\end{array}$ . ",
+        "bbox": [
+            173,
+            579,
+            825,
+            662
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2.2 COATTENTION ENCODER ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            680,
+            390,
+            695
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "We propose a coattention mechanism that attends to the question and document simultaneously, similar to (Lu et al., 2016), and finally fuses both attention contexts. Figure 2 provides an illustration of the coattention encoder. ",
+        "bbox": [
+            174,
+            707,
+            825,
+            750
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "We first compute the affinity matrix, which contains affinity scores corresponding to all pairs of document words and question words: $L = D ^ { \\top } Q \\in \\mathbb { R } ^ { ( m + 1 ) \\times ( n + 1 ) }$ . The affinity matrix is normalized row-wise to produce the attention weights $A ^ { Q }$ across the document for each word in the question, and column-wise to produce the attention weights $A ^ { D }$ across the question for each word in the document: ",
+        "bbox": [
+            173,
+            756,
+            825,
+            828
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "equation",
+        "img_path": "images/0b9612fdcd62bbde420d3294715e2b488ff20e952a7bac9155fd001efebd85ca.jpg",
+        "text": "$$\nA ^ { Q } = \\operatorname { s o f t m a x } \\left( L \\right) \\in \\mathbb { R } ^ { ( m + 1 ) \\times ( n + 1 ) } { \\mathrm { ~ a n d ~ } } A ^ { D } = \\operatorname { s o f t m a x } \\left( L ^ { \\top } \\right) \\in \\mathbb { R } ^ { ( n + 1 ) \\times ( m + 1 ) }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            223,
+            845,
+            771,
+            867
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Next, we compute the summaries, or attention contexts, of the document in light of each word of the question. ",
+        "bbox": [
+            171,
+            877,
+            825,
+            905
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "equation",
+        "img_path": "images/eabde3ef2b7d5396db8ce04464bea87500de6a6fae67c536112caa5e175ec1a2.jpg",
+        "text": "$$\nC ^ { Q } = D A ^ { Q } \\in \\mathbb { R } ^ { \\ell \\times ( n + 1 ) } .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            411,
+            906,
+            586,
+            922
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "image",
+        "img_path": "images/659657d3664439f5aaf2ad20059c8aff9fa095ee215405eee86563f70a315687.jpg",
+        "image_caption": [
+            "Figure 2: Coattention encoder. The affinity matrix $L$ is not shown here. We instead directly show the normalized attention weights $A ^ { D }$ and $\\dot { A } ^ { Q }$ . "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            183,
+            109,
+            818,
+            313
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "We similarly compute the summaries $Q A ^ { D }$ of the question in light of each word of the document. Similar to Cui et al. (2016), we also compute the summaries $C ^ { \\mathcal { { Q } } } A ^ { D }$ of the previous attention contexts in light of each word of the document. These two operations can be done in parallel, as is shown in Eq. 3. One possible interpretation for the operation $C ^ { Q } A ^ { D }$ is the mapping of question encoding into space of document encodings. ",
+        "bbox": [
+            174,
+            383,
+            825,
+            455
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/e7fc356977edae75c16da08a71131bc1fe53766fbace45f59c4cafbd9da39dec.jpg",
+        "text": "$$\nC ^ { D } = \\left[ Q ; C ^ { Q } \\right] A ^ { D } \\in \\mathbb { R } ^ { 2 \\ell \\times ( m + 1 ) } .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            382,
+            462,
+            616,
+            483
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "We define $C ^ { D }$ , a co-dependent representation of the question and document, as the coattention context. We use the notation $[ a ; b ]$ for concatenating the vectors $a$ and $b$ horizontally. ",
+        "bbox": [
+            174,
+            497,
+            825,
+            526
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "The last step is the fusion of temporal information to the coattention context via a bidirectional LSTM: ",
+        "bbox": [
+            168,
+            532,
+            821,
+            558
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/b70446b0603fb23ef8d132a24326f397cb6862b4b6496cb265c16224b89e171f.jpg",
+        "text": "$$\n\\boldsymbol { u } _ { t } = \\mathrm { B i - L S T M } \\left( u _ { t - 1 } , u _ { t + 1 } , \\left[ d _ { t } ; c _ { t } ^ { D } \\right] \\right) \\in \\mathbb { R } ^ { 2 \\ell } .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            344,
+            558,
+            651,
+            577
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "We define $U = [ u _ { 1 } , \\dots , u _ { m } ] \\in \\mathbb { R } ^ { 2 \\ell \\times m }$ , which provides a foundation for selecting which span may be the best possible answer, as the coattention encoding. ",
+        "bbox": [
+            174,
+            580,
+            821,
+            611
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "2.3 DYNAMIC POINTING DECODER ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            626,
+            431,
+            641
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Due to the nature of SQuAD, an intuitive method for producing the answer span is by predicting the start and end points of the span (Wang & Jiang, 2016b). However, given a question-document pair, there may exist several intuitive answer spans within the document, each corresponding to a local maxima. We propose an iterative technique to select an answer span by alternating between predicting the start point and predicting the end point. This iterative procedure allows the model to recover from initial local maxima corresponding to incorrect answer spans. ",
+        "bbox": [
+            173,
+            651,
+            825,
+            737
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Figure 3 provides an illustration of the Dynamic Decoder, which is similar to a state machine whose state is maintained by an LSTM-based sequential model. During each iteration, the decoder updates its state taking into account the coattention encoding corresponding to current estimates of the start and end positions, and produces, via a multilayer neural network, new estimates of the start and end positions. ",
+        "bbox": [
+            173,
+            742,
+            825,
+            814
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Let $h _ { i } , s _ { i }$ , and $e _ { i }$ denote the hidden state of the LSTM, the estimate of the position, and the estimate of the end position during iteration $i$ . The LSTM state update is then described by Eq. 5. ",
+        "bbox": [
+            173,
+            819,
+            825,
+            849
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/deb287d5c17e8226321ff80afd968fc83ca7761f3b9ba1ba78d6395364b0c112.jpg",
+        "text": "$$\nh _ { i } = \\mathrm { L S T M } _ { d e c } \\left( h _ { i - 1 } , \\left[ u _ { s _ { i - 1 } } ; u _ { e _ { i - 1 } } \\right] \\right)\n$$",
+        "text_format": "latex",
+        "bbox": [
+            369,
+            867,
+            627,
+            886
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "where $u _ { s _ { i - 1 } }$ and $u _ { e _ { i - 1 } }$ are the representations corresponding to the previous estimate of the start and end positions in the coattention encoding $U$ . ",
+        "bbox": [
+            176,
+            895,
+            823,
+            924
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "image",
+        "img_path": "images/6b17096e746bf2a05c497268ea80bc69a1959ba4479008235c346ae565e33292.jpg",
+        "image_caption": [
+            "Figure 3: Dynamic Decoder. Blue denotes the variables and functions related to estimating the start position whereas red denotes the variables and functions related to estimating the end position. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            179,
+            104,
+            820,
+            359
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Given the current hidden state $h _ { i }$ , previous start position $u _ { s _ { i - 1 } }$ , and previous end position $u _ { e _ { i - 1 } }$ , we estimate the current start position and end position via Eq. 6 and Eq. 7. ",
+        "bbox": [
+            173,
+            433,
+            823,
+            462
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/3bf21e545f3b01bf0d8cf59d0bf55537d163c353404750b88f7d6d4ee5175cbe.jpg",
+        "text": "$$\n\\begin{array} { c } { s _ { i } = \\underset { t } { \\operatorname { a r g m a x } } \\left( \\alpha _ { 1 } , \\ldots , \\alpha _ { m } \\right) } \\\\ { \\ } \\\\ { e _ { i } = \\underset { t } { \\operatorname { a r g m a x } } \\left( \\beta _ { 1 } , \\ldots , \\beta _ { m } \\right) } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            406,
+            479,
+            591,
+            546
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "where $\\alpha _ { t }$ and $\\beta _ { t }$ represent the start score and end score corresponding to the tth word in the document. We compute $\\alpha _ { t }$ and $\\beta _ { t }$ with separate neural networks. These networks have the same architecture but do not share parameters. ",
+        "bbox": [
+            176,
+            553,
+            823,
+            597
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Based on the strong empirical performance of Maxout Networks (Goodfellow et al., 2013) and Highway Networks (Srivastava et al., 2015), especially with regards to deep architectures, we propose a Highway Maxout Network (HMN) to compute $\\alpha _ { t }$ as described by Eq. 8. The intuition behind using such model is that the QA task consists of multiple question types and document topics. These variations may require different models to estimate the answer span. Maxout provides a simple and effective way to pool across multiple model variations. ",
+        "bbox": [
+            173,
+            602,
+            825,
+            686
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/d5fce1c08850a8d2b2699f50725885b800b1aaecba9142ff5956d772638d5843.jpg",
+        "text": "$$\n\\alpha _ { t } = \\mathrm { H M N } _ { s t a r t } \\left( u _ { t } , h _ { i } , u _ { s _ { i - 1 } } , u _ { e _ { i - 1 } } \\right)\n$$",
+        "text_format": "latex",
+        "bbox": [
+            370,
+            704,
+            625,
+            724
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Here, $u _ { t }$ is the coattention encoding corresponding to the $t$ th word in the document. $\\mathrm { H M N } _ { s t a r t }$ is illustrated in Figure 4. The end score, $\\beta _ { t }$ , is computed similarly to the start score $\\alpha _ { t }$ , but using a separate $\\mathrm { H M N } _ { e n d }$ . ",
+        "bbox": [
+            174,
+            731,
+            825,
+            775
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "We now describe the HMN model: ",
+        "bbox": [
+            176,
+            780,
+            401,
+            795
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/99a7b0e24a018c83940362ae014b6d290ee2bbd0ebfc0b5879e6f5bb0a803486.jpg",
+        "text": "$$\n\\begin{array} { r c l } { { \\mathrm { H M N } \\left( u _ { t } , h _ { i } , u _ { s _ { i - 1 } } , u _ { e _ { i - 1 } } \\right) } } & { { = } } & { { \\operatorname* { m a x } \\left( W ^ { ( 3 ) } \\left[ m _ { t } ^ { ( 1 ) } ; m _ { t } ^ { ( 2 ) } \\right] + b ^ { ( 3 ) } \\right) } } \\\\ { { r } } & { { = } } & { { \\operatorname { t a n h } \\left( W ^ { ( D ) } \\left[ h _ { i } ; u _ { s _ { i - 1 } } ; u _ { e _ { i - 1 } } \\right] \\right) } } \\\\ { { m _ { t } ^ { ( 1 ) } } } & { { = } } & { { \\operatorname* { m a x } \\left( W ^ { ( 1 ) } \\left[ u _ { t } ; r \\right] + b ^ { ( 1 ) } \\right) } } \\\\ { { m _ { t } ^ { ( 2 ) } } } & { { = } } & { { \\operatorname* { m a x } \\left( W ^ { ( 2 ) } m _ { t } ^ { ( 1 ) } + b ^ { ( 2 ) } \\right) } } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            269,
+            818,
+            722,
+            931
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "where $r \\in \\mathbb { R } ^ { \\ell }$ is a non-linear projection of the current state with parameters $W ^ { ( D ) } \\in \\mathbb { R } ^ { \\ell \\times 5 \\ell }$ , $m _ { t } ^ { ( 1 ) }$ is the output of the first maxout layer with parameters $W ^ { ( 1 ) } \\in \\mathbb { R } ^ { p \\times \\ell \\times 3 \\ell }$ and $b ^ { ( 1 ) } \\in \\mathbb { R } ^ { p \\times \\ell }$ , and $m _ { t } ^ { ( 2 ) }$ is the output of the second maxout layer with parameters $W ^ { ( 2 ) } \\in \\mathbb { R } ^ { p \\times \\ell \\times \\ell }$ and $b ^ { ( 2 ) } \\in \\mathbb { R } ^ { p \\times \\ell }$ . $m _ { t } ^ { ( 1 ) }$ and m(2)t a re fed into the final maxout layer, which has parameters $W ^ { ( 3 ) } \\in \\mathbb { R } ^ { p \\times 1 \\times 2 \\ell }$ , and $b ^ { ( 3 ) } \\in \\mathbb { R } ^ { p }$ . $p$ is the pooling size of each maxout layer. The max operation computes the maximum value over the first dimension of a tensor. We note that there is highway connection between the output of the first maxout layer and the last maxout layer. ",
+        "bbox": [
+            174,
+            103,
+            506,
+            299
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "To train the network, we minimize the cumulative softmax cross entropy of the start and end points across all iterations. The iterative procedure halts when both the estimate of the start position and the estimate of the end position no longer change, or when a maximum number of iterations is reached. Details can be found in Section 4.1 ",
+        "bbox": [
+            174,
+            306,
+            506,
+            402
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "image",
+        "img_path": "images/34c9b1af90d072819538f6780f37239b9e8f6a72c45b555988700cec3a94e07c.jpg",
+        "image_caption": [
+            "Figure 4: Highway Maxout Network. Dotted lines denote highway connections. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            531,
+            112,
+            823,
+            349
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "3 RELATED WORK ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            429,
+            343,
+            445
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Statistical QA Traditional approaches to question answering typically involve rule-based algorithms or linear classifiers over hand-engineered feature sets. Richardson et al. (2013) proposed two baselines, one that uses simple lexical features such as a sliding window to match bags of words, and another that uses word-distances between words in the question and in the document. Berant et al. (2014) proposed an alternative approach in which one first learns a structured representation of the entities and relations in the document in the form of a knowledge base, then converts the question to a structured query with which to match the content of the knowledge base. Wang et al. (2015) described a statistical model using frame semantic features as well as syntactic features such as part of speech tags and dependency parses. Chen et al. (2016) proposed a competitive statistical baseline using a variety of carefully crafted lexical, syntactic, and word order features. ",
+        "bbox": [
+            173,
+            463,
+            825,
+            603
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Neural QA Neural attention models have been widely applied for machine comprehension or question-answering in NLP. Hermann et al. (2015) proposed an AttentiveReader model with the release of the CNN/Daily Mail cloze-style question answering dataset. Hill et al. (2016) released another dataset steming from the children’s book and proposed a window-based memory network. Kadlec et al. (2016) presented a pointer-style attention mechanism but performs only one attention step. Sordoni et al. (2016) introduced an iterative neural attention model and applied it to cloze-style machine comprehension tasks. ",
+        "bbox": [
+            174,
+            609,
+            825,
+            707
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Recently, Rajpurkar et al. (2016) released the SQuAD dataset. Different from cloze-style queries, answers include non-entities and longer phrases, and questions are more realistic. For SQuAD, Wang & Jiang (2016b) proposed an end-to-end neural network model that consists of a Match-LSTM encoder, originally introduced in Wang & Jiang (2016a), and a pointer network decoder (Vinyals et al., 2015); Yu et al. (2016) introduced a dynamic chunk reader, a neural reading comprehension model that extracts a set of answer candidates of variable lengths from the document and ranks them to answer the question. ",
+        "bbox": [
+            174,
+            713,
+            825,
+            811
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Lu et al. (2016) proposed a hierarchical co-attention model for visual question answering, which achieved state of the art result on the COCO-VQA dataset (Antol et al., 2015). In (Lu et al., 2016), the co-attention mechanism computes a conditional representation of the image given the question, as well as a conditional representation of the question given the image. ",
+        "bbox": [
+            174,
+            819,
+            825,
+            875
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Inspired by the above works, we propose a dynamic coattention model (DCN) that consists of a novel coattentive encoder and dynamic decoder. In our model, instead of estimating the start and end positions of the answer span in a single pass (Wang & Jiang, 2016b), we iteratively update the start and end positions in a similar fashion to the Iterative Conditional Modes algorithm (Besag, 1986). ",
+        "bbox": [
+            176,
+            882,
+            823,
+            924
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "table",
+        "img_path": "images/1605164114228002420daf4077ddc6f0a8eeb0996db3932f94f49047687b88a7.jpg",
+        "table_caption": [
+            "Table 1: Leaderboard performance at the time of writing (Nov 4 2016). ∗ indicates that the model used for submission is unpublished. − indicates that the development scores were not publicly available at the time of writing. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Model</td><td>Dev EM</td><td>Dev F1</td><td>Test EM</td><td>Test F1</td></tr><tr><td>Ensemble</td><td></td><td></td><td></td><td></td></tr><tr><td>DCN (Ours)</td><td>70.3</td><td>79.4</td><td>71.2</td><td>80.4</td></tr><tr><td>Microsoft Research Asia *</td><td>一</td><td>1</td><td>69.4</td><td>78.3</td></tr><tr><td>Allen Institute *</td><td>69.2</td><td>77.8</td><td>69.9</td><td>78.1</td></tr><tr><td>Singapore Management University *</td><td>67.6</td><td>76.8</td><td>67.9</td><td>77.0</td></tr><tr><td>Google NYC *</td><td>68.2</td><td>76.7</td><td>一</td><td></td></tr><tr><td>Single model</td><td></td><td></td><td></td><td></td></tr><tr><td>DCN (Ours)</td><td>65.4</td><td>75.6</td><td>66.2</td><td>75.9</td></tr><tr><td>Microsoft Research Asia *</td><td>65.9</td><td>75.2</td><td>65.5</td><td>75.0</td></tr><tr><td>Google NYC *</td><td>66.4</td><td>74.9</td><td>1</td><td>1</td></tr><tr><td>Singapore Management University *</td><td>1</td><td>1</td><td>64.7</td><td>73.7</td></tr><tr><td>Carnegie Mellon University</td><td>1</td><td>1</td><td>62.5</td><td>73.3</td></tr><tr><td>Dynamic Chunk Reader (Yu et al., 2016)</td><td>62.5</td><td>71.2</td><td>62.5</td><td>71.0</td></tr><tr><td>Match-LSTM (Wang &amp; Jiang,2016b)</td><td>59.1</td><td>70.0</td><td>59.5</td><td>70.3</td></tr><tr><td>Baseline (Rajpurkar et al., 2016)</td><td>40.0</td><td>51.0</td><td>40.4</td><td>51.0</td></tr><tr><td>Human (Rajpurkar et al., 2016)</td><td>81.4</td><td>91.0</td><td>82.3</td><td>91.2</td></tr></table>",
+        "bbox": [
+            209,
+            101,
+            787,
+            364
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            176,
+            444,
+            821,
+            473
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "4 EXPERIMENTS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            496,
+            326,
+            511
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "4.1 IMPLEMENTATION DETAILS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            527,
+            405,
+            542
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "We train and evaluate our model on the SQuAD dataset. To preprocess the corpus, we use the tokenizer from Stanford CoreNLP (Manning et al., 2014). We use as GloVe word vectors pretrained on the 840B Common Crawl corpus (Pennington et al., 2014). We limit the vocabulary to words that are present in the Common Crawl corpus and set embeddings for out-of-vocabulary words to zero. Empirically, we found that training the embeddings consistently led to overfitting and subpar performance, and hence only report results with fixed word embeddings. ",
+        "bbox": [
+            174,
+            554,
+            823,
+            637
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "We use a max sequence length of 600 during training and a hidden state size of 200 for all recurrent units, maxout layers, and linear layers. All LSTMs have randomly initialized parameters and an initial state of zero. Sentinel vectors are randomly initialized and optimized during training. For the dynamic decoder, we set the maximum number of iterations to 4 and use a maxout pool size of 16. We use dropout to regularize our network during training (Srivastava et al., 2014), and optimize the model using ADAM (Kingma & Ba, 2014). All models are implemented and trained with Chainer (Tokui et al., 2015). ",
+        "bbox": [
+            174,
+            645,
+            825,
+            742
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "4.2 RESULTS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            761,
+            277,
+            775
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Evaluation on the SQuAD dataset consists of two metrics. The exact match score (EM) calculates the exact string match between the predicted answer and a ground truth answer. The F1 score calculates the overlap between words in the predicted answer and a ground truth answer. Because a document-question pair may have several ground truth answers, the EM and F1 for a documentquestion pair is taken to be the maximum value across all ground truth answers. The overall metric is then computed by averaging over all document-question pairs. The offical SQuAD evaluation is hosted on CodaLab 2. The training and development sets are publicly available while the test set is withheld. ",
+        "bbox": [
+            174,
+            787,
+            825,
+            898
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "The performance of the Dynamic Coattention Network on the SQuAD dataset, compared to other submitted models on the leaderboard 3, is shown in Table 1. At the time of writing, our singlemodel DCN ranks first at $6 6 . 2 \\%$ exact match and $7 5 . 9 \\%$ F1 on the test data among single-model submissions. Our ensemble DCN ranks first overall at $7 1 . 6 \\%$ exact match and $8 0 . 4 \\%$ F1 on the test data. ",
+        "bbox": [
+            174,
+            103,
+            825,
+            172
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "The DCN has the capability to estimate the start and end points of the answer span multiple times, each time conditioned on its previous estimates. By doing so, the model is able to explore local maxima corresponding to multiple plausible answers, as is shown in Figure 5. ",
+        "bbox": [
+            174,
+            180,
+            825,
+            223
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/c3102bd8496d3d4cf1baf2bcf5fff89efedb6e23756c3ea7ee32a876b2887df7.jpg",
+        "image_caption": [
+            "Question 1: Who recovered Tolbert's fumble? "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            183,
+            257,
+            808,
+            392
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/a845dc12bdf8267e6cba84587670144160e05035c8b5b3713d05e247bc5ea6f6.jpg",
+        "image_caption": [],
+        "image_footnote": [],
+        "bbox": [
+            184,
+            397,
+            812,
+            518
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/085444cc5b6dcb9a4ec51b52f4a781f31f790443b465e8a01b0e5d0fd4bca99f.jpg",
+        "image_caption": [
+            "Question 3: What kind of weapons did Tesla's treatise concern? ",
+            "Figure 5: Examples of the start and end conditional distributions produced by the dynamic decoder. Odd (blue) rows denote the start distributions and even (red) rows denote the end distributions. i indicates the iteration number of the dynamic decoder. Higher probability mass is indicated by darker regions. The offset corresponding to the word with the highest probability mass is shown on the right hand side. The predicted span is underlined in red, and a ground truth answer span is underlined in green. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            183,
+            534,
+            810,
+            694
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "For example, Question 1 in Figure 5 demonstrates an instance where the model initially guesses an incorrect start point and a correct end point. In subsequent iterations, the model adjusts the start point, ultimately arriving at the correct start point in iteration 3. Similarly, the model gradually shifts probability mass for the end point to the correct word. ",
+        "bbox": [
+            174,
+            804,
+            825,
+            861
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Question 2 shows an example in which both the start and end estimates are initially incorrect. The model then settles on the correct answer in the next iteration. ",
+        "bbox": [
+            176,
+            867,
+            823,
+            896
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/587fa0e39bc3021fe61bff9f3565c68bc05181a466d0bc36dfea698f3988018c.jpg",
+        "image_caption": [
+            "Figure 6: Performance of the DCN for various lengths of documents, questions, and answers. The blue dot indicates the mean F1 at given length. The vertical bar represents the standard deviation of F1s at a given length. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            179,
+            106,
+            816,
+            223
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "While the dynamic nature of the decoder allows the model to escape initial local maxima corresponding to incorrect answers, Question 3 demonstrates a case where the model is unable to decide between multiple local maxima despite several iterations. Namely, the model alternates between the answers “charged particle beam” and “particle beam weapons” indefinitely. Empirically, we observe that the model, trained with a maximum iteration of 4, takes 2.7 iterations to converge to an answer on average. ",
+        "bbox": [
+            173,
+            285,
+            825,
+            369
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Model Ablation The performance of our model and its ablations on the SQuAD development set is shown in Table 2. On the decoder side, we experiment with various pool sizes for the HMN maxout layers, using a 2-layer MLP instead of a HMN, and forcing the HMN decoder to a single iteration. Empirically, we achieve the best performance on the development set with an iterative HMN ",
+        "bbox": [
+            173,
+            376,
+            367,
+            569
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "table",
+        "img_path": "images/d8c0c6d7af28df7f8be0568d155ae503bad0f6993110863dc8ce1aed3014439b.jpg",
+        "table_caption": [
+            "Table 2: Single model ablations on the development set. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Model</td><td>Dev EM</td><td>Dev F1</td></tr><tr><td>Dynamic Coattention Network (DCN)</td><td></td><td></td></tr><tr><td>pool size 16 HMN</td><td>65.4</td><td>75.6</td></tr><tr><td>pool size 8 HMN</td><td>64.4</td><td>74.9</td></tr><tr><td>pool size 4 HMN</td><td>65.2</td><td>75.2</td></tr><tr><td>DCN with 2-layer MLP instead of HMN</td><td>63.8</td><td>74.4</td></tr><tr><td>DCN with single iteration decoder</td><td>63.7</td><td>74.0</td></tr><tr><td>DCN with Wang &amp; Jiang (2016b) attention</td><td>63.7</td><td>73.7</td></tr></table>",
+        "bbox": [
+            379,
+            392,
+            826,
+            526
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "with pool size 16, and find that the model consistently benefits from a deeper, iterative decoder network. The performance improves as the number of maximum allowed iterations increases, with little improvement after 4 iterations. On the encoder side, replacing the coattention mechanism with an attention mechanism similar to Wang & Jiang (2016b) by setting $C ^ { D }$ to $Q A ^ { D }$ in equation 3 results in a 1.9 point F1 drop. This suggests that, at an additional cost of a softmax computation and a dot product, the coattention mechanism provides a simple and effective means to better encode the document and question sequences. Further studies, such as performance without attention and performance on questions requiring different types of reasoning can be found in the appendix. ",
+        "bbox": [
+            173,
+            570,
+            826,
+            681
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Performance across length One point of interest is how the performance of the DCN varies with respect to the length of document. Intuitively, we expect the model performance to deteriorate with longer examples, as is the case with neural machine translation (Luong et al., 2015). However, as in shown in Figure 6, there is no notable performance degradation for longer documents and questions contrary to our expectations. This suggests that the coattentive encoder is largely agnostic to long documents, and is able to focus on small sections of relevant text while ignoring the rest of the (potentially very long) document. We do note a performance degradation with longer answers. However, this is intuitive given the nature of the evaluation metric. Namely, it becomes increasingly challenging to compute the correct word span as the number of words increases. ",
+        "bbox": [
+            174,
+            688,
+            483,
+            924
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "image",
+        "img_path": "images/653f0cc5f5b4e69dc4ebc621a1c337abbcdd7c24b52621540fafc0ac3422a7ea.jpg",
+        "image_caption": [
+            "Figure 7: Performance of the DCN across question types. The height of each bar represents the mean F1 for the given question type. The lower number denotes how many instances in the dev set are of the corresponding question type. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            503,
+            708,
+            820,
+            868
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            104,
+            483,
+            131
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Performance across question type Another natural way to analyze the performance of the model is to examine its performance across question types. In Figure 7, we note that the mean F1 of DCN exceeds those of previous systems (Wang & Jiang, 2016b; Yu et al., 2016) across all question types. The DCN, like other models, is adept at “when” questions and struggles with the more complex “why” questions. ",
+        "bbox": [
+            174,
+            140,
+            825,
+            208
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Breakdown of F1 distribution Finally, we note that the DCN performance is highly bimodal. On the development set, the model perfectly predicts $100 \\%$ F1) an answer for $6 2 . 2 \\%$ of examples and predicts a completely wrong answer $0 \\%$ F1) for $1 6 . 3 \\%$ of examples. That is, the model picks out partial answers only $2 1 . 5 \\%$ of the time. Upon qualitative inspections of the $0 \\%$ F1 answers, some of which are shown in Appendix A.4, we observe that when the model is wrong, its mistakes tend to have the correct “answer type” (eg. person for a “who” question, method for a “how” question) and the answer boundaries encapsulate a well-defined phrase. ",
+        "bbox": [
+            174,
+            215,
+            825,
+            313
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "5 CONCLUSION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            333,
+            318,
+            348
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "We proposed the Dynamic Coattention Network, an end-to-end neural network architecture for question answering. The DCN consists of a coattention encoder which learns co-dependent representations of the question and of the document, and a dynamic decoder which iteratively estimates the answer span. We showed that the iterative nature of the model allows it to recover from initial local maxima corresponding to incorrect predictions. On the SQuAD dataset, the DCN achieves the state of the art results at $7 5 . 9 \\%$ F1 with a single model and $8 0 . 4 \\%$ F1 with an ensemble. The DCN significantly outperforms all other models. ",
+        "bbox": [
+            174,
+            364,
+            825,
+            462
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "ACKNOWLEDGMENTS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            478,
+            326,
+            491
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "We thank Kazuma Hashimoto and Bryan McCann for their help and insights. ",
+        "bbox": [
+            176,
+            501,
+            676,
+            515
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "REFERENCES ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            536,
+            285,
+            551
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Stanislaw Antol, Aishwarya Agrawal, Jiasen Lu, Margaret Mitchell, Dhruv Batra, C Lawrence Zitnick, and Devi Parikh. Vqa: Visual question answering. In Proceedings of the IEEE International Conference on Computer Vision, pp. 2425–2433, 2015. ",
+        "bbox": [
+            174,
+            559,
+            823,
+            602
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Jonathan Berant, Vivek Srikumar, Pei-Chun Chen, Abby Vander Linden, Brittany Harding, Brad Huang, Peter Clark, and Christopher D Manning. Modeling biological processes for reading comprehension. In EMNLP, 2014. ",
+        "bbox": [
+            174,
+            609,
+            823,
+            651
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Julian Besag. On the statistical analysis of dirty pictures. Journal of the Royal Statistical Society. Series B (Methodological), pp. 259–302, 1986. ",
+        "bbox": [
+            173,
+            660,
+            820,
+            689
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Danqi Chen, Jason Bolton, and Christopher D. Manning. A thorough examination of the cnn/daily mail reading comprehension task. In Association for Computational Linguistics (ACL), 2016. ",
+        "bbox": [
+            173,
+            696,
+            823,
+            726
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Yiming Cui, Zhipeng Chen, Si Wei, Shijin Wang, Ting Liu, and Guoping Hu. Attention-overattention neural networks for reading comprehension. arXiv preprint arXiv:1607.04423, 2016. ",
+        "bbox": [
+            173,
+            733,
+            821,
+            762
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Ian J Goodfellow, David Warde-Farley, Mehdi Mirza, Aaron C Courville, and Yoshua Bengio. Maxout networks. ICML (3), 28:1319–1327, 2013. ",
+        "bbox": [
+            173,
+            770,
+            821,
+            800
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Karl Moritz Hermann, Tomas Kocisky, Edward Grefenstette, Lasse Espeholt, Will Kay, Mustafa Suleyman, and Phil Blunsom. Teaching machines to read and comprehend. In Advances in Neural Information Processing Systems, pp. 1693–1701, 2015. ",
+        "bbox": [
+            176,
+            808,
+            821,
+            851
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Felix Hill, Antoine Bordes, Sumit Chopra, and Jason Weston. The goldilocks principle: Reading children’s books with explicit memory representations. In ICLR, 2016. ",
+        "bbox": [
+            173,
+            858,
+            821,
+            887
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Sepp Hochreiter and Jurgen Schmidhuber. Long short-term memory. ¨ Neural computation, 9(8): 1735–1780, 1997. ",
+        "bbox": [
+            174,
+            895,
+            821,
+            922
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Rudolf Kadlec, Martin Schmid, Ondrej Bajgar, and Jan Kleindienst. Text understanding with the attention sum reader network. arXiv preprint arXiv:1603.01547, 2016. ",
+        "bbox": [
+            171,
+            103,
+            823,
+            132
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Diederik Kingma and Jimmy Ba. Adam: A method for stochastic optimization. arXiv preprint arXiv:1412.6980, 2014. ",
+        "bbox": [
+            176,
+            138,
+            823,
+            167
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Jiasen Lu, Jianwei Yang, Dhruv Batra, and Devi Parikh. Hierarchical question-image co-attention for visual question answering. arXiv preprint arXiv:1606.00061, 2016. ",
+        "bbox": [
+            173,
+            174,
+            823,
+            203
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Christopher D Manning, Mihai Surdeanu, John Bauer, Jenny Rose Finkel, Steven Bethard, and David McClosky. The stanford corenlp natural language processing toolkit. In ACL (System Demonstrations), pp. 55–60, 2014. ",
+        "bbox": [
+            176,
+            272,
+            823,
+            315
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Stephen Merity, Caiming Xiong, James Bradbury, and Richard Socher. Pointer sentinel mixture models. arXiv preprint arXiv:1609.07843, 2016. ",
+        "bbox": [
+            173,
+            321,
+            821,
+            351
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Jeffrey Pennington, Richard Socher, and Christopher D Manning. Glove: Global vectors for word representation. In EMNLP, volume 14, pp. 1532–43, 2014. ",
+        "bbox": [
+            174,
+            357,
+            823,
+            387
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "P. Rajpurkar, J. Zhang, K. Lopyrev, and P. Liang. Squad: $1 0 0 { , } 0 0 0 { + }$ questions for machine comprehension of text. In Empirical Methods in Natural Language Processing (EMNLP), 2016. ",
+        "bbox": [
+            174,
+            392,
+            821,
+            422
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Matthew Richardson, Christopher JC Burges, and Erin Renshaw. Mctest: A challenge dataset for the open-domain machine comprehension of text. In EMNLP, volume 3, pp. 4, 2013. ",
+        "bbox": [
+            173,
+            428,
+            821,
+            458
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Alessandro Sordoni, Phillip Bachman, and Yoshua Bengio. Iterative alternating neural attention for machine reading. arXiv preprint arXiv:1606.02245, 2016. ",
+        "bbox": [
+            169,
+            463,
+            823,
+            492
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Nitish Srivastava, Geoffrey E Hinton, Alex Krizhevsky, Ilya Sutskever, and Ruslan Salakhutdinov. Dropout: a simple way to prevent neural networks from overfitting. Journal of Machine Learning Research, 15(1):1929–1958, 2014. ",
+        "bbox": [
+            174,
+            498,
+            821,
+            541
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Rupesh K Srivastava, Klaus Greff, and Juergen Schmidhuber. Training very deep networks. In Advances in Neural Information Processing Systems 28, pp. 2377–2385, 2015. ",
+        "bbox": [
+            171,
+            547,
+            821,
+            577
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Seiya Tokui, Kenta Oono, Shohei Hido, and Justin Clayton. Chainer: a next-generation open source framework for deep learning. In Proceedings of Workshop on Machine Learning Systems (LearningSys) in The Twenty-ninth Annual Conference on Neural Information Processing Systems (NIPS), 2015. ",
+        "bbox": [
+            174,
+            583,
+            823,
+            640
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Oriol Vinyals, Meire Fortunato, and Navdeep Jaitly. Pointer networks. In Advances in Neural Information Processing Systems, pp. 2692–2700, 2015. ",
+        "bbox": [
+            173,
+            646,
+            821,
+            676
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Hai Wang, Mohit Bansal, Kevin Gimpel, and David McAllester. Machine comprehension with syntax, frames, and semantics. In Proceedings of the 53rd Annual Meeting of the Association for Computational Linguistics and the 7th International Joint Conference on Natural Language Processing (Volume 2: Short Papers), pp. 700–706. Association for Computational Linguistics, 2015. ",
+        "bbox": [
+            173,
+            681,
+            826,
+            751
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Shuohang Wang and Jing Jiang. Learning natural language inference with LSTM. In Proceedings of the 2016 Conference of the North American Chapter of the Association for Computational Linguistics: Human Language Technologies, pp. 1442–1451. Association for Computational Linguistics, 2016a. ",
+        "bbox": [
+            173,
+            758,
+            825,
+            815
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Shuohang Wang and Jing Jiang. Machine comprehension using match-LSTM and answer pointer. arXiv preprint arXiv:1608.07905, 2016b. ",
+        "bbox": [
+            173,
+            820,
+            820,
+            851
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Y. Yu, W. Zhang, K. Hasan, M. Yu, B. Xiang, and B. Zhou. End-to-End Reading Comprehension with Dynamic Answer Chunk Ranking. ArXiv e-prints, October 2016. ",
+        "bbox": [
+            174,
+            857,
+            820,
+            887
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Yang Yu, Wei Zhang, Kazi Hasan, Mo Yu, Bing Xiang, and Bowen Zhou. End-to-end answer chunk extraction and ranking for reading comprehension. arXiv preprint arXiv:1610.09996v2, 2016. ",
+        "bbox": [
+            173,
+            892,
+            821,
+            921
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "A APPENDIX ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            102,
+            297,
+            117
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "A.1 PERFORMANCE WITHOUT ATTENTION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            135,
+            480,
+            148
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "In our experiments, we also investigate a model without any attention mechanism. In this model, the encoder is a simple LSTM network that first ingests the question and then ingests the document. The hidden states corresponding to words in the document is then passed to the decoder. This model achieves $3 3 . 3 \\%$ exact match and $4 1 . 9 \\%$ F1, significantly worse than models with attention. ",
+        "bbox": [
+            174,
+            161,
+            825,
+            218
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "A.2 SAMPLES REQUIRING DIFFERENT TYPES OF REASONING ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            238,
+            606,
+            251
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "We generate predictions for examples requiring different types of reasoning, given by Rajpurkar et al. (2016). Because this set of examples is very limited, they do not conclusively demonstrate the effectiveness of the model on different types of reasoning tasks. Nevertheless, these examples show that the DCN is a promising architecture for challenging question answering tasks including those that involve reasoning over multiple sentences. ",
+        "bbox": [
+            174,
+            263,
+            825,
+            333
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "WHAT IS THE RANKINE CYCLE SOMETIMES CALLED? ",
+        "bbox": [
+            178,
+            353,
+            544,
+            367
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "The Rankine cycle is sometimes referred to as a practical Carnot cycle because, when an efficient turbine is used, the TS diagram begins to resemble the Carnot cycle. ",
+        "bbox": [
+            173,
+            381,
+            823,
+            409
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Type of reasoning Lexical variation (synonymy) ",
+        "bbox": [
+            176,
+            416,
+            495,
+            430
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Ground truth practical Carnot cycle ",
+        "bbox": [
+            176,
+            438,
+            419,
+            452
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Prediction practical Carnot cycle ",
+        "bbox": [
+            176,
+            459,
+            397,
+            473
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "WHICH TWO GOVERNING BODIES HAVE LEGISLATIVE VETO POWER? ",
+        "bbox": [
+            174,
+            493,
+            647,
+            507
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "While the Commision has a monopoly on initiating legislation, the European Parliament and the Council of the European Union have powers of amendment and veto during the legislative progress. ",
+        "bbox": [
+            173,
+            518,
+            823,
+            547
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Type of reasoning Lexical variation (world knowledge) ",
+        "bbox": [
+            178,
+            554,
+            540,
+            569
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Ground truth the European Parliament and the Council of the European Union ",
+        "bbox": [
+            176,
+            575,
+            696,
+            590
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Prediction European Parliament and the Council of the European Union ",
+        "bbox": [
+            176,
+            597,
+            650,
+            611
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "WHAT SHAKESPEARE SCHOLAR IS CURRENTLY ON THE UNIVERSITYS FACULTY?",
+        "bbox": [
+            176,
+            632,
+            732,
+            645
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Current faculty include the anthropologist Marshall Sahlins, historian Dipesh Chakrabarty, ... Shakespeare scholar David Bevington, and renowned political scientists John Mearsheimer and Robert Pape. ",
+        "bbox": [
+            176,
+            659,
+            823,
+            700
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Type of reasoning Syntactic variation ",
+        "bbox": [
+            176,
+            707,
+            426,
+            722
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Ground truth David Bevington ",
+        "bbox": [
+            174,
+            728,
+            387,
+            743
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Prediction David Bevington ",
+        "bbox": [
+            174,
+            750,
+            362,
+            765
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "WHAT COLLECTION DOES THE V&A THEATRE & PERFORMANCE GALLERIES HOLD? ",
+        "bbox": [
+            171,
+            784,
+            759,
+            797
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "The V&A Theatre & Performance galleries, formerly the Theatre Museum, opened in March 2009. The collections are stored by the V&A, and are available for research, exhibitions and other shows. They hold the UK’s biggest national collection of material about live performance in the UK since Shakespeare’s day, covering drama, dance, musical theatre, circus, music hall, rock and pop, and most other forms of live entertainment. ",
+        "bbox": [
+            174,
+            810,
+            825,
+            881
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Type of reasoning Multiple sentence reasoning ",
+        "bbox": [
+            176,
+            887,
+            486,
+            902
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Ground truth Material about live performance ",
+        "bbox": [
+            174,
+            909,
+            485,
+            924
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Prediction UK’s biggest national collection of material about live performance in the UK since Shakespeare’s day ",
+        "bbox": [
+            173,
+            103,
+            823,
+            132
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "WHAT IS THE MAIN GOAL OF CRIMINAL PUNISHMENT OF CIVIL DISOBEDIENTS? ",
+        "bbox": [
+            174,
+            151,
+            727,
+            165
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Type of reasoning Ambiguous ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            178,
+            380,
+            193
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Along with giving the offender his ”just deserts”, achieving crime control via incapacitation and deterrence is a major goal of crime punishment. ",
+        "bbox": [
+            174,
+            199,
+            825,
+            227
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Ground truth achieving crime control via incapacitation and deterrence ",
+        "bbox": [
+            176,
+            234,
+            648,
+            248
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Prediction achieving crime control via incapacitation and deterrence ",
+        "bbox": [
+            174,
+            256,
+            625,
+            270
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "A.3 SAMPLES OF CORRECT SQUAD PREDICTIONS BY THE DYNAMIC COATTENTION NETWORK ",
+        "bbox": [
+            173,
+            290,
+            772,
+            318
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "HOW DID THE MONGOLS ACQUIRE CHINESE PRINTING TECHNOLOGY?",
+        "bbox": [
+            178,
+            330,
+            663,
+            344
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "ID: 572882242ca10214002da420 ",
+        "bbox": [
+            176,
+            357,
+            397,
+            371
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "The Mongol rulers patronized the Yuan printing industry. Chinese printing technology was transferred to the Mongols through Kingdom of Qocho and Tibetan intermediaries. Some Yuan documents such as Wang Zhen’s Nong Shu were printed with earthenware movable type, a technology invented in the 12th century. However, most published works were still produced through traditional block printing techniques. The publication of a Taoist text inscribed with the name of Tregene Khatun, gedei’s wife, is one of the first printed works sponsored by the Mongols. In 1273, the Mongols created the Imperial Library Directorate, a government-sponsored printing office. The Yuan government established centers for printing throughout China. Local schools and government agencies were funded to support the publishing of books. ",
+        "bbox": [
+            174,
+            378,
+            825,
+            503
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Ground truth through Kingdom of Qocho and Tibetan intermediaries ",
+        "bbox": [
+            176,
+            511,
+            635,
+            525
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Prediction: through Kingdom of Qocho and Tibetan intermediaries ",
+        "bbox": [
+            174,
+            532,
+            619,
+            546
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "WHO APPOINTS ELDERS? ",
+        "bbox": [
+            176,
+            564,
+            351,
+            578
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "ID 5730d473b7151e1900c0155b ",
+        "bbox": [
+            176,
+            588,
+            392,
+            603
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Elders are called by God, affirmed by the church, and ordained by a bishop to a ministry of Word, Sacrament, Order and Service within the church. They may be appointed to the local church, or to other valid extension ministries of the church. Elders are given the authority to preach the Word of God, administer the sacraments of the church, to provide care and counseling, and to order the life of the church for ministry and mission. Elders may also be assigned as District Superintendents, and they are eligible for election to the episcopacy. Elders serve a term of 23 years as provisional Elders prior to their ordination. ",
+        "bbox": [
+            174,
+            611,
+            825,
+            708
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Ground truth bishop, the local church ",
+        "bbox": [
+            176,
+            715,
+            431,
+            729
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Prediction a bishop ",
+        "bbox": [
+            174,
+            737,
+            307,
+            751
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "AN ALGORITHM FOR X WHICH REDUCES TO C WOULD ALLOW US TO DO WHAT? ",
+        "bbox": [
+            176,
+            770,
+            728,
+            785
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "ID 56e1ce08e3433e14004231a6 ",
+        "bbox": [
+            176,
+            796,
+            388,
+            810
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "This motivates the concept of a problem being hard for a complexity class. A problem X is hard for a class of problems C if every problem in C can be reduced to X. Thus no problem in C is harder than X, since an algorithm for X allows us to solve any problem in C. Of course, the notion of hard problems depends on the type of reduction being used. For complexity classes larger than P, polynomial-time reductions are commonly used. In particular, the set of problems that are hard for NP is the set of NP-hard problems. ",
+        "bbox": [
+            174,
+            819,
+            825,
+            901
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Ground truth solve any problem in C ",
+        "bbox": [
+            176,
+            909,
+            426,
+            922
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Prediction solve any problem in C ",
+        "bbox": [
+            176,
+            103,
+            403,
+            117
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "HOW MANY GENERAL QUESTIONS ARE AVAILABLE TO OPPOSITION LEADERS? ",
+        "bbox": [
+            176,
+            137,
+            714,
+            150
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "ID 572fd7b8947a6a140053cd3e ",
+        "bbox": [
+            174,
+            161,
+            387,
+            175
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Parliamentary time is also set aside for question periods in the debating chamber. A ”General Question Time” takes place on a Thursday between $1 1 { : } 4 0 \\ \\mathrm { a . m }$ . and $1 2 \\ \\mathrm { p . m }$ . where members can direct questions to any member of the Scottish Government. At $2 . 3 0 \\mathrm { p m }$ , a 40-minute long themed ”Question Time” takes place, where members can ask questions of ministers in departments that are selected for questioning that sitting day, such as health and justice or education and transport. Between $1 2 \\ \\mathrm { p . m }$ . and $1 2 { : } 3 0 ~ \\mathrm { p . m }$ . on Thursdays, when Parliament is sitting, First Minister’s Question Time takes place. This gives members an opportunity to question the First Minister directly on issues under their jurisdiction. Opposition leaders ask a general question of the First Minister and then supplementary questions. Such a practice enables a ”lead-in” to the questioner, who then uses their supplementary question to ask the First Minister any issue. The four general questions available to opposition leaders are: ",
+        "bbox": [
+            174,
+            184,
+            825,
+            335
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Ground truth four ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            343,
+            302,
+            357
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Prediction four ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            364,
+            279,
+            378
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "WHAT ARE SOME OF THE ACCEPTED GENERAL PRINCIPLES OF EUROPEAN UNION LAW? ",
+        "bbox": [
+            173,
+            397,
+            781,
+            410
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "ID 5726a00cf1498d1400e8e551 ",
+        "bbox": [
+            176,
+            422,
+            387,
+            436
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "The principles of European Union law are rules of law which have been developed by the European Court of Justice that constitute unwritten rules which are not expressly provided for in the treaties but which affect how European Union law is interpreted and applies. In formulating these principles, the courts have drawn on a variety of sources, including: public international law and legal doctrines and principles present in the legal systems of European Union member states and in the jurisprudence of the European Court of Human Rights. Accepted general principles of European Union Law include fundamental rights (see human rights), proportionality, legal certainty, equality before the law and subsidiarity. ",
+        "bbox": [
+            174,
+            444,
+            825,
+            556
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Ground truth fundamental rights (see human rights), proportionality, legal certainty, equality before the law and subsidiarity ",
+        "bbox": [
+            174,
+            563,
+            820,
+            590
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Prediction fundamental rights (see human rights), proportionality, legal certainty, equality before the law and subsidiarity ",
+        "bbox": [
+            174,
+            598,
+            823,
+            626
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "WHY WAS TESLA RETURNED TO GOSPIC? ",
+        "bbox": [
+            176,
+            643,
+            465,
+            657
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "ID 56dfaa047aa994140058dfbd ",
+        "bbox": [
+            176,
+            670,
+            385,
+            684
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "On 24 March 1879, Tesla was returned to Gospi under police guard for not having a residence permit. On 17 April 1879, Milutin Tesla died at the age of 60 after contracting an unspecified illness (although some sources say that he died of a stroke). During that year, Tesla taught a large class of students in his old school, Higher Real Gymnasium, in Gospi. ",
+        "bbox": [
+            174,
+            691,
+            825,
+            747
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Ground truth not having a residence permit ",
+        "bbox": [
+            176,
+            753,
+            467,
+            768
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Prediction not having a residence permit ",
+        "bbox": [
+            176,
+            775,
+            444,
+            790
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "A.4 SAMPLES OF INCORRECT SQUAD PREDICTIONS BY THE DYNAMIC COATTENTION NETWORK ",
+        "bbox": [
+            173,
+            808,
+            790,
+            835
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "WHAT IS ONE SUPPLEMENTARY SOURCE OF EUROPEAN UNION LAW? ",
+        "bbox": [
+            176,
+            847,
+            653,
+            861
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "ID 5725c3a9ec44d21400f3d506 ",
+        "bbox": [
+            176,
+            873,
+            388,
+            888
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "European Union law is applied by the courts of member states and the Court of Justice of the European Union. Where the laws of member states provide for lesser rights European Union law can be enforced by the courts of member states. In case of European Union law which should have been transposed into the laws of member states, such as Directives, the European Commission can take proceedings against the member state under the Treaty on the Functioning of the European Union. The European Court of Justice is the highest court able to interpret European Union law. Supplementary sources of European Union law include case law by the Court of Justice, international law and general principles of European Union law. ",
+        "bbox": [
+            174,
+            895,
+            823,
+            922
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            103,
+            825,
+            186
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "Ground truth international law ",
+        "bbox": [
+            176,
+            194,
+            385,
+            208
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "Prediction case law by the Court of Justice ",
+        "bbox": [
+            174,
+            215,
+            460,
+            229
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "Comment The prediction produced by the model is correct, however it was not selected by Mechanical Turk annotators. ",
+        "bbox": [
+            173,
+            237,
+            821,
+            265
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "WHO DESIGNED THE ILLUMINATION SYSTEMS THAT TESLA ELECTRIC LIGHT & MANUFACTURING INSTALLED? ",
+        "bbox": [
+            176,
+            282,
+            727,
+            309
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "ID 56e0d6cf231d4119001ac424 ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            321,
+            388,
+            335
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "After leaving Edison’s company Tesla partnered with two businessmen in 1886, Robert Lane and Benjamin Vail, who agreed to finance an electric lighting company in Tesla’s name, Tesla Electric Light & Manufacturing. The company installed electrical arc light based illumination systems designed by Tesla and also had designs for dynamo electric machine commutators, the first patents issued to Tesla in the US. ",
+        "bbox": [
+            174,
+            343,
+            825,
+            412
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "Ground truth Tesla ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            420,
+            310,
+            434
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "Prediction Robert Lane and Benjamin Vail ",
+        "bbox": [
+            176,
+            441,
+            459,
+            455
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "Comment The model produces an incorrect prediction that corresponds to people that funded Tesla, instead of Tesla who actually designed the illumination system. Empirically, we find that most mistakes made by the model have the correct type (eg. named entity type) despite not including types as prior knowledge to the model. In this case, the incorrect response has the correct type of person. ",
+        "bbox": [
+            174,
+            463,
+            825,
+            532
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "CYDIPPID ARE TYPICALLY WHAT SHAPE? ",
+        "bbox": [
+            176,
+            550,
+            462,
+            564
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "ID 57265746dd62a815002e821a ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            575,
+            392,
+            590
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "Cydippid ctenophores have bodies that are more or less rounded, sometimes nearly spherical and other times more cylindrical or egg-shaped; the common coastal ”sea gooseberry,” Pleurobrachia, sometimes has an egg-shaped body with the mouth at the narrow end, although some individuals are more uniformly round. From opposite sides of the body extends a pair of long, slender tentacles, each housed in a sheath into which it can be withdrawn. Some species of cydippids have bodies that are flattened to various extents, so that they are wider in the plane of the tentacles. ",
+        "bbox": [
+            174,
+            597,
+            825,
+            680
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "Ground truth more or less rounded, egg-shaped ",
+        "bbox": [
+            174,
+            688,
+            495,
+            702
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "Prediction spherical ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            709,
+            310,
+            723
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "Comment Although the mistake is subtle, the prediction is incorrect. The statement “are more or less rounded, sometimes nearly spherical” suggests that the entity is more often “rounded” than “spherical” or “cylindrical” or “egg-shaped” (an answer given by an annotator). This suggests that the model has trouble discerning among multiple intuitive answers due to a lack of understanding of the relative severity of “more or less” versus “sometimes” and “other times”. ",
+        "bbox": [
+            174,
+            731,
+            825,
+            800
+        ],
+        "page_idx": 13
+    }
+]

parse/train/tUeeRzMXJZ/tUeeRzMXJZ.md

@@ -0,0 +1,333 @@
+# Provably Efficient Causal Reinforcement Learning with Confounded Observational Data
+
+Lingxiao Wang Northwestern University lwang@u.northwestern.edu
+
+Zhuoran Yang Princeton University zy6@princeton.edu
+
+Zhaoran Wang Northwestern University zhaoranwang@gmail.com
+
+# Abstract
+
+Empowered by neural networks, deep reinforcement learning (DRL) achieves tremendous empirical success. However, DRL requires a large dataset by interacting with the environment, which is unrealistic in critical scenarios such as autonomous driving and personalized medicine. In this paper, we study how to incorporate the dataset collected in the offline setting to improve the sample efficiency in the online setting. To incorporate the observational data, we face two challenges. (a) The behavior policy that generates the observational data may depend on unobserved random variables (confounders), which affect the received rewards and transition dynamics. (b) Exploration in the online setting requires quantifying the uncertainty given both the observational and interventional data. To tackle such challenges, we propose the deconfounded optimistic value iteration (DOVI) algorithm, which incorporates the confounded observational data in a provably efficient manner. DOVI explicitly adjusts for the confounding bias in the observational data, where the confounders are partially observed or unobserved. In both cases, such adjustments allow us to construct the bonus based on a notion of information gain, which takes into account the amount of information acquired from the offline setting. In particular, we prove that the regret of DOVI is smaller than the optimal regret achievable in the pure online setting when the confounded observational data are informative upon the adjustments.
+
+# 1 Introduction
+
+Empowered by the breakthrough in neural networks, deep reinforcement learning (DRL) achieves significant empirical successes in various scenarios [19, 23, 36, 37]. Learning an expressive function approximator necessitates collecting a large dataset. Specifically, in the online setting, it requires the agent to interact with the environment for a large number of steps. For example, to learn a human-level policy for playing Atari games, the agent has to interact with a simulator for more than $1 0 ^ { 8 }$ steps [13]. However, in most scenarios, we do not have access to a simulator that allows for trial and error without any cost. Meanwhile, in critical scenarios, e.g., autonomous driving and personalized medicine, trial and error in the real world is unsafe and even unethical. As a result, it remains challenging to apply DRL to more scenarios.
+
+To bypass such a barrier, we study how to incorporate the dataset collected offline, namely the observational data, to improve the sample efficiency of RL in the online setting [21]. In contrast to the interventional data collected online in possibly expensive ways, observational data are often abundantly available in various scenarios. For example, in autonomous driving, we have access to trajectories generated by the drivers. As another example, in personalized medicine, we have access to electronic health records from doctors. However, to incorporate the observational data in a provably efficient way, we have to address two challenges.
+
+• The observational data are possibly confounded. Specifically, there often exist unobserved random variables, namely confounders, that causally affect the agent and the environment at the same time. In particular, the policy used to generate the observational data, namely the behavior policy, possibly depends on the confounders. Meanwhile, the confounders possibly affect the received rewards and the transition dynamics.
+
+In the example of autonomous driving [9, 22], the drivers may be affected by complicated traffic or poor road design, resulting in traffic accidents even without misconduct. The complicated traffic and poor road design subsequently affect both the action of the drivers and the outcome. Therefore, it is unclear from the observational data whether the accidents are due to the actions adopted by the drivers. Agents trained with such observational data may be unwilling to take any actions under complicated traffic, jeopardizing the safety of passengers.
+
+In the example of personalized medicine [8, 29], the patients may not be compliant with prescriptions and instructions, which subsequently affects both the treatment and the outcome. As another example, the doctor may prescribe medicine to patients based on patients’ socioeconomic status (which could be inferred by the doctor through interacting with the patients). Meanwhile, socioeconomic status affects the patients’ health condition and subsequently plays the role of the confounder. In both scenarios, such confounders may be unavailable due to privacy or ethical concerns. Such a confounding issue makes the observational data uninformative and even misleading for identifying and estimating the causal effect, which is crucial for decision-making in the online setting. In all the examples, it is unclear from the observational data whether the outcome is due to the actions adopted.
+
+• Even without the confounding issue, it remains unclear how the observational data may facilitate exploration in the online setting, which is the key to the sample efficiency of RL. At the core of exploration is uncertainty quantification. Specifically, quantifying the uncertainty that remains given the dataset collected up to the current step, including the observational data and the interventional data, allows us to construct a bonus. When incorporated into the reward, such a bonus encourages the agent to explore the less visited state-action pairs with more uncertainty. In particular, constructing such a bonus requires quantifying the amount of information carried over by the observational data from the offline setting, which also plays a key role in characterizing the regret, especially how much the observational data may facilitate reducing the regret.
+
+Uncertainty quantification becomes even more challenging when the observational data are confounded. Specifically, as the behavior policy depends on the confounders, there is a mismatch between the data generating processes in the offline setting and the online setting. As a result, it remains challenging to quantify how much information carried over from the offline setting is useful for the online setting, as the observational data are uninformative and even misleading due to the confounding issue.
+
+Contribution. To study causal reinforcement learning, we propose a class of Markov decision processes (MDPs), namely confounded MDPs, which captures the data generating processes in both the offline setting and the online setting as well as their mismatch due to the confounding issue. In particular, we study two tractable cases of confounded MDPs in the episodic setting with linear function approximation [7, 16, 42, 43].
+
+• In the first case, the confounders are partially observed in the observational data. Assuming that an observed subset of the confounders satisfies the backdoor criterion [32], we propose the deconfounded optimistic value iteration (DOVI) algorithm, which explicitly corrects for the confounding bias in the observational data using the backdoor adjustment. • In the second case, the confounders are unobserved in the observational data. Assuming that there exists an observed set of intermediate states that satisfies the frontdoor criterion [32], we propose an extension of DOVI, namely $\mathrm { D O V I ^ { + } }$ , which explicitly corrects for the confounding bias in the observational data using the composition of two backdoor adjustments. We remark that $\mathrm { D O V I ^ { + } }$ follows the same principle of design as DOVI and defer the discussion of $\mathrm { D O V I ^ { + } }$ to $\ S$ .
+
+In both cases, the adjustments allow DOVI and $\mathrm { D O V I ^ { + } }$ to incorporate the observational data into the interventional data while bypassing the confounding issue. It further enables estimating the causal effect of a policy on the received rewards and the transition dynamics with enlarged effective sample size. Moreover, such adjustments allow us to construct the bonus based on a notion of information gain, which takes into account the amount of information carried over from the offline setting.
+
+In particular, we prove that DOVI and $\mathrm { D O V I ^ { + } }$ attain the $\Delta _ { H } \cdot \sqrt { d ^ { 3 } H ^ { 3 } T }$ -regret up to logarithmic factors, where $d$ is the dimension of features, $H$ is the length of each episode, and $\bar { T _ { \mathbf { \Lambda } } } = H K$ is the number of steps taken in the online setting, where $K$ is the number of episodes. Here the multiplicative factor $\Delta _ { H } > 0$ depends on $d , H ,$ , and a notion of information gain that quantifies the amount of information obtained from the interventional data additionally when given the properly adjusted observational data. When the observational data are unavailable or uninformative upon the adjustments, √ $\Delta _ { H }$ is a logarithmic factor. Correspondingly, DOVI and $\mathrm { D O V I ^ { + } }$ attain the optimal $\sqrt { T }$ -regret achievable in the pure online setting [7, 16, 42, 43]. When the observational data are sufficiently informative upon the adjustments, $\Delta _ { H }$ decreases towards zero as the effective sample size of the observational data increases, which quantifies how much the observational data may facilitate exploration in the online setting.
+
+Related Work. Our work is related to the study of causal bandit [20]. The goal of causal bandit is to obtain the optimal intervention in the online setting where the data generating process is described by a causal diagram. The previous study establishes causal bandit algorithms in the online setting [26, 34], the offline setting [17, 18], and a combination of both settings [11]. In contrast to this line of work, we study causal RL in a combination of the online setting and the offline setting. Causal RL is more challenging than causal bandit, which corresponds to $H = 1$ , as it involves the transition dynamics and is more challenging in exploration. See $\ S _ { \mathrm { B } }$ for a detailed literature review on causal bandit.
+
+Our work is related to the study of causal RL considered in various settings. [45] propose a modelbased RL algorithm that solves dynamic treatment regimes (DTR), which involve a combination of the online setting and the offline setting. Their algorithm hinges on the analysis of sensitivity [3, 27, 38, 44], which constructs a set of feasible models of the transition dynamics based on the confounded observational data. Correspondingly, their algorithm achieves exploration by choosing an optimistic model of the transition dynamics from such a feasible set. In contrast, we propose a model-free RL algorithm, which achieves exploration through the bonus based on a notion of information gain. It is worth mentioning that the assumption of [45] is weaker than ours as theirs does not allow for identifying the causal effect. As a result of partial identification, the regret of their algorithm is the same as the regret in the pure online setting as $T \to + \infty$ . In contrast, our work instantiates the following framework in handling confounders for reinforcement learning. (a) First, we propose the estimation equation based on the observations, which identifies the causal effect of actions on the cumulative reward. (b) Second, we conduct point estimation and uncertainty quantification based on observations and the estimation equation. (c) Finally, we conduct exploration based on the uncertainty quantification and achieve the regret reduction in the online setting. Consequently, the regret of our algorithm is smaller than the regret in the pure online setting by a multiplicative factor for all $T$ . [25] propose a model-based RL algorithm in a combination of the online setting and the offline setting. Their algorithm uses a variational autoencoder (VAE) for estimating a structural causal model (SCM) based on the confounded observational data. In particular, their algorithm utilizes the actor-critic algorithm to obtain the optimal policy in such an SCM. However, the regret of their algorithm remains unclear. [6] propose a model-based RL algorithm in the pure online setting that learns the optimal policy in a partially observable Markov decision process (POMDP). The regret of their algorithm also remains unclear. [35] utilize generative adversarial reinforcement learning to reconstruct transition dynamics with confounder, and [40] propose a model-based approach for POMDP based on adjustment with proxy variables. [30] consider offpolicy policy evaluation under one-decision confounding and constructs worst-case bounds with theoretical guarantee. [4] utilizes states and actions as proxy variables to tackle off-policy policy evaluation with confounders. In contrast, our work utilizes backdoor and frontdoor adjustments to handle confounded observation.
+
+# 2 Confounded Reinforcement Learning
+
+Structural Causal Model. We denote a structural causal model (SCM) [32] by a tuple $( A , B , F , P )$ . Here $A$ is the set of exogenous (unobserved) variables, $B$ is the set of endogenous (observed) variables, $F$ is the set of structural functions capturing the causal relations, which determines an endogenous variable $v \in B$ based on the other exogenous and endogenous variables, and $P$ is the distribution of all the exogenous variables. We say that a pair of variables $Y$ and $Z$ are confounded by a variable $W$ if they are both caused by $W$ .
+
+An intervention on a set of endogenous variables $X \subseteq B$ assigns a value $x$ to $X$ regardless of the other exogenous and endogenous variables as well as the structural functions. We denote by $\operatorname { d o } ( X \ = \ x )$ the intervention on $X$ and write $\operatorname { d o } ( x )$ if it is clear from the context. Similarly, a stochastic intervention [10, 28] on a set of endogenous variables $X \subseteq B$ assigns a distribution $p$ to $X$ regardless of the other exogenous and endogenous variables as well as the structural functions. We denote by $\mathrm { d o } ( X \sim p )$ the stochastic intervention on $X$ .
+
+Confounded Markov Decision Process. To characterize a Markov decision process (MDP) in the offline setting with observational data, which are possibly confounded, we introduce an SCM, where the endogenous variables are the states $\{ s _ { h } \} _ { h \in [ H ] }$ , actions $\{ a _ { h } \} _ { h \in [ H ] }$ , and rewards $\{ r _ { h } \} _ { h \in [ H ] }$ . Let $\{ w _ { h } \} _ { h \in [ H ] }$ be the confounders. In $\ S 3$ , we assume that the confounders are partially observed, while in $\ S$ , we assume that they are unobserved. The set of structural functions $F$ consists of the transition of states $s _ { h + 1 } \sim \mathcal { P } _ { h } ( \cdot \mid s _ { h } , a _ { h } , w _ { h } )$ , the transition of confounders $w _ { h } \sim \widetilde { \mathcal { P } } _ { h } ( \cdot \vert s _ { h } )$ , the behavior policy $a _ { h } \sim \nu _ { h } ( \cdot \mid s _ { h } , w _ { h } )$ , which depends on the confounder $w _ { h }$ , and the reward function $r _ { h } ( s _ { h } , a _ { h } , w _ { h } )$ . See Figure 1 for the causal diagram that describes such an SCM.
+
+![](images/fc242512d131e0246c4a3f1a2122f7150bde2eca97f93e0ff5f87914970bb452.jpg)  
+Figure 1: Causal diagrams of the $h$ -th step of the confounded MDP (a) in the offline setting and (b) in the online setting, respectively.
+
+Here $a _ { h }$ and $s _ { h + 1 }$ are confounded by $w _ { h }$ in addition to $s _ { h }$ . We denote such a confounded MDP by the tuple $( S , \mathcal { A } , \mathcal { W } , H , \overline { { \mathcal { P } } } , r )$ , where $H$ is the length of an episode, $s , A$ , and $\mathcal { W }$ are the spaces of states, actions, and confounders, respectively, $\bar { r \ = \ \{ r _ { h } \} _ { h \in \{ H \} } }$ is the set of reward functions, and $\overline { { \mathcal { P } } } = \{ \mathcal { P } _ { h } , \widetilde { \mathcal { P } } _ { h } \} _ { h \in H }$ is the set of transition kernels. In the sequel, we assume without loss of generality that $r _ { h }$ takes value in $[ 0 , 1 ]$ for all $h \in [ H ]$ .
+
+In the online setting that allows for intervention, we assume that the confounders $\{ w _ { h } \} _ { h \in [ H ] }$ are unobserved. A policy $\pi = \{ \pi _ { h } \} _ { h \in [ H ] }$ induces the stochastic intervention $\mathrm { d o } ( a _ { 1 } \sim$ $\pi _ { 1 } ( \cdot \cdot \vert s _ { 1 } ) , \ldots , a _ { H } \sim \pi _ { H } ( \cdot \vert s _ { H } ) )$ , which does not depend on the confounders. In particular, an agent interacts with the environment as follows. At the beginning of the $k$ -th episode, the environment arbitrarily selects an initial state $s _ { 1 } ^ { k }$ and the agent selects a policy $\pi ^ { k } = \mathbf { \bar { \{ } }  { \pi _ { h } ^ { k } } \} _ { h \in [ H ] }$ . At the $h$ -th step of the $k$ -th episode, the agent observes the state $s _ { h } ^ { k }$ and takes the action $a _ { h } ^ { k } \sim \bar { \pi } _ { h } ^ { k } ( \cdot | s _ { h } ^ { k } )$ . The environment randomly selects the confounder $w _ { h } ^ { k } \sim \widetilde { \mathcal { P } } _ { h } ( \cdot \vert s _ { h } ^ { k } )$ , which is unobserved, and the agent receives the reward $s _ { h + 1 } ^ { k } \sim \mathcal { P } _ { h } ( \cdot \mid s _ { h } ^ { k } , a _ { h } ^ { k } , w _ { h } ^ { k } )$ . ${ r _ { h } ^ { k } } = r _ { h } ( s _ { h } ^ { k } , a _ { h } ^ { k } , w _ { h } ^ { k } )$ . The environment then transits into the next state
+
+For a policy $\pi = \{ \pi _ { h } \} _ { h \in H }$ , which does not depend on the confounders $\{ w _ { h } \} _ { h \in [ H ] }$ , we define the value function $V ^ { \pi } = \{ V _ { h } ^ { \pi } \} _ { h \in [ H ] }$ as follows,
+
+$$
+V _ { h } ^ { \pi } ( s ) = \mathbb { E } _ { \pi } \bigg [ \sum _ { j = h } ^ { H } r _ { j } ( s _ { j } , a _ { j } , w _ { j } ) \biggm | s _ { h } = s \bigg ] , \quad \forall h \in [ H ] ,
+$$
+
+where we denote by $\mathbb { E } _ { \pi }$ the expectation with respect to the confounders $\{ w _ { j } \} _ { j = h } ^ { H }$ and the trajectory $\{ ( s _ { j } , a _ { j } ) \} _ { j = h } ^ { H }$ , starting from the state $s _ { j } = s$ and following the policy $\pi$ . Correspondingly, we define the action-value function $Q ^ { \pi } = \{ Q _ { h } ^ { \pi } \} _ { h \in [ H ] }$ as follows,
+
+$$
+Q _ { h } ^ { \pi } ( s , a ) = \mathbb { E } _ { \pi } \bigg [ \sum _ { j = h } ^ { H } r _ { j } ( s _ { j } , a _ { j } , w _ { j } ) \biggm | s _ { h } = s , \mathrm { d o } ( a _ { h } = a ) \bigg ] , \quad \forall h \in [ H ] .
+$$
+
+We assess the performance of an algorithm using the regret against the globally optimal policy $\pi ^ { * } = \{ \pi _ { h } ^ { * } \} _ { h \in [ H ] }$ in hindsight after $K$ episodes, which is defined as follows,
+
+$$
+\mathrm { R e g r e t } ( T ) = \operatorname* { m a x } _ { \pi } \sum _ { k = 1 } ^ { K } \bigl ( V _ { 1 } ^ { \pi } ( s _ { 1 } ^ { k } ) - V _ { 1 } ^ { \pi ^ { k } } ( s _ { 1 } ^ { k } ) \bigr ) = \sum _ { k = 1 } ^ { K } \bigl ( V _ { 1 } ^ { \pi ^ { * } } ( s _ { 1 } ^ { k } ) - V _ { 1 } ^ { \pi ^ { k } } ( s _ { 1 } ^ { k } ) \bigr ) .
+$$
+
+Here $T = H K$ is the total number of steps.
+
+Our goal is to design an algorithm that minimizes the regret defined in (2.3), where $\pi ^ { * }$ does not depend on the confounders $\{ w _ { h } \} _ { h \in [ H ] }$ . In the online setting that allows for intervention, it is well understood how to minimize such a regret [2, 14–16]. However, it remains unclear how to efficiently utilize the observational data obtained in the offline setting, which are possibly confounded. In realworld applications, e.g., autonomous driving and personalized medicine, such observational data are often abundant, whereas intervention in the online setting is often restricted. We refer to $\mathrm { \ S C }$ for a comparison between the confounded MDP and other extensions of MDP, including the dynamics treatment regime (DTR), partially observable MDP (POMDP), and contextual MDP (CMDP).
+
+Why is Incorporating Confounded Observational Data Challenging? Straightforwardly incorporating the confounded observational data into an online algorithm possibly leads to an undesirable regret due to the mismatch between the online and offline data generating processes. In particular, due to the existence of the confounders $\{ w _ { h } \} _ { h \in [ H ] }$ , which are partially observed (§3) or unobserved $^ { ( \ S ) }$ , the conditional probability $\mathbb { P } ( s _ { h + 1 } \mid s _ { h } , a _ { h } )$ in the offline setting is different from the causal effect $\mathbb { P } ( s _ { h + 1 } \mid s _ { h } , \mathrm { d o } ( a _ { h } ) )$ in the online setting [33]. More specifically, it holds that
+
+$$
+\begin{array} { r l } & { \mathbb { P } \big ( s _ { h + 1 } | s _ { h } , a _ { h } \big ) = \frac { \mathbb { E } _ { w _ { h } \sim \widetilde { \mathcal { P } } _ { h } ( \cdot | s _ { h } ) } \big [ \mathcal { P } _ { h } \big ( s _ { h + 1 } | s _ { h } , a _ { h } , w _ { h } \big ) \cdot \nu _ { h } \big ( a _ { h } | s _ { h } , w _ { h } \big ) \big ] } { \mathbb { E } _ { w _ { h } \sim \widetilde { \mathcal { P } } _ { h } ( \cdot | s _ { h } ) } \big [ \nu _ { h } \big ( a _ { h } \big | s _ { h } , w _ { h } \big ) \big ] } , } \\ & { \mathbb { P } \big ( s _ { h + 1 } \big | s _ { h } , \mathrm { d o } ( a _ { h } ) \big ) = \mathbb { E } _ { w _ { h } \sim \widetilde { \mathcal { P } } _ { h } ( \cdot | s _ { h } ) } \big [ \mathcal { P } _ { h } \big ( \cdot | s _ { h } , a _ { h } , w _ { h } \big ) \big ] . } \end{array}
+$$
+
+In other words, without proper covariate adjustments [32], the confounded observational data may be not informative for estimating the transition dynamics and the associated action-value function in the online setting. To this end, we propose an algorithm that incorporates the confounded observational data in a provably efficient manner. Moreover, our analysis quantifies the amount of information carried over by the confounded observational data from the offline setting and to what extent it helps reducing the regret in the online setting.
+
+# 3 Algorithm and Theory for Partially Observed Confounder
+
+In this section, we propose the Deconfounded Optimistic Value Iteration (DOVI) algorithm. DOVI handles the case where the confounders are unobserved in the online setting but are partially observed in the offline setting. We then characterize the regret of DOVI. We defer the extension of DOVI, namely $\mathrm { D O V I + }$ , to $\ S \mathrm { A }$ which handles the case where the confounders are unobserved in both the online setting and the offline setting.
+
+# 3.1 Algorithm
+
+Backdoor Adjustment. In the online setting that allows for intervention, the causal effect of $a _ { h }$ on $s _ { h + 1 }$ given $s _ { h }$ , that is, $\mathbb { P } \big ( s _ { h + 1 } | s _ { h } , \mathrm { d o } ( a _ { h } ) \big ) \big )$ , plays a key role in the estimation of the action-value function. Meanwhile, the confounded observational data may not allow us to identify the causal effect $\mathbb { P } \big ( s _ { h + 1 } | s _ { h } , \mathrm { d o } ( a _ { h } ) \big )$ if the confounder $w _ { h }$ is unobserved. However, if the confounder $w _ { h }$ is partially observed in the offline setting, the observed subset $u _ { h }$ of $w _ { h }$ allows us to identify the causal effect $\bar { \mathbb { P } } ( s _ { h + 1 } \mid s _ { h } , \mathrm { d o } ( a _ { h } ) )$ , as long as $u _ { h }$ satisfies the following backdoor criterion.
+
+Assumption 3.1 (Backdoor Criterion [32, 33]). In the SCM defined in $\ S$ and its induced directed acyclic graph (DAG), for all $h \in [ H ]$ , there exists an observed subset $u _ { h }$ of $w _ { h }$ that satisfies the backdoor criterion, that is,
+
+• the elements of $u _ { h }$ are not the descendants of $a _ { h }$ , and   
+• conditioning on $s _ { h }$ , the elements of $u _ { h }$ $d$ -separate every path between $a _ { h }$ and $s _ { h + 1 } , r _ { h }$ that has an incoming arrow into $a _ { h }$ .
+
+See Figure 2 for an example that satisfies the backdoor criterion. In particular, we identify the causal effect $\bar { \mathbb { P } } ( s _ { h + 1 } \mid s _ { h } , \mathrm { d o } ( a _ { h } \bar { ) } )$ as follows.
+
+![](images/fa812e4d1a72af3a441491ece0e503dfa5d5d4fc3fb3f61e57797a91312491fe.jpg)  
+Figure 2: An illustration of the backdoor criterion modified from [32]. The causal diagram corresponds to the $h$ -th step of the confounded MDP conditioning on $s _ { h }$ . Here $w _ { h } = \{ w _ { 1 , h } , w _ { 2 , h } , w _ { 3 , h } \}$ is the unobserved confounders and the subset $u _ { h } = \left\{ u _ { 1 , h } , u _ { 2 , h } \right\}$ satisfies the backdoor criterion.
+
+Proposition 3.2 (Backdoor Adjustment [32]). Under Assumption 3.1, it holds for all $h \in [ H ]$ that
+
+$$
+\begin{array} { r l } & { \mathbb { P } \big ( s _ { h + 1 } \mid s _ { h } , \mathrm { d o } ( a _ { h } ) \big ) = \mathbb { E } _ { u _ { h } \sim \mathbb { P } ( \cdot \mid s _ { h } ) } \left[ \mathbb { P } ( s _ { h + 1 } \mid s _ { h } , a _ { h } , u _ { h } ) \right] , } \\ & { \mathbb { E } \big [ r _ { h } ( s _ { h } , a _ { h } , w _ { h } ) \big \mid s _ { h } , \mathrm { d o } ( a _ { h } ) \big ] = \mathbb { E } _ { u _ { h } \sim \mathbb { P } ( \cdot \mid s _ { h } ) } \Big [ \mathbb { E } \big [ r _ { h } ( s _ { h } , a _ { h } , w _ { h } ) \big \mid s _ { h } , a _ { h } , u _ { h } \big ] \Big ] . } \end{array}
+$$
+
+Here $( s _ { h + 1 } , s _ { h } , a _ { h } , u _ { h } )$ follows the SCM defined in $\ S 2$ , which generates the confounded observational data.
+
+Proof. See [32] for a detailed proof.
+
+With a slight abuse of notation, we write $\mathbb { P } ( s _ { h + 1 } \mid s _ { h } , a _ { h } , u _ { h } )$ as $\mathcal { P } _ { h } ( s _ { h + 1 } \mid s _ { h } , a _ { h } , u _ { h } )$ and $\mathbb { P } ( u _ { h } \mid s _ { h } )$ as $\mathcal { \widetilde { P } } _ { h } ( u _ { h } \vert s _ { h } )$ , since they are induced by the SCM defined in $\ S 2$ . In the sequel, we define $\mathcal { U }$ the space of observed state $u _ { h }$ and write $r _ { h } = r _ { h } ( s _ { h } , a _ { h } , w _ { h } )$ for notational simplicity.
+
+Backdoor-Adjusted Bellman Equation. We now formulate the Bellman equation for the confounded MDP. It holds for all $( s _ { h } , a _ { h } ) \in \mathcal { S } \times \mathcal { A }$ that
+
+$$
+Q _ { h } ^ { \pi } ( s _ { h } , a _ { h } ) = \mathbb { E } _ { \pi } \left[ \sum _ { j = h } ^ { H } r _ { j } ( s _ { j } , a _ { j } , u _ { j } ) \middle | s _ { h } , \mathrm { d o } ( a _ { h } ) \right] = \mathbb { E } \left[ r _ { h } \middle | s _ { h } , \mathrm { d o } ( a _ { h } ) \right] + \mathbb { E } _ { s _ { h + 1 } } \left[ V _ { h + 1 } ^ { \pi } ( s _ { h + 1 } ) \right] ,
+$$
+
+where Esh+1 denotes the expectation with respect to $\begin{array} { r l r } { s _ { h + 1 } } & { { } \sim } & { \mathbb { P } ( \cdot \mid s _ { h } , \mathrm { d o } ( a _ { h } ) ) } \end{array}$ . Here $\mathbb { E } [ r _ { h } \vert s _ { h } , \mathrm { d o } ( a _ { h } ) ]$ and $\mathbb { P } ( \cdot \mid s _ { h } , \mathrm { d o } ( a _ { h } ) )$ are characterized in Proposition 3.2. In the sequel, we define the following transition operator and counterfactual reward function,
+
+$$
+\begin{array} { r l } & { ( \mathbb { P } _ { h } V ) ( s _ { h } , a _ { h } ) = \mathbb { E } _ { s _ { h + 1 } \sim \mathbb { P } ( \cdot \mid s _ { h } , \mathrm { d o } ( a _ { h } ) ) } \bigl [ V ( s _ { h + 1 } ) \bigr ] , \quad \forall V : \mathcal { S } \mapsto \mathbb { R } , ( s _ { h } , a _ { h } ) \in \mathcal { S } \times \mathcal { A } , } \\ & { \quad R _ { h } ( s _ { h } , a _ { h } ) = \mathbb { E } \bigl [ r _ { h } \mid s _ { h } , \mathrm { d o } ( a _ { h } ) \bigr ] , \quad \forall ( s _ { h } , a _ { h } ) \in \mathcal { S } \times \mathcal { A } . } \end{array}
+$$
+
+We have the following Bellman equation,
+
+$$
+\begin{array} { r } { Q _ { h } ^ { \pi } ( s _ { h } , a _ { h } ) = R _ { h } ( s _ { h } , a _ { h } ) + ( \mathbb { P } _ { h } V _ { h + 1 } ^ { \pi } ) ( s _ { h } , a _ { h } ) , \quad \forall h \in [ H ] , ( s _ { h } , a _ { h } ) \in \mathcal { S } \times \mathcal { A } . } \end{array}
+$$
+
+Correspondingly, the Bellman optimality equation takes the following form,
+
+$$
+Q _ { h } ^ { * } ( s _ { h } , a _ { h } ) = R _ { h } ( s _ { h } , a _ { h } ) + ( { \mathbb { P } } _ { h } V _ { h + 1 } ^ { * } ) ( s _ { h } , a _ { h } ) , \quad V _ { h } ^ { * } ( s _ { h } ) = \operatorname* { m a x } _ { a _ { h } \in \mathcal { A } } Q _ { h } ^ { * } ( s _ { h } , a _ { h } ) ,
+$$
+
+which holds for all $h \in [ H ]$ and $( s _ { h } , a _ { h } ) \in \mathcal { S } \times \mathcal { A }$ . Such a Bellman optimality equation allows us to adapt the least-squares value iteration (LSVI) algorithm [2, 5, 14, 16, 31].
+
+Linear Function Approximation. We focus on the following setting with linear transition kernels and reward functions [7, 16, 42, 43], which corresponds to a linear SCM [33].
+
+Assumption 3.3 (Linear Confounded MDP). We assume that $\begin{array} { r } { \mathcal { P } _ { h } \big ( s _ { h + 1 } \big | s _ { h } , a _ { h } , u _ { h } \big ) = \big \langle \phi _ { h } \big ( s _ { h } , a _ { h } , u _ { h } \big ) , \mu _ { h } \big ( s _ { h + 1 } \big ) \big \rangle , \quad \forall h \in [ H ] , ( s _ { h + 1 } , s _ { h } , a _ { h } ) \in \mathcal { S } \times \mathcal { S } \times \mathcal { A } , } \end{array}$ where $\phi _ { h } ( \cdot , \cdot , \cdot )$ and $\boldsymbol { \mu } _ { h } ( \cdot ) = ( \mu _ { 1 , h } ( \cdot ) , \ldots , \mu _ { d , h } ( \cdot ) ) ^ { \top }$ are $\mathbb { R } ^ { d }$ -valued functions. We assume that $\begin{array} { r } { \sum _ { i = 1 } ^ { d } \| \mu _ { i , h } \| _ { 1 } ^ { 2 } \leq d } \end{array}$ and $\| \phi _ { h } ( s _ { h } , a _ { h } , u _ { h } ) \| _ { 2 } \le 1$ for all $h \in [ H ]$ and $( s _ { h } , a _ { h } , u _ { h } ) \in \mathcal S \times \mathcal A \times \mathcal U$ Meanwhile, we assume that
+
+$\begin{array} { r } { \mathbb { E } [ r _ { h } | s _ { h } , a _ { h } , u _ { h } ] = \phi _ { h } ( s _ { h } , a _ { h } , u _ { h } ) ^ { \top } \theta _ { h } , \quad \forall h \in [ H ] , ( s _ { h } , a _ { h } , u _ { h } ) \in \mathcal { S } \times \mathcal { A } \times \mathcal { U } , } \end{array}$ where $\theta _ { h } \in \mathbb { R } ^ { d }$ and $\| \theta _ { h } \| _ { 2 } \leq \sqrt { d }$ for all $h \in [ H ]$ .
+
+Such a linear setting generalizes the tabular setting where $s , A .$ , and $\mathcal { U }$ are finite.
+
+Proposition 3.4. We define the backdoor-adjusted feature as follows,
+
+$$
+\begin{array} { r } { \psi _ { h } ( s _ { h } , a _ { h } ) = \mathbb { E } _ { a _ { h } \sim \widetilde { \mathcal { P } } _ { h } ( \cdot \mid s _ { h } ) } \big [ \phi _ { h } ( s _ { h } , a _ { h } , u _ { h } ) \big ] , \quad \forall h \in [ H ] , ( s _ { h } , a _ { h } ) \in \mathcal { S } \times \mathcal { A } . } \end{array}
+$$
+
+Under Assumption 3.1, it holds that
+
+$$
+\mathbb { P } ( s _ { h + 1 } | s _ { h } , \mathrm { d o } ( a _ { h } ) ) = \langle \psi _ { h } ( s _ { h } , a _ { h } ) , \mu _ { h } ( s _ { h + 1 } ) \rangle , \quad \forall h \in [ H ] , ( s _ { h + 1 } , s _ { h } , a _ { h } ) \in \mathcal { S } \times \mathcal { S } \times \mathcal { A } .
+$$
+
+Moreover, the action-value functions $Q _ { h } ^ { \pi }$ and $Q _ { h } ^ { * }$ are linear in the backdoor-adjusted feature $\psi _ { h }$ for all $\pi$ .
+
+Proof. See $\mathrm { \ S F . 1 }$ for a detailed proof.
+
+Such an observation allows us to estimate the action-value function based on the backdoor-adjusted features $\{ \psi _ { h } \} _ { h \in [ H ] }$ in the online setting. See $\ S$ for a detailed discussion. In the sequel, we assume that either the density of $\{ \widetilde { \mathcal { P } } _ { h } ( \cdot \vert s _ { h } ) \} _ { h \in [ H ] }$ is known or the backdoor-adjusted feature $\{ \psi _ { h } \} _ { h \in [ H ] }$ is known.
+
+In the sequel, we introduce the DOVI algorithm (Algorithm 1). Each iteration of DOVI consists of two components, namely point estimation, where we estimate $Q _ { h } ^ { * }$ based on the confounded observational data and the interventional data, and uncertainty quantification, where we construct the upper confidence bound (UCB) of the point estimator.
+
+# Algorithm 1 Deconfounded Optimistic Value Iteration (DOVI) for Confounded MDP
+
+Require: Observational data $\{ ( s _ { h } ^ { i } , a _ { h } ^ { i } , u _ { h } ^ { i } , r _ { h } ^ { i } ) \} _ { i \in [ n ] , h \in [ H ] }$ , tuning parameters $\lambda , \beta > 0$ , backdooradjusted feature $\{ \psi _ { h } \} _ { h \in [ H ] }$ , which is defined in (3.6).   
+1: Initialization: Set $\{ Q _ { h } ^ { 0 } , V _ { h } ^ { 0 } \} _ { h \in [ H ] }$ as zero functions and $V _ { H + 1 } ^ { k }$ as a zero function for $k \in [ K ]$ . 2: for $k = 1 , \ldots , K$ do   
+3: for 4: S $h = H , \ldots , 1$   
+$\begin{array} { r } { \omega _ { h } ^ { k }  { \stackrel {  } { \sim } } \operatorname { a r g m i n } _ { \omega \in \mathbb { R } ^ { d } } \sum _ { \tau = 1 } ^ { k - 1 } ( r _ { h } ^ { \tau } + V _ { h + 1 } ^ { \tau } ( s _ { h + 1 } ^ { \tau } ) - \omega ^ { \top } \psi _ { h } ( s _ { h } ^ { \tau } , a _ { h } ^ { \tau } ) ) ^ { 2 } + \lambda \| \omega \| _ { 2 } ^ { 2 } + L _ { h } ^ { k } ( \omega ) , } \end{array}$ where $L _ { h } ^ { k }$ is defined in (3.8).   
+5: Set $Q _ { h } ^ { k } ( \cdot , \cdot ) \gets \operatorname* { m i n } \{ \psi _ { h } ( \cdot , \cdot ) ^ { \top } \omega _ { h } ^ { k } + \Gamma _ { h } ^ { k } ( \cdot , \cdot ) , H - h \}$ , where $\Gamma _ { h } ^ { k }$ is defined in (3.12). 6: Set $\pi _ { h } ^ { k } ( \cdot \vert s _ { h } ) \gets \mathrm { a r g m a x } _ { a _ { h } \in \mathcal { A } } Q _ { h } ^ { k } ( s _ { h } , a _ { h } )$ for all $s _ { h } \in S$ .   
+7: Set $V _ { h } ^ { k } ( \cdot )  \langle \pi _ { h } ^ { k } ( \cdot \vert \cdot ) , Q _ { h } ^ { k } ( \cdot , \cdot ) \rangle _ { \cal A }$ .   
+8: end for   
+9: Obtain $s _ { 1 } ^ { k }$ from the environment.   
+10: for $h = 1 , \ldots , H$ do   
+11: Take $a _ { h } ^ { k } \sim \pi _ { h } ^ { k } ( \cdot | s _ { h } ^ { k } )$ . Obtain $r _ { h } ^ { k } = r _ { h } ( s _ { h } ^ { k } , a _ { h } ^ { k } , u _ { h } ^ { k } )$ and $s _ { h + 1 } ^ { k }$ .   
+12: end for   
+13: end for
+
+Point Estimation. To solve the Bellman optimality equation in (3.4), we minimize the empirical mean-squared Bellman error as follows at each step,
+
+$$
+\omega _ { h } ^ { k } \gets \underset { \omega \in \mathbb { R } ^ { d } } { \operatorname { a r g m i n } } \sum _ { \tau = 1 } ^ { k - 1 } \big ( r _ { h } ^ { \tau } + V _ { h + 1 } ^ { \tau } ( s _ { h + 1 } ^ { \tau } ) - \omega ^ { \top } \psi _ { h } ( s _ { h } ^ { \tau } , a _ { h } ^ { \tau } ) \big ) ^ { 2 } + \lambda \| \omega \| _ { 2 } ^ { 2 } + L _ { h } ^ { k } ( \omega ) , h = H , \ldots , 1 ,
+$$
+
+where we set $V _ { H + 1 } ^ { k } = 0$ for all $k \in [ K ]$ and $V _ { h + 1 } ^ { \tau }$ is defined in Line 7 of Algorithm 1 for all $( \tau , h ) \in [ K ] \times [ H - 1 ]$ . Here $k$ is the index of episode, $\lambda > 0$ is a tuning parameter, and $L _ { h } ^ { k }$ is a regularizer, which is constructed based on the confounded observational data. More specifically, we define
+
+$$
+L _ { h } ^ { k } ( \omega ) = \sum _ { i = 1 } ^ { n } \bigl ( r _ { h } ^ { i } + V _ { h + 1 } ^ { k } ( s _ { h + 1 } ^ { i } ) - \omega ^ { \top } \phi _ { h } ( s _ { h } ^ { i } , a _ { h } ^ { i } , u _ { h } ^ { i } ) \bigr ) ^ { 2 } , \quad \forall ( k , h ) \in [ K ] \times [ H ] ,
+$$
+
+which corresponds to the least-squares loss for regressing $r _ { h } ^ { i } + V _ { h + 1 } ^ { k } ( s _ { h + 1 } ^ { i } )$ against $\phi _ { h } ( s _ { h } ^ { i } , a _ { h } ^ { i } , u _ { h } ^ { i } )$ for all $i \in [ n ]$ . Here $\{ ( s _ { h } ^ { i } , a _ { h } ^ { i } , u _ { h } ^ { i } , r _ { h } ^ { i } ) \} _ { ( i , h ) \in [ n ] \times [ H ] }$ are the confounded observational data, where $u _ { h } ^ { i } \sim \widetilde { \mathcal { P } } _ { h } ( \cdot | s _ { h } ^ { i } )$ , $s _ { h + 1 } ^ { i } \sim \mathcal { P } _ { h } \big ( \cdot \mid s _ { h } ^ { i } , a _ { h } ^ { i } , u _ { h } ^ { i } \big )$ , and $a _ { h } ^ { i } \sim \nu _ { h } ( \cdot \mid s _ { h } ^ { i } , w _ { h } ^ { i } )$ with $\nu = \{ \nu _ { h } \} _ { h \in [ H ] }$ being the behavior policy. Here recall that, with a slight abuse of notation, we write $\mathbb { P } ( s _ { h + 1 } \mid s _ { h } , a _ { h } , u _ { h } )$ as $\mathcal { P } _ { h } ( s _ { h + 1 } \mid s _ { h } , a _ { h } , u _ { h } )$ and $\mathbb { P } ( u _ { h } \mid s _ { h } )$ as $\mathcal { \widetilde { P } } _ { h } ( u _ { h } \vert s _ { h } )$ , since they are induced by the SCM defined in §2.
+
+The update in (3.7) takes the following explicit form,
+
+$$
+\begin{array} { r l } & { \omega _ { h } ^ { k } \gets ( \Lambda _ { h } ^ { k } ) ^ { - 1 } \Bigg ( \displaystyle \sum _ { \tau = 1 } ^ { k - 1 } \psi _ { h } ( s _ { h } ^ { \tau } , a _ { h } ^ { \tau } ) \cdot \big ( V _ { h + 1 } ^ { k } ( s _ { h + 1 } ^ { \tau } ) + r _ { h } ^ { \tau } \big ) } \\ & { \qquad + \displaystyle \sum _ { i = 1 } ^ { n } \phi _ { h } ( s _ { h } ^ { i } , a _ { h } ^ { i } , u _ { h } ^ { i } ) \cdot \big ( V _ { h + 1 } ^ { k } ( s _ { h + 1 } ^ { i } ) + r _ { h } ^ { i } \big ) \Bigg ) , } \end{array}
+$$
+
+where
+
+$$
+\Lambda _ { h } ^ { k } = \sum _ { \tau = 1 } ^ { k - 1 } \psi _ { h } ( s _ { h } ^ { \tau } , a _ { h } ^ { \tau } ) \psi _ { h } ( s _ { h } ^ { \tau } , a _ { h } ^ { \tau } ) ^ { \top } + \sum _ { i = 1 } ^ { n } \phi _ { h } ( s _ { h } ^ { i } , a _ { h } ^ { i } , u _ { h } ^ { i } ) \phi _ { h } ( s _ { h } ^ { i } , a _ { h } ^ { i } , u _ { h } ^ { i } ) ^ { \top } + \lambda I .
+$$
+
+Uncertainty Quantification. We now construct the UCB $\Gamma _ { h } ^ { k } ( \cdot , \cdot )$ of the point estimator $\psi _ { h } ( \cdot , \cdot ) ^ { \top } \omega _ { h } ^ { k }$ obtained from (3.9), which encourages the exploration of the less visited state-action pairs. To this end, we employ the following notion of information gain to motivate the UCB,
+
+$$
+\Gamma _ { h } ^ { k } ( s _ { h } ^ { k } , a _ { h } ^ { k } ) \propto H ( \omega _ { h } ^ { k } \mid \xi _ { k - 1 } ) - H \big ( \omega _ { h } ^ { k } \mid \xi _ { k - 1 } \cup \{ ( s _ { h } ^ { k } , a _ { h } ^ { k } ) \} \big ) ,
+$$
+
+where $H ( \omega _ { h } ^ { k } \mid \xi _ { k - 1 } )$ is the differential entropy of the random variable $\omega _ { h } ^ { k }$ given the data $\xi _ { k - 1 }$ . In particular, $\ddot { \xi } _ { k - 1 } ~ = ~ \{ \big ( s _ { h } ^ { \tau } , a _ { h } ^ { \tau } , r _ { h } ^ { \tau } \big ) \} _ { ( \tau , h ) \in [ k - 1 ] \times [ H ] } \cup \big \{ \big ( s _ { h } ^ { i } , a _ { h } ^ { i } , u _ { h } ^ { i } , r _ { h } ^ { i } \big ) \big \} _ { ( i , h ) \in [ n ] \times [ H ] }$ consists of the confounded observational data and the interventional data up to the $\left( k - 1 \right)$ -th episode. However, it is challenging to characterize the distribution of $\omega _ { h } ^ { k }$ . To this end, we consider a Bayesian counterpart of the confounded MDP, where the prior of $\omega _ { h } ^ { k }$ is $N ( 0 , I / \lambda )$ and the residual of the regression problem in (3.7) is $N ( 0 , 1 )$ . In such a “parallel” confounded MDP, the posterior of $\omega _ { h } ^ { k }$ follows $N ( \mu _ { k , h } , ( \Lambda _ { h } ^ { k } ) ^ { - 1 } )$ , where $\Lambda _ { h } ^ { k }$ is defined in (3.10) and $\mu _ { k , h }$ coincides with the right-hand side of (3.9). Moreover, it holds for all $( s _ { h } ^ { k } , a _ { h } ^ { k } ) \in \mathcal { S } \times \mathcal { A }$ that
+
+$$
+\begin{array} { r l } & { H ( \omega _ { h } ^ { k } \mid \xi _ { k - 1 } ) = 1 / 2 \cdot \log \operatorname* { d e t } \bigl ( ( 2 \pi e ) ^ { d } \cdot ( \Lambda _ { h } ^ { k } ) ^ { - 1 } \bigr ) , } \\ & { H \bigl ( \omega _ { h } ^ { k } \mid \xi _ { k - 1 } \cup \{ ( s _ { h } ^ { k } , a _ { h } ^ { k } ) \} \bigr ) = 1 / 2 \cdot \log \operatorname* { d e t } \Bigl ( ( 2 \pi e ) ^ { d } \cdot \bigl ( \Lambda _ { h } ^ { k } + \psi _ { h } ( s _ { h } ^ { k } , a _ { h } ^ { k } ) \psi _ { h } ( s _ { h } ^ { k } , a _ { h } ^ { k } ) ^ { \top } \bigr ) ^ { - 1 } \Bigr ) . } \end{array}
+$$
+
+Correspondingly, we employ the following UCB, which instantiates (3.11), that is,
+
+$$
+\Gamma _ { h } ^ { k } ( s _ { h } ^ { k } , a _ { h } ^ { k } ) = \beta \cdot \Big ( \log \operatorname* { d e t } \big ( \Lambda _ { h } ^ { k } + \psi _ { h } ( s _ { h } ^ { k } , a _ { h } ^ { k } ) \psi _ { h } ( s _ { h } ^ { k } , a _ { h } ^ { k } ) ^ { \top } \big ) - \log \operatorname* { d e t } ( \Lambda _ { h } ^ { k } ) \Big ) ^ { 1 / 2 }
+$$
+
+for all $( s _ { h } ^ { k } , a _ { h } ^ { k } ) \ \in \ S \times { \mathcal { A } }$ . Here $\beta > 0$ is a tuning parameter. We highlight that, although the information gain in (3.11) relies on the “parallel” confounded MDP, the UCB in (3.12), which is used in Line 5 of Algorithm 1, does not rely on the Bayesian perspective. Also, our analysis establishes the frequentist regret.
+
+Regularization with Observational Data: A Bayesian Perspective. In the “parallel” confounded MDP, it holds that
+
+$$
+\omega _ { h } ^ { k } \sim N ( 0 , I / \lambda ) , \quad \omega _ { h } ^ { k } \mid \xi _ { 0 } \sim N \big ( \mu _ { 1 , h } , ( \Lambda _ { h } ^ { 1 } ) ^ { - 1 } \big ) , \quad \omega _ { h } ^ { k } \mid \xi _ { k - 1 } \sim N \big ( \mu _ { k , h } , ( \Lambda _ { h } ^ { k } ) ^ { - 1 } \big ) ,
+$$
+
+where $\mu _ { k , h }$ coincides with the right-hand side of (3.9) and $\mu _ { 1 , h }$ is defined by setting $k = 1$ in $\mu _ { k , h }$ . Here $\xi _ { 0 } = \{ \big ( s _ { h } ^ { i } , a _ { h } ^ { i } , u _ { h } ^ { i } , r _ { h } ^ { i } \big ) \} _ { ( i , h ) \in [ n ] \times [ H ] }$ are the confounded observational data. Hence, the regularizer $L _ { h } ^ { k }$ in (3.8) corresponds to using $\omega _ { h } ^ { k } \mid \xi _ { 0 }$ as the prior for the Bayesian regression problem given only the interventional data $\xi _ { k - 1 } \setminus \xi _ { 0 } = \{ ( s _ { h } ^ { \tau } , a _ { h } ^ { \tau } , r _ { h } ^ { \tau } ) \} _ { ( \tau , h ) \in [ k - 1 ] \times [ H ] } .$ .
+
+# 3.2 Theory
+
+The following theorem characterizes the regret of DOVI, which is defined in (2.3).
+
+Theorem 3.5 (Regret of DOVI). Let $\beta = C d H \sqrt { \log ( d ( T + n H ) / \zeta ) }$ and $\lambda = 1$ , where $C > 0$ and $\zeta \in ( 0 , 1 ]$ are absolute constants. Under Assumptions 3.1 and 3.3, it holds with probability at least $1 - 5 \zeta / 2$ that
+
+$$
+\mathrm { R e g r e t } ( T ) \le C ^ { \prime } \cdot \Delta _ { H } \cdot \sqrt { d ^ { 3 } H ^ { 3 } T } \cdot \sqrt { \log \left( d ( T + n H ) / \zeta \right) } ,
+$$
+
+where $C ^ { \prime } > 0$ is an absolute constant and
+
+$$
+\Delta _ { H } = { \frac { 1 } { \sqrt { d H ^ { 2 } } } } \sum _ { h = 1 } ^ { H } \bigl ( \log \operatorname* { d e t } ( \Lambda _ { h } ^ { K + 1 } ) - \log \operatorname* { d e t } ( \Lambda _ { h } ^ { 1 } ) \bigr ) ^ { 1 / 2 } .
+$$
+
+Proof. See $\mathrm { \ S F } . 3$ for a detailed proof.
+
+Note that $\Lambda _ { h } ^ { K + 1 } \preceq ( n + K + \lambda ) I$ and $\Lambda _ { h } ^ { 1 } \succeq \lambda I$ for all $h \in [ H ]$ . Hence, it holds that √ $\Delta _ { H } =$ $\mathcal { O } ( \sqrt { \log ( n + K + 1 ) } )$ in the worst case. Thus, the regret of DOVI is $\mathcal { O } ( \sqrt { d ^ { 3 } H ^ { 3 } T } )$ up to logarithmic factors, which is optimal in the total number of steps $T$ if we only consider the online setting. However, $\Delta _ { H }$ is possibly much smaller than $\mathcal { O } ( \sqrt { \log ( n + K + 1 ) } )$ , depending on the amount of information carried over by the confounded observational data from the offline setting, which is quantified in the following.
+
+Interpretation of $\Delta _ { H }$ : An Information-Theoretic Perspective. Let $\omega _ { h } ^ { * }$ be the parameter of the globally optimal action-value function $Q _ { h } ^ { * }$ , which corresponds to $\pi ^ { * }$ in (2.3). Recall that we denote by $\xi _ { 0 }$ and $\xi _ { K }$ the confounded observational data $\{ ( s _ { h } ^ { i } , a _ { h } ^ { i } , u _ { h } ^ { i } , r _ { h } ^ { i } ) \} _ { ( i , h ) \in [ n ] \times [ H ] }$ and the union $\{ \big ( s _ { h } ^ { i } , a _ { h } ^ { i } , u _ { h } ^ { i } , r _ { h } ^ { i } \big ) \} _ { ( i , h ) \in [ n ] \times [ H ] } \cup \{ \big ( s _ { h } ^ { k } , \underline { { a } } _ { h } ^ { k } , r _ { h } ^ { k } \big ) \} _ { ( k , h ) \in [ K ] \times [ H ] }$ of the confounded observational data and the interventional data up to the $K$ -th episode, respectively. We consider the aforementioned Bayesian counterpart of the confounded MDP, where the prior of $\omega _ { h } ^ { * }$ is also $N ( 0 , I / \lambda )$ . In such a “parallel” confounded MDP, we have
+
+$$
+\omega _ { h } ^ { * } \sim N ( 0 , I / \lambda ) , \quad \omega _ { h } ^ { * } \mid \xi _ { 0 } \sim N \big ( \mu _ { 1 , h } ^ { * } , ( \Lambda _ { h } ^ { 1 } ) ^ { - 1 } \big ) , \quad \omega _ { h } ^ { * } \mid \xi _ { K } \sim N \big ( \mu _ { K , h } ^ { * } , ( \Lambda _ { h } ^ { K + 1 } ) ^ { - 1 } \big ) ,
+$$
+
+where
+
+$$
+\begin{array} { r l } & { \mu _ { 1 , h } ^ { * } = ( \Lambda _ { h } ^ { 1 } ) ^ { - 1 } \displaystyle \sum _ { i = 1 } ^ { n } \phi _ { h } ( s _ { h } ^ { i } , a _ { h } ^ { i } , u _ { h } ^ { i } ) \cdot \left( V _ { h + 1 } ^ { * } ( s _ { h + 1 } ^ { i } ) + r _ { h } ^ { i } \right) , } \\ & { \mu _ { K , h } ^ { * } = ( \Lambda _ { h } ^ { K + 1 } ) ^ { - 1 } \bigg ( \Lambda _ { h } ^ { 1 } \mu _ { 1 , h } ^ { * } + \displaystyle \sum _ { \tau = 1 } ^ { K } \psi _ { h } ( s _ { h } ^ { \tau } , a _ { h } ^ { \tau } ) \cdot \left( V _ { h + 1 } ^ { * } ( s _ { h + 1 } ^ { \tau } ) + r _ { h } ^ { \tau } \right) \bigg ) . } \end{array}
+$$
+
+It then holds for the right-hand side of (3.14) that
+
+$$
+1 / 2 \cdot \log \operatorname* { d e t } ( \Lambda _ { h } ^ { K + 1 } ) - 1 / 2 \cdot \log \operatorname* { d e t } ( \Lambda _ { h } ^ { 1 } ) = H ( \omega _ { h } ^ { * } \mid \xi _ { 0 } ) - H ( \omega _ { h } ^ { * } \mid \xi _ { K } ) .
+$$
+
+The left-hand side of (3.16) characterizes the information gain of intervention in the online setting given the confounded observational data in the offline setting. In other words, if the confounded observational data are sufficiently informative upon the backdoor adjustment, then $\Delta _ { H }$ is small, which implies that the regret is small. More specifically, the matrices $( \Lambda _ { h } ^ { 1 } ) ^ { - 1 }$ and $( \Lambda _ { h } ^ { K + 1 } ) ^ { - 1 }$ defined in (3.10) characterize the ellipsoidal confidence sets given $\xi _ { 0 }$ and $\xi _ { K }$ , respectively. If the confounded observational data are sufficiently informative upon the backdoor adjustment, $\Lambda _ { h } ^ { K + 1 }$ is close to $\Lambda _ { h } ^ { 1 }$ . To illustrate, let $\{ \psi _ { h } \big ( s _ { h } ^ { \tau } , a _ { h } ^ { \tau } \big ) \} _ { ( \tau , h ) \in [ K ] \times [ H ] }$ and $\{ \phi _ { h } \big ( s _ { h } ^ { i } , a _ { h } ^ { i } , u _ { h } ^ { i } \big ) \} _ { ( i , h ) \in [ n ] \times [ H ] }$ be sampled uniformly at random from the canonical basis $\{ e _ { \ell } \} _ { \ell \in [ d ] }$ of $\mathbb { R } ^ { d }$ . It then holds that $\Lambda _ { h } ^ { K + 1 } \approx ( K + n ) I / d + \lambda I$ and $\Lambda _ { h } ^ { 1 } \approx n I / d + \lambda I$ . Hence, for $\lambda = 1$ and sufficiently large $n$ and $K$ , we have $\Delta _ { H } = \mathcal { O } ( \sqrt { \log ( 1 + K / ( n + d ) ) } ) = \mathcal { O } ( \sqrt { K / ( n + d ) } )$ . For example, for $n = \Omega ( K ^ { 2 } )$ , it holds that $\Delta _ { H } = \mathcal { O } ( n ^ { - 1 / 2 } )$ , which implies that the regret of DOVI is $\mathcal { O } ( n ^ { - 1 / 2 } \cdot \sqrt { d ^ { 3 } H ^ { 3 } T } )$ . In other words, if the confounded observational data are sufficiently informative upon the backdoor adjustment, the regret of DOVI can be arbitrarily small given a sufficiently large sample size $n$ of the confounded observational data, which is often the case in practice [8, 9, 21, 22, 29].
+
+# 4 Conclusion
+
+In this paper, we propose the deconfounded optimistic value iteration (DOVI) algorithm and its variant $\bar { \mathrm { D O V I } } ^ { + }$ , which incorporate the confounded observational data to the online reinforcement learning in a provably efficient manner. DOVI and $\mathrm { D O V I ^ { + } }$ explicitly adjust for the confounding bias in the observational data via the backdoor and frontdoor adjustments, respectively. In both cases, such adjustments allow us to construct the bonus based on a notion of information gain, which considers the amount of information acquired from the offline dataset. We further conduct regret analysis of DOVI and $\mathrm { D O V I ^ { + } }$ . Our analysis suggests that practitioners can tackle the confounding issue in the offline dataset by estimating the counterfactual reward for value function estimations, given that a proper adjustment such as the backdoor or frontdoor adjustment is available. In the case of backdoor and frontdoor adjustment, we prove that the regret of DOVI is smaller than the optimal regret achievable in the pure online setting when the confounded observational data are informative upon the adjustments, suggesting that one can exploit the confounded observational data in reinforcement learning upon proper adjustments. In our future study, we wish to incorporate proxy variables that are native to MDPs for the adjustments of the offline dataset, such as the variables exploited by [4, 24, 40].
+
+# Acknolodgements
+
+Zhaoran Wang acknowledges National Science Foundation (Awards 2048075, 2008827, 2015568, 1934931), Simons Institute (Theory of Reinforcement Learning), Amazon, J.P. Morgan, and Two Sigma for their supports. Zhuoran Yang acknowledges Simons Institute (Theory of Reinforcement Learning). The authors also thank the anonymous reviewers, whose invaluable suggestions help the authors to improve the paper.
+
+# References
+
+[1] Abbasi-Yadkori, Y., Pal, D. and Szepesv ´ ari, C. (2011). Improved algorithms for linear stochas- ´ tic bandits. In Advances in Neural Information Processing Systems.   
+[2] Azar, M. G., Osband, I. and Munos, R. (2017). Minimax regret bounds for reinforcement learning. In International Conference on Machine Learning.   
+[3] Balke, A. and Pearl, J. (2013). Counterfactuals and policy analysis in structural models. arXiv preprint arXiv:1302.4929.   
+[4] Bennett, A., Kallus, N., Li, L. and Mousavi, A. (2021). Off-policy evaluation in infinitehorizon reinforcement learning with latent confounders. In International Conference on Artificial Intelligence and Statistics.   
+[5] Bradtke, S. J. and Barto, A. G. (1996). Linear least-squares algorithms for temporal difference learning. Machine Learning, 22 33–57.   
+[6] Buesing, L., Weber, T., Zwols, Y., Racaniere, S., Guez, A., Lespiau, J.-B. and Heess, N. (2018). Woulda, coulda, shoulda: Counterfactually-guided policy search. arXiv preprint arXiv:1811.06272.   
+[7] Cai, Q., Yang, Z., Jin, C. and Wang, Z. (2019). Provably efficient exploration in policy optimization. arXiv preprint arXiv:1912.05830.   
+[8] Chakraborty, B. and Murphy, S. A. (2014). Dynamic treatment regimes. Annual Review of Statistics and Its Application, 1 447–464.   
+[9] de Haan, P., Jayaraman, D. and Levine, S. (2019). Causal confusion in imitation learning. In Advances in Neural Information Processing Systems.   
+[10] D´ıaz, I. and Hejazi, N. (2019). Causal mediation analysis for stochastic interventions. arXiv preprint arXiv:1901.02776.   
+[11] Forney, A., Pearl, J. and Bareinboim, E. (2017). Counterfactual data-fusion for online reinforcement learners. In International Conference on Machine Learning.   
+[12] Hallak, A., Di Castro, D. and Mannor, S. (2015). Contextual Markov decision processes. arXiv preprint arXiv:1502.02259.   
+[13] Hessel, M., Modayil, J., Van Hasselt, H., Schaul, T., Ostrovski, G., Dabney, W., Horgan, D., Piot, B., Azar, M. and Silver, D. (2018). Rainbow: Combining improvements in deep reinforcement learning. In AAAI Conference on Artificial Intelligence.   
+[14] Jaksch, T., Ortner, R. and Auer, P. (2010). Near-optimal regret bounds for reinforcement learning. Journal of Machine Learning Research, 11 1563–1600.   
+[15] Jin, C., Allen-Zhu, Z., Bubeck, S. and Jordan, M. I. (2018). Is Q-learning provably efficient? In Advances in Neural Information Processing Systems.   
+[16] Jin, C., Yang, Z., Wang, Z. and Jordan, M. I. (2019). Provably efficient reinforcement learning with linear function approximation. arXiv preprint arXiv:1907.05388.   
+[17] Kallus, N. and Zhou, A. (2018). Confounding-robust policy improvement. In Advances in Neural Information Processing Systems.   
+[18] Kallus, N. and Zhou, A. (2018). Policy evaluation and optimization with continuous treatments. arXiv preprint arXiv:1802.06037.   
+[19] Kober, J., Bagnell, J. A. and Peters, J. (2013). Reinforcement learning in robotics: Asurvey. International Journal of Robotics Research, 32 1238–1274.   
+[20] Lattimore, F., Lattimore, T. and Reid, M. D. (2016). Causal bandits: Learning good interventions via causal inference. In Advances in Neural Information Processing Systems.   
+[21] Levine, S., Kumar, A., Tucker, G. and Fu, J. (2020). Offline reinforcement learning: Tutorial, review, and perspectives on open problems. arXiv preprint arXiv:2005.01643.   
+[22] Li, C., Chan, S. H. and Chen, Y.-T. (2020). Who make drivers stop? Towards drivercentric risk assessment: Risk object identification via causal inference. arXiv preprint arXiv:2003.02425.   
+[23] Li, J., Monroe, W., Ritter, A., Galley, M., Gao, J. and Jurafsky, D. (2016). Deep reinforcement learning for dialogue generation. arXiv preprint arXiv:1606.01541.   
+[24] Liao, L., Fu, Z., Yang, Z., Kolar, M. and Wang, Z. (2021). Instrumental variable value iteration for causal offline reinforcement learning. arXiv preprint arXiv:2102.09907.   
+[25] Lu, C., Scholkopf, B. and Hern ¨ andez-Lobato, J. M. (2018). Deconfounding reinforcement ´ learning in observational settings. arXiv preprint arXiv:1812.10576.   
+[26] Lu, Y., Meisami, A., Tewari, A. and Yan, Z. (2019). Regret analysis of causal bandit problems. arXiv preprint arXiv:1910.04938.   
+[27] Manski, C. F. (1990). Nonparametric bounds on treatment effects. American Economic Review, 80 319–323.   
+[28] Munoz, I. D. and van der Laan, M. (2012). Population intervention causal effects based on ˜ stochastic interventions. Biometrics, 68 541–549.   
+[29] Murphy, S. A. (2003). Optimal dynamic treatment regimes. Journal of the Royal Statistical Society: Series B (Statistical Methodology), 65 331–355.   
+[30] Namkoong, H., Keramati, R., Yadlowsky, S. and Brunskill, E. (2020). Off-policy policy evaluation for sequential decisions under unobserved confounding. arXiv preprint arXiv:2003.05623.   
+[31] Osband, I., Van Roy, B. and Wen, Z. (2014). Generalization and exploration via randomized value functions. arXiv preprint arXiv:1402.0635.   
+[32] Pearl, J. (2009). Causality. Cambridge university press.   
+[33] Peters, J., Janzing, D. and Scholkopf, B. (2017). ¨ Elements of Causal Inference: Foundations and Learning Algorithms. MIT press.   
+[34] Sen, R., Shanmugam, K., Dimakis, A. G. and Shakkottai, S. (2017). Identifying best interventions through online importance sampling. In International Conference on Machine Learning.   
+[35] Shang, W., Yu, Y., Li, Q., Qin, Z., Meng, Y. and Ye, J. (2019). Environment reconstruction with hidden confounders for reinforcement learning based recommendation. In Proceedings of the 25th ACM SIGKDD International Conference on Knowledge Discovery & Data Mining.   
+[36] Silver, D., Huang, A., Maddison, C. J., Guez, A., Sifre, L., Van Den Driessche, G., Schrittwieser, J., Antonoglou, I., Panneershelvam, V., Lanctot, M. et al. (2016). Mastering the game of Go with deep neural networks and tree search. Nature, 529 484.   
+[37] Silver, D., Schrittwieser, J., Simonyan, K., Antonoglou, I., Huang, A., Guez, A., Hubert, T., Baker, L., Lai, M., Bolton, A. et al. (2017). Mastering the game of Go without human knowledge. Nature, 550 354.   
+[38] Tan, Z. (2006). A distributional approach for causal inference using propensity scores. Journal of the American Statistical Association, 101 1619–1637.   
+[39] Tennenholtz, G., Mannor, S. and Shalit, U. (2019). Off-policy evaluation in partially observable environments. arXiv preprint arXiv:1909.03739.   
+[40] Tennenholtz, G., Shalit, U. and Mannor, S. (2020). Off-policy evaluation in partially observable environments. In Proceedings of the AAAI Conference on Artificial Intelligence, vol. 34.   
+[41] Vershynin, R. (2010). Introduction to the non-asymptotic analysis of random matrices. arXiv preprint arXiv:1011.3027.   
+[42] Yang, L. and Wang, M. (2019). Sample-optimal parametric Q-learning using linearly additive features. In International Conference on Machine Learning.   
+[43] Yang, L. F. and Wang, M. (2019). Reinforcement leaning in feature space: Matrix bandit, kernels, and regret bound. arXiv preprint arXiv:1905.10389.   
+[44] Zhang, J. and Bareinboim, E. (2017). Transfer learning in multi-armed bandit: A causal approach. In Autonomous Agents and Multi-Agent Systems.   
+[45] Zhang, J. and Bareinboim, E. (2019). Near-optimal reinforcement learning in dynamic treatment regimes. In Advances in Neural Information Processing Systems.

parse/train/tUeeRzMXJZ/tUeeRzMXJZ_content_list.json

@@ -0,0 +1,1367 @@
+[
+    {
+        "type": "text",
+        "text": "Provably Efficient Causal Reinforcement Learning with Confounded Observational Data ",
+        "text_level": 1,
+        "bbox": [
+            192,
+            122,
+            808,
+            172
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Lingxiao Wang Northwestern University lwang@u.northwestern.edu ",
+        "bbox": [
+            199,
+            222,
+            406,
+            263
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Zhuoran Yang Princeton University zy6@princeton.edu ",
+        "bbox": [
+            441,
+            222,
+            584,
+            263
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Zhaoran Wang Northwestern University zhaoranwang@gmail.com ",
+        "bbox": [
+            617,
+            222,
+            799,
+            263
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Abstract ",
+        "text_level": 1,
+        "bbox": [
+            462,
+            299,
+            535,
+            315
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Empowered by neural networks, deep reinforcement learning (DRL) achieves tremendous empirical success. However, DRL requires a large dataset by interacting with the environment, which is unrealistic in critical scenarios such as autonomous driving and personalized medicine. In this paper, we study how to incorporate the dataset collected in the offline setting to improve the sample efficiency in the online setting. To incorporate the observational data, we face two challenges. (a) The behavior policy that generates the observational data may depend on unobserved random variables (confounders), which affect the received rewards and transition dynamics. (b) Exploration in the online setting requires quantifying the uncertainty given both the observational and interventional data. To tackle such challenges, we propose the deconfounded optimistic value iteration (DOVI) algorithm, which incorporates the confounded observational data in a provably efficient manner. DOVI explicitly adjusts for the confounding bias in the observational data, where the confounders are partially observed or unobserved. In both cases, such adjustments allow us to construct the bonus based on a notion of information gain, which takes into account the amount of information acquired from the offline setting. In particular, we prove that the regret of DOVI is smaller than the optimal regret achievable in the pure online setting when the confounded observational data are informative upon the adjustments. ",
+        "bbox": [
+            233,
+            335,
+            764,
+            597
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 Introduction ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            632,
+            310,
+            650
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Empowered by the breakthrough in neural networks, deep reinforcement learning (DRL) achieves significant empirical successes in various scenarios [19, 23, 36, 37]. Learning an expressive function approximator necessitates collecting a large dataset. Specifically, in the online setting, it requires the agent to interact with the environment for a large number of steps. For example, to learn a human-level policy for playing Atari games, the agent has to interact with a simulator for more than $1 0 ^ { 8 }$ steps [13]. However, in most scenarios, we do not have access to a simulator that allows for trial and error without any cost. Meanwhile, in critical scenarios, e.g., autonomous driving and personalized medicine, trial and error in the real world is unsafe and even unethical. As a result, it remains challenging to apply DRL to more scenarios. ",
+        "bbox": [
+            174,
+            667,
+            825,
+            791
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "To bypass such a barrier, we study how to incorporate the dataset collected offline, namely the observational data, to improve the sample efficiency of RL in the online setting [21]. In contrast to the interventional data collected online in possibly expensive ways, observational data are often abundantly available in various scenarios. For example, in autonomous driving, we have access to trajectories generated by the drivers. As another example, in personalized medicine, we have access to electronic health records from doctors. However, to incorporate the observational data in a provably efficient way, we have to address two challenges. ",
+        "bbox": [
+            174,
+            799,
+            825,
+            896
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "• The observational data are possibly confounded. Specifically, there often exist unobserved random variables, namely confounders, that causally affect the agent and the environment at the same time. In particular, the policy used to generate the observational data, namely the behavior policy, possibly depends on the confounders. Meanwhile, the confounders possibly affect the received rewards and the transition dynamics. ",
+        "bbox": [
+            176,
+            92,
+            825,
+            160
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "In the example of autonomous driving [9, 22], the drivers may be affected by complicated traffic or poor road design, resulting in traffic accidents even without misconduct. The complicated traffic and poor road design subsequently affect both the action of the drivers and the outcome. Therefore, it is unclear from the observational data whether the accidents are due to the actions adopted by the drivers. Agents trained with such observational data may be unwilling to take any actions under complicated traffic, jeopardizing the safety of passengers. ",
+        "bbox": [
+            189,
+            162,
+            825,
+            246
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "In the example of personalized medicine [8, 29], the patients may not be compliant with prescriptions and instructions, which subsequently affects both the treatment and the outcome. As another example, the doctor may prescribe medicine to patients based on patients’ socioeconomic status (which could be inferred by the doctor through interacting with the patients). Meanwhile, socioeconomic status affects the patients’ health condition and subsequently plays the role of the confounder. In both scenarios, such confounders may be unavailable due to privacy or ethical concerns. Such a confounding issue makes the observational data uninformative and even misleading for identifying and estimating the causal effect, which is crucial for decision-making in the online setting. In all the examples, it is unclear from the observational data whether the outcome is due to the actions adopted. ",
+        "bbox": [
+            191,
+            248,
+            823,
+            386
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "• Even without the confounding issue, it remains unclear how the observational data may facilitate exploration in the online setting, which is the key to the sample efficiency of RL. At the core of exploration is uncertainty quantification. Specifically, quantifying the uncertainty that remains given the dataset collected up to the current step, including the observational data and the interventional data, allows us to construct a bonus. When incorporated into the reward, such a bonus encourages the agent to explore the less visited state-action pairs with more uncertainty. In particular, constructing such a bonus requires quantifying the amount of information carried over by the observational data from the offline setting, which also plays a key role in characterizing the regret, especially how much the observational data may facilitate reducing the regret. ",
+        "bbox": [
+            174,
+            391,
+            825,
+            515
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Uncertainty quantification becomes even more challenging when the observational data are confounded. Specifically, as the behavior policy depends on the confounders, there is a mismatch between the data generating processes in the offline setting and the online setting. As a result, it remains challenging to quantify how much information carried over from the offline setting is useful for the online setting, as the observational data are uninformative and even misleading due to the confounding issue. ",
+        "bbox": [
+            187,
+            518,
+            825,
+            601
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Contribution. To study causal reinforcement learning, we propose a class of Markov decision processes (MDPs), namely confounded MDPs, which captures the data generating processes in both the offline setting and the online setting as well as their mismatch due to the confounding issue. In particular, we study two tractable cases of confounded MDPs in the episodic setting with linear function approximation [7, 16, 42, 43]. ",
+        "bbox": [
+            174,
+            619,
+            825,
+            689
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "• In the first case, the confounders are partially observed in the observational data. Assuming that an observed subset of the confounders satisfies the backdoor criterion [32], we propose the deconfounded optimistic value iteration (DOVI) algorithm, which explicitly corrects for the confounding bias in the observational data using the backdoor adjustment. • In the second case, the confounders are unobserved in the observational data. Assuming that there exists an observed set of intermediate states that satisfies the frontdoor criterion [32], we propose an extension of DOVI, namely $\\mathrm { D O V I ^ { + } }$ , which explicitly corrects for the confounding bias in the observational data using the composition of two backdoor adjustments. We remark that $\\mathrm { D O V I ^ { + } }$ follows the same principle of design as DOVI and defer the discussion of $\\mathrm { D O V I ^ { + } }$ to $\\ S$ . ",
+        "bbox": [
+            173,
+            699,
+            825,
+            830
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "In both cases, the adjustments allow DOVI and $\\mathrm { D O V I ^ { + } }$ to incorporate the observational data into the interventional data while bypassing the confounding issue. It further enables estimating the causal effect of a policy on the received rewards and the transition dynamics with enlarged effective sample size. Moreover, such adjustments allow us to construct the bonus based on a notion of information gain, which takes into account the amount of information carried over from the offline setting. ",
+        "bbox": [
+            174,
+            842,
+            823,
+            911
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "In particular, we prove that DOVI and $\\mathrm { D O V I ^ { + } }$ attain the $\\Delta _ { H } \\cdot \\sqrt { d ^ { 3 } H ^ { 3 } T }$ -regret up to logarithmic factors, where $d$ is the dimension of features, $H$ is the length of each episode, and $\\bar { T _ { \\mathbf { \\Lambda } } } = H K$ is the number of steps taken in the online setting, where $K$ is the number of episodes. Here the multiplicative factor $\\Delta _ { H } > 0$ depends on $d , H ,$ , and a notion of information gain that quantifies the amount of information obtained from the interventional data additionally when given the properly adjusted observational data. When the observational data are unavailable or uninformative upon the adjustments, √ $\\Delta _ { H }$ is a logarithmic factor. Correspondingly, DOVI and $\\mathrm { D O V I ^ { + } }$ attain the optimal $\\sqrt { T }$ -regret achievable in the pure online setting [7, 16, 42, 43]. When the observational data are sufficiently informative upon the adjustments, $\\Delta _ { H }$ decreases towards zero as the effective sample size of the observational data increases, which quantifies how much the observational data may facilitate exploration in the online setting. ",
+        "bbox": [
+            174,
+            89,
+            825,
+            246
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Related Work. Our work is related to the study of causal bandit [20]. The goal of causal bandit is to obtain the optimal intervention in the online setting where the data generating process is described by a causal diagram. The previous study establishes causal bandit algorithms in the online setting [26, 34], the offline setting [17, 18], and a combination of both settings [11]. In contrast to this line of work, we study causal RL in a combination of the online setting and the offline setting. Causal RL is more challenging than causal bandit, which corresponds to $H = 1$ , as it involves the transition dynamics and is more challenging in exploration. See $\\ S _ { \\mathrm { B } }$ for a detailed literature review on causal bandit. ",
+        "bbox": [
+            173,
+            256,
+            825,
+            367
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Our work is related to the study of causal RL considered in various settings. [45] propose a modelbased RL algorithm that solves dynamic treatment regimes (DTR), which involve a combination of the online setting and the offline setting. Their algorithm hinges on the analysis of sensitivity [3, 27, 38, 44], which constructs a set of feasible models of the transition dynamics based on the confounded observational data. Correspondingly, their algorithm achieves exploration by choosing an optimistic model of the transition dynamics from such a feasible set. In contrast, we propose a model-free RL algorithm, which achieves exploration through the bonus based on a notion of information gain. It is worth mentioning that the assumption of [45] is weaker than ours as theirs does not allow for identifying the causal effect. As a result of partial identification, the regret of their algorithm is the same as the regret in the pure online setting as $T \\to + \\infty$ . In contrast, our work instantiates the following framework in handling confounders for reinforcement learning. (a) First, we propose the estimation equation based on the observations, which identifies the causal effect of actions on the cumulative reward. (b) Second, we conduct point estimation and uncertainty quantification based on observations and the estimation equation. (c) Finally, we conduct exploration based on the uncertainty quantification and achieve the regret reduction in the online setting. Consequently, the regret of our algorithm is smaller than the regret in the pure online setting by a multiplicative factor for all $T$ . [25] propose a model-based RL algorithm in a combination of the online setting and the offline setting. Their algorithm uses a variational autoencoder (VAE) for estimating a structural causal model (SCM) based on the confounded observational data. In particular, their algorithm utilizes the actor-critic algorithm to obtain the optimal policy in such an SCM. However, the regret of their algorithm remains unclear. [6] propose a model-based RL algorithm in the pure online setting that learns the optimal policy in a partially observable Markov decision process (POMDP). The regret of their algorithm also remains unclear. [35] utilize generative adversarial reinforcement learning to reconstruct transition dynamics with confounder, and [40] propose a model-based approach for POMDP based on adjustment with proxy variables. [30] consider offpolicy policy evaluation under one-decision confounding and constructs worst-case bounds with theoretical guarantee. [4] utilizes states and actions as proxy variables to tackle off-policy policy evaluation with confounders. In contrast, our work utilizes backdoor and frontdoor adjustments to handle confounded observation. ",
+        "bbox": [
+            173,
+            375,
+            825,
+            772
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "2 Confounded Reinforcement Learning ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            792,
+            517,
+            810
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Structural Causal Model. We denote a structural causal model (SCM) [32] by a tuple $( A , B , F , P )$ . Here $A$ is the set of exogenous (unobserved) variables, $B$ is the set of endogenous (observed) variables, $F$ is the set of structural functions capturing the causal relations, which determines an endogenous variable $v \\in B$ based on the other exogenous and endogenous variables, and $P$ is the distribution of all the exogenous variables. We say that a pair of variables $Y$ and $Z$ are confounded by a variable $W$ if they are both caused by $W$ . ",
+        "bbox": [
+            174,
+            827,
+            823,
+            911
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "An intervention on a set of endogenous variables $X \\subseteq B$ assigns a value $x$ to $X$ regardless of the other exogenous and endogenous variables as well as the structural functions. We denote by $\\operatorname { d o } ( X \\ = \\ x )$ the intervention on $X$ and write $\\operatorname { d o } ( x )$ if it is clear from the context. Similarly, a stochastic intervention [10, 28] on a set of endogenous variables $X \\subseteq B$ assigns a distribution $p$ to $X$ regardless of the other exogenous and endogenous variables as well as the structural functions. We denote by $\\mathrm { d o } ( X \\sim p )$ the stochastic intervention on $X$ . ",
+        "bbox": [
+            173,
+            90,
+            825,
+            175
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Confounded Markov Decision Process. To characterize a Markov decision process (MDP) in the offline setting with observational data, which are possibly confounded, we introduce an SCM, where the endogenous variables are the states $\\{ s _ { h } \\} _ { h \\in [ H ] }$ , actions $\\{ a _ { h } \\} _ { h \\in [ H ] }$ , and rewards $\\{ r _ { h } \\} _ { h \\in [ H ] }$ . Let $\\{ w _ { h } \\} _ { h \\in [ H ] }$ be the confounders. In $\\ S 3$ , we assume that the confounders are partially observed, while in $\\ S$ , we assume that they are unobserved. The set of structural functions $F$ consists of the transition of states $s _ { h + 1 } \\sim \\mathcal { P } _ { h } ( \\cdot \\mid s _ { h } , a _ { h } , w _ { h } )$ , the transition of confounders $w _ { h } \\sim \\widetilde { \\mathcal { P } } _ { h } ( \\cdot \\vert s _ { h } )$ , the behavior policy $a _ { h } \\sim \\nu _ { h } ( \\cdot \\mid s _ { h } , w _ { h } )$ , which depends on the confounder $w _ { h }$ , and the reward function $r _ { h } ( s _ { h } , a _ { h } , w _ { h } )$ . See Figure 1 for the causal diagram that describes such an SCM. ",
+        "bbox": [
+            173,
+            185,
+            825,
+            301
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "image",
+        "img_path": "images/fc242512d131e0246c4a3f1a2122f7150bde2eca97f93e0ff5f87914970bb452.jpg",
+        "image_caption": [
+            "Figure 1: Causal diagrams of the $h$ -th step of the confounded MDP (a) in the offline setting and (b) in the online setting, respectively. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            200,
+            314,
+            803,
+            428
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Here $a _ { h }$ and $s _ { h + 1 }$ are confounded by $w _ { h }$ in addition to $s _ { h }$ . We denote such a confounded MDP by the tuple $( S , \\mathcal { A } , \\mathcal { W } , H , \\overline { { \\mathcal { P } } } , r )$ , where $H$ is the length of an episode, $s , A$ , and $\\mathcal { W }$ are the spaces of states, actions, and confounders, respectively, $\\bar { r \\ = \\ \\{ r _ { h } \\} _ { h \\in \\{ H \\} } }$ is the set of reward functions, and $\\overline { { \\mathcal { P } } } = \\{ \\mathcal { P } _ { h } , \\widetilde { \\mathcal { P } } _ { h } \\} _ { h \\in H }$ is the set of transition kernels. In the sequel, we assume without loss of generality that $r _ { h }$ takes value in $[ 0 , 1 ]$ for all $h \\in [ H ]$ . ",
+        "bbox": [
+            173,
+            484,
+            825,
+            561
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "In the online setting that allows for intervention, we assume that the confounders $\\{ w _ { h } \\} _ { h \\in [ H ] }$ are unobserved. A policy $\\pi = \\{ \\pi _ { h } \\} _ { h \\in [ H ] }$ induces the stochastic intervention $\\mathrm { d o } ( a _ { 1 } \\sim$ $\\pi _ { 1 } ( \\cdot \\cdot \\vert s _ { 1 } ) , \\ldots , a _ { H } \\sim \\pi _ { H } ( \\cdot \\vert s _ { H } ) )$ , which does not depend on the confounders. In particular, an agent interacts with the environment as follows. At the beginning of the $k$ -th episode, the environment arbitrarily selects an initial state $s _ { 1 } ^ { k }$ and the agent selects a policy $\\pi ^ { k } = \\mathbf { \\bar { \\{ } }  { \\pi _ { h } ^ { k } } \\} _ { h \\in [ H ] }$ . At the $h$ -th step of the $k$ -th episode, the agent observes the state $s _ { h } ^ { k }$ and takes the action $a _ { h } ^ { k } \\sim \\bar { \\pi } _ { h } ^ { k } ( \\cdot | s _ { h } ^ { k } )$ . The environment randomly selects the confounder $w _ { h } ^ { k } \\sim \\widetilde { \\mathcal { P } } _ { h } ( \\cdot \\vert s _ { h } ^ { k } )$ , which is unobserved, and the agent receives the reward $s _ { h + 1 } ^ { k } \\sim \\mathcal { P } _ { h } ( \\cdot \\mid s _ { h } ^ { k } , a _ { h } ^ { k } , w _ { h } ^ { k } )$ . ${ r _ { h } ^ { k } } = r _ { h } ( s _ { h } ^ { k } , a _ { h } ^ { k } , w _ { h } ^ { k } )$ . The environment then transits into the next state ",
+        "bbox": [
+            173,
+            566,
+            825,
+            707
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "For a policy $\\pi = \\{ \\pi _ { h } \\} _ { h \\in H }$ , which does not depend on the confounders $\\{ w _ { h } \\} _ { h \\in [ H ] }$ , we define the value function $V ^ { \\pi } = \\{ V _ { h } ^ { \\pi } \\} _ { h \\in [ H ] }$ as follows, ",
+        "bbox": [
+            173,
+            710,
+            825,
+            743
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/d246d52e6cd291b5d9112b4a63cc7980f6324f3d35cc2cc9e7d00a5121e878be.jpg",
+        "text": "$$\nV _ { h } ^ { \\pi } ( s ) = \\mathbb { E } _ { \\pi } \\bigg [ \\sum _ { j = h } ^ { H } r _ { j } ( s _ { j } , a _ { j } , w _ { j } ) \\biggm | s _ { h } = s \\bigg ] , \\quad \\forall h \\in [ H ] ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            313,
+            751,
+            683,
+            796
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "where we denote by $\\mathbb { E } _ { \\pi }$ the expectation with respect to the confounders $\\{ w _ { j } \\} _ { j = h } ^ { H }$ and the trajectory $\\{ ( s _ { j } , a _ { j } ) \\} _ { j = h } ^ { H }$ , starting from the state $s _ { j } = s$ and following the policy $\\pi$ . Correspondingly, we define the action-value function $Q ^ { \\pi } = \\{ Q _ { h } ^ { \\pi } \\} _ { h \\in [ H ] }$ as follows, ",
+        "bbox": [
+            174,
+            805,
+            825,
+            856
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/b9aaf7bae6d9cc9f0c16f9eec91864874bb1c150456627caa2d7d753e6be4181.jpg",
+        "text": "$$\nQ _ { h } ^ { \\pi } ( s , a ) = \\mathbb { E } _ { \\pi } \\bigg [ \\sum _ { j = h } ^ { H } r _ { j } ( s _ { j } , a _ { j } , w _ { j } ) \\biggm | s _ { h } = s , \\mathrm { d o } ( a _ { h } = a ) \\bigg ] , \\quad \\forall h \\in [ H ] .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            264,
+            864,
+            735,
+            909
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "We assess the performance of an algorithm using the regret against the globally optimal policy $\\pi ^ { * } = \\{ \\pi _ { h } ^ { * } \\} _ { h \\in [ H ] }$ in hindsight after $K$ episodes, which is defined as follows, ",
+        "bbox": [
+            171,
+            90,
+            825,
+            119
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/00276619a26958d1d719dd9340160f5de593498236ee87d2b14a46630e799ca8.jpg",
+        "text": "$$\n\\mathrm { R e g r e t } ( T ) = \\operatorname* { m a x } _ { \\pi } \\sum _ { k = 1 } ^ { K } \\bigl ( V _ { 1 } ^ { \\pi } ( s _ { 1 } ^ { k } ) - V _ { 1 } ^ { \\pi ^ { k } } ( s _ { 1 } ^ { k } ) \\bigr ) = \\sum _ { k = 1 } ^ { K } \\bigl ( V _ { 1 } ^ { \\pi ^ { * } } ( s _ { 1 } ^ { k } ) - V _ { 1 } ^ { \\pi ^ { k } } ( s _ { 1 } ^ { k } ) \\bigr ) .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            251,
+            127,
+            745,
+            171
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Here $T = H K$ is the total number of steps. ",
+        "bbox": [
+            174,
+            176,
+            459,
+            190
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Our goal is to design an algorithm that minimizes the regret defined in (2.3), where $\\pi ^ { * }$ does not depend on the confounders $\\{ w _ { h } \\} _ { h \\in [ H ] }$ . In the online setting that allows for intervention, it is well understood how to minimize such a regret [2, 14–16]. However, it remains unclear how to efficiently utilize the observational data obtained in the offline setting, which are possibly confounded. In realworld applications, e.g., autonomous driving and personalized medicine, such observational data are often abundant, whereas intervention in the online setting is often restricted. We refer to $\\mathrm { \\ S C }$ for a comparison between the confounded MDP and other extensions of MDP, including the dynamics treatment regime (DTR), partially observable MDP (POMDP), and contextual MDP (CMDP). ",
+        "bbox": [
+            173,
+            196,
+            825,
+            308
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Why is Incorporating Confounded Observational Data Challenging? Straightforwardly incorporating the confounded observational data into an online algorithm possibly leads to an undesirable regret due to the mismatch between the online and offline data generating processes. In particular, due to the existence of the confounders $\\{ w _ { h } \\} _ { h \\in [ H ] }$ , which are partially observed (§3) or unobserved $^ { ( \\ S ) }$ , the conditional probability $\\mathbb { P } ( s _ { h + 1 } \\mid s _ { h } , a _ { h } )$ in the offline setting is different from the causal effect $\\mathbb { P } ( s _ { h + 1 } \\mid s _ { h } , \\mathrm { d o } ( a _ { h } ) )$ in the online setting [33]. More specifically, it holds that ",
+        "bbox": [
+            173,
+            314,
+            825,
+            400
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/e870ea1008b81d480b706dee5a5ae15005be28db51268a0c533e4a1db300eda3.jpg",
+        "text": "$$\n\\begin{array} { r l } & { \\mathbb { P } \\big ( s _ { h + 1 } | s _ { h } , a _ { h } \\big ) = \\frac { \\mathbb { E } _ { w _ { h } \\sim \\widetilde { \\mathcal { P } } _ { h } ( \\cdot | s _ { h } ) } \\big [ \\mathcal { P } _ { h } \\big ( s _ { h + 1 } | s _ { h } , a _ { h } , w _ { h } \\big ) \\cdot \\nu _ { h } \\big ( a _ { h } | s _ { h } , w _ { h } \\big ) \\big ] } { \\mathbb { E } _ { w _ { h } \\sim \\widetilde { \\mathcal { P } } _ { h } ( \\cdot | s _ { h } ) } \\big [ \\nu _ { h } \\big ( a _ { h } \\big | s _ { h } , w _ { h } \\big ) \\big ] } , } \\\\ & { \\mathbb { P } \\big ( s _ { h + 1 } \\big | s _ { h } , \\mathrm { d o } ( a _ { h } ) \\big ) = \\mathbb { E } _ { w _ { h } \\sim \\widetilde { \\mathcal { P } } _ { h } ( \\cdot | s _ { h } ) } \\big [ \\mathcal { P } _ { h } \\big ( \\cdot | s _ { h } , a _ { h } , w _ { h } \\big ) \\big ] . } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            248,
+            405,
+            746,
+            472
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "In other words, without proper covariate adjustments [32], the confounded observational data may be not informative for estimating the transition dynamics and the associated action-value function in the online setting. To this end, we propose an algorithm that incorporates the confounded observational data in a provably efficient manner. Moreover, our analysis quantifies the amount of information carried over by the confounded observational data from the offline setting and to what extent it helps reducing the regret in the online setting. ",
+        "bbox": [
+            173,
+            474,
+            825,
+            559
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "3 Algorithm and Theory for Partially Observed Confounder ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            577,
+            691,
+            595
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "In this section, we propose the Deconfounded Optimistic Value Iteration (DOVI) algorithm. DOVI handles the case where the confounders are unobserved in the online setting but are partially observed in the offline setting. We then characterize the regret of DOVI. We defer the extension of DOVI, namely $\\mathrm { D O V I + }$ , to $\\ S \\mathrm { A }$ which handles the case where the confounders are unobserved in both the online setting and the offline setting. ",
+        "bbox": [
+            173,
+            608,
+            825,
+            679
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "3.1 Algorithm ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            694,
+            285,
+            708
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Backdoor Adjustment. In the online setting that allows for intervention, the causal effect of $a _ { h }$ on $s _ { h + 1 }$ given $s _ { h }$ , that is, $\\mathbb { P } \\big ( s _ { h + 1 } | s _ { h } , \\mathrm { d o } ( a _ { h } ) \\big ) \\big )$ , plays a key role in the estimation of the action-value function. Meanwhile, the confounded observational data may not allow us to identify the causal effect $\\mathbb { P } \\big ( s _ { h + 1 } | s _ { h } , \\mathrm { d o } ( a _ { h } ) \\big )$ if the confounder $w _ { h }$ is unobserved. However, if the confounder $w _ { h }$ is partially observed in the offline setting, the observed subset $u _ { h }$ of $w _ { h }$ allows us to identify the causal effect $\\bar { \\mathbb { P } } ( s _ { h + 1 } \\mid s _ { h } , \\mathrm { d o } ( a _ { h } ) )$ , as long as $u _ { h }$ satisfies the following backdoor criterion. ",
+        "bbox": [
+            173,
+            719,
+            825,
+            803
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Assumption 3.1 (Backdoor Criterion [32, 33]). In the SCM defined in $\\ S$ and its induced directed acyclic graph (DAG), for all $h \\in [ H ]$ , there exists an observed subset $u _ { h }$ of $w _ { h }$ that satisfies the backdoor criterion, that is, ",
+        "bbox": [
+            176,
+            806,
+            825,
+            849
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "• the elements of $u _ { h }$ are not the descendants of $a _ { h }$ , and   \n• conditioning on $s _ { h }$ , the elements of $u _ { h }$ $d$ -separate every path between $a _ { h }$ and $s _ { h + 1 } , r _ { h }$ that has an incoming arrow into $a _ { h }$ . ",
+        "bbox": [
+            215,
+            859,
+            825,
+            912
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "See Figure 2 for an example that satisfies the backdoor criterion. In particular, we identify the causal effect $\\bar { \\mathbb { P } } ( s _ { h + 1 } \\mid s _ { h } , \\mathrm { d o } ( a _ { h } \\bar { ) } )$ as follows. ",
+        "bbox": [
+            173,
+            90,
+            823,
+            119
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "image",
+        "img_path": "images/fa812e4d1a72af3a441491ece0e503dfa5d5d4fc3fb3f61e57797a91312491fe.jpg",
+        "image_caption": [
+            "Figure 2: An illustration of the backdoor criterion modified from [32]. The causal diagram corresponds to the $h$ -th step of the confounded MDP conditioning on $s _ { h }$ . Here $w _ { h } = \\{ w _ { 1 , h } , w _ { 2 , h } , w _ { 3 , h } \\}$ is the unobserved confounders and the subset $u _ { h } = \\left\\{ u _ { 1 , h } , u _ { 2 , h } \\right\\}$ satisfies the backdoor criterion. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            372,
+            131,
+            624,
+            224
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Proposition 3.2 (Backdoor Adjustment [32]). Under Assumption 3.1, it holds for all $h \\in [ H ]$ that ",
+        "bbox": [
+            168,
+            285,
+            818,
+            301
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "equation",
+        "img_path": "images/059836c7da018a534eff53eda7a1e45a3a02d20ce1b65fc5e20428c702fbe592.jpg",
+        "text": "$$\n\\begin{array} { r l } & { \\mathbb { P } \\big ( s _ { h + 1 } \\mid s _ { h } , \\mathrm { d o } ( a _ { h } ) \\big ) = \\mathbb { E } _ { u _ { h } \\sim \\mathbb { P } ( \\cdot \\mid s _ { h } ) } \\left[ \\mathbb { P } ( s _ { h + 1 } \\mid s _ { h } , a _ { h } , u _ { h } ) \\right] , } \\\\ & { \\mathbb { E } \\big [ r _ { h } ( s _ { h } , a _ { h } , w _ { h } ) \\big \\mid s _ { h } , \\mathrm { d o } ( a _ { h } ) \\big ] = \\mathbb { E } _ { u _ { h } \\sim \\mathbb { P } ( \\cdot \\mid s _ { h } ) } \\Big [ \\mathbb { E } \\big [ r _ { h } ( s _ { h } , a _ { h } , w _ { h } ) \\big \\mid s _ { h } , a _ { h } , u _ { h } \\big ] \\Big ] . } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            235,
+            301,
+            761,
+            351
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Here $( s _ { h + 1 } , s _ { h } , a _ { h } , u _ { h } )$ follows the SCM defined in $\\ S 2$ , which generates the confounded observational data. ",
+        "bbox": [
+            173,
+            352,
+            823,
+            381
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Proof. See [32] for a detailed proof. ",
+        "bbox": [
+            174,
+            393,
+            413,
+            410
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "With a slight abuse of notation, we write $\\mathbb { P } ( s _ { h + 1 } \\mid s _ { h } , a _ { h } , u _ { h } )$ as $\\mathcal { P } _ { h } ( s _ { h + 1 } \\mid s _ { h } , a _ { h } , u _ { h } )$ and $\\mathbb { P } ( u _ { h } \\mid s _ { h } )$ as $\\mathcal { \\widetilde { P } } _ { h } ( u _ { h } \\vert s _ { h } )$ , since they are induced by the SCM defined in $\\ S 2$ . In the sequel, we define $\\mathcal { U }$ the space of observed state $u _ { h }$ and write $r _ { h } = r _ { h } ( s _ { h } , a _ { h } , w _ { h } )$ for notational simplicity. ",
+        "bbox": [
+            173,
+            422,
+            826,
+            469
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Backdoor-Adjusted Bellman Equation. We now formulate the Bellman equation for the confounded MDP. It holds for all $( s _ { h } , a _ { h } ) \\in \\mathcal { S } \\times \\mathcal { A }$ that ",
+        "bbox": [
+            173,
+            474,
+            823,
+            503
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "equation",
+        "img_path": "images/aa8c03ce0fab0192ad8c18b39a01daaa6ff0d1849fb37f5f490992090ccff2f4.jpg",
+        "text": "$$\nQ _ { h } ^ { \\pi } ( s _ { h } , a _ { h } ) = \\mathbb { E } _ { \\pi } \\left[ \\sum _ { j = h } ^ { H } r _ { j } ( s _ { j } , a _ { j } , u _ { j } ) \\middle | s _ { h } , \\mathrm { d o } ( a _ { h } ) \\right] = \\mathbb { E } \\left[ r _ { h } \\middle | s _ { h } , \\mathrm { d o } ( a _ { h } ) \\right] + \\mathbb { E } _ { s _ { h + 1 } } \\left[ V _ { h + 1 } ^ { \\pi } ( s _ { h + 1 } ) \\right] ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            179,
+            507,
+            813,
+            550
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "where Esh+1 denotes the expectation with respect to $\\begin{array} { r l r } { s _ { h + 1 } } & { { } \\sim } & { \\mathbb { P } ( \\cdot \\mid s _ { h } , \\mathrm { d o } ( a _ { h } ) ) } \\end{array}$ . Here $\\mathbb { E } [ r _ { h } \\vert s _ { h } , \\mathrm { d o } ( a _ { h } ) ]$ and $\\mathbb { P } ( \\cdot \\mid s _ { h } , \\mathrm { d o } ( a _ { h } ) )$ are characterized in Proposition 3.2. In the sequel, we define the following transition operator and counterfactual reward function, ",
+        "bbox": [
+            174,
+            553,
+            820,
+            598
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "equation",
+        "img_path": "images/b8e32641d96953b892d012f75bdef243b53a934eff77e59cf9ee6214a8027913.jpg",
+        "text": "$$\n\\begin{array} { r l } & { ( \\mathbb { P } _ { h } V ) ( s _ { h } , a _ { h } ) = \\mathbb { E } _ { s _ { h + 1 } \\sim \\mathbb { P } ( \\cdot \\mid s _ { h } , \\mathrm { d o } ( a _ { h } ) ) } \\bigl [ V ( s _ { h + 1 } ) \\bigr ] , \\quad \\forall V : \\mathcal { S } \\mapsto \\mathbb { R } , ( s _ { h } , a _ { h } ) \\in \\mathcal { S } \\times \\mathcal { A } , } \\\\ & { \\quad R _ { h } ( s _ { h } , a _ { h } ) = \\mathbb { E } \\bigl [ r _ { h } \\mid s _ { h } , \\mathrm { d o } ( a _ { h } ) \\bigr ] , \\quad \\forall ( s _ { h } , a _ { h } ) \\in \\mathcal { S } \\times \\mathcal { A } . } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            200,
+            598,
+            766,
+            640
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "We have the following Bellman equation, ",
+        "bbox": [
+            178,
+            640,
+            446,
+            655
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "equation",
+        "img_path": "images/41e2c695bfb18eb02bb514dfc61496934865e2e52e5f44e1b92dc538cb2c0a0d.jpg",
+        "text": "$$\n\\begin{array} { r } { Q _ { h } ^ { \\pi } ( s _ { h } , a _ { h } ) = R _ { h } ( s _ { h } , a _ { h } ) + ( \\mathbb { P } _ { h } V _ { h + 1 } ^ { \\pi } ) ( s _ { h } , a _ { h } ) , \\quad \\forall h \\in [ H ] , ( s _ { h } , a _ { h } ) \\in \\mathcal { S } \\times \\mathcal { A } . } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            217,
+            656,
+            748,
+            674
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Correspondingly, the Bellman optimality equation takes the following form, ",
+        "bbox": [
+            179,
+            675,
+            673,
+            690
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "equation",
+        "img_path": "images/3a81ff5cfa75945277e9efb13e4bdd0228b923eba96644fb716833337fffa5a7.jpg",
+        "text": "$$\nQ _ { h } ^ { * } ( s _ { h } , a _ { h } ) = R _ { h } ( s _ { h } , a _ { h } ) + ( { \\mathbb { P } } _ { h } V _ { h + 1 } ^ { * } ) ( s _ { h } , a _ { h } ) , \\quad V _ { h } ^ { * } ( s _ { h } ) = \\operatorname* { m a x } _ { a _ { h } \\in \\mathcal { A } } Q _ { h } ^ { * } ( s _ { h } , a _ { h } ) ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            236,
+            691,
+            759,
+            715
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "which holds for all $h \\in [ H ]$ and $( s _ { h } , a _ { h } ) \\in \\mathcal { S } \\times \\mathcal { A }$ . Such a Bellman optimality equation allows us to adapt the least-squares value iteration (LSVI) algorithm [2, 5, 14, 16, 31]. ",
+        "bbox": [
+            174,
+            718,
+            823,
+            748
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Linear Function Approximation. We focus on the following setting with linear transition kernels and reward functions [7, 16, 42, 43], which corresponds to a linear SCM [33]. ",
+        "bbox": [
+            176,
+            757,
+            820,
+            786
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Assumption 3.3 (Linear Confounded MDP). We assume that $\\begin{array} { r } { \\mathcal { P } _ { h } \\big ( s _ { h + 1 } \\big | s _ { h } , a _ { h } , u _ { h } \\big ) = \\big \\langle \\phi _ { h } \\big ( s _ { h } , a _ { h } , u _ { h } \\big ) , \\mu _ { h } \\big ( s _ { h + 1 } \\big ) \\big \\rangle , \\quad \\forall h \\in [ H ] , ( s _ { h + 1 } , s _ { h } , a _ { h } ) \\in \\mathcal { S } \\times \\mathcal { S } \\times \\mathcal { A } , } \\end{array}$ where $\\phi _ { h } ( \\cdot , \\cdot , \\cdot )$ and $\\boldsymbol { \\mu } _ { h } ( \\cdot ) = ( \\mu _ { 1 , h } ( \\cdot ) , \\ldots , \\mu _ { d , h } ( \\cdot ) ) ^ { \\top }$ are $\\mathbb { R } ^ { d }$ -valued functions. We assume that $\\begin{array} { r } { \\sum _ { i = 1 } ^ { d } \\| \\mu _ { i , h } \\| _ { 1 } ^ { 2 } \\leq d } \\end{array}$ and $\\| \\phi _ { h } ( s _ { h } , a _ { h } , u _ { h } ) \\| _ { 2 } \\le 1$ for all $h \\in [ H ]$ and $( s _ { h } , a _ { h } , u _ { h } ) \\in \\mathcal S \\times \\mathcal A \\times \\mathcal U$ Meanwhile, we assume that ",
+        "bbox": [
+            171,
+            789,
+            583,
+            804
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            805,
+            825,
+            871
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "$\\begin{array} { r } { \\mathbb { E } [ r _ { h } | s _ { h } , a _ { h } , u _ { h } ] = \\phi _ { h } ( s _ { h } , a _ { h } , u _ { h } ) ^ { \\top } \\theta _ { h } , \\quad \\forall h \\in [ H ] , ( s _ { h } , a _ { h } , u _ { h } ) \\in \\mathcal { S } \\times \\mathcal { A } \\times \\mathcal { U } , } \\end{array}$ where $\\theta _ { h } \\in \\mathbb { R } ^ { d }$ and $\\| \\theta _ { h } \\| _ { 2 } \\leq \\sqrt { d }$ for all $h \\in [ H ]$ . ",
+        "bbox": [
+            174,
+            872,
+            754,
+            912
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Such a linear setting generalizes the tabular setting where $s , A .$ , and $\\mathcal { U }$ are finite. ",
+        "bbox": [
+            173,
+            90,
+            700,
+            107
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Proposition 3.4. We define the backdoor-adjusted feature as follows, ",
+        "bbox": [
+            173,
+            109,
+            630,
+            123
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "equation",
+        "img_path": "images/a4aa6b31c3f9d9796703f72bb0af44d1e877087ea43a4d60a5f1ad96bbed5380.jpg",
+        "text": "$$\n\\begin{array} { r } { \\psi _ { h } ( s _ { h } , a _ { h } ) = \\mathbb { E } _ { a _ { h } \\sim \\widetilde { \\mathcal { P } } _ { h } ( \\cdot \\mid s _ { h } ) } \\big [ \\phi _ { h } ( s _ { h } , a _ { h } , u _ { h } ) \\big ] , \\quad \\forall h \\in [ H ] , ( s _ { h } , a _ { h } ) \\in \\mathcal { S } \\times \\mathcal { A } . } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            240,
+            127,
+            758,
+            148
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Under Assumption 3.1, it holds that ",
+        "bbox": [
+            174,
+            152,
+            411,
+            166
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "equation",
+        "img_path": "images/c66ff3bd2d8f5aabe69542823d651c069fe4f25a7d63286a666ce9b54c20f57a.jpg",
+        "text": "$$\n\\mathbb { P } ( s _ { h + 1 } | s _ { h } , \\mathrm { d o } ( a _ { h } ) ) = \\langle \\psi _ { h } ( s _ { h } , a _ { h } ) , \\mu _ { h } ( s _ { h + 1 } ) \\rangle , \\quad \\forall h \\in [ H ] , ( s _ { h + 1 } , s _ { h } , a _ { h } ) \\in \\mathcal { S } \\times \\mathcal { S } \\times \\mathcal { A } .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            194,
+            171,
+            802,
+            189
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Moreover, the action-value functions $Q _ { h } ^ { \\pi }$ and $Q _ { h } ^ { * }$ are linear in the backdoor-adjusted feature $\\psi _ { h }$ for all $\\pi$ . ",
+        "bbox": [
+            173,
+            193,
+            825,
+            223
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Proof. See $\\mathrm { \\ S F . 1 }$ for a detailed proof. ",
+        "bbox": [
+            174,
+            236,
+            413,
+            251
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Such an observation allows us to estimate the action-value function based on the backdoor-adjusted features $\\{ \\psi _ { h } \\} _ { h \\in [ H ] }$ in the online setting. See $\\ S$ for a detailed discussion. In the sequel, we assume that either the density of $\\{ \\widetilde { \\mathcal { P } } _ { h } ( \\cdot \\vert s _ { h } ) \\} _ { h \\in [ H ] }$ is known or the backdoor-adjusted feature $\\{ \\psi _ { h } \\} _ { h \\in [ H ] }$ is known. ",
+        "bbox": [
+            173,
+            265,
+            825,
+            325
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "In the sequel, we introduce the DOVI algorithm (Algorithm 1). Each iteration of DOVI consists of two components, namely point estimation, where we estimate $Q _ { h } ^ { * }$ based on the confounded observational data and the interventional data, and uncertainty quantification, where we construct the upper confidence bound (UCB) of the point estimator. ",
+        "bbox": [
+            173,
+            330,
+            825,
+            388
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Algorithm 1 Deconfounded Optimistic Value Iteration (DOVI) for Confounded MDP ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            401,
+            735,
+            417
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Require: Observational data $\\{ ( s _ { h } ^ { i } , a _ { h } ^ { i } , u _ { h } ^ { i } , r _ { h } ^ { i } ) \\} _ { i \\in [ n ] , h \\in [ H ] }$ , tuning parameters $\\lambda , \\beta > 0$ , backdooradjusted feature $\\{ \\psi _ { h } \\} _ { h \\in [ H ] }$ , which is defined in (3.6).   \n1: Initialization: Set $\\{ Q _ { h } ^ { 0 } , V _ { h } ^ { 0 } \\} _ { h \\in [ H ] }$ as zero functions and $V _ { H + 1 } ^ { k }$ as a zero function for $k \\in [ K ]$ . 2: for $k = 1 , \\ldots , K$ do   \n3: for 4: S $h = H , \\ldots , 1$   \n$\\begin{array} { r } { \\omega _ { h } ^ { k }  { \\stackrel {  } { \\sim } } \\operatorname { a r g m i n } _ { \\omega \\in \\mathbb { R } ^ { d } } \\sum _ { \\tau = 1 } ^ { k - 1 } ( r _ { h } ^ { \\tau } + V _ { h + 1 } ^ { \\tau } ( s _ { h + 1 } ^ { \\tau } ) - \\omega ^ { \\top } \\psi _ { h } ( s _ { h } ^ { \\tau } , a _ { h } ^ { \\tau } ) ) ^ { 2 } + \\lambda \\| \\omega \\| _ { 2 } ^ { 2 } + L _ { h } ^ { k } ( \\omega ) , } \\end{array}$ where $L _ { h } ^ { k }$ is defined in (3.8).   \n5: Set $Q _ { h } ^ { k } ( \\cdot , \\cdot ) \\gets \\operatorname* { m i n } \\{ \\psi _ { h } ( \\cdot , \\cdot ) ^ { \\top } \\omega _ { h } ^ { k } + \\Gamma _ { h } ^ { k } ( \\cdot , \\cdot ) , H - h \\}$ , where $\\Gamma _ { h } ^ { k }$ is defined in (3.12). 6: Set $\\pi _ { h } ^ { k } ( \\cdot \\vert s _ { h } ) \\gets \\mathrm { a r g m a x } _ { a _ { h } \\in \\mathcal { A } } Q _ { h } ^ { k } ( s _ { h } , a _ { h } )$ for all $s _ { h } \\in S$ .   \n7: Set $V _ { h } ^ { k } ( \\cdot )  \\langle \\pi _ { h } ^ { k } ( \\cdot \\vert \\cdot ) , Q _ { h } ^ { k } ( \\cdot , \\cdot ) \\rangle _ { \\cal A }$ .   \n8: end for   \n9: Obtain $s _ { 1 } ^ { k }$ from the environment.   \n10: for $h = 1 , \\ldots , H$ do   \n11: Take $a _ { h } ^ { k } \\sim \\pi _ { h } ^ { k } ( \\cdot | s _ { h } ^ { k } )$ . Obtain $r _ { h } ^ { k } = r _ { h } ( s _ { h } ^ { k } , a _ { h } ^ { k } , u _ { h } ^ { k } )$ and $s _ { h + 1 } ^ { k }$ .   \n12: end for   \n13: end for ",
+        "bbox": [
+            176,
+            420,
+            826,
+            661
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Point Estimation. To solve the Bellman optimality equation in (3.4), we minimize the empirical mean-squared Bellman error as follows at each step, ",
+        "bbox": [
+            173,
+            675,
+            821,
+            705
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "equation",
+        "img_path": "images/d65c9f481f5cb9b2a12c0df6b5b8a9420c2214d472f0b5ede89e07d85852a305.jpg",
+        "text": "$$\n\\omega _ { h } ^ { k } \\gets \\underset { \\omega \\in \\mathbb { R } ^ { d } } { \\operatorname { a r g m i n } } \\sum _ { \\tau = 1 } ^ { k - 1 } \\big ( r _ { h } ^ { \\tau } + V _ { h + 1 } ^ { \\tau } ( s _ { h + 1 } ^ { \\tau } ) - \\omega ^ { \\top } \\psi _ { h } ( s _ { h } ^ { \\tau } , a _ { h } ^ { \\tau } ) \\big ) ^ { 2 } + \\lambda \\| \\omega \\| _ { 2 } ^ { 2 } + L _ { h } ^ { k } ( \\omega ) , h = H , \\ldots , 1 ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            192,
+            708,
+            805,
+            752
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "where we set $V _ { H + 1 } ^ { k } = 0$ for all $k \\in [ K ]$ and $V _ { h + 1 } ^ { \\tau }$ is defined in Line 7 of Algorithm 1 for all $( \\tau , h ) \\in [ K ] \\times [ H - 1 ]$ . Here $k$ is the index of episode, $\\lambda > 0$ is a tuning parameter, and $L _ { h } ^ { k }$ is a regularizer, which is constructed based on the confounded observational data. More specifically, we define ",
+        "bbox": [
+            173,
+            771,
+            825,
+            832
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "equation",
+        "img_path": "images/1e1463ab472f1fe08bcfd47b5a6d82ee6a1a4f9621ea4be0058f53a1b36a86a8.jpg",
+        "text": "$$\nL _ { h } ^ { k } ( \\omega ) = \\sum _ { i = 1 } ^ { n } \\bigl ( r _ { h } ^ { i } + V _ { h + 1 } ^ { k } ( s _ { h + 1 } ^ { i } ) - \\omega ^ { \\top } \\phi _ { h } ( s _ { h } ^ { i } , a _ { h } ^ { i } , u _ { h } ^ { i } ) \\bigr ) ^ { 2 } , \\quad \\forall ( k , h ) \\in [ K ] \\times [ H ] ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            215,
+            833,
+            746,
+            876
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "which corresponds to the least-squares loss for regressing $r _ { h } ^ { i } + V _ { h + 1 } ^ { k } ( s _ { h + 1 } ^ { i } )$ against $\\phi _ { h } ( s _ { h } ^ { i } , a _ { h } ^ { i } , u _ { h } ^ { i } )$ for all $i \\in [ n ]$ . Here $\\{ ( s _ { h } ^ { i } , a _ { h } ^ { i } , u _ { h } ^ { i } , r _ { h } ^ { i } ) \\} _ { ( i , h ) \\in [ n ] \\times [ H ] }$ are the confounded observational data, where $u _ { h } ^ { i } \\sim \\widetilde { \\mathcal { P } } _ { h } ( \\cdot | s _ { h } ^ { i } )$ , $s _ { h + 1 } ^ { i } \\sim \\mathcal { P } _ { h } \\big ( \\cdot \\mid s _ { h } ^ { i } , a _ { h } ^ { i } , u _ { h } ^ { i } \\big )$ , and $a _ { h } ^ { i } \\sim \\nu _ { h } ( \\cdot \\mid s _ { h } ^ { i } , w _ { h } ^ { i } )$ with $\\nu = \\{ \\nu _ { h } \\} _ { h \\in [ H ] }$ being the behavior policy. Here recall that, with a slight abuse of notation, we write $\\mathbb { P } ( s _ { h + 1 } \\mid s _ { h } , a _ { h } , u _ { h } )$ as $\\mathcal { P } _ { h } ( s _ { h + 1 } \\mid s _ { h } , a _ { h } , u _ { h } )$ and $\\mathbb { P } ( u _ { h } \\mid s _ { h } )$ as $\\mathcal { \\widetilde { P } } _ { h } ( u _ { h } \\vert s _ { h } )$ , since they are induced by the SCM defined in §2. ",
+        "bbox": [
+            174,
+            878,
+            823,
+            915
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            88,
+            826,
+            152
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "The update in (3.7) takes the following explicit form, ",
+        "bbox": [
+            174,
+            156,
+            522,
+            172
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "equation",
+        "img_path": "images/8462f13d3c79f88b8c48d3e995a4fc53894bbdd733d1629a3a796c0480e32225.jpg",
+        "text": "$$\n\\begin{array} { r l } & { \\omega _ { h } ^ { k } \\gets ( \\Lambda _ { h } ^ { k } ) ^ { - 1 } \\Bigg ( \\displaystyle \\sum _ { \\tau = 1 } ^ { k - 1 } \\psi _ { h } ( s _ { h } ^ { \\tau } , a _ { h } ^ { \\tau } ) \\cdot \\big ( V _ { h + 1 } ^ { k } ( s _ { h + 1 } ^ { \\tau } ) + r _ { h } ^ { \\tau } \\big ) } \\\\ & { \\qquad + \\displaystyle \\sum _ { i = 1 } ^ { n } \\phi _ { h } ( s _ { h } ^ { i } , a _ { h } ^ { i } , u _ { h } ^ { i } ) \\cdot \\big ( V _ { h + 1 } ^ { k } ( s _ { h + 1 } ^ { i } ) + r _ { h } ^ { i } \\big ) \\Bigg ) , } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            276,
+            179,
+            722,
+            266
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "where ",
+        "bbox": [
+            173,
+            272,
+            217,
+            285
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "equation",
+        "img_path": "images/2e525db580e7bf8a223928427fe6d5be53ee99784e348c11e0e79203219864a0.jpg",
+        "text": "$$\n\\Lambda _ { h } ^ { k } = \\sum _ { \\tau = 1 } ^ { k - 1 } \\psi _ { h } ( s _ { h } ^ { \\tau } , a _ { h } ^ { \\tau } ) \\psi _ { h } ( s _ { h } ^ { \\tau } , a _ { h } ^ { \\tau } ) ^ { \\top } + \\sum _ { i = 1 } ^ { n } \\phi _ { h } ( s _ { h } ^ { i } , a _ { h } ^ { i } , u _ { h } ^ { i } ) \\phi _ { h } ( s _ { h } ^ { i } , a _ { h } ^ { i } , u _ { h } ^ { i } ) ^ { \\top } + \\lambda I .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            218,
+            291,
+            740,
+            334
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Uncertainty Quantification. We now construct the UCB $\\Gamma _ { h } ^ { k } ( \\cdot , \\cdot )$ of the point estimator $\\psi _ { h } ( \\cdot , \\cdot ) ^ { \\top } \\omega _ { h } ^ { k }$ obtained from (3.9), which encourages the exploration of the less visited state-action pairs. To this end, we employ the following notion of information gain to motivate the UCB, ",
+        "bbox": [
+            173,
+            348,
+            823,
+            392
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "equation",
+        "img_path": "images/189c807a993e11ca4039e04c060fabb9f9e57a0d42c41a2df64a2d68e2152e21.jpg",
+        "text": "$$\n\\Gamma _ { h } ^ { k } ( s _ { h } ^ { k } , a _ { h } ^ { k } ) \\propto H ( \\omega _ { h } ^ { k } \\mid \\xi _ { k - 1 } ) - H \\big ( \\omega _ { h } ^ { k } \\mid \\xi _ { k - 1 } \\cup \\{ ( s _ { h } ^ { k } , a _ { h } ^ { k } ) \\} \\big ) ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            303,
+            398,
+            691,
+            419
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "where $H ( \\omega _ { h } ^ { k } \\mid \\xi _ { k - 1 } )$ is the differential entropy of the random variable $\\omega _ { h } ^ { k }$ given the data $\\xi _ { k - 1 }$ . In particular, $\\ddot { \\xi } _ { k - 1 } ~ = ~ \\{ \\big ( s _ { h } ^ { \\tau } , a _ { h } ^ { \\tau } , r _ { h } ^ { \\tau } \\big ) \\} _ { ( \\tau , h ) \\in [ k - 1 ] \\times [ H ] } \\cup \\big \\{ \\big ( s _ { h } ^ { i } , a _ { h } ^ { i } , u _ { h } ^ { i } , r _ { h } ^ { i } \\big ) \\big \\} _ { ( i , h ) \\in [ n ] \\times [ H ] }$ consists of the confounded observational data and the interventional data up to the $\\left( k - 1 \\right)$ -th episode. However, it is challenging to characterize the distribution of $\\omega _ { h } ^ { k }$ . To this end, we consider a Bayesian counterpart of the confounded MDP, where the prior of $\\omega _ { h } ^ { k }$ is $N ( 0 , I / \\lambda )$ and the residual of the regression problem in (3.7) is $N ( 0 , 1 )$ . In such a “parallel” confounded MDP, the posterior of $\\omega _ { h } ^ { k }$ follows $N ( \\mu _ { k , h } , ( \\Lambda _ { h } ^ { k } ) ^ { - 1 } )$ , where $\\Lambda _ { h } ^ { k }$ is defined in (3.10) and $\\mu _ { k , h }$ coincides with the right-hand side of (3.9). Moreover, it holds for all $( s _ { h } ^ { k } , a _ { h } ^ { k } ) \\in \\mathcal { S } \\times \\mathcal { A }$ that ",
+        "bbox": [
+            173,
+            426,
+            826,
+            551
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "equation",
+        "img_path": "images/f68bfebcc9a1a30f964126981d1b7792b1239c770379f8cedc8935cb4aa9df30.jpg",
+        "text": "$$\n\\begin{array} { r l } & { H ( \\omega _ { h } ^ { k } \\mid \\xi _ { k - 1 } ) = 1 / 2 \\cdot \\log \\operatorname* { d e t } \\bigl ( ( 2 \\pi e ) ^ { d } \\cdot ( \\Lambda _ { h } ^ { k } ) ^ { - 1 } \\bigr ) , } \\\\ & { H \\bigl ( \\omega _ { h } ^ { k } \\mid \\xi _ { k - 1 } \\cup \\{ ( s _ { h } ^ { k } , a _ { h } ^ { k } ) \\} \\bigr ) = 1 / 2 \\cdot \\log \\operatorname* { d e t } \\Bigl ( ( 2 \\pi e ) ^ { d } \\cdot \\bigl ( \\Lambda _ { h } ^ { k } + \\psi _ { h } ( s _ { h } ^ { k } , a _ { h } ^ { k } ) \\psi _ { h } ( s _ { h } ^ { k } , a _ { h } ^ { k } ) ^ { \\top } \\bigr ) ^ { - 1 } \\Bigr ) . } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            197,
+            556,
+            794,
+            606
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Correspondingly, we employ the following UCB, which instantiates (3.11), that is, ",
+        "bbox": [
+            174,
+            611,
+            715,
+            627
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "equation",
+        "img_path": "images/481eebe3f789e03295bf20f2b0dcb79112ae4b052985e502458bb7aec2c7f22b.jpg",
+        "text": "$$\n\\Gamma _ { h } ^ { k } ( s _ { h } ^ { k } , a _ { h } ^ { k } ) = \\beta \\cdot \\Big ( \\log \\operatorname* { d e t } \\big ( \\Lambda _ { h } ^ { k } + \\psi _ { h } ( s _ { h } ^ { k } , a _ { h } ^ { k } ) \\psi _ { h } ( s _ { h } ^ { k } , a _ { h } ^ { k } ) ^ { \\top } \\big ) - \\log \\operatorname* { d e t } ( \\Lambda _ { h } ^ { k } ) \\Big ) ^ { 1 / 2 }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            222,
+            633,
+            736,
+            664
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "for all $( s _ { h } ^ { k } , a _ { h } ^ { k } ) \\ \\in \\ S \\times { \\mathcal { A } }$ . Here $\\beta > 0$ is a tuning parameter. We highlight that, although the information gain in (3.11) relies on the “parallel” confounded MDP, the UCB in (3.12), which is used in Line 5 of Algorithm 1, does not rely on the Bayesian perspective. Also, our analysis establishes the frequentist regret. ",
+        "bbox": [
+            173,
+            671,
+            826,
+            728
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Regularization with Observational Data: A Bayesian Perspective. In the “parallel” confounded MDP, it holds that ",
+        "bbox": [
+            173,
+            733,
+            825,
+            763
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "equation",
+        "img_path": "images/994e4219bdef564248594be4ae72dbec81da8c0f7ebf8889fbf98279250036de.jpg",
+        "text": "$$\n\\omega _ { h } ^ { k } \\sim N ( 0 , I / \\lambda ) , \\quad \\omega _ { h } ^ { k } \\mid \\xi _ { 0 } \\sim N \\big ( \\mu _ { 1 , h } , ( \\Lambda _ { h } ^ { 1 } ) ^ { - 1 } \\big ) , \\quad \\omega _ { h } ^ { k } \\mid \\xi _ { k - 1 } \\sim N \\big ( \\mu _ { k , h } , ( \\Lambda _ { h } ^ { k } ) ^ { - 1 } \\big ) ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            227,
+            767,
+            769,
+            787
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "where $\\mu _ { k , h }$ coincides with the right-hand side of (3.9) and $\\mu _ { 1 , h }$ is defined by setting $k = 1$ in $\\mu _ { k , h }$ . Here $\\xi _ { 0 } = \\{ \\big ( s _ { h } ^ { i } , a _ { h } ^ { i } , u _ { h } ^ { i } , r _ { h } ^ { i } \\big ) \\} _ { ( i , h ) \\in [ n ] \\times [ H ] }$ are the confounded observational data. Hence, the regularizer $L _ { h } ^ { k }$ in (3.8) corresponds to using $\\omega _ { h } ^ { k } \\mid \\xi _ { 0 }$ as the prior for the Bayesian regression problem given only the interventional data $\\xi _ { k - 1 } \\setminus \\xi _ { 0 } = \\{ ( s _ { h } ^ { \\tau } , a _ { h } ^ { \\tau } , r _ { h } ^ { \\tau } ) \\} _ { ( \\tau , h ) \\in [ k - 1 ] \\times [ H ] } .$ . ",
+        "bbox": [
+            173,
+            794,
+            825,
+            857
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "3.2 Theory ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            871,
+            264,
+            886
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "The following theorem characterizes the regret of DOVI, which is defined in (2.3). ",
+        "bbox": [
+            173,
+            896,
+            714,
+            912
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Theorem 3.5 (Regret of DOVI). Let $\\beta = C d H \\sqrt { \\log ( d ( T + n H ) / \\zeta ) }$ and $\\lambda = 1$ , where $C > 0$ and $\\zeta \\in ( 0 , 1 ]$ are absolute constants. Under Assumptions 3.1 and 3.3, it holds with probability at least $1 - 5 \\zeta / 2$ that ",
+        "bbox": [
+            173,
+            89,
+            825,
+            133
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "equation",
+        "img_path": "images/b82b627fde2c397c2b10446ea970c2a3725e9791eacad3503fd29412bf5a587e.jpg",
+        "text": "$$\n\\mathrm { R e g r e t } ( T ) \\le C ^ { \\prime } \\cdot \\Delta _ { H } \\cdot \\sqrt { d ^ { 3 } H ^ { 3 } T } \\cdot \\sqrt { \\log \\left( d ( T + n H ) / \\zeta \\right) } ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            303,
+            142,
+            691,
+            170
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "where $C ^ { \\prime } > 0$ is an absolute constant and ",
+        "bbox": [
+            176,
+            179,
+            446,
+            194
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "equation",
+        "img_path": "images/51177b65c88dd97314c6231a832f5ffcf96cba9ffa6b4d70beaefce6af3ae24a.jpg",
+        "text": "$$\n\\Delta _ { H } = { \\frac { 1 } { \\sqrt { d H ^ { 2 } } } } \\sum _ { h = 1 } ^ { H } \\bigl ( \\log \\operatorname* { d e t } ( \\Lambda _ { h } ^ { K + 1 } ) - \\log \\operatorname* { d e t } ( \\Lambda _ { h } ^ { 1 } ) \\bigr ) ^ { 1 / 2 } .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            315,
+            200,
+            681,
+            244
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Proof. See $\\mathrm { \\ S F } . 3$ for a detailed proof. ",
+        "bbox": [
+            174,
+            263,
+            413,
+            279
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Note that $\\Lambda _ { h } ^ { K + 1 } \\preceq ( n + K + \\lambda ) I$ and $\\Lambda _ { h } ^ { 1 } \\succeq \\lambda I$ for all $h \\in [ H ]$ . Hence, it holds that √ $\\Delta _ { H } =$ $\\mathcal { O } ( \\sqrt { \\log ( n + K + 1 ) } )$ in the worst case. Thus, the regret of DOVI is $\\mathcal { O } ( \\sqrt { d ^ { 3 } H ^ { 3 } T } )$ up to logarithmic factors, which is optimal in the total number of steps $T$ if we only consider the online setting. However, $\\Delta _ { H }$ is possibly much smaller than $\\mathcal { O } ( \\sqrt { \\log ( n + K + 1 ) } )$ , depending on the amount of information carried over by the confounded observational data from the offline setting, which is quantified in the following. ",
+        "bbox": [
+            173,
+            299,
+            825,
+            392
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Interpretation of $\\Delta _ { H }$ : An Information-Theoretic Perspective. Let $\\omega _ { h } ^ { * }$ be the parameter of the globally optimal action-value function $Q _ { h } ^ { * }$ , which corresponds to $\\pi ^ { * }$ in (2.3). Recall that we denote by $\\xi _ { 0 }$ and $\\xi _ { K }$ the confounded observational data $\\{ ( s _ { h } ^ { i } , a _ { h } ^ { i } , u _ { h } ^ { i } , r _ { h } ^ { i } ) \\} _ { ( i , h ) \\in [ n ] \\times [ H ] }$ and the union $\\{ \\big ( s _ { h } ^ { i } , a _ { h } ^ { i } , u _ { h } ^ { i } , r _ { h } ^ { i } \\big ) \\} _ { ( i , h ) \\in [ n ] \\times [ H ] } \\cup \\{ \\big ( s _ { h } ^ { k } , \\underline { { a } } _ { h } ^ { k } , r _ { h } ^ { k } \\big ) \\} _ { ( k , h ) \\in [ K ] \\times [ H ] }$ of the confounded observational data and the interventional data up to the $K$ -th episode, respectively. We consider the aforementioned Bayesian counterpart of the confounded MDP, where the prior of $\\omega _ { h } ^ { * }$ is also $N ( 0 , I / \\lambda )$ . In such a “parallel” confounded MDP, we have ",
+        "bbox": [
+            173,
+            396,
+            825,
+            500
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "equation",
+        "img_path": "images/49129cab931398ea35a2ba4607da169e4ea87a2936eba77511ba5631d40fc304.jpg",
+        "text": "$$\n\\omega _ { h } ^ { * } \\sim N ( 0 , I / \\lambda ) , \\quad \\omega _ { h } ^ { * } \\mid \\xi _ { 0 } \\sim N \\big ( \\mu _ { 1 , h } ^ { * } , ( \\Lambda _ { h } ^ { 1 } ) ^ { - 1 } \\big ) , \\quad \\omega _ { h } ^ { * } \\mid \\xi _ { K } \\sim N \\big ( \\mu _ { K , h } ^ { * } , ( \\Lambda _ { h } ^ { K + 1 } ) ^ { - 1 } \\big ) ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            199,
+            507,
+            756,
+            529
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "where ",
+        "bbox": [
+            174,
+            535,
+            217,
+            549
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "equation",
+        "img_path": "images/0f122a8ae933bd73b5713d4ddbf31f0c8f735cb2caf0fc2e02ecdfd7fb2642a7.jpg",
+        "text": "$$\n\\begin{array} { r l } & { \\mu _ { 1 , h } ^ { * } = ( \\Lambda _ { h } ^ { 1 } ) ^ { - 1 } \\displaystyle \\sum _ { i = 1 } ^ { n } \\phi _ { h } ( s _ { h } ^ { i } , a _ { h } ^ { i } , u _ { h } ^ { i } ) \\cdot \\left( V _ { h + 1 } ^ { * } ( s _ { h + 1 } ^ { i } ) + r _ { h } ^ { i } \\right) , } \\\\ & { \\mu _ { K , h } ^ { * } = ( \\Lambda _ { h } ^ { K + 1 } ) ^ { - 1 } \\bigg ( \\Lambda _ { h } ^ { 1 } \\mu _ { 1 , h } ^ { * } + \\displaystyle \\sum _ { \\tau = 1 } ^ { K } \\psi _ { h } ( s _ { h } ^ { \\tau } , a _ { h } ^ { \\tau } ) \\cdot \\left( V _ { h + 1 } ^ { * } ( s _ { h + 1 } ^ { \\tau } ) + r _ { h } ^ { \\tau } \\right) \\bigg ) . } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            264,
+            556,
+            733,
+            642
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "It then holds for the right-hand side of (3.14) that ",
+        "bbox": [
+            174,
+            648,
+            498,
+            665
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "equation",
+        "img_path": "images/3d71bb01073b4ccc29a099e99cdb27b1c6751c6d42a1a8d6983d67e07de043b1.jpg",
+        "text": "$$\n1 / 2 \\cdot \\log \\operatorname* { d e t } ( \\Lambda _ { h } ^ { K + 1 } ) - 1 / 2 \\cdot \\log \\operatorname* { d e t } ( \\Lambda _ { h } ^ { 1 } ) = H ( \\omega _ { h } ^ { * } \\mid \\xi _ { 0 } ) - H ( \\omega _ { h } ^ { * } \\mid \\xi _ { K } ) .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            264,
+            672,
+            732,
+            693
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "The left-hand side of (3.16) characterizes the information gain of intervention in the online setting given the confounded observational data in the offline setting. In other words, if the confounded observational data are sufficiently informative upon the backdoor adjustment, then $\\Delta _ { H }$ is small, which implies that the regret is small. More specifically, the matrices $( \\Lambda _ { h } ^ { 1 } ) ^ { - 1 }$ and $( \\Lambda _ { h } ^ { K + 1 } ) ^ { - 1 }$ defined in (3.10) characterize the ellipsoidal confidence sets given $\\xi _ { 0 }$ and $\\xi _ { K }$ , respectively. If the confounded observational data are sufficiently informative upon the backdoor adjustment, $\\Lambda _ { h } ^ { K + 1 }$ is close to $\\Lambda _ { h } ^ { 1 }$ . To illustrate, let $\\{ \\psi _ { h } \\big ( s _ { h } ^ { \\tau } , a _ { h } ^ { \\tau } \\big ) \\} _ { ( \\tau , h ) \\in [ K ] \\times [ H ] }$ and $\\{ \\phi _ { h } \\big ( s _ { h } ^ { i } , a _ { h } ^ { i } , u _ { h } ^ { i } \\big ) \\} _ { ( i , h ) \\in [ n ] \\times [ H ] }$ be sampled uniformly at random from the canonical basis $\\{ e _ { \\ell } \\} _ { \\ell \\in [ d ] }$ of $\\mathbb { R } ^ { d }$ . It then holds that $\\Lambda _ { h } ^ { K + 1 } \\approx ( K + n ) I / d + \\lambda I$ and $\\Lambda _ { h } ^ { 1 } \\approx n I / d + \\lambda I$ . Hence, for $\\lambda = 1$ and sufficiently large $n$ and $K$ , we have $\\Delta _ { H } = \\mathcal { O } ( \\sqrt { \\log ( 1 + K / ( n + d ) ) } ) = \\mathcal { O } ( \\sqrt { K / ( n + d ) } )$ . For example, for $n = \\Omega ( K ^ { 2 } )$ , it holds that $\\Delta _ { H } = \\mathcal { O } ( n ^ { - 1 / 2 } )$ , which implies that the regret of DOVI is $\\mathcal { O } ( n ^ { - 1 / 2 } \\cdot \\sqrt { d ^ { 3 } H ^ { 3 } T } )$ . In other words, if the confounded observational data are sufficiently informative upon the backdoor adjustment, the regret of DOVI can be arbitrarily small given a sufficiently large sample size $n$ of the confounded observational data, which is often the case in practice [8, 9, 21, 22, 29]. ",
+        "bbox": [
+            173,
+            699,
+            825,
+            912
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "4 Conclusion ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            89,
+            299,
+            106
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "In this paper, we propose the deconfounded optimistic value iteration (DOVI) algorithm and its variant $\\bar { \\mathrm { D O V I } } ^ { + }$ , which incorporate the confounded observational data to the online reinforcement learning in a provably efficient manner. DOVI and $\\mathrm { D O V I ^ { + } }$ explicitly adjust for the confounding bias in the observational data via the backdoor and frontdoor adjustments, respectively. In both cases, such adjustments allow us to construct the bonus based on a notion of information gain, which considers the amount of information acquired from the offline dataset. We further conduct regret analysis of DOVI and $\\mathrm { D O V I ^ { + } }$ . Our analysis suggests that practitioners can tackle the confounding issue in the offline dataset by estimating the counterfactual reward for value function estimations, given that a proper adjustment such as the backdoor or frontdoor adjustment is available. In the case of backdoor and frontdoor adjustment, we prove that the regret of DOVI is smaller than the optimal regret achievable in the pure online setting when the confounded observational data are informative upon the adjustments, suggesting that one can exploit the confounded observational data in reinforcement learning upon proper adjustments. In our future study, we wish to incorporate proxy variables that are native to MDPs for the adjustments of the offline dataset, such as the variables exploited by [4, 24, 40]. ",
+        "bbox": [
+            174,
+            121,
+            825,
+            327
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Acknolodgements ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            347,
+            325,
+            363
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Zhaoran Wang acknowledges National Science Foundation (Awards 2048075, 2008827, 2015568, 1934931), Simons Institute (Theory of Reinforcement Learning), Amazon, J.P. Morgan, and Two Sigma for their supports. Zhuoran Yang acknowledges Simons Institute (Theory of Reinforcement Learning). The authors also thank the anonymous reviewers, whose invaluable suggestions help the authors to improve the paper. ",
+        "bbox": [
+            174,
+            377,
+            825,
+            446
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "References ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            465,
+            266,
+            482
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "[1] Abbasi-Yadkori, Y., Pal, D. and Szepesv ´ ari, C. (2011). Improved algorithms for linear stochas- ´ tic bandits. In Advances in Neural Information Processing Systems.   \n[2] Azar, M. G., Osband, I. and Munos, R. (2017). Minimax regret bounds for reinforcement learning. In International Conference on Machine Learning.   \n[3] Balke, A. and Pearl, J. (2013). Counterfactuals and policy analysis in structural models. arXiv preprint arXiv:1302.4929.   \n[4] Bennett, A., Kallus, N., Li, L. and Mousavi, A. (2021). Off-policy evaluation in infinitehorizon reinforcement learning with latent confounders. In International Conference on Artificial Intelligence and Statistics.   \n[5] Bradtke, S. J. and Barto, A. G. (1996). Linear least-squares algorithms for temporal difference learning. Machine Learning, 22 33–57.   \n[6] Buesing, L., Weber, T., Zwols, Y., Racaniere, S., Guez, A., Lespiau, J.-B. and Heess, N. (2018). Woulda, coulda, shoulda: Counterfactually-guided policy search. arXiv preprint arXiv:1811.06272.   \n[7] Cai, Q., Yang, Z., Jin, C. and Wang, Z. (2019). Provably efficient exploration in policy optimization. arXiv preprint arXiv:1912.05830.   \n[8] Chakraborty, B. and Murphy, S. A. (2014). Dynamic treatment regimes. Annual Review of Statistics and Its Application, 1 447–464.   \n[9] de Haan, P., Jayaraman, D. and Levine, S. (2019). Causal confusion in imitation learning. In Advances in Neural Information Processing Systems.   \n[10] D´ıaz, I. and Hejazi, N. (2019). Causal mediation analysis for stochastic interventions. arXiv preprint arXiv:1901.02776.   \n[11] Forney, A., Pearl, J. and Bareinboim, E. (2017). Counterfactual data-fusion for online reinforcement learners. In International Conference on Machine Learning.   \n[12] Hallak, A., Di Castro, D. and Mannor, S. (2015). Contextual Markov decision processes. arXiv preprint arXiv:1502.02259.   \n[13] Hessel, M., Modayil, J., Van Hasselt, H., Schaul, T., Ostrovski, G., Dabney, W., Horgan, D., Piot, B., Azar, M. and Silver, D. (2018). Rainbow: Combining improvements in deep reinforcement learning. In AAAI Conference on Artificial Intelligence.   \n[14] Jaksch, T., Ortner, R. and Auer, P. (2010). Near-optimal regret bounds for reinforcement learning. Journal of Machine Learning Research, 11 1563–1600.   \n[15] Jin, C., Allen-Zhu, Z., Bubeck, S. and Jordan, M. I. (2018). Is Q-learning provably efficient? In Advances in Neural Information Processing Systems.   \n[16] Jin, C., Yang, Z., Wang, Z. and Jordan, M. I. (2019). Provably efficient reinforcement learning with linear function approximation. arXiv preprint arXiv:1907.05388.   \n[17] Kallus, N. and Zhou, A. (2018). Confounding-robust policy improvement. In Advances in Neural Information Processing Systems.   \n[18] Kallus, N. and Zhou, A. (2018). Policy evaluation and optimization with continuous treatments. arXiv preprint arXiv:1802.06037.   \n[19] Kober, J., Bagnell, J. A. and Peters, J. (2013). Reinforcement learning in robotics: Asurvey. International Journal of Robotics Research, 32 1238–1274.   \n[20] Lattimore, F., Lattimore, T. and Reid, M. D. (2016). Causal bandits: Learning good interventions via causal inference. In Advances in Neural Information Processing Systems.   \n[21] Levine, S., Kumar, A., Tucker, G. and Fu, J. (2020). Offline reinforcement learning: Tutorial, review, and perspectives on open problems. arXiv preprint arXiv:2005.01643.   \n[22] Li, C., Chan, S. H. and Chen, Y.-T. (2020). Who make drivers stop? Towards drivercentric risk assessment: Risk object identification via causal inference. arXiv preprint arXiv:2003.02425.   \n[23] Li, J., Monroe, W., Ritter, A., Galley, M., Gao, J. and Jurafsky, D. (2016). Deep reinforcement learning for dialogue generation. arXiv preprint arXiv:1606.01541.   \n[24] Liao, L., Fu, Z., Yang, Z., Kolar, M. and Wang, Z. (2021). Instrumental variable value iteration for causal offline reinforcement learning. arXiv preprint arXiv:2102.09907.   \n[25] Lu, C., Scholkopf, B. and Hern ¨ andez-Lobato, J. M. (2018). Deconfounding reinforcement ´ learning in observational settings. arXiv preprint arXiv:1812.10576.   \n[26] Lu, Y., Meisami, A., Tewari, A. and Yan, Z. (2019). Regret analysis of causal bandit problems. arXiv preprint arXiv:1910.04938.   \n[27] Manski, C. F. (1990). Nonparametric bounds on treatment effects. American Economic Review, 80 319–323.   \n[28] Munoz, I. D. and van der Laan, M. (2012). Population intervention causal effects based on ˜ stochastic interventions. Biometrics, 68 541–549.   \n[29] Murphy, S. A. (2003). Optimal dynamic treatment regimes. Journal of the Royal Statistical Society: Series B (Statistical Methodology), 65 331–355.   \n[30] Namkoong, H., Keramati, R., Yadlowsky, S. and Brunskill, E. (2020). Off-policy policy evaluation for sequential decisions under unobserved confounding. arXiv preprint arXiv:2003.05623.   \n[31] Osband, I., Van Roy, B. and Wen, Z. (2014). Generalization and exploration via randomized value functions. arXiv preprint arXiv:1402.0635.   \n[32] Pearl, J. (2009). Causality. Cambridge university press.   \n[33] Peters, J., Janzing, D. and Scholkopf, B. (2017). ¨ Elements of Causal Inference: Foundations and Learning Algorithms. MIT press.   \n[34] Sen, R., Shanmugam, K., Dimakis, A. G. and Shakkottai, S. (2017). Identifying best interventions through online importance sampling. In International Conference on Machine Learning.   \n[35] Shang, W., Yu, Y., Li, Q., Qin, Z., Meng, Y. and Ye, J. (2019). Environment reconstruction with hidden confounders for reinforcement learning based recommendation. In Proceedings of the 25th ACM SIGKDD International Conference on Knowledge Discovery & Data Mining.   \n[36] Silver, D., Huang, A., Maddison, C. J., Guez, A., Sifre, L., Van Den Driessche, G., Schrittwieser, J., Antonoglou, I., Panneershelvam, V., Lanctot, M. et al. (2016). Mastering the game of Go with deep neural networks and tree search. Nature, 529 484.   \n[37] Silver, D., Schrittwieser, J., Simonyan, K., Antonoglou, I., Huang, A., Guez, A., Hubert, T., Baker, L., Lai, M., Bolton, A. et al. (2017). Mastering the game of Go without human knowledge. Nature, 550 354.   \n[38] Tan, Z. (2006). A distributional approach for causal inference using propensity scores. Journal of the American Statistical Association, 101 1619–1637.   \n[39] Tennenholtz, G., Mannor, S. and Shalit, U. (2019). Off-policy evaluation in partially observable environments. arXiv preprint arXiv:1909.03739.   \n[40] Tennenholtz, G., Shalit, U. and Mannor, S. (2020). Off-policy evaluation in partially observable environments. In Proceedings of the AAAI Conference on Artificial Intelligence, vol. 34.   \n[41] Vershynin, R. (2010). Introduction to the non-asymptotic analysis of random matrices. arXiv preprint arXiv:1011.3027.   \n[42] Yang, L. and Wang, M. (2019). Sample-optimal parametric Q-learning using linearly additive features. In International Conference on Machine Learning.   \n[43] Yang, L. F. and Wang, M. (2019). Reinforcement leaning in feature space: Matrix bandit, kernels, and regret bound. arXiv preprint arXiv:1905.10389.   \n[44] Zhang, J. and Bareinboim, E. (2017). Transfer learning in multi-armed bandit: A causal approach. In Autonomous Agents and Multi-Agent Systems.   \n[45] Zhang, J. and Bareinboim, E. (2019). Near-optimal reinforcement learning in dynamic treatment regimes. In Advances in Neural Information Processing Systems. ",
+        "bbox": [
+            179,
+            489,
+            826,
+            914
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            171,
+            60,
+            828,
+            912
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            171,
+            87,
+            828,
+            622
+        ],
+        "page_idx": 11
+    }
+]