Add files using upload-large-folder tool

parse/train/B1lnbRNtwr/B1lnbRNtwr.md

@@ -0,0 +1,213 @@
+# GLOBAL RELATIONAL MODELS OF SOURCE CODE
+
+Vincent J. Hellendoorn, Petros Maniatis, Rishabh Singh, Charles Sutton, David Bieber Google Research {vhellendoorn,maniatis,rising,charlessutton,dbieber}@google.com
+
+# ABSTRACT
+
+Models of code can learn distributed representations of a program’s syntax and semantics to predict many non-trivial properties of a program. Recent state-ofthe-art models leverage highly structured representations of programs, such as trees, graphs and paths therein (e.g., data-flow relations), which are precise and abundantly available for code. This provides a strong inductive bias towards semantically meaningful relations, yielding more generalizable representations than classical sequence-based models. Unfortunately, these models primarily rely on graph-based message passing to represent relations in code, which makes them de facto local due to the high cost of message-passing steps, quite in contrast to modern, global sequence-based models, such as the Transformer. In this work, we bridge this divide between global and structured models by introducing two new hybrid model families that are both global and incorporate structural bias: Graph Sandwiches, which wrap traditional (gated) graph message-passing layers in sequential message-passing layers; and Graph Relational Embedding Attention Transformers (GREAT for short), which bias traditional Transformers with relational information from graph edge types. By studying a popular, non-trivial program repair task, variable-misuse identification, we explore the relative merits of traditional and hybrid model families for code representation. Starting with a graph-based model that already improves upon the prior state-of-the-art for this task by $20 \%$ , we show that our proposed hybrid models improve an additional $1 0 { - } 1 5 \%$ , while training both faster and using fewer parameters.
+
+# 1 INTRODUCTION
+
+Well-trained models of source code can learn complex properties of a program, such as its implicit type structure (Hellendoorn et al., 2018), naming conventions (Allamanis et al., 2015), and potential bugs and repairs (Vasic et al., 2019). This requires learning to represent a program’s latent, semantic properties based on its source. Initial representations of source code relied on sequential models from natural-language processing, such as $n$ -gram language models (Hindle et al., 2012; Allamanis & Sutton, 2013; Hellendoorn & Devanbu, 2017) and Recurrent Neural Networks (RNNs) (White et al., 2015), but these models struggle to capture the complexity of source code.
+
+Source code is rich in structured information, such as a program’s abstract syntax tree, data and control flow. Allamanis et al. (2018b) proposed to model some of this structure directly, providing a powerful inductive bias towards semantically meaningful relations in the code. Their Gated Graph Neural Network (GGNN) model for embedding programs was shown to learn better, more generalizable representations faster than classical RNN-based sequence models.
+
+However, the debate on effective modeling of code is far from settled. Graph neural networks typically rely on synchronous message passing, which makes them inherently local, requiring many iterations of message passing to aggregate information from distant parts of the code. However, state-of-the-art graph neural networks for code often use as few as eight message-passing iterations (Allamanis et al., 2018b; Fernandes et al., 2018), primarily for computational reasons: program graphs can be very large, and training time grows linearly with the number of message passes. This is in contrast to, e.g., Transformer models (Vaswani et al., 2017), which allow program-wide information flow at every step, yet lack the powerful inductive bias from knowing the code’s structure.
+
+This leads us to a basic research question: is there a fundamental dichotomy between global, unstructured and local, structured models? Our answer is an emphatic no. Our starting point is the sequence-to-pointer model of Vasic et al. (2019), which is state-of-the-art for the task of localizing and repairing a particular type of bug. As a sequence model, their architecture can (at least potentially) propagate information globally, but it lacks access to the known semantic structure of code. To this end, we replace the sequence encoder of Vasic et al. (2019) with a GGNN, yielding a new graph-to-mutlihead-pointer model. Remarkably, this model alone yields a $2 0 \%$ improvement over the state of the art, though at the cost of being significantly larger than the sequence model.
+
+Motivated by this result, we propose two new families of models that efficiently combine longerdistance information, such as the sequence model can represent, with the semantic structural information available to the GGNN. One family, the Graph Sandwich, alternates between message passing and sequential information flow through a chain of nodes within the graph; the other, the Graph Relational Embedding Attention Transformer (GREAT), generalizes the relative position embeddings in Transformers by Shaw et al. (2018) to convey structural relations instead. We show that our proposed model families outperform all prior results, as well as our new, already stronger baseline by an additional $10 \%$ each, while training both substantially faster and using fewer parameters.
+
+# 2 RELATED WORK
+
+Distributed Representation of Programs: There has been increasing interest in modeling source code using machine learning (Allamanis et al., 2018a). Hindle et al. (2012) model programs as sequences of tokens and use an $n$ -gram model for predicting code completions. Raychev et al. (2015) use conditional random fields (CRFs) to predict program properties over a set of pairwise program features obtained from the program’s dependency graph. Many approaches use neural language models to embed programs as sequences of tokens (Bhoopchand et al., 2016; White et al., 2015). Some techniques leverage the ASTs of programs in tree-structured recurrent models (Piech et al., 2015; Parisotto et al., 2016; Chen et al., 2018). code2vec (Alon et al., 2018) and code2seq (Alon et al., 2019) model programs as a weighted combination of a set of leaf-to-leaf paths in the abstract syntax tree. Finally, Allamanis et al. (2018b) proposed using GGNNs for embedding program graphs consisting of ASTs together with control-flow and data-flow edges. Some recent models of code embed run-time information of programs, e.g., program traces, besides syntactic information (Wang et al., 2018). In this paper, we explore the space of combining sequence-based and graph-based representations of programs, as well as introduce a Transformer-based model with additional program-edge information to learn program representations. Fernandes et al. (2018) also combine an RNN and a GNN architecture, achieving slight improvements over a GGNN. However, they only consider a single RNN layer inserted at the start; we include larger and more diverse hybrids, as well as entirely different combinations of structural and sequential features.
+
+Neural Program Repair: Automatically generating fixes to repair program bugs is an active field of research with many proposed approaches based on genetic programming, program analysis and formal methods, and machine learning (Monperrus, 2018; Gazzola et al., 2019). In this paper, we focus on a specific class of repair task called VarMisuse as proposed by Allamanis et al. (2018b), who use a graph-based embedding of programs to predict the most likely variable at each variable-use location and generate a repair prediction whenever the predicted variable is different from the one present, using an enumerative approach. Vasic et al. (2019) improved this approach by jointly predicting both the bug and repair locations using a two-headed pointer mechanism. Our multi-headed pointer graph, graph-sandwich and GREAT models significantly outperform these approaches.
+
+# 3 SEMI-STRUCTURED MODELS OF SOURCE CODE
+
+Models of code have so far either been structured (GNNs) or unstructured (RNNs, Transformers). Considering the graph-based models’ substantially superior performance compared to RNNs despite their locality limitations, we may ask: to what extent could global information help GNNs, and to what extent could structural features help sequence-based models?
+
+# 3.1 MODELS
+
+We address the questions of combining local and global information with two families of models.
+
+Graph-sandwich Models Let $T = \langle t _ { 1 } , t _ { 2 } , \cdot \cdot \cdot , t _ { n } \rangle$ denote a program’s token sequence and $\mathcal { G } =$ $( \nu , \mathcal { E } )$ denote the corresponding program graph, where $\nu$ is the set of node vertices and $\mathcal { E }$ is the list of edge sets for different edge types. In both graph and sequence based models, the nodes $v$ maintain a state vector $h ^ { ( v ) }$ that is initialized with initial node embedding $\boldsymbol { x } ^ { ( v ) } \in \mathbb { R } ^ { D }$ .
+
+In a GGNN layer, messages of type $k$ are sent from each node $v \in \mathcal V$ to its neighbors computed as mk $m _ { k } ^ { ( v ) } = \mathrm { L i n e a r L a y e r } _ { k } ( h ^ { ( v ) } )$ . After the message passing step, the set of messages at each node are aggregated as $\begin{array} { r } { m ^ { ( v ) } \ = \ \Sigma _ { e _ { k } ( u , v ) \in \mathcal { E } } \ m _ { k } ^ { ( u ) } } \end{array}$ Finally, the state vector of a node $v$ is updated as $h _ { \mathrm { n e w } } ^ { ( v ) } = \mathrm { G R U } ( m ^ { ( v ) } , h ^ { ( v ) } )$ . In aated as e of a node . A Transfo $v$ (correspondmer compute l, $t _ { i }$ $T$ $h _ { \mathrm { n e w } } ^ { ( v ) } = f ( t _ { v } , h ^ { ( t _ { i - 1 } ) } )$ $t _ { v }  \mathbf { q _ { t } } , \mathbf { k _ { t } } , \mathbf { v _ { t } }$ corresponding to a query, key and value for each token.1 Each token then computes its attention to√ all other tokens using $e _ { i j } = ( { \bf q _ { i } } { \bf k _ { j } } ^ { \top } ) / \sqrt { N } ,$ 2 which can be soft-maxed to yield attention probabilities $a _ { i j } = \exp ( e _ { i j } ) / \Sigma \exp ( \bar { e } _ { i , : } )$ .
+
+Our first class of models follows from the observation that $T \subseteq V$ ; i.e., the source code tokens used by sequence models, like RNNs, are by definition also nodes in the program graph, so GGNNs update their state with every message pass. We can thus envision a combined model that uses each of these as a building block; for instance, assuming initial node features $\boldsymbol { x } ^ { ( v ) } \in \mathbb { R } ^ { D }$ , the formula [RNN, GGNN(3), RNN] describes a model in which we first run an RNN on all tokens $\in \mathcal { T }$ (in lexical ordering), then, using these as initial states for $v \in T$ while using the default node-type embeddings for all other nodes, run three message passing steps using a GGNN, after which we again gather the nodes corresponding to $T$ and update their state with an additional RNN pass.
+
+The resulting family of models alternates GGNN-style message passing operations and layers of sequence-based models. By varying the number and size of sequential layers and blocks of GGNNstyle message passing, this variant particularly provides insight into the first question above (how can global information help GNNs?), by showing the transition in performance potential of models that increasingly incorporate sequential features. We refer to this class of models as sandwich models.
+
+Graph Relational Embedding Attention Transformer The above family of models still rely on explicit message passing for their structural bias, thereby only indirectly combining structural and global information to the model. We may wish to instead directly encode structural bias into a sequence-based model, which requires a relaxation of the ‘hard’ inductive bias from the GGNN. For Transformer-based architectures, Shaw et al. (2018) show that relational features can be incorporated directly into the attention function by changing the attention computation to:3√ $e _ { i j } = ( { \bf q _ { i } } + b _ { i j } ) { { \bf k _ { j } } ^ { \top } } / \sqrt { N }$ where ${ \bf q _ { i } }$ and $\mathbf { k _ { j } }$ correspond to the query and key vectors as described above, $b _ { i j }$ is an added bias term for the specific attention weight between tokens $i$ and $j$ , and $N$ is the per-head attention dimension. In our case, we compute $b _ { i j } = W _ { e } ^ { \top } { \mathbf e } + b _ { e }$ , where $W _ { e } \in \mathbb { R } ^ { N } , b _ { e } \in \mathbb { R }$ , and $\mathbf { e } \in \mathbb { R } ^ { N }$ is an embedding of the edge type connecting nodes $i$ and $j$ , if any. If multiple edge types are present between two nodes, the resulting biases are simply added. We name this model GREAT, for Graph Relational Embedding Attention Transformer.
+
+# 3.2 ARCHITECTURAL DETAILS
+
+In this section, we present details of different architectures we compare and their hyperparameters.
+
+General: All of our models follow the structure proposed by Vasic et al. (2019), stacking an initial token-embedding layer, a ‘core’ model that computes a distributed representation of the code under inspection (in their case, an LSTM), followed by a projection into two pointers for the localization and repair tasks (see Section 4). This core model is the part varied in our work. We use
+
+SubwordTextEncoder from Tensor2Tensor (Vaswani et al., 2018) to generate a 10K sub-token vocabulary from training data and embed each token by averaging embeddings of its sub-token(s).
+
+GGNN: Many types of graph-based message-passing neural networks have been proposed for code, mostly differing in how a node’s state is updated based on ‘messages’ sent by nodes it is connected to. Most commonly used is the gated graph neural network (GGNN) (Li et al., 2015), which uses a GRU cell (Cho et al., 2014) to update a node’s state. Although other options sometimes outperform this architecture, the improvements are generally minor, so we rely on this model for our baseline. One hyperparameter of the architecture is whether to use different transformations at each message-passing step, or to reuse one set of transformations for multiple message passes. Following Allamanis et al. (2018b), we use blocks of two message-passing layers, in which the first layer is repeated three times, for four message passes per block. We then sweep over GGNN architectures that repeat these blocks 1 to 4 times (thus yielding 4 to 16 message passes). By default, the message dimension is set to 128, but we include an ablation with 256-dimensional messages as well.
+
+RNNs: We experimented with the one-directional entailment-attention-based RNN proposed by Vasic et al. (2019), but found a simpler bi-directional RNN architecture to work even better. We use GRUs as the recurrent cells, vary the number of layers from 1 to 3, and the hidden dimension (of the concatenated forward and backward component) in $\{ 1 2 8 , 2 5 6 , 5 1 2 \}$ .
+
+Transformers: We base our architecture on the original Transformer (Vaswani et al., 2017), varying the number of layers from 1 to 10 and the attention dimension in $\{ 1 2 8 , 2 5 6 , 5 1 2 , 1 0 2 4 \}$ .
+
+Sandwich Models: We distinguish between two types of sandwich models: ‘small’ sandwiches, which add a single RNN or Transformer to a GGNN architecture, and ‘large’ sandwiches, which wrap every message-passing block (as defined above) with a 128-dimensional (bi-directional) RNN/Transformer layer. We vary the number of message-passing blocks from 1 to 3 (corresponding to 4 to 12 message passes) to span a similar parameter domain as the GGNNs above (ca. $1 . 5  { \mathbf { M } } -$ 5M), increasing the number of layers to 2 and their dimension to 512 for a later ablation.
+
+GREAT: Uses the same architectural variations as the Transformer family; edge-type embedding dimensions are fixed at the per-head attention dimension, as described above.
+
+Global hyper-parameters: We train most of our models with batch sizes of $\{ 1 2 . 5 \mathrm { K } , 2 5 \mathrm { K } , 5 0 \mathrm { K } \}$ tokens, with the exception of the Transformer architectures; due to the quadratic nature of the attention computation, 25K tokens was too large for these models, so we additionally trained these with 6.25K-token batches.4 Learning rates were varied in $\left\{ 1 \mathrm { e } { - } 3 , 4 \mathrm { - } \mathrm { e } 4 , 1 \mathrm { e } { - } 4 , 4 \mathrm { e } { - } 5 , 1 \mathrm { e } { - } 5 \right\}$ using an Adam optimizer, where we omitted the first option for our GGNN models and the last for our RNNs due to poor performance. Sub-tokens were embedded using 128-dimensional embeddings.
+
+Hardware: all our models were trained on a single Tesla P100 GPU on 25 million samples, which required between 40 and 250 hours for our various models. However, we emphasize that overall training time is not our main objective; we primarily assess the ultimated converged accuracy of our models and present training behavior over time for reference of our various models’ training behavior.
+
+# 3.3 ABOUT GRAPH REPRESENTATIONS OF CODE
+
+Our program graphs borrow many edge types from Allamanis et al. (2018b), such as data-flow (e.g., read & write), adjacent-token, and syntactic edges, which we further augment with edges between control-flow statements and function calls. When representing programs as graphs, a key decision needs to be made regarding the Abstract Syntax Tree (AST). Typically, one of the edge types in the graphs represents syntactic parent-child relationships in the AST. Additionally, some of the edges representing relations (e.g., control-flow) are naturally represented as edges between internal nodes in this tree, e.g., between two IfStatement nodes. However, ablations often find that the effectiveness of including the AST is limited in graph-based models (Allamanis et al., 2018b).
+
+This raises the question of whether it is possible to represent programs as graphs that include sequential and semantic information, but not syntax. To this end, we propose a leaves-only graph representation for code as follows: edges that represent semantic relationships such as control flow and data flow can easily be moved down from internal nodes – which typically represent a span of multiple tokens – to those leaf nodes in the graph that represent the begin token of that span. Thus, an edge that used to connect two IfStatement interior AST nodes is moved down to connect the corresponding if tokens. Now, the AST can be omitted entirely, thereby removing parent-child relations among syntax nodes, producing what we call a leaves-only graph. This latter representation is substantially more compressed than the graphs with ASTs, often using $2 { - } 3 \mathbf { x }$ fewer nodes (while retaining most of the edges), and additionally aligns better with sequence-based models, because all edges are directly connected to the original code tokens.5 We compare both settings for each graph-based model, but unless otherwise specified, we use the ‘full’ graphs for the regular GGNN model and the ‘leaves-only’ graphs (without ASTs) for the sandwich and GREAT models.
+
+# 4 EXPERIMENTAL SETUP
+
+The VarMisuse Task We focus our study on the variable-misuse localization-and-repair task (Vasic et al., 2019): given a function, predict two pointers into the function’s tokens, one pointer for the location of a variable use containing the wrong variable (or a special no-bug location), and one pointer for any occurrence of the correct variable that should be used at the faulty location instead.
+
+Synthetic Dataset We used the ETH Py150 dataset (Raychev et al., 2016), which is based on GitHub Python code, and already partitioned into train and test splits (100K and 50K files, respectively). We further split the 100K train files into 90K train and 10K validation examples and applied a deduplication step on that dataset (Allamanis, 2018). We extracted all top-level function definitions from these files; any function that uses multiple variables can be turned into a training example by randomly replacing one variable usage with another. As there may be many candidates for such bugs in a function, we limit our extraction to up to three samples per function to avoid biasing our dataset too strongly towards longer functions. For every synthetically generated buggy example, an unperturbed, bug-free example of the function is included as well, to keep our dataset balanced, yielding ca. 2M total training and 755K test samples. Finally, we train with functions with up to 250 tokens; at test time, we raise this to 1,000 to study our models’ generalization to longer functions.
+
+Metrics As we are mainly interested in contrasting the behavior of different models of code, we focus most of our results on the various models’ learning curves by tracking development-set accuracy on 25K held-out samples every 250K samples as the models train. Here, we measure two accuracy metrics: localization accuracy (whether the model correctly identifies the bug’s location for buggy samples); and (independently) repair accuracy (whether the model points to the correct variable to repair the bug). Note that these metrics focus on buggy samples; the models also determine whether a function is buggy, which we discuss below. We group all models by their ‘family’, as categorized in Section 3.2, reporting the maximum held-out performance per family.
+
+For deeper insight into the fully trained models’ performance, we also analyze the performance of the best models in each family in more depth on the test portion of our synthetic dataset. Specifically, we assess their bugginess-classification accuracy (whether the model correctly identifies the method as (non-)buggy) and their joint localization and repair accuracy (for buggy samples, how often the model correctly localizes and repairs the bug). Here, we also increase the maximum function size to 1,000 tokens and analyze the impact of longer functions on our models’ performance.
+
+# 4.1 DATA & CODE RELEASE
+
+We release a public implementation of the GREAT model based on Tensorflow, as well as the program graphs for all samples in our training and evaluation datasets whose license permits us to redistribute these at: https://doi.org/10.5281/zenodo.3668323, which tracks the latest release of our Github repository at: https://github.com/VHellendoorn/ ICLR20-Great.
+
+# 5 RESULTS
+
+There are many degrees of freedom in our family of models, so we structure our results around a series of comparisons, which we analyze and discuss in this section. We start with our key result, which compares all our model families (RNNs, Transformers, GGNNs, Sandwich hybrids, and GREAT models) across a comparable parameter domain (ca. 1.4M – 5.5M parameters) in Figure 1.
+
+![](images/96061ba572ebf13a72a349a63a2a4c26ec4970bd22d2b93d03adfbc9020773de.jpg)  
+Figure 1: Comparison of top-performing models from all model families across a comparable parameter domain of $1 . 5 \mathrm { M } - 5 \mathrm { M }$ parameters. Performance visualized using the localization (left) and repair (right) accuracy Pareto fronts w.r.t. both training time (top) and number of training samples seen (bottom), both log-scaled, where an epoch is ca. 2M samples. In all cases, our proposed models substantially outperform GGNNs from early in the training process.
+
+Although there are subtle differences between the models’ behavior on localization and repair accuracy, the overall picture is consistent: whereas our newly proposed graph-to-multihead-pointer models already substantially outperform RNN-based models (the previous state-of-the-art), and sometimes Transformers, the hybrid global & structured models achieve significantly better results faster.
+
+Time-wise (the top two figures), the GGNN models take the longest to converge, continuing to improve slightly even after a week of training mainly because their largest (16-layer) architecture starts to dominate the 12-layer version’s performance after ca. 170h. The Sandwich models follow its training curve, but are more accurate and faster to converge, achieving especially good results for limited training budgets, partly because they succeeded with just 4 – 8 layers of message passing by relying on their global components.
+
+The Transformer architecture, although slower at first, widely outperforms the RNN as a baseline model. The GREAT model tracks its learning curve, starting out slower than the models with explicit message passing, but gradually overtaking them after ca. 10h, as the underlying Transformer becomes increasingly effective. We note that this model achieves state-of-the-art results despite having, at the time of this writing, received less training time (ca. 64h compared to up to 240h).
+
+The bottom half of Figure 1 abstracts away the potentially confounding issue of implementation speed of our models by tracking performance w.r.t the number of training samples. Naturally, the end-points of the curves (the converged accuracy) are identical, but importantly the various models’ training curves are quite similar; even here, the GGNN is only able to outperform some of our proposed models briefly, yielding inferior performance to all within just one epoch.
+
+The RNN and GGNN models appear to be particularly complementary; even though the RNN’s localization accuracy is very poor compared to the GGNN, the combined model still sustains a ${ \sim } 5 \%$ improvement on the latter.6 However, the Transformer Sandwich does not seem to benefit similarly, showing virtually no difference in performance with the RNN Sandwich model. This strongly suggests that the Transformer’s ability to access long-distance information overlaps in large part (though not entirely, given GREAT’s performance) with the GGNNs’ ability to do so using message passing. We conjecture that the Transformer learns to infer many of the same connections (e.g., data-flow, control-flow) that are encoded explicitly in the graph’s message passing.
+
+To understand the behavior of the many models and combinations that may be used for code, we now explore the variations on our choices of parameters, models, and metrics.
+
+# 5.1 LARGER MODELS
+
+Model capacity is a potential threat to any comparison between models of different families. We aimed to ensure a fair comparison in the previous section by selecting a range of hyper-parameters (which includes the number of stacked layers) for these architectures that span a similar parameter count range. For instance, a 6-layer Transformer with 512-dimensional attention is comparable to a 2-layer 512-dimensional bi-directional RNN and an 8-layer GGNN. However, all these architectures are relatively modest, having at most ${ \sim } 5 \mathbf { M }$ parameters. By increasing the number, and dimensionality of their layers, we can evaluate a second family of models with ca. 5–20M parameters.
+
+Figure 2 shows the performance for the low- and high-parameter variations for each of our bestperforming model families. Overall, while providing more parameters to the GGNNs made virtually no difference, all our hybrid models increase $2 - 3 \%$ in both localization and repair accuracy, providing further support for combining global, structured models. The best-performing instances of each model family were consistently the larger architectures, 15M parameters for the GGNN, 12.5M & 10M for the RNN and Transformer Sandwiches respectively and 7.9M for GREAT.7
+
+![](images/891bb76b8b22cc3f22d8d35865dbfce9b0f0a82d9df045cca8830b19b5be6265.jpg)  
+Figure 2: Comparison of smaller (1.5–5M parameter) and larger (5–20M parameter, identified with $\cdot _ { + + } ,$ variants of each model family. Localization and repair accuracy Pareto-front w.r.t. time.
+
+# 5.2 ON SYNTACTIC INFORMATION
+
+In the previous results, the GGNN models were trained on ‘full’ graphs (as described in Section 3.3), that use the code’s AST structure, and the sandwich models on ‘leaves-only’ graphs, with only source token nodes, and edges moved to connect these directly. These settings are arguably each appropriate to the underlying model, but both models can also use the alternative setting.
+
+![](images/a820488f09223f97e60319c333a9fc46ccb028312e07b0032199bdaa49aa909f.jpg)  
+Figure 3: Comparing impact of graph representation on GGNNs and RNN Sandwich models. Localization and repair accuracy Pareto-front w.r.t time. Note: y-axis cropped to simplify comparison.
+
+Figure 3 shows the training curves for the alternative settings. In all cases, the models that do not use syntax train substantially faster because each sample’s graph representation is more than twice as small, so these models naturally lead in accuracy early on in training. However, whereas the GGNN equipped with syntax overtakes its counter-part within ca. 48h, the sandwich models display a much longer lag, with no cross-over observed at all on localization accuracy in this time window.8
+
+The sandwich model on full graphs still compares favorably with the GGNN baseline, though its early training behavior is not as effective. It is also interesting to note that the best-performing Sandwich models in this setting were consistently architectures with more message-passing steps. This may be due to the additional distance between information propagated along the tokens and along semantic edges, which in this setting are almost universally connected to AST-internal nodes.
+
+# 5.3 RNNS IN SANDWICHES: SINGLE VS. MANY
+
+Recent work on neural summarization also mixed RNNs and GGNNs (Fernandes et al., 2018), but did so by inserting a single RNN layer into a GNN architecture, before any message passing. We compare this architecture to a full Sandwich model in Figure 4. Although a single RNN certainly helps compared to the GGNN, interleaving RNNs and GGNN-style message passes performed substantially better. In fact, the best performing full Sandwiches used fewer parameters than the Single models because they used 8 message passes instead of 12, relying more heavily on the RNNs.9
+
+# 5.4 TEST-SET ANALYSIS
+
+Having identified our best-performing models in each family, we now study their performance on the test data, specifically using the metrics used in Vasic et al. (2019) (see Section 4) in Table 1. In general, the two metrics correlated well; models that accurately determined whether a function contained a bug also accurately identified the bug (and repair), as may be expected. The baseline RNN model achieves a modest $44 \%$ accuracy at the latter task; this is slightly lower than reported in prior work (Vasic et al., 2019), which is likely due in part to our dataset de-duplication. Transformers and GGNNs perform substantially better (and comparably, though the latter trained 6x longer for this performance), but still fall well short of our hybrid models’ performance, which are especially much more accurate on long functions. The GREAT model shows most promise on the repair task, already outperforming the sandwich models despite having so far had limited training time.
+
+![](images/4e04d6ea7dd5bfb2ef01a6dfd6d452ab0dbf57732e286b392cbf2337a905571b.jpg)  
+Figure 4: Comparison of RNN sandwiches with a single RNN vs. those with RNNs around every message-passing block (‘Multi’). Localization and repair accuracy Pareto-front w.r.t. time.
+
+Table 1: Test-set results of best-performing models by family, on metrics of Vasic et al. (2019). Grouped by maximum length; $6 . 5 \%$ of test set samples exceeded 250 tokens (the training limit).   
+
+<table><tr><td rowspan=1 colspan=4>Model Family</td><td rowspan=1 colspan=1>Class. Accuracy≤ 250  ≤1000</td><td rowspan=1 colspan=1>Loc &amp; Rep Accuracy≤ 250  ≤1000</td><td rowspan=1 colspan=1>Parameters</td><td rowspan=1 colspan=1>TrainingTime</td></tr><tr><td rowspan=1 colspan=4>RNN1</td><td rowspan=1 colspan=1>71.8%  70.6%</td><td rowspan=1 colspan=1>44.4%  42.5%</td><td rowspan=1 colspan=1>4.3M</td><td rowspan=1 colspan=1>31.3h</td></tr><tr><td rowspan=3 colspan=4>TransformerGGNN</td><td rowspan=1 colspan=1>75.9%  73.2%</td><td rowspan=1 colspan=1>67.7%  63.0%</td><td rowspan=1 colspan=1>3.7M</td><td rowspan=1 colspan=1>41.5h</td></tr><tr><td rowspan=1 colspan=2></td><td rowspan=1 colspan=2>GGNN</td><td rowspan=1 colspan=1>81.4%  79.2%</td><td rowspan=1 colspan=1>64.0%  60.9%</td><td rowspan=1 colspan=1>5.5M</td><td rowspan=1 colspan=1>241h</td></tr><tr><td rowspan=2 colspan=4>RNN Sandwich</td><td></td><td></td><td></td><td></td></tr><tr><td rowspan=1 colspan=1>82.5%  81.9%</td><td rowspan=1 colspan=1>75.8%  73.8%</td><td rowspan=1 colspan=1>12.6M</td><td rowspan=1 colspan=1>109h</td></tr><tr><td rowspan=1 colspan=4>Transformer Sandwich</td><td rowspan=1 colspan=1>81.1%  78.1%</td><td rowspan=1 colspan=1>74.5%  71.4%</td><td rowspan=1 colspan=1>10M</td><td rowspan=1 colspan=1>161h</td></tr><tr><td rowspan=1 colspan=4>GREAT</td><td rowspan=1 colspan=1>80.1%  76.9%</td><td rowspan=1 colspan=1>76.4%  73.1%</td><td rowspan=1 colspan=1>7.9M</td><td rowspan=1 colspan=1>120h</td></tr></table>
+
+1: a stronger version of the model proposed in Vasic et al. (2019) (previous SOTA).
+
+# 5.5 REAL BUGS ANALYSIS
+
+We want to ensure that our models can be useful for real bugs and do not simply overfit to the synthetic data generation that we used. This risk exists because we did not filter our introduced bugs based on whether they would be difficult to detect, for instance because they conflate variables with similar names, usage, or data types; presumably, such bugs are more likely to escape a developer’s notice and find their way into real code bases. It is therefore expected that performance on realworld bugs will be lower for all our models, but we must assert that our proposed models do not just outperform GGNNs on synthetic data, e.g. by memorizing characteristics of synthetic bugs.
+
+To mitigate this threat, we collect real variable misuse bugs from code on Github. Specifically, we collect ca. 1 million commits that modify Python files from Github. We extracted all changes to functions from these commits, filtering these according to the same criteria that we used to introduce variable-misuse bugs: we looked for commits that exclusively changed a single variable usage in a function body from one variable in scope to another. We focus on functions with up to 250 tokens, since all our models performed substantially better on these in Table 1. We identified 170 such changes, in which we assumed that the version before the change was buggy and the updated version correct. We removed any functions that had occurred in our training data, of which we found 9 and paired the remaining functions up (correct and buggy) to create a real-world evaluation set with 322 functions, which we presented to our models.
+
+Table 2 shows the results of running our various models on these bugs. In general, these were clearly substantially more difficult for all our models than the synthetic samples we generated. However, we see a clear difference in performance with all our proposed models performing substantially better than previous baselines, and showing favorable precision/recall trade-offs.
+
+Table 2: Results on 322 paired buggy and non-buggy samples from 161 real variable misuse bugs mined from Github commits. ‘Class.’ measures accuracy at identifying non-buggy samples; ‘Prec.’ and ‘Rec.’ capture the precision and recall at identifying the correct localization and repair on the buggy samples.   
+
+<table><tr><td>Model Family</td><td colspan="2"> All Samples</td><td>Precision at Recall = 5%</td><td>Precision at Recall = 10%</td></tr><tr><td>RNN</td><td>Class. Prec. 52.8% 13.3%</td><td>Rec. 46.6%</td><td>44.4%</td><td>23.5%</td></tr><tr><td>Transformer</td><td>62.1% 15.8%</td><td>47.2%</td><td>33.3%</td><td>17.6%</td></tr><tr><td>GGNN</td><td>65.8% 17.7%</td><td>42.2%</td><td>44.4%</td><td>23.5%</td></tr><tr><td>RNN Sandwich</td><td>69.6% 28.6%</td><td>43.5%</td><td>77.8%</td><td>64.7%</td></tr><tr><td>Trans.Sandwich</td><td>75.2% 21.5%</td><td>40.4%</td><td>33.3%</td><td>35.3%</td></tr><tr><td>GREAT</td><td>70.2% 23.7%</td><td>36.7%</td><td>44.4%</td><td>29.4%</td></tr></table>
+
+# 6 CONCLUSION
+
+We demonstrate that models leveraging richly structured representations of source code do not have to be confined to local contexts. Instead, models that leverage only limited message passing in combination with global models learn much more powerful representations faster. We proposed two different architectures for combining local and global information: sandwich models that combine two different message-passing schedules and achieve highly competitive models quickly, and the GREAT model which adds information from a sparse graph to a Transformer to achieve stateof-the-art results. In the process, we raise the state-of-the-art performance on the VarMisuse bug localization and repair task by over $30 \%$ .
+
+# REFERENCES
+
+Miltiadis Allamanis. The adverse effects of code duplication in machine learning models of code. CoRR, abs/1812.06469, 2018. URL http://arxiv.org/abs/1812.06469.
+
+Miltiadis Allamanis and Charles Sutton. Mining source code repositories at massive scale using language modeling. In Working Conference on Mining Software Repositories (MSR), 2013.
+
+Miltiadis Allamanis, Earl T Barr, Christian Bird, and Charles Sutton. Suggesting accurate method and class names. In Proceedings of the 2015 10th Joint Meeting on Foundations of Software Engineering, pp. 38–49. ACM, 2015.
+
+Miltiadis Allamanis, Earl T. Barr, Premkumar Devanbu, and Charles Sutton. A survey of machine learning for big code and naturalness. ACM Comput. Surv., 51(4):81:1–81:37, July 2018a. ISSN 0360-0300.
+
+Miltiadis Allamanis, Marc Brockschmidt, and Mahmoud Khademi. Learning to represent programs with graphs. In International Conference on Learning Representations, 2018b.
+
+Uri Alon, Meital Zilberstein, Omer Levy, and Eran Yahav. code2vec: Learning distributed representations of code. CoRR, abs/1803.09473, 2018.
+
+Uri Alon, Shaked Brody, Omer Levy, and Eran Yahav. code2seq: Generating sequences from structured representations of code. In 7th International Conference on Learning Representations, ICLR 2019, New Orleans, LA, USA, May 6-9, 2019, 2019.
+
+Avishkar Bhoopchand, Tim Rocktaschel, Earl Barr, and Sebastian Riedel. Learning python code ¨ suggestion with a sparse pointer network. arXiv preprint arXiv:1611.08307, 2016.
+
+Xinyun Chen, Chang Liu, and Dawn Song. Tree-to-tree neural networks for program translation. In S. Bengio, H. Wallach, H. Larochelle, K. Grauman, N. Cesa-Bianchi, and R. Garnett (eds.), Advances in Neural Information Processing Systems 31, pp. 2547–2557. Curran Associates, Inc., 2018. URL http://papers.nips.cc/paper/ 7521-tree-to-tree-neural-networks-for-program-translation.pdf.
+
+Kyunghyun Cho, Bart Van Merrienboer, Caglar Gulcehre, Dzmitry Bahdanau, Fethi Bougares, Hol- ¨ ger Schwenk, and Yoshua Bengio. Learning phrase representations using rnn encoder-decoder for statistical machine translation. arXiv preprint arXiv:1406.1078, 2014.
+
+Patrick Fernandes, Miltiadis Allamanis, and Marc Brockschmidt. Structured neural summarization. arXiv preprint arXiv:1811.01824, 2018.
+
+Luca Gazzola, Daniela Micucci, and Leonardo Mariani. Automatic software repair: A survey. IEEE Trans. Software Eng., 45(1):34–67, 2019.
+
+Vincent J Hellendoorn and Premkumar Devanbu. Are deep neural networks the best choice for modeling source code? In Proceedings of the 2017 11th Joint Meeting on Foundations of Software Engineering, pp. 763–773. ACM, 2017.
+
+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, pp. 152–162. ACM, 2018.
+
+Abram Hindle, Earl T. Barr, Zhendong Su, Mark Gabel, and Premkumar Devanbu. On the naturalness of software. In Proceedings of the 34th International Conference on Software Engineering, ICSE ’12, pp. 837–847, 2012.
+
+Yujia Li, Daniel Tarlow, Marc Brockschmidt, and Richard Zemel. Gated graph sequence neural networks, 2015.
+
+Martin Monperrus. Automatic software repair: A bibliography. ACM Comput. Surv., 51(1):17:1– 17:24, January 2018. ISSN 0360-0300.
+
+Emilio Parisotto, Abdel-rahman Mohamed, Rishabh Singh, Lihong Li, Dengyong Zhou, and Pushmeet Kohli. Neuro-symbolic program synthesis. CoRR, abs/1611.01855, 2016. URL http: //arxiv.org/abs/1611.01855.
+
+Chris Piech, Jonathan Huang, Andy Nguyen, Mike Phulsuksombati, Mehran Sahami, and Leonidas Guibas. Learning program embeddings to propagate feedback on student code. In Proceedings of the 32Nd International Conference on International Conference on Machine Learning - Volume 37, ICML’15, pp. 1093–1102, 2015.
+
+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, 2015.
+
+Veselin Raychev, Pavol Bielik, and Martin T. Vechev. Probabilistic model for code with decision trees. In Proceedings of the 2016 ACM SIGPLAN International Conference on Object-Oriented Programming, Systems, Languages, and Applications, OOPSLA 2016, part of SPLASH 2016, Amsterdam, The Netherlands, October 30 - November 4, 2016, pp. 731–747, 2016.
+
+Peter Shaw, Jakob Uszkoreit, and Ashish Vaswani. Self-attention with relative position representations. arXiv preprint arXiv:1803.02155, 2018.
+
+Marko Vasic, Aditya Kanade, Petros Maniatis, David Bieber, and Rishabh Singh. Neural program repair by jointly learning to localize and repair. arXiv preprint arXiv:1904.01720, 2019.
+
+Ashish Vaswani, Noam Shazeer, Niki Parmar, Jakob Uszkoreit, Llion Jones, Aidan N Gomez, Łukasz Kaiser, and Illia Polosukhin. Attention is all you need. In Advances in neural information processing systems, pp. 5998–6008, 2017.
+
+Ashish Vaswani, Samy Bengio, Eugene Brevdo, Franc¸ois Chollet, Aidan N. Gomez, Stephan Gouws, Llion Jones, Lukasz Kaiser, Nal Kalchbrenner, Niki Parmar, Ryan Sepassi, Noam Shazeer, and Jakob Uszkoreit. Tensor2tensor for neural machine translation. In Proceedings of the 13th Conference of the Association for Machine Translation in the Americas, AMTA 2018, Boston, MA, USA, March 17-21, 2018 - Volume 1: Research Papers, pp. 193–199, 2018. URL https://www.aclweb.org/anthology/W18-1819/.
+
+Ke Wang, Rishabh Singh, and Zhendong Su. Dynamic neural program embeddings for program repair. In 6th International Conference on Learning Representations, ICLR 2018, Vancouver, BC, Canada, April 30 - May 3, 2018, Conference Track Proceedings, 2018.
+
+Martin White, Christopher Vendome, Mario Linares-Vasquez, and Denys Poshyvanyk. Toward ´ deep learning software repositories. In Proceedings of the 12th Working Conference on Mining Software Repositories, pp. 334–345. IEEE Press, 2015.

parse/train/B1lnbRNtwr/B1lnbRNtwr_content_list.json

@@ -0,0 +1,1203 @@
+[
+    {
+        "type": "text",
+        "text": "GLOBAL RELATIONAL MODELS OF SOURCE CODE ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            98,
+            781,
+            122
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Vincent J. Hellendoorn, Petros Maniatis, Rishabh Singh, Charles Sutton, David Bieber Google Research {vhellendoorn,maniatis,rising,charlessutton,dbieber}@google.com ",
+        "bbox": [
+            183,
+            143,
+            794,
+            188
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "ABSTRACT ",
+        "text_level": 1,
+        "bbox": [
+            454,
+            224,
+            544,
+            239
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Models of code can learn distributed representations of a program’s syntax and semantics to predict many non-trivial properties of a program. Recent state-ofthe-art models leverage highly structured representations of programs, such as trees, graphs and paths therein (e.g., data-flow relations), which are precise and abundantly available for code. This provides a strong inductive bias towards semantically meaningful relations, yielding more generalizable representations than classical sequence-based models. Unfortunately, these models primarily rely on graph-based message passing to represent relations in code, which makes them de facto local due to the high cost of message-passing steps, quite in contrast to modern, global sequence-based models, such as the Transformer. In this work, we bridge this divide between global and structured models by introducing two new hybrid model families that are both global and incorporate structural bias: Graph Sandwiches, which wrap traditional (gated) graph message-passing layers in sequential message-passing layers; and Graph Relational Embedding Attention Transformers (GREAT for short), which bias traditional Transformers with relational information from graph edge types. By studying a popular, non-trivial program repair task, variable-misuse identification, we explore the relative merits of traditional and hybrid model families for code representation. Starting with a graph-based model that already improves upon the prior state-of-the-art for this task by $20 \\%$ , we show that our proposed hybrid models improve an additional $1 0 { - } 1 5 \\%$ , while training both faster and using fewer parameters. ",
+        "bbox": [
+            233,
+            261,
+            764,
+            553
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 INTRODUCTION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            594,
+            336,
+            609
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Well-trained models of source code can learn complex properties of a program, such as its implicit type structure (Hellendoorn et al., 2018), naming conventions (Allamanis et al., 2015), and potential bugs and repairs (Vasic et al., 2019). This requires learning to represent a program’s latent, semantic properties based on its source. Initial representations of source code relied on sequential models from natural-language processing, such as $n$ -gram language models (Hindle et al., 2012; Allamanis & Sutton, 2013; Hellendoorn & Devanbu, 2017) and Recurrent Neural Networks (RNNs) (White et al., 2015), but these models struggle to capture the complexity of source code. ",
+        "bbox": [
+            174,
+            631,
+            825,
+            728
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Source code is rich in structured information, such as a program’s abstract syntax tree, data and control flow. Allamanis et al. (2018b) proposed to model some of this structure directly, providing a powerful inductive bias towards semantically meaningful relations in the code. Their Gated Graph Neural Network (GGNN) model for embedding programs was shown to learn better, more generalizable representations faster than classical RNN-based sequence models. ",
+        "bbox": [
+            174,
+            736,
+            823,
+            805
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "However, the debate on effective modeling of code is far from settled. Graph neural networks typically rely on synchronous message passing, which makes them inherently local, requiring many iterations of message passing to aggregate information from distant parts of the code. However, state-of-the-art graph neural networks for code often use as few as eight message-passing iterations (Allamanis et al., 2018b; Fernandes et al., 2018), primarily for computational reasons: program graphs can be very large, and training time grows linearly with the number of message passes. This is in contrast to, e.g., Transformer models (Vaswani et al., 2017), which allow program-wide information flow at every step, yet lack the powerful inductive bias from knowing the code’s structure. ",
+        "bbox": [
+            174,
+            811,
+            823,
+            924
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "This leads us to a basic research question: is there a fundamental dichotomy between global, unstructured and local, structured models? Our answer is an emphatic no. Our starting point is the sequence-to-pointer model of Vasic et al. (2019), which is state-of-the-art for the task of localizing and repairing a particular type of bug. As a sequence model, their architecture can (at least potentially) propagate information globally, but it lacks access to the known semantic structure of code. To this end, we replace the sequence encoder of Vasic et al. (2019) with a GGNN, yielding a new graph-to-mutlihead-pointer model. Remarkably, this model alone yields a $2 0 \\%$ improvement over the state of the art, though at the cost of being significantly larger than the sequence model. ",
+        "bbox": [
+            174,
+            103,
+            823,
+            215
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Motivated by this result, we propose two new families of models that efficiently combine longerdistance information, such as the sequence model can represent, with the semantic structural information available to the GGNN. One family, the Graph Sandwich, alternates between message passing and sequential information flow through a chain of nodes within the graph; the other, the Graph Relational Embedding Attention Transformer (GREAT), generalizes the relative position embeddings in Transformers by Shaw et al. (2018) to convey structural relations instead. We show that our proposed model families outperform all prior results, as well as our new, already stronger baseline by an additional $10 \\%$ each, while training both substantially faster and using fewer parameters. ",
+        "bbox": [
+            174,
+            222,
+            825,
+            333
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2 RELATED WORK ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            368,
+            344,
+            385
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Distributed Representation of Programs: There has been increasing interest in modeling source code using machine learning (Allamanis et al., 2018a). Hindle et al. (2012) model programs as sequences of tokens and use an $n$ -gram model for predicting code completions. Raychev et al. (2015) use conditional random fields (CRFs) to predict program properties over a set of pairwise program features obtained from the program’s dependency graph. Many approaches use neural language models to embed programs as sequences of tokens (Bhoopchand et al., 2016; White et al., 2015). Some techniques leverage the ASTs of programs in tree-structured recurrent models (Piech et al., 2015; Parisotto et al., 2016; Chen et al., 2018). code2vec (Alon et al., 2018) and code2seq (Alon et al., 2019) model programs as a weighted combination of a set of leaf-to-leaf paths in the abstract syntax tree. Finally, Allamanis et al. (2018b) proposed using GGNNs for embedding program graphs consisting of ASTs together with control-flow and data-flow edges. Some recent models of code embed run-time information of programs, e.g., program traces, besides syntactic information (Wang et al., 2018). In this paper, we explore the space of combining sequence-based and graph-based representations of programs, as well as introduce a Transformer-based model with additional program-edge information to learn program representations. Fernandes et al. (2018) also combine an RNN and a GNN architecture, achieving slight improvements over a GGNN. However, they only consider a single RNN layer inserted at the start; we include larger and more diverse hybrids, as well as entirely different combinations of structural and sequential features. ",
+        "bbox": [
+            174,
+            409,
+            825,
+            659
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Neural Program Repair: Automatically generating fixes to repair program bugs is an active field of research with many proposed approaches based on genetic programming, program analysis and formal methods, and machine learning (Monperrus, 2018; Gazzola et al., 2019). In this paper, we focus on a specific class of repair task called VarMisuse as proposed by Allamanis et al. (2018b), who use a graph-based embedding of programs to predict the most likely variable at each variable-use location and generate a repair prediction whenever the predicted variable is different from the one present, using an enumerative approach. Vasic et al. (2019) improved this approach by jointly predicting both the bug and repair locations using a two-headed pointer mechanism. Our multi-headed pointer graph, graph-sandwich and GREAT models significantly outperform these approaches. ",
+        "bbox": [
+            173,
+            666,
+            825,
+            791
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "3 SEMI-STRUCTURED MODELS OF SOURCE CODE ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            827,
+            604,
+            843
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Models of code have so far either been structured (GNNs) or unstructured (RNNs, Transformers). Considering the graph-based models’ substantially superior performance compared to RNNs despite their locality limitations, we may ask: to what extent could global information help GNNs, and to what extent could structural features help sequence-based models? ",
+        "bbox": [
+            174,
+            867,
+            825,
+            922
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "3.1 MODELS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            103,
+            276,
+            117
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "We address the questions of combining local and global information with two families of models. ",
+        "bbox": [
+            173,
+            131,
+            810,
+            146
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Graph-sandwich Models Let $T = \\langle t _ { 1 } , t _ { 2 } , \\cdot \\cdot \\cdot , t _ { n } \\rangle$ denote a program’s token sequence and $\\mathcal { G } =$ $( \\nu , \\mathcal { E } )$ denote the corresponding program graph, where $\\nu$ is the set of node vertices and $\\mathcal { E }$ is the list of edge sets for different edge types. In both graph and sequence based models, the nodes $v$ maintain a state vector $h ^ { ( v ) }$ that is initialized with initial node embedding $\\boldsymbol { x } ^ { ( v ) } \\in \\mathbb { R } ^ { D }$ . ",
+        "bbox": [
+            174,
+            152,
+            823,
+            210
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "In a GGNN layer, messages of type $k$ are sent from each node $v \\in \\mathcal V$ to its neighbors computed as mk $m _ { k } ^ { ( v ) } = \\mathrm { L i n e a r L a y e r } _ { k } ( h ^ { ( v ) } )$ . After the message passing step, the set of messages at each node are aggregated as $\\begin{array} { r } { m ^ { ( v ) } \\ = \\ \\Sigma _ { e _ { k } ( u , v ) \\in \\mathcal { E } } \\ m _ { k } ^ { ( u ) } } \\end{array}$ Finally, the state vector of a node $v$ is updated as $h _ { \\mathrm { n e w } } ^ { ( v ) } = \\mathrm { G R U } ( m ^ { ( v ) } , h ^ { ( v ) } )$ . In aated as e of a node . A Transfo $v$ (correspondmer compute l, $t _ { i }$ $T$ $h _ { \\mathrm { n e w } } ^ { ( v ) } = f ( t _ { v } , h ^ { ( t _ { i - 1 } ) } )$ $t _ { v }  \\mathbf { q _ { t } } , \\mathbf { k _ { t } } , \\mathbf { v _ { t } }$ corresponding to a query, key and value for each token.1 Each token then computes its attention to√ all other tokens using $e _ { i j } = ( { \\bf q _ { i } } { \\bf k _ { j } } ^ { \\top } ) / \\sqrt { N } ,$ 2 which can be soft-maxed to yield attention probabilities $a _ { i j } = \\exp ( e _ { i j } ) / \\Sigma \\exp ( \\bar { e } _ { i , : } )$ . ",
+        "bbox": [
+            173,
+            217,
+            825,
+            348
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Our first class of models follows from the observation that $T \\subseteq V$ ; i.e., the source code tokens used by sequence models, like RNNs, are by definition also nodes in the program graph, so GGNNs update their state with every message pass. We can thus envision a combined model that uses each of these as a building block; for instance, assuming initial node features $\\boldsymbol { x } ^ { ( v ) } \\in \\mathbb { R } ^ { D }$ , the formula [RNN, GGNN(3), RNN] describes a model in which we first run an RNN on all tokens $\\in \\mathcal { T }$ (in lexical ordering), then, using these as initial states for $v \\in T$ while using the default node-type embeddings for all other nodes, run three message passing steps using a GGNN, after which we again gather the nodes corresponding to $T$ and update their state with an additional RNN pass. ",
+        "bbox": [
+            173,
+            353,
+            825,
+            467
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "The resulting family of models alternates GGNN-style message passing operations and layers of sequence-based models. By varying the number and size of sequential layers and blocks of GGNNstyle message passing, this variant particularly provides insight into the first question above (how can global information help GNNs?), by showing the transition in performance potential of models that increasingly incorporate sequential features. We refer to this class of models as sandwich models. ",
+        "bbox": [
+            174,
+            473,
+            825,
+            542
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Graph Relational Embedding Attention Transformer The above family of models still rely on explicit message passing for their structural bias, thereby only indirectly combining structural and global information to the model. We may wish to instead directly encode structural bias into a sequence-based model, which requires a relaxation of the ‘hard’ inductive bias from the GGNN. For Transformer-based architectures, Shaw et al. (2018) show that relational features can be incorporated directly into the attention function by changing the attention computation to:3√ $e _ { i j } = ( { \\bf q _ { i } } + b _ { i j } ) { { \\bf k _ { j } } ^ { \\top } } / \\sqrt { N }$ where ${ \\bf q _ { i } }$ and $\\mathbf { k _ { j } }$ correspond to the query and key vectors as described above, $b _ { i j }$ is an added bias term for the specific attention weight between tokens $i$ and $j$ , and $N$ is the per-head attention dimension. In our case, we compute $b _ { i j } = W _ { e } ^ { \\top } { \\mathbf e } + b _ { e }$ , where $W _ { e } \\in \\mathbb { R } ^ { N } , b _ { e } \\in \\mathbb { R }$ , and $\\mathbf { e } \\in \\mathbb { R } ^ { N }$ is an embedding of the edge type connecting nodes $i$ and $j$ , if any. If multiple edge types are present between two nodes, the resulting biases are simply added. We name this model GREAT, for Graph Relational Embedding Attention Transformer. ",
+        "bbox": [
+            173,
+            549,
+            826,
+            723
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3.2 ARCHITECTURAL DETAILS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            744,
+            401,
+            758
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "In this section, we present details of different architectures we compare and their hyperparameters. ",
+        "bbox": [
+            169,
+            772,
+            816,
+            787
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "General: All of our models follow the structure proposed by Vasic et al. (2019), stacking an initial token-embedding layer, a ‘core’ model that computes a distributed representation of the code under inspection (in their case, an LSTM), followed by a projection into two pointers for the localization and repair tasks (see Section 4). This core model is the part varied in our work. We use ",
+        "bbox": [
+            174,
+            794,
+            823,
+            851
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "SubwordTextEncoder from Tensor2Tensor (Vaswani et al., 2018) to generate a 10K sub-token vocabulary from training data and embed each token by averaging embeddings of its sub-token(s). ",
+        "bbox": [
+            173,
+            103,
+            823,
+            132
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "GGNN: Many types of graph-based message-passing neural networks have been proposed for code, mostly differing in how a node’s state is updated based on ‘messages’ sent by nodes it is connected to. Most commonly used is the gated graph neural network (GGNN) (Li et al., 2015), which uses a GRU cell (Cho et al., 2014) to update a node’s state. Although other options sometimes outperform this architecture, the improvements are generally minor, so we rely on this model for our baseline. One hyperparameter of the architecture is whether to use different transformations at each message-passing step, or to reuse one set of transformations for multiple message passes. Following Allamanis et al. (2018b), we use blocks of two message-passing layers, in which the first layer is repeated three times, for four message passes per block. We then sweep over GGNN architectures that repeat these blocks 1 to 4 times (thus yielding 4 to 16 message passes). By default, the message dimension is set to 128, but we include an ablation with 256-dimensional messages as well. ",
+        "bbox": [
+            174,
+            138,
+            825,
+            291
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "RNNs: We experimented with the one-directional entailment-attention-based RNN proposed by Vasic et al. (2019), but found a simpler bi-directional RNN architecture to work even better. We use GRUs as the recurrent cells, vary the number of layers from 1 to 3, and the hidden dimension (of the concatenated forward and backward component) in $\\{ 1 2 8 , 2 5 6 , 5 1 2 \\}$ . ",
+        "bbox": [
+            174,
+            299,
+            825,
+            354
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Transformers: We base our architecture on the original Transformer (Vaswani et al., 2017), varying the number of layers from 1 to 10 and the attention dimension in $\\{ 1 2 8 , 2 5 6 , 5 1 2 , 1 0 2 4 \\}$ . ",
+        "bbox": [
+            173,
+            361,
+            823,
+            390
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Sandwich Models: We distinguish between two types of sandwich models: ‘small’ sandwiches, which add a single RNN or Transformer to a GGNN architecture, and ‘large’ sandwiches, which wrap every message-passing block (as defined above) with a 128-dimensional (bi-directional) RNN/Transformer layer. We vary the number of message-passing blocks from 1 to 3 (corresponding to 4 to 12 message passes) to span a similar parameter domain as the GGNNs above (ca. $1 . 5  { \\mathbf { M } } -$ 5M), increasing the number of layers to 2 and their dimension to 512 for a later ablation. ",
+        "bbox": [
+            174,
+            397,
+            825,
+            479
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "GREAT: Uses the same architectural variations as the Transformer family; edge-type embedding dimensions are fixed at the per-head attention dimension, as described above. ",
+        "bbox": [
+            173,
+            487,
+            821,
+            515
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Global hyper-parameters: We train most of our models with batch sizes of $\\{ 1 2 . 5 \\mathrm { K } , 2 5 \\mathrm { K } , 5 0 \\mathrm { K } \\}$ tokens, with the exception of the Transformer architectures; due to the quadratic nature of the attention computation, 25K tokens was too large for these models, so we additionally trained these with 6.25K-token batches.4 Learning rates were varied in $\\left\\{ 1 \\mathrm { e } { - } 3 , 4 \\mathrm { - } \\mathrm { e } 4 , 1 \\mathrm { e } { - } 4 , 4 \\mathrm { e } { - } 5 , 1 \\mathrm { e } { - } 5 \\right\\}$ using an Adam optimizer, where we omitted the first option for our GGNN models and the last for our RNNs due to poor performance. Sub-tokens were embedded using 128-dimensional embeddings. ",
+        "bbox": [
+            174,
+            522,
+            825,
+            606
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Hardware: all our models were trained on a single Tesla P100 GPU on 25 million samples, which required between 40 and 250 hours for our various models. However, we emphasize that overall training time is not our main objective; we primarily assess the ultimated converged accuracy of our models and present training behavior over time for reference of our various models’ training behavior. ",
+        "bbox": [
+            174,
+            613,
+            825,
+            683
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3.3 ABOUT GRAPH REPRESENTATIONS OF CODE ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            700,
+            524,
+            714
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Our program graphs borrow many edge types from Allamanis et al. (2018b), such as data-flow (e.g., read & write), adjacent-token, and syntactic edges, which we further augment with edges between control-flow statements and function calls. When representing programs as graphs, a key decision needs to be made regarding the Abstract Syntax Tree (AST). Typically, one of the edge types in the graphs represents syntactic parent-child relationships in the AST. Additionally, some of the edges representing relations (e.g., control-flow) are naturally represented as edges between internal nodes in this tree, e.g., between two IfStatement nodes. However, ablations often find that the effectiveness of including the AST is limited in graph-based models (Allamanis et al., 2018b). ",
+        "bbox": [
+            174,
+            726,
+            825,
+            837
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "This raises the question of whether it is possible to represent programs as graphs that include sequential and semantic information, but not syntax. To this end, we propose a leaves-only graph representation for code as follows: edges that represent semantic relationships such as control flow and data flow can easily be moved down from internal nodes – which typically represent a span of multiple tokens – to those leaf nodes in the graph that represent the begin token of that span. Thus, an edge that used to connect two IfStatement interior AST nodes is moved down to connect the corresponding if tokens. Now, the AST can be omitted entirely, thereby removing parent-child relations among syntax nodes, producing what we call a leaves-only graph. This latter representation is substantially more compressed than the graphs with ASTs, often using $2 { - } 3 \\mathbf { x }$ fewer nodes (while retaining most of the edges), and additionally aligns better with sequence-based models, because all edges are directly connected to the original code tokens.5 We compare both settings for each graph-based model, but unless otherwise specified, we use the ‘full’ graphs for the regular GGNN model and the ‘leaves-only’ graphs (without ASTs) for the sandwich and GREAT models. ",
+        "bbox": [
+            174,
+            844,
+            823,
+            900
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            103,
+            825,
+            229
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "4 EXPERIMENTAL SETUP ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            250,
+            398,
+            265
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "The VarMisuse Task We focus our study on the variable-misuse localization-and-repair task (Vasic et al., 2019): given a function, predict two pointers into the function’s tokens, one pointer for the location of a variable use containing the wrong variable (or a special no-bug location), and one pointer for any occurrence of the correct variable that should be used at the faulty location instead. ",
+        "bbox": [
+            174,
+            281,
+            825,
+            337
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Synthetic Dataset We used the ETH Py150 dataset (Raychev et al., 2016), which is based on GitHub Python code, and already partitioned into train and test splits (100K and 50K files, respectively). We further split the 100K train files into 90K train and 10K validation examples and applied a deduplication step on that dataset (Allamanis, 2018). We extracted all top-level function definitions from these files; any function that uses multiple variables can be turned into a training example by randomly replacing one variable usage with another. As there may be many candidates for such bugs in a function, we limit our extraction to up to three samples per function to avoid biasing our dataset too strongly towards longer functions. For every synthetically generated buggy example, an unperturbed, bug-free example of the function is included as well, to keep our dataset balanced, yielding ca. 2M total training and 755K test samples. Finally, we train with functions with up to 250 tokens; at test time, we raise this to 1,000 to study our models’ generalization to longer functions. ",
+        "bbox": [
+            174,
+            343,
+            825,
+            497
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Metrics As we are mainly interested in contrasting the behavior of different models of code, we focus most of our results on the various models’ learning curves by tracking development-set accuracy on 25K held-out samples every 250K samples as the models train. Here, we measure two accuracy metrics: localization accuracy (whether the model correctly identifies the bug’s location for buggy samples); and (independently) repair accuracy (whether the model points to the correct variable to repair the bug). Note that these metrics focus on buggy samples; the models also determine whether a function is buggy, which we discuss below. We group all models by their ‘family’, as categorized in Section 3.2, reporting the maximum held-out performance per family. ",
+        "bbox": [
+            174,
+            503,
+            825,
+            614
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "For deeper insight into the fully trained models’ performance, we also analyze the performance of the best models in each family in more depth on the test portion of our synthetic dataset. Specifically, we assess their bugginess-classification accuracy (whether the model correctly identifies the method as (non-)buggy) and their joint localization and repair accuracy (for buggy samples, how often the model correctly localizes and repairs the bug). Here, we also increase the maximum function size to 1,000 tokens and analyze the impact of longer functions on our models’ performance. ",
+        "bbox": [
+            174,
+            622,
+            825,
+            705
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "4.1 DATA & CODE RELEASE ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            723,
+            385,
+            737
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "We release a public implementation of the GREAT model based on Tensorflow, as well as the program graphs for all samples in our training and evaluation datasets whose license permits us to redistribute these at: https://doi.org/10.5281/zenodo.3668323, which tracks the latest release of our Github repository at: https://github.com/VHellendoorn/ ICLR20-Great. ",
+        "bbox": [
+            174,
+            750,
+            825,
+            818
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "5 RESULTS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            839,
+            281,
+            854
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "There are many degrees of freedom in our family of models, so we structure our results around a series of comparisons, which we analyze and discuss in this section. We start with our key result, which compares all our model families (RNNs, Transformers, GGNNs, Sandwich hybrids, and GREAT models) across a comparable parameter domain (ca. 1.4M – 5.5M parameters) in Figure 1. ",
+        "bbox": [
+            178,
+            871,
+            823,
+            900
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            103,
+            825,
+            132
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "image",
+        "img_path": "images/96061ba572ebf13a72a349a63a2a4c26ec4970bd22d2b93d03adfbc9020773de.jpg",
+        "image_caption": [
+            "Figure 1: Comparison of top-performing models from all model families across a comparable parameter domain of $1 . 5 \\mathrm { M } - 5 \\mathrm { M }$ parameters. Performance visualized using the localization (left) and repair (right) accuracy Pareto fronts w.r.t. both training time (top) and number of training samples seen (bottom), both log-scaled, where an epoch is ca. 2M samples. In all cases, our proposed models substantially outperform GGNNs from early in the training process. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            236,
+            161,
+            756,
+            550
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Although there are subtle differences between the models’ behavior on localization and repair accuracy, the overall picture is consistent: whereas our newly proposed graph-to-multihead-pointer models already substantially outperform RNN-based models (the previous state-of-the-art), and sometimes Transformers, the hybrid global & structured models achieve significantly better results faster. ",
+        "bbox": [
+            174,
+            651,
+            823,
+            707
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Time-wise (the top two figures), the GGNN models take the longest to converge, continuing to improve slightly even after a week of training mainly because their largest (16-layer) architecture starts to dominate the 12-layer version’s performance after ca. 170h. The Sandwich models follow its training curve, but are more accurate and faster to converge, achieving especially good results for limited training budgets, partly because they succeeded with just 4 – 8 layers of message passing by relying on their global components. ",
+        "bbox": [
+            174,
+            713,
+            825,
+            797
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "The Transformer architecture, although slower at first, widely outperforms the RNN as a baseline model. The GREAT model tracks its learning curve, starting out slower than the models with explicit message passing, but gradually overtaking them after ca. 10h, as the underlying Transformer becomes increasingly effective. We note that this model achieves state-of-the-art results despite having, at the time of this writing, received less training time (ca. 64h compared to up to 240h). ",
+        "bbox": [
+            174,
+            805,
+            825,
+            875
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "The bottom half of Figure 1 abstracts away the potentially confounding issue of implementation speed of our models by tracking performance w.r.t the number of training samples. Naturally, the end-points of the curves (the converged accuracy) are identical, but importantly the various models’ training curves are quite similar; even here, the GGNN is only able to outperform some of our proposed models briefly, yielding inferior performance to all within just one epoch. ",
+        "bbox": [
+            176,
+            882,
+            823,
+            924
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            103,
+            821,
+            132
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "The RNN and GGNN models appear to be particularly complementary; even though the RNN’s localization accuracy is very poor compared to the GGNN, the combined model still sustains a ${ \\sim } 5 \\%$ improvement on the latter.6 However, the Transformer Sandwich does not seem to benefit similarly, showing virtually no difference in performance with the RNN Sandwich model. This strongly suggests that the Transformer’s ability to access long-distance information overlaps in large part (though not entirely, given GREAT’s performance) with the GGNNs’ ability to do so using message passing. We conjecture that the Transformer learns to infer many of the same connections (e.g., data-flow, control-flow) that are encoded explicitly in the graph’s message passing. ",
+        "bbox": [
+            174,
+            138,
+            825,
+            251
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "To understand the behavior of the many models and combinations that may be used for code, we now explore the variations on our choices of parameters, models, and metrics. ",
+        "bbox": [
+            176,
+            257,
+            823,
+            285
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "5.1 LARGER MODELS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            303,
+            338,
+            318
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Model capacity is a potential threat to any comparison between models of different families. We aimed to ensure a fair comparison in the previous section by selecting a range of hyper-parameters (which includes the number of stacked layers) for these architectures that span a similar parameter count range. For instance, a 6-layer Transformer with 512-dimensional attention is comparable to a 2-layer 512-dimensional bi-directional RNN and an 8-layer GGNN. However, all these architectures are relatively modest, having at most ${ \\sim } 5 \\mathbf { M }$ parameters. By increasing the number, and dimensionality of their layers, we can evaluate a second family of models with ca. 5–20M parameters. ",
+        "bbox": [
+            173,
+            329,
+            825,
+            428
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Figure 2 shows the performance for the low- and high-parameter variations for each of our bestperforming model families. Overall, while providing more parameters to the GGNNs made virtually no difference, all our hybrid models increase $2 - 3 \\%$ in both localization and repair accuracy, providing further support for combining global, structured models. The best-performing instances of each model family were consistently the larger architectures, 15M parameters for the GGNN, 12.5M & 10M for the RNN and Transformer Sandwiches respectively and 7.9M for GREAT.7 ",
+        "bbox": [
+            174,
+            434,
+            823,
+            517
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/891bb76b8b22cc3f22d8d35865dbfce9b0f0a82d9df045cca8830b19b5be6265.jpg",
+        "image_caption": [
+            "Figure 2: Comparison of smaller (1.5–5M parameter) and larger (5–20M parameter, identified with $\\cdot _ { + + } ,$ variants of each model family. Localization and repair accuracy Pareto-front w.r.t. time. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            238,
+            544,
+            756,
+            728
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "5.2 ON SYNTACTIC INFORMATION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            803,
+            424,
+            816
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "In the previous results, the GGNN models were trained on ‘full’ graphs (as described in Section 3.3), that use the code’s AST structure, and the sandwich models on ‘leaves-only’ graphs, with only source token nodes, and edges moved to connect these directly. These settings are arguably each appropriate to the underlying model, but both models can also use the alternative setting. ",
+        "bbox": [
+            176,
+            828,
+            823,
+            885
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/a820488f09223f97e60319c333a9fc46ccb028312e07b0032199bdaa49aa909f.jpg",
+        "image_caption": [
+            "Figure 3: Comparing impact of graph representation on GGNNs and RNN Sandwich models. Localization and repair accuracy Pareto-front w.r.t time. Note: y-axis cropped to simplify comparison. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            238,
+            113,
+            756,
+            296
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Figure 3 shows the training curves for the alternative settings. In all cases, the models that do not use syntax train substantially faster because each sample’s graph representation is more than twice as small, so these models naturally lead in accuracy early on in training. However, whereas the GGNN equipped with syntax overtakes its counter-part within ca. 48h, the sandwich models display a much longer lag, with no cross-over observed at all on localization accuracy in this time window.8 ",
+        "bbox": [
+            174,
+            381,
+            823,
+            450
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "The sandwich model on full graphs still compares favorably with the GGNN baseline, though its early training behavior is not as effective. It is also interesting to note that the best-performing Sandwich models in this setting were consistently architectures with more message-passing steps. This may be due to the additional distance between information propagated along the tokens and along semantic edges, which in this setting are almost universally connected to AST-internal nodes. ",
+        "bbox": [
+            174,
+            458,
+            825,
+            529
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "5.3 RNNS IN SANDWICHES: SINGLE VS. MANY",
+        "text_level": 1,
+        "bbox": [
+            174,
+            556,
+            517,
+            570
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Recent work on neural summarization also mixed RNNs and GGNNs (Fernandes et al., 2018), but did so by inserting a single RNN layer into a GNN architecture, before any message passing. We compare this architecture to a full Sandwich model in Figure 4. Although a single RNN certainly helps compared to the GGNN, interleaving RNNs and GGNN-style message passes performed substantially better. In fact, the best performing full Sandwiches used fewer parameters than the Single models because they used 8 message passes instead of 12, relying more heavily on the RNNs.9 ",
+        "bbox": [
+            174,
+            585,
+            825,
+            670
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "5.4 TEST-SET ANALYSIS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            698,
+            356,
+            712
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Having identified our best-performing models in each family, we now study their performance on the test data, specifically using the metrics used in Vasic et al. (2019) (see Section 4) in Table 1. In general, the two metrics correlated well; models that accurately determined whether a function contained a bug also accurately identified the bug (and repair), as may be expected. The baseline RNN model achieves a modest $44 \\%$ accuracy at the latter task; this is slightly lower than reported in prior work (Vasic et al., 2019), which is likely due in part to our dataset de-duplication. Transformers and GGNNs perform substantially better (and comparably, though the latter trained 6x longer for this performance), but still fall well short of our hybrid models’ performance, which are especially much more accurate on long functions. The GREAT model shows most promise on the repair task, already outperforming the sandwich models despite having so far had limited training time. ",
+        "bbox": [
+            174,
+            728,
+            825,
+            867
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "image",
+        "img_path": "images/4e04d6ea7dd5bfb2ef01a6dfd6d452ab0dbf57732e286b392cbf2337a905571b.jpg",
+        "image_caption": [
+            "Figure 4: Comparison of RNN sandwiches with a single RNN vs. those with RNNs around every message-passing block (‘Multi’). Localization and repair accuracy Pareto-front w.r.t. time. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            236,
+            113,
+            756,
+            295
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "table",
+        "img_path": "images/4e7aea86a35c3a5154dd03b345cf8c91955b43f8821d291f304467e0d6db27fa.jpg",
+        "table_caption": [
+            "Table 1: Test-set results of best-performing models by family, on metrics of Vasic et al. (2019). Grouped by maximum length; $6 . 5 \\%$ of test set samples exceeded 250 tokens (the training limit). "
+        ],
+        "table_footnote": [
+            "1: a stronger version of the model proposed in Vasic et al. (2019) (previous SOTA). "
+        ],
+        "table_body": "<table><tr><td rowspan=1 colspan=4>Model Family</td><td rowspan=1 colspan=1>Class. Accuracy≤ 250  ≤1000</td><td rowspan=1 colspan=1>Loc &amp; Rep Accuracy≤ 250  ≤1000</td><td rowspan=1 colspan=1>Parameters</td><td rowspan=1 colspan=1>TrainingTime</td></tr><tr><td rowspan=1 colspan=4>RNN1</td><td rowspan=1 colspan=1>71.8%  70.6%</td><td rowspan=1 colspan=1>44.4%  42.5%</td><td rowspan=1 colspan=1>4.3M</td><td rowspan=1 colspan=1>31.3h</td></tr><tr><td rowspan=3 colspan=4>TransformerGGNN</td><td rowspan=1 colspan=1>75.9%  73.2%</td><td rowspan=1 colspan=1>67.7%  63.0%</td><td rowspan=1 colspan=1>3.7M</td><td rowspan=1 colspan=1>41.5h</td></tr><tr><td rowspan=1 colspan=2></td><td rowspan=1 colspan=2>GGNN</td><td rowspan=1 colspan=1>81.4%  79.2%</td><td rowspan=1 colspan=1>64.0%  60.9%</td><td rowspan=1 colspan=1>5.5M</td><td rowspan=1 colspan=1>241h</td></tr><tr><td rowspan=2 colspan=4>RNN Sandwich</td><td></td><td></td><td></td><td></td></tr><tr><td rowspan=1 colspan=1>82.5%  81.9%</td><td rowspan=1 colspan=1>75.8%  73.8%</td><td rowspan=1 colspan=1>12.6M</td><td rowspan=1 colspan=1>109h</td></tr><tr><td rowspan=1 colspan=4>Transformer Sandwich</td><td rowspan=1 colspan=1>81.1%  78.1%</td><td rowspan=1 colspan=1>74.5%  71.4%</td><td rowspan=1 colspan=1>10M</td><td rowspan=1 colspan=1>161h</td></tr><tr><td rowspan=1 colspan=4>GREAT</td><td rowspan=1 colspan=1>80.1%  76.9%</td><td rowspan=1 colspan=1>76.4%  73.1%</td><td rowspan=1 colspan=1>7.9M</td><td rowspan=1 colspan=1>120h</td></tr></table>",
+        "bbox": [
+            184,
+            410,
+            813,
+            537
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "5.5 REAL BUGS ANALYSIS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            588,
+            374,
+            603
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "We want to ensure that our models can be useful for real bugs and do not simply overfit to the synthetic data generation that we used. This risk exists because we did not filter our introduced bugs based on whether they would be difficult to detect, for instance because they conflate variables with similar names, usage, or data types; presumably, such bugs are more likely to escape a developer’s notice and find their way into real code bases. It is therefore expected that performance on realworld bugs will be lower for all our models, but we must assert that our proposed models do not just outperform GGNNs on synthetic data, e.g. by memorizing characteristics of synthetic bugs. ",
+        "bbox": [
+            174,
+            617,
+            825,
+            715
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "To mitigate this threat, we collect real variable misuse bugs from code on Github. Specifically, we collect ca. 1 million commits that modify Python files from Github. We extracted all changes to functions from these commits, filtering these according to the same criteria that we used to introduce variable-misuse bugs: we looked for commits that exclusively changed a single variable usage in a function body from one variable in scope to another. We focus on functions with up to 250 tokens, since all our models performed substantially better on these in Table 1. We identified 170 such changes, in which we assumed that the version before the change was buggy and the updated version correct. We removed any functions that had occurred in our training data, of which we found 9 and paired the remaining functions up (correct and buggy) to create a real-world evaluation set with 322 functions, which we presented to our models. ",
+        "bbox": [
+            174,
+            722,
+            825,
+            861
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Table 2 shows the results of running our various models on these bugs. In general, these were clearly substantially more difficult for all our models than the synthetic samples we generated. However, we see a clear difference in performance with all our proposed models performing substantially better than previous baselines, and showing favorable precision/recall trade-offs. ",
+        "bbox": [
+            174,
+            867,
+            823,
+            924
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "table",
+        "img_path": "images/a2588d44c5222e93ce00d4984202080de0bba24d5330bb29927852b42faca985.jpg",
+        "table_caption": [
+            "Table 2: Results on 322 paired buggy and non-buggy samples from 161 real variable misuse bugs mined from Github commits. ‘Class.’ measures accuracy at identifying non-buggy samples; ‘Prec.’ and ‘Rec.’ capture the precision and recall at identifying the correct localization and repair on the buggy samples. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Model Family</td><td colspan=\"2\"> All Samples</td><td>Precision at Recall = 5%</td><td>Precision at Recall = 10%</td></tr><tr><td>RNN</td><td>Class. Prec. 52.8% 13.3%</td><td>Rec. 46.6%</td><td>44.4%</td><td>23.5%</td></tr><tr><td>Transformer</td><td>62.1% 15.8%</td><td>47.2%</td><td>33.3%</td><td>17.6%</td></tr><tr><td>GGNN</td><td>65.8% 17.7%</td><td>42.2%</td><td>44.4%</td><td>23.5%</td></tr><tr><td>RNN Sandwich</td><td>69.6% 28.6%</td><td>43.5%</td><td>77.8%</td><td>64.7%</td></tr><tr><td>Trans.Sandwich</td><td>75.2% 21.5%</td><td>40.4%</td><td>33.3%</td><td>35.3%</td></tr><tr><td>GREAT</td><td>70.2% 23.7%</td><td>36.7%</td><td>44.4%</td><td>29.4%</td></tr></table>",
+        "bbox": [
+            228,
+            174,
+            769,
+            301
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "6 CONCLUSION ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            330,
+            318,
+            347
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "We demonstrate that models leveraging richly structured representations of source code do not have to be confined to local contexts. Instead, models that leverage only limited message passing in combination with global models learn much more powerful representations faster. We proposed two different architectures for combining local and global information: sandwich models that combine two different message-passing schedules and achieve highly competitive models quickly, and the GREAT model which adds information from a sparse graph to a Transformer to achieve stateof-the-art results. In the process, we raise the state-of-the-art performance on the VarMisuse bug localization and repair task by over $30 \\%$ . ",
+        "bbox": [
+            173,
+            361,
+            825,
+            473
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "REFERENCES ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            493,
+            285,
+            508
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Miltiadis Allamanis. The adverse effects of code duplication in machine learning models of code. CoRR, abs/1812.06469, 2018. URL http://arxiv.org/abs/1812.06469. ",
+        "bbox": [
+            176,
+            516,
+            823,
+            545
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Miltiadis Allamanis and Charles Sutton. Mining source code repositories at massive scale using language modeling. In Working Conference on Mining Software Repositories (MSR), 2013. ",
+        "bbox": [
+            173,
+            553,
+            823,
+            583
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Miltiadis Allamanis, Earl T Barr, Christian Bird, and Charles Sutton. Suggesting accurate method and class names. In Proceedings of the 2015 10th Joint Meeting on Foundations of Software Engineering, pp. 38–49. ACM, 2015. ",
+        "bbox": [
+            174,
+            589,
+            823,
+            633
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Miltiadis Allamanis, Earl T. Barr, Premkumar Devanbu, and Charles Sutton. A survey of machine learning for big code and naturalness. ACM Comput. Surv., 51(4):81:1–81:37, July 2018a. ISSN 0360-0300. ",
+        "bbox": [
+            173,
+            640,
+            823,
+            683
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Miltiadis Allamanis, Marc Brockschmidt, and Mahmoud Khademi. Learning to represent programs with graphs. In International Conference on Learning Representations, 2018b. ",
+        "bbox": [
+            169,
+            691,
+            823,
+            720
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Uri Alon, Meital Zilberstein, Omer Levy, and Eran Yahav. code2vec: Learning distributed representations of code. CoRR, abs/1803.09473, 2018. ",
+        "bbox": [
+            171,
+            728,
+            821,
+            757
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Uri Alon, Shaked Brody, Omer Levy, and Eran Yahav. code2seq: Generating sequences from structured representations of code. In 7th International Conference on Learning Representations, ICLR 2019, New Orleans, LA, USA, May 6-9, 2019, 2019. ",
+        "bbox": [
+            176,
+            765,
+            823,
+            809
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Avishkar Bhoopchand, Tim Rocktaschel, Earl Barr, and Sebastian Riedel. Learning python code ¨ suggestion with a sparse pointer network. arXiv preprint arXiv:1611.08307, 2016. ",
+        "bbox": [
+            171,
+            816,
+            823,
+            845
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Xinyun Chen, Chang Liu, and Dawn Song. Tree-to-tree neural networks for program translation. In S. Bengio, H. Wallach, H. Larochelle, K. Grauman, N. Cesa-Bianchi, and R. Garnett (eds.), Advances in Neural Information Processing Systems 31, pp. 2547–2557. Curran Associates, Inc., 2018. URL http://papers.nips.cc/paper/ 7521-tree-to-tree-neural-networks-for-program-translation.pdf. ",
+        "bbox": [
+            176,
+            854,
+            825,
+            922
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Kyunghyun Cho, Bart Van Merrienboer, Caglar Gulcehre, Dzmitry Bahdanau, Fethi Bougares, Hol- ¨ ger Schwenk, and Yoshua Bengio. Learning phrase representations using rnn encoder-decoder for statistical machine translation. arXiv preprint arXiv:1406.1078, 2014. ",
+        "bbox": [
+            176,
+            103,
+            821,
+            146
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Patrick Fernandes, Miltiadis Allamanis, and Marc Brockschmidt. Structured neural summarization. arXiv preprint arXiv:1811.01824, 2018. ",
+        "bbox": [
+            171,
+            155,
+            823,
+            184
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Luca Gazzola, Daniela Micucci, and Leonardo Mariani. Automatic software repair: A survey. IEEE Trans. Software Eng., 45(1):34–67, 2019. ",
+        "bbox": [
+            171,
+            193,
+            823,
+            222
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Vincent J Hellendoorn and Premkumar Devanbu. Are deep neural networks the best choice for modeling source code? In Proceedings of the 2017 11th Joint Meeting on Foundations of Software Engineering, pp. 763–773. ACM, 2017. ",
+        "bbox": [
+            176,
+            231,
+            825,
+            273
+        ],
+        "page_idx": 10
+    },
+    {
+        "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, pp. 152–162. ACM, 2018. ",
+        "bbox": [
+            174,
+            282,
+            825,
+            339
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Abram Hindle, Earl T. Barr, Zhendong Su, Mark Gabel, and Premkumar Devanbu. On the naturalness of software. In Proceedings of the 34th International Conference on Software Engineering, ICSE ’12, pp. 837–847, 2012. ",
+        "bbox": [
+            174,
+            348,
+            825,
+            392
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Yujia Li, Daniel Tarlow, Marc Brockschmidt, and Richard Zemel. Gated graph sequence neural networks, 2015. ",
+        "bbox": [
+            173,
+            400,
+            823,
+            429
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Martin Monperrus. Automatic software repair: A bibliography. ACM Comput. Surv., 51(1):17:1– 17:24, January 2018. ISSN 0360-0300. ",
+        "bbox": [
+            169,
+            438,
+            825,
+            467
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Emilio Parisotto, Abdel-rahman Mohamed, Rishabh Singh, Lihong Li, Dengyong Zhou, and Pushmeet Kohli. Neuro-symbolic program synthesis. CoRR, abs/1611.01855, 2016. URL http: //arxiv.org/abs/1611.01855. ",
+        "bbox": [
+            174,
+            477,
+            821,
+            518
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Chris Piech, Jonathan Huang, Andy Nguyen, Mike Phulsuksombati, Mehran Sahami, and Leonidas Guibas. Learning program embeddings to propagate feedback on student code. In Proceedings of the 32Nd International Conference on International Conference on Machine Learning - Volume 37, ICML’15, pp. 1093–1102, 2015. ",
+        "bbox": [
+            174,
+            529,
+            826,
+            585
+        ],
+        "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, 2015. ",
+        "bbox": [
+            174,
+            594,
+            826,
+            637
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Veselin Raychev, Pavol Bielik, and Martin T. Vechev. Probabilistic model for code with decision trees. In Proceedings of the 2016 ACM SIGPLAN International Conference on Object-Oriented Programming, Systems, Languages, and Applications, OOPSLA 2016, part of SPLASH 2016, Amsterdam, The Netherlands, October 30 - November 4, 2016, pp. 731–747, 2016. ",
+        "bbox": [
+            173,
+            645,
+            825,
+            703
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Peter Shaw, Jakob Uszkoreit, and Ashish Vaswani. Self-attention with relative position representations. arXiv preprint arXiv:1803.02155, 2018. ",
+        "bbox": [
+            173,
+            712,
+            823,
+            741
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Marko Vasic, Aditya Kanade, Petros Maniatis, David Bieber, and Rishabh Singh. Neural program repair by jointly learning to localize and repair. arXiv preprint arXiv:1904.01720, 2019. ",
+        "bbox": [
+            171,
+            750,
+            823,
+            780
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Ashish Vaswani, Noam Shazeer, Niki Parmar, Jakob Uszkoreit, Llion Jones, Aidan N Gomez, Łukasz Kaiser, and Illia Polosukhin. Attention is all you need. In Advances in neural information processing systems, pp. 5998–6008, 2017. ",
+        "bbox": [
+            174,
+            787,
+            825,
+            830
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Ashish Vaswani, Samy Bengio, Eugene Brevdo, Franc¸ois Chollet, Aidan N. Gomez, Stephan Gouws, Llion Jones, Lukasz Kaiser, Nal Kalchbrenner, Niki Parmar, Ryan Sepassi, Noam Shazeer, and Jakob Uszkoreit. Tensor2tensor for neural machine translation. In Proceedings of the 13th Conference of the Association for Machine Translation in the Americas, AMTA 2018, Boston, MA, USA, March 17-21, 2018 - Volume 1: Research Papers, pp. 193–199, 2018. URL https://www.aclweb.org/anthology/W18-1819/. ",
+        "bbox": [
+            174,
+            840,
+            825,
+            924
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Ke Wang, Rishabh Singh, and Zhendong Su. Dynamic neural program embeddings for program repair. In 6th International Conference on Learning Representations, ICLR 2018, Vancouver, BC, Canada, April 30 - May 3, 2018, Conference Track Proceedings, 2018. ",
+        "bbox": [
+            178,
+            103,
+            823,
+            146
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Martin White, Christopher Vendome, Mario Linares-Vasquez, and Denys Poshyvanyk. Toward ´ deep learning software repositories. In Proceedings of the 12th Working Conference on Mining Software Repositories, pp. 334–345. IEEE Press, 2015. ",
+        "bbox": [
+            176,
+            155,
+            821,
+            196
+        ],
+        "page_idx": 11
+    }
+]

parse/train/EI2KOXKdnP/EI2KOXKdnP.md

@@ -0,0 +1,215 @@
+# MLP-Mixer: An all-MLP Architecture for Vision
+
+Ilya Tolstikhin∗, Neil Houlsby∗, Alexander Kolesnikov∗, Lucas Beyer∗,
+
+Xiaohua Zhai, Thomas Unterthiner, Jessica Yung, Andreas Steiner,
+
+Daniel Keysers, Jakob Uszkoreit, Mario Lucic, Alexey Dosovitskiy
+
+∗equal contribution
+
+Google Research, Brain Team
+
+{tolstikhin, neilhoulsby, akolesnikov, lbeyer, xzhai, unterthiner, jessicayung†, andstein, keysers, usz, lucic, adosovitskiy}@google.com
+
+†work done during Google AI Residency
+
+# Abstract
+
+Convolutional Neural Networks (CNNs) are the go-to model for computer vision. Recently, attention-based networks, such as the Vision Transformer, have also become popular. In this paper we show that while convolutions and attention are both sufficient for good performance, neither of them are necessary. We present MLP-Mixer, an architecture based exclusively on multi-layer perceptrons (MLPs). MLP-Mixer contains two types of layers: one with MLPs applied independently to image patches (i.e. “mixing” the per-location features), and one with MLPs applied across patches (i.e. “mixing” spatial information). When trained on large datasets, or with modern regularization schemes, MLP-Mixer attains competitive scores on image classification benchmarks, with pre-training and inference cost comparable to state-of-the-art models. We hope that these results spark further research beyond the realms of well established CNNs and Transformers.1
+
+# 1 Introduction
+
+As the history of computer vision demonstrates, the availability of larger datasets coupled with increased computational capacity often leads to a paradigm shift. While Convolutional Neural Networks (CNNs) have been the de-facto standard for computer vision, recently Vision Transformers [14] (ViT), an alternative based on self-attention layers, attained state-of-the-art performance. ViT continues the long-lasting trend of removing hand-crafted visual features and inductive biases from models and relies further on learning from raw data.
+
+We propose the MLP-Mixer architecture (or “Mixer” for short), a competitive but conceptually and technically simple alternative, that does not use convolutions or self-attention. Instead, Mixer’s architecture is based entirely on multi-layer perceptrons (MLPs) that are repeatedly applied across either spatial locations or feature channels. Mixer relies only on basic matrix multiplication routines, changes to data layout (reshapes and transpositions), and scalar nonlinearities.
+
+Figure 1 depicts the macro-structure of Mixer. It accepts a sequence of linearly projected image patches (also referred to as tokens) shaped as a “patches $\times$ channels” table as an input, and maintains this dimensionality. Mixer makes use of two types of MLP layers: channel-mixing MLPs and token-mixing MLPs. The channel-mixing MLPs allow communication between different channels;
+
+![](images/759c8bb1b0f4ebf46f621f72824e0a25d409516ac63197eee33154d2126e49cb.jpg)  
+Figure 1: MLP-Mixer consists of per-patch linear embeddings, Mixer layers, and a classifier head. Mixer layers contain one token-mixing MLP and one channel-mixing MLP, each consisting of two fully-connected layers and a GELU nonlinearity. Other components include: skip-connections, dropout, and layer norm on the channels.
+
+they operate on each token independently and take individual rows of the table as inputs. The token-mixing MLPs allow communication between different spatial locations (tokens); they operate on each channel independently and take individual columns of the table as inputs. These two types of layers are interleaved to enable interaction of both input dimensions.
+
+In the extreme case, our architecture can be seen as a very special CNN, which uses $1 \times 1$ convolutions for channel mixing, and single-channel depth-wise convolutions of a full receptive field and parameter sharing for token mixing. However, the converse is not true as typical CNNs are not special cases of Mixer. Furthermore, a convolution is more complex than the plain matrix multiplication in MLPs as it requires an additional costly reduction to matrix multiplication and/or specialized implementation.
+
+Despite its simplicity, Mixer attains competitive results. When pre-trained on large datasets (i.e., ${ \sim } 1 0 0 \mathbf { M }$ images), it reaches near state-of-the-art performance, previously claimed by CNNs and Transformers, in terms of the accuracy/cost trade-off. This includes $8 7 . 9 4 \%$ top-1 validation accuracy on ILSVRC2012 “ImageNet” [13]. When pre-trained on data of more modest scale (i.e., ${ \sim } 1 -$ 10M images), coupled with modern regularization techniques [49, 54], Mixer also achieves strong performance. However, similar to ViT, it falls slightly short of specialized CNN architectures.
+
+# 2 Mixer Architecture
+
+Modern deep vision architectures consist of layers that mix features (i) at a given spatial location, (ii) between different spatial locations, or both at once. In CNNs, (ii) is implemented with $N \times N$ convolutions (for $N > 1$ ) and pooling. Neurons in deeper layers have a larger receptive field [1, 29]. At the same time, $1 \times 1$ convolutions also perform (i), and larger kernels perform both (i) and (ii). In Vision Transformers and other attention-based architectures, self-attention layers allow both (i) and (ii) and the MLP-blocks perform (i). The idea behind the Mixer architecture is to clearly separate the per-location (channel-mixing) operations (i) and cross-location (token-mixing) operations (ii). Both operations are implemented with MLPs. Figure 1 summarizes the architecture.
+
+Mixer takes as input a sequence of $S$ non-overlapping image patches, each one projected to a desired hidden dimension $C$ . This results in a two-dimensional real-valued input table, $\mathbf { \bar { X } } \in \mathbb { R } ^ { S \times C }$ . If the original input image has resolution $( H , W )$ , and each patch has resolution $( P , P )$ , then the number of patches is $\bar { S } = \bar { H W } / P ^ { 2 }$ . All patches are linearly projected with the same projection matrix. Mixer consists of multiple layers of identical size, and each layer consists of two MLP blocks. The first one is the token-mixing MLP: it acts on columns of $\mathbf { X }$ (i.e. it is applied to a transposed input table $\mathbf { X } ^ { \top }$ ), maps $\mathbb { R } ^ { S } \mapsto \mathbb { R } ^ { S }$ , and is shared across all columns. The second one is the channel-mixing MLP: it acts on rows of $\mathbf { X }$ , maps $\mathbb { R } ^ { C } \mapsto \mathbb { R } ^ { C }$ , and is shared across all rows. Each MLP block contains two fully-connected layers and a nonlinearity applied independently to each row of its input data tensor. Mixer layers can be written as follows (omitting layer indices):
+
+$$
+\begin{array} { r } { \mathbf { U } _ { * , i } = \mathbf { X } _ { * , i } + \mathbf { W } _ { 2 } \sigma \big ( \mathbf { W } _ { 1 } \mathrm { L a y e r N o r m } ( \mathbf { X } ) _ { * , i } \big ) , \quad \mathrm { f o r } i = 1 \ldots C , } \\ { \mathbf { Y } _ { j , * } = \mathbf { U } _ { j , * } + \mathbf { W } _ { 4 } \sigma \big ( \mathbf { W } _ { 3 } \mathrm { L a y e r N o r m } ( \mathbf { U } ) _ { j , * } \big ) , \quad \mathrm { f o r } j = 1 \ldots S . } \end{array}
+$$
+
+Here $\sigma$ is an element-wise nonlinearity (GELU [16]). $D _ { S }$ and $D _ { C }$ are tunable hidden widths in the token-mixing and channel-mixing MLPs, respectively. Note that $D _ { S }$ is selected independently of the number of input patches. Therefore, the computational complexity of the network is linear in the number of input patches, unlike ViT whose complexity is quadratic. Since $D _ { C }$ is independent of the patch size, the overall complexity is linear in the number of pixels in the image, as for a typical CNN.
+
+As mentioned above, the same channel-mixing MLP (token-mixing MLP) is applied to every row (column) of $\mathbf { X }$ . Tying the parameters of the channel-mixing MLPs (within each layer) is a natural choice—it provides positional invariance, a prominent feature of convolutions. However, tying parameters across channels is much less common. For example, separable convolutions [9, 40], used in some CNNs, apply convolutions to each channel independently of the other channels. However, in separable convolutions, a different convolutional kernel is applied to each channel unlike the token-mixing MLPs in Mixer that share the same kernel (of full receptive field) for all of the channels. The parameter tying prevents the architecture from growing too fast when increasing the hidden dimension $C$ or the sequence length $S$ and leads to significant memory savings. Surprisingly, this choice does not affect the empirical performance, see Supplementary A.1.
+
+Each layer in Mixer (except for the initial patch projection layer) takes an input of the same size. This “isotropic” design is most similar to Transformers, or deep RNNs in other domains, that also use a fixed width. This is unlike most CNNs, which have a pyramidal structure: deeper layers have a lower resolution input, but more channels. Note that while these are the typical designs, other combinations exist, such as isotropic ResNets [38] and pyramidal ViTs [52].
+
+Aside from the MLP layers, Mixer uses other standard architectural components: skip-connections [15] and layer normalization [2]. Unlike ViTs, Mixer does not use position embeddings because the token-mixing MLPs are sensitive to the order of the input tokens. Finally, Mixer uses a standard classification head with the global average pooling layer followed by a linear classifier. Overall, the architecture can be written compactly in JAX/Flax, the code is given in Supplementary F.
+
+# 3 Experiments
+
+We evaluate the performance of MLP-Mixer models, pre-trained with medium- to large-scale datasets, on a range of small and mid-sized downstream classification tasks. We are interested in three primary quantities: (1) Accuracy on the downstream task; (2) Total computational cost of pre-training, which is important when training the model from scratch on the upstream dataset; (3) Test-time throughput, which is important to the practitioner. Our goal is not to demonstrate state-of-the-art results, but to show that, remarkably, a simple MLP-based model is competitive with today’s best convolutional and attention-based models.
+
+Downstream tasks We use popular downstream tasks such as ILSVRC2012 “ImageNet” (1.3M training examples, 1k classes) with the original validation labels [13] and cleaned-up ReaL labels [5], CIFAR-10/100 (50k examples, 10/100 classes) [23], Oxford-IIIT Pets (3.7k examples, 36 classes) [33], and Oxford Flowers-102 (2k examples, 102 classes) [32]. We also use the Visual Task Adaptation Benchmark (VTAB-1k), which consists of 19 diverse datasets, each with 1k training examples [58].
+
+Pre-training We follow the standard transfer learning setup: pre-training followed by fine-tuning on the downstream tasks. We pre-train our models on two public datasets: ILSVRC2021 ImageNet, and ImageNet-21k, a superset of ILSVRC2012 that contains 21k classes and 14M images [13]. To assess performance at larger scale, we also train on JFT-300M, a proprietary dataset with 300M examples and 18k classes [44]. We de-duplicate all pre-training datasets with respect to the test sets of the downstream tasks as done in Dosovitskiy et al. [14], Kolesnikov et al. [22]. We pre-train all models at resolution 224 using Adam with $\beta _ { 1 } = 0 . 9$ , $\beta _ { 2 } = 0 . 9 9 9$ , linear learning rate warmup of 10k steps and linear decay, batch size 4 096, weight decay, and gradient clipping at global norm 1. For JFT-300M, we pre-process images by applying the cropping technique from Szegedy et al. [45] in addition to random horizontal flipping. For ImageNet and ImageNet-21k, we employ additional data augmentation and regularization techniques. In particular, we use RandAugment [12], mixup [60], dropout [43], and stochastic depth [19]. This set of techniques was inspired by the timm library [54] and Touvron et al. [48]. More details on these hyperparameters are provided in Supplementary B.
+
+Table 1: Specifications of the Mixer architectures. The “B”, “L”, and “H” (base, large, and huge) model scales follow Dosovitskiy et al. [14]. A brief notation $\mathbf { \ddot { B } } / 1 6 ^ { \mathbf { \ ' } }$ means the model of base scale with patches of resolution $1 6 \times 1 6$ . The number of parameters is reported for an input resolution of 224 and does not include the weights of the classifier head.   
+
+<table><tr><td>Specification</td><td>S/32</td><td>S/16</td><td>B/32</td><td>B/16</td><td>L/32</td><td>L/16</td><td>H/14</td></tr><tr><td>Number of layers</td><td>8</td><td>8</td><td>12</td><td>12</td><td>24</td><td>24</td><td>32</td></tr><tr><td>Patch resolution P×P</td><td>32×32</td><td>16×16</td><td>32×32</td><td>16×16</td><td>32×32</td><td>16×16</td><td>14×14</td></tr><tr><td>Hidden size C</td><td>512</td><td>512</td><td>768</td><td>768</td><td>1024</td><td>1024</td><td>1280</td></tr><tr><td>Sequence length S</td><td>49</td><td>196</td><td>49</td><td>196</td><td>49</td><td>196</td><td>256</td></tr><tr><td>MLP dimension Dc</td><td>2048</td><td>2048</td><td>3072</td><td>3072</td><td>4096</td><td>4096</td><td>5120</td></tr><tr><td>MLP dimension Ds</td><td>256</td><td>256</td><td>384</td><td>384</td><td>512</td><td>512</td><td>640</td></tr><tr><td>Parameters (M)</td><td>19</td><td>18</td><td>60</td><td>59</td><td>206</td><td>207</td><td>431</td></tr></table>
+
+Fine-tuning We fine-tune using momentum SGD, batch size 512, gradient clipping at global norm 1, and a cosine learning rate schedule with a linear warmup. We do not use weight decay when finetuning. Following common practice [22, 48], we also fine-tune at higher resolutions with respect to those used during pre-training. Since we keep the patch resolution fixed, this increases the number of input patches (say from $S$ to $S ^ { \prime }$ ) and thus requires modifying the shape of Mixer’s token-mixing MLP blocks. Formally, the input in Eq. (1) is left-multiplied by a weight matrix $\mathbf { W } _ { 1 } \in \mathbb { R } ^ { D _ { S } \times S }$ and this operation has to be adjusted when changing the input dimension $S$ . For this, we increase the hidden layer width from $D _ { S }$ to $D _ { S ^ { \prime } }$ in proportion to the number of patches and initialize the (now larger) weight matrix $\mathbf { W } _ { 2 } ^ { \prime } \in \mathbb { R } ^ { D _ { S ^ { \prime } } \times S ^ { \prime } }$ with a block-diagonal matrix containing copies of $\mathbf { W } _ { 2 }$ on its diagonal. This particular scheme only allows for $S ^ { \prime } = \breve { K } ^ { 2 } S$ with $K \in \mathbb N$ . See Supplementary C for further details. On the VTAB-1k benchmark we follow the BiT-HyperRule [22] and fine-tune Mixer models at resolution 224 and 448 on the datasets with small and large input images respectively.
+
+Metrics We evaluate the trade-off between the model’s computational cost and quality. For the former we compute two metrics: (1) Total pre-training time on TPU-v3 accelerators, which combines three relevant factors: the theoretical FLOPs for each training setup, the computational efficiency on the relevant training hardware, and the data efficiency. (2) Throughput in images/sec/core on TPU-v3. Since models of different sizes may benefit from different batch sizes, we sweep the batch sizes and report the highest throughput for each model. For model quality, we focus on top-1 downstream accuracy after fine-tuning. On two occasions (Figure 3, right and Figure 4), where fine-tuning all of the models is too costly, we report the few-shot accuracies obtained by solving the $\ell _ { 2 }$ -regularized linear regression problem between the frozen learned representations of images and the labels.
+
+Models We compare various configurations of Mixer, summarized in Table 1, to the most recent, state-of-the-art, CNNs and attention-based models. In all the figures and tables, the MLP-based Mixer models are marked with pink ( ), convolution-based models with yellow $( \circ )$ , and attention-based models with blue ( ). The Vision Transformers (ViTs) have model scales and patch resolutions similar to Mixer. HaloNets are attention-based models that use a ResNet-like structure with local selfattention layers instead of $3 \times 3$ convolutions [51]. We focus on the particularly efficient “HaloNet-H4 (base 128, Conv-12)” model, which is a hybrid variant of the wider HaloNet-H4 architecture with some of the self-attention layers replaced by convolutions. Note, we mark HaloNets with both attention and convolutions with blue ( ). Big Transfer (BiT) [22] models are ResNets optimized for transfer learning. NFNets [7] are normalizer-free ResNets with several optimizations for ImageNet classification. We consider the NFNet- $\cdot \mathrm { F 4 + }$ model variant. We consider MPL [35] and ALIGN [21] for EfficientNet architectures. MPL is pre-trained at very large-scale on JFT-300M images, using meta-pseudo labelling from ImageNet instead of the original labels. We compare to the EfficientNetB6-Wide model variant. ALIGN pre-train image encoder and language encoder on noisy web image text pairs in a contrastive way. We compare to their best EfficientNet-L2 image encoder.
+
+# 3.1 Main results
+
+Table 2 presents comparison of the largest Mixer models to state-of-the-art models from the literature. “ImNet” and “ReaL” columns refer to the original ImageNet validation [13] and cleaned-up ReaL [5] labels. “Avg. $5 ^ { \circ }$ stands for the average performance across all five downstream tasks (ImageNet, CIFAR-10, CIFAR-100, Pets, Flowers). Figure 2 (left) visualizes the accuracy-compute frontier. When pre-trained on ImageNet-21k with additional regularization, Mixer achieves an overall strong performance $8 4 . 1 5 \%$ top-1 on ImageNet), although slightly inferior to other models2. Regularization in this scenario is necessary and Mixer overfits without it, which is consistent with similar observations for ViT [14]. The same conclusion holds when training Mixer from random initialization on ImageNet (see Section 3.2): Mixer-B/16 attains a reasonable score of $7 6 . 4 \%$ at resolution 224, but tends to overfit. This score is similar to a vanilla ResNet50, but behind state-of-the-art CNNs/hybrids for the ImageNet “from scratch” setting, e.g. $8 4 . 7 \%$ BotNet [42] and $8 6 . 5 \%$ NFNet [7].
+
+Table 2: Transfer performance, inference throughput, and training cost. The rows are sorted by inference throughput (fifth column). Mixer has comparable transfer accuracy to state-of-the-art models with similar cost. The Mixer models are fine-tuned at resolution 448. Mixer performance numbers are averaged over three fine-tuning runs and standard deviations are smaller than 0.1.   
+
+<table><tr><td></td><td>ImNet top-1</td><td>ReaL top-1</td><td>Avg 5 top-1</td><td>VTAB-1k 19 tasks</td><td>Throughput img/sec/core</td><td>TPUv3 core-days</td></tr><tr><td colspan="7">Pre-trained on ImageNet-21k (public)</td></tr><tr><td>HaloNet [51]</td><td>85.8</td><td></td><td></td><td></td><td>120</td><td>0.10k</td></tr><tr><td>Mixer-L/16</td><td>84.15</td><td>87.86</td><td>93.91</td><td>74.95</td><td>105</td><td>0.41k</td></tr><tr><td>ViT-L/16 [14]</td><td>85.30</td><td>88.62</td><td>94.39</td><td>72.72</td><td>32</td><td>0.18k</td></tr><tr><td>BiT-R152x4 [22] .</td><td>85.39</td><td></td><td>94.04</td><td>70.64</td><td>26</td><td>0.94k</td></tr><tr><td colspan="7">Pre-trained on JFT-30OM (proprietary)</td></tr><tr><td>NFNet-F4+ [7]</td><td>89.2</td><td></td><td></td><td></td><td>46</td><td>1.86k</td></tr><tr><td>· Mixer-H/14</td><td>87.94</td><td>90.18</td><td>95.71</td><td>75.33</td><td>40</td><td>1.01k</td></tr><tr><td>·BiT-R152x4 [22]</td><td>87.54</td><td>90.54</td><td>95.33</td><td>76.29</td><td>26</td><td>9.90k</td></tr><tr><td>ViT-H/14 [14]</td><td>88.55</td><td>90.72</td><td>95.97</td><td>77.63</td><td>15</td><td>2.30k</td></tr><tr><td colspan="7">Pre-trained on unlabelled or weakly labelled data (proprietary)</td></tr><tr><td>·MPL [35]</td><td>90.0</td><td>91.12</td><td></td><td></td><td>一</td><td>20.48k</td></tr><tr><td>ALIGN[21] T</td><td>88.64</td><td>一</td><td></td><td>79.99</td><td>15</td><td>14.82k</td></tr></table>
+
+When the size of the upstream dataset increases, Mixer’s performance improves significantly. In particular, Mixer-H/14 achieves $8 7 . 9 4 \%$ top-1 accuracy on ImageNet, which is $0 . 5 \%$ better than BiTResNet $1 5 2 \mathrm { x } 4$ and only $0 . 5 \%$ lower than ViT-H/14. Remarkably, Mixer-H/14 runs 2.5 times faster than ViT-H/14 and almost twice as fast as BiT. Overall, Figure 2 (left) supports our main claim that in terms of the accuracy-compute trade-off Mixer is competitive with more conventional neural network architectures. The figure also demonstrates a clear correlation between the total pre-training cost and the downstream accuracy, even across architecture classes.
+
+BiT-ResNet1 $5 2 \mathrm { x } 4$ in the table are pre-trained using SGD with momentum and a long schedule. Since Adam tends to converge faster, we complete the picture in Figure 2 (left) with the BiT-R200x3 model from Dosovitskiy et al. [14] pre-trained on JFT-300M using Adam. This ResNet has a slightly lower accuracy, but considerably lower pre-training compute. Finally, the results of smaller ViT-L/16 and Mixer-L/16 models are also reported in this figure.
+
+# 3.2 The role of the model scale
+
+The results outlined in the previous section focus on (large) models at the upper end of the compute spectrum. We now turn our attention to smaller Mixer models.
+
+We may scale the model in two independent ways: (1) Increasing the model size (number of layers, hidden dimension, MLP widths) when pre-training; (2) Increasing the input image resolution when fine-tuning. While the former affects both pre-training compute and test-time throughput, the latter only affects the throughput. Unless stated otherwise, we fine-tune at resolution 224.
+
+![](images/e888ec18a5f1ffc5126a75c42bc7c88e5c7569217134a6f3ca6be02f3064c9b2.jpg)  
+Figure 2: Left: ImageNet accuracy/training cost Pareto frontier (dashed line) for the SOTA models in Table 2. Models are pre-trained on ImageNet-21k, or JFT (labelled, or pseudo-labelled for MPL), or web image text pairs. Mixer is as good as these extremely performant ResNets, ViTs, and hybrid models, and sits on frontier with HaloNet, ViT, NFNet, and MPL. Right: Mixer (solid) catches or exceeds BiT (dotted) and ViT (dashed) as the data size grows. Every point on a curve uses the same pre-training compute; they correspond to pre-training on $3 \%$ , $10 \%$ , $30 \%$ , and $100 \%$ of JFT-300M for 233, 70, 23, and 7 epochs, respectively. Additional points at ${ \sim } 3 \mathbf { B }$ correspond to pre-training on an even larger JFT-3B dataset for the same number of total steps. Mixer improves more rapidly with data than ResNets, or even ViT. The gap between large Mixer and ViT models shrinks.
+
+![](images/dcb60c2290be7785a89bed98d1d0cadb3b9e81795e4b5a5cc118b0fb971d4aa5.jpg)  
+Figure 3: The role of the model scale. ImageNet validation top-1 accuracy vs. total pre-training compute (left) and throughput (right) of ViT, BiT, and Mixer models at various scales. All models are pre-trained on JFT-300M and fine-tuned at resolution 224, which is lower than in Figure 2 (left).
+
+We compare various configurations of Mixer (see Table 1) to ViT models of similar scales and BiT models pre-trained with Adam. The results are summarized in Table 3 and Figure 3. When trained from scratch on ImageNet, Mixer-B/16 achieves a reasonable top-1 accuracy of $7 6 . 4 4 \%$ . This is $3 \%$ behind the ViT-B/16 model. The training curves (not reported) reveal that both models achieve very similar values of the training loss. In other words, Mixer-B/16 overfits more than ViT-B/16. For the Mixer-L/16 and ViT-L/16 models this difference is even more pronounced.
+
+As the pre-training dataset grows, Mixer’s performance steadily improves. Remarkably, Mixer-H/14 pre-trained on JFT-300M and fine-tuned at 224 resolution is only $0 . 3 \%$ behind ViT-H/14 on ImageNet whilst running 2.2 times faster. Figure 3 clearly demonstrates that although Mixer is slightly below the frontier on the lower end of model scales, it sits confidently on the frontier at the high end.
+
+# 3.3 The role of the pre-training dataset size
+
+The results presented thus far demonstrate that pre-training on larger datasets significantly improves Mixer’s performance. Here, we study this effect in more detail.
+
+To study Mixer’s ability to make use of the growing number of training examples we pre-train Mixer-B/32, Mixer-L/32, and Mixer-L/16 models on random subsets of JFT-300M containing $3 \%$ , $10 \%$ , $30 \%$ and $100 \%$ of all the training examples for 233, 70, 23, and 7 epochs. Thus, every model is pre-trained for the same number of total steps. We also pre-train Mixer-L/16 model on an even larger JFT-3B dataset [59] containing roughly 3B images with 30k classes for the same number of total steps.
+
+Table 3: Performance of Mixer and other models from the literature across various model and pre-training dataset scales. “Avg. 5” denotes the average performance across five downstream tasks. Mixer and ViT models are averaged over three fine-tuning runs, standard deviations are smaller than 0.15. $( \ddagger )$ Extrapolated from the numbers reported for the same models pre-trained on JFT-300M without extra regularization. $\mathbf { \Pi } ( \widehat { \mathbf { a } } )$ Numbers provided by authors of Dosovitskiy et al. [14] through personal communication. Rows are sorted by throughput.   
+
+<table><tr><td></td><td>Image size</td><td>Pre-Train Epochs</td><td>ImNet top-1</td><td>ReaL top-1</td><td></td><td>Avg.5Throughput top-1 (img/sec/core） core-days</td><td>TPUv3</td></tr><tr><td colspan="8">Pre-trained on ImageNet (with extra regularization)</td></tr><tr><td>Mixer-B/16</td><td>224</td><td>300</td><td>76.44</td><td>82.36</td><td>88.33</td><td>1384</td><td>0.01k(t)</td></tr><tr><td>ViT-B/16 ()</td><td>224</td><td>300</td><td>79.67</td><td>84.97</td><td>90.79</td><td>861</td><td>0.02k(±)</td></tr><tr><td>Mixer-L/16 .</td><td>224</td><td>300</td><td>71.76</td><td>77.08</td><td>87.25</td><td>419</td><td>0.04k(t)</td></tr><tr><td>ViT-L/16 ()</td><td>224</td><td>300</td><td>76.11</td><td>80.93</td><td>89.66</td><td>280</td><td>0.05k($)</td></tr><tr><td colspan="8">Pre-trained on ImageNet-21k (with extra regularization)</td></tr><tr><td>·Mixer-B/16</td><td>224</td><td>300</td><td>80.64</td><td>85.80</td><td>92.50</td><td>1384</td><td>0.15k(t)</td></tr><tr><td>ViT-B/16 ()</td><td>224</td><td>300</td><td>84.59</td><td>88.93</td><td>94.16</td><td>861</td><td>0.18k(t)</td></tr><tr><td>Mixer-L/16</td><td>224</td><td>300</td><td>82.89</td><td>87.54</td><td>93.63</td><td>419</td><td>0.41k($)</td></tr><tr><td>ViT-L/16 (a)</td><td>224</td><td>300</td><td>84.46</td><td>88.35</td><td>94.49</td><td>280</td><td>0.55k(t)</td></tr><tr><td>·Mixer-L/16</td><td>448</td><td>300</td><td>83.91</td><td>87.75</td><td>93.86</td><td>105</td><td>0.41k($)</td></tr><tr><td colspan="8">Pre-trained on JFT-300M</td></tr><tr><td>·Mixer-S/32</td><td>224</td><td>5</td><td>68.70</td><td>75.83</td><td>87.13</td><td>11489</td><td>0.01k</td></tr><tr><td>Mixer-B/32</td><td>224</td><td>7</td><td>75.53</td><td>81.94</td><td>90.99</td><td>4208</td><td>0.05k</td></tr><tr><td>Mixer-S/16</td><td>224</td><td>5</td><td>73.83</td><td>80.60</td><td>89.50</td><td>3994</td><td>0.03k</td></tr><tr><td>BiT-R50x1</td><td>224</td><td>7</td><td>73.69</td><td>81.92</td><td>一</td><td>2159</td><td>0.08k</td></tr><tr><td>Mixer-B/16</td><td>224</td><td>7</td><td>80.00</td><td>85.56</td><td>92.60</td><td>1384</td><td>0.08k</td></tr><tr><td>·Mixer-L/32</td><td>224</td><td>7</td><td>80.67</td><td>85.62</td><td>93.24</td><td>1314</td><td>0.12k</td></tr><tr><td>BiT-R152x1</td><td>224</td><td>7</td><td>79.12</td><td>86.12</td><td></td><td>932</td><td>0.14k</td></tr><tr><td>BiT-R50x2</td><td>224</td><td>7</td><td>78.92</td><td>86.06</td><td></td><td>890</td><td>0.14k</td></tr><tr><td>BiT-R152x2</td><td>224</td><td>14</td><td>83.34</td><td>88.90</td><td></td><td>356</td><td>0.58k</td></tr><tr><td>Mixer-L/16</td><td>224</td><td>7</td><td>84.05</td><td>88.14</td><td>94.51</td><td>419</td><td>0.23k</td></tr><tr><td>·Mixer-L/16</td><td>224</td><td>14</td><td>84.82</td><td>88.48</td><td>94.77</td><td>419</td><td>0.45k</td></tr><tr><td>ViT-L/16</td><td>224</td><td>14</td><td>85.63</td><td>89.16</td><td>95.21</td><td>280</td><td>0.65k</td></tr><tr><td>Mixer-H/14</td><td>224</td><td>14</td><td>86.32</td><td>89.14</td><td>95.49</td><td>194</td><td>1.01k</td></tr><tr><td>. BiT-R200x3</td><td>224</td><td>14</td><td>84.73</td><td>89.58</td><td></td><td>141</td><td>1.78k</td></tr><tr><td>Mixer-L/16</td><td>448</td><td>14</td><td>86.78</td><td>89.72</td><td>95.13</td><td>105</td><td>0.45k</td></tr><tr><td>ViT-H/14</td><td>224</td><td>14</td><td>86.65</td><td>89.56</td><td>95.57</td><td>87</td><td>2.30k</td></tr><tr><td>ViT-L/16 [14]</td><td>512</td><td>14</td><td>87.76</td><td>90.54</td><td>95.63</td><td>32</td><td>0.65k</td></tr></table>
+
+While not strictly comparable, this allows us to further extrapolate the effect of scale. We use the linear 5-shot top-1 accuracy on ImageNet as a proxy for transfer quality. For every pre-training run we perform early stopping based on the best upstream validation performance. Results are reported in Figure 2 (right), where we also include ViT-B/32, ViT-L/32, ViT-L/16, and BiT- $\mathbf { R } 1 5 2 \mathbf { x } 2$ models.
+
+When pre-trained on the smallest subset of JFT-300M, all Mixer models strongly overfit. BiT models also overfit, but to a lesser extent, possibly due to the strong inductive biases associated with the convolutions. As the dataset increases, the performance of both Mixer-L/32 and Mixer-L/16 grows faster than BiT; Mixer-L/16 keeps improving, while the BiT model plateaus.
+
+The same conclusions hold for ViT, consistent with Dosovitskiy et al. [14]. However, the relative improvement of larger Mixer models are even more pronounced. The performance gap between Mixer-L/16 and ViT-L/16 shrinks with data scale. It appears that Mixer benefits from the growing dataset size even more than ViT. One could speculate and explain it again with the difference in inductive biases: self-attention layers in ViT lead to certain properties of the learned functions that are less compatible with the true underlying distribution than those discovered with Mixer architecture.
+
+# 3.4 Invariance to input permutations
+
+In this section, we study the difference between inductive biases of Mixer and CNN architectures. Specifically, we train Mixer-B/16 and ResNet50x1 models on JFT-300M following the pre-training setup described in Section 3 and using one of two different input transformations: (1) Shuffle the order of $1 6 \times 1 6$ patches and permute pixels within each patch with a shared permutation; (2) Permute the pixels globally in the entire image. Same permutation is used across all images. We report the linear 5-shot top-1 accuracy of the trained models on ImageNet in Figure 4 (bottom). Some original images along with their two transformed versions appear in Figure 4 (top). As could be expected, Mixer is invariant to the order of patches and pixels within the patches (the blue and green curves match perfectly). On the other hand, ResNet’s strong inductive bias relies on a particular order of pixels within an image and its performance drops significantly when the patches are permuted. Remarkably, when globally permuting the pixels, Mixer’s performance drops much less ( ${ \sim } 4 5 \%$ drop) compared to the ResNet $\sim 7 5 \%$ drop).
+
+![](images/4d73edba72e7ee7ea5c72a0d41ac9476e577939a71c5c92b54605615df0e5d5c.jpg)  
+Figure 4: Top: Input examples from ImageNet before permuting the contents (left); after shuffling the $1 6 \times 1 6$ patches and pixels within the patches (center); after shuffling pixels globally (right). Bottom: Mixer-B/16 (left) and ResNet50x1 (right) trained with three corresponding input pipelines.
+
+![](images/6580eadc8dc26ea6d1683a42b8533e69114404d978ae2cc5853f9e28e8fb58f1.jpg)  
+Figure 5: Hidden units in the first (left), second (center), and third (right) token-mixing MLPs of a Mixer-B/16 model trained on JFT-300M. Each unit has 196 weights, one for each of the $1 4 \times 1 4$ incoming patches. We pair the units to highlight the emergence of kernels of opposing phase. Pairs are sorted by filter frequency. In contrast to the kernels of convolutional filters, where each weight corresponds to one pixel in the input image, one weight in any plot from the left column corresponds to a particular $1 6 \times 1 6$ patch of the input image. Complete plots in Supplementary D.
+
+# 3.5 Visualization
+
+It is commonly observed that the first layers of CNNs tend to learn Gabor-like detectors that act on pixels in local regions of the image. In contrast, Mixer allows for global information exchange in the token-mixing MLPs, which begs the question whether it processes information in a similar fashion. Figure 5 shows hidden units of the first three token-mixing MLPs of Mixer trained on JFT-300M. Recall that the token-mixing MLPs allow global communication between different spatial locations. Some of the learned features operate on the entire image, while others operate on smaller regions. Deeper layers appear to have no clearly identifiable structure. Similar to CNNs, we observe many pairs of feature detectors with opposite phases [39]. The structure of learned units depends on the hyperparameters. Plots for the first embedding layer appear in Figure 2 of Supplementary D.
+
+# 4 Related work
+
+MLP-Mixer is a new architecture for computer vision that differs from previous successful architectures because it uses neither convolutional nor self-attention layers. Nevertheless, the design choices can be traced back to ideas from the literature on CNNs [24, 25] and Transformers [50].
+
+CNNs have been the de-facto standard in computer vision since the AlexNet model [24] surpassed prevailing approaches based on hand-crafted image features [36]. Many works focused on improving the design of CNNs. Simonyan and Zisserman [41] demonstrated that one can train state-of-the-art models using only convolutions with small $3 \times 3$ kernels. He et al. [15] introduced skip-connections together with the batch normalization [20], which enabled training of very deep neural networks and further improved performance. A prominent line of research has investigated the benefits of using sparse convolutions, such as grouped [57] or depth-wise [9, 17] variants. In a similar spirit to our token-mixing MLPs, Wu et al. [55] share parameters in the depth-wise convolutions for natural language processing. Hu et al. [18] and Wang et al. [53] propose to augment convolutional networks with non-local operations to partially alleviate the constraint of local processing from CNNs. Mixer takes the idea of using convolutions with small kernels to the extreme: by reducing the kernel size to $1 \times 1$ it turns convolutions into standard dense matrix multiplications applied independently to each spatial location (channel-mixing MLPs). This alone does not allow aggregation of spatial information and to compensate we apply dense matrix multiplications that are applied to every feature across all spatial locations (token-mixing MLPs). In Mixer, matrix multiplications are applied row-wise or column-wise on the “patches $\times$ features” input table, which is also closely related to the work on sparse convolutions. Mixer uses skip-connections [15] and normalization layers [2, 20].
+
+In computer vision, self-attention based Transformer architectures were initially applied for generative modeling [8, 34]. Their value for image recognition was demonstrated later, albeit in combination with a convolution-like locality bias [37], or on low-resolution images [10]. Dosovitskiy et al. [14] introduced ViT, a pure transformer model that has fewer locality biases, but scales well to large data. ViT achieves state-of-the-art performance on popular vision benchmarks while retaining the robustness of CNNs [6]. Touvron et al. [49] trained ViT effectively on smaller datasets using extensive regularization. Mixer borrows design choices from recent transformer-based architectures. The design of Mixer’s MLP-blocks originates in [27, 50]. Converting images to a sequence of patches and directly processing embeddings of these patches originates in Dosovitskiy et al. [14].
+
+Many recent works strive to design more effective architectures for vision. Srinivas et al. [42] replace $3 \times 3$ convolutions in ResNets by self-attention layers. Ramachandran et al. [37], Tay et al. [47], Li et al. [26], and Bello [3] design networks with new attention-like mechanisms. Mixer can be seen as a step in an orthogonal direction, without reliance on locality bias and attention mechanisms.
+
+The work of Lin et al. [28] is closely related. It attains reasonable performance on CIFAR-10 using fully connected networks, heavy data augmentation, and pre-training with an auto-encoder. Neyshabur [31] devises custom regularization and optimization algorithms and trains a fully-connected network, attaining impressive performance on small-scale tasks. Instead we rely on token and channel-mixing MLPs, use standard regularization and optimization techniques, and scale to large data effectively.
+
+Traditionally, networks evaluated on ImageNet [13] are trained from random initialization using Inception-style pre-processing [46]. For smaller datasets, transfer of ImageNet models is popular. However, modern state-of-the-art models typically use either weights pre-trained on larger datasets, or more recent data-augmentation and training strategies. For example, Dosovitskiy et al. [14], Kolesnikov et al. [22], Mahajan et al. [30], Pham et al. [35], Xie et al. [56] all advance state-of-the-art in image classification using large-scale pre-training. Examples of improvements due to augmentation or regularization changes include Cubuk et al. [11], who attain excellent classification performance with learned data augmentation, and Bello et al. [4], who show that canonical ResNets are still near state-of-the-art, if one uses recent training and augmentation strategies.
+
+# 5 Conclusions
+
+We describe a very simple architecture for vision. Our experiments demonstrate that it is as good as existing state-of-the-art methods in terms of the trade-off between accuracy and computational resources required for training and inference. We believe these results open many questions. On the practical side, it may be useful to study the features learned by the model and identify the main differences (if any) from those learned by CNNs and Transformers. On the theoretical side, we would like to understand the inductive biases hidden in these various features and eventually their role in generalization. Most of all, we hope that our results spark further research, beyond the realms of established models based on convolutions and self-attention. It would be particularly interesting to see whether such a design works in NLP or other domains.
+
+# Acknowledgments and Disclosure of Funding
+
+The work was performed in the Brain teams in Berlin and Zürich. We thank Josip Djolonga for feedback on the initial version of the paper; Preetum Nakkiran for proposing to train MLP-Mixer on input images with shuffled pixels; Olivier Bousquet, Yann Dauphin, and Dirk Weissenborn for useful discussions.
+
+# References
+
+[1] A. Araujo, W. Norris, and J. Sim. Computing receptive fields of convolutional neural networks. Distill, 2019. doi: 10.23915/distill.00021. URL https://distill.pub/2019/ computing-receptive-fields.   
+[2] J. L. Ba, J. R. Kiros, and G. E. Hinton. Layer normalization. arXiv preprint arXiv:1607.06450, 2016.   
+[3] I. Bello. LambdaNetworks: Modeling long-range interactions without attention. arXiv preprint arXiv:2102.08602, 2021.   
+[4] I. Bello, W. Fedus, X. Du, E. D. Cubuk, A. Srinivas, T.-Y. Lin, J. Shlens, and B. Zoph. Revisiting ResNets: Improved training and scaling strategies. arXiv preprint arXiv:2103.07579, 2021.   
+[5] L. Beyer, O. J. Hénaff, A. Kolesnikov, X. Zhai, and A. van den Oord. Are we done with ImageNet? arXiv preprint arXiv:2006.07159, 2020.   
+[6] S. Bhojanapalli, A. Chakrabarti, D. Glasner, D. Li, T. Unterthiner, and A. Veit. Understanding robustness of transformers for image classification. arXiv preprint arXiv:2103.14586, 2021.   
+[7] A. Brock, S. De, S. L. Smith, and K. Simonyan. High-performance large-scale image recognition without normalization. arXiv preprint arXiv:2102.06171, 2021.   
+[8] R. Child, S. Gray, A. Radford, and I. Sutskever. Generating long sequences with sparse transformers. arXiv preprint arXiv:1904.10509, 2019.   
+[9] F. Chollet. Xception: Deep learning with depthwise separable convolutions. In CVPR, 2017.   
+[10] J.-B. Cordonnier, A. Loukas, and M. Jaggi. On the relationship between self-attention and convolutional layers. In ICLR, 2020.   
+[11] E. D. Cubuk, B. Zoph, D. Mane, V. Vasudevan, and Q. V. Le. AutoAugment: Learning augmentation policies from data. In CVPR, 2019.   
+[12] E. D. Cubuk, B. Zoph, J. Shlens, and Q. V. Le. RandAugment: Practical automated data augmentation with a reduced search space. In CVPR Workshops, 2020.   
+[13] J. Deng, W. Dong, R. Socher, L. Li, Kai Li, and Li Fei-Fei. ImageNet: A large-scale hierarchical image database. In CVPR, 2009.   
+[14] A. Dosovitskiy, L. Beyer, A. Kolesnikov, D. Weissenborn, X. Zhai, T. Unterthiner, M. Dehghani, M. Minderer, G. Heigold, S. Gelly, J. Uszkoreit, and N. Houlsby. An image is worth 16x16 words: Transformers for image recognition at scale. In ICLR, 2021.   
+[15] K. He, X. Zhang, S. Ren, and J. Sun. Deep residual learning for image recognition. In CVPR, 2016.   
+[16] D. Hendrycks and K. Gimpel. Gaussian error linear units (GELUs). arXiv preprint arXiv:1606.08415, 2016.   
+[17] A. G. Howard, M. Zhu, B. Chen, D. Kalenichenko, W. Wang, T. Weyand, M. Andreetto, and H. Adam. Mobilenets: Efficient convolutional neural networks for mobile vision applications. arXiv preprint arXiv:1704.04861, 2017.   
+[18] J. Hu, L. Shen, and G. Sun. Squeeze-and-excitation networks. In CVPR, 2018.   
+[19] G. Huang, Y. Sun, Z. Liu, D. Sedra, and K. Q. Weinberger. Deep networks with stochastic depth. In ECCV, 2016.   
+[20] S. Ioffe and C. Szegedy. Batch normalization: Accelerating deep network training by reducing internal covariate shift. In ICML, 2015.   
+[21] C. Jia, Y. Yang, Y. Xia, Y.-T. Chen, Z. Parekh, H. Pham, Q. V. Le, Y. Sung, Z. Li, and T. Duerig. Scaling up visual and vision-language representation learning with noisy text supervision. arXiv preprint arXiv:2102.05918, 2021.   
+[22] A. Kolesnikov, L. Beyer, X. Zhai, J. Puigcerver, J. Yung, S. Gelly, and N. Houlsby. Big transfer (BiT): General visual representation learning. In ECCV, 2020.   
+[23] A. Krizhevsky. Learning multiple layers of features from tiny images. Technical report, University of Toronto, 2009.   
+[24] A. Krizhevsky, I. Sutskever, and G. E. Hinton. ImageNet classification with deep convolutional neural networks. In NeurIPS, 2012.   
+[25] Y. LeCun, B. Boser, J. Denker, D. Henderson, R. Howard, W. Hubbard, and L. Jackel. Backpropagation applied to handwritten zip code recognition. Neural Computation, 1:541–551, 1989.   
+[26] D. Li, J. Hu, C. Wang, X. Li, Q. She, L. Zhu, T. Zhang, and Q. Chen. Involution: Inverting the inherence of convolution for visual recognition. CVPR, 2021.   
+[27] M. Lin, Q. Chen, and S. Yan. Network in network. In ICLR, 2014.   
+[28] Z. Lin, R. Memisevic, and K. Konda. How far can we go without convolution: Improving fullyconnected networks. In ICLR, Workshop Track, 2016.   
+[29] W. Luo, Y. Li, R. Urtasun, and R. Zemel. Understanding the effective receptive field in deep convolutional neural networks. In NeurIPS, 2016.   
+[30] D. Mahajan, R. Girshick, V. Ramanathan, K. He, M. Paluri, Y. Li, A. Bharambe, and L. van der Maaten. Exploring the limits of weakly supervised pretraining. In ECCV, 2018.   
+[31] B. Neyshabur. Towards learning convolutions from scratch. In NeurIPS, 2020.   
+[32] M. Nilsback and A. Zisserman. Automated flower classification over a large number of classes. In ICVGIP, 2008.   
+[33] O. M. Parkhi, A. Vedaldi, A. Zisserman, and C. V. Jawahar. Cats and dogs. In CVPR, 2012.   
+[34] N. Parmar, A. Vaswani, J. Uszkoreit, L. Kaiser, N. Shazeer, A. Ku, and D. Tran. Image transformer. In ICML, 2018.   
+[35] H. Pham, Z. Dai, Q. Xie, M.-T. Luong, and Q. V. Le. Meta pseudo labels. In CVPR, 2021.   
+[36] A. Pinz. Object categorization. Foundations and Trends in Computer Graphics and Vision, 1(4), 2006.   
+[37] P. Ramachandran, N. Parmar, A. Vaswani, I. Bello, A. Levskaya, and J. Shlens. Stand-alone self-attention in vision models. In NeurIPS, 2019.   
+[38] M. Sandler, J. Baccash, A. Zhmoginov, and Howard. Non-discriminative data or weak model? On the relative importance of data and model resolution. In ICCV Workshop on Real-World Recognition from Low-Quality Images and Videos, 2019.   
+[39] W. Shang, K. Sohn, D. Almeida, and H. Lee. Understanding and improving convolutional neural networks via concatenated rectified linear units. In ICML, 2016.   
+[40] L. Sifre. Rigid-Motion Scattering For Image Classification. PhD thesis, Ecole Polytechnique, 2014.   
+[41] K. Simonyan and A. Zisserman. Very deep convolutional networks for large-scale image recognition. In ICLR, 2015.   
+[42] A. Srinivas, T.-Y. Lin, N. Parmar, J. Shlens, P. Abbeel, and A. Vaswani. Bottleneck transformers for visual recognition. arXiv preprint arXiv:2101.11605, 2021.   
+[43] N. Srivastava, G. Hinton, A. Krizhevsky, I. Sutskever, and R. Salakhutdinov. Dropout: A simple way to prevent neural networks from overfitting. JMLR, 15(56), 2014.   
+[44] C. Sun, A. Shrivastava, S. Singh, and A. Gupta. Revisiting unreasonable effectiveness of data in deep learning era. In ICCV, 2017.   
+[45] C. Szegedy, W. Liu, Y. Jia, P. Sermanet, S. Reed, D. Anguelov, D. Erhan, V. Vanhoucke, and A. Rabinovich. Going deeper with convolutions. In CVPR, 2015.   
+[46] C. Szegedy, V. Vanhoucke, S. Ioffe, J. Shlens, and Z. Wojna. Rethinking the inception architecture for computer vision. In CVPR, 2016.   
+[47] Y. Tay, D. Bahri, D. Metzler, D.-C. Juan, Z. Zhao, and C. Zheng. Synthesizer: Rethinking self-attention in transformer models. arXiv, 2020.   
+[48] H. Touvron, A. Vedaldi, M. Douze, and H. Jegou. Fixing the train-test resolution discrepancy. In NeurIPS, 2019.   
+[49] H. Touvron, M. Cord, M. Douze, F. Massa, A. Sablayrolles, and H. Jégou. Training data-efficient image transformers & distillation through attention. arXiv preprint arXiv:2012.12877, 2020.   
+[50] A. Vaswani, N. Shazeer, N. Parmar, J. Uszkoreit, L. Jones, A. N. Gomez, Ł. Kaiser, and I. Polosukhin. Attention is all you need. In NeurIPS, 2017.   
+[51] A. Vaswani, P. Ramachandran, A. Srinivas, N. Parmar, B. Hechtman, and J. Shlens. Scaling local self-attention for parameter efficient visual backbones. arXiv preprint arXiv:2103.12731, 2021.   
+[52] W. Wang, E. Xie, X. Li, D.-P. Fan, K. Song, D. Liang, T. Lu, P. Luo, and L. Shao. Pyramid vision transformer: A versatile backbone for dense prediction without convolutions. arXiv preprint arXiv:2102.12122, 2021.   
+[53] X. Wang, R. Girshick, A. Gupta, and K. He. Non-local neural networks. In CVPR, 2018.   
+[54] R. Wightman. Pytorch image models. https://github.com/rwightman/ pytorch-image-models, 2019.   
+[55] F. Wu, A. Fan, A. Baevski, Y. Dauphin, and M. Auli. Pay less attention with lightweight and dynamic convolutions. In ICLR, 2019.   
+[56] Q. Xie, M.-T. Luong, E. Hovy, and Q. V. Le. Self-training with noisy student improves imagenet classification. In CVPR, 2020.   
+[57] S. Xie, R. Girshick, P. Dollár, Z. Tu, and K. He. Aggregated residual transformations for deep neural networks. arXiv preprint arXiv:1611.05431, 2016.   
+[58] X. Zhai, J. Puigcerver, A. Kolesnikov, P. Ruyssen, C. Riquelme, M. Lucic, J. Djolonga, A. S. Pinto, M. Neumann, A. Dosovitskiy, et al. A large-scale study of representation learning with the visual task adaptation benchmark. arXiv preprint arXiv:1910.04867, 2019.   
+[59] X. Zhai, A. Kolesnikov, N. Houlsby, and L. Beyer. Scaling vision transformers. arXiv preprint arXiv:2106.04560, 2021.   
+[60] H. Zhang, M. Cisse, Y. N. Dauphin, and D. Lopez-Paz. mixup: Beyond empirical risk minimization. In ICLR, 2018.

parse/train/EI2KOXKdnP/EI2KOXKdnP_content_list.json

@@ -0,0 +1,933 @@
+[
+    {
+        "type": "text",
+        "text": "MLP-Mixer: An all-MLP Architecture for Vision ",
+        "text_level": 1,
+        "bbox": [
+            197,
+            122,
+            799,
+            147
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Ilya Tolstikhin∗, Neil Houlsby∗, Alexander Kolesnikov∗, Lucas Beyer∗, ",
+        "bbox": [
+            264,
+            195,
+            754,
+            212
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Xiaohua Zhai, Thomas Unterthiner, Jessica Yung, Andreas Steiner, ",
+        "bbox": [
+            274,
+            217,
+            745,
+            232
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Daniel Keysers, Jakob Uszkoreit, Mario Lucic, Alexey Dosovitskiy ",
+        "bbox": [
+            276,
+            238,
+            743,
+            252
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "∗equal contribution ",
+        "bbox": [
+            446,
+            258,
+            573,
+            272
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Google Research, Brain Team ",
+        "bbox": [
+            410,
+            277,
+            607,
+            290
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "{tolstikhin, neilhoulsby, akolesnikov, lbeyer, xzhai, unterthiner, jessicayung†, andstein, keysers, usz, lucic, adosovitskiy}@google.com ",
+        "bbox": [
+            312,
+            296,
+            705,
+            338
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "†work done during Google AI Residency ",
+        "bbox": [
+            375,
+            344,
+            642,
+            359
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Abstract ",
+        "text_level": 1,
+        "bbox": [
+            462,
+            400,
+            535,
+            416
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Convolutional Neural Networks (CNNs) are the go-to model for computer vision. Recently, attention-based networks, such as the Vision Transformer, have also become popular. In this paper we show that while convolutions and attention are both sufficient for good performance, neither of them are necessary. We present MLP-Mixer, an architecture based exclusively on multi-layer perceptrons (MLPs). MLP-Mixer contains two types of layers: one with MLPs applied independently to image patches (i.e. “mixing” the per-location features), and one with MLPs applied across patches (i.e. “mixing” spatial information). When trained on large datasets, or with modern regularization schemes, MLP-Mixer attains competitive scores on image classification benchmarks, with pre-training and inference cost comparable to state-of-the-art models. We hope that these results spark further research beyond the realms of well established CNNs and Transformers.1 ",
+        "bbox": [
+            233,
+            431,
+            766,
+            597
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 Introduction ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            623,
+            310,
+            640
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "As the history of computer vision demonstrates, the availability of larger datasets coupled with increased computational capacity often leads to a paradigm shift. While Convolutional Neural Networks (CNNs) have been the de-facto standard for computer vision, recently Vision Transformers [14] (ViT), an alternative based on self-attention layers, attained state-of-the-art performance. ViT continues the long-lasting trend of removing hand-crafted visual features and inductive biases from models and relies further on learning from raw data. ",
+        "bbox": [
+            174,
+            654,
+            825,
+            738
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "We propose the MLP-Mixer architecture (or “Mixer” for short), a competitive but conceptually and technically simple alternative, that does not use convolutions or self-attention. Instead, Mixer’s architecture is based entirely on multi-layer perceptrons (MLPs) that are repeatedly applied across either spatial locations or feature channels. Mixer relies only on basic matrix multiplication routines, changes to data layout (reshapes and transpositions), and scalar nonlinearities. ",
+        "bbox": [
+            174,
+            744,
+            825,
+            814
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Figure 1 depicts the macro-structure of Mixer. It accepts a sequence of linearly projected image patches (also referred to as tokens) shaped as a “patches $\\times$ channels” table as an input, and maintains this dimensionality. Mixer makes use of two types of MLP layers: channel-mixing MLPs and token-mixing MLPs. The channel-mixing MLPs allow communication between different channels; ",
+        "bbox": [
+            174,
+            820,
+            823,
+            876
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "image",
+        "img_path": "images/759c8bb1b0f4ebf46f621f72824e0a25d409516ac63197eee33154d2126e49cb.jpg",
+        "image_caption": [
+            "Figure 1: MLP-Mixer consists of per-patch linear embeddings, Mixer layers, and a classifier head. Mixer layers contain one token-mixing MLP and one channel-mixing MLP, each consisting of two fully-connected layers and a GELU nonlinearity. Other components include: skip-connections, dropout, and layer norm on the channels. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            225,
+            93,
+            772,
+            313
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "they operate on each token independently and take individual rows of the table as inputs. The token-mixing MLPs allow communication between different spatial locations (tokens); they operate on each channel independently and take individual columns of the table as inputs. These two types of layers are interleaved to enable interaction of both input dimensions. ",
+        "bbox": [
+            174,
+            405,
+            825,
+            460
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "In the extreme case, our architecture can be seen as a very special CNN, which uses $1 \\times 1$ convolutions for channel mixing, and single-channel depth-wise convolutions of a full receptive field and parameter sharing for token mixing. However, the converse is not true as typical CNNs are not special cases of Mixer. Furthermore, a convolution is more complex than the plain matrix multiplication in MLPs as it requires an additional costly reduction to matrix multiplication and/or specialized implementation. ",
+        "bbox": [
+            174,
+            467,
+            825,
+            537
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Despite its simplicity, Mixer attains competitive results. When pre-trained on large datasets (i.e., ${ \\sim } 1 0 0 \\mathbf { M }$ images), it reaches near state-of-the-art performance, previously claimed by CNNs and Transformers, in terms of the accuracy/cost trade-off. This includes $8 7 . 9 4 \\%$ top-1 validation accuracy on ILSVRC2012 “ImageNet” [13]. When pre-trained on data of more modest scale (i.e., ${ \\sim } 1 -$ 10M images), coupled with modern regularization techniques [49, 54], Mixer also achieves strong performance. However, similar to ViT, it falls slightly short of specialized CNN architectures. ",
+        "bbox": [
+            174,
+            542,
+            826,
+            627
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2 Mixer Architecture ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            650,
+            367,
+            666
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Modern deep vision architectures consist of layers that mix features (i) at a given spatial location, (ii) between different spatial locations, or both at once. In CNNs, (ii) is implemented with $N \\times N$ convolutions (for $N > 1$ ) and pooling. Neurons in deeper layers have a larger receptive field [1, 29]. At the same time, $1 \\times 1$ convolutions also perform (i), and larger kernels perform both (i) and (ii). In Vision Transformers and other attention-based architectures, self-attention layers allow both (i) and (ii) and the MLP-blocks perform (i). The idea behind the Mixer architecture is to clearly separate the per-location (channel-mixing) operations (i) and cross-location (token-mixing) operations (ii). Both operations are implemented with MLPs. Figure 1 summarizes the architecture. ",
+        "bbox": [
+            174,
+            683,
+            825,
+            795
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Mixer takes as input a sequence of $S$ non-overlapping image patches, each one projected to a desired hidden dimension $C$ . This results in a two-dimensional real-valued input table, $\\mathbf { \\bar { X } } \\in \\mathbb { R } ^ { S \\times C }$ . If the original input image has resolution $( H , W )$ , and each patch has resolution $( P , P )$ , then the number of patches is $\\bar { S } = \\bar { H W } / P ^ { 2 }$ . All patches are linearly projected with the same projection matrix. Mixer consists of multiple layers of identical size, and each layer consists of two MLP blocks. The first one is the token-mixing MLP: it acts on columns of $\\mathbf { X }$ (i.e. it is applied to a transposed input table $\\mathbf { X } ^ { \\top }$ ), maps $\\mathbb { R } ^ { S } \\mapsto \\mathbb { R } ^ { S }$ , and is shared across all columns. The second one is the channel-mixing MLP: it acts on rows of $\\mathbf { X }$ , maps $\\mathbb { R } ^ { C } \\mapsto \\mathbb { R } ^ { C }$ , and is shared across all rows. Each MLP block contains two fully-connected layers and a nonlinearity applied independently to each row of its input data tensor. Mixer layers can be written as follows (omitting layer indices): ",
+        "bbox": [
+            174,
+            800,
+            825,
+            911
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            90,
+            823,
+            119
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/2c8c6654efa6c7166ff291d40e60d324d625c8579bcf986e46cbc1e3cf546ea9.jpg",
+        "text": "$$\n\\begin{array} { r } { \\mathbf { U } _ { * , i } = \\mathbf { X } _ { * , i } + \\mathbf { W } _ { 2 } \\sigma \\big ( \\mathbf { W } _ { 1 } \\mathrm { L a y e r N o r m } ( \\mathbf { X } ) _ { * , i } \\big ) , \\quad \\mathrm { f o r } i = 1 \\ldots C , } \\\\ { \\mathbf { Y } _ { j , * } = \\mathbf { U } _ { j , * } + \\mathbf { W } _ { 4 } \\sigma \\big ( \\mathbf { W } _ { 3 } \\mathrm { L a y e r N o r m } ( \\mathbf { U } ) _ { j , * } \\big ) , \\quad \\mathrm { f o r } j = 1 \\ldots S . } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            279,
+            122,
+            718,
+            162
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Here $\\sigma$ is an element-wise nonlinearity (GELU [16]). $D _ { S }$ and $D _ { C }$ are tunable hidden widths in the token-mixing and channel-mixing MLPs, respectively. Note that $D _ { S }$ is selected independently of the number of input patches. Therefore, the computational complexity of the network is linear in the number of input patches, unlike ViT whose complexity is quadratic. Since $D _ { C }$ is independent of the patch size, the overall complexity is linear in the number of pixels in the image, as for a typical CNN. ",
+        "bbox": [
+            174,
+            165,
+            825,
+            234
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "As mentioned above, the same channel-mixing MLP (token-mixing MLP) is applied to every row (column) of $\\mathbf { X }$ . Tying the parameters of the channel-mixing MLPs (within each layer) is a natural choice—it provides positional invariance, a prominent feature of convolutions. However, tying parameters across channels is much less common. For example, separable convolutions [9, 40], used in some CNNs, apply convolutions to each channel independently of the other channels. However, in separable convolutions, a different convolutional kernel is applied to each channel unlike the token-mixing MLPs in Mixer that share the same kernel (of full receptive field) for all of the channels. The parameter tying prevents the architecture from growing too fast when increasing the hidden dimension $C$ or the sequence length $S$ and leads to significant memory savings. Surprisingly, this choice does not affect the empirical performance, see Supplementary A.1. ",
+        "bbox": [
+            173,
+            239,
+            825,
+            378
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Each layer in Mixer (except for the initial patch projection layer) takes an input of the same size. This “isotropic” design is most similar to Transformers, or deep RNNs in other domains, that also use a fixed width. This is unlike most CNNs, which have a pyramidal structure: deeper layers have a lower resolution input, but more channels. Note that while these are the typical designs, other combinations exist, such as isotropic ResNets [38] and pyramidal ViTs [52]. ",
+        "bbox": [
+            173,
+            385,
+            825,
+            455
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Aside from the MLP layers, Mixer uses other standard architectural components: skip-connections [15] and layer normalization [2]. Unlike ViTs, Mixer does not use position embeddings because the token-mixing MLPs are sensitive to the order of the input tokens. Finally, Mixer uses a standard classification head with the global average pooling layer followed by a linear classifier. Overall, the architecture can be written compactly in JAX/Flax, the code is given in Supplementary F. ",
+        "bbox": [
+            174,
+            460,
+            825,
+            531
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3 Experiments ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            549,
+            312,
+            566
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "We evaluate the performance of MLP-Mixer models, pre-trained with medium- to large-scale datasets, on a range of small and mid-sized downstream classification tasks. We are interested in three primary quantities: (1) Accuracy on the downstream task; (2) Total computational cost of pre-training, which is important when training the model from scratch on the upstream dataset; (3) Test-time throughput, which is important to the practitioner. Our goal is not to demonstrate state-of-the-art results, but to show that, remarkably, a simple MLP-based model is competitive with today’s best convolutional and attention-based models. ",
+        "bbox": [
+            173,
+            579,
+            825,
+            676
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Downstream tasks We use popular downstream tasks such as ILSVRC2012 “ImageNet” (1.3M training examples, 1k classes) with the original validation labels [13] and cleaned-up ReaL labels [5], CIFAR-10/100 (50k examples, 10/100 classes) [23], Oxford-IIIT Pets (3.7k examples, 36 classes) [33], and Oxford Flowers-102 (2k examples, 102 classes) [32]. We also use the Visual Task Adaptation Benchmark (VTAB-1k), which consists of 19 diverse datasets, each with 1k training examples [58]. ",
+        "bbox": [
+            174,
+            683,
+            825,
+            752
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Pre-training We follow the standard transfer learning setup: pre-training followed by fine-tuning on the downstream tasks. We pre-train our models on two public datasets: ILSVRC2021 ImageNet, and ImageNet-21k, a superset of ILSVRC2012 that contains 21k classes and 14M images [13]. To assess performance at larger scale, we also train on JFT-300M, a proprietary dataset with 300M examples and 18k classes [44]. We de-duplicate all pre-training datasets with respect to the test sets of the downstream tasks as done in Dosovitskiy et al. [14], Kolesnikov et al. [22]. We pre-train all models at resolution 224 using Adam with $\\beta _ { 1 } = 0 . 9$ , $\\beta _ { 2 } = 0 . 9 9 9$ , linear learning rate warmup of 10k steps and linear decay, batch size 4 096, weight decay, and gradient clipping at global norm 1. For JFT-300M, we pre-process images by applying the cropping technique from Szegedy et al. [45] in addition to random horizontal flipping. For ImageNet and ImageNet-21k, we employ additional data augmentation and regularization techniques. In particular, we use RandAugment [12], mixup [60], dropout [43], and stochastic depth [19]. This set of techniques was inspired by the timm library [54] and Touvron et al. [48]. More details on these hyperparameters are provided in Supplementary B. ",
+        "bbox": [
+            174,
+            758,
+            825,
+            911
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "table",
+        "img_path": "images/7e26b274eefa2449ead43edb17625410832b76d92162f3866cc372fdf2f626a0.jpg",
+        "table_caption": [
+            "Table 1: Specifications of the Mixer architectures. The “B”, “L”, and “H” (base, large, and huge) model scales follow Dosovitskiy et al. [14]. A brief notation $\\mathbf { \\ddot { B } } / 1 6 ^ { \\mathbf { \\ ' } }$ means the model of base scale with patches of resolution $1 6 \\times 1 6$ . The number of parameters is reported for an input resolution of 224 and does not include the weights of the classifier head. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Specification</td><td>S/32</td><td>S/16</td><td>B/32</td><td>B/16</td><td>L/32</td><td>L/16</td><td>H/14</td></tr><tr><td>Number of layers</td><td>8</td><td>8</td><td>12</td><td>12</td><td>24</td><td>24</td><td>32</td></tr><tr><td>Patch resolution P×P</td><td>32×32</td><td>16×16</td><td>32×32</td><td>16×16</td><td>32×32</td><td>16×16</td><td>14×14</td></tr><tr><td>Hidden size C</td><td>512</td><td>512</td><td>768</td><td>768</td><td>1024</td><td>1024</td><td>1280</td></tr><tr><td>Sequence length S</td><td>49</td><td>196</td><td>49</td><td>196</td><td>49</td><td>196</td><td>256</td></tr><tr><td>MLP dimension Dc</td><td>2048</td><td>2048</td><td>3072</td><td>3072</td><td>4096</td><td>4096</td><td>5120</td></tr><tr><td>MLP dimension Ds</td><td>256</td><td>256</td><td>384</td><td>384</td><td>512</td><td>512</td><td>640</td></tr><tr><td>Parameters (M)</td><td>19</td><td>18</td><td>60</td><td>59</td><td>206</td><td>207</td><td>431</td></tr></table>",
+        "bbox": [
+            215,
+            160,
+            779,
+            276
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            295,
+            823,
+            323
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Fine-tuning We fine-tune using momentum SGD, batch size 512, gradient clipping at global norm 1, and a cosine learning rate schedule with a linear warmup. We do not use weight decay when finetuning. Following common practice [22, 48], we also fine-tune at higher resolutions with respect to those used during pre-training. Since we keep the patch resolution fixed, this increases the number of input patches (say from $S$ to $S ^ { \\prime }$ ) and thus requires modifying the shape of Mixer’s token-mixing MLP blocks. Formally, the input in Eq. (1) is left-multiplied by a weight matrix $\\mathbf { W } _ { 1 } \\in \\mathbb { R } ^ { D _ { S } \\times S }$ and this operation has to be adjusted when changing the input dimension $S$ . For this, we increase the hidden layer width from $D _ { S }$ to $D _ { S ^ { \\prime } }$ in proportion to the number of patches and initialize the (now larger) weight matrix $\\mathbf { W } _ { 2 } ^ { \\prime } \\in \\mathbb { R } ^ { D _ { S ^ { \\prime } } \\times S ^ { \\prime } }$ with a block-diagonal matrix containing copies of $\\mathbf { W } _ { 2 }$ on its diagonal. This particular scheme only allows for $S ^ { \\prime } = \\breve { K } ^ { 2 } S$ with $K \\in \\mathbb N$ . See Supplementary C for further details. On the VTAB-1k benchmark we follow the BiT-HyperRule [22] and fine-tune Mixer models at resolution 224 and 448 on the datasets with small and large input images respectively. ",
+        "bbox": [
+            173,
+            329,
+            825,
+            497
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Metrics We evaluate the trade-off between the model’s computational cost and quality. For the former we compute two metrics: (1) Total pre-training time on TPU-v3 accelerators, which combines three relevant factors: the theoretical FLOPs for each training setup, the computational efficiency on the relevant training hardware, and the data efficiency. (2) Throughput in images/sec/core on TPU-v3. Since models of different sizes may benefit from different batch sizes, we sweep the batch sizes and report the highest throughput for each model. For model quality, we focus on top-1 downstream accuracy after fine-tuning. On two occasions (Figure 3, right and Figure 4), where fine-tuning all of the models is too costly, we report the few-shot accuracies obtained by solving the $\\ell _ { 2 }$ -regularized linear regression problem between the frozen learned representations of images and the labels. ",
+        "bbox": [
+            174,
+            503,
+            825,
+            628
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Models We compare various configurations of Mixer, summarized in Table 1, to the most recent, state-of-the-art, CNNs and attention-based models. In all the figures and tables, the MLP-based Mixer models are marked with pink ( ), convolution-based models with yellow $( \\circ )$ , and attention-based models with blue ( ). The Vision Transformers (ViTs) have model scales and patch resolutions similar to Mixer. HaloNets are attention-based models that use a ResNet-like structure with local selfattention layers instead of $3 \\times 3$ convolutions [51]. We focus on the particularly efficient “HaloNet-H4 (base 128, Conv-12)” model, which is a hybrid variant of the wider HaloNet-H4 architecture with some of the self-attention layers replaced by convolutions. Note, we mark HaloNets with both attention and convolutions with blue ( ). Big Transfer (BiT) [22] models are ResNets optimized for transfer learning. NFNets [7] are normalizer-free ResNets with several optimizations for ImageNet classification. We consider the NFNet- $\\cdot \\mathrm { F 4 + }$ model variant. We consider MPL [35] and ALIGN [21] for EfficientNet architectures. MPL is pre-trained at very large-scale on JFT-300M images, using meta-pseudo labelling from ImageNet instead of the original labels. We compare to the EfficientNetB6-Wide model variant. ALIGN pre-train image encoder and language encoder on noisy web image text pairs in a contrastive way. We compare to their best EfficientNet-L2 image encoder. ",
+        "bbox": [
+            174,
+            633,
+            825,
+            842
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3.1 Main results ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            857,
+            300,
+            872
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Table 2 presents comparison of the largest Mixer models to state-of-the-art models from the literature. “ImNet” and “ReaL” columns refer to the original ImageNet validation [13] and cleaned-up ReaL [5] labels. “Avg. $5 ^ { \\circ }$ stands for the average performance across all five downstream tasks (ImageNet, CIFAR-10, CIFAR-100, Pets, Flowers). Figure 2 (left) visualizes the accuracy-compute frontier. When pre-trained on ImageNet-21k with additional regularization, Mixer achieves an overall strong performance $8 4 . 1 5 \\%$ top-1 on ImageNet), although slightly inferior to other models2. Regularization in this scenario is necessary and Mixer overfits without it, which is consistent with similar observations for ViT [14]. The same conclusion holds when training Mixer from random initialization on ImageNet (see Section 3.2): Mixer-B/16 attains a reasonable score of $7 6 . 4 \\%$ at resolution 224, but tends to overfit. This score is similar to a vanilla ResNet50, but behind state-of-the-art CNNs/hybrids for the ImageNet “from scratch” setting, e.g. $8 4 . 7 \\%$ BotNet [42] and $8 6 . 5 \\%$ NFNet [7]. ",
+        "bbox": [
+            174,
+            883,
+            821,
+            911
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "table",
+        "img_path": "images/520a8ab358be53d9597d292a724c5d33b52cd7a6c61bc1526554b9469dd172b6.jpg",
+        "table_caption": [
+            "Table 2: Transfer performance, inference throughput, and training cost. The rows are sorted by inference throughput (fifth column). Mixer has comparable transfer accuracy to state-of-the-art models with similar cost. The Mixer models are fine-tuned at resolution 448. Mixer performance numbers are averaged over three fine-tuning runs and standard deviations are smaller than 0.1. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td></td><td>ImNet top-1</td><td>ReaL top-1</td><td>Avg 5 top-1</td><td>VTAB-1k 19 tasks</td><td>Throughput img/sec/core</td><td>TPUv3 core-days</td></tr><tr><td colspan=\"7\">Pre-trained on ImageNet-21k (public)</td></tr><tr><td>HaloNet [51]</td><td>85.8</td><td></td><td></td><td></td><td>120</td><td>0.10k</td></tr><tr><td>Mixer-L/16</td><td>84.15</td><td>87.86</td><td>93.91</td><td>74.95</td><td>105</td><td>0.41k</td></tr><tr><td>ViT-L/16 [14]</td><td>85.30</td><td>88.62</td><td>94.39</td><td>72.72</td><td>32</td><td>0.18k</td></tr><tr><td>BiT-R152x4 [22] .</td><td>85.39</td><td></td><td>94.04</td><td>70.64</td><td>26</td><td>0.94k</td></tr><tr><td colspan=\"7\">Pre-trained on JFT-30OM (proprietary)</td></tr><tr><td>NFNet-F4+ [7]</td><td>89.2</td><td></td><td></td><td></td><td>46</td><td>1.86k</td></tr><tr><td>· Mixer-H/14</td><td>87.94</td><td>90.18</td><td>95.71</td><td>75.33</td><td>40</td><td>1.01k</td></tr><tr><td>·BiT-R152x4 [22]</td><td>87.54</td><td>90.54</td><td>95.33</td><td>76.29</td><td>26</td><td>9.90k</td></tr><tr><td>ViT-H/14 [14]</td><td>88.55</td><td>90.72</td><td>95.97</td><td>77.63</td><td>15</td><td>2.30k</td></tr><tr><td colspan=\"7\">Pre-trained on unlabelled or weakly labelled data (proprietary)</td></tr><tr><td>·MPL [35]</td><td>90.0</td><td>91.12</td><td></td><td></td><td>一</td><td>20.48k</td></tr><tr><td>ALIGN[21] T</td><td>88.64</td><td>一</td><td></td><td>79.99</td><td>15</td><td>14.82k</td></tr></table>",
+        "bbox": [
+            238,
+            160,
+            759,
+            387
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            407,
+            825,
+            534
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "When the size of the upstream dataset increases, Mixer’s performance improves significantly. In particular, Mixer-H/14 achieves $8 7 . 9 4 \\%$ top-1 accuracy on ImageNet, which is $0 . 5 \\%$ better than BiTResNet $1 5 2 \\mathrm { x } 4$ and only $0 . 5 \\%$ lower than ViT-H/14. Remarkably, Mixer-H/14 runs 2.5 times faster than ViT-H/14 and almost twice as fast as BiT. Overall, Figure 2 (left) supports our main claim that in terms of the accuracy-compute trade-off Mixer is competitive with more conventional neural network architectures. The figure also demonstrates a clear correlation between the total pre-training cost and the downstream accuracy, even across architecture classes. ",
+        "bbox": [
+            174,
+            539,
+            825,
+            636
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "BiT-ResNet1 $5 2 \\mathrm { x } 4$ in the table are pre-trained using SGD with momentum and a long schedule. Since Adam tends to converge faster, we complete the picture in Figure 2 (left) with the BiT-R200x3 model from Dosovitskiy et al. [14] pre-trained on JFT-300M using Adam. This ResNet has a slightly lower accuracy, but considerably lower pre-training compute. Finally, the results of smaller ViT-L/16 and Mixer-L/16 models are also reported in this figure. ",
+        "bbox": [
+            174,
+            642,
+            825,
+            712
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "3.2 The role of the model scale ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            731,
+            398,
+            746
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "The results outlined in the previous section focus on (large) models at the upper end of the compute spectrum. We now turn our attention to smaller Mixer models. ",
+        "bbox": [
+            173,
+            757,
+            823,
+            785
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "We may scale the model in two independent ways: (1) Increasing the model size (number of layers, hidden dimension, MLP widths) when pre-training; (2) Increasing the input image resolution when fine-tuning. While the former affects both pre-training compute and test-time throughput, the latter only affects the throughput. Unless stated otherwise, we fine-tune at resolution 224. ",
+        "bbox": [
+            176,
+            791,
+            823,
+            820
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "image",
+        "img_path": "images/e888ec18a5f1ffc5126a75c42bc7c88e5c7569217134a6f3ca6be02f3064c9b2.jpg",
+        "image_caption": [
+            "Figure 2: Left: ImageNet accuracy/training cost Pareto frontier (dashed line) for the SOTA models in Table 2. Models are pre-trained on ImageNet-21k, or JFT (labelled, or pseudo-labelled for MPL), or web image text pairs. Mixer is as good as these extremely performant ResNets, ViTs, and hybrid models, and sits on frontier with HaloNet, ViT, NFNet, and MPL. Right: Mixer (solid) catches or exceeds BiT (dotted) and ViT (dashed) as the data size grows. Every point on a curve uses the same pre-training compute; they correspond to pre-training on $3 \\%$ , $10 \\%$ , $30 \\%$ , and $100 \\%$ of JFT-300M for 233, 70, 23, and 7 epochs, respectively. Additional points at ${ \\sim } 3 \\mathbf { B }$ correspond to pre-training on an even larger JFT-3B dataset for the same number of total steps. Mixer improves more rapidly with data than ResNets, or even ViT. The gap between large Mixer and ViT models shrinks. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            232,
+            92,
+            767,
+            247
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "image",
+        "img_path": "images/dcb60c2290be7785a89bed98d1d0cadb3b9e81795e4b5a5cc118b0fb971d4aa5.jpg",
+        "image_caption": [
+            "Figure 3: The role of the model scale. ImageNet validation top-1 accuracy vs. total pre-training compute (left) and throughput (right) of ViT, BiT, and Mixer models at various scales. All models are pre-trained on JFT-300M and fine-tuned at resolution 224, which is lower than in Figure 2 (left). "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            210,
+            398,
+            787,
+            515
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            583,
+            821,
+            611
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "We compare various configurations of Mixer (see Table 1) to ViT models of similar scales and BiT models pre-trained with Adam. The results are summarized in Table 3 and Figure 3. When trained from scratch on ImageNet, Mixer-B/16 achieves a reasonable top-1 accuracy of $7 6 . 4 4 \\%$ . This is $3 \\%$ behind the ViT-B/16 model. The training curves (not reported) reveal that both models achieve very similar values of the training loss. In other words, Mixer-B/16 overfits more than ViT-B/16. For the Mixer-L/16 and ViT-L/16 models this difference is even more pronounced. ",
+        "bbox": [
+            174,
+            617,
+            825,
+            700
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "As the pre-training dataset grows, Mixer’s performance steadily improves. Remarkably, Mixer-H/14 pre-trained on JFT-300M and fine-tuned at 224 resolution is only $0 . 3 \\%$ behind ViT-H/14 on ImageNet whilst running 2.2 times faster. Figure 3 clearly demonstrates that although Mixer is slightly below the frontier on the lower end of model scales, it sits confidently on the frontier at the high end. ",
+        "bbox": [
+            174,
+            707,
+            825,
+            762
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "3.3 The role of the pre-training dataset size ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            781,
+            486,
+            796
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "The results presented thus far demonstrate that pre-training on larger datasets significantly improves Mixer’s performance. Here, we study this effect in more detail. ",
+        "bbox": [
+            176,
+            808,
+            823,
+            835
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "To study Mixer’s ability to make use of the growing number of training examples we pre-train Mixer-B/32, Mixer-L/32, and Mixer-L/16 models on random subsets of JFT-300M containing $3 \\%$ , $10 \\%$ , $30 \\%$ and $100 \\%$ of all the training examples for 233, 70, 23, and 7 epochs. Thus, every model is pre-trained for the same number of total steps. We also pre-train Mixer-L/16 model on an even larger JFT-3B dataset [59] containing roughly 3B images with 30k classes for the same number of total steps. ",
+        "bbox": [
+            176,
+            842,
+            825,
+            911
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "table",
+        "img_path": "images/7fb179a35692e5d7af2ac5139b1c7d513db42916c8578b35a36b1c4ad70aff29.jpg",
+        "table_caption": [
+            "Table 3: Performance of Mixer and other models from the literature across various model and pre-training dataset scales. “Avg. 5” denotes the average performance across five downstream tasks. Mixer and ViT models are averaged over three fine-tuning runs, standard deviations are smaller than 0.15. $( \\ddagger )$ Extrapolated from the numbers reported for the same models pre-trained on JFT-300M without extra regularization. $\\mathbf { \\Pi } ( \\widehat { \\mathbf { a } } )$ Numbers provided by authors of Dosovitskiy et al. [14] through personal communication. Rows are sorted by throughput. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td></td><td>Image size</td><td>Pre-Train Epochs</td><td>ImNet top-1</td><td>ReaL top-1</td><td></td><td>Avg.5Throughput top-1 (img/sec/core） core-days</td><td>TPUv3</td></tr><tr><td colspan=\"8\">Pre-trained on ImageNet (with extra regularization)</td></tr><tr><td>Mixer-B/16</td><td>224</td><td>300</td><td>76.44</td><td>82.36</td><td>88.33</td><td>1384</td><td>0.01k(t)</td></tr><tr><td>ViT-B/16 ()</td><td>224</td><td>300</td><td>79.67</td><td>84.97</td><td>90.79</td><td>861</td><td>0.02k(±)</td></tr><tr><td>Mixer-L/16 .</td><td>224</td><td>300</td><td>71.76</td><td>77.08</td><td>87.25</td><td>419</td><td>0.04k(t)</td></tr><tr><td>ViT-L/16 ()</td><td>224</td><td>300</td><td>76.11</td><td>80.93</td><td>89.66</td><td>280</td><td>0.05k($)</td></tr><tr><td colspan=\"8\">Pre-trained on ImageNet-21k (with extra regularization)</td></tr><tr><td>·Mixer-B/16</td><td>224</td><td>300</td><td>80.64</td><td>85.80</td><td>92.50</td><td>1384</td><td>0.15k(t)</td></tr><tr><td>ViT-B/16 ()</td><td>224</td><td>300</td><td>84.59</td><td>88.93</td><td>94.16</td><td>861</td><td>0.18k(t)</td></tr><tr><td>Mixer-L/16</td><td>224</td><td>300</td><td>82.89</td><td>87.54</td><td>93.63</td><td>419</td><td>0.41k($)</td></tr><tr><td>ViT-L/16 (a)</td><td>224</td><td>300</td><td>84.46</td><td>88.35</td><td>94.49</td><td>280</td><td>0.55k(t)</td></tr><tr><td>·Mixer-L/16</td><td>448</td><td>300</td><td>83.91</td><td>87.75</td><td>93.86</td><td>105</td><td>0.41k($)</td></tr><tr><td colspan=\"8\">Pre-trained on JFT-300M</td></tr><tr><td>·Mixer-S/32</td><td>224</td><td>5</td><td>68.70</td><td>75.83</td><td>87.13</td><td>11489</td><td>0.01k</td></tr><tr><td>Mixer-B/32</td><td>224</td><td>7</td><td>75.53</td><td>81.94</td><td>90.99</td><td>4208</td><td>0.05k</td></tr><tr><td>Mixer-S/16</td><td>224</td><td>5</td><td>73.83</td><td>80.60</td><td>89.50</td><td>3994</td><td>0.03k</td></tr><tr><td>BiT-R50x1</td><td>224</td><td>7</td><td>73.69</td><td>81.92</td><td>一</td><td>2159</td><td>0.08k</td></tr><tr><td>Mixer-B/16</td><td>224</td><td>7</td><td>80.00</td><td>85.56</td><td>92.60</td><td>1384</td><td>0.08k</td></tr><tr><td>·Mixer-L/32</td><td>224</td><td>7</td><td>80.67</td><td>85.62</td><td>93.24</td><td>1314</td><td>0.12k</td></tr><tr><td>BiT-R152x1</td><td>224</td><td>7</td><td>79.12</td><td>86.12</td><td></td><td>932</td><td>0.14k</td></tr><tr><td>BiT-R50x2</td><td>224</td><td>7</td><td>78.92</td><td>86.06</td><td></td><td>890</td><td>0.14k</td></tr><tr><td>BiT-R152x2</td><td>224</td><td>14</td><td>83.34</td><td>88.90</td><td></td><td>356</td><td>0.58k</td></tr><tr><td>Mixer-L/16</td><td>224</td><td>7</td><td>84.05</td><td>88.14</td><td>94.51</td><td>419</td><td>0.23k</td></tr><tr><td>·Mixer-L/16</td><td>224</td><td>14</td><td>84.82</td><td>88.48</td><td>94.77</td><td>419</td><td>0.45k</td></tr><tr><td>ViT-L/16</td><td>224</td><td>14</td><td>85.63</td><td>89.16</td><td>95.21</td><td>280</td><td>0.65k</td></tr><tr><td>Mixer-H/14</td><td>224</td><td>14</td><td>86.32</td><td>89.14</td><td>95.49</td><td>194</td><td>1.01k</td></tr><tr><td>. BiT-R200x3</td><td>224</td><td>14</td><td>84.73</td><td>89.58</td><td></td><td>141</td><td>1.78k</td></tr><tr><td>Mixer-L/16</td><td>448</td><td>14</td><td>86.78</td><td>89.72</td><td>95.13</td><td>105</td><td>0.45k</td></tr><tr><td>ViT-H/14</td><td>224</td><td>14</td><td>86.65</td><td>89.56</td><td>95.57</td><td>87</td><td>2.30k</td></tr><tr><td>ViT-L/16 [14]</td><td>512</td><td>14</td><td>87.76</td><td>90.54</td><td>95.63</td><td>32</td><td>0.65k</td></tr></table>",
+        "bbox": [
+            238,
+            186,
+            758,
+            612
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "While not strictly comparable, this allows us to further extrapolate the effect of scale. We use the linear 5-shot top-1 accuracy on ImageNet as a proxy for transfer quality. For every pre-training run we perform early stopping based on the best upstream validation performance. Results are reported in Figure 2 (right), where we also include ViT-B/32, ViT-L/32, ViT-L/16, and BiT- $\\mathbf { R } 1 5 2 \\mathbf { x } 2$ models. ",
+        "bbox": [
+            174,
+            627,
+            823,
+            684
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "When pre-trained on the smallest subset of JFT-300M, all Mixer models strongly overfit. BiT models also overfit, but to a lesser extent, possibly due to the strong inductive biases associated with the convolutions. As the dataset increases, the performance of both Mixer-L/32 and Mixer-L/16 grows faster than BiT; Mixer-L/16 keeps improving, while the BiT model plateaus. ",
+        "bbox": [
+            174,
+            689,
+            825,
+            746
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "The same conclusions hold for ViT, consistent with Dosovitskiy et al. [14]. However, the relative improvement of larger Mixer models are even more pronounced. The performance gap between Mixer-L/16 and ViT-L/16 shrinks with data scale. It appears that Mixer benefits from the growing dataset size even more than ViT. One could speculate and explain it again with the difference in inductive biases: self-attention layers in ViT lead to certain properties of the learned functions that are less compatible with the true underlying distribution than those discovered with Mixer architecture. ",
+        "bbox": [
+            174,
+            751,
+            825,
+            835
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "3.4 Invariance to input permutations ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            856,
+            442,
+            871
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "In this section, we study the difference between inductive biases of Mixer and CNN architectures. Specifically, we train Mixer-B/16 and ResNet50x1 models on JFT-300M following the pre-training setup described in Section 3 and using one of two different input transformations: (1) Shuffle the order of $1 6 \\times 1 6$ patches and permute pixels within each patch with a shared permutation; (2) Permute the pixels globally in the entire image. Same permutation is used across all images. We report the linear 5-shot top-1 accuracy of the trained models on ImageNet in Figure 4 (bottom). Some original images along with their two transformed versions appear in Figure 4 (top). As could be expected, Mixer is invariant to the order of patches and pixels within the patches (the blue and green curves match perfectly). On the other hand, ResNet’s strong inductive bias relies on a particular order of pixels within an image and its performance drops significantly when the patches are permuted. Remarkably, when globally permuting the pixels, Mixer’s performance drops much less ( ${ \\sim } 4 5 \\%$ drop) compared to the ResNet $\\sim 7 5 \\%$ drop). ",
+        "bbox": [
+            174,
+            882,
+            823,
+            911
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/4d73edba72e7ee7ea5c72a0d41ac9476e577939a71c5c92b54605615df0e5d5c.jpg",
+        "image_caption": [
+            "Figure 4: Top: Input examples from ImageNet before permuting the contents (left); after shuffling the $1 6 \\times 1 6$ patches and pixels within the patches (center); after shuffling pixels globally (right). Bottom: Mixer-B/16 (left) and ResNet50x1 (right) trained with three corresponding input pipelines. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            236,
+            88,
+            761,
+            258
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "image",
+        "img_path": "images/6580eadc8dc26ea6d1683a42b8533e69114404d978ae2cc5853f9e28e8fb58f1.jpg",
+        "image_caption": [
+            "Figure 5: Hidden units in the first (left), second (center), and third (right) token-mixing MLPs of a Mixer-B/16 model trained on JFT-300M. Each unit has 196 weights, one for each of the $1 4 \\times 1 4$ incoming patches. We pair the units to highlight the emergence of kernels of opposing phase. Pairs are sorted by filter frequency. In contrast to the kernels of convolutional filters, where each weight corresponds to one pixel in the input image, one weight in any plot from the left column corresponds to a particular $1 6 \\times 1 6$ patch of the input image. Complete plots in Supplementary D. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            194,
+            328,
+            805,
+            479
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            592,
+            825,
+            729
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "3.5 Visualization ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            757,
+            303,
+            771
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "It is commonly observed that the first layers of CNNs tend to learn Gabor-like detectors that act on pixels in local regions of the image. In contrast, Mixer allows for global information exchange in the token-mixing MLPs, which begs the question whether it processes information in a similar fashion. Figure 5 shows hidden units of the first three token-mixing MLPs of Mixer trained on JFT-300M. Recall that the token-mixing MLPs allow global communication between different spatial locations. Some of the learned features operate on the entire image, while others operate on smaller regions. Deeper layers appear to have no clearly identifiable structure. Similar to CNNs, we observe many pairs of feature detectors with opposite phases [39]. The structure of learned units depends on the hyperparameters. Plots for the first embedding layer appear in Figure 2 of Supplementary D. ",
+        "bbox": [
+            174,
+            786,
+            826,
+            911
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "4 Related work ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            89,
+            316,
+            106
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "MLP-Mixer is a new architecture for computer vision that differs from previous successful architectures because it uses neither convolutional nor self-attention layers. Nevertheless, the design choices can be traced back to ideas from the literature on CNNs [24, 25] and Transformers [50]. ",
+        "bbox": [
+            176,
+            121,
+            825,
+            162
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "CNNs have been the de-facto standard in computer vision since the AlexNet model [24] surpassed prevailing approaches based on hand-crafted image features [36]. Many works focused on improving the design of CNNs. Simonyan and Zisserman [41] demonstrated that one can train state-of-the-art models using only convolutions with small $3 \\times 3$ kernels. He et al. [15] introduced skip-connections together with the batch normalization [20], which enabled training of very deep neural networks and further improved performance. A prominent line of research has investigated the benefits of using sparse convolutions, such as grouped [57] or depth-wise [9, 17] variants. In a similar spirit to our token-mixing MLPs, Wu et al. [55] share parameters in the depth-wise convolutions for natural language processing. Hu et al. [18] and Wang et al. [53] propose to augment convolutional networks with non-local operations to partially alleviate the constraint of local processing from CNNs. Mixer takes the idea of using convolutions with small kernels to the extreme: by reducing the kernel size to $1 \\times 1$ it turns convolutions into standard dense matrix multiplications applied independently to each spatial location (channel-mixing MLPs). This alone does not allow aggregation of spatial information and to compensate we apply dense matrix multiplications that are applied to every feature across all spatial locations (token-mixing MLPs). In Mixer, matrix multiplications are applied row-wise or column-wise on the “patches $\\times$ features” input table, which is also closely related to the work on sparse convolutions. Mixer uses skip-connections [15] and normalization layers [2, 20]. ",
+        "bbox": [
+            174,
+            169,
+            825,
+            404
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "In computer vision, self-attention based Transformer architectures were initially applied for generative modeling [8, 34]. Their value for image recognition was demonstrated later, albeit in combination with a convolution-like locality bias [37], or on low-resolution images [10]. Dosovitskiy et al. [14] introduced ViT, a pure transformer model that has fewer locality biases, but scales well to large data. ViT achieves state-of-the-art performance on popular vision benchmarks while retaining the robustness of CNNs [6]. Touvron et al. [49] trained ViT effectively on smaller datasets using extensive regularization. Mixer borrows design choices from recent transformer-based architectures. The design of Mixer’s MLP-blocks originates in [27, 50]. Converting images to a sequence of patches and directly processing embeddings of these patches originates in Dosovitskiy et al. [14]. ",
+        "bbox": [
+            174,
+            410,
+            825,
+            535
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Many recent works strive to design more effective architectures for vision. Srinivas et al. [42] replace $3 \\times 3$ convolutions in ResNets by self-attention layers. Ramachandran et al. [37], Tay et al. [47], Li et al. [26], and Bello [3] design networks with new attention-like mechanisms. Mixer can be seen as a step in an orthogonal direction, without reliance on locality bias and attention mechanisms. ",
+        "bbox": [
+            174,
+            541,
+            825,
+            597
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "The work of Lin et al. [28] is closely related. It attains reasonable performance on CIFAR-10 using fully connected networks, heavy data augmentation, and pre-training with an auto-encoder. Neyshabur [31] devises custom regularization and optimization algorithms and trains a fully-connected network, attaining impressive performance on small-scale tasks. Instead we rely on token and channel-mixing MLPs, use standard regularization and optimization techniques, and scale to large data effectively. ",
+        "bbox": [
+            174,
+            603,
+            825,
+            672
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Traditionally, networks evaluated on ImageNet [13] are trained from random initialization using Inception-style pre-processing [46]. For smaller datasets, transfer of ImageNet models is popular. However, modern state-of-the-art models typically use either weights pre-trained on larger datasets, or more recent data-augmentation and training strategies. For example, Dosovitskiy et al. [14], Kolesnikov et al. [22], Mahajan et al. [30], Pham et al. [35], Xie et al. [56] all advance state-of-the-art in image classification using large-scale pre-training. Examples of improvements due to augmentation or regularization changes include Cubuk et al. [11], who attain excellent classification performance with learned data augmentation, and Bello et al. [4], who show that canonical ResNets are still near state-of-the-art, if one uses recent training and augmentation strategies. ",
+        "bbox": [
+            174,
+            679,
+            825,
+            804
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "5 Conclusions ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            823,
+            305,
+            840
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "We describe a very simple architecture for vision. Our experiments demonstrate that it is as good as existing state-of-the-art methods in terms of the trade-off between accuracy and computational resources required for training and inference. We believe these results open many questions. On the practical side, it may be useful to study the features learned by the model and identify the main differences (if any) from those learned by CNNs and Transformers. On the theoretical side, we would like to understand the inductive biases hidden in these various features and eventually their role in generalization. Most of all, we hope that our results spark further research, beyond the realms of established models based on convolutions and self-attention. It would be particularly interesting to see whether such a design works in NLP or other domains. ",
+        "bbox": [
+            174,
+            856,
+            823,
+            911
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            92,
+            825,
+            160
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Acknowledgments and Disclosure of Funding ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            180,
+            553,
+            198
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "The work was performed in the Brain teams in Berlin and Zürich. We thank Josip Djolonga for feedback on the initial version of the paper; Preetum Nakkiran for proposing to train MLP-Mixer on input images with shuffled pixels; Olivier Bousquet, Yann Dauphin, and Dirk Weissenborn for useful discussions. ",
+        "bbox": [
+            174,
+            212,
+            825,
+            267
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "References ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            287,
+            266,
+            304
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "[1] A. Araujo, W. Norris, and J. Sim. Computing receptive fields of convolutional neural networks. Distill, 2019. doi: 10.23915/distill.00021. URL https://distill.pub/2019/ computing-receptive-fields.   \n[2] J. L. Ba, J. R. Kiros, and G. E. Hinton. Layer normalization. arXiv preprint arXiv:1607.06450, 2016.   \n[3] I. Bello. LambdaNetworks: Modeling long-range interactions without attention. arXiv preprint arXiv:2102.08602, 2021.   \n[4] I. Bello, W. Fedus, X. Du, E. D. Cubuk, A. Srinivas, T.-Y. Lin, J. Shlens, and B. Zoph. Revisiting ResNets: Improved training and scaling strategies. arXiv preprint arXiv:2103.07579, 2021.   \n[5] L. Beyer, O. J. Hénaff, A. Kolesnikov, X. Zhai, and A. van den Oord. Are we done with ImageNet? arXiv preprint arXiv:2006.07159, 2020.   \n[6] S. Bhojanapalli, A. Chakrabarti, D. Glasner, D. Li, T. Unterthiner, and A. Veit. Understanding robustness of transformers for image classification. arXiv preprint arXiv:2103.14586, 2021.   \n[7] A. Brock, S. De, S. L. Smith, and K. Simonyan. High-performance large-scale image recognition without normalization. arXiv preprint arXiv:2102.06171, 2021.   \n[8] R. Child, S. Gray, A. Radford, and I. Sutskever. Generating long sequences with sparse transformers. arXiv preprint arXiv:1904.10509, 2019.   \n[9] F. Chollet. Xception: Deep learning with depthwise separable convolutions. In CVPR, 2017.   \n[10] J.-B. Cordonnier, A. Loukas, and M. Jaggi. On the relationship between self-attention and convolutional layers. In ICLR, 2020.   \n[11] E. D. Cubuk, B. Zoph, D. Mane, V. Vasudevan, and Q. V. Le. AutoAugment: Learning augmentation policies from data. In CVPR, 2019.   \n[12] E. D. Cubuk, B. Zoph, J. Shlens, and Q. V. Le. RandAugment: Practical automated data augmentation with a reduced search space. In CVPR Workshops, 2020.   \n[13] J. Deng, W. Dong, R. Socher, L. Li, Kai Li, and Li Fei-Fei. ImageNet: A large-scale hierarchical image database. In CVPR, 2009.   \n[14] A. Dosovitskiy, L. Beyer, A. Kolesnikov, D. Weissenborn, X. Zhai, T. Unterthiner, M. Dehghani, M. Minderer, G. Heigold, S. Gelly, J. Uszkoreit, and N. Houlsby. An image is worth 16x16 words: Transformers for image recognition at scale. In ICLR, 2021.   \n[15] K. He, X. Zhang, S. Ren, and J. Sun. Deep residual learning for image recognition. In CVPR, 2016.   \n[16] D. Hendrycks and K. Gimpel. Gaussian error linear units (GELUs). arXiv preprint arXiv:1606.08415, 2016.   \n[17] A. G. Howard, M. Zhu, B. Chen, D. Kalenichenko, W. Wang, T. Weyand, M. Andreetto, and H. Adam. Mobilenets: Efficient convolutional neural networks for mobile vision applications. arXiv preprint arXiv:1704.04861, 2017.   \n[18] J. Hu, L. Shen, and G. Sun. Squeeze-and-excitation networks. In CVPR, 2018.   \n[19] G. Huang, Y. Sun, Z. Liu, D. Sedra, and K. Q. Weinberger. Deep networks with stochastic depth. In ECCV, 2016.   \n[20] S. Ioffe and C. Szegedy. Batch normalization: Accelerating deep network training by reducing internal covariate shift. In ICML, 2015.   \n[21] C. Jia, Y. Yang, Y. Xia, Y.-T. Chen, Z. Parekh, H. Pham, Q. V. Le, Y. Sung, Z. Li, and T. Duerig. Scaling up visual and vision-language representation learning with noisy text supervision. arXiv preprint arXiv:2102.05918, 2021.   \n[22] A. Kolesnikov, L. Beyer, X. Zhai, J. Puigcerver, J. Yung, S. Gelly, and N. Houlsby. Big transfer (BiT): General visual representation learning. In ECCV, 2020.   \n[23] A. Krizhevsky. Learning multiple layers of features from tiny images. Technical report, University of Toronto, 2009.   \n[24] A. Krizhevsky, I. Sutskever, and G. E. Hinton. ImageNet classification with deep convolutional neural networks. In NeurIPS, 2012.   \n[25] Y. LeCun, B. Boser, J. Denker, D. Henderson, R. Howard, W. Hubbard, and L. Jackel. Backpropagation applied to handwritten zip code recognition. Neural Computation, 1:541–551, 1989.   \n[26] D. Li, J. Hu, C. Wang, X. Li, Q. She, L. Zhu, T. Zhang, and Q. Chen. Involution: Inverting the inherence of convolution for visual recognition. CVPR, 2021.   \n[27] M. Lin, Q. Chen, and S. Yan. Network in network. In ICLR, 2014.   \n[28] Z. Lin, R. Memisevic, and K. Konda. How far can we go without convolution: Improving fullyconnected networks. In ICLR, Workshop Track, 2016.   \n[29] W. Luo, Y. Li, R. Urtasun, and R. Zemel. Understanding the effective receptive field in deep convolutional neural networks. In NeurIPS, 2016.   \n[30] D. Mahajan, R. Girshick, V. Ramanathan, K. He, M. Paluri, Y. Li, A. Bharambe, and L. van der Maaten. Exploring the limits of weakly supervised pretraining. In ECCV, 2018.   \n[31] B. Neyshabur. Towards learning convolutions from scratch. In NeurIPS, 2020.   \n[32] M. Nilsback and A. Zisserman. Automated flower classification over a large number of classes. In ICVGIP, 2008.   \n[33] O. M. Parkhi, A. Vedaldi, A. Zisserman, and C. V. Jawahar. Cats and dogs. In CVPR, 2012.   \n[34] N. Parmar, A. Vaswani, J. Uszkoreit, L. Kaiser, N. Shazeer, A. Ku, and D. Tran. Image transformer. In ICML, 2018.   \n[35] H. Pham, Z. Dai, Q. Xie, M.-T. Luong, and Q. V. Le. Meta pseudo labels. In CVPR, 2021.   \n[36] A. Pinz. Object categorization. Foundations and Trends in Computer Graphics and Vision, 1(4), 2006.   \n[37] P. Ramachandran, N. Parmar, A. Vaswani, I. Bello, A. Levskaya, and J. Shlens. Stand-alone self-attention in vision models. In NeurIPS, 2019.   \n[38] M. Sandler, J. Baccash, A. Zhmoginov, and Howard. Non-discriminative data or weak model? On the relative importance of data and model resolution. In ICCV Workshop on Real-World Recognition from Low-Quality Images and Videos, 2019.   \n[39] W. Shang, K. Sohn, D. Almeida, and H. Lee. Understanding and improving convolutional neural networks via concatenated rectified linear units. In ICML, 2016.   \n[40] L. Sifre. Rigid-Motion Scattering For Image Classification. PhD thesis, Ecole Polytechnique, 2014.   \n[41] K. Simonyan and A. Zisserman. Very deep convolutional networks for large-scale image recognition. In ICLR, 2015.   \n[42] A. Srinivas, T.-Y. Lin, N. Parmar, J. Shlens, P. Abbeel, and A. Vaswani. Bottleneck transformers for visual recognition. arXiv preprint arXiv:2101.11605, 2021.   \n[43] N. Srivastava, G. Hinton, A. Krizhevsky, I. Sutskever, and R. Salakhutdinov. Dropout: A simple way to prevent neural networks from overfitting. JMLR, 15(56), 2014.   \n[44] C. Sun, A. Shrivastava, S. Singh, and A. Gupta. Revisiting unreasonable effectiveness of data in deep learning era. In ICCV, 2017.   \n[45] C. Szegedy, W. Liu, Y. Jia, P. Sermanet, S. Reed, D. Anguelov, D. Erhan, V. Vanhoucke, and A. Rabinovich. Going deeper with convolutions. In CVPR, 2015.   \n[46] C. Szegedy, V. Vanhoucke, S. Ioffe, J. Shlens, and Z. Wojna. Rethinking the inception architecture for computer vision. In CVPR, 2016.   \n[47] Y. Tay, D. Bahri, D. Metzler, D.-C. Juan, Z. Zhao, and C. Zheng. Synthesizer: Rethinking self-attention in transformer models. arXiv, 2020.   \n[48] H. Touvron, A. Vedaldi, M. Douze, and H. Jegou. Fixing the train-test resolution discrepancy. In NeurIPS, 2019.   \n[49] H. Touvron, M. Cord, M. Douze, F. Massa, A. Sablayrolles, and H. Jégou. Training data-efficient image transformers & distillation through attention. arXiv preprint arXiv:2012.12877, 2020.   \n[50] A. Vaswani, N. Shazeer, N. Parmar, J. Uszkoreit, L. Jones, A. N. Gomez, Ł. Kaiser, and I. Polosukhin. Attention is all you need. In NeurIPS, 2017.   \n[51] A. Vaswani, P. Ramachandran, A. Srinivas, N. Parmar, B. Hechtman, and J. Shlens. Scaling local self-attention for parameter efficient visual backbones. arXiv preprint arXiv:2103.12731, 2021.   \n[52] W. Wang, E. Xie, X. Li, D.-P. Fan, K. Song, D. Liang, T. Lu, P. Luo, and L. Shao. Pyramid vision transformer: A versatile backbone for dense prediction without convolutions. arXiv preprint arXiv:2102.12122, 2021.   \n[53] X. Wang, R. Girshick, A. Gupta, and K. He. Non-local neural networks. In CVPR, 2018.   \n[54] R. Wightman. Pytorch image models. https://github.com/rwightman/ pytorch-image-models, 2019.   \n[55] F. Wu, A. Fan, A. Baevski, Y. Dauphin, and M. Auli. Pay less attention with lightweight and dynamic convolutions. In ICLR, 2019.   \n[56] Q. Xie, M.-T. Luong, E. Hovy, and Q. V. Le. Self-training with noisy student improves imagenet classification. In CVPR, 2020.   \n[57] S. Xie, R. Girshick, P. Dollár, Z. Tu, and K. He. Aggregated residual transformations for deep neural networks. arXiv preprint arXiv:1611.05431, 2016.   \n[58] X. Zhai, J. Puigcerver, A. Kolesnikov, P. Ruyssen, C. Riquelme, M. Lucic, J. Djolonga, A. S. Pinto, M. Neumann, A. Dosovitskiy, et al. A large-scale study of representation learning with the visual task adaptation benchmark. arXiv preprint arXiv:1910.04867, 2019.   \n[59] X. Zhai, A. Kolesnikov, N. Houlsby, and L. Beyer. Scaling vision transformers. arXiv preprint arXiv:2106.04560, 2021.   \n[60] H. Zhang, M. Cisse, Y. N. Dauphin, and D. Lopez-Paz. mixup: Beyond empirical risk minimization. In ICLR, 2018. ",
+        "bbox": [
+            173,
+            306,
+            826,
+            916
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            171,
+            95,
+            828,
+            912
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            171,
+            89,
+            828,
+            645
+        ],
+        "page_idx": 11
+    }
+]

parse/train/djbC2A4uTHP/djbC2A4uTHP.md

@@ -0,0 +1,269 @@
+# Consistency Regularization for Variational Auto-Encoders
+
+Samarth Sinha Vector Institute University of Toronto
+
+Adji B. Dieng   
+Google Brain   
+Princeton University
+
+# Abstract
+
+Variational auto-encoders (vaes) are a powerful approach to unsupervised learning. They enable scalable approximate posterior inference in latent-variable models using variational inference (vi). A vae posits a variational family parameterized by a deep neural network—called an encoder—that takes data as input. This encoder is shared across all the observations, which amortizes the cost of inference. However the encoder of a vae has the undesirable property that it maps a given observation and a semantics-preserving transformation of it to different latent representations. This “inconsistency" of the encoder lowers the quality of the learned representations, especially for downstream tasks, and also negatively affects generalization. In this paper, we propose a regularization method to enforce consistency in vaes. The idea is to minimize the Kullback-Leibler (kl) divergence between the variational distribution when conditioning on the observation and the variational distribution when conditioning on a random semantic-preserving transformation of this observation. This regularization is applicable to any vae. In our experiments we apply it to four different vae variants on several benchmark datasets and found it always improves the quality of the learned representations but also leads to better generalization. In particular, when applied to the nouveau variational auto-encoder (nvae), our regularization method yields state-of-the-art performance on mnist, cifar-10, and celeba. We also applied our method to 3D data and found it learns representations of superior quality as measured by accuracy on a downstream classification task. Finally, we show our method can even outperform the triplet loss, an advanced and popular contrastive learning-based method for representation learning.
+
+# 1 Introduction
+
+Variational auto-encoders (vaes) have significantly impacted research on unsupervised learning. They have been used in several areas, including density estimation (Kingma & Welling, 2013; Rezende et al., 2014), image generation (Gregor et al., 2015), text generation (Bowman et al., 2015; Fang et al., 2019), music generation (Roberts et al., 2018), topic modeling (Miao et al., 2016; Dieng et al., 2019), and recommendation systems (Liang et al., 2018). Vaes have also been used for different representation learning problems such as semi-supervised learning (Kingma et al., 2014), anomaly detection (An & Cho, 2015; Zimmerer et al., 2018), language modeling Bowman et al. (2015), active learning (Sinha et al., 2019), continual learning (Achille et al., 2018), and motion prediction of agents (Walker et al., 2016). This widespread application of vae representations makes it critical that we focus on improving them.
+
+vaes extend deterministic auto-encoders to probabilistic generative modeling. The encoder of a vae parameterizes an approximate posterior distribution over latent variables of a generative model. The encoder is shared between all observations, which amortizes the cost of posterior inference. Once fitted, the encoder of a vae can be used to obtain low-dimensional representations of data, (e.g. for downstream tasks.) The quality of these representations is therefore very important to a successful application of vaes.
+
+![](images/87da93feb9101d9471f5468dd3ffeb7e8e2ecfe35807360b6f865d0e977509dc.jpg)  
+Figure 1: Illustration of the inconsistency problem in vaes and how cr-vaes address this problem. The red dots correspond to the representations of few images from mnist. The blue dots correspond to the representations of the transformed images. The transformations used here are rotations, translations, and scaling; they are semantics-preserving. The arrows connect the representations of any two pairs of an image and its transformation. The shorter the arrow, the better. (a): The vae maps the two sets of images to different areas in the latent space. (b): Even when trained with the original dataset augmented with the transformed images, the vae still maps the two sets of images to different parts in the latent space. (c): The cr-vae maps an image and its transformation to nearby areas in the latent space.
+
+Researchers have looked at ways to improve the quality of the latent representations of vaes, often tackling the so-called latent variable collapse problem—in which the approximate posterior distribution induced by the encoder collapses to the prior over the latent variables (Bowman et al., 2015; Kim et al., 2018; Dieng et al., 2018; He et al., 2019; Fu et al., 2019).
+
+In this paper, we focus on a different problem pertaining to the latent representations of vaes for image data. Indeed, the encoder of a fitted vae tends to map an image and a semantics-preserving transformation of that image to different parts in the latent space. This “inconsistency" of the encoder affects the quality of the learned representations and generalization. We propose a method to enforce consistency in vaes. The idea is simple and consists in maximizing the likelihood of the images while minimizing the Kullback-Leibler $\mathbf { \Pi } ( \kappa \mathbf { L } )$ divergence between the approximate posterior distribution induced by the encoder when conditioning on the image, on one hand, and its transformation, on the other hand. This regularization technique can be applied to any vae variant to improve the quality of the learned representations and boost generalization performance. We call a vae with this form of regularization, a consistency-regularized variational auto-encoder (cr-vae).
+
+Figure 1 illustrates the inconsistency problem of vaes and how cr-vaes address this problem on mnist. The red dots are representations of a few images and the blue dots are the representations of their transformations. We applied semantics-preserving transformations: rotation, translation, and scaling. The vae maps each image and its transformation to different parts in the latent space as evidenced by the long arrows connecting each pair (a). Even when we include the transformed images to the data and fit the vae the inconsistency problem still occurs (b). The cr-vae does not suffer from the inconsistency problem; it maps each image and its transformation to nearby areas in the latent space, as evidenced by the short arrows connecting each pair (c).
+
+In our experiments (see Section 4), we apply the proposed technique to four vae variants, the original vae (Kingma & Welling, 2013), the importance-weighted auto-encoder (iwae) (Burda et al., 2015), the $\beta$ -vae (Higgins et al., 2017), and the nouveau variational auto-encoder (nvae) (Vahdat & Kautz, 2020). We found, on four different benchmark datasets, that cr-vaes always yield better representations and generalize better than their base vaes. In particular, consistency-regularized nouveau variational auto-encoders (cr-nvaes) yield state-of-the-art performance on mnist and cifar-10. We also applied cr-vaes to 3D data where these conclusions still hold.
+
+# 2 Method
+
+We consider a latent-variable model $p _ { \boldsymbol { \theta } } ( \mathbf { x } , \mathbf { z } ) = p _ { \boldsymbol { \theta } } ( \mathbf { x } | \mathbf { z } ) \cdot p ( \mathbf { z } )$ , where $\mathbf { x }$ denotes an observation and $\mathbf { z }$ is its associated latent variable. The marginal $p ( \mathbf { z } )$ is a prior over the latent variable and $p _ { \boldsymbol { \theta } } ( \mathbf { x } | \mathbf { z } )$
+
+is an exponential family distribution whose natural parameter is a function of $\mathbf { z }$ parameterized by $\theta$ , e.g. through a neural network. Our goal is to learn the parameters $\theta$ and a posterior distribution over the latent variables. The approach of vaes is to maximize the evidence lower bound (elbo), a lower bound on the log marginal likelihood of the data,
+
+$$
+\mathcal { L } _ { \mathrm { v A E } } = \mathtt { E L B O } = \mathbb { E } _ { q _ { \phi } ( \mathbf { z } | \mathbf { x } ) } \left[ \log \left( \frac { p _ { \theta } ( \mathbf { x } , \mathbf { z } ) } { q _ { \phi } ( \mathbf { z } | \mathbf { x } ) } \right) \right]
+$$
+
+where $q _ { \phi } ( \mathbf { z } | \mathbf { x } )$ is an approximate posterior distribution over the latent variables. The idea of a vae is to let the parameters of the distribution $q _ { \phi } ( { \bf z } | { \bf x } )$ be given by the output of a neural network, with parameters $\phi$ , that takes $\mathbf { x }$ as input. The parameters $\theta$ and $\phi$ are then jointly optimized by maximizing a Monte Carlo approximation of the elbo using the reparameterization trick (Kingma & Welling, 2013).
+
+Consider a semantics-preserving transformation $t ( \tilde { \mathbf { x } } | \mathbf { x } )$ of data $\mathbf { x }$ (e.g. rotation or translation for images.) A good representation learning algorithm should provide similar latent representations for $\mathbf { x }$ and $\tilde { \mathbf { x } }$ . This is not the case for the vae that maximizes Equation 1 and its variants. Once fit to data, the encoder of a vae is unable to yield similar latent representations for a data $\mathbf { x }$ and its tranformation x˜ (see Figure 1). This is because there is nothing in Equation 1 that forces this desideratum.
+
+We now propose a regularization method that ensures consistency of the encoder of a vae. We call a vae with such a regularization a cr-vae. The regularization proposed is applicable to many variants of the vae such as the iwae (Burda et al., 2015), the $\beta$ -vae (Higgins et al., 2017), and the nvae (Vahdat & Kautz, 2020). In what follows, we use the standard vae, the one that maximizes Equation 1, as the base vae to regularize to illustrate the method.
+
+Consider an image $\mathbf { x }$ . Denote by $t ( \tilde { \mathbf { x } } | \mathbf { x } )$ the random process by which we generate $\tilde { \mathbf { x } }$ , a semanticspreserving transformation of $\mathbf { x }$ . We draw $\tilde { \mathbf { x } }$ from $t ( \tilde { \mathbf { x } } | \mathbf { x } )$ as follows:
+
+$$
+\begin{array} { r } { \tilde { { \mathbf { x } } } \sim t ( \tilde { { \mathbf { x } } } | { \mathbf { x } } ) \iff \epsilon \sim p ( \epsilon ) \mathrm { a n d } \tilde { { \mathbf { x } } } = g ( { \mathbf { x } } , \epsilon ) . } \end{array}
+$$
+
+Here $g ( \mathbf { x } , \epsilon )$ is a semantics-preserving transformation of the image $\mathbf { x }$ , e.g. translation with random length $\epsilon$ drawn from $\boldsymbol { p } ( \boldsymbol { \epsilon } ) = \mathbf { \bar { \mathcal { U } } } [ - \delta , \delta ]$ for some threshold $\delta$ . A cr-vae then maximizes
+
+$$
+\mathcal { L } _ { \mathtt { C R - V A E } } ( \mathbf { x } ) = \mathcal { L } _ { \mathtt { V A E } } ( \mathbf { x } ) + \mathbb { E } _ { t ( \tilde { \mathbf { x } } | \mathbf { x } ) } \left[ \mathcal { L } _ { \mathtt { V A E } } ( \tilde { \mathbf { x } } ) \right] - \lambda \cdot \mathcal { R } ( \mathbf { x } , \phi )
+$$
+
+where the regularization term $\mathcal { R } ( \mathbf { x } , \phi )$ is
+
+$$
+\begin{array} { r } { \mathcal { R } ( \mathbf { x } , \phi ) = \mathbb { E } _ { t ( \tilde { \mathbf { x } } | \mathbf { x } ) } \left[ \mathrm { K L } \left( q _ { \phi } ( \mathbf { z } | \tilde { \mathbf { x } } ) | | q _ { \phi } ( \mathbf { z } | \mathbf { x } ) \right) \right] . } \end{array}
+$$
+
+Maximizing the objective in Equation 3 maximizes the likelihood of the data and their augmentations while enforcing consistency through $\mathcal { R } ( \mathbf { x } , \phi )$ . Minimizing $\mathcal { R } ( \mathbf { x } , \phi )$ , which only affects the encoder (with parameters $\phi$ ), forces each observation and the corresponding augmentations to lie close to each other in the latent space. The hyperparameter $\lambda \geq 0$ controls the strength of this constraint.
+
+The objective in Equation 3 is intractable but we can easily approximate it using Monte Carlo with the reparameterization trick. In particular, we approximate the regularization term with one sample from $t ( \tilde { \mathbf { x } } | \mathbf { x } )$ and make the dependence to this sample explicit using the notation $\mathcal { R } ( \mathbf { x } , \tilde { \mathbf { x } } , \phi )$ . Algorithm 1 illustrates this in greater detail. Although we show the application of consistency regularization using the vae that maximizes the elbo, $\mathcal { L } _ { \mathrm { v _ { A E } } } ( \cdot )$ in Equation 3 can be replaced with any vae objective.
+
+# 3 Related Work
+
+Applying consistency regularization to vaes, as we do in this paper, has not been previously explored. Consistency regularization is a widely used technique for semi-supervised learning (Bachman et al., 2014; Sajjadi et al., 2016; Laine & Aila, 2016; Miyato et al., 2018; Xie et al., 2019). The core idea behind consistency regularization for semi-supervised learning is to force classifiers to learn representations that are insensitive to semantics-preserving changes to images, so as to improve classification of unlabeled images. Examples of semantics-preserving changes used in the literature include rotation, zoom, translation, crop, or adversarial attacks. Consistency is often enforced by minimizing the $\mathbb { L } _ { 2 }$ distance between a classifier’s logit output for an image and the logit output for its semantics-preserving transformation (Sajjadi et al., 2016; Laine & Aila, 2016), or by minimizing the kl divergence between the classifier’s label distribution induced by the image and that of its tranformation (Miyato et al., 2018; Xie et al., 2019).
+
+<table><tr><td>input :Data X,consistency regularization strength 入,latent space dimensionality K Initialize parameters 0,$ foriterationt=1,2,...do for n=1,...,Bdo Transform the data: ∈n ~ p(∈n) and xn = T(xn,∈n) Get variational mean and variance for the data: μn = WTNN(xn; Φ) + a and σn = softplus(QTNN(xn; Φ) + b) Get S samples from the variational distribution when conditioning on Xn: η(s) ~ N(0,I) and Z） ）= μn+n(s).σn for s=1,...,S Get variational mean and variance for the transformed data:</td></tr></table>
+
+More recently, consistency regularization has been applied to generative adversarial networks (gans) (Goodfellow et al., 2014). Indeed Wei et al. (2018) and Zhang et al. (2020) show that applying consistency regularization on the discriminator of a gan—also a classifier—can substantially improve its performance.
+
+The idea we develop in this paper differs from the works above in two ways. First, it applies consistency regularization to vaes for image data. Second, it leverages consistency regularization, not in the label or logit space, as done in the works mentioned above, but in the latent space.
+
+Although different, consistency regularization for vaes relates to works that study ways to constrain the sensitivity of encoders to various perturbations. For example, denoising auto-encoders (daes) and their variants (Vincent et al., 2008, 2010) corrupt an image $\mathbf { x }$ into $\mathbf { x } ^ { \prime }$ , typically using Gaussian noise, and then minimize the distance between the reconstruction of $\mathbf { x } ^ { \prime }$ and the un-corrupted image x. The motivation is to learn representations that are insensitive to the added noise. Our work differs in that we do not constrain the decoder to recover the original image from the corrupted image but, rather, to constrain the encoder to recover the latent representation of the original image from the corrupted image via a kl divergence minimization constraint.
+
+Contractive auto-encoders (caes) (Rifai et al., 2011) share a similar goal with cr-vaes. A cae is an auto-encoder whose encoder is constrained by minimizing the norm of the Jacobian of the output of the encoder with respect to the input image. This norm constraint on the Jacobian forces the representations learned by the encoder to be insensitive to changes in the input. Our work differs in several main ways. First, cr-vaes are not deterministic auto-encoders, contrary to caes. We can easily sample from a cr-vae, as for any vae, which is not the case for a cae. Second, a cae does not apply transformations to the input image, which limits the sensitivities it can learn to limit to those exhibited in the training set. Finally, caes use the Jacobian to impose a consistency constraint, which are not as easy to compute as the kl divergence we use on the variational distribution induced by the encoder.
+
+Table 1: cr-vaes learn better representations than their base vaes on all three benchmark datasets. Although fitting the base vae with augmentations does improve the representations, adding the consistency regularization further improves the quality of these learned representations. The value of $\beta$ for the $\beta$ -vae is inside the parentheses.   
+
+<table><tr><td rowspan="2">Method</td><td colspan="2">MNIST</td><td colspan="2">OMNIGLOT</td><td colspan="2">CELEBA</td></tr><tr><td>MI</td><td>AU</td><td>MI</td><td>AU</td><td>MI</td><td>AU</td></tr><tr><td>VAE</td><td>124.5 ±1.1</td><td>36±0.8</td><td>105.4±1.2</td><td>50±0.0</td><td>33.8±0.2</td><td>32±0.9</td></tr><tr><td>VAE + Aug</td><td>125.9 ± 0.2</td><td>42 ± 0.5</td><td>105.9 ± 0.7</td><td>50 ±0.0</td><td>34.1± 0.8</td><td>33 ± 0.9</td></tr><tr><td>CR-VAE</td><td>126.3 ± 0.9</td><td>47 ± 0.5</td><td>107.8 ± 1.1</td><td>50±0.0</td><td>34.9 ± 0.5</td><td>33 ±1.2</td></tr><tr><td>IWAE</td><td>127.1 ± 0.7</td><td>39±0.5</td><td>110.3±1.1</td><td>50±0.0</td><td>36.9± 0.5</td><td>36 ±1.6</td></tr><tr><td>IWAE+Aug</td><td>129.0 ± 0.9</td><td>45±0.8</td><td>112.9 ± 0.7</td><td>50 ±0.0</td><td>37.0± 0.2</td><td>36 ± 1.2</td></tr><tr><td>CR-IWAE</td><td>129.7 ± 1.0</td><td>50 ± 0.0</td><td>115.3 ± 0.8</td><td>50±0.0</td><td>38.4 ± 0.5</td><td>36 ± 1.9</td></tr><tr><td>β-VAE (0.5)</td><td>284.3± 1.1</td><td>50±0.0</td><td>143.4 ± 1.0</td><td>50±0.0</td><td>75.8 ± 0.5</td><td>49± 0.5</td></tr><tr><td>β-VAE (0.5) + Aug</td><td>289.3 ± 1.0</td><td>50±0.0</td><td>159.6 ± 1.3</td><td>50±0.0</td><td>75.7 ± 0.3</td><td>49±0.0</td></tr><tr><td>β-CR-VAE (0.5)</td><td>291.9 ± 0.7</td><td>50±0.0</td><td>169.5 ± 0.5</td><td>50±0.0</td><td>77.1 ± 0.1</td><td>50 ± 0.0</td></tr><tr><td>β-VAE (10)</td><td>6.3± 0.6</td><td>8±1.7</td><td>1.4 ± 0.2</td><td>4±0.9</td><td>3.6± 0.3</td><td>7±0.8</td></tr><tr><td>β-VAE (10) + Aug</td><td>6.5 ± 0.5</td><td>9±1.1</td><td>1.6 ± 0.2</td><td>4±0.5</td><td>3.7 ± 0.1</td><td>7±0.0</td></tr><tr><td>β-CR-VAE (10)</td><td>6.9 ± 0.6</td><td>10 ± 0.5</td><td>1.6 ± 0.1</td><td>4± 0.5</td><td>3.7 ± 0.4</td><td>9 ± 0.9</td></tr></table>
+
+# 4 Empirical Study
+
+In this section we show that a cr-vae improves the learned representations of its base vae and positively affects generalization performance We also show that the proposed regularization method is amenable to different vae variants by applying it not only to the original vae but also to the iwae, the $\beta$ -vae, and the nvae. We showcase the importance of the KL regularization term by conducting an ablation study. We found that only regularizing with data augmentation improves performance but that accounting for the kl term $\lambda > 0$ ) further improves the quality of the learned representations and generalization.
+
+We will conduct three sets of experiments. In the first experiment, we will apply the regularization method proposed in this paper to standard vaes such as the original vae, the iwae, and the $\beta$ -vae. We use mnist, omniglot, and celeba as datasets for this experiment. For celeba, we choose the $3 2 \mathrm { x 3 2 }$ resolution for this experiment. Our results show that adding consistency regularization always improves upon the base vae, both in terms of the quality of the learned representations and generalization. We conduct an ablation study and also report performance of the different vae variants above when they are fitted with the original data and their augmentations. The results from this ablation highlight the importance of setting $\lambda > 0$ .
+
+In the second set of experiments we apply our method to a large-scale vae, the latest nvae (Vahdat & Kautz, 2020). We use mnist, cifar-10, and celeba as datasets for this experiment. We increased the resolution for the celeba dataset for this experiment to $6 4 \mathrm { x 6 4 }$ . We reach the same conclusions as for the first sets of experiments; cr-vaes improve the learned representations and generalization of their base vaes. In this particular setting, the cr-nvae achieves state-of-the-art generalization performance on both mnist and cifar-10. This state-of-the-art performance couldn’t be reach simply by training the nvae with augmentations, as our results show.
+
+Finally, in a third set of experiments, we apply our regularization technique to a 3D point-cloud dataset called ShapeNet (Chang et al., 2015). We adapt a high-performing auto-encoding method called FoldingNet (Yang et al., 2018) to its vae counterpart and apply the method we described in this paper to that vae variant on the ShapeNet dataset. We found that adding consistency regularization yields better learned representations.
+
+We next describe in great detail the set up for each of these experiments and the results showcasing the usefulness of the regularization method we propose in this paper.
+
+Table 2: cr-vaes learn representations that yield higher accuracy on downstream classification than their base vaes. These results correspond to the accuracy from a linear classifier that was fitted on the training. We fed this classifier with the representations learned by each method. On both mnist and cifar-10, cr-vaes yield higher accuracy.   
+
+<table><tr><td>Method</td><td>MNIST</td><td>CIFAR-10</td></tr><tr><td>VAE</td><td>98.5</td><td>32.6</td></tr><tr><td>VAE+Aug</td><td>98.9</td><td>40.1</td></tr><tr><td>CR-VAE</td><td>99.4</td><td>44.7</td></tr><tr><td>IWAE</td><td>98.6</td><td>35.8</td></tr><tr><td>IWAE+Aug</td><td>99.9</td><td>37.1</td></tr><tr><td>CR-IWAE</td><td>99.9</td><td>44.8</td></tr><tr><td>β- VAE (0.5)</td><td>97.6</td><td>27.0</td></tr><tr><td>β- VAE (0.5)+Aug</td><td>98.7</td><td>27.6</td></tr><tr><td>β- CR-VAE (0.5)</td><td>98.9</td><td>30.0</td></tr><tr><td>β- VAE (10)</td><td>99.4</td><td>36.5</td></tr><tr><td>β- VAE (10)+Aug</td><td>99.6</td><td>42.1</td></tr><tr><td>β- CR-VAE (10)</td><td>99.6</td><td>46.1</td></tr></table>
+
+Table 3: cr-vaes generalize better than their base vaes on almost all cases; they achieve lower negative log-likelihoods. Although training the base vaes with the augmented data improves generalization, adding the consistency regularization term further improves generalization performance.   
+
+<table><tr><td>Method</td><td>MNIST</td><td>OMNIGLOT</td><td>CELEBA</td></tr><tr><td>VAE</td><td>83.7 ± 0.3</td><td>128.2± 0.8</td><td>66.1±0.2</td></tr><tr><td>VAE + Aug</td><td>82.8 ±0.4</td><td>125.7 ± 0.2</td><td>66.0± 0.2</td></tr><tr><td>CR-VAE</td><td>81.2 ± 0.2</td><td>124.1 ± 0.1</td><td>65.9 ± 0.2</td></tr><tr><td>IWAE</td><td>81.7± 0.3</td><td>127.5 ± 0.5</td><td>65.3 ± 0.1</td></tr><tr><td>IWAE+Aug</td><td>80.4± 0.2</td><td>125.0 ± 0.6</td><td>65.3 ± 0.1</td></tr><tr><td>CR-IWAE</td><td>79.7 ± 0.3</td><td>123.6 ± 0.5</td><td>65.0 ± 0.2</td></tr><tr><td>β-VAE (0.5)</td><td>92.6±0.3</td><td>137.1 ± 0.2</td><td>68.7±0.2</td></tr><tr><td>β-VAE (0.5) + Aug</td><td>90.0 ± 0.5</td><td>134.6 ± 0.5</td><td>68.8 ± 0.2</td></tr><tr><td>β-CR-VAE (0.5)</td><td>85.7 ± 0.6</td><td>132.5 ± 0.3</td><td>68.2 ± 0.1</td></tr><tr><td>β-VAE (10)</td><td>126.1 ± 1.8</td><td>157.5 ± 1.1</td><td>92.7± 0.5</td></tr><tr><td>β-VAE (10) + Aug</td><td>127.1 ± 1.0</td><td>157.3 ± 0.5</td><td>92.7 ± 0.3</td></tr><tr><td>β-CR-VAE (10)</td><td>126.2 ± 0.5</td><td>157.6 ± 0.6</td><td>92.6 ± 0.1</td></tr></table>
+
+# 4.1 Application to standard vaes on benchmark datasets
+
+We apply consistency regularization, as described in this paper, to the original vae, the iwae, and the $\beta$ -vae. We now describe the set up and results for this experiment.
+
+Datasets. We study three benchmark datasets that we briefly describe below. We first consider mnist. mnist is a handwritten digit recognition dataset with 60, 000 images in the training set and 10, 000 images in the test set (LeCun, 1998). We form a validation set of 10, 000 images randomly sampled from the training set.
+
+We also consider omniglot, a handwritten alphabet recognition dataset (Lake et al., 2011). This dataset is composed of 19, 280 images. We use 16, 280 randomly sampled images for training and 1, 000 for validation and the remaining 2, 000 samples for testing.
+
+Finally we consider celeba. It is a dataset of faces, consisting of 162, 770 images for training, 19, 867 images for validation, and 19, 962 images for testing (Liu et al., 2018). We set the resolution to $3 2 \mathrm { x 3 2 }$ for this experiment.
+
+Transformations $t ( \tilde { \mathbf { x } } | \mathbf { x } )$ . We consider three transformations variants for image data $t ( \tilde { \mathbf { x } } | \mathbf { x } )$ . The first randomly translates an image $[ - 2 , 2 ]$ pixels in any direction. The second transformation randomly rotates an image uniformly in $[ - 1 5 , 1 5 ]$ degrees clockwise. Finally the third transformation randomly scales an image by a factor uniformly sampled from [0.9, 1.1].
+
+Table 4: The regularization term $\lambda$ affects both generalization performance and the quality of the learned representations. Many values of $\lambda$ perform better than the base vae. However a large enough value of $\lambda$ , e.g. $\lambda = 1$ , can lead to worse performance than the base vae because for large values of $\lambda$ the regularization term takes over the data-term in the objective function.   
+
+<table><tr><td></td><td>入</td><td>MI</td><td>AU</td><td>NLL</td></tr><tr><td>VAE</td><td>11</td><td>124.5</td><td>36</td><td>83.7</td></tr><tr><td>CR-VAE</td><td>0.001</td><td>125.0</td><td>38</td><td>83.5</td></tr><tr><td>CR-VAE</td><td>0.01</td><td>125.9</td><td>41</td><td>82.4</td></tr><tr><td>CR-VAE</td><td>0.1</td><td>126.3</td><td>47</td><td>81.2</td></tr><tr><td>CR-VAE</td><td>1</td><td>124.3</td><td>47</td><td>83.9</td></tr></table>
+
+Table 5: The choice of augmentation affects both generalization performance and the quality of the learned representations. Jointly using all augmentations works best.   
+
+<table><tr><td>Augmentation</td><td>MI</td><td>AU</td><td>NLL</td></tr><tr><td>Rotations only</td><td>125.8</td><td>45</td><td>82.1</td></tr><tr><td>Translations only</td><td>126.1</td><td>45</td><td>81.9</td></tr><tr><td>Scaling only</td><td>125.1</td><td>42</td><td>82.7</td></tr><tr><td>All</td><td>126.3</td><td>47</td><td>81.2</td></tr></table>
+
+Evaluation metrics. The regularization method we propose in this paper is mainly aimed at improving the learned representations of vaes. To assess these representations we use three metrics: mutual information, number of active latent units, and accuracy on a downstream classification task. We also evaluate the effect of the proposed method on generalization to unseen data. For that we also report negative log-likelihood. We define each of these metrics next.
+
+Mutual information $( M I )$ . The first quality metric is the mutual information $I ( \mathbf { z } ; \mathbf { x } )$ between the observations and the latents under the joint distribution induced by the encoder,
+
+$$
+I ( \mathbf { z } ; \mathbf { x } ) = \mathbb { E } _ { p _ { d } ( \mathbf { x } ) } \left[ K L ( q _ { \phi } ( \mathbf { z } | \mathbf { x } ) | | p ( \mathbf { z } ) ) - \kappa \mathbf { L } ( q _ { \phi } ( \mathbf { z } ) | | p ( \mathbf { z } ) ) \right]
+$$
+
+where $p _ { d } ( \mathbf { x } )$ is the empirical data distribution and $q _ { \phi } ( \mathbf { z } )$ is the aggregated posterior, the marginal over $\mathbf { z }$ induced by the joint distribution defined by $p _ { d } ( \mathbf { x } )$ and $q _ { \phi } ( { \bf z } | { \bf x } )$ . The mutual information is intractable but we can approximate it with Monte Carlo. Higher mutual information corresponds to more interpretable latent variables.
+
+Number of active latent units $( A U )$ . The second quality metrics we consider is the number of active latent units (AU). It is defined in Burda et al. (2015) and measures the “activity" of a dimension of the latent variables $\mathbf { z }$ . A latent dimension is “active" if
+
+$$
+C o v _ { \mathbf { x } } ( \mathbb { E } _ { \mathbf { u } \sim q _ { \phi } ( \mathbf { u } | \mathbf { x } ) } ) > \delta
+$$
+
+where $\delta$ is a threshold defined by the user. For our experiments we set $\delta = 0 . 0 1$ . The higher the number of latent active units, the better the learned representations.
+
+Accuracy on downstream classification. This metric is calculated by fitting a given vae, taking the learned representations for each data in the test set and computing the accuracy from the prediction of the labels of the images in that same test set by a classifier fitted on the training set. This metric is only applicable to labelled datasets.
+
+Negative log-likelihood. We use negative held-out log-likelihood to assess generalization. Consider an unseen data $\mathbf { x } ^ { * }$ , its negative held-out log-likelihood under the fitted model is
+
+$$
+\log p _ { \boldsymbol \theta } ( \mathbf { x } ^ { * } ) = - \log \left( \mathbb { E } _ { q _ { \boldsymbol \phi } ( \mathbf { z } | \mathbf { x } ^ { * } ) } \left[ \frac { p _ { \boldsymbol \theta } ( \mathbf { x } ^ { * } , \mathbf { z } ) } { q _ { \boldsymbol \phi } ( \mathbf { z } | \mathbf { x } ^ { * } ) } \right] \right) .
+$$
+
+Table 6: The cr-vae outperforms a popular and advanced contrastive learning technique called triplet loss on both generalization performance and quality of learned representations.   
+
+<table><tr><td>Method</td><td>MI</td><td>AU</td><td>NLL</td></tr><tr><td>VAE</td><td>124.5</td><td>36</td><td>83.7</td></tr><tr><td>VAE + augmentations</td><td>125.9</td><td>42</td><td>82.8</td></tr><tr><td>VAE + triplet loss</td><td>124.9</td><td>39</td><td>83.1</td></tr><tr><td>CR-VAE</td><td>126.3</td><td>47</td><td>81.2</td></tr></table>
+
+This is intractable and we approximate it using Monte Carlo,
+
+$$
+\log p _ { \theta } ( \mathbf { x } ^ { * } ) \approx - \log \frac { 1 } { S } \sum _ { s = 1 } ^ { S } \frac { p _ { \theta } ( \mathbf { x } ^ { * } , \mathbf { z } ^ { ( s ) } ) } { q _ { \phi } ( \mathbf { z } ^ { ( s ) } | \mathbf { x } ^ { * } ) }
+$$
+
+where $\mathbf { z } ^ { ( 1 ) } , \ldots , \mathbf { z } ^ { ( S ) } \sim q _ { \phi } ( \mathbf { z } | \mathbf { x } ^ { * } )$
+
+Settings. The vaes are built on the same architecture as Tolstikhin et al. (2017). The networks are trained with the Adam optimizer with a learning rate of $1 0 ^ { - 4 }$ (Kingma & Ba, 2014) and trained for 100 epochs with a batch size of 64. We set the dimensionality of the latent variables to 50, therefore the maximum number of active latent units in the latent space is 50. We found $\lambda = 0 . 1$ to be best according to cross-validation using held-out log-likelihood and exploring the range $[ 1 e ^ { - 4 } , 1 . 0 ]$ datasets. In an ablation study we explore $\lambda = 0$ . For the $\beta$ -vae we set $\lambda = 0 . 1 \cdot \beta$ and study both $\beta = 0 . 1$ and $\beta = 1 0$ , two regimes under which the $\beta$ -vae performs qualitatively very differently (Higgins et al., 2017). All experiments were done on a GPU cluster consisting of Nvidia P100 and RTX. The training took approximately 1 day for most experiments.
+
+Results. Table 1 shows that on all the three benchmark datasets all the different vae variants we studied, consistency regularization as developed in this paper always improves the quality of the learned representations as measured by mutual information and the number of active latent units. These results are confirmed by the numbers shown in Table 2 where cr-vaes always lead to better accuracy on downstream classification.
+
+We proposed consistency regularization as a way to improve the quality of the learned representations. Incidentally, Table 3 also shows that it can improve generalization as measured by negative loglikelihood.
+
+Ablation Study. We now look at the impact of each factor that goes into the regularization method we introduced in this paper using mnist. We test the impact of the regularization term $\lambda$ and the impact of the choice of augmentation on all metrics. Table 4 and Table 5 show the results.
+
+Table 4 shows that even small consistency regularization (a small $\lambda$ value) results in improvement over the base vae but that a large enough $\lambda$ value can hurt performance.
+
+Table 5 shows that rotations and translations are more important than scaling, but the combination of all three augmentations works best for cr-vaes.
+
+Comparison to Contrastive Learning. We look at how cr-vaes compare against a popular and advanced contrastive-learning-based technique, the triplet loss (Schroff et al., 2015) using mnist. Table 6 shows that the cr-vae outperforms the triplet loss on both generalization performance and quality of learned representations. Table 6 also confirms existing literature showing simply applying augmentations can outperform complex contrastive learning-based methods such as the triplet loss (Kostrikov et al., 2020; Sinha & Garg, 2021).
+
+# 4.2 Application to the large-scale nvae on benchmark datasets
+
+Along with standard VAE variants, we also experiment with a large scale state-of-the-art vae, the nvae(Vahdat & Kautz, 2020). Similar to before, we simply add consistency regularization using the image-based augmentations techniques to the NVAE model and experiment on benchmark datasets: mnist (LeCun, 1998), cifar-10 (Krizhevsky et al., 2009) and celeba (Liu et al., 2018).
+
+The results for large scale generative modeling are tabulated in Table 8 and Table 7, where we see that using cr-nvae we are able to learn representations that yield better accuracy on downstream classification and set new state-of-the-art values on each of the datasets, improving upon the baseline log-likelihood values. This shows the ability of consistency regularization to work at scale on challenging generative modeling tasks.
+
+Table 7: The cr-nvaes learns better representations than the base nvae as measured by accuracy on a downstream classification on both mnist and cifar-10. We get to this same conclusion when looking at the number of active units as an indicator for the quality of the learned latent representations; cr-nvae recovers 226 units whereas nvae recovers 211 units.   
+
+<table><tr><td>Method</td><td>MNIST</td><td>CIFAR-10</td></tr><tr><td>NVAE</td><td>99.9</td><td>57.9</td></tr><tr><td>NVAE+Aug</td><td>99.9</td><td>66.4</td></tr><tr><td>CR-NVAE</td><td>99.9</td><td>71.4</td></tr></table>
+
+Table 8: Large-scale experiments with nvaes with and without consistency-regularization on 3 benchmark datasets: dynamically binarized mnist, cifar-10 and celeba. We report generalization using negative log-likelihood on mnist and bits per dim on cifar-10 and celeba. On all datasets consistency regularization improves generalization performance. In particular cr-nvae achieves state-of-the-art performance on mnist and cifar-10.   
+
+<table><tr><td></td><td>MNIST (28 × 28)</td><td>CIFAR-10 (32 × 32)</td><td>CELEBA (64 × 64)</td></tr><tr><td>NVAE</td><td>78.19</td><td>2.91</td><td>2.03</td></tr><tr><td>NVAE+Aug</td><td>77.53</td><td>2.70</td><td>1.96</td></tr><tr><td>CR-NVAE</td><td>76.93</td><td>2.51</td><td>1.86</td></tr></table>
+
+![](images/013be7f0e1e75e1072aef4213dc3071a40eed8f53d36cb5a52a75b32e6cdd895.jpg)  
+Figure 2: Interpolation between two samples of a lamp, airplane and table using a trained CRFoldingNet trained on the ShapeNet dataset. The CR-FoldingNet is able to learn an interpretable latent space.
+
+# 4.3 Application to the FoldingNet on 3D point-cloud data
+
+Along with working with image data, we additionally experiment with 3D point cloud data using a FoldingNet Yang et al. (2018) and the ShapeNet dataset Chang et al. (2015) which consists of 55 distinct object classes. FoldingNet learns a deep AutoEncoder to learn unsupervised representations from the point cloud data. To add consistency regularization, we first substitute the AutoEncoder to a vae by adding the KL term from the ELBO to the baseline FoldingNet. We then add the additional consistency regularization KL term to the latent space of FoldingNet.
+
+Table 9: The FoldingNet yields higher accuracy when paired with consistency regularization on the ShapeNet dataset. The results shown here correspond to a FoldingNet that was trained with augmented data, the same used to apply consistency regularization. As can be seen from these results, enforcing consistency through KL as we do in this paper leads to representations that perform well on a downstream classification. Here the classifier used is a linear SVM. We also report mean reconstruction error through Chamfer distance where the same conclusion holds.   
+
+<table><tr><td>Method</td><td>Accuracy</td><td>Reconstruction Loss</td></tr><tr><td>Folding Net (Aug)</td><td>82.5%</td><td>0.0355</td></tr><tr><td>CR-Folding Net</td><td>84.6%</td><td>0.0327</td></tr></table>
+
+For the ShapeNet point cloud data, we perform data augmentation using a similar scheme to what we did for the previous experiments, we randomly translate, rotate and add jitter to the $( x , y , z )$ coordinates of the point cloud data. We follow the same scheme detailed in FoldingNet (Yang et al., 2018).
+
+We train both the FoldingNet turned in a vae and the CR-FoldingNet with these augmentations. To train CR-FoldingNet, we additionally apply the consistency regularization term as proposed in Equation 3. The results on the validation set for reconstruction (as measured by Chamfer distance) and accuracy are shown in Table 9.
+
+We also visualize the point clouds reconstructions and interpolations between 3 different object classes using a CR-FoldingNet in Figure 2. We perform 4 interpolation steps for each of the objects, to highlight the interpretable learned latent space. Additionally, we perform the same interpolation on the baseline FoldingNet model. We show these interpolations in the appendix.
+
+# 5 Conclusion
+
+We proposed a simple regularization technique to constrain encoders of vaes to learn similar latent representations for an image and a semantics-preserving transformation of the image. The idea consists in maximizing the likelihood of the pair of images while minimizing the kl divergence between the variational distribution induced by the encoder when conditioning on the image on one hand, and its transformation, on the other hand. We applied this technique to several vae variants on several datasets, including a 3D dataset. We found it always leads to better learned representations and also better generalization to unseen data. In particular, when applied to the nvae, the regularization technique we developed in this paper yields state-of-the-art results on mnist and cifar-10.
+
+# Broader Impact
+
+In this paper, we propose a simple method that performs a KL-based consistency regularization scheme using data augmentation for vaes. The broader impact of the study includes practical applications such as graphics and computer vision applications. The method we propose improves the learned representations of vaes, and as an artifact, also improves their generalization to unseen data. In this regard, any implications of vaes also apply to this work. For example, the generative model fit by a vae may be used to generate artificial data such as images, text, and 3D objects. Biases may arise as a result of poor data selection. Furthermore, text generated from generative systems may amplify harmful speech contained in the data. However, the method we propose can also improve the performance of vaes when used in certain practical domains as we discussed in the introduction of the paper.
+
+# 6 Acknowledgements
+
+We thank Kevin Murphy, Ben Poole, and Augustus Odena for their comments on this work.
+
+# References
+
+Achille, A., Eccles, T., Matthey, L., Burgess, C. P., Watters, N., Lerchner, A., and Higgins, I. Life-long disentangled representation learning with cross-domain latent homologies. arXiv preprint arXiv:1808.06508, 2018.   
+An, J. and Cho, S. Variational autoencoder based anomaly detection using reconstruction probability. Special Lecture on IE, 2(1), 2015.   
+Bachman, P., Alsharif, O., and Precup, D. Learning with pseudo-ensembles. In Advances in neural information processing systems, pp. 3365–3373, 2014.   
+Bowman, S. R., Vilnis, L., Vinyals, O., Dai, A. M., Jozefowicz, R., and Bengio, S. Generating sentences from a continuous space. arXiv preprint arXiv:1511.06349, 2015.   
+Burda, Y., Grosse, R., and Salakhutdinov, R. Importance weighted autoencoders. arXiv preprint arXiv:1509.00519, 2015.   
+Chang, A. X., Funkhouser, T., Guibas, L., Hanrahan, P., Huang, Q., Li, Z., Savarese, S., Savva, M., Song, S., Su, H., et al. Shapenet: An information-rich 3d model repository. arXiv preprint arXiv:1512.03012, 2015.   
+Dieng, A. B., Kim, Y., Rush, A. M., and Blei, D. M. Avoiding latent variable collapse with generative skip models. arXiv preprint arXiv:1807.04863, 2018.   
+Dieng, A. B., Ruiz, F. J., and Blei, D. M. Topic modeling in embedding spaces. arXiv preprint arXiv:1907.04907, 2019.   
+Fang, L., Li, C., Gao, J., Dong, W., and Chen, C. Implicit deep latent variable models for text generation. arXiv preprint arXiv:1908.11527, 2019.   
+Fu, H., Li, C., Liu, X., Gao, J., Celikyilmaz, A., and Carin, L. Cyclical annealing schedule: A simple approach to mitigating kl vanishing. arXiv preprint arXiv:1903.10145, 2019.   
+Goodfellow, I., Pouget-Abadie, J., Mirza, M., Xu, B., Warde-Farley, D., Ozair, S., Courville, A., and Bengio, Y. Generative adversarial nets. In Advances in neural information processing systems, pp. 2672–2680, 2014.   
+Gregor, K., Danihelka, I., Graves, A., Rezende, D. J., and Wierstra, D. Draw: A recurrent neural network for image generation. arXiv preprint arXiv:1502.04623, 2015.   
+Hadjeres, G., Nielsen, F., and Pachet, F. Glsr-vae: Geodesic latent space regularization for variational autoencoder architectures. In 2017 IEEE Symposium Series on Computational Intelligence (SSCI), pp. 1–7. IEEE, 2017.   
+He, J., Spokoyny, D., Neubig, G., and Berg-Kirkpatrick, T. Lagging inference networks and posterior collapse in variational autoencoders. arXiv preprint arXiv:1901.05534, 2019.   
+Higgins, I., Matthey, L., Pal, A., Burgess, C., Glorot, X., Botvinick, M., Mohamed, S., and Lerchner, A. beta-vae: Learning basic visual concepts with a constrained variational framework. Iclr, 2(5):6, 2017.   
+Jun, H., Child, R., Chen, M., Schulman, J., Ramesh, A., Radford, A., and Sutskever, I. Distribution augmentation for generative modeling. In International Conference on Machine Learning, pp. 5006–5019. PMLR, 2020.   
+Kim, Y., Wiseman, S., Miller, A. C., Sontag, D., and Rush, A. M. Semi-amortized variational autoencoders. arXiv preprint arXiv:1802.02550, 2018.   
+Kingma, D. P. and Ba, J. Adam: A method for stochastic optimization. arXiv preprint arXiv:1412.6980, 2014.   
+Kingma, D. P. and Welling, M. Auto-encoding variational bayes. arXiv preprint arXiv:1312.6114, 2013.   
+Kingma, D. P., Rezende, D. J., Mohamed, S., and Welling, M. Semi-supervised learning with deep generative models. arXiv preprint arXiv:1406.5298, 2014.   
+Kostrikov, I., Yarats, D., and Fergus, R. Image augmentation is all you need: Regularizing deep reinforcement learning from pixels. arXiv preprint arXiv:2004.13649, 2020.   
+Krizhevsky, A., Hinton, G., et al. Learning multiple layers of features from tiny images. 2009.   
+Laine, S. and Aila, T. Temporal ensembling for semi-supervised learning. arXiv preprint arXiv:1610.02242, 2016.   
+Lake, B., Salakhutdinov, R., Gross, J., and Tenenbaum, J. One shot learning of simple visual concepts. In Proceedings of the annual meeting of the cognitive science society, volume 33, 2011.   
+LeCun, Y. The mnist database of handwritten digits. http://yann. lecun. com/exdb/mnist/, 1998.   
+Liang, D., Krishnan, R. G., Hoffman, M. D., and Jebara, T. Variational autoencoders for collaborative filtering. In Proceedings of the 2018 World Wide Web Conference, pp. 689–698, 2018.   
+Liu, Z., Luo, P., Wang, X., and Tang, X. Large-scale celebfaces attributes (celeba) dataset. Retrieved August, 15: 2018, 2018.   
+Miao, Y., Yu, L., and Blunsom, P. Neural variational inference for text processing. In International conference on machine learning, pp. 1727–1736, 2016.   
+Miyato, T., Maeda, S.-i., Ishii, S., and Koyama, M. Virtual adversarial training: a regularization method for supervised and semi-supervised learning. IEEE transactions on pattern analysis and machine intelligence, 2018.   
+Osada, G., Ahsan, B., Bora, R. P., and Nishide, T. Regularization with latent space virtual adversarial training. In European Conference on Computer Vision, pp. 565–581. Springer, 2020.   
+Rezende, D. J., Mohamed, S., and Wierstra, D. Stochastic backpropagation and approximate inference in deep generative models. arXiv preprint arXiv:1401.4082, 2014.   
+Rifai, S., Vincent, P., Muller, X., Glorot, X., and Bengio, Y. Contractive auto-encoders: Explicit invariance during feature extraction. 2011.   
+Roberts, A., Engel, J., Raffel, C., Hawthorne, C., and Eck, D. A hierarchical latent vector model for learning long-term structure in music. arXiv preprint arXiv:1803.05428, 2018.   
+Sajjadi, M., Javanmardi, M., and Tasdizen, T. Regularization with stochastic transformations and perturbations for deep semi-supervised learning. In NeurIPS, 2016.   
+Schroff, F., Kalenichenko, D., and Philbin, J. Facenet: A unified embedding for face recognition and clustering. In Proceedings of the IEEE conference on computer vision and pattern recognition, pp. 815–823, 2015.   
+Sinha, S. and Garg, A. S4rl: Surprisingly simple self-supervision for offline reinforcement learning. arXiv preprint arXiv:2103.06326, 2021.   
+Sinha, S., Ebrahimi, S., and Darrell, T. Variational adversarial active learning. In Proceedings of the IEEE International Conference on Computer Vision, pp. 5972–5981, 2019.   
+Tolstikhin, I., Bousquet, O., Gelly, S., and Schoelkopf, B. Wasserstein auto-encoders. arXiv preprint arXiv:1711.01558, 2017.   
+Vahdat, A. and Kautz, J. Nvae: A deep hierarchical variational autoencoder. arXiv preprint arXiv:2007.03898, 2020.   
+Vincent, P., Larochelle, H., Bengio, Y., and Manzagol, P.-A. Extracting and composing robust features with denoising autoencoders. In Proceedings of the 25th international conference on Machine learning, pp. 1096–1103, 2008.   
+Vincent, P., Larochelle, H., Lajoie, I., Bengio, Y., and Manzagol, P.-A. Stacked denoising autoencoders: Learning useful representations in a deep network with a local denoising criterion. Journal of machine learning research, 11(Dec):3371–3408, 2010.   
+Walker, J., Doersch, C., Gupta, A., and Hebert, M. An uncertain future: Forecasting from static images using variational autoencoders. In European Conference on Computer Vision, pp. 835–851. Springer, 2016.   
+Wei, X., Gong, B., Liu, Z., Lu, W., and Wang, L. Improving the improved training of wasserstein gans: A consistency term and its dual effect. arXiv preprint arXiv:1803.01541, 2018.   
+Xie, Q., Dai, Z., Hovy, E., Luong, M.-T., and Le, Q. V. Unsupervised data augmentation for consistency training. arXiv preprint arXiv:1904.12848, 2019.   
+Yang, Y., Feng, C., Shen, Y., and Tian, D. Foldingnet: Point cloud auto-encoder via deep grid deformation. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pp. 206–215, 2018.   
+Zhang, H., Zhang, Z., Odena, A., and Lee, H. Consistency regularization for generative adversarial networks. 2020.   
+Zimmerer, D., Kohl, S. A., Petersen, J., Isensee, F., and Maier-Hein, K. H. Context-encoding variational autoencoder for unsupervised anomaly detection. arXiv preprint arXiv:1812.05941, 2018.

parse/train/djbC2A4uTHP/djbC2A4uTHP_content_list.json

@@ -0,0 +1,1187 @@
+[
+    {
+        "type": "text",
+        "text": "Consistency Regularization for Variational Auto-Encoders ",
+        "text_level": 1,
+        "bbox": [
+            312,
+            123,
+            683,
+            171
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Samarth Sinha Vector Institute University of Toronto ",
+        "bbox": [
+            295,
+            222,
+            437,
+            263
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Adji B. Dieng   \nGoogle Brain   \nPrinceton University ",
+        "bbox": [
+            565,
+            222,
+            702,
+            263
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Abstract ",
+        "text_level": 1,
+        "bbox": [
+            462,
+            299,
+            535,
+            315
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Variational auto-encoders (vaes) are a powerful approach to unsupervised learning. They enable scalable approximate posterior inference in latent-variable models using variational inference (vi). A vae posits a variational family parameterized by a deep neural network—called an encoder—that takes data as input. This encoder is shared across all the observations, which amortizes the cost of inference. However the encoder of a vae has the undesirable property that it maps a given observation and a semantics-preserving transformation of it to different latent representations. This “inconsistency\" of the encoder lowers the quality of the learned representations, especially for downstream tasks, and also negatively affects generalization. In this paper, we propose a regularization method to enforce consistency in vaes. The idea is to minimize the Kullback-Leibler (kl) divergence between the variational distribution when conditioning on the observation and the variational distribution when conditioning on a random semantic-preserving transformation of this observation. This regularization is applicable to any vae. In our experiments we apply it to four different vae variants on several benchmark datasets and found it always improves the quality of the learned representations but also leads to better generalization. In particular, when applied to the nouveau variational auto-encoder (nvae), our regularization method yields state-of-the-art performance on mnist, cifar-10, and celeba. We also applied our method to 3D data and found it learns representations of superior quality as measured by accuracy on a downstream classification task. Finally, we show our method can even outperform the triplet loss, an advanced and popular contrastive learning-based method for representation learning. ",
+        "bbox": [
+            232,
+            325,
+            766,
+            630
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 Introduction ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            645,
+            312,
+            661
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Variational auto-encoders (vaes) have significantly impacted research on unsupervised learning. They have been used in several areas, including density estimation (Kingma & Welling, 2013; Rezende et al., 2014), image generation (Gregor et al., 2015), text generation (Bowman et al., 2015; Fang et al., 2019), music generation (Roberts et al., 2018), topic modeling (Miao et al., 2016; Dieng et al., 2019), and recommendation systems (Liang et al., 2018). Vaes have also been used for different representation learning problems such as semi-supervised learning (Kingma et al., 2014), anomaly detection (An & Cho, 2015; Zimmerer et al., 2018), language modeling Bowman et al. (2015), active learning (Sinha et al., 2019), continual learning (Achille et al., 2018), and motion prediction of agents (Walker et al., 2016). This widespread application of vae representations makes it critical that we focus on improving them. ",
+        "bbox": [
+            174,
+            670,
+            825,
+            808
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "vaes extend deterministic auto-encoders to probabilistic generative modeling. The encoder of a vae parameterizes an approximate posterior distribution over latent variables of a generative model. The encoder is shared between all observations, which amortizes the cost of posterior inference. Once fitted, the encoder of a vae can be used to obtain low-dimensional representations of data, (e.g. for downstream tasks.) The quality of these representations is therefore very important to a successful application of vaes. ",
+        "bbox": [
+            174,
+            816,
+            825,
+            871
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "image",
+        "img_path": "images/87da93feb9101d9471f5468dd3ffeb7e8e2ecfe35807360b6f865d0e977509dc.jpg",
+        "image_caption": [
+            "Figure 1: Illustration of the inconsistency problem in vaes and how cr-vaes address this problem. The red dots correspond to the representations of few images from mnist. The blue dots correspond to the representations of the transformed images. The transformations used here are rotations, translations, and scaling; they are semantics-preserving. The arrows connect the representations of any two pairs of an image and its transformation. The shorter the arrow, the better. (a): The vae maps the two sets of images to different areas in the latent space. (b): Even when trained with the original dataset augmented with the transformed images, the vae still maps the two sets of images to different parts in the latent space. (c): The cr-vae maps an image and its transformation to nearby areas in the latent space. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            210,
+            0,
+            794,
+            219
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            176,
+            385,
+            821,
+            412
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Researchers have looked at ways to improve the quality of the latent representations of vaes, often tackling the so-called latent variable collapse problem—in which the approximate posterior distribution induced by the encoder collapses to the prior over the latent variables (Bowman et al., 2015; Kim et al., 2018; Dieng et al., 2018; He et al., 2019; Fu et al., 2019). ",
+        "bbox": [
+            174,
+            420,
+            825,
+            476
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "In this paper, we focus on a different problem pertaining to the latent representations of vaes for image data. Indeed, the encoder of a fitted vae tends to map an image and a semantics-preserving transformation of that image to different parts in the latent space. This “inconsistency\" of the encoder affects the quality of the learned representations and generalization. We propose a method to enforce consistency in vaes. The idea is simple and consists in maximizing the likelihood of the images while minimizing the Kullback-Leibler $\\mathbf { \\Pi } ( \\kappa \\mathbf { L } )$ divergence between the approximate posterior distribution induced by the encoder when conditioning on the image, on one hand, and its transformation, on the other hand. This regularization technique can be applied to any vae variant to improve the quality of the learned representations and boost generalization performance. We call a vae with this form of regularization, a consistency-regularized variational auto-encoder (cr-vae). ",
+        "bbox": [
+            174,
+            483,
+            825,
+            622
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Figure 1 illustrates the inconsistency problem of vaes and how cr-vaes address this problem on mnist. The red dots are representations of a few images and the blue dots are the representations of their transformations. We applied semantics-preserving transformations: rotation, translation, and scaling. The vae maps each image and its transformation to different parts in the latent space as evidenced by the long arrows connecting each pair (a). Even when we include the transformed images to the data and fit the vae the inconsistency problem still occurs (b). The cr-vae does not suffer from the inconsistency problem; it maps each image and its transformation to nearby areas in the latent space, as evidenced by the short arrows connecting each pair (c). ",
+        "bbox": [
+            173,
+            628,
+            825,
+            741
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "In our experiments (see Section 4), we apply the proposed technique to four vae variants, the original vae (Kingma & Welling, 2013), the importance-weighted auto-encoder (iwae) (Burda et al., 2015), the $\\beta$ -vae (Higgins et al., 2017), and the nouveau variational auto-encoder (nvae) (Vahdat & Kautz, 2020). We found, on four different benchmark datasets, that cr-vaes always yield better representations and generalize better than their base vaes. In particular, consistency-regularized nouveau variational auto-encoders (cr-nvaes) yield state-of-the-art performance on mnist and cifar-10. We also applied cr-vaes to 3D data where these conclusions still hold. ",
+        "bbox": [
+            174,
+            747,
+            825,
+            844
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2 Method ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            858,
+            271,
+            875
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "We consider a latent-variable model $p _ { \\boldsymbol { \\theta } } ( \\mathbf { x } , \\mathbf { z } ) = p _ { \\boldsymbol { \\theta } } ( \\mathbf { x } | \\mathbf { z } ) \\cdot p ( \\mathbf { z } )$ , where $\\mathbf { x }$ denotes an observation and $\\mathbf { z }$ is its associated latent variable. The marginal $p ( \\mathbf { z } )$ is a prior over the latent variable and $p _ { \\boldsymbol { \\theta } } ( \\mathbf { x } | \\mathbf { z } )$ ",
+        "bbox": [
+            174,
+            882,
+            823,
+            911
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "is an exponential family distribution whose natural parameter is a function of $\\mathbf { z }$ parameterized by $\\theta$ , e.g. through a neural network. Our goal is to learn the parameters $\\theta$ and a posterior distribution over the latent variables. The approach of vaes is to maximize the evidence lower bound (elbo), a lower bound on the log marginal likelihood of the data, ",
+        "bbox": [
+            173,
+            90,
+            826,
+            147
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/5d271458eb06f054cd1c9f6f42d7f9c933f577600e9497a10a7ddf4e3e3b6ade.jpg",
+        "text": "$$\n\\mathcal { L } _ { \\mathrm { v A E } } = \\mathtt { E L B O } = \\mathbb { E } _ { q _ { \\phi } ( \\mathbf { z } | \\mathbf { x } ) } \\left[ \\log \\left( \\frac { p _ { \\theta } ( \\mathbf { x } , \\mathbf { z } ) } { q _ { \\phi } ( \\mathbf { z } | \\mathbf { x } ) } \\right) \\right]\n$$",
+        "text_format": "latex",
+        "bbox": [
+            352,
+            154,
+            645,
+            189
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "where $q _ { \\phi } ( \\mathbf { z } | \\mathbf { x } )$ is an approximate posterior distribution over the latent variables. The idea of a vae is to let the parameters of the distribution $q _ { \\phi } ( { \\bf z } | { \\bf x } )$ be given by the output of a neural network, with parameters $\\phi$ , that takes $\\mathbf { x }$ as input. The parameters $\\theta$ and $\\phi$ are then jointly optimized by maximizing a Monte Carlo approximation of the elbo using the reparameterization trick (Kingma & Welling, 2013). ",
+        "bbox": [
+            174,
+            195,
+            825,
+            266
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Consider a semantics-preserving transformation $t ( \\tilde { \\mathbf { x } } | \\mathbf { x } )$ of data $\\mathbf { x }$ (e.g. rotation or translation for images.) A good representation learning algorithm should provide similar latent representations for $\\mathbf { x }$ and $\\tilde { \\mathbf { x } }$ . This is not the case for the vae that maximizes Equation 1 and its variants. Once fit to data, the encoder of a vae is unable to yield similar latent representations for a data $\\mathbf { x }$ and its tranformation x˜ (see Figure 1). This is because there is nothing in Equation 1 that forces this desideratum. ",
+        "bbox": [
+            173,
+            272,
+            825,
+            343
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "We now propose a regularization method that ensures consistency of the encoder of a vae. We call a vae with such a regularization a cr-vae. The regularization proposed is applicable to many variants of the vae such as the iwae (Burda et al., 2015), the $\\beta$ -vae (Higgins et al., 2017), and the nvae (Vahdat & Kautz, 2020). In what follows, we use the standard vae, the one that maximizes Equation 1, as the base vae to regularize to illustrate the method. ",
+        "bbox": [
+            173,
+            348,
+            825,
+            419
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Consider an image $\\mathbf { x }$ . Denote by $t ( \\tilde { \\mathbf { x } } | \\mathbf { x } )$ the random process by which we generate $\\tilde { \\mathbf { x } }$ , a semanticspreserving transformation of $\\mathbf { x }$ . We draw $\\tilde { \\mathbf { x } }$ from $t ( \\tilde { \\mathbf { x } } | \\mathbf { x } )$ as follows: ",
+        "bbox": [
+            174,
+            425,
+            825,
+            454
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/f03c44e8274f6944635a3eaf220484b2dffc981faaf10c88764078d41e3aee5f.jpg",
+        "text": "$$\n\\begin{array} { r } { \\tilde { { \\mathbf { x } } } \\sim t ( \\tilde { { \\mathbf { x } } } | { \\mathbf { x } } ) \\iff \\epsilon \\sim p ( \\epsilon ) \\mathrm { a n d } \\tilde { { \\mathbf { x } } } = g ( { \\mathbf { x } } , \\epsilon ) . } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            349,
+            460,
+            647,
+            478
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Here $g ( \\mathbf { x } , \\epsilon )$ is a semantics-preserving transformation of the image $\\mathbf { x }$ , e.g. translation with random length $\\epsilon$ drawn from $\\boldsymbol { p } ( \\boldsymbol { \\epsilon } ) = \\mathbf { \\bar { \\mathcal { U } } } [ - \\delta , \\delta ]$ for some threshold $\\delta$ . A cr-vae then maximizes ",
+        "bbox": [
+            173,
+            486,
+            825,
+            513
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/232a0cf438bd8162ffcb009760e5764148e0ddb2944864d1ba174eb053dc3ab2.jpg",
+        "text": "$$\n\\mathcal { L } _ { \\mathtt { C R - V A E } } ( \\mathbf { x } ) = \\mathcal { L } _ { \\mathtt { V A E } } ( \\mathbf { x } ) + \\mathbb { E } _ { t ( \\tilde { \\mathbf { x } } | \\mathbf { x } ) } \\left[ \\mathcal { L } _ { \\mathtt { V A E } } ( \\tilde { \\mathbf { x } } ) \\right] - \\lambda \\cdot \\mathcal { R } ( \\mathbf { x } , \\phi )\n$$",
+        "text_format": "latex",
+        "bbox": [
+            310,
+            522,
+            686,
+            541
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "where the regularization term $\\mathcal { R } ( \\mathbf { x } , \\phi )$ is ",
+        "bbox": [
+            176,
+            549,
+            441,
+            564
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/c74383d34e75780205a7859f62fd761513688c87abc06ef16c17185ee13fd7a4.jpg",
+        "text": "$$\n\\begin{array} { r } { \\mathcal { R } ( \\mathbf { x } , \\phi ) = \\mathbb { E } _ { t ( \\tilde { \\mathbf { x } } | \\mathbf { x } ) } \\left[ \\mathrm { K L } \\left( q _ { \\phi } ( \\mathbf { z } | \\tilde { \\mathbf { x } } ) | | q _ { \\phi } ( \\mathbf { z } | \\mathbf { x } ) \\right) \\right] . } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            354,
+            570,
+            643,
+            589
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Maximizing the objective in Equation 3 maximizes the likelihood of the data and their augmentations while enforcing consistency through $\\mathcal { R } ( \\mathbf { x } , \\phi )$ . Minimizing $\\mathcal { R } ( \\mathbf { x } , \\phi )$ , which only affects the encoder (with parameters $\\phi$ ), forces each observation and the corresponding augmentations to lie close to each other in the latent space. The hyperparameter $\\lambda \\geq 0$ controls the strength of this constraint. ",
+        "bbox": [
+            173,
+            602,
+            823,
+            660
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "The objective in Equation 3 is intractable but we can easily approximate it using Monte Carlo with the reparameterization trick. In particular, we approximate the regularization term with one sample from $t ( \\tilde { \\mathbf { x } } | \\mathbf { x } )$ and make the dependence to this sample explicit using the notation $\\mathcal { R } ( \\mathbf { x } , \\tilde { \\mathbf { x } } , \\phi )$ . Algorithm 1 illustrates this in greater detail. Although we show the application of consistency regularization using the vae that maximizes the elbo, $\\mathcal { L } _ { \\mathrm { v _ { A E } } } ( \\cdot )$ in Equation 3 can be replaced with any vae objective. ",
+        "bbox": [
+            173,
+            665,
+            825,
+            750
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3 Related Work ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            762,
+            321,
+            779
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Applying consistency regularization to vaes, as we do in this paper, has not been previously explored. Consistency regularization is a widely used technique for semi-supervised learning (Bachman et al., 2014; Sajjadi et al., 2016; Laine & Aila, 2016; Miyato et al., 2018; Xie et al., 2019). The core idea behind consistency regularization for semi-supervised learning is to force classifiers to learn representations that are insensitive to semantics-preserving changes to images, so as to improve classification of unlabeled images. Examples of semantics-preserving changes used in the literature include rotation, zoom, translation, crop, or adversarial attacks. Consistency is often enforced by minimizing the $\\mathbb { L } _ { 2 }$ distance between a classifier’s logit output for an image and the logit output for its semantics-preserving transformation (Sajjadi et al., 2016; Laine & Aila, 2016), or by minimizing the kl divergence between the classifier’s label distribution induced by the image and that of its tranformation (Miyato et al., 2018; Xie et al., 2019). ",
+        "bbox": [
+            174,
+            786,
+            825,
+            911
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "table",
+        "img_path": "images/d590410ae5320acbe610c74382f7978aeec1c5aa980fb2c6b19f816af2109735.jpg",
+        "table_caption": [],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>input :Data X,consistency regularization strength 入,latent space dimensionality K Initialize parameters 0,$ foriterationt=1,2,...do for n=1,...,Bdo Transform the data: ∈n ~ p(∈n) and xn = T(xn,∈n) Get variational mean and variance for the data: μn = WTNN(xn; Φ) + a and σn = softplus(QTNN(xn; Φ) + b) Get S samples from the variational distribution when conditioning on Xn: η(s) ~ N(0,I) and Z） ）= μn+n(s).σn for s=1,...,S Get variational mean and variance for the transformed data:</td></tr></table>",
+        "bbox": [
+            171,
+            127,
+            781,
+            529
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            560,
+            821,
+            588
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "More recently, consistency regularization has been applied to generative adversarial networks (gans) (Goodfellow et al., 2014). Indeed Wei et al. (2018) and Zhang et al. (2020) show that applying consistency regularization on the discriminator of a gan—also a classifier—can substantially improve its performance. ",
+        "bbox": [
+            174,
+            597,
+            825,
+            652
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "The idea we develop in this paper differs from the works above in two ways. First, it applies consistency regularization to vaes for image data. Second, it leverages consistency regularization, not in the label or logit space, as done in the works mentioned above, but in the latent space. ",
+        "bbox": [
+            174,
+            660,
+            825,
+            702
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Although different, consistency regularization for vaes relates to works that study ways to constrain the sensitivity of encoders to various perturbations. For example, denoising auto-encoders (daes) and their variants (Vincent et al., 2008, 2010) corrupt an image $\\mathbf { x }$ into $\\mathbf { x } ^ { \\prime }$ , typically using Gaussian noise, and then minimize the distance between the reconstruction of $\\mathbf { x } ^ { \\prime }$ and the un-corrupted image x. The motivation is to learn representations that are insensitive to the added noise. Our work differs in that we do not constrain the decoder to recover the original image from the corrupted image but, rather, to constrain the encoder to recover the latent representation of the original image from the corrupted image via a kl divergence minimization constraint. ",
+        "bbox": [
+            174,
+            709,
+            825,
+            820
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Contractive auto-encoders (caes) (Rifai et al., 2011) share a similar goal with cr-vaes. A cae is an auto-encoder whose encoder is constrained by minimizing the norm of the Jacobian of the output of the encoder with respect to the input image. This norm constraint on the Jacobian forces the representations learned by the encoder to be insensitive to changes in the input. Our work differs in several main ways. First, cr-vaes are not deterministic auto-encoders, contrary to caes. We can easily sample from a cr-vae, as for any vae, which is not the case for a cae. Second, a cae does not apply transformations to the input image, which limits the sensitivities it can learn to limit to those exhibited in the training set. Finally, caes use the Jacobian to impose a consistency constraint, which are not as easy to compute as the kl divergence we use on the variational distribution induced by the encoder. ",
+        "bbox": [
+            174,
+            827,
+            823,
+            911
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "table",
+        "img_path": "images/01f62b4aea9bb82dffcddb89fa9a85c9f395e99eb8cc15ec176ece76074b337b.jpg",
+        "table_caption": [
+            "Table 1: cr-vaes learn better representations than their base vaes on all three benchmark datasets. Although fitting the base vae with augmentations does improve the representations, adding the consistency regularization further improves the quality of these learned representations. The value of $\\beta$ for the $\\beta$ -vae is inside the parentheses. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=\"2\">Method</td><td colspan=\"2\">MNIST</td><td colspan=\"2\">OMNIGLOT</td><td colspan=\"2\">CELEBA</td></tr><tr><td>MI</td><td>AU</td><td>MI</td><td>AU</td><td>MI</td><td>AU</td></tr><tr><td>VAE</td><td>124.5 ±1.1</td><td>36±0.8</td><td>105.4±1.2</td><td>50±0.0</td><td>33.8±0.2</td><td>32±0.9</td></tr><tr><td>VAE + Aug</td><td>125.9 ± 0.2</td><td>42 ± 0.5</td><td>105.9 ± 0.7</td><td>50 ±0.0</td><td>34.1± 0.8</td><td>33 ± 0.9</td></tr><tr><td>CR-VAE</td><td>126.3 ± 0.9</td><td>47 ± 0.5</td><td>107.8 ± 1.1</td><td>50±0.0</td><td>34.9 ± 0.5</td><td>33 ±1.2</td></tr><tr><td>IWAE</td><td>127.1 ± 0.7</td><td>39±0.5</td><td>110.3±1.1</td><td>50±0.0</td><td>36.9± 0.5</td><td>36 ±1.6</td></tr><tr><td>IWAE+Aug</td><td>129.0 ± 0.9</td><td>45±0.8</td><td>112.9 ± 0.7</td><td>50 ±0.0</td><td>37.0± 0.2</td><td>36 ± 1.2</td></tr><tr><td>CR-IWAE</td><td>129.7 ± 1.0</td><td>50 ± 0.0</td><td>115.3 ± 0.8</td><td>50±0.0</td><td>38.4 ± 0.5</td><td>36 ± 1.9</td></tr><tr><td>β-VAE (0.5)</td><td>284.3± 1.1</td><td>50±0.0</td><td>143.4 ± 1.0</td><td>50±0.0</td><td>75.8 ± 0.5</td><td>49± 0.5</td></tr><tr><td>β-VAE (0.5) + Aug</td><td>289.3 ± 1.0</td><td>50±0.0</td><td>159.6 ± 1.3</td><td>50±0.0</td><td>75.7 ± 0.3</td><td>49±0.0</td></tr><tr><td>β-CR-VAE (0.5)</td><td>291.9 ± 0.7</td><td>50±0.0</td><td>169.5 ± 0.5</td><td>50±0.0</td><td>77.1 ± 0.1</td><td>50 ± 0.0</td></tr><tr><td>β-VAE (10)</td><td>6.3± 0.6</td><td>8±1.7</td><td>1.4 ± 0.2</td><td>4±0.9</td><td>3.6± 0.3</td><td>7±0.8</td></tr><tr><td>β-VAE (10) + Aug</td><td>6.5 ± 0.5</td><td>9±1.1</td><td>1.6 ± 0.2</td><td>4±0.5</td><td>3.7 ± 0.1</td><td>7±0.0</td></tr><tr><td>β-CR-VAE (10)</td><td>6.9 ± 0.6</td><td>10 ± 0.5</td><td>1.6 ± 0.1</td><td>4± 0.5</td><td>3.7 ± 0.4</td><td>9 ± 0.9</td></tr></table>",
+        "bbox": [
+            173,
+            165,
+            834,
+            363
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            388,
+            825,
+            444
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "4 Empirical Study ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            457,
+            343,
+            474
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "In this section we show that a cr-vae improves the learned representations of its base vae and positively affects generalization performance We also show that the proposed regularization method is amenable to different vae variants by applying it not only to the original vae but also to the iwae, the $\\beta$ -vae, and the nvae. We showcase the importance of the KL regularization term by conducting an ablation study. We found that only regularizing with data augmentation improves performance but that accounting for the kl term $\\lambda > 0$ ) further improves the quality of the learned representations and generalization. ",
+        "bbox": [
+            173,
+            482,
+            825,
+            579
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "We will conduct three sets of experiments. In the first experiment, we will apply the regularization method proposed in this paper to standard vaes such as the original vae, the iwae, and the $\\beta$ -vae. We use mnist, omniglot, and celeba as datasets for this experiment. For celeba, we choose the $3 2 \\mathrm { x 3 2 }$ resolution for this experiment. Our results show that adding consistency regularization always improves upon the base vae, both in terms of the quality of the learned representations and generalization. We conduct an ablation study and also report performance of the different vae variants above when they are fitted with the original data and their augmentations. The results from this ablation highlight the importance of setting $\\lambda > 0$ . ",
+        "bbox": [
+            173,
+            585,
+            825,
+            696
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "In the second set of experiments we apply our method to a large-scale vae, the latest nvae (Vahdat & Kautz, 2020). We use mnist, cifar-10, and celeba as datasets for this experiment. We increased the resolution for the celeba dataset for this experiment to $6 4 \\mathrm { x 6 4 }$ . We reach the same conclusions as for the first sets of experiments; cr-vaes improve the learned representations and generalization of their base vaes. In this particular setting, the cr-nvae achieves state-of-the-art generalization performance on both mnist and cifar-10. This state-of-the-art performance couldn’t be reach simply by training the nvae with augmentations, as our results show. ",
+        "bbox": [
+            173,
+            703,
+            825,
+            800
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Finally, in a third set of experiments, we apply our regularization technique to a 3D point-cloud dataset called ShapeNet (Chang et al., 2015). We adapt a high-performing auto-encoding method called FoldingNet (Yang et al., 2018) to its vae counterpart and apply the method we described in this paper to that vae variant on the ShapeNet dataset. We found that adding consistency regularization yields better learned representations. ",
+        "bbox": [
+            174,
+            806,
+            825,
+            876
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "We next describe in great detail the set up for each of these experiments and the results showcasing the usefulness of the regularization method we propose in this paper. ",
+        "bbox": [
+            173,
+            883,
+            821,
+            911
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "table",
+        "img_path": "images/ca2e472d072fc4f4263a91a933a1bbd1bd818c34ad3086fbc683078ed7560075.jpg",
+        "table_caption": [
+            "Table 2: cr-vaes learn representations that yield higher accuracy on downstream classification than their base vaes. These results correspond to the accuracy from a linear classifier that was fitted on the training. We fed this classifier with the representations learned by each method. On both mnist and cifar-10, cr-vaes yield higher accuracy. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Method</td><td>MNIST</td><td>CIFAR-10</td></tr><tr><td>VAE</td><td>98.5</td><td>32.6</td></tr><tr><td>VAE+Aug</td><td>98.9</td><td>40.1</td></tr><tr><td>CR-VAE</td><td>99.4</td><td>44.7</td></tr><tr><td>IWAE</td><td>98.6</td><td>35.8</td></tr><tr><td>IWAE+Aug</td><td>99.9</td><td>37.1</td></tr><tr><td>CR-IWAE</td><td>99.9</td><td>44.8</td></tr><tr><td>β- VAE (0.5)</td><td>97.6</td><td>27.0</td></tr><tr><td>β- VAE (0.5)+Aug</td><td>98.7</td><td>27.6</td></tr><tr><td>β- CR-VAE (0.5)</td><td>98.9</td><td>30.0</td></tr><tr><td>β- VAE (10)</td><td>99.4</td><td>36.5</td></tr><tr><td>β- VAE (10)+Aug</td><td>99.6</td><td>42.1</td></tr><tr><td>β- CR-VAE (10)</td><td>99.6</td><td>46.1</td></tr></table>",
+        "bbox": [
+            352,
+            164,
+            640,
+            381
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "table",
+        "img_path": "images/8b9b3f68fca58fe2e42e1a8482298efe7f6b2f24634f547d5b7a3e397bf38b80.jpg",
+        "table_caption": [
+            "Table 3: cr-vaes generalize better than their base vaes on almost all cases; they achieve lower negative log-likelihoods. Although training the base vaes with the augmented data improves generalization, adding the consistency regularization term further improves generalization performance. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Method</td><td>MNIST</td><td>OMNIGLOT</td><td>CELEBA</td></tr><tr><td>VAE</td><td>83.7 ± 0.3</td><td>128.2± 0.8</td><td>66.1±0.2</td></tr><tr><td>VAE + Aug</td><td>82.8 ±0.4</td><td>125.7 ± 0.2</td><td>66.0± 0.2</td></tr><tr><td>CR-VAE</td><td>81.2 ± 0.2</td><td>124.1 ± 0.1</td><td>65.9 ± 0.2</td></tr><tr><td>IWAE</td><td>81.7± 0.3</td><td>127.5 ± 0.5</td><td>65.3 ± 0.1</td></tr><tr><td>IWAE+Aug</td><td>80.4± 0.2</td><td>125.0 ± 0.6</td><td>65.3 ± 0.1</td></tr><tr><td>CR-IWAE</td><td>79.7 ± 0.3</td><td>123.6 ± 0.5</td><td>65.0 ± 0.2</td></tr><tr><td>β-VAE (0.5)</td><td>92.6±0.3</td><td>137.1 ± 0.2</td><td>68.7±0.2</td></tr><tr><td>β-VAE (0.5) + Aug</td><td>90.0 ± 0.5</td><td>134.6 ± 0.5</td><td>68.8 ± 0.2</td></tr><tr><td>β-CR-VAE (0.5)</td><td>85.7 ± 0.6</td><td>132.5 ± 0.3</td><td>68.2 ± 0.1</td></tr><tr><td>β-VAE (10)</td><td>126.1 ± 1.8</td><td>157.5 ± 1.1</td><td>92.7± 0.5</td></tr><tr><td>β-VAE (10) + Aug</td><td>127.1 ± 1.0</td><td>157.3 ± 0.5</td><td>92.7 ± 0.3</td></tr><tr><td>β-CR-VAE (10)</td><td>126.2 ± 0.5</td><td>157.6 ± 0.6</td><td>92.6 ± 0.1</td></tr></table>",
+        "bbox": [
+            282,
+            457,
+            715,
+            641
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "4.1 Application to standard vaes on benchmark datasets ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            667,
+            584,
+            683
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "We apply consistency regularization, as described in this paper, to the original vae, the iwae, and the $\\beta$ -vae. We now describe the set up and results for this experiment. ",
+        "bbox": [
+            174,
+            686,
+            823,
+            715
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Datasets. We study three benchmark datasets that we briefly describe below. We first consider mnist. mnist is a handwritten digit recognition dataset with 60, 000 images in the training set and 10, 000 images in the test set (LeCun, 1998). We form a validation set of 10, 000 images randomly sampled from the training set. ",
+        "bbox": [
+            173,
+            722,
+            825,
+            779
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "We also consider omniglot, a handwritten alphabet recognition dataset (Lake et al., 2011). This dataset is composed of 19, 280 images. We use 16, 280 randomly sampled images for training and 1, 000 for validation and the remaining 2, 000 samples for testing. ",
+        "bbox": [
+            174,
+            785,
+            825,
+            827
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Finally we consider celeba. It is a dataset of faces, consisting of 162, 770 images for training, 19, 867 images for validation, and 19, 962 images for testing (Liu et al., 2018). We set the resolution to $3 2 \\mathrm { x 3 2 }$ for this experiment. ",
+        "bbox": [
+            174,
+            834,
+            825,
+            876
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Transformations $t ( \\tilde { \\mathbf { x } } | \\mathbf { x } )$ . We consider three transformations variants for image data $t ( \\tilde { \\mathbf { x } } | \\mathbf { x } )$ . The first randomly translates an image $[ - 2 , 2 ]$ pixels in any direction. The second transformation randomly rotates an image uniformly in $[ - 1 5 , 1 5 ]$ degrees clockwise. Finally the third transformation randomly scales an image by a factor uniformly sampled from [0.9, 1.1]. ",
+        "bbox": [
+            173,
+            882,
+            821,
+            912
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "table",
+        "img_path": "images/9049cac26096d5e7579e063d4751364e984a103026cb53014919ca12ce878707.jpg",
+        "table_caption": [
+            "Table 4: The regularization term $\\lambda$ affects both generalization performance and the quality of the learned representations. Many values of $\\lambda$ perform better than the base vae. However a large enough value of $\\lambda$ , e.g. $\\lambda = 1$ , can lead to worse performance than the base vae because for large values of $\\lambda$ the regularization term takes over the data-term in the objective function. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td></td><td>入</td><td>MI</td><td>AU</td><td>NLL</td></tr><tr><td>VAE</td><td>11</td><td>124.5</td><td>36</td><td>83.7</td></tr><tr><td>CR-VAE</td><td>0.001</td><td>125.0</td><td>38</td><td>83.5</td></tr><tr><td>CR-VAE</td><td>0.01</td><td>125.9</td><td>41</td><td>82.4</td></tr><tr><td>CR-VAE</td><td>0.1</td><td>126.3</td><td>47</td><td>81.2</td></tr><tr><td>CR-VAE</td><td>1</td><td>124.3</td><td>47</td><td>83.9</td></tr></table>",
+        "bbox": [
+            354,
+            165,
+            640,
+            265
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "table",
+        "img_path": "images/ac39e3c789e3adf899bf3dc4d7aa0cb25c62b933db2b17bafbd2bb47123459fc.jpg",
+        "table_caption": [
+            "Table 5: The choice of augmentation affects both generalization performance and the quality of the learned representations. Jointly using all augmentations works best. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Augmentation</td><td>MI</td><td>AU</td><td>NLL</td></tr><tr><td>Rotations only</td><td>125.8</td><td>45</td><td>82.1</td></tr><tr><td>Translations only</td><td>126.1</td><td>45</td><td>81.9</td></tr><tr><td>Scaling only</td><td>125.1</td><td>42</td><td>82.7</td></tr><tr><td>All</td><td>126.3</td><td>47</td><td>81.2</td></tr></table>",
+        "bbox": [
+            351,
+            325,
+            642,
+            412
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            438,
+            823,
+            467
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Evaluation metrics. The regularization method we propose in this paper is mainly aimed at improving the learned representations of vaes. To assess these representations we use three metrics: mutual information, number of active latent units, and accuracy on a downstream classification task. We also evaluate the effect of the proposed method on generalization to unseen data. For that we also report negative log-likelihood. We define each of these metrics next. ",
+        "bbox": [
+            173,
+            472,
+            825,
+            541
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Mutual information $( M I )$ . The first quality metric is the mutual information $I ( \\mathbf { z } ; \\mathbf { x } )$ between the observations and the latents under the joint distribution induced by the encoder, ",
+        "bbox": [
+            173,
+            547,
+            823,
+            577
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "equation",
+        "img_path": "images/20429e2704dad1c0dc1720cb8df1c75463dee281517f045ffd9fcd6d220eec7b.jpg",
+        "text": "$$\nI ( \\mathbf { z } ; \\mathbf { x } ) = \\mathbb { E } _ { p _ { d } ( \\mathbf { x } ) } \\left[ K L ( q _ { \\phi } ( \\mathbf { z } | \\mathbf { x } ) | | p ( \\mathbf { z } ) ) - \\kappa \\mathbf { L } ( q _ { \\phi } ( \\mathbf { z } ) | | p ( \\mathbf { z } ) ) \\right]\n$$",
+        "text_format": "latex",
+        "bbox": [
+            307,
+            583,
+            691,
+            602
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "where $p _ { d } ( \\mathbf { x } )$ is the empirical data distribution and $q _ { \\phi } ( \\mathbf { z } )$ is the aggregated posterior, the marginal over $\\mathbf { z }$ induced by the joint distribution defined by $p _ { d } ( \\mathbf { x } )$ and $q _ { \\phi } ( { \\bf z } | { \\bf x } )$ . The mutual information is intractable but we can approximate it with Monte Carlo. Higher mutual information corresponds to more interpretable latent variables. ",
+        "bbox": [
+            173,
+            608,
+            825,
+            664
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Number of active latent units $( A U )$ . The second quality metrics we consider is the number of active latent units (AU). It is defined in Burda et al. (2015) and measures the “activity\" of a dimension of the latent variables $\\mathbf { z }$ . A latent dimension is “active\" if ",
+        "bbox": [
+            173,
+            670,
+            825,
+            712
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "equation",
+        "img_path": "images/807f0b6a2f18d592a13c2f76527dd67d65704ecf0bc4f5ce156fe8502705139e.jpg",
+        "text": "$$\nC o v _ { \\mathbf { x } } ( \\mathbb { E } _ { \\mathbf { u } \\sim q _ { \\phi } ( \\mathbf { u } | \\mathbf { x } ) } ) > \\delta\n$$",
+        "text_format": "latex",
+        "bbox": [
+            421,
+            719,
+            578,
+            738
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "where $\\delta$ is a threshold defined by the user. For our experiments we set $\\delta = 0 . 0 1$ . The higher the number of latent active units, the better the learned representations. ",
+        "bbox": [
+            171,
+            743,
+            825,
+            772
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Accuracy on downstream classification. This metric is calculated by fitting a given vae, taking the learned representations for each data in the test set and computing the accuracy from the prediction of the labels of the images in that same test set by a classifier fitted on the training set. This metric is only applicable to labelled datasets. ",
+        "bbox": [
+            173,
+            777,
+            825,
+            833
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Negative log-likelihood. We use negative held-out log-likelihood to assess generalization. Consider an unseen data $\\mathbf { x } ^ { * }$ , its negative held-out log-likelihood under the fitted model is ",
+        "bbox": [
+            173,
+            839,
+            823,
+            868
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "equation",
+        "img_path": "images/49142c6f3e517ea78a7cf6503ab86315a9fab4eae97e9da18bb18134b4423853.jpg",
+        "text": "$$\n\\log p _ { \\boldsymbol \\theta } ( \\mathbf { x } ^ { * } ) = - \\log \\left( \\mathbb { E } _ { q _ { \\boldsymbol \\phi } ( \\mathbf { z } | \\mathbf { x } ^ { * } ) } \\left[ \\frac { p _ { \\boldsymbol \\theta } ( \\mathbf { x } ^ { * } , \\mathbf { z } ) } { q _ { \\boldsymbol \\phi } ( \\mathbf { z } | \\mathbf { x } ^ { * } ) } \\right] \\right) .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            343,
+            875,
+            653,
+            910
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "table",
+        "img_path": "images/4b2324520025efa58830e21a6115ffa750dd98795319a96faee2d2d6ca2a0112.jpg",
+        "table_caption": [
+            "Table 6: The cr-vae outperforms a popular and advanced contrastive learning technique called triplet loss on both generalization performance and quality of learned representations. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Method</td><td>MI</td><td>AU</td><td>NLL</td></tr><tr><td>VAE</td><td>124.5</td><td>36</td><td>83.7</td></tr><tr><td>VAE + augmentations</td><td>125.9</td><td>42</td><td>82.8</td></tr><tr><td>VAE + triplet loss</td><td>124.9</td><td>39</td><td>83.1</td></tr><tr><td>CR-VAE</td><td>126.3</td><td>47</td><td>81.2</td></tr></table>",
+        "bbox": [
+            336,
+            137,
+            655,
+            223
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "This is intractable and we approximate it using Monte Carlo, ",
+        "bbox": [
+            173,
+            247,
+            570,
+            262
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "equation",
+        "img_path": "images/7dda144bd40410a81a940ae50d5e67f85669cc267a11ca25ba90d8da35a5eb88.jpg",
+        "text": "$$\n\\log p _ { \\theta } ( \\mathbf { x } ^ { * } ) \\approx - \\log \\frac { 1 } { S } \\sum _ { s = 1 } ^ { S } \\frac { p _ { \\theta } ( \\mathbf { x } ^ { * } , \\mathbf { z } ^ { ( s ) } ) } { q _ { \\phi } ( \\mathbf { z } ^ { ( s ) } | \\mathbf { x } ^ { * } ) }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            367,
+            267,
+            629,
+            310
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "where $\\mathbf { z } ^ { ( 1 ) } , \\ldots , \\mathbf { z } ^ { ( S ) } \\sim q _ { \\phi } ( \\mathbf { z } | \\mathbf { x } ^ { * } )$ ",
+        "bbox": [
+            174,
+            315,
+            393,
+            333
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Settings. The vaes are built on the same architecture as Tolstikhin et al. (2017). The networks are trained with the Adam optimizer with a learning rate of $1 0 ^ { - 4 }$ (Kingma & Ba, 2014) and trained for 100 epochs with a batch size of 64. We set the dimensionality of the latent variables to 50, therefore the maximum number of active latent units in the latent space is 50. We found $\\lambda = 0 . 1$ to be best according to cross-validation using held-out log-likelihood and exploring the range $[ 1 e ^ { - 4 } , 1 . 0 ]$ datasets. In an ablation study we explore $\\lambda = 0$ . For the $\\beta$ -vae we set $\\lambda = 0 . 1 \\cdot \\beta$ and study both $\\beta = 0 . 1$ and $\\beta = 1 0$ , two regimes under which the $\\beta$ -vae performs qualitatively very differently (Higgins et al., 2017). All experiments were done on a GPU cluster consisting of Nvidia P100 and RTX. The training took approximately 1 day for most experiments. ",
+        "bbox": [
+            173,
+            338,
+            825,
+            463
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Results. Table 1 shows that on all the three benchmark datasets all the different vae variants we studied, consistency regularization as developed in this paper always improves the quality of the learned representations as measured by mutual information and the number of active latent units. These results are confirmed by the numbers shown in Table 2 where cr-vaes always lead to better accuracy on downstream classification. ",
+        "bbox": [
+            174,
+            469,
+            825,
+            539
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "We proposed consistency regularization as a way to improve the quality of the learned representations. Incidentally, Table 3 also shows that it can improve generalization as measured by negative loglikelihood. ",
+        "bbox": [
+            174,
+            545,
+            825,
+            587
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Ablation Study. We now look at the impact of each factor that goes into the regularization method we introduced in this paper using mnist. We test the impact of the regularization term $\\lambda$ and the impact of the choice of augmentation on all metrics. Table 4 and Table 5 show the results. ",
+        "bbox": [
+            176,
+            593,
+            823,
+            635
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Table 4 shows that even small consistency regularization (a small $\\lambda$ value) results in improvement over the base vae but that a large enough $\\lambda$ value can hurt performance. ",
+        "bbox": [
+            173,
+            641,
+            823,
+            670
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Table 5 shows that rotations and translations are more important than scaling, but the combination of all three augmentations works best for cr-vaes. ",
+        "bbox": [
+            171,
+            676,
+            823,
+            704
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Comparison to Contrastive Learning. We look at how cr-vaes compare against a popular and advanced contrastive-learning-based technique, the triplet loss (Schroff et al., 2015) using mnist. Table 6 shows that the cr-vae outperforms the triplet loss on both generalization performance and quality of learned representations. Table 6 also confirms existing literature showing simply applying augmentations can outperform complex contrastive learning-based methods such as the triplet loss (Kostrikov et al., 2020; Sinha & Garg, 2021). ",
+        "bbox": [
+            174,
+            709,
+            825,
+            794
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "4.2 Application to the large-scale nvae on benchmark datasets ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            803,
+            622,
+            818
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Along with standard VAE variants, we also experiment with a large scale state-of-the-art vae, the nvae(Vahdat & Kautz, 2020). Similar to before, we simply add consistency regularization using the image-based augmentations techniques to the NVAE model and experiment on benchmark datasets: mnist (LeCun, 1998), cifar-10 (Krizhevsky et al., 2009) and celeba (Liu et al., 2018). ",
+        "bbox": [
+            174,
+            821,
+            825,
+            877
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "The results for large scale generative modeling are tabulated in Table 8 and Table 7, where we see that using cr-nvae we are able to learn representations that yield better accuracy on downstream classification and set new state-of-the-art values on each of the datasets, improving upon the baseline log-likelihood values. This shows the ability of consistency regularization to work at scale on challenging generative modeling tasks. ",
+        "bbox": [
+            174,
+            883,
+            820,
+            911
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "table",
+        "img_path": "images/0f2716d399a4da7efa579f44270d8b63f236485b38e4adc90d9c678c3b3a2ee1.jpg",
+        "table_caption": [
+            "Table 7: The cr-nvaes learns better representations than the base nvae as measured by accuracy on a downstream classification on both mnist and cifar-10. We get to this same conclusion when looking at the number of active units as an indicator for the quality of the learned latent representations; cr-nvae recovers 226 units whereas nvae recovers 211 units. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Method</td><td>MNIST</td><td>CIFAR-10</td></tr><tr><td>NVAE</td><td>99.9</td><td>57.9</td></tr><tr><td>NVAE+Aug</td><td>99.9</td><td>66.4</td></tr><tr><td>CR-NVAE</td><td>99.9</td><td>71.4</td></tr></table>",
+        "bbox": [
+            375,
+            165,
+            617,
+            237
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "table",
+        "img_path": "images/6a278a274b29255ea80874edce5c640ac9b6abc9a186c108a470f5a2d42a756f.jpg",
+        "table_caption": [
+            "Table 8: Large-scale experiments with nvaes with and without consistency-regularization on 3 benchmark datasets: dynamically binarized mnist, cifar-10 and celeba. We report generalization using negative log-likelihood on mnist and bits per dim on cifar-10 and celeba. On all datasets consistency regularization improves generalization performance. In particular cr-nvae achieves state-of-the-art performance on mnist and cifar-10. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td></td><td>MNIST (28 × 28)</td><td>CIFAR-10 (32 × 32)</td><td>CELEBA (64 × 64)</td></tr><tr><td>NVAE</td><td>78.19</td><td>2.91</td><td>2.03</td></tr><tr><td>NVAE+Aug</td><td>77.53</td><td>2.70</td><td>1.96</td></tr><tr><td>CR-NVAE</td><td>76.93</td><td>2.51</td><td>1.86</td></tr></table>",
+        "bbox": [
+            236,
+            342,
+            754,
+            415
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "image",
+        "img_path": "images/013be7f0e1e75e1072aef4213dc3071a40eed8f53d36cb5a52a75b32e6cdd895.jpg",
+        "image_caption": [
+            "Figure 2: Interpolation between two samples of a lamp, airplane and table using a trained CRFoldingNet trained on the ShapeNet dataset. The CR-FoldingNet is able to learn an interpretable latent space. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            197,
+            441,
+            794,
+            696
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            781,
+            825,
+            823
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "4.3 Application to the FoldingNet on 3D point-cloud data ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            835,
+            583,
+            851
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Along with working with image data, we additionally experiment with 3D point cloud data using a FoldingNet Yang et al. (2018) and the ShapeNet dataset Chang et al. (2015) which consists of 55 distinct object classes. FoldingNet learns a deep AutoEncoder to learn unsupervised representations from the point cloud data. To add consistency regularization, we first substitute the AutoEncoder to a vae by adding the KL term from the ELBO to the baseline FoldingNet. We then add the additional consistency regularization KL term to the latent space of FoldingNet. ",
+        "bbox": [
+            174,
+            856,
+            825,
+            911
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "table",
+        "img_path": "images/3415f282ed82b433ed836f811f5ab0ae836d4bcb25e77dd339ab61af4daf5a9e.jpg",
+        "table_caption": [
+            "Table 9: The FoldingNet yields higher accuracy when paired with consistency regularization on the ShapeNet dataset. The results shown here correspond to a FoldingNet that was trained with augmented data, the same used to apply consistency regularization. As can be seen from these results, enforcing consistency through KL as we do in this paper leads to representations that perform well on a downstream classification. Here the classifier used is a linear SVM. We also report mean reconstruction error through Chamfer distance where the same conclusion holds. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Method</td><td>Accuracy</td><td>Reconstruction Loss</td></tr><tr><td>Folding Net (Aug)</td><td>82.5%</td><td>0.0355</td></tr><tr><td>CR-Folding Net</td><td>84.6%</td><td>0.0327</td></tr></table>",
+        "bbox": [
+            307,
+            193,
+            684,
+            251
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            171,
+            281,
+            823,
+            309
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "For the ShapeNet point cloud data, we perform data augmentation using a similar scheme to what we did for the previous experiments, we randomly translate, rotate and add jitter to the $( x , y , z )$ coordinates of the point cloud data. We follow the same scheme detailed in FoldingNet (Yang et al., 2018). ",
+        "bbox": [
+            174,
+            320,
+            825,
+            376
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "We train both the FoldingNet turned in a vae and the CR-FoldingNet with these augmentations. To train CR-FoldingNet, we additionally apply the consistency regularization term as proposed in Equation 3. The results on the validation set for reconstruction (as measured by Chamfer distance) and accuracy are shown in Table 9. ",
+        "bbox": [
+            174,
+            387,
+            825,
+            443
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "We also visualize the point clouds reconstructions and interpolations between 3 different object classes using a CR-FoldingNet in Figure 2. We perform 4 interpolation steps for each of the objects, to highlight the interpretable learned latent space. Additionally, we perform the same interpolation on the baseline FoldingNet model. We show these interpolations in the appendix. ",
+        "bbox": [
+            174,
+            455,
+            825,
+            510
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "5 Conclusion ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            529,
+            299,
+            545
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "We proposed a simple regularization technique to constrain encoders of vaes to learn similar latent representations for an image and a semantics-preserving transformation of the image. The idea consists in maximizing the likelihood of the pair of images while minimizing the kl divergence between the variational distribution induced by the encoder when conditioning on the image on one hand, and its transformation, on the other hand. We applied this technique to several vae variants on several datasets, including a 3D dataset. We found it always leads to better learned representations and also better generalization to unseen data. In particular, when applied to the nvae, the regularization technique we developed in this paper yields state-of-the-art results on mnist and cifar-10. ",
+        "bbox": [
+            174,
+            556,
+            825,
+            667
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Broader Impact ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            685,
+            310,
+            702
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "In this paper, we propose a simple method that performs a KL-based consistency regularization scheme using data augmentation for vaes. The broader impact of the study includes practical applications such as graphics and computer vision applications. The method we propose improves the learned representations of vaes, and as an artifact, also improves their generalization to unseen data. In this regard, any implications of vaes also apply to this work. For example, the generative model fit by a vae may be used to generate artificial data such as images, text, and 3D objects. Biases may arise as a result of poor data selection. Furthermore, text generated from generative systems may amplify harmful speech contained in the data. However, the method we propose can also improve the performance of vaes when used in certain practical domains as we discussed in the introduction of the paper. ",
+        "bbox": [
+            174,
+            712,
+            825,
+            852
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "6 Acknowledgements ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            869,
+            364,
+            886
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "We thank Kevin Murphy, Ben Poole, and Augustus Odena for their comments on this work. ",
+        "bbox": [
+            169,
+            897,
+            769,
+            911
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "References ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            90,
+            266,
+            106
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Achille, A., Eccles, T., Matthey, L., Burgess, C. P., Watters, N., Lerchner, A., and Higgins, I. Life-long disentangled representation learning with cross-domain latent homologies. arXiv preprint arXiv:1808.06508, 2018.   \nAn, J. and Cho, S. Variational autoencoder based anomaly detection using reconstruction probability. Special Lecture on IE, 2(1), 2015.   \nBachman, P., Alsharif, O., and Precup, D. Learning with pseudo-ensembles. In Advances in neural information processing systems, pp. 3365–3373, 2014.   \nBowman, S. R., Vilnis, L., Vinyals, O., Dai, A. M., Jozefowicz, R., and Bengio, S. Generating sentences from a continuous space. arXiv preprint arXiv:1511.06349, 2015.   \nBurda, Y., Grosse, R., and Salakhutdinov, R. Importance weighted autoencoders. arXiv preprint arXiv:1509.00519, 2015.   \nChang, A. X., Funkhouser, T., Guibas, L., Hanrahan, P., Huang, Q., Li, Z., Savarese, S., Savva, M., Song, S., Su, H., et al. Shapenet: An information-rich 3d model repository. arXiv preprint arXiv:1512.03012, 2015.   \nDieng, A. B., Kim, Y., Rush, A. M., and Blei, D. M. Avoiding latent variable collapse with generative skip models. arXiv preprint arXiv:1807.04863, 2018.   \nDieng, A. B., Ruiz, F. J., and Blei, D. M. Topic modeling in embedding spaces. arXiv preprint arXiv:1907.04907, 2019.   \nFang, L., Li, C., Gao, J., Dong, W., and Chen, C. Implicit deep latent variable models for text generation. arXiv preprint arXiv:1908.11527, 2019.   \nFu, H., Li, C., Liu, X., Gao, J., Celikyilmaz, A., and Carin, L. Cyclical annealing schedule: A simple approach to mitigating kl vanishing. arXiv preprint arXiv:1903.10145, 2019.   \nGoodfellow, I., Pouget-Abadie, J., Mirza, M., Xu, B., Warde-Farley, D., Ozair, S., Courville, A., and Bengio, Y. Generative adversarial nets. In Advances in neural information processing systems, pp. 2672–2680, 2014.   \nGregor, K., Danihelka, I., Graves, A., Rezende, D. J., and Wierstra, D. Draw: A recurrent neural network for image generation. arXiv preprint arXiv:1502.04623, 2015.   \nHadjeres, G., Nielsen, F., and Pachet, F. Glsr-vae: Geodesic latent space regularization for variational autoencoder architectures. In 2017 IEEE Symposium Series on Computational Intelligence (SSCI), pp. 1–7. IEEE, 2017.   \nHe, J., Spokoyny, D., Neubig, G., and Berg-Kirkpatrick, T. Lagging inference networks and posterior collapse in variational autoencoders. arXiv preprint arXiv:1901.05534, 2019.   \nHiggins, I., Matthey, L., Pal, A., Burgess, C., Glorot, X., Botvinick, M., Mohamed, S., and Lerchner, A. beta-vae: Learning basic visual concepts with a constrained variational framework. Iclr, 2(5):6, 2017.   \nJun, H., Child, R., Chen, M., Schulman, J., Ramesh, A., Radford, A., and Sutskever, I. Distribution augmentation for generative modeling. In International Conference on Machine Learning, pp. 5006–5019. PMLR, 2020.   \nKim, Y., Wiseman, S., Miller, A. C., Sontag, D., and Rush, A. M. Semi-amortized variational autoencoders. arXiv preprint arXiv:1802.02550, 2018.   \nKingma, D. P. and Ba, J. Adam: A method for stochastic optimization. arXiv preprint arXiv:1412.6980, 2014.   \nKingma, D. P. and Welling, M. Auto-encoding variational bayes. arXiv preprint arXiv:1312.6114, 2013.   \nKingma, D. P., Rezende, D. J., Mohamed, S., and Welling, M. Semi-supervised learning with deep generative models. arXiv preprint arXiv:1406.5298, 2014.   \nKostrikov, I., Yarats, D., and Fergus, R. Image augmentation is all you need: Regularizing deep reinforcement learning from pixels. arXiv preprint arXiv:2004.13649, 2020.   \nKrizhevsky, A., Hinton, G., et al. Learning multiple layers of features from tiny images. 2009.   \nLaine, S. and Aila, T. Temporal ensembling for semi-supervised learning. arXiv preprint arXiv:1610.02242, 2016.   \nLake, B., Salakhutdinov, R., Gross, J., and Tenenbaum, J. One shot learning of simple visual concepts. In Proceedings of the annual meeting of the cognitive science society, volume 33, 2011.   \nLeCun, Y. The mnist database of handwritten digits. http://yann. lecun. com/exdb/mnist/, 1998.   \nLiang, D., Krishnan, R. G., Hoffman, M. D., and Jebara, T. Variational autoencoders for collaborative filtering. In Proceedings of the 2018 World Wide Web Conference, pp. 689–698, 2018.   \nLiu, Z., Luo, P., Wang, X., and Tang, X. Large-scale celebfaces attributes (celeba) dataset. Retrieved August, 15: 2018, 2018.   \nMiao, Y., Yu, L., and Blunsom, P. Neural variational inference for text processing. In International conference on machine learning, pp. 1727–1736, 2016.   \nMiyato, T., Maeda, S.-i., Ishii, S., and Koyama, M. Virtual adversarial training: a regularization method for supervised and semi-supervised learning. IEEE transactions on pattern analysis and machine intelligence, 2018.   \nOsada, G., Ahsan, B., Bora, R. P., and Nishide, T. Regularization with latent space virtual adversarial training. In European Conference on Computer Vision, pp. 565–581. Springer, 2020.   \nRezende, D. J., Mohamed, S., and Wierstra, D. Stochastic backpropagation and approximate inference in deep generative models. arXiv preprint arXiv:1401.4082, 2014.   \nRifai, S., Vincent, P., Muller, X., Glorot, X., and Bengio, Y. Contractive auto-encoders: Explicit invariance during feature extraction. 2011.   \nRoberts, A., Engel, J., Raffel, C., Hawthorne, C., and Eck, D. A hierarchical latent vector model for learning long-term structure in music. arXiv preprint arXiv:1803.05428, 2018.   \nSajjadi, M., Javanmardi, M., and Tasdizen, T. Regularization with stochastic transformations and perturbations for deep semi-supervised learning. In NeurIPS, 2016.   \nSchroff, F., Kalenichenko, D., and Philbin, J. Facenet: A unified embedding for face recognition and clustering. In Proceedings of the IEEE conference on computer vision and pattern recognition, pp. 815–823, 2015.   \nSinha, S. and Garg, A. S4rl: Surprisingly simple self-supervision for offline reinforcement learning. arXiv preprint arXiv:2103.06326, 2021.   \nSinha, S., Ebrahimi, S., and Darrell, T. Variational adversarial active learning. In Proceedings of the IEEE International Conference on Computer Vision, pp. 5972–5981, 2019.   \nTolstikhin, I., Bousquet, O., Gelly, S., and Schoelkopf, B. Wasserstein auto-encoders. arXiv preprint arXiv:1711.01558, 2017.   \nVahdat, A. and Kautz, J. Nvae: A deep hierarchical variational autoencoder. arXiv preprint arXiv:2007.03898, 2020.   \nVincent, P., Larochelle, H., Bengio, Y., and Manzagol, P.-A. Extracting and composing robust features with denoising autoencoders. In Proceedings of the 25th international conference on Machine learning, pp. 1096–1103, 2008.   \nVincent, P., Larochelle, H., Lajoie, I., Bengio, Y., and Manzagol, P.-A. Stacked denoising autoencoders: Learning useful representations in a deep network with a local denoising criterion. Journal of machine learning research, 11(Dec):3371–3408, 2010.   \nWalker, J., Doersch, C., Gupta, A., and Hebert, M. An uncertain future: Forecasting from static images using variational autoencoders. In European Conference on Computer Vision, pp. 835–851. Springer, 2016.   \nWei, X., Gong, B., Liu, Z., Lu, W., and Wang, L. Improving the improved training of wasserstein gans: A consistency term and its dual effect. arXiv preprint arXiv:1803.01541, 2018.   \nXie, Q., Dai, Z., Hovy, E., Luong, M.-T., and Le, Q. V. Unsupervised data augmentation for consistency training. arXiv preprint arXiv:1904.12848, 2019.   \nYang, Y., Feng, C., Shen, Y., and Tian, D. Foldingnet: Point cloud auto-encoder via deep grid deformation. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pp. 206–215, 2018.   \nZhang, H., Zhang, Z., Odena, A., and Lee, H. Consistency regularization for generative adversarial networks. 2020.   \nZimmerer, D., Kohl, S. A., Petersen, J., Isensee, F., and Maier-Hein, K. H. Context-encoding variational autoencoder for unsupervised anomaly detection. arXiv preprint arXiv:1812.05941, 2018. ",
+        "bbox": [
+            171,
+            109,
+            828,
+            914
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            171,
+            60,
+            828,
+            914
+        ],
+        "page_idx": 11
+    }
+]

parse/train/ryghZJBKPS/ryghZJBKPS.md

@@ -0,0 +1,422 @@
+# DEEP BATCH ACTIVE LEARNING BY DIVERSE, UNCERTAIN GRADIENT LOWER BOUNDS
+
+Jordan T. Ash Princeton University
+
+Chicheng Zhang University of Arizona
+
+Akshay Krishnamurthy Microsoft Research NYC
+
+John Langford Microsoft Research NYC
+
+Alekh Agarwal Microsoft Research Redmond
+
+# ABSTRACT
+
+We design a new algorithm for batch active learning with deep neural network models. Our algorithm, Batch Active learning by Diverse Gradient Embeddings (BADGE), samples groups of points that are disparate and high magnitude when represented in a hallucinated gradient space, a strategy designed to incorporate both predictive uncertainty and sample diversity into every selected batch. Crucially, BADGE trades off between uncertainty and diversity without requiring any hand-tuned hyperparameters. While other approaches sometimes succeed for particular batch sizes or architectures, BADGE consistently performs as well or better, making it a useful option for real world active learning problems.
+
+# 1 INTRODUCTION
+
+In recent years, deep neural networks have produced state-of-the-art results on a variety of important supervised learning tasks. However, many of these successes have been limited to domains where large amounts of labeled data are available. A promising approach for minimizing labeling effort is active learning, a learning protocol where labels can be requested by the algorithm in a sequential, feedback-driven fashion. Active learning algorithms aim to identify and label only maximally-informative samples, so that a high-performing classifier can be trained with minimal labeling effort. As such, a robust active learning algorithm for deep neural networks may considerably expand the domains in which these models are applicable.
+
+How should we design a practical, general-purpose, label-efficient active learning algorithm for deep neural networks? Theory for active learning suggests a version-space-based approach (Cohn et al., 1994; Balcan et al., 2006), which explicitly or implicitly maintains a set of plausible models, and queries examples for which these models make different predictions. But when using highly expressive models like neural networks, these algorithms degenerate to querying every example. Further, the computational overhead of training deep neural networks precludes approaches that update the model to best fit data after each label query, as is often done (exactly or approximately) for linear methods (Beygelzimer et al., 2010; Cesa-Bianchi et al., 2009). Unfortunately, the theory provides little guidance for these models.
+
+One option is to use the network’s uncertainty to inform a query strategy, for example by labeling samples for which the model is least confident. In a batch setting, however, this creates a pathological scenario where data in the batch are nearly identical, a clear inefficiency. Remedying this issue, we could select samples to maximize batch diversity, but this might choose points that provide little new information to the model.
+
+For these reasons, methods that exploit just uncertainty or diversity do not consistently work well across model architectures, batch sizes, or datasets. An algorithm that performs well when using a ResNet, for example, might perform poorly when using a multilayer perceptron. A diversity-based approach might work well when the batch size is very large, but poorly when the batch size is small. Further, what even constitutes a “large” or “small” batch size is largely a function of the statistical properties of the data in question. These weaknesses pose a major problem for real, practical batch active learning situations, where data are unfamiliar and potentially unstructured. There is no way to know which active learning algorithm is best to use.
+
+Moreover, in a real active learning scenario, every change of hyperparameters typically causes the algorithm to label examples not chosen under other hyperparameters, provoking substantial labeling inefficiency. That is, hyperparameter sweeps in active learning can be label expensive. As a result, active learning algorithms need to “just work”, given fixed hyperparameters, to a greater extent than is typical for supervised learning.
+
+Based on these observations, we design an approach which creates diverse batches of examples about which the current model is uncertain. We measure uncertainty as the gradient magnitude with respect to parameters in the final (output) layer, which is computed using the most likely label according to the model. To capture diversity, we collect a batch of examples where these gradients span a diverse set of directions. More specifically, we build up the batch of query points based on these hallucinated gradients using the $k { \mathrm { - M E A N S + + } }$ initialization (Arthur and Vassilvitskii, 2007), which simultaneously captures both the magnitude of a candidate gradient and its distance from previously included points in the batch. We name the resulting approach Batch Active learning by Diverse Gradient Embeddings (BADGE).
+
+We show that BADGE is robust to architecture choice, batch size, and dataset, generally performing as well as or better than the best baseline across our experiments, which vary all of the aforementioned environmental conditions. We begin by introducing our notation and setting, followed by a description of the BADGE algorithm in Section 3 and experiments in Section 4. We defer our discussion of related work to Section 5.
+
+# 2 NOTATION AND SETTING
+
+Define $[ K ] : = \{ 1 , 2 , \dots , K \}$ . Denote by $\mathcal { X }$ the instance space and by $\mathcal { V }$ the label space. In this work we consider multiclass classification, so $\mathcal { V } = [ K ]$ . Denote by $D$ the distribution from which examples are drawn, by $D _ { \mathcal { X } }$ the unlabeled data distribution, and by $D _ { \mathcal { V } | \mathcal { X } }$ the conditional distribution over labels given examples. We consider the pool-based active learning setup, where the learner receives an unlabeled dataset $U$ sampled according to $D _ { \mathcal { X } }$ and can request labels sampled according to $D _ { \mathcal { Y } | \mathcal { X } }$ for any $x \in$ $U$ . We use $\mathbb { E } _ { D }$ to denote expectation under the data distribution $D$ . Given a classifier $h \ : \ \mathcal { X }  \ \mathcal { Y }$ , which maps examples to labels, and a labeled example $( x , y )$ , we denote the $0 / 1$ error of $h$ on $( x , y )$ as $\ell _ { 0 1 } ( h ( x ) , \bar { y } ) = I ( \bar { h } ( x ) \neq y )$ . The performance of a classifier $h$ is measured by its expected $0 / 1$ error, i.e. $\begin{array} { r } { \mathbb { E } _ { D } [ \ell _ { 0 1 } ( h ( x ) , y ) ] = \operatorname* { P r } _ { ( x , y ) \sim D } ( h ( x ) \neq y ) } \end{array}$ . The goal of pool-based active learning is to find a classifier with a small expected $0 / 1$ error using as few label queries as possible. Given a set $S$ of labeled examples $( x , y )$ , where each $x \in S$ is picked from $U$ , followed by a label query, we use $\mathbb { E } _ { S }$ as the sample averages over $S$ .
+
+In this paper, we consider classifiers $h$ parameterized by underlying neural networks $f$ of fixed architecture, with the weights in the network denoted by $\theta$ . We abbreviate the classifier with parameters $\theta$ as $h _ { \theta }$ since the architectures are fixed in any given context, and our classifiers take the form $h _ { \theta } ( x ) = \operatorname { a r g m a x } _ { y \in [ K ] } f ( x ; \theta ) _ { y }$ , where $f ( x ; \theta ) \in \mathbb { R } ^ { K }$ is a probability vector of scores assigned to candidate labels, given the example $x$ and parameters $\theta$ . We optimize the parameters by minimizing the cross-entropy loss $\mathbb { E } _ { S } [ \ell _ { \mathrm { C E } } ( f ( x ; \theta ) , y ) ]$ over the labeled examples, where $\begin{array} { r } { \ell _ { \mathrm { C E } } ( p , y ) = \sum _ { i = 1 } ^ { K } I ( y = i ) \ln 1 / p _ { i } = \ln { 1 / p _ { y } } } \end{array}$ .
+
+Algorithm 1 BADGE: Batch Active learning by Diverse Gradient Embeddings
+
+Require: Neural network $f ( x ; \theta )$ , unlabeled pool of examples $U$ , initial number of examples $M$ , number of iterations $T$ , number of examples in a batch $B$ .
+
+1: Labeled dataset $S \gets M$ examples drawn uniformly at random from $U$ together with queried labels.
+
+Train an initial model $\theta _ { 1 }$ on $S$ by minimizing $\mathbb { E } _ { S } [ \dot { \ell _ { \mathrm { C E } } } ( f ( x ; \theta ) , y ) ]$ .
+
+4: For all examples $x$ in $U \backslash S$
+
+1. Compute its hypothetical label $\hat { y } ( x ) = h _ { \theta _ { t } } ( x )$ .   
+2. Compute gradient embedding $\begin{array} { r } { g _ { x } = \frac { \partial } { \partial \theta _ { \mathrm { o u t } } } \ell _ { \mathrm { C E } } ( f ( x ; \theta ) , \hat { y } ( x ) ) | _ { \theta = \theta _ { t } } } \end{array}$ , where $\theta _ { \mathrm { o u t } }$ refers to parameters of the final (output) layer.   
+5: Compute $S _ { t }$ , a random subset of $U \backslash S$ , using the $k { \mathrm { - M E A N S + + } }$ seeding algorithm on $\{ g _ { x } : x \in U \setminus S \}$ and query for their labels.   
+6: $S \gets S \cup S _ { t }$ .   
+7: Train a model $\theta _ { t + 1 }$ on $S$ by minimizing $\mathbb { E } _ { S } [ \ell _ { \mathrm { C E } } ( f ( x ; \theta ) , y ) ]$ .
+
+8: end for   
+9: return Final model $\theta _ { T + 1 }$
+
+# 3 ALGORITHM
+
+BADGE, described in Algorithm 1, starts by drawing an initial set of $M$ examples uniformly at random from $U$ and asking for their labels. It then proceeds iteratively, performing two main computations at each step $t$ : a gradient embedding computation and a sampling computation. Specifically, at each step $t$ , for every $x$ in the pool $U$ , we compute the label ${ \hat { y } } ( x )$ preferred by the current model, and the gradient $g _ { x }$ of the loss on $( x , { \hat { y } } ( x ) )$ with respect to the parameters of the last layer of the network. Given these gradient embedding vectors $\{ g _ { x } : x \in U \}$ , BADGE selects a set of points by sampling via the $k$ -MEAN ${ \hphantom { 0 } } _ { \mathrm { S } + + }$ initialization scheme (Arthur and Vassilvitskii, 2007). The algorithm queries the labels of these examples, retrains the model, and repeats.
+
+We now describe the main computations — the embedding and sampling steps — in more detail.
+
+The gradient embedding. Since deep neural networks are optimized using gradient-based methods, we capture uncertainty about an example through the lens of gradients. In particular, we consider the model uncertain about an example if knowing the label induces a large gradient of the loss with respect to the model parameters and hence a large update to the model. A difficulty with this reasoning is that we need to know the label to compute the gradient. As a proxy, we compute the gradient as if the model’s current prediction on the example is the true label. We show in Proposition 1 that, assuming a common structure satisfied by most natural neural networks, the gradient norm with respect to the last layer using this label provides a lower bound on the gradient norm induced by any other label. In addition, under that assumption, the length of this hypothetical gradient vector captures the uncertainty of the model on the example: if the model is highly certain about the example’s label, then the example’s gradient embedding will have a small norm, and vice versa for samples where the model is uncertain (see example below). Thus, the gradient embedding conveys information both about the model’s uncertainty and potential update direction upon receiving a label at an example.
+
+The sampling step. We want the newly-acquired labeled samples to induce large and diverse changes to the model. To this end, we want the selection procedure to favor both sample magnitude and batch diversity. Specifically, we want to avoid the pathology of, for example, selecting a batch of $k$ similar samples where even just a single label could alleviate our uncertainty on all remaining $\left( k - 1 \right)$ samples.
+
+A natural way of making this selection without introducing additional hyperparameters is to sample from a $k$ -Determinantal Point Process ( $k$ -DPP; (Kulesza and Taskar, 2011)). That is, to select a batch of $k$ points with probability proportional to the determinant of their Gram matrix. Recently, Derezinski and Warmuth´ (2018) showed that in experimental design for least square linear regression settings, learning from samples drawn from a $k$ -DPP can have much smaller mean square prediction error than learning from iid samples. In this process, when the batch size is very low, the selection will naturally favor points with a large length, which corresponds to uncertainty in our space. When the batch size is large, the sampler focuses more on diversity because linear independence, which is more difficult to achieve for large $k$ , is required to make the Gram determinant non-zero.
+
+![](images/3fe9bade8f08ff05364a6d8e2a7baee936a987903dffc50b0cac6374c5710223.jpg)  
+Figure 1: Left and center: Learning curves for $k { \mathrm { - M E A N S + + } }$ and $k$ -DPP sampling with gradient embeddings for different scenarios. The performance of the two sampling approaches nearly perfectly overlaps. Right: A run time comparison (seconds) corresponding to the middle scenario. Each line is the average over five independent experiments. Standard errors are shown by shaded regions.
+
+Unfortunately, sampling from a $k$ -DPP is not trivial. Many sampling algorithms (Kang, 2013; Anari et al., 2016) rely on MCMC, where mixing time poses a significant computational hurdle. The state-of-the-art algorithm of Derezinski (2018) has a high-order polynomial running time in the batch size and the embedding ´ dimension. To overcome this computational hurdle, we suggest instead sampling using the $k { \mathrm { - M E A N S + + } }$ seeding algorithm (Arthur and Vassilvitskii, 2007), originally made to produce a good initialization for $k$ -means clustering. $k { \mathrm { - M E A N S + + } }$ seeding selects centroids by iteratively sampling points in proportion to their squared distances from the nearest centroid that has already been chosen, which, like a $k$ -DPP, tends to select a diverse batch of high-magnitude samples. For completeness, we give a formal description of the $k$ -MEA $\mathrm { J } S + +$ seeding algorithm in Appendix A.
+
+Example: multiclass classification with softmax activations. Consider a neural network $f$ where the last nonlinearity is a softmax, i.e. $\sigma ( z ) _ { i } = e ^ { z _ { i } } / { \sum _ { j = 1 } ^ { K } e ^ { z _ { j } } }$ . Specifically, $f$ is parametrized by $\theta = ( W , V )$ , where $\theta _ { \mathrm { o u t } } = W = ( W _ { 1 } , \ldots , W _ { K } ) ^ { \top } \in \mathbb { R } ^ { K \times d }$ are the weights of the last layer, and $V$ consists of weights of all previous layers. This means that $f ( x ; \theta ) = \sigma ( W \cdot \bar { z } ( x ; V ) )$ , where $z$ is the nonlinear function that maps an input $x$ to the output of the network’s penultimate layer. Let us fix an unlabeled sample $x$ and define $p _ { i } = f ( x ; \theta ) _ { i }$ . With this notation, we have
+
+$$
+\ell _ { \mathrm { { C E } } } ( f ( x ; \theta ) , y ) = \ln \left( \sum _ { j = 1 } ^ { K } e ^ { W _ { j } \cdot z ( x ; V ) } \right) - W _ { y } \cdot z ( x ; V ) .
+$$
+
+Define $\begin{array} { r } { g _ { x } ^ { y } = \frac { \partial } { \partial W } \ell _ { \mathrm { C E } } ( f ( x ; \theta ) , y ) } \end{array}$ for a label $y$ and $g _ { x } = g _ { x } ^ { \hat { y } }$ as the gradient embedding in our algorithm, where ${ \hat { y } } = \operatorname { a r g m a x } _ { i \in [ K ] } p _ { i }$ . Then the $i$ -th block of $g _ { x }$ (i.e. the gradients corresponding to label $i$ ) is
+
+$$
+( g _ { x } ) _ { i } = \frac { \partial } { \partial W _ { i } } \ell _ { \mathrm { C E } } ( f ( x ; \theta ) , \hat { y } ) = ( p _ { i } - I ( \hat { y } = i ) ) z ( x ; V ) .
+$$
+
+Based on this expression, we can make the following observations:
+
+1. Each block of $g _ { x }$ is a scaling of $z ( x ; V )$ , which is the output of the penultimate layer of the network. In this respect, $g _ { x }$ captures $x$ ’s representation information similar to that of Sener and Savarese (2018).
+
+2. Proposition 1 below shows that the norm of $g _ { x }$ is a lower bound on the norm of the loss gradient induced by the example with true label $y$ with respect to the weights in the last layer, that is $\| g _ { x } \| \leq \| \dot { g } _ { x } ^ { y } \|$ . This suggests that the norm of $g _ { x }$ conservatively estimates the example’s influence on the current model.
+
+3. If the current model $\theta$ is highly confident about $x$ , i.e. vector $p$ is skewed towards a standard basis vector $e _ { j }$ , then $\hat { y } = j$ , and vector $( p _ { i } - I ( \hat { y } = i ) ) _ { i = 1 } ^ { K }$ has a small length. Therefore, $g _ { x }$ has a small length as well. Such high-confidence examples tend to have gradient embeddings of small magnitude, which are unlikely to be repeatedly selected by $k { \mathrm { - M E A N S + + } }$ at iteration $t$ .
+
+Proposition 1. For all $y \in \{ 1 , \ldots , K \}$ , let $\begin{array} { r } { g _ { x } ^ { y } = \frac { \partial } { \partial W } \ell _ { \mathrm { C E } } ( f ( x ; \theta ) , y ) } \end{array}$ . Then
+
+$$
+\| g _ { x } ^ { y } \| ^ { 2 } = \Big ( \sum _ { i = 1 } ^ { K } p _ { i } ^ { 2 } + 1 - 2 p _ { y } \Big ) \| z ( x ; V ) \| ^ { 2 } .
+$$
+
+Consequently, ${ \hat { y } } = \operatorname { a r g m i n } _ { y \in [ K ] } \left\| g _ { x } ^ { y } \right\|$ .
+
+Proof. Observe that by Equation (1),
+
+$$
+\| g _ { x } ^ { y } \| ^ { 2 } = \sum _ { i = 1 } ^ { K } \left( p _ { i } - I ( y = i ) \right) ^ { 2 } \| z ( x ; V ) \| ^ { 2 } = \Big ( \sum _ { i = 1 } ^ { K } p _ { i } ^ { 2 } + 1 - 2 p _ { y } \Big ) \| z ( x ; V ) \| ^ { 2 } .
+$$
+
+The second claim follows from the fact that yˆ = argmaxy∈[K] py.
+
+This simple sampler tends to produce diverse batches similar to a $k$ -DPP. As shown in Figure 1, switching between the two samplers does not affect the active learner’s statistical performance but greatly improves its computational performance. Appendix G compares run time and test accuracy for both $k$ -MEANS $^ { + + }$ and $k$ -DPP based sampling based on the gradient embeddings of the unlabeled examples.
+
+Figure 2 illustrates the batch diversity and average gradient magnitude per selected batch for a variety of sampling strategies. As expected, both $k$ -DPPs and $k { \mathrm { - M E A N S + + } }$ tend to select samples that are diverse (as measured by the magnitude of their Gram determinant) and high magnitude. Other samplers, such as furthest-first traversal for $k$ -Center clustering (FF- $k$ -CENTER), do not seem to have this property. The FF- $k$ -CENTER algorithm is the sampling choice of the CORESET approach to active learning, which we describe in the proceeding section (Sener and Savarese, 2018). Appendix F discusses diversity with respect to uncertainty-based approaches.
+
+Appendix B provides further justification for why BADGE yields better updates than vanilla uncertainty sampling in the special case of binary logistic regression $K = 2$ and $z ( x ; V ) = x $ ).
+
+# 4 EXPERIMENTS
+
+We evaluate the performance of BADGE against several algorithms from the literature. In our experiments, we seek to answer the following question: How robust are the learning algorithms to choices of neural network architecture, batch size, and dataset?
+
+To ensure a comprehensive comparison among all algorithms, we evaluate them in a batch-mode active learning setup with $M = 1 0 0$ being the number of initial random labeled examples and batch size $B$ varying from $\{ 1 0 0 , 1 0 0 0 , 1 0 0 0 0 \}$ . The following is a list of the baseline algorithms evaluated; the first performs representative sampling, the next three are uncertainty based, the fifth is a hybrid of representative and uncertainty-based approaches, and the last is traditional supervised learning.
+
+![](images/e9edd9bc4085eb347e0355361c980da855565eadfb3c1c4c32469cc726e95c60.jpg)  
+Figure 2: A comparison of batch selection algorithms using our gradient embedding. Left and center: Plots showing the log determinant of the Gram matrix of the selected batch of gradient embeddings as learning progresses. Right: The average embedding magnitude (a measurement of predictive uncertainty) in the selected batch. The FF- $k$ -CENTER sampler finds points that are not as diverse or high-magnitude as other samplers. Notice also that $k { \mathrm { - M E A N S + + } }$ tends to actually select samples that are both more diverse and higher-magnitude than a $k$ -DPP, a potential pathology of the $k$ -DPP’s degree of stochastisity. Standard errors are shown by shaded regions.
+
+1. CORESET: A diversity-based approach using coreset selection. The embedding of each example is computed by the network’s penultimate layer and the samples at each round are selected using a greedy furthest-first traversal conditioned on all labeled examples (Sener and Savarese, 2018).   
+2. CONF (Confidence Sampling): An uncertainty-based active learning algorithm that selects $B$ examples with smallest predicted class probability, $\operatorname* { m a x } _ { i = 1 } ^ { K } f ( x ; \theta ) _ { i }$ (e.g. Wang and Shang, 2014).   
+3. MARG (Margin Sampling): An uncertainty-based active learning algorithm that selects the bottom $B$ examples sorted according to the example’s multiclass margin, defined as $f ( x ; \theta ) _ { \hat { y } } - f ( x ; \theta ) _ { y ^ { \prime } }$ , where $\hat { y }$ and $y ^ { \prime }$ are the indices of the largest and second largest entries of $f ( x ; \theta )$ (Roth and Small, 2006).   
+4. ENTROPY: An uncertainty-based active learning algorithm that selects the top $B$ examples according to the entropy of the example’s predictive class probability distribution, defined as $H ( ( f ( x ; \theta ) _ { y } ) _ { y = 1 } ^ { K } )$ , where $\begin{array} { r } { H ( p ) = \sum _ { i = 1 } ^ { K ^ { - } } p _ { i } \ln ^ { - } \Bigr / p _ { i } } \end{array}$ (Wang and Shang, 2014).   
+5. ALBL (Active Learning by Learning): A bandit-style meta-active learning algorithm that selects between CORESET and CONF at every round (Hsu and Lin, 2015).   
+6. RAND: The naive baseline of randomly selecting $k$ examples to query at each round.
+
+We consider three neural network architectures: a two-layer Perceptron with ReLU activations (MLP), an 18-layer convolutional ResNet (He et al., 2016), and an 11-layer VGG network (Simonyan and Zisserman, 2014). We evaluate our algorithms using three image datasets, SVHN (Netzer et al., 2011), CIFAR10 (Krizhevsky, 2009) and MNIST (LeCun et al., 1998) 1, and four non-image datasets from the OpenML repository (#6, #155, #156, and #184). 2 We study each situation with 7 active learning algorithms, including BADGE, making for 231 total experiments.
+
+For the image datasets, the embedding dimensionality in the MLP is 256. For the OpenML datasets, the embedding dimensionality of the MLP is 1024, as more capacity helps the model fit training data. We fit models using cross-entropy loss and the Adam variant of SGD until training accuracy exceeds $9 9 \%$ . We use a learning rate of 0.001 for image data and of 0.0001 for non-image data. We avoid warm starting and retrain models from scratch every time new samples are queried (Ash and Adams, 2019). All experiments are repeated five times. No learning rate schedules or data augmentation are used. Baselines use implementations from the libact library (Yang et al., 2017). All models are trained in PyTorch (Paszke et al., 2017).
+
+![](images/862b919b13024e0ae4ccf8ea1350510ffaca7bdbca2409f37db62423dba2128a.jpg)  
+Figure 3: Active learning test accuracy versus the number of total labeled samples for a range of conditions. Standard errors are shown by shaded regions.
+
+Learning curves. Here we show examples of learning curves that highlight some of the phenomena we observe related to the fragility of active learning algorithms with respect to batch size, architecture, and dataset.
+
+Often, we see that in early rounds of training, it is better to do diversity sampling, and later in training, it is better to do uncertainty sampling. This kind of event is demonstrated in Figure 3a, which shows CORESET outperforming confidence-based methods at first, but then doing worse than these methods later on.
+
+In this figure, BADGE performs as well as diversity sampling when that strategy does best, and as well as uncertainty sampling once those methods start outpacing CORESET. This suggests that BADGE is a good choice regardless of labeling budget.
+
+Separately, we notice that diversity sampling only seems to work well when either the model has good architectural priors (inductive biases) built in, or when the data are easy to learn. Otherwise, penultimate layer representations are not meaningful, and diverse sampling can be deleterious. For this reason, CORESET often performs worse than random on sufficiently complex data when not using a convolutional network (Figure 3b). That is, the diversity induced by unconditional random sampling can often yield a batch that better represents the data. Even when batch size is large and the model has helpful inductive biases, the uncertainty information in BADGE can give it an advantage over pure diversity approaches (Figure 3c). Comprehensive plots of this kind, spanning architecture, dataset, and batch size are in Appendix C.
+
+![](images/b6198f1f5a9453b9546972ece2536fc119869120e54d54025af727432c2cd297.jpg)  
+Figure 4: A pairwise penalty matrix over all experiments. Element $P _ { i , j }$ corresponds roughly to the number of times algorithm $_ { i }$ outperforms algorithm $j$ . Column-wise averages at the bottom show overall performance (lower is better).
+
+Pairwise comparisons. We next show a comprehensive pairwise comparison of algorithms over all datasets $( D )$ , batch sizes $( B )$ , model architectures $( A )$ , and label budgets $( L )$ . From the learning curves, it can be observed that when label budgets are large enough, all algorithms eventually reach similar performance, making the comparison between them uninteresting in the large sample limit. For this reason, for each combination of $( D , B , { \bar { A } } )$ , we select a set of labeling budgets $L$ where learning is still progressing. We experimented with three different batch sizes and eleven dataset-architecture pairs, making the total number of $( D , B , A )$ combinations $3 \times 1 1 = 3 3$ . Specifically, we compute $n _ { 0 }$ , the smallest number of labels where RAND’s accuracy reaches $9 9 \%$ of its final accuracy, and choose label budget $L$ from $\big \{ M + 2 ^ { m - 1 } B : m \in [ \lfloor \log ( ( n _ { 0 } - \dot { M } ) / B ) \rfloor ] \big \} .$ . The calculation of scores in the penalty matrix $P$ follows the following protocol: For each $( D , B , A , L )$ combination and each pair of algorithms $( i , j )$ , we have 5 test errors (one for each repeated run), $\big \{ e _ { i } ^ { 1 } , \ldots , e _ { i } ^ { 5 } \big \}$ and $\big \{ e _ { j } ^ { 1 } , \ldots , e _ { j } ^ { 5 } \big \}$ respectively. We compute the $t$ -score as $\begin{array} { c c l } { t } & { = } & { \sqrt { 5 } \hat { \mu } / \hat { \sigma } } \end{array}$ , where
+
+$$
+\hat { \mu } = \frac { 1 } { 5 } \sum _ { l = 1 } ^ { 5 } ( e _ { i } ^ { l } - e _ { j } ^ { l } ) , ~ \hat { \sigma } = \sqrt { \frac { 1 } { 4 } \sum _ { l = 1 } ^ { 5 } ( e _ { i } ^ { l } - e _ { j } ^ { l } - \hat { \mu } ) ^ { 2 } } .
+$$
+
+We use the two-sided $t$ -test to compare pairs of algorithms: algorithm $i$ is said to beat algorithm $j$ in this setting if $t ~ > ~ 2 . 7 7 6$ (the critical point of $p$ -value being 0.05), and similarly algorithm $j$ beats algorithm $i$ if $t < - 2 . 7 7 6$ . For each $( D , B , A )$ combination, suppose there are ${ } ^ { n } D , B , A$ different values of $L$ . Then, for each $L$ , if algorithm $i$ beats algorithm $j$ , we accumulate a penalty of $1 / n _ { D , B , A }$ to $P _ { i , j }$ ; otherwise, if algorithm $j$ beats algorithm $i$ , we accumulate a penalty of $1 / n _ { D , B , A }$ to $P _ { j , i }$ The choice of the penalty value $1 / n _ { D , B , A }$ is to ensure that every $( D , B , A )$ combination is assigned equal influence in the aggregated matrix. Therefore, the largest entry of $P$ is at most 33, the total number of $( D , B , A )$ combinations.
+
+![](images/8aea56706be71d726b40aab86de0168f6950ac1a8c1af6affb837d9b574a0b9b.jpg)  
+Figure 5: The cumulative distribution function of normalized errors for all acquisition functions.
+
+Intuitively, each row $i$ indicates the number of settings in which algorithm $i$ beats other algorithms and each column $j$ indicates the number of settings in which algorithm $j$ is beaten by another algorithm.
+
+The penalty matrix in Figure 4 summarizes all experiments, showing that BADGE generally outperforms baselines. Matrices grouped by batch size and architecture in Appendix D show a similar trend.
+
+Cumulative distribution functions of normalized errors. For each $( D , B , A , L )$ combination, we compute the average error for each algorithm $i$ as $\textstyle { \bar { e } } _ { i } = { \frac { 1 } { 5 } } \sum _ { l = 1 } ^ { 5 } e _ { i } ^ { l }$ . To ensure that the errors of the algorithms are on the same scale in all settings, we compute the normalized error of every algorithm $i$ $\mathrm { n e } _ { i } = \bar { e } _ { i } / \bar { e } _ { r }$ , where $r$ is the index of the RAND algorithm. By definition, the normalized errors of the RAND algorithm are identically 1 in all settings. Like with penalty matrices, for each $( D , B , A )$ combination, we only consider a subset of $L$ values from the set $\big \{ M + 2 ^ { m - 1 } B : m \in [ \lfloor \log ( ( n _ { 0 } - M ) / B ) \rfloor ] \big \}$ . We assign a weight proportional to $1 / n _ { D , B , A }$ to each $( D , B , A , L )$ combination, where there are ${ } ^ { n } D , B , A$ different $L$ values for this combination of $( D , B , A )$ . We then plot the cumulative distribution functions (CDFs) of the normalized errors of all algorithms: for a value of $x$ , the $y$ value is the total weight of settings where the algorithm has normalized error at most $x$ ; in general, an algorithm that has a higher CDF value has better performance.
+
+We plot the generated CDFs in Figures 5, 22 and 23. We can see from Figure 5 that BADGE has the best overall performance. In addition, from Figures 22 and 23 in Appendix E, we can conclude that when batch size is small (100 or 1000) or when an MLP is used, both BADGE and MARG perform best. However, in the regime when the batch size is large (10000), MARG’s performance degrades, while BADGE, ALBL and CORESET are the best performing approaches.
+
+# 5 RELATED WORK
+
+Active learning is a been well-studied problem (Settles, 2010; Dasgupta, 2011; Hanneke, 2014). There are two major strategies for active learning—representative sampling and uncertainty sampling.
+
+Representative sampling algorithms select batches of unlabeled examples that are representative of the unlabeled set to ask for labels. It is based on the intuition that the sets of representative examples chosen, once labeled, can act as a surrogate for the full dataset. Consequently, performing loss minimization on the surrogate suffices to ensure a low error with respect to the full dataset. In the context of deep learning, Sener and Savarese (2018); Geifman and El-Yaniv (2017) select representative examples based on core-set construction, a fundamental problem in computational geometry. Inspired by generative adversarial learning, Gissin and Shalev-Shwartz (2019) select samples that are maximally indistinguishable from the pool of unlabeled examples.
+
+On the other hand, uncertainty sampling is based on a different principle—to select new samples that maximally reduce the uncertainty the algorithm has on the target classifier. In the context of linear classification, Tong and Koller (2001); Schohn and Cohn (2000); Tur et al. (2005) propose uncertainty sampling methods that query examples that lie closest to the current decision boundary. Some uncertainty sampling approaches have theoretical guarantees on statistical consistency (Hanneke, 2014; Balcan et al., 2006). Such methods have also been recently generalized to deep learning. For instance, Gal et al. (2017) use Dropout as an approximation of the posterior of the model parameters, and develop information-based uncertainty reduction criteria; inspired by recent advances on adversarial examples generation, Ducoffe and Precioso (2018) use the distance between an example and one of its adversarial examples as an approximation of its distance to the current decision boundary, and uses it as the criterion of label queries. An ensemble of classifiers could also be used to effectively estimate uncertainty (Beluch et al., 2018).
+
+There are several existing approaches that support a hybrid of representative sampling and uncertainty sampling. For example, Baram et al. (2004); Hsu and Lin (2015) present meta-active learning algorithms that can combine the advantages of different active learning algorithms. Inspired by expected loss minimization, Huang et al. (2010) develop label query criteria that balances between the representativeness and informativeness of examples. Another method for this is Active Learning by Learning (Hsu and Lin, 2015), which can select whether to exercise a diversity based algorithm or an uncertainty based algorithm at each round of training as a sequential decision process.
+
+There is also a large body of literature on batch mode active learning, where the learner is asked to select a batch of samples within each round (Guo and Schuurmans, 2008; Wang and Ye, 2015; Chen and Krause; Wei et al., 2015; Kirsch et al., 2019). In these works, batch selection is often formulated as an optimization problem with objectives based on (upper bounds of) average log-likelihood, average squared loss, etc.
+
+A different query criterion based on expected gradient length (EGL) has been proposed in the as well (Settles et al., 2008). In recent work, Huang et al. (2016) show that the EGL criterion is related to the $T$ -optimality criterion in experimental design. They further demonstrate that the samples selected by EGL are very different from those by entropy-based uncertainty criterion. Zhang et al. (2017a) use the EGL criterion in active sentence and document classification with CNNs. These approaches differ most substantially from BADGE in that they do not take into account the diversity of the examples queried within each batch.
+
+There is a wide array of theoretical articles that focus on the related problem of adaptive subsampling for fully-labeled datasets in regression settings (Han et al., 2016; Wang et al., 2018; Ting and Brochu, 2018). Empirical studies of batch stochastic gradient descent also employ adaptive sampling to “emphasize” hard or representative examples (Zhang et al., 2017b; Chang et al., 2017). These works aim at reducing computation costs or finding a better local optimal solution, as opposed to reducing label costs. Nevertheless, our work is inspired by their sampling criteria, which also emphasize samples that induce large updates to the model.
+
+As mentioned earlier, our sampling criterion has resemblance to sampling from $k$ -determinantal point processes (Kulesza and Taskar, 2011). Note that in multiclass classification settings, our gradient-based embedding of an example can be viewed as the outer product of the original embedding in the penultimate layer and a probability score vector that encodes the uncertainty information on this example (see Section 3). In this view, the penultimate layer embedding characterizes the diversity of each example, whereas the probability score vector characterizes the quality of each example. The $k$ -DPP is also a natural probabilistic tool for sampling that trades off between quality and diversity (See Kulesza et al., 2012, Section 3.1). We remark that concurrent to our work, Bıyık et al. (2019) develops $k$ -DPP based active learning algorithms based on this principle by explicitly designing diversity and uncertainty measures.
+
+# 6 DISCUSSION
+
+We have established that BADGE is empirically an effective deep active learning algorithm across different architectures and batch sizes, performing similar to or better than other active learning algorithms. A fundamental remaining question is: "Why?" While deep learning is notoriously difficult to analyze theoretically, there are several intuitively appealing properties of BADGE:
+
+1. The definition of uncertainty (a lower bound on the gradient magnitude of the last layer) guarantees some update of parameters. 2. It optimizes for diversity as well as uncertainty, eliminating a failure mode of choosing many identical uncertain examples in a batch, and does so without requiring any hyperparameters. 3. The randomization associated with the $k { \mathrm { - M E A N S + + } }$ initialization sampler implies that, even for adversarially constructed datasets, it eventually converges to a good solution.
+
+The combination of these properties appears to generate the robustness that we observe empirically.
+
+# REFERENCES
+
+David Cohn, Les Atlas, and Richard Ladner. Improving generalization with active learning. Machine learning, 1994.   
+Maria-Florina Balcan, Alina Beygelzimer, and John Langford. Agnostic active learning. In International Conference on Machine Learning, 2006.   
+Alina Beygelzimer, Daniel J Hsu, John Langford, and Tong Zhang. Agnostic active learning without constraints. In Neural Information Processing Systems, 2010.   
+Nicolo Cesa-Bianchi, Claudio Gentile, and Francesco Orabona. Robust bounds for classification via selective sampling. In International Conference on Machine Learning, 2009.   
+David Arthur and Sergei Vassilvitskii. k-means $^ { + + }$ : The advantages of careful seeding. In ACM-SIAM symposium on Discrete algorithms, 2007.   
+Alex Kulesza and Ben Taskar. k-dpps: Fixed-size determinantal point processes. In International Conference on Machine Learning, 2011.   
+Michał Derezinski and Manfred K Warmuth. Reverse iterative volume sampling for linear regression. ´ The Journal of Machine Learning Research, 19(1), 2018.   
+Byungkon Kang. Fast determinantal point process sampling with application to clustering. In Neural Information Processing Systems, 2013.
+
+Nima Anari, Shayan Oveis Gharan, and Alireza Rezaei. Monte carlo markov chain algorithms for sampling strongly rayleigh distributions and determinantal point processes. In Conference on Learning Theory, 2016.
+
+Michał Derezinski. Fast determinantal point processes via distortion-free intermediate sampling. ´ arXiv preprint, 2018.
+
+Ozan Sener and Silvio Savarese. Active learning for convolutional neural networks: A core-set approach. In International Conference on Learning Representations, 2018.
+
+Dan Wang and Yi Shang. A new active labeling method for deep learning. In 2014 International joint conference on neural networks, 2014.
+
+Dan Roth and Kevin Small. Margin-based active learning for structured output spaces. In European Conference on Machine Learning, 2006.
+
+Wei-Ning Hsu and Hsuan-Tien Lin. Active learning by learning. In Association for the advancement of artificial intelligence, 2015.
+
+Kaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. Deep residual learning for image recognition. In Proceedings of the IEEE conference on computer vision and pattern recognition, pages 770–778, 2016.
+
+Karen Simonyan and Andrew Zisserman. Very deep convolutional networks for large-scale image recognition. arXiv preprint, 2014.
+
+Yuval Netzer, Tao Wang, Adam Coates, Alessandro Bissacco, Bo Wu, and Andrew Y Ng. Reading digits in natural images with unsupervised feature learning. 2011.
+
+Alex Krizhevsky. Learning multiple layers of features from tiny images. Technical report, Citeseer, 2009.
+
+Yann LeCun, Léon Bottou, Yoshua Bengio, Patrick Haffner, et al. Gradient-based learning applied to document recognition. IEEE, 1998.
+
+Jordan T Ash and Ryan P Adams. On the difficulty of warm-starting neural network training. arXiv preprint, 2019.
+
+Yao-Yuan Yang, Shao-Chuan Lee, Yu-An Chung, Tung-En Wu, Si-An Chen, and Hsuan-Tien Lin. libact: Pool-based active learning in python. arXiv preprint, 2017.
+
+Adam Paszke, Sam Gross, Soumith Chintala, Gregory Chanan, Edward Yang, Zachary DeVito, Zeming Lin, Alban Desmaison, Luca Antiga, and Adam Lerer. Automatic differentiation in pytorch. 2017.
+
+Burr Settles. Active learning literature survey. University of Wisconsin, Madison, 2010.
+
+Sanjoy Dasgupta. Two faces of active learning. Theoretical computer science, 2011.
+
+Steve Hanneke. Theory of disagreement-based active learning. Foundations and Trends in Machine Learning, 2014.
+
+Yonatan Geifman and Ran El-Yaniv. Deep active learning over the long tail. arXiv preprint, 2017.
+
+Daniel Gissin and Shai Shalev-Shwartz. Discriminative active learning. arXiv preprint, 2019.
+
+Simon Tong and Daphne Koller. Support vector machine active learning with applications to text classification. Journal of machine learning research, 2001.
+
+Greg Schohn and David Cohn. Less is more: Active learning with support vector machines. In International Conference on Machine Learning, 2000.
+
+Gokhan Tur, Dilek Hakkani-Tür, and Robert E Schapire. Combining active and semi-supervised learning for spoken language understanding. Speech Communication, 2005.
+
+Yarin Gal, Riashat Islam, and Zoubin Ghahramani. Deep bayesian active learning with image data. In International Conference on Machine Learning, 2017.
+
+Melanie Ducoffe and Frederic Precioso. Adversarial active learning for deep networks: a margin based approach. arXiv preprint, 2018.
+
+William H Beluch, Tim Genewein, Andreas Nürnberger, and Jan M Köhler. The power of ensembles for active learning in image classification. In IEEE Conference on Computer Vision and Pattern Recognition, 2018.
+
+Yoram Baram, Ran El Yaniv, and Kobi Luz. Online choice of active learning algorithms. Journal of Machine Learning Research, 2004.
+
+Sheng-Jun Huang, Rong Jin, and Zhi-Hua Zhou. Active learning by querying informative and representative examples. In Neural Information Processing Systems, 2010.
+
+Yuhong Guo and Dale Schuurmans. Discriminative batch mode active learning. In Neural Information Processing Systems, 2008.
+
+Zheng Wang and Jieping Ye. Querying discriminative and representative samples for batch mode active learning. Transactions on Knowledge Discovery from Data, 2015.
+
+Yuxin Chen and Andreas Krause. Near-optimal batch mode active learning and adaptive submodular optimization. In International Conference on Machine Learning.
+
+Kai Wei, Rishabh Iyer, and Jeff Bilmes. Submodularity in data subset selection and active learning. In International Conference on Machine Learning, 2015.
+
+Andreas Kirsch, Joost van Amersfoort, and Yarin Gal. Batchbald: Efficient and diverse batch acquisition for deep bayesian active learning. In Neural Information Processing Systems 32, 2019.
+
+Burr Settles, Mark Craven, and Soumya Ray. Multiple-instance active learning. In Neural Information Processing Systems, 2008.
+
+Jiaji Huang, Rewon Child, and Vinay Rao. Active learning for speech recognition: the power of gradients. arXiv preprint, 2016.
+
+Ye Zhang, Matthew Lease, and Byron C Wallace. Active discriminative text representation learning. In AAAI Conference on Artificial Intelligence, 2017a.
+
+Lei Han, Kean Ming Tan, Ting Yang, and Tong Zhang. Local uncertainty sampling for large-scale multi-class logistic regression. arXiv preprint, 2016.
+
+HaiYing Wang, Rong Zhu, and Ping Ma. Optimal subsampling for large sample logistic regression. Journal of the American Statistical Association, 2018.
+
+Daniel Ting and Eric Brochu. Optimal subsampling with influence functions. In Neural Information Processing Systems, 2018.
+
+Cheng Zhang, Hedvig Kjellstrom, and Stephan Mandt. Determinantal point processes for mini-batch diversification. Uncertainty in Artificial Intelligence, 2017b.
+
+Haw-Shiuan Chang, Erik Learned-Miller, and Andrew McCallum. Active bias: Training more accurate neural networks by emphasizing high variance samples. In Neural Information Processing Systems, 2017.
+
+Alex Kulesza, Ben Taskar, et al. Determinantal point processes for machine learning. Foundations and Trends in Machine Learning, 2012.
+
+Erdem Bıyık, Kenneth Wang, Nima Anari, and Dorsa Sadigh. Batch active learning using determinantal point processes. arXiv preprint, 2019.
+
+Stephen Mussmann and Percy S Liang. Uncertainty sampling is preconditioned stochastic gradient descent on zero-one loss. In Neural Information Processing Systems, 2018.
+
+# A THE $k$ -MEA ${ . N S + + }$ SEEDING ALGORITHM
+
+Here we briefly review the $k { \mathrm { - M E A N S + + } }$ seeding algorithm by (Arthur and Vassilvitskii, 2007). Its basic idea is to perform sequential sampling of $k$ centers, where each new center is sampled from the ground set with probability proportional to the squared distance to its nearest center. It is shown in (Arthur and Vassilvitskii, 2007) that the set of centers returned is guaranteed to approximate the $k$ -means objective function in expectation, thus ensuring diversity.
+
+# Algorithm 2 The $k$ -MEANS++ seeding algorithm (Arthur and Vassilvitskii, 2007)
+
+Require: Ground set $G \subset \mathbb { R } ^ { d }$ , target size $k$ .   
+Ensure: Center set $C$ of size $k$ . $C _ { 1 } \gets \{ c _ { 1 } \}$ , where $c _ { 1 }$ is sampled uniformly at random from $G$ . for $t = 2 , \ldots , k$ : do Define $D _ { t } ( x ) : = \mathrm { m i n } _ { c \in C _ { t - 1 } } \| x - c \| _ { 2 }$ . $c _ { t } \gets$ Sample $x$ from $G$ with probability $\frac { D _ { t } ( x ) ^ { 2 } } { \sum _ { x \in G } D _ { t } ( x ) ^ { 2 } }$ . $C _ { t } \gets C _ { t - 1 } \cup \{ c _ { t } \} _ { }$ . end for return $C _ { k }$ .
+
+# B BADGE FOR BINARY LOGISTIC REGRESSION
+
+We consider instantiating BADGE for binary logistic regression, where $\mathcal { V } = \{ - 1 , + 1 \}$ . Given a linear classifier $w$ , we define the predictive probability of $w$ on $x$ as $p _ { w } ( y | x , \theta ) = \sigma ( y w \cdot x )$ , where $\begin{array} { r } { \sigma ( z ) = \frac { 1 } { 1 + e ^ { - z } } } \end{array}$ is the sigmoid funciton.
+
+Recall that ${ \hat { y } } = { \hat { y } } ( x )$ is the hallucinated label:
+
+$$
+\hat { y } ( x ) = \left\{ { \begin{array} { l l } { + 1 , } & { p _ { w } ( + 1 | x , \theta ) > 1 / 2 , } \\ { - 1 , } & { p _ { w } ( + 1 | x , \theta ) \leq 1 / 2 . } \end{array} } \right.
+$$
+
+The binary logistic loss of classifier $w$ on example $( x , y )$ is defined as:
+
+$$
+\ell ( w , ( x , y ) ) = \ln ( 1 + \exp ( - y w \cdot x ) ) .
+$$
+
+Now, given model $w$ and example $x$ , we define $\begin{array} { r } { \hat { g } _ { x } = \frac { \partial } { \partial w } \ell ( w , ( x , \hat { y } ) ) = ( 1 - p _ { w } ( \hat { y } | x , \theta ) ) \cdot ( - \hat { y } \cdot x ) } \end{array}$ as the loss gradient induced by the example with hallucinated label, and $\begin{array} { r } { \tilde { g } _ { x } = \frac { \partial } { \partial w } \ell ( w , ( x , y ) ) = ( 1 - p _ { w } ( y | x , \theta ) ) \cdot ( - y \cdot x ) } \end{array}$ as the loss gradient induced by the example with true label.
+
+![](images/eb67dcecb5e582087261eb4ed09d95f125d1a62a5adfb0b8d0f0f0be6bba3e0a.jpg)  
+Figure 6: Full learning curves for OpenML #6 with MLP.
+
+![](images/1c591f31c495cb4e2c3d089926a4a9dcc80732c6e0a95a3492a7a4b106da884d.jpg)  
+Figure 7: Full learning curves for OpenML #155 with MLP.
+
+Suppose that BADGE only selects examples from region $S _ { w } = \{ x : w \cdot x = 0 \}$ , then as $p _ { w } ( + 1 | x , \theta ) =$ $\begin{array} { r } { p _ { w } \big ( - 1 | x , \theta \big ) = \frac { 1 } { 2 } } \end{array}$ , we have that for all $x$ in $S _ { w }$ , $\hat { g } _ { x } = s _ { x } \cdot g _ { x }$ for some $s _ { x } \in \{ \pm 1 \}$ . This implies that, sampling from a DPP induced by ${ \hat { g } } _ { x }$ ’s is equivalent to sampling from a DPP induced by $g _ { x }$ ’s. It is noted in Mussmann and Liang (2018) that uncertainty sampling (i.e. sampling from $D _ { | S _ { w } }$ ) implicitly performs preconditioned stochastic gradient descent on the expected 0-1 loss. In addition, it has been shown that DPP sampling over gradients may reduce the variance of the mini-batch stochastic gradient updates (Zhang et al., 2017b); this suggests that BADGE, when restricted its sampling over low-margin regions $( S _ { w } )$ , improves over uncertainty sampling by collecting examples that together induce lower-variance updates on the gradient direction of expected 0-1 loss.
+
+# C ALL LEARNING CURVES
+
+We plot all learning curves (test accuracy as a function of the number of labeled example queried) in Figures 6 to 12. In addition, we zoom into regions of the learning curves that discriminates the performance of all algorithms in Figures 13 to 19.
+
+# D PAIRWISE COMPARISONS OF ALGORITHMS
+
+In addition to Figure 4 in the main text, we also provide penalty matrices (Figures 20 and 21), where the results are aggregated by conditioning on a fixed batch size (100, 1000 and 10000) or on a fixed neural network model (MLP, ResNet and VGG). For each penalty matrix, the parenthesized number in its title is the total number of $( D , B , A )$ combinations aggregated; as discussed in Section 4, this is also an upper bound on all its entries. It can be seen that uncertainty-based methods (e.g. MARG) perform well only in small batch size regimes (100) or when using MLP models; representative sampling based methods (e.g. CORESET) only perform well in large batch size regimes (10000) or when using ResNet or VGG models. In contrast, BADGE’s performance is competitive across all batch sizes and neural network models.
+
+![](images/d9030f407149623b5e1e3c6e2181cca01dc0f054d2cc7ee5b9e65e37b788430f.jpg)  
+Figure 8: Full learning curves for OpenML #156 with MLP.
+
+![](images/0dc915ff317f4bdacdb7591b36b371084cd4cbb9f1f0d4f07c652c08e046f8dd.jpg)  
+Figure 9: Full learning curves for OpenML #184 with MLP.
+
+![](images/021581459787c3b3df4ed9065c4342a96367bf511bc9af442888620fe9489f66.jpg)  
+Figure 10: Full learning curves for SVHN with MLP, ResNet and VGG.
+
+![](images/e8fe0e3b347610236751383630edb45029111c672cb94ecfd283ffc78dca523d.jpg)  
+Figure 11: Full learning curves for MNIST with MLP.
+
+![](images/a4a03ba238975dad7d4d9706c2fc6f8bf6ace30f7ad25c97337a95b53ba674be.jpg)  
+Figure 12: Full learning curves for CIFAR10 with MLP, ResNet and VGG.
+
+![](images/990f157de5f16287b5cc2739568242f27ae18014df01472d1d1c4978f90a5d0a.jpg)  
+Figure 13: Zoomed-in learning curves for OpenML $\# 6$ with MLP.
+
+![](images/d654ac52f0e8e7b4de997ddc93ec4e0f4ce9c1df3e103a48670fd2e5bf5edd73.jpg)  
+Figure 14: Zoomed-in learning curves for OpenML #155 with MLP.
+
+![](images/0f700512626eabdd7ba390eaa418d36818628e85542d87e27533dd250077d27a.jpg)  
+Figure 15: Zoomed-in learning curves for OpenML #156 with MLP.
+
+![](images/f2afa1c87f4feaa6e3796baea1d6a22218fb040453bcdb82a250d55b4d0a9738.jpg)  
+Figure 16: Zoomed-in learning curves for OpenML #184 with MLP.
+
+![](images/f0c42a0c3e2d768cd833fa7d50e3800e2873b503e576998c7a448383e9630f34.jpg)  
+Figure 17: Zoomed-in learning curves for SVHN with MLP, ResNet and VGG.
+
+![](images/fbce56c22162e29e6d225aa0e5d67f5788bf75bd60797bed3ade2cebd28df0bb.jpg)  
+Figure 18: Zoomed-in learning curves for MNIST with MLP.
+
+![](images/1500a84f46227f17a6b03c0a03417a976729932c9d4bd0b0846c341096d3bce2.jpg)  
+Figure 19: Zoomed-in learning curves for CIFAR10 with MLP, ResNet and VGG.
+
+![](images/bcdf7607b2dfbb32a55c7026c517c34f609fe133885d1d155bef016d2d58a66c.jpg)  
+Figure 20: Pairwise penalty matrices of the algorithms, grouped by different batch sizes. The parenthesized number in the title is the total number of $( D , B , A )$ combinations aggregated, which is also an upper bound on all its entries. Element $( i , j )$ corresponds roughly to the number of times algorithm $i$ beats algorithm $j$ . Column-wise averages at the bottom show aggregate performance (lower is better). From left to right: batch size $= 1 0 0$ , 1000, 10000.
+
+![](images/8ec656b0d27579e17e5d426494b01e24c71753019e1725e0565a8cb78ab69c17.jpg)  
+Figure 21: Pairwise penalty matrices of the algorithms, grouped by different neural network models. The parenthesized number in the title is the total number of $( D , B , A )$ combinations aggregated, which is also an upper bound on all its entries. Element $( i , j )$ corresponds roughly to the number of times algorithm $i$ beats algorithm $j$ . Column-wise averages at the bottom show aggregate performance (lower is better). From left to right: MLP, ResNet and VGG.
+
+![](images/7dd5a955d88848c7fffd4e19963044529b8b5dd217cfd79f1fe6e676bf7c481e.jpg)  
+Figure 22: CDFs of normalized errors of the algorithms, group by different batch sizes. Higher CDF indicates better performance. From left to right: batch size $= 1 0 0$ , 1000, 10000.
+
+![](images/1e8686a7c69e02d8ee3ed0ecbbd8213345b8e48ed6000061e556cbde8724f18f.jpg)  
+Figure 23: CDFs of normalized errors of the algorithms, group by different neural network models. Higher CDF indicates better performance. From left to right: MLP, ResNet and VGG.
+
+# E CDFS OF NORMALIZED ERRORS OF DIFFERENT ALGORITHMS
+
+In addition to Figure 5 that aggregates over all settings, we show here the CDFs of normalized errors by conditioning on fixed batch sizes (100, 1000 and 10000) in Figure 22, and show the CDFs of normalized errors by conditioning on fixed neural network models (MLP, ResNet and VGG) in Figure 23.
+
+# F BATCH UNCERTAINTY AND DIVERSITY
+
+Figure 24 gives a comparison of sampling methods with gradient embedding in two settings (OpenML # 6, MLP, batchsize 100 and SVHN, ResNet, batchsize 1000), in terms of uncertainty and diversity of examples selected within batches. These two properties are measured by average $\ell _ { 2 }$ norm and determinant of the Gram matrix of gradient embedding, respectively. It can be seen that, $k { \mathrm { - M E A N S + + } }$ (BADGE) induces good batch diversity in both settings. CONF generally selects examples with high uncertainty, but in some iterations of OpenML #6, the batch diversity is relatively low, as evidenced by the corresponding log Gram determinant being $- \infty$ . These areas are indicated by gaps in the learning curve for CONF. Situations where there are many gaps in the CONF plot seem to correspond to situations in which CONF performs poorly in terms of accuracy (see Figure 13 for the corresponding learning curve). Both $k$ -DPP and FF- $k$ -CENTER (an algorithm that approximately minimizes $k$ -center objective) select batches that have lower diversity than $k$ -MEANS $^ { + + }$ (BADGE).
+
+![](images/06e0a6591dd6c4b5362a74a440c88b7e0461b3c1f9819bca861c53a4a12938ab.jpg)  
+Figure 24: A comparison of batch selection algorithms in gradient space. Plots a and b show the log determinants of the Gram matrices of gradient embeddings within batches as learning progresses. Plots c and $\mathbf { d }$ show the average embedding magnitude (a measurement of predictive uncertainty) in the selected batch. The $k$ -centers sampler finds points that are not as diverse or high-magnitude as other samplers. Notice also that $k { \mathrm { - M E A N S + + } }$ tends to actually select samples that are both more diverse and higher-magnitude than a $k$ -DPP, a potential pathology of the $k$ -DPP’s degree of stochastisity. Among all algorithms, CONF has the largest average norm of gradient embeddings within a batch; however, in OpenML #6, and the first few interations of SVHN, some batches have a log Gram determinant of $- \infty$ (shown as gaps in the curve), which shows that CONF sometimes selects batches that are inferior in diversity.
+
+# G COMPARISON OF $k$ -MEANS $^ { + + }$ AND $k$ -DPP IN BATCH SELECTION
+
+In Figures 25 to 31, we give running time and test accuracy comparisons between $k { \mathrm { - M E A N S + + } }$ and $k$ -DPP for selecting examples based on gradient embedding in batch mode active learning. We implement the $k$ -DPP sampling using the MCMC algorithm from (Kang, 2013), which has a time complexity of $O ( \tau \cdot ( k ^ { 2 } + k d ) )$
+
+![](images/68897bb6eb4bbcd2af8922a41897bb08fb0a8da3dee3dc4ea852ae1ac708751f.jpg)  
+Figure 25: Learning curves and running times for OpenML #6 with MLP.
+
+![](images/b1f42c320b083c071d89711fbe35a86eb10b8d1f0c2d817a99adf3ecf93c99a1.jpg)  
+Figure 26: Learning curves and running times for OpenML #155 with MLP.
+
+and space complexity of $O ( k ^ { 2 } + k d )$ , where $\tau$ is the number of sampling steps. We set $\tau$ as $\lfloor 5 k \ln k \rfloor$ in our experiment. The comparisons for batch size 10000 are not shown here as the implementation of $k$ -DPP sampling runs out of memory.
+
+It can be seen from the figures that, although $k$ -DPP and $k { \mathrm { - M E A N S + + } }$ are based on different sampling criteria, the classification accuracies of their induced active learning algorithm are similar. In addition, when large batch sizes are required (e.g. $k = 1 0 0 0$ ), the running times of $k$ -DPP sampling are generally much higher than those of $k$ -MEA $\mathrm { N S } { + } { + }$ .
+
+![](images/5d40d22c75721a059cbb0b806209efb76c254e0e8846d044ac3890ff3d1626ee.jpg)  
+Figure 27: Learning curves and running times for OpenML #156 with MLP.
+
+![](images/8fe1677b8a9ebbca89d82595804c40b53899f667292aace8887172757fda3d48.jpg)  
+Figure 28: Learning curves and running times for OpenML #184 with MLP.
+
+![](images/432ede9d567f05ff30cc84e24734b9684b3267b38f6ff82e344349767b470a38.jpg)  
+Figure 29: Learning curves and running times for SVHN with MLP and ResNet.
+
+![](images/76e18f8566dc277eb165ad2a542cf0aeb87cdf8690bfcf233cdf2a0caac590d4.jpg)  
+Figure 30: Learning curves and running times for MNIST with MLP.
+
+![](images/3398b065aad57ae31c9b307f82c2049a16bcf7ee25b9677c8a6caa71d142daf3.jpg)  
+Figure 31: Learning curves and running times for CIFAR10 with MLP and ResNet.

parse/train/ryghZJBKPS/ryghZJBKPS_content_list.json

@@ -0,0 +1,2203 @@
+[
+    {
+        "type": "text",
+        "text": "DEEP BATCH ACTIVE LEARNING BY DIVERSE, UNCERTAIN GRADIENT LOWER BOUNDS ",
+        "text_level": 1,
+        "bbox": [
+            148,
+            116,
+            763,
+            164
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Jordan T. Ash Princeton University ",
+        "bbox": [
+            156,
+            189,
+            294,
+            218
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Chicheng Zhang University of Arizona ",
+        "bbox": [
+            411,
+            189,
+            555,
+            217
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Akshay Krishnamurthy Microsoft Research NYC ",
+        "bbox": [
+            671,
+            189,
+            839,
+            217
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "John Langford Microsoft Research NYC ",
+        "bbox": [
+            158,
+            238,
+            326,
+            266
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Alekh Agarwal Microsoft Research Redmond ",
+        "bbox": [
+            493,
+            239,
+            691,
+            267
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "ABSTRACT ",
+        "text_level": 1,
+        "bbox": [
+            452,
+            304,
+            544,
+            319
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "We design a new algorithm for batch active learning with deep neural network models. Our algorithm, Batch Active learning by Diverse Gradient Embeddings (BADGE), samples groups of points that are disparate and high magnitude when represented in a hallucinated gradient space, a strategy designed to incorporate both predictive uncertainty and sample diversity into every selected batch. Crucially, BADGE trades off between uncertainty and diversity without requiring any hand-tuned hyperparameters. While other approaches sometimes succeed for particular batch sizes or architectures, BADGE consistently performs as well or better, making it a useful option for real world active learning problems. ",
+        "bbox": [
+            207,
+            334,
+            792,
+            446
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 INTRODUCTION ",
+        "text_level": 1,
+        "bbox": [
+            150,
+            477,
+            310,
+            492
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "In recent years, deep neural networks have produced state-of-the-art results on a variety of important supervised learning tasks. However, many of these successes have been limited to domains where large amounts of labeled data are available. A promising approach for minimizing labeling effort is active learning, a learning protocol where labels can be requested by the algorithm in a sequential, feedback-driven fashion. Active learning algorithms aim to identify and label only maximally-informative samples, so that a high-performing classifier can be trained with minimal labeling effort. As such, a robust active learning algorithm for deep neural networks may considerably expand the domains in which these models are applicable. ",
+        "bbox": [
+            148,
+            507,
+            851,
+            606
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "How should we design a practical, general-purpose, label-efficient active learning algorithm for deep neural networks? Theory for active learning suggests a version-space-based approach (Cohn et al., 1994; Balcan et al., 2006), which explicitly or implicitly maintains a set of plausible models, and queries examples for which these models make different predictions. But when using highly expressive models like neural networks, these algorithms degenerate to querying every example. Further, the computational overhead of training deep neural networks precludes approaches that update the model to best fit data after each label query, as is often done (exactly or approximately) for linear methods (Beygelzimer et al., 2010; Cesa-Bianchi et al., 2009). Unfortunately, the theory provides little guidance for these models. ",
+        "bbox": [
+            148,
+            612,
+            851,
+            724
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "One option is to use the network’s uncertainty to inform a query strategy, for example by labeling samples for which the model is least confident. In a batch setting, however, this creates a pathological scenario where data in the batch are nearly identical, a clear inefficiency. Remedying this issue, we could select samples to maximize batch diversity, but this might choose points that provide little new information to the model. ",
+        "bbox": [
+            148,
+            731,
+            851,
+            787
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "For these reasons, methods that exploit just uncertainty or diversity do not consistently work well across model architectures, batch sizes, or datasets. An algorithm that performs well when using a ResNet, for example, might perform poorly when using a multilayer perceptron. A diversity-based approach might work well when the batch size is very large, but poorly when the batch size is small. Further, what even constitutes a “large” or “small” batch size is largely a function of the statistical properties of the data in question. These weaknesses pose a major problem for real, practical batch active learning situations, where data are unfamiliar and potentially unstructured. There is no way to know which active learning algorithm is best to use. ",
+        "bbox": [
+            145,
+            794,
+            849,
+            821
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            148,
+            119,
+            851,
+            190
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Moreover, in a real active learning scenario, every change of hyperparameters typically causes the algorithm to label examples not chosen under other hyperparameters, provoking substantial labeling inefficiency. That is, hyperparameter sweeps in active learning can be label expensive. As a result, active learning algorithms need to “just work”, given fixed hyperparameters, to a greater extent than is typical for supervised learning. ",
+        "bbox": [
+            148,
+            196,
+            849,
+            253
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Based on these observations, we design an approach which creates diverse batches of examples about which the current model is uncertain. We measure uncertainty as the gradient magnitude with respect to parameters in the final (output) layer, which is computed using the most likely label according to the model. To capture diversity, we collect a batch of examples where these gradients span a diverse set of directions. More specifically, we build up the batch of query points based on these hallucinated gradients using the $k { \\mathrm { - M E A N S + + } }$ initialization (Arthur and Vassilvitskii, 2007), which simultaneously captures both the magnitude of a candidate gradient and its distance from previously included points in the batch. We name the resulting approach Batch Active learning by Diverse Gradient Embeddings (BADGE). ",
+        "bbox": [
+            147,
+            260,
+            851,
+            372
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "We show that BADGE is robust to architecture choice, batch size, and dataset, generally performing as well as or better than the best baseline across our experiments, which vary all of the aforementioned environmental conditions. We begin by introducing our notation and setting, followed by a description of the BADGE algorithm in Section 3 and experiments in Section 4. We defer our discussion of related work to Section 5. ",
+        "bbox": [
+            148,
+            378,
+            849,
+            434
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2 NOTATION AND SETTING ",
+        "text_level": 1,
+        "bbox": [
+            150,
+            455,
+            385,
+            470
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Define $[ K ] : = \\{ 1 , 2 , \\dots , K \\}$ . Denote by $\\mathcal { X }$ the instance space and by $\\mathcal { V }$ the label space. In this work we consider multiclass classification, so $\\mathcal { V } = [ K ]$ . Denote by $D$ the distribution from which examples are drawn, by $D _ { \\mathcal { X } }$ the unlabeled data distribution, and by $D _ { \\mathcal { V } | \\mathcal { X } }$ the conditional distribution over labels given examples. We consider the pool-based active learning setup, where the learner receives an unlabeled dataset $U$ sampled according to $D _ { \\mathcal { X } }$ and can request labels sampled according to $D _ { \\mathcal { Y } | \\mathcal { X } }$ for any $x \\in$ $U$ . We use $\\mathbb { E } _ { D }$ to denote expectation under the data distribution $D$ . Given a classifier $h \\ : \\ \\mathcal { X }  \\ \\mathcal { Y }$ , which maps examples to labels, and a labeled example $( x , y )$ , we denote the $0 / 1$ error of $h$ on $( x , y )$ as $\\ell _ { 0 1 } ( h ( x ) , \\bar { y } ) = I ( \\bar { h } ( x ) \\neq y )$ . The performance of a classifier $h$ is measured by its expected $0 / 1$ error, i.e. $\\begin{array} { r } { \\mathbb { E } _ { D } [ \\ell _ { 0 1 } ( h ( x ) , y ) ] = \\operatorname* { P r } _ { ( x , y ) \\sim D } ( h ( x ) \\neq y ) } \\end{array}$ . The goal of pool-based active learning is to find a classifier with a small expected $0 / 1$ error using as few label queries as possible. Given a set $S$ of labeled examples $( x , y )$ , where each $x \\in S$ is picked from $U$ , followed by a label query, we use $\\mathbb { E } _ { S }$ as the sample averages over $S$ . ",
+        "bbox": [
+            147,
+            484,
+            852,
+            640
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "In this paper, we consider classifiers $h$ parameterized by underlying neural networks $f$ of fixed architecture, with the weights in the network denoted by $\\theta$ . We abbreviate the classifier with parameters $\\theta$ as $h _ { \\theta }$ since the architectures are fixed in any given context, and our classifiers take the form $h _ { \\theta } ( x ) = \\operatorname { a r g m a x } _ { y \\in [ K ] } f ( x ; \\theta ) _ { y }$ , where $f ( x ; \\theta ) \\in \\mathbb { R } ^ { K }$ is a probability vector of scores assigned to candidate labels, given the example $x$ and parameters $\\theta$ . We optimize the parameters by minimizing the cross-entropy loss $\\mathbb { E } _ { S } [ \\ell _ { \\mathrm { C E } } ( f ( x ; \\theta ) , y ) ]$ over the labeled examples, where $\\begin{array} { r } { \\ell _ { \\mathrm { C E } } ( p , y ) = \\sum _ { i = 1 } ^ { K } I ( y = i ) \\ln 1 / p _ { i } = \\ln { 1 / p _ { y } } } \\end{array}$ . ",
+        "bbox": [
+            147,
+            647,
+            852,
+            739
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Algorithm 1 BADGE: Batch Active learning by Diverse Gradient Embeddings ",
+        "bbox": [
+            150,
+            119,
+            671,
+            135
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Require: Neural network $f ( x ; \\theta )$ , unlabeled pool of examples $U$ , initial number of examples $M$ , number of iterations $T$ , number of examples in a batch $B$ . ",
+        "bbox": [
+            150,
+            138,
+            852,
+            165
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "1: Labeled dataset $S \\gets M$ examples drawn uniformly at random from $U$ together with queried labels. ",
+        "bbox": [
+            156,
+            166,
+            841,
+            179
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Train an initial model $\\theta _ { 1 }$ on $S$ by minimizing $\\mathbb { E } _ { S } [ \\dot { \\ell _ { \\mathrm { C E } } } ( f ( x ; \\theta ) , y ) ]$ . ",
+        "bbox": [
+            174,
+            181,
+            622,
+            194
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "4: For all examples $x$ in $U \\backslash S$ ",
+        "bbox": [
+            156,
+            208,
+            379,
+            222
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "1. Compute its hypothetical label $\\hat { y } ( x ) = h _ { \\theta _ { t } } ( x )$ .   \n2. Compute gradient embedding $\\begin{array} { r } { g _ { x } = \\frac { \\partial } { \\partial \\theta _ { \\mathrm { o u t } } } \\ell _ { \\mathrm { C E } } ( f ( x ; \\theta ) , \\hat { y } ( x ) ) | _ { \\theta = \\theta _ { t } } } \\end{array}$ , where $\\theta _ { \\mathrm { o u t } }$ refers to parameters of the final (output) layer.   \n5: Compute $S _ { t }$ , a random subset of $U \\backslash S$ , using the $k { \\mathrm { - M E A N S + + } }$ seeding algorithm on $\\{ g _ { x } : x \\in U \\setminus S \\}$ and query for their labels.   \n6: $S \\gets S \\cup S _ { t }$ .   \n7: Train a model $\\theta _ { t + 1 }$ on $S$ by minimizing $\\mathbb { E } _ { S } [ \\ell _ { \\mathrm { C E } } ( f ( x ; \\theta ) , y ) ]$ . ",
+        "bbox": [
+            187,
+            222,
+            856,
+            266
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            147,
+            266,
+            854,
+            321
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "8: end for   \n9: return Final model $\\theta _ { T + 1 }$ ",
+        "bbox": [
+            153,
+            321,
+            349,
+            349
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3 ALGORITHM ",
+        "text_level": 1,
+        "bbox": [
+            148,
+            381,
+            284,
+            396
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "BADGE, described in Algorithm 1, starts by drawing an initial set of $M$ examples uniformly at random from $U$ and asking for their labels. It then proceeds iteratively, performing two main computations at each step $t$ : a gradient embedding computation and a sampling computation. Specifically, at each step $t$ , for every $x$ in the pool $U$ , we compute the label ${ \\hat { y } } ( x )$ preferred by the current model, and the gradient $g _ { x }$ of the loss on $( x , { \\hat { y } } ( x ) )$ with respect to the parameters of the last layer of the network. Given these gradient embedding vectors $\\{ g _ { x } : x \\in U \\}$ , BADGE selects a set of points by sampling via the $k$ -MEAN ${ \\hphantom { 0 } } _ { \\mathrm { S } + + }$ initialization scheme (Arthur and Vassilvitskii, 2007). The algorithm queries the labels of these examples, retrains the model, and repeats. ",
+        "bbox": [
+            148,
+            412,
+            851,
+            510
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "We now describe the main computations — the embedding and sampling steps — in more detail. ",
+        "bbox": [
+            148,
+            517,
+            779,
+            531
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "The gradient embedding. Since deep neural networks are optimized using gradient-based methods, we capture uncertainty about an example through the lens of gradients. In particular, we consider the model uncertain about an example if knowing the label induces a large gradient of the loss with respect to the model parameters and hence a large update to the model. A difficulty with this reasoning is that we need to know the label to compute the gradient. As a proxy, we compute the gradient as if the model’s current prediction on the example is the true label. We show in Proposition 1 that, assuming a common structure satisfied by most natural neural networks, the gradient norm with respect to the last layer using this label provides a lower bound on the gradient norm induced by any other label. In addition, under that assumption, the length of this hypothetical gradient vector captures the uncertainty of the model on the example: if the model is highly certain about the example’s label, then the example’s gradient embedding will have a small norm, and vice versa for samples where the model is uncertain (see example below). Thus, the gradient embedding conveys information both about the model’s uncertainty and potential update direction upon receiving a label at an example. ",
+        "bbox": [
+            148,
+            547,
+            851,
+            714
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "The sampling step. We want the newly-acquired labeled samples to induce large and diverse changes to the model. To this end, we want the selection procedure to favor both sample magnitude and batch diversity. Specifically, we want to avoid the pathology of, for example, selecting a batch of $k$ similar samples where even just a single label could alleviate our uncertainty on all remaining $\\left( k - 1 \\right)$ samples. ",
+        "bbox": [
+            148,
+            731,
+            851,
+            787
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "A natural way of making this selection without introducing additional hyperparameters is to sample from a $k$ -Determinantal Point Process ( $k$ -DPP; (Kulesza and Taskar, 2011)). That is, to select a batch of $k$ points with probability proportional to the determinant of their Gram matrix. Recently, Derezinski and Warmuth´ (2018) showed that in experimental design for least square linear regression settings, learning from samples drawn from a $k$ -DPP can have much smaller mean square prediction error than learning from iid samples. In this process, when the batch size is very low, the selection will naturally favor points with a large length, which corresponds to uncertainty in our space. When the batch size is large, the sampler focuses more on diversity because linear independence, which is more difficult to achieve for large $k$ , is required to make the Gram determinant non-zero. ",
+        "bbox": [
+            145,
+            794,
+            848,
+            821
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "image",
+        "img_path": "images/3fe9bade8f08ff05364a6d8e2a7baee936a987903dffc50b0cac6374c5710223.jpg",
+        "image_caption": [
+            "Figure 1: Left and center: Learning curves for $k { \\mathrm { - M E A N S + + } }$ and $k$ -DPP sampling with gradient embeddings for different scenarios. The performance of the two sampling approaches nearly perfectly overlaps. Right: A run time comparison (seconds) corresponding to the middle scenario. Each line is the average over five independent experiments. Standard errors are shown by shaded regions. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            147,
+            133,
+            849,
+            267
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            147,
+            342,
+            852,
+            439
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Unfortunately, sampling from a $k$ -DPP is not trivial. Many sampling algorithms (Kang, 2013; Anari et al., 2016) rely on MCMC, where mixing time poses a significant computational hurdle. The state-of-the-art algorithm of Derezinski (2018) has a high-order polynomial running time in the batch size and the embedding ´ dimension. To overcome this computational hurdle, we suggest instead sampling using the $k { \\mathrm { - M E A N S + + } }$ seeding algorithm (Arthur and Vassilvitskii, 2007), originally made to produce a good initialization for $k$ -means clustering. $k { \\mathrm { - M E A N S + + } }$ seeding selects centroids by iteratively sampling points in proportion to their squared distances from the nearest centroid that has already been chosen, which, like a $k$ -DPP, tends to select a diverse batch of high-magnitude samples. For completeness, we give a formal description of the $k$ -MEA $\\mathrm { J } S + +$ seeding algorithm in Appendix A. ",
+        "bbox": [
+            147,
+            445,
+            852,
+            573
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Example: multiclass classification with softmax activations. Consider a neural network $f$ where the last nonlinearity is a softmax, i.e. $\\sigma ( z ) _ { i } = e ^ { z _ { i } } / { \\sum _ { j = 1 } ^ { K } e ^ { z _ { j } } }$ . Specifically, $f$ is parametrized by $\\theta = ( W , V )$ , where $\\theta _ { \\mathrm { o u t } } = W = ( W _ { 1 } , \\ldots , W _ { K } ) ^ { \\top } \\in \\mathbb { R } ^ { K \\times d }$ are the weights of the last layer, and $V$ consists of weights of all previous layers. This means that $f ( x ; \\theta ) = \\sigma ( W \\cdot \\bar { z } ( x ; V ) )$ , where $z$ is the nonlinear function that maps an input $x$ to the output of the network’s penultimate layer. Let us fix an unlabeled sample $x$ and define $p _ { i } = f ( x ; \\theta ) _ { i }$ . With this notation, we have ",
+        "bbox": [
+            147,
+            585,
+            852,
+            672
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/c0a77f9cb45b53e1dbc20841a41ef19cb516cd593b6a7208b585f88a23eee329.jpg",
+        "text": "$$\n\\ell _ { \\mathrm { { C E } } } ( f ( x ; \\theta ) , y ) = \\ln \\left( \\sum _ { j = 1 } ^ { K } e ^ { W _ { j } \\cdot z ( x ; V ) } \\right) - W _ { y } \\cdot z ( x ; V ) .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            310,
+            675,
+            687,
+            727
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Define $\\begin{array} { r } { g _ { x } ^ { y } = \\frac { \\partial } { \\partial W } \\ell _ { \\mathrm { C E } } ( f ( x ; \\theta ) , y ) } \\end{array}$ for a label $y$ and $g _ { x } = g _ { x } ^ { \\hat { y } }$ as the gradient embedding in our algorithm, where ${ \\hat { y } } = \\operatorname { a r g m a x } _ { i \\in [ K ] } p _ { i }$ . Then the $i$ -th block of $g _ { x }$ (i.e. the gradients corresponding to label $i$ ) is ",
+        "bbox": [
+            145,
+            737,
+            849,
+            768
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/9441310347a519c3bf0c4e0278a502b2a72f0f5cf89c8efe0a5342d05f3ee882.jpg",
+        "text": "$$\n( g _ { x } ) _ { i } = \\frac { \\partial } { \\partial W _ { i } } \\ell _ { \\mathrm { C E } } ( f ( x ; \\theta ) , \\hat { y } ) = ( p _ { i } - I ( \\hat { y } = i ) ) z ( x ; V ) .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            310,
+            772,
+            687,
+            805
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Based on this expression, we can make the following observations: ",
+        "bbox": [
+            147,
+            808,
+            586,
+            823
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "1. Each block of $g _ { x }$ is a scaling of $z ( x ; V )$ , which is the output of the penultimate layer of the network. In this respect, $g _ { x }$ captures $x$ ’s representation information similar to that of Sener and Savarese (2018). ",
+        "bbox": [
+            184,
+            119,
+            852,
+            162
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "2. Proposition 1 below shows that the norm of $g _ { x }$ is a lower bound on the norm of the loss gradient induced by the example with true label $y$ with respect to the weights in the last layer, that is $\\| g _ { x } \\| \\leq \\| \\dot { g } _ { x } ^ { y } \\|$ . This suggests that the norm of $g _ { x }$ conservatively estimates the example’s influence on the current model. ",
+        "bbox": [
+            186,
+            166,
+            852,
+            222
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "3. If the current model $\\theta$ is highly confident about $x$ , i.e. vector $p$ is skewed towards a standard basis vector $e _ { j }$ , then $\\hat { y } = j$ , and vector $( p _ { i } - I ( \\hat { y } = i ) ) _ { i = 1 } ^ { K }$ has a small length. Therefore, $g _ { x }$ has a small length as well. Such high-confidence examples tend to have gradient embeddings of small magnitude, which are unlikely to be repeatedly selected by $k { \\mathrm { - M E A N S + + } }$ at iteration $t$ . ",
+        "bbox": [
+            186,
+            227,
+            851,
+            284
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Proposition 1. For all $y \\in \\{ 1 , \\ldots , K \\}$ , let $\\begin{array} { r } { g _ { x } ^ { y } = \\frac { \\partial } { \\partial W } \\ell _ { \\mathrm { C E } } ( f ( x ; \\theta ) , y ) } \\end{array}$ . Then ",
+        "bbox": [
+            148,
+            285,
+            643,
+            304
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/1f627c49dffa6687b15a575a630b10f4186558a62c8cbad6574f787671935456.jpg",
+        "text": "$$\n\\| g _ { x } ^ { y } \\| ^ { 2 } = \\Big ( \\sum _ { i = 1 } ^ { K } p _ { i } ^ { 2 } + 1 - 2 p _ { y } \\Big ) \\| z ( x ; V ) \\| ^ { 2 } .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            357,
+            309,
+            638,
+            352
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Consequently, ${ \\hat { y } } = \\operatorname { a r g m i n } _ { y \\in [ K ] } \\left\\| g _ { x } ^ { y } \\right\\|$ . ",
+        "bbox": [
+            148,
+            356,
+            400,
+            373
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Proof. Observe that by Equation (1), ",
+        "bbox": [
+            148,
+            386,
+            390,
+            401
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/186ef9f07fafdec057c5d4f7fa9b5bc24cf0fd602b6e46330071731b7cdd09b1.jpg",
+        "text": "$$\n\\| g _ { x } ^ { y } \\| ^ { 2 } = \\sum _ { i = 1 } ^ { K } \\left( p _ { i } - I ( y = i ) \\right) ^ { 2 } \\| z ( x ; V ) \\| ^ { 2 } = \\Big ( \\sum _ { i = 1 } ^ { K } p _ { i } ^ { 2 } + 1 - 2 p _ { y } \\Big ) \\| z ( x ; V ) \\| ^ { 2 } .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            241,
+            406,
+            756,
+            449
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "The second claim follows from the fact that yˆ = argmaxy∈[K] py. ",
+        "bbox": [
+            147,
+            454,
+            578,
+            469
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "This simple sampler tends to produce diverse batches similar to a $k$ -DPP. As shown in Figure 1, switching between the two samplers does not affect the active learner’s statistical performance but greatly improves its computational performance. Appendix G compares run time and test accuracy for both $k$ -MEANS $^ { + + }$ and $k$ -DPP based sampling based on the gradient embeddings of the unlabeled examples. ",
+        "bbox": [
+            147,
+            474,
+            852,
+            531
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Figure 2 illustrates the batch diversity and average gradient magnitude per selected batch for a variety of sampling strategies. As expected, both $k$ -DPPs and $k { \\mathrm { - M E A N S + + } }$ tend to select samples that are diverse (as measured by the magnitude of their Gram determinant) and high magnitude. Other samplers, such as furthest-first traversal for $k$ -Center clustering (FF- $k$ -CENTER), do not seem to have this property. The FF- $k$ -CENTER algorithm is the sampling choice of the CORESET approach to active learning, which we describe in the proceeding section (Sener and Savarese, 2018). Appendix F discusses diversity with respect to uncertainty-based approaches. ",
+        "bbox": [
+            147,
+            536,
+            851,
+            635
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Appendix B provides further justification for why BADGE yields better updates than vanilla uncertainty sampling in the special case of binary logistic regression $K = 2$ and $z ( x ; V ) = x $ ). ",
+        "bbox": [
+            145,
+            641,
+            849,
+            670
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "4 EXPERIMENTS ",
+        "text_level": 1,
+        "bbox": [
+            148,
+            683,
+            300,
+            699
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "We evaluate the performance of BADGE against several algorithms from the literature. In our experiments, we seek to answer the following question: How robust are the learning algorithms to choices of neural network architecture, batch size, and dataset? ",
+        "bbox": [
+            148,
+            703,
+            851,
+            746
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "To ensure a comprehensive comparison among all algorithms, we evaluate them in a batch-mode active learning setup with $M = 1 0 0$ being the number of initial random labeled examples and batch size $B$ varying from $\\{ 1 0 0 , 1 0 0 0 , 1 0 0 0 0 \\}$ . The following is a list of the baseline algorithms evaluated; the first performs representative sampling, the next three are uncertainty based, the fifth is a hybrid of representative and uncertainty-based approaches, and the last is traditional supervised learning. ",
+        "bbox": [
+            148,
+            752,
+            851,
+            823
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "image",
+        "img_path": "images/e9edd9bc4085eb347e0355361c980da855565eadfb3c1c4c32469cc726e95c60.jpg",
+        "image_caption": [
+            "Figure 2: A comparison of batch selection algorithms using our gradient embedding. Left and center: Plots showing the log determinant of the Gram matrix of the selected batch of gradient embeddings as learning progresses. Right: The average embedding magnitude (a measurement of predictive uncertainty) in the selected batch. The FF- $k$ -CENTER sampler finds points that are not as diverse or high-magnitude as other samplers. Notice also that $k { \\mathrm { - M E A N S + + } }$ tends to actually select samples that are both more diverse and higher-magnitude than a $k$ -DPP, a potential pathology of the $k$ -DPP’s degree of stochastisity. Standard errors are shown by shaded regions. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            153,
+            132,
+            846,
+            276
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "1. CORESET: A diversity-based approach using coreset selection. The embedding of each example is computed by the network’s penultimate layer and the samples at each round are selected using a greedy furthest-first traversal conditioned on all labeled examples (Sener and Savarese, 2018).   \n2. CONF (Confidence Sampling): An uncertainty-based active learning algorithm that selects $B$ examples with smallest predicted class probability, $\\operatorname* { m a x } _ { i = 1 } ^ { K } f ( x ; \\theta ) _ { i }$ (e.g. Wang and Shang, 2014).   \n3. MARG (Margin Sampling): An uncertainty-based active learning algorithm that selects the bottom $B$ examples sorted according to the example’s multiclass margin, defined as $f ( x ; \\theta ) _ { \\hat { y } } - f ( x ; \\theta ) _ { y ^ { \\prime } }$ , where $\\hat { y }$ and $y ^ { \\prime }$ are the indices of the largest and second largest entries of $f ( x ; \\theta )$ (Roth and Small, 2006).   \n4. ENTROPY: An uncertainty-based active learning algorithm that selects the top $B$ examples according to the entropy of the example’s predictive class probability distribution, defined as $H ( ( f ( x ; \\theta ) _ { y } ) _ { y = 1 } ^ { K } )$ , where $\\begin{array} { r } { H ( p ) = \\sum _ { i = 1 } ^ { K ^ { - } } p _ { i } \\ln ^ { - } \\Bigr / p _ { i } } \\end{array}$ (Wang and Shang, 2014).   \n5. ALBL (Active Learning by Learning): A bandit-style meta-active learning algorithm that selects between CORESET and CONF at every round (Hsu and Lin, 2015).   \n6. RAND: The naive baseline of randomly selecting $k$ examples to query at each round. ",
+        "bbox": [
+            184,
+            411,
+            852,
+            632
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "We consider three neural network architectures: a two-layer Perceptron with ReLU activations (MLP), an 18-layer convolutional ResNet (He et al., 2016), and an 11-layer VGG network (Simonyan and Zisserman, 2014). We evaluate our algorithms using three image datasets, SVHN (Netzer et al., 2011), CIFAR10 (Krizhevsky, 2009) and MNIST (LeCun et al., 1998) 1, and four non-image datasets from the OpenML repository (#6, #155, #156, and #184). 2 We study each situation with 7 active learning algorithms, including BADGE, making for 231 total experiments. ",
+        "bbox": [
+            147,
+            641,
+            852,
+            726
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "For the image datasets, the embedding dimensionality in the MLP is 256. For the OpenML datasets, the embedding dimensionality of the MLP is 1024, as more capacity helps the model fit training data. We fit models using cross-entropy loss and the Adam variant of SGD until training accuracy exceeds $9 9 \\%$ . We use a learning rate of 0.001 for image data and of 0.0001 for non-image data. We avoid warm starting and retrain models from scratch every time new samples are queried (Ash and Adams, 2019). All experiments are repeated five times. No learning rate schedules or data augmentation are used. Baselines use implementations from the libact library (Yang et al., 2017). All models are trained in PyTorch (Paszke et al., 2017). ",
+        "bbox": [
+            148,
+            732,
+            848,
+            761
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "image",
+        "img_path": "images/862b919b13024e0ae4ccf8ea1350510ffaca7bdbca2409f37db62423dba2128a.jpg",
+        "image_caption": [
+            "Figure 3: Active learning test accuracy versus the number of total labeled samples for a range of conditions. Standard errors are shown by shaded regions. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            155,
+            113,
+            831,
+            292
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            148,
+            345,
+            851,
+            415
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Learning curves. Here we show examples of learning curves that highlight some of the phenomena we observe related to the fragility of active learning algorithms with respect to batch size, architecture, and dataset. ",
+        "bbox": [
+            143,
+            425,
+            852,
+            454
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Often, we see that in early rounds of training, it is better to do diversity sampling, and later in training, it is better to do uncertainty sampling. This kind of event is demonstrated in Figure 3a, which shows CORESET outperforming confidence-based methods at first, but then doing worse than these methods later on. ",
+        "bbox": [
+            148,
+            460,
+            851,
+            502
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "In this figure, BADGE performs as well as diversity sampling when that strategy does best, and as well as uncertainty sampling once those methods start outpacing CORESET. This suggests that BADGE is a good choice regardless of labeling budget. ",
+        "bbox": [
+            148,
+            510,
+            485,
+            579
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Separately, we notice that diversity sampling only seems to work well when either the model has good architectural priors (inductive biases) built in, or when the data are easy to learn. Otherwise, penultimate layer representations are not meaningful, and diverse sampling can be deleterious. For this reason, CORESET often performs worse than random on sufficiently complex data when not using a convolutional network (Figure 3b). That is, the diversity induced by unconditional random sampling can often yield a batch that better represents the data. Even when batch size is large and the model has helpful inductive biases, the uncertainty information in BADGE can give it an advantage over pure diversity approaches (Figure 3c). Comprehensive plots of this kind, spanning architecture, dataset, and batch size are in Appendix C. ",
+        "bbox": [
+            148,
+            587,
+            485,
+            823
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/b6198f1f5a9453b9546972ece2536fc119869120e54d54025af727432c2cd297.jpg",
+        "image_caption": [
+            "Figure 4: A pairwise penalty matrix over all experiments. Element $P _ { i , j }$ corresponds roughly to the number of times algorithm $_ { i }$ outperforms algorithm $j$ . Column-wise averages at the bottom show overall performance (lower is better). "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            496,
+            512,
+            849,
+            761
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Pairwise comparisons. We next show a comprehensive pairwise comparison of algorithms over all datasets $( D )$ , batch sizes $( B )$ , model architectures $( A )$ , and label budgets $( L )$ . From the learning curves, it can be observed that when label budgets are large enough, all algorithms eventually reach similar performance, making the comparison between them uninteresting in the large sample limit. For this reason, for each combination of $( D , B , { \\bar { A } } )$ , we select a set of labeling budgets $L$ where learning is still progressing. We experimented with three different batch sizes and eleven dataset-architecture pairs, making the total number of $( D , B , A )$ combinations $3 \\times 1 1 = 3 3$ . Specifically, we compute $n _ { 0 }$ , the smallest number of labels where RAND’s accuracy reaches $9 9 \\%$ of its final accuracy, and choose label budget $L$ from $\\big \\{ M + 2 ^ { m - 1 } B : m \\in [ \\lfloor \\log ( ( n _ { 0 } - \\dot { M } ) / B ) \\rfloor ] \\big \\} .$ . The calculation of scores in the penalty matrix $P$ follows the following protocol: For each $( D , B , A , L )$ combination and each pair of algorithms $( i , j )$ , we have 5 test errors (one for each repeated run), $\\big \\{ e _ { i } ^ { 1 } , \\ldots , e _ { i } ^ { 5 } \\big \\}$ and $\\big \\{ e _ { j } ^ { 1 } , \\ldots , e _ { j } ^ { 5 } \\big \\}$ respectively. We compute the $t$ -score as $\\begin{array} { c c l } { t } & { = } & { \\sqrt { 5 } \\hat { \\mu } / \\hat { \\sigma } } \\end{array}$ , where ",
+        "bbox": [
+            147,
+            119,
+            852,
+            277
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "equation",
+        "img_path": "images/32eeed035433770dcd2fc45f0a5eb44ee367692d933f0fc9411bc45e38f7149f.jpg",
+        "text": "$$\n\\hat { \\mu } = \\frac { 1 } { 5 } \\sum _ { l = 1 } ^ { 5 } ( e _ { i } ^ { l } - e _ { j } ^ { l } ) , ~ \\hat { \\sigma } = \\sqrt { \\frac { 1 } { 4 } \\sum _ { l = 1 } ^ { 5 } ( e _ { i } ^ { l } - e _ { j } ^ { l } - \\hat { \\mu } ) ^ { 2 } } .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            166,
+            289,
+            500,
+            335
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "We use the two-sided $t$ -test to compare pairs of algorithms: algorithm $i$ is said to beat algorithm $j$ in this setting if $t ~ > ~ 2 . 7 7 6$ (the critical point of $p$ -value being 0.05), and similarly algorithm $j$ beats algorithm $i$ if $t < - 2 . 7 7 6$ . For each $( D , B , A )$ combination, suppose there are ${ } ^ { n } D , B , A$ different values of $L$ . Then, for each $L$ , if algorithm $i$ beats algorithm $j$ , we accumulate a penalty of $1 / n _ { D , B , A }$ to $P _ { i , j }$ ; otherwise, if algorithm $j$ beats algorithm $i$ , we accumulate a penalty of $1 / n _ { D , B , A }$ to $P _ { j , i }$ The choice of the penalty value $1 / n _ { D , B , A }$ is to ensure that every $( D , B , A )$ combination is assigned equal influence in the aggregated matrix. Therefore, the largest entry of $P$ is at most 33, the total number of $( D , B , A )$ combinations. ",
+        "bbox": [
+            148,
+            344,
+            521,
+            525
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "image",
+        "img_path": "images/8aea56706be71d726b40aab86de0168f6950ac1a8c1af6affb837d9b574a0b9b.jpg",
+        "image_caption": [
+            "Figure 5: The cumulative distribution function of normalized errors for all acquisition functions. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            539,
+            290,
+            846,
+            462
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Intuitively, each row $i$ indicates the number of settings in which algorithm $i$ beats other algorithms and each column $j$ indicates the number of settings in which algorithm $j$ is beaten by another algorithm. ",
+        "bbox": [
+            148,
+            525,
+            852,
+            553
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "The penalty matrix in Figure 4 summarizes all experiments, showing that BADGE generally outperforms baselines. Matrices grouped by batch size and architecture in Appendix D show a similar trend. ",
+        "bbox": [
+            148,
+            560,
+            851,
+            589
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Cumulative distribution functions of normalized errors. For each $( D , B , A , L )$ combination, we compute the average error for each algorithm $i$ as $\\textstyle { \\bar { e } } _ { i } = { \\frac { 1 } { 5 } } \\sum _ { l = 1 } ^ { 5 } e _ { i } ^ { l }$ . To ensure that the errors of the algorithms are on the same scale in all settings, we compute the normalized error of every algorithm $i$ $\\mathrm { n e } _ { i } = \\bar { e } _ { i } / \\bar { e } _ { r }$ , where $r$ is the index of the RAND algorithm. By definition, the normalized errors of the RAND algorithm are identically 1 in all settings. Like with penalty matrices, for each $( D , B , A )$ combination, we only consider a subset of $L$ values from the set $\\big \\{ M + 2 ^ { m - 1 } B : m \\in [ \\lfloor \\log ( ( n _ { 0 } - M ) / B ) \\rfloor ] \\big \\}$ . We assign a weight proportional to $1 / n _ { D , B , A }$ to each $( D , B , A , L )$ combination, where there are ${ } ^ { n } D , B , A$ different $L$ values for this combination of $( D , B , A )$ . We then plot the cumulative distribution functions (CDFs) of the normalized errors of all algorithms: for a value of $x$ , the $y$ value is the total weight of settings where the algorithm has normalized error at most $x$ ; in general, an algorithm that has a higher CDF value has better performance. ",
+        "bbox": [
+            147,
+            601,
+            852,
+            746
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "We plot the generated CDFs in Figures 5, 22 and 23. We can see from Figure 5 that BADGE has the best overall performance. In addition, from Figures 22 and 23 in Appendix E, we can conclude that when batch size is small (100 or 1000) or when an MLP is used, both BADGE and MARG perform best. However, in the regime when the batch size is large (10000), MARG’s performance degrades, while BADGE, ALBL and CORESET are the best performing approaches. ",
+        "bbox": [
+            148,
+            752,
+            851,
+            823
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "5 RELATED WORK ",
+        "text_level": 1,
+        "bbox": [
+            148,
+            118,
+            313,
+            135
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Active learning is a been well-studied problem (Settles, 2010; Dasgupta, 2011; Hanneke, 2014). There are two major strategies for active learning—representative sampling and uncertainty sampling. ",
+        "bbox": [
+            150,
+            166,
+            851,
+            195
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Representative sampling algorithms select batches of unlabeled examples that are representative of the unlabeled set to ask for labels. It is based on the intuition that the sets of representative examples chosen, once labeled, can act as a surrogate for the full dataset. Consequently, performing loss minimization on the surrogate suffices to ensure a low error with respect to the full dataset. In the context of deep learning, Sener and Savarese (2018); Geifman and El-Yaniv (2017) select representative examples based on core-set construction, a fundamental problem in computational geometry. Inspired by generative adversarial learning, Gissin and Shalev-Shwartz (2019) select samples that are maximally indistinguishable from the pool of unlabeled examples. ",
+        "bbox": [
+            148,
+            202,
+            852,
+            314
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "On the other hand, uncertainty sampling is based on a different principle—to select new samples that maximally reduce the uncertainty the algorithm has on the target classifier. In the context of linear classification, Tong and Koller (2001); Schohn and Cohn (2000); Tur et al. (2005) propose uncertainty sampling methods that query examples that lie closest to the current decision boundary. Some uncertainty sampling approaches have theoretical guarantees on statistical consistency (Hanneke, 2014; Balcan et al., 2006). Such methods have also been recently generalized to deep learning. For instance, Gal et al. (2017) use Dropout as an approximation of the posterior of the model parameters, and develop information-based uncertainty reduction criteria; inspired by recent advances on adversarial examples generation, Ducoffe and Precioso (2018) use the distance between an example and one of its adversarial examples as an approximation of its distance to the current decision boundary, and uses it as the criterion of label queries. An ensemble of classifiers could also be used to effectively estimate uncertainty (Beluch et al., 2018). ",
+        "bbox": [
+            148,
+            320,
+            851,
+            473
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "There are several existing approaches that support a hybrid of representative sampling and uncertainty sampling. For example, Baram et al. (2004); Hsu and Lin (2015) present meta-active learning algorithms that can combine the advantages of different active learning algorithms. Inspired by expected loss minimization, Huang et al. (2010) develop label query criteria that balances between the representativeness and informativeness of examples. Another method for this is Active Learning by Learning (Hsu and Lin, 2015), which can select whether to exercise a diversity based algorithm or an uncertainty based algorithm at each round of training as a sequential decision process. ",
+        "bbox": [
+            148,
+            481,
+            852,
+            578
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "There is also a large body of literature on batch mode active learning, where the learner is asked to select a batch of samples within each round (Guo and Schuurmans, 2008; Wang and Ye, 2015; Chen and Krause; Wei et al., 2015; Kirsch et al., 2019). In these works, batch selection is often formulated as an optimization problem with objectives based on (upper bounds of) average log-likelihood, average squared loss, etc. ",
+        "bbox": [
+            148,
+            585,
+            851,
+            641
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "A different query criterion based on expected gradient length (EGL) has been proposed in the as well (Settles et al., 2008). In recent work, Huang et al. (2016) show that the EGL criterion is related to the $T$ -optimality criterion in experimental design. They further demonstrate that the samples selected by EGL are very different from those by entropy-based uncertainty criterion. Zhang et al. (2017a) use the EGL criterion in active sentence and document classification with CNNs. These approaches differ most substantially from BADGE in that they do not take into account the diversity of the examples queried within each batch. ",
+        "bbox": [
+            148,
+            647,
+            849,
+            732
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "There is a wide array of theoretical articles that focus on the related problem of adaptive subsampling for fully-labeled datasets in regression settings (Han et al., 2016; Wang et al., 2018; Ting and Brochu, 2018). Empirical studies of batch stochastic gradient descent also employ adaptive sampling to “emphasize” hard or representative examples (Zhang et al., 2017b; Chang et al., 2017). These works aim at reducing computation costs or finding a better local optimal solution, as opposed to reducing label costs. Nevertheless, our work is inspired by their sampling criteria, which also emphasize samples that induce large updates to the model. ",
+        "bbox": [
+            148,
+            738,
+            851,
+            821
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "As mentioned earlier, our sampling criterion has resemblance to sampling from $k$ -determinantal point processes (Kulesza and Taskar, 2011). Note that in multiclass classification settings, our gradient-based embedding of an example can be viewed as the outer product of the original embedding in the penultimate layer and a probability score vector that encodes the uncertainty information on this example (see Section 3). In this view, the penultimate layer embedding characterizes the diversity of each example, whereas the probability score vector characterizes the quality of each example. The $k$ -DPP is also a natural probabilistic tool for sampling that trades off between quality and diversity (See Kulesza et al., 2012, Section 3.1). We remark that concurrent to our work, Bıyık et al. (2019) develops $k$ -DPP based active learning algorithms based on this principle by explicitly designing diversity and uncertainty measures. ",
+        "bbox": [
+            148,
+            119,
+            851,
+            246
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "6 DISCUSSION ",
+        "text_level": 1,
+        "bbox": [
+            148,
+            266,
+            284,
+            282
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "We have established that BADGE is empirically an effective deep active learning algorithm across different architectures and batch sizes, performing similar to or better than other active learning algorithms. A fundamental remaining question is: \"Why?\" While deep learning is notoriously difficult to analyze theoretically, there are several intuitively appealing properties of BADGE: ",
+        "bbox": [
+            148,
+            297,
+            852,
+            354
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "1. The definition of uncertainty (a lower bound on the gradient magnitude of the last layer) guarantees some update of parameters. 2. It optimizes for diversity as well as uncertainty, eliminating a failure mode of choosing many identical uncertain examples in a batch, and does so without requiring any hyperparameters. 3. The randomization associated with the $k { \\mathrm { - M E A N S + + } }$ initialization sampler implies that, even for adversarially constructed datasets, it eventually converges to a good solution. ",
+        "bbox": [
+            184,
+            366,
+            852,
+            460
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "The combination of these properties appears to generate the robustness that we observe empirically. ",
+        "bbox": [
+            155,
+            465,
+            802,
+            481
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "REFERENCES ",
+        "text_level": 1,
+        "bbox": [
+            148,
+            501,
+            259,
+            516
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "David Cohn, Les Atlas, and Richard Ladner. Improving generalization with active learning. Machine learning, 1994.   \nMaria-Florina Balcan, Alina Beygelzimer, and John Langford. Agnostic active learning. In International Conference on Machine Learning, 2006.   \nAlina Beygelzimer, Daniel J Hsu, John Langford, and Tong Zhang. Agnostic active learning without constraints. In Neural Information Processing Systems, 2010.   \nNicolo Cesa-Bianchi, Claudio Gentile, and Francesco Orabona. Robust bounds for classification via selective sampling. In International Conference on Machine Learning, 2009.   \nDavid Arthur and Sergei Vassilvitskii. k-means $^ { + + }$ : The advantages of careful seeding. In ACM-SIAM symposium on Discrete algorithms, 2007.   \nAlex Kulesza and Ben Taskar. k-dpps: Fixed-size determinantal point processes. In International Conference on Machine Learning, 2011.   \nMichał Derezinski and Manfred K Warmuth. Reverse iterative volume sampling for linear regression. ´ The Journal of Machine Learning Research, 19(1), 2018.   \nByungkon Kang. Fast determinantal point process sampling with application to clustering. In Neural Information Processing Systems, 2013. ",
+        "bbox": [
+            145,
+            523,
+            854,
+            824
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Nima Anari, Shayan Oveis Gharan, and Alireza Rezaei. Monte carlo markov chain algorithms for sampling strongly rayleigh distributions and determinantal point processes. In Conference on Learning Theory, 2016. ",
+        "bbox": [
+            145,
+            119,
+            852,
+            150
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Michał Derezinski. Fast determinantal point processes via distortion-free intermediate sampling. ´ arXiv preprint, 2018. ",
+        "bbox": [
+            148,
+            156,
+            848,
+            186
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Ozan Sener and Silvio Savarese. Active learning for convolutional neural networks: A core-set approach. In International Conference on Learning Representations, 2018. ",
+        "bbox": [
+            148,
+            194,
+            848,
+            224
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Dan Wang and Yi Shang. A new active labeling method for deep learning. In 2014 International joint conference on neural networks, 2014. ",
+        "bbox": [
+            147,
+            231,
+            849,
+            261
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Dan Roth and Kevin Small. Margin-based active learning for structured output spaces. In European Conference on Machine Learning, 2006. ",
+        "bbox": [
+            145,
+            267,
+            849,
+            297
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Wei-Ning Hsu and Hsuan-Tien Lin. Active learning by learning. In Association for the advancement of artificial intelligence, 2015. ",
+        "bbox": [
+            148,
+            305,
+            851,
+            335
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Kaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. Deep residual learning for image recognition. In Proceedings of the IEEE conference on computer vision and pattern recognition, pages 770–778, 2016. ",
+        "bbox": [
+            147,
+            342,
+            851,
+            372
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Karen Simonyan and Andrew Zisserman. Very deep convolutional networks for large-scale image recognition. arXiv preprint, 2014. ",
+        "bbox": [
+            147,
+            380,
+            851,
+            409
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Yuval Netzer, Tao Wang, Adam Coates, Alessandro Bissacco, Bo Wu, and Andrew Y Ng. Reading digits in natural images with unsupervised feature learning. 2011. ",
+        "bbox": [
+            147,
+            416,
+            851,
+            446
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Alex Krizhevsky. Learning multiple layers of features from tiny images. Technical report, Citeseer, 2009. ",
+        "bbox": [
+            148,
+            454,
+            843,
+            470
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Yann LeCun, Léon Bottou, Yoshua Bengio, Patrick Haffner, et al. Gradient-based learning applied to document recognition. IEEE, 1998. ",
+        "bbox": [
+            143,
+            477,
+            849,
+            507
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Jordan T Ash and Ryan P Adams. On the difficulty of warm-starting neural network training. arXiv preprint, 2019. ",
+        "bbox": [
+            145,
+            513,
+            852,
+            544
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Yao-Yuan Yang, Shao-Chuan Lee, Yu-An Chung, Tung-En Wu, Si-An Chen, and Hsuan-Tien Lin. libact: Pool-based active learning in python. arXiv preprint, 2017. ",
+        "bbox": [
+            143,
+            551,
+            852,
+            582
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Adam Paszke, Sam Gross, Soumith Chintala, Gregory Chanan, Edward Yang, Zachary DeVito, Zeming Lin, Alban Desmaison, Luca Antiga, and Adam Lerer. Automatic differentiation in pytorch. 2017. ",
+        "bbox": [
+            147,
+            588,
+            852,
+            618
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Burr Settles. Active learning literature survey. University of Wisconsin, Madison, 2010. ",
+        "bbox": [
+            145,
+            626,
+            723,
+            642
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Sanjoy Dasgupta. Two faces of active learning. Theoretical computer science, 2011. ",
+        "bbox": [
+            147,
+            648,
+            700,
+            665
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Steve Hanneke. Theory of disagreement-based active learning. Foundations and Trends in Machine Learning, 2014. ",
+        "bbox": [
+            147,
+            672,
+            854,
+            702
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Yonatan Geifman and Ran El-Yaniv. Deep active learning over the long tail. arXiv preprint, 2017. ",
+        "bbox": [
+            147,
+            709,
+            790,
+            726
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Daniel Gissin and Shai Shalev-Shwartz. Discriminative active learning. arXiv preprint, 2019. ",
+        "bbox": [
+            147,
+            733,
+            763,
+            750
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Simon Tong and Daphne Koller. Support vector machine active learning with applications to text classification. Journal of machine learning research, 2001. ",
+        "bbox": [
+            145,
+            756,
+            851,
+            786
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Greg Schohn and David Cohn. Less is more: Active learning with support vector machines. In International Conference on Machine Learning, 2000. ",
+        "bbox": [
+            147,
+            794,
+            849,
+            823
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Gokhan Tur, Dilek Hakkani-Tür, and Robert E Schapire. Combining active and semi-supervised learning for spoken language understanding. Speech Communication, 2005. ",
+        "bbox": [
+            143,
+            119,
+            852,
+            148
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Yarin Gal, Riashat Islam, and Zoubin Ghahramani. Deep bayesian active learning with image data. In International Conference on Machine Learning, 2017. ",
+        "bbox": [
+            151,
+            159,
+            849,
+            188
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Melanie Ducoffe and Frederic Precioso. Adversarial active learning for deep networks: a margin based approach. arXiv preprint, 2018. ",
+        "bbox": [
+            147,
+            196,
+            849,
+            227
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "William H Beluch, Tim Genewein, Andreas Nürnberger, and Jan M Köhler. The power of ensembles for active learning in image classification. In IEEE Conference on Computer Vision and Pattern Recognition, 2018. ",
+        "bbox": [
+            147,
+            236,
+            854,
+            279
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Yoram Baram, Ran El Yaniv, and Kobi Luz. Online choice of active learning algorithms. Journal of Machine Learning Research, 2004. ",
+        "bbox": [
+            148,
+            289,
+            851,
+            318
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Sheng-Jun Huang, Rong Jin, and Zhi-Hua Zhou. Active learning by querying informative and representative examples. In Neural Information Processing Systems, 2010. ",
+        "bbox": [
+            143,
+            327,
+            851,
+            357
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Yuhong Guo and Dale Schuurmans. Discriminative batch mode active learning. In Neural Information Processing Systems, 2008. ",
+        "bbox": [
+            147,
+            366,
+            849,
+            395
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Zheng Wang and Jieping Ye. Querying discriminative and representative samples for batch mode active learning. Transactions on Knowledge Discovery from Data, 2015. ",
+        "bbox": [
+            147,
+            405,
+            851,
+            435
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Yuxin Chen and Andreas Krause. Near-optimal batch mode active learning and adaptive submodular optimization. In International Conference on Machine Learning. ",
+        "bbox": [
+            147,
+            444,
+            849,
+            474
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Kai Wei, Rishabh Iyer, and Jeff Bilmes. Submodularity in data subset selection and active learning. In International Conference on Machine Learning, 2015. ",
+        "bbox": [
+            148,
+            483,
+            848,
+            512
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Andreas Kirsch, Joost van Amersfoort, and Yarin Gal. Batchbald: Efficient and diverse batch acquisition for deep bayesian active learning. In Neural Information Processing Systems 32, 2019. ",
+        "bbox": [
+            145,
+            521,
+            848,
+            551
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Burr Settles, Mark Craven, and Soumya Ray. Multiple-instance active learning. In Neural Information Processing Systems, 2008. ",
+        "bbox": [
+            148,
+            559,
+            848,
+            589
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Jiaji Huang, Rewon Child, and Vinay Rao. Active learning for speech recognition: the power of gradients. arXiv preprint, 2016. ",
+        "bbox": [
+            143,
+            599,
+            849,
+            628
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Ye Zhang, Matthew Lease, and Byron C Wallace. Active discriminative text representation learning. In AAAI Conference on Artificial Intelligence, 2017a. ",
+        "bbox": [
+            147,
+            637,
+            848,
+            667
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Lei Han, Kean Ming Tan, Ting Yang, and Tong Zhang. Local uncertainty sampling for large-scale multi-class logistic regression. arXiv preprint, 2016. ",
+        "bbox": [
+            142,
+            676,
+            849,
+            707
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "HaiYing Wang, Rong Zhu, and Ping Ma. Optimal subsampling for large sample logistic regression. Journal of the American Statistical Association, 2018. ",
+        "bbox": [
+            142,
+            715,
+            851,
+            744
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Daniel Ting and Eric Brochu. Optimal subsampling with influence functions. In Neural Information Processing Systems, 2018. ",
+        "bbox": [
+            145,
+            753,
+            849,
+            784
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Cheng Zhang, Hedvig Kjellstrom, and Stephan Mandt. Determinantal point processes for mini-batch diversification. Uncertainty in Artificial Intelligence, 2017b. ",
+        "bbox": [
+            145,
+            794,
+            848,
+            823
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Haw-Shiuan Chang, Erik Learned-Miller, and Andrew McCallum. Active bias: Training more accurate neural networks by emphasizing high variance samples. In Neural Information Processing Systems, 2017. ",
+        "bbox": [
+            145,
+            119,
+            851,
+            148
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Alex Kulesza, Ben Taskar, et al. Determinantal point processes for machine learning. Foundations and Trends in Machine Learning, 2012. ",
+        "bbox": [
+            147,
+            156,
+            849,
+            185
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Erdem Bıyık, Kenneth Wang, Nima Anari, and Dorsa Sadigh. Batch active learning using determinantal point processes. arXiv preprint, 2019. ",
+        "bbox": [
+            147,
+            193,
+            848,
+            222
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Stephen Mussmann and Percy S Liang. Uncertainty sampling is preconditioned stochastic gradient descent on zero-one loss. In Neural Information Processing Systems, 2018. ",
+        "bbox": [
+            147,
+            228,
+            849,
+            258
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "A THE $k$ -MEA ${ . N S + + }$ SEEDING ALGORITHM ",
+        "text_level": 1,
+        "bbox": [
+            148,
+            282,
+            513,
+            299
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Here we briefly review the $k { \\mathrm { - M E A N S + + } }$ seeding algorithm by (Arthur and Vassilvitskii, 2007). Its basic idea is to perform sequential sampling of $k$ centers, where each new center is sampled from the ground set with probability proportional to the squared distance to its nearest center. It is shown in (Arthur and Vassilvitskii, 2007) that the set of centers returned is guaranteed to approximate the $k$ -means objective function in expectation, thus ensuring diversity. ",
+        "bbox": [
+            147,
+            313,
+            851,
+            383
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Algorithm 2 The $k$ -MEANS++ seeding algorithm (Arthur and Vassilvitskii, 2007) ",
+        "text_level": 1,
+        "bbox": [
+            147,
+            397,
+            683,
+            411
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Require: Ground set $G \\subset \\mathbb { R } ^ { d }$ , target size $k$ .   \nEnsure: Center set $C$ of size $k$ . $C _ { 1 } \\gets \\{ c _ { 1 } \\}$ , where $c _ { 1 }$ is sampled uniformly at random from $G$ . for $t = 2 , \\ldots , k$ : do Define $D _ { t } ( x ) : = \\mathrm { m i n } _ { c \\in C _ { t - 1 } } \\| x - c \\| _ { 2 }$ . $c _ { t } \\gets$ Sample $x$ from $G$ with probability $\\frac { D _ { t } ( x ) ^ { 2 } } { \\sum _ { x \\in G } D _ { t } ( x ) ^ { 2 } }$ . $C _ { t } \\gets C _ { t - 1 } \\cup \\{ c _ { t } \\} _ { }$ . end for return $C _ { k }$ . ",
+        "bbox": [
+            147,
+            415,
+            576,
+            555
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "B BADGE FOR BINARY LOGISTIC REGRESSION ",
+        "text_level": 1,
+        "bbox": [
+            148,
+            582,
+            558,
+            598
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "We consider instantiating BADGE for binary logistic regression, where $\\mathcal { V } = \\{ - 1 , + 1 \\}$ . Given a linear classifier $w$ , we define the predictive probability of $w$ on $x$ as $p _ { w } ( y | x , \\theta ) = \\sigma ( y w \\cdot x )$ , where $\\begin{array} { r } { \\sigma ( z ) = \\frac { 1 } { 1 + e ^ { - z } } } \\end{array}$ is the sigmoid funciton. ",
+        "bbox": [
+            147,
+            612,
+            852,
+            656
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Recall that ${ \\hat { y } } = { \\hat { y } } ( x )$ is the hallucinated label: ",
+        "bbox": [
+            147,
+            662,
+            447,
+            678
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "equation",
+        "img_path": "images/761d32e1fc0ea3a16b3cc392c02bb4a4bc88fb94d123a527dc896c44b63172ea.jpg",
+        "text": "$$\n\\hat { y } ( x ) = \\left\\{ { \\begin{array} { l l } { + 1 , } & { p _ { w } ( + 1 | x , \\theta ) > 1 / 2 , } \\\\ { - 1 , } & { p _ { w } ( + 1 | x , \\theta ) \\leq 1 / 2 . } \\end{array} } \\right.\n$$",
+        "text_format": "latex",
+        "bbox": [
+            375,
+            683,
+            620,
+            718
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "The binary logistic loss of classifier $w$ on example $( x , y )$ is defined as: ",
+        "bbox": [
+            148,
+            729,
+            609,
+            744
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "equation",
+        "img_path": "images/e12959b2bd715346b53c680fd61135d51d59b955ba6bea4935589b7e90cd23d7.jpg",
+        "text": "$$\n\\ell ( w , ( x , y ) ) = \\ln ( 1 + \\exp ( - y w \\cdot x ) ) .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            372,
+            747,
+            622,
+            765
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Now, given model $w$ and example $x$ , we define $\\begin{array} { r } { \\hat { g } _ { x } = \\frac { \\partial } { \\partial w } \\ell ( w , ( x , \\hat { y } ) ) = ( 1 - p _ { w } ( \\hat { y } | x , \\theta ) ) \\cdot ( - \\hat { y } \\cdot x ) } \\end{array}$ as the loss gradient induced by the example with hallucinated label, and $\\begin{array} { r } { \\tilde { g } _ { x } = \\frac { \\partial } { \\partial w } \\ell ( w , ( x , y ) ) = ( 1 - p _ { w } ( y | x , \\theta ) ) \\cdot ( - y \\cdot x ) } \\end{array}$ as the loss gradient induced by the example with true label. ",
+        "bbox": [
+            147,
+            776,
+            852,
+            823
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "image",
+        "img_path": "images/eb67dcecb5e582087261eb4ed09d95f125d1a62a5adfb0b8d0f0f0be6bba3e0a.jpg",
+        "image_caption": [
+            "Figure 6: Full learning curves for OpenML #6 with MLP. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            145,
+            131,
+            849,
+            282
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "image",
+        "img_path": "images/1c591f31c495cb4e2c3d089926a4a9dcc80732c6e0a95a3492a7a4b106da884d.jpg",
+        "image_caption": [
+            "Figure 7: Full learning curves for OpenML #155 with MLP. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            145,
+            335,
+            852,
+            486
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "Suppose that BADGE only selects examples from region $S _ { w } = \\{ x : w \\cdot x = 0 \\}$ , then as $p _ { w } ( + 1 | x , \\theta ) =$ $\\begin{array} { r } { p _ { w } \\big ( - 1 | x , \\theta \\big ) = \\frac { 1 } { 2 } } \\end{array}$ , we have that for all $x$ in $S _ { w }$ , $\\hat { g } _ { x } = s _ { x } \\cdot g _ { x }$ for some $s _ { x } \\in \\{ \\pm 1 \\}$ . This implies that, sampling from a DPP induced by ${ \\hat { g } } _ { x }$ ’s is equivalent to sampling from a DPP induced by $g _ { x }$ ’s. It is noted in Mussmann and Liang (2018) that uncertainty sampling (i.e. sampling from $D _ { | S _ { w } }$ ) implicitly performs preconditioned stochastic gradient descent on the expected 0-1 loss. In addition, it has been shown that DPP sampling over gradients may reduce the variance of the mini-batch stochastic gradient updates (Zhang et al., 2017b); this suggests that BADGE, when restricted its sampling over low-margin regions $( S _ { w } )$ , improves over uncertainty sampling by collecting examples that together induce lower-variance updates on the gradient direction of expected 0-1 loss. ",
+        "bbox": [
+            147,
+            518,
+            851,
+            643
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "C ALL LEARNING CURVES ",
+        "text_level": 1,
+        "bbox": [
+            150,
+            671,
+            382,
+            686
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "We plot all learning curves (test accuracy as a function of the number of labeled example queried) in Figures 6 to 12. In addition, we zoom into regions of the learning curves that discriminates the performance of all algorithms in Figures 13 to 19. ",
+        "bbox": [
+            148,
+            694,
+            851,
+            736
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "D PAIRWISE COMPARISONS OF ALGORITHMS ",
+        "text_level": 1,
+        "bbox": [
+            148,
+            758,
+            534,
+            773
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "In addition to Figure 4 in the main text, we also provide penalty matrices (Figures 20 and 21), where the results are aggregated by conditioning on a fixed batch size (100, 1000 and 10000) or on a fixed neural network model (MLP, ResNet and VGG). For each penalty matrix, the parenthesized number in its title is the total number of $( D , B , A )$ combinations aggregated; as discussed in Section 4, this is also an upper bound on all its entries. It can be seen that uncertainty-based methods (e.g. MARG) perform well only in small batch size regimes (100) or when using MLP models; representative sampling based methods (e.g. CORESET) only perform well in large batch size regimes (10000) or when using ResNet or VGG models. In contrast, BADGE’s performance is competitive across all batch sizes and neural network models. ",
+        "bbox": [
+            148,
+            780,
+            851,
+            821
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "image",
+        "img_path": "images/d9030f407149623b5e1e3c6e2181cca01dc0f054d2cc7ee5b9e65e37b788430f.jpg",
+        "image_caption": [
+            "Figure 8: Full learning curves for OpenML #156 with MLP. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            143,
+            200,
+            849,
+            353
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "image",
+        "img_path": "images/0dc915ff317f4bdacdb7591b36b371084cd4cbb9f1f0d4f07c652c08e046f8dd.jpg",
+        "image_caption": [
+            "Figure 9: Full learning curves for OpenML #184 with MLP. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            145,
+            555,
+            851,
+            708
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "image",
+        "img_path": "images/021581459787c3b3df4ed9065c4342a96367bf511bc9af442888620fe9489f66.jpg",
+        "image_caption": [
+            "Figure 10: Full learning curves for SVHN with MLP, ResNet and VGG. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            142,
+            131,
+            854,
+            546
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "image",
+        "img_path": "images/e8fe0e3b347610236751383630edb45029111c672cb94ecfd283ffc78dca523d.jpg",
+        "image_caption": [
+            "Figure 11: Full learning curves for MNIST with MLP. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            143,
+            617,
+            852,
+            771
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "image",
+        "img_path": "images/a4a03ba238975dad7d4d9706c2fc6f8bf6ace30f7ad25c97337a95b53ba674be.jpg",
+        "image_caption": [
+            "Figure 12: Full learning curves for CIFAR10 with MLP, ResNet and VGG. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            142,
+            132,
+            852,
+            546
+        ],
+        "page_idx": 16
+    },
+    {
+        "type": "image",
+        "img_path": "images/990f157de5f16287b5cc2739568242f27ae18014df01472d1d1c4978f90a5d0a.jpg",
+        "image_caption": [
+            "Figure 13: Zoomed-in learning curves for OpenML $\\# 6$ with MLP. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            143,
+            617,
+            852,
+            772
+        ],
+        "page_idx": 16
+    },
+    {
+        "type": "image",
+        "img_path": "images/d654ac52f0e8e7b4de997ddc93ec4e0f4ce9c1df3e103a48670fd2e5bf5edd73.jpg",
+        "image_caption": [
+            "Figure 14: Zoomed-in learning curves for OpenML #155 with MLP. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            145,
+            141,
+            852,
+            294
+        ],
+        "page_idx": 17
+    },
+    {
+        "type": "image",
+        "img_path": "images/0f700512626eabdd7ba390eaa418d36818628e85542d87e27533dd250077d27a.jpg",
+        "image_caption": [
+            "Figure 15: Zoomed-in learning curves for OpenML #156 with MLP. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            143,
+            376,
+            851,
+            531
+        ],
+        "page_idx": 17
+    },
+    {
+        "type": "image",
+        "img_path": "images/f2afa1c87f4feaa6e3796baea1d6a22218fb040453bcdb82a250d55b4d0a9738.jpg",
+        "image_caption": [
+            "Figure 16: Zoomed-in learning curves for OpenML #184 with MLP. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            145,
+            611,
+            851,
+            766
+        ],
+        "page_idx": 17
+    },
+    {
+        "type": "image",
+        "img_path": "images/f0c42a0c3e2d768cd833fa7d50e3800e2873b503e576998c7a448383e9630f34.jpg",
+        "image_caption": [
+            "Figure 17: Zoomed-in learning curves for SVHN with MLP, ResNet and VGG. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            142,
+            132,
+            854,
+            546
+        ],
+        "page_idx": 18
+    },
+    {
+        "type": "image",
+        "img_path": "images/fbce56c22162e29e6d225aa0e5d67f5788bf75bd60797bed3ade2cebd28df0bb.jpg",
+        "image_caption": [
+            "Figure 18: Zoomed-in learning curves for MNIST with MLP. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            143,
+            617,
+            852,
+            772
+        ],
+        "page_idx": 18
+    },
+    {
+        "type": "image",
+        "img_path": "images/1500a84f46227f17a6b03c0a03417a976729932c9d4bd0b0846c341096d3bce2.jpg",
+        "image_caption": [
+            "Figure 19: Zoomed-in learning curves for CIFAR10 with MLP, ResNet and VGG. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            142,
+            251,
+            851,
+            661
+        ],
+        "page_idx": 19
+    },
+    {
+        "type": "image",
+        "img_path": "images/bcdf7607b2dfbb32a55c7026c517c34f609fe133885d1d155bef016d2d58a66c.jpg",
+        "image_caption": [
+            "Figure 20: Pairwise penalty matrices of the algorithms, grouped by different batch sizes. The parenthesized number in the title is the total number of $( D , B , A )$ combinations aggregated, which is also an upper bound on all its entries. Element $( i , j )$ corresponds roughly to the number of times algorithm $i$ beats algorithm $j$ . Column-wise averages at the bottom show aggregate performance (lower is better). From left to right: batch size $= 1 0 0$ , 1000, 10000. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            142,
+            125,
+            854,
+            291
+        ],
+        "page_idx": 20
+    },
+    {
+        "type": "image",
+        "img_path": "images/8ec656b0d27579e17e5d426494b01e24c71753019e1725e0565a8cb78ab69c17.jpg",
+        "image_caption": [
+            "Figure 21: Pairwise penalty matrices of the algorithms, grouped by different neural network models. The parenthesized number in the title is the total number of $( D , B , A )$ combinations aggregated, which is also an upper bound on all its entries. Element $( i , j )$ corresponds roughly to the number of times algorithm $i$ beats algorithm $j$ . Column-wise averages at the bottom show aggregate performance (lower is better). From left to right: MLP, ResNet and VGG. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            143,
+            435,
+            854,
+            603
+        ],
+        "page_idx": 20
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            147,
+            751,
+            852,
+            821
+        ],
+        "page_idx": 20
+    },
+    {
+        "type": "image",
+        "img_path": "images/7dd5a955d88848c7fffd4e19963044529b8b5dd217cfd79f1fe6e676bf7c481e.jpg",
+        "image_caption": [
+            "Figure 22: CDFs of normalized errors of the algorithms, group by different batch sizes. Higher CDF indicates better performance. From left to right: batch size $= 1 0 0$ , 1000, 10000. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            148,
+            121,
+            849,
+            279
+        ],
+        "page_idx": 21
+    },
+    {
+        "type": "image",
+        "img_path": "images/1e8686a7c69e02d8ee3ed0ecbbd8213345b8e48ed6000061e556cbde8724f18f.jpg",
+        "image_caption": [
+            "Figure 23: CDFs of normalized errors of the algorithms, group by different neural network models. Higher CDF indicates better performance. From left to right: MLP, ResNet and VGG. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            148,
+            353,
+            849,
+            511
+        ],
+        "page_idx": 21
+    },
+    {
+        "type": "text",
+        "text": "E CDFS OF NORMALIZED ERRORS OF DIFFERENT ALGORITHMS ",
+        "text_level": 1,
+        "bbox": [
+            147,
+            594,
+            687,
+            609
+        ],
+        "page_idx": 21
+    },
+    {
+        "type": "text",
+        "text": "In addition to Figure 5 that aggregates over all settings, we show here the CDFs of normalized errors by conditioning on fixed batch sizes (100, 1000 and 10000) in Figure 22, and show the CDFs of normalized errors by conditioning on fixed neural network models (MLP, ResNet and VGG) in Figure 23. ",
+        "bbox": [
+            148,
+            626,
+            852,
+            669
+        ],
+        "page_idx": 21
+    },
+    {
+        "type": "text",
+        "text": "F BATCH UNCERTAINTY AND DIVERSITY ",
+        "text_level": 1,
+        "bbox": [
+            148,
+            693,
+            500,
+            708
+        ],
+        "page_idx": 21
+    },
+    {
+        "type": "text",
+        "text": "Figure 24 gives a comparison of sampling methods with gradient embedding in two settings (OpenML # 6, MLP, batchsize 100 and SVHN, ResNet, batchsize 1000), in terms of uncertainty and diversity of examples selected within batches. These two properties are measured by average $\\ell _ { 2 }$ norm and determinant of the Gram matrix of gradient embedding, respectively. It can be seen that, $k { \\mathrm { - M E A N S + + } }$ (BADGE) induces good batch diversity in both settings. CONF generally selects examples with high uncertainty, but in some iterations of OpenML #6, the batch diversity is relatively low, as evidenced by the corresponding log Gram determinant being $- \\infty$ . These areas are indicated by gaps in the learning curve for CONF. Situations where there are many gaps in the CONF plot seem to correspond to situations in which CONF performs poorly in terms of accuracy (see Figure 13 for the corresponding learning curve). Both $k$ -DPP and FF- $k$ -CENTER (an algorithm that approximately minimizes $k$ -center objective) select batches that have lower diversity than $k$ -MEANS $^ { + + }$ (BADGE). ",
+        "bbox": [
+            147,
+            724,
+            851,
+            823
+        ],
+        "page_idx": 21
+    },
+    {
+        "type": "image",
+        "img_path": "images/06e0a6591dd6c4b5362a74a440c88b7e0461b3c1f9819bca861c53a4a12938ab.jpg",
+        "image_caption": [
+            "Figure 24: A comparison of batch selection algorithms in gradient space. Plots a and b show the log determinants of the Gram matrices of gradient embeddings within batches as learning progresses. Plots c and $\\mathbf { d }$ show the average embedding magnitude (a measurement of predictive uncertainty) in the selected batch. The $k$ -centers sampler finds points that are not as diverse or high-magnitude as other samplers. Notice also that $k { \\mathrm { - M E A N S + + } }$ tends to actually select samples that are both more diverse and higher-magnitude than a $k$ -DPP, a potential pathology of the $k$ -DPP’s degree of stochastisity. Among all algorithms, CONF has the largest average norm of gradient embeddings within a batch; however, in OpenML #6, and the first few interations of SVHN, some batches have a log Gram determinant of $- \\infty$ (shown as gaps in the curve), which shows that CONF sometimes selects batches that are inferior in diversity. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            158,
+            126,
+            828,
+            492
+        ],
+        "page_idx": 22
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            148,
+            672,
+            852,
+            728
+        ],
+        "page_idx": 22
+    },
+    {
+        "type": "text",
+        "text": "G COMPARISON OF $k$ -MEANS $^ { + + }$ AND $k$ -DPP IN BATCH SELECTION ",
+        "text_level": 1,
+        "bbox": [
+            145,
+            748,
+            717,
+            765
+        ],
+        "page_idx": 22
+    },
+    {
+        "type": "text",
+        "text": "In Figures 25 to 31, we give running time and test accuracy comparisons between $k { \\mathrm { - M E A N S + + } }$ and $k$ -DPP for selecting examples based on gradient embedding in batch mode active learning. We implement the $k$ -DPP sampling using the MCMC algorithm from (Kang, 2013), which has a time complexity of $O ( \\tau \\cdot ( k ^ { 2 } + k d ) )$ ",
+        "bbox": [
+            148,
+            780,
+            852,
+            821
+        ],
+        "page_idx": 22
+    },
+    {
+        "type": "image",
+        "img_path": "images/68897bb6eb4bbcd2af8922a41897bb08fb0a8da3dee3dc4ea852ae1ac708751f.jpg",
+        "image_caption": [
+            "Figure 25: Learning curves and running times for OpenML #6 with MLP. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            166,
+            118,
+            828,
+            244
+        ],
+        "page_idx": 23
+    },
+    {
+        "type": "image",
+        "img_path": "images/b1f42c320b083c071d89711fbe35a86eb10b8d1f0c2d817a99adf3ecf93c99a1.jpg",
+        "image_caption": [
+            "Figure 26: Learning curves and running times for OpenML #155 with MLP. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            151,
+            304,
+            844,
+            434
+        ],
+        "page_idx": 23
+    },
+    {
+        "type": "text",
+        "text": "and space complexity of $O ( k ^ { 2 } + k d )$ , where $\\tau$ is the number of sampling steps. We set $\\tau$ as $\\lfloor 5 k \\ln k \\rfloor$ in our experiment. The comparisons for batch size 10000 are not shown here as the implementation of $k$ -DPP sampling runs out of memory. ",
+        "bbox": [
+            147,
+            501,
+            852,
+            545
+        ],
+        "page_idx": 23
+    },
+    {
+        "type": "text",
+        "text": "It can be seen from the figures that, although $k$ -DPP and $k { \\mathrm { - M E A N S + + } }$ are based on different sampling criteria, the classification accuracies of their induced active learning algorithm are similar. In addition, when large batch sizes are required (e.g. $k = 1 0 0 0$ ), the running times of $k$ -DPP sampling are generally much higher than those of $k$ -MEA $\\mathrm { N S } { + } { + }$ . ",
+        "bbox": [
+            147,
+            551,
+            851,
+            608
+        ],
+        "page_idx": 23
+    },
+    {
+        "type": "image",
+        "img_path": "images/5d40d22c75721a059cbb0b806209efb76c254e0e8846d044ac3890ff3d1626ee.jpg",
+        "image_caption": [
+            "Figure 27: Learning curves and running times for OpenML #156 with MLP. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            151,
+            646,
+            844,
+            776
+        ],
+        "page_idx": 23
+    },
+    {
+        "type": "image",
+        "img_path": "images/8fe1677b8a9ebbca89d82595804c40b53899f667292aace8887172757fda3d48.jpg",
+        "image_caption": [
+            "Figure 28: Learning curves and running times for OpenML #184 with MLP. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            151,
+            131,
+            843,
+            261
+        ],
+        "page_idx": 24
+    },
+    {
+        "type": "image",
+        "img_path": "images/432ede9d567f05ff30cc84e24734b9684b3267b38f6ff82e344349767b470a38.jpg",
+        "image_caption": [
+            "Figure 29: Learning curves and running times for SVHN with MLP and ResNet. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            151,
+            337,
+            844,
+            556
+        ],
+        "page_idx": 24
+    },
+    {
+        "type": "image",
+        "img_path": "images/76e18f8566dc277eb165ad2a542cf0aeb87cdf8690bfcf233cdf2a0caac590d4.jpg",
+        "image_caption": [
+            "Figure 30: Learning curves and running times for MNIST with MLP. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            151,
+            633,
+            844,
+            763
+        ],
+        "page_idx": 24
+    },
+    {
+        "type": "image",
+        "img_path": "images/3398b065aad57ae31c9b307f82c2049a16bcf7ee25b9677c8a6caa71d142daf3.jpg",
+        "image_caption": [
+            "Figure 31: Learning curves and running times for CIFAR10 with MLP and ResNet. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            151,
+            337,
+            843,
+            556
+        ],
+        "page_idx": 25
+    }
+]