Add files using upload-large-folder tool

parse/train/B1l6qiR5F7/B1l6qiR5F7_content_list.json

@@ -0,0 +1,1556 @@
+[
+    {
+        "type": "text",
+        "text": "ORDERED NEURONS: INTEGRATING TREE STRUCTURES INTO RECURRENT NEURAL NETWORKS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            99,
+            650,
+            172
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Yikang Shen∗   \nMila/Universite de Montr´ eal and Microsoft Research´   \nMontreal, Canada´ ",
+        "bbox": [
+            183,
+            195,
+            532,
+            237
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Shawn Tan∗ Mila/Universite de Montr´ eal´ Montreal, Canada´ ",
+        "bbox": [
+            625,
+            195,
+            813,
+            237
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Alessandro Sordoni Microsoft Research Montreal, Canada´ ",
+        "bbox": [
+            184,
+            258,
+            323,
+            300
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Aaron Courville   \nMila/Universite de Montr´ eal´   \nMontreal, Canada´ ",
+        "bbox": [
+            482,
+            258,
+            671,
+            300
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "ABSTRACT ",
+        "text_level": 1,
+        "bbox": [
+            454,
+            338,
+            544,
+            353
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Natural language is hierarchically structured: smaller units (e.g., phrases) are nested within larger units (e.g., clauses). When a larger constituent ends, all of the smaller constituents that are nested within it must also be closed. While the standard LSTM architecture allows different neurons to track information at different time scales, it does not have an explicit bias towards modeling a hierarchy of constituents. This paper proposes to add such an inductive bias by ordering the neurons; a vector of master input and forget gates ensures that when a given neuron is updated, all the neurons that follow it in the ordering are also updated. Our novel recurrent architecture, ordered neurons LSTM (ON-LSTM), achieves good performance on four different tasks: language modeling, unsupervised parsing, targeted syntactic evaluation, and logical inference1. ",
+        "bbox": [
+            233,
+            369,
+            764,
+            522
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 INTRODUCTION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            551,
+            336,
+            566
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Natural language has a sequential overt form as spoken and written, but the underlying structure of language is not strictly sequential. This structure is usually tree-like. Linguists agree on a set of rules, or syntax, that determine this structure (Chomsky, 1956; 1965; Sandra & Taft, 2014) and dictate how single words compose to form meaningful larger units, also called “constituents” (Koopman et al., 2013). The human brain can also implicitly acquire the latent structure of language (Dehaene et al., 2015): during language acquisition, children are not given annotated parse trees. This observation brings more interest in latent structure induction with artificial neural network approaches, which are inspired by information processing and communication patterns in biological nervous systems. From a practical point of view, integrating a tree structure into a neural network language model may be important for multiple reasons: ",
+        "bbox": [
+            174,
+            583,
+            825,
+            723
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "(i) to obtain a hierarchical representation with increasing levels of abstraction, a key feature of deep neural networks (Bengio et al., 2009; LeCun et al., 2015; Schmidhuber, 2015);   \n(ii) to model the compositional effects of language (Koopman et al., 2013; Socher et al., 2013) and help with the long-term dependency problem (Bengio et al., 2009; Tai et al., 2015) by providing shortcuts for gradient backpropagation (Chung et al., 2016);   \n(iii) to improve generalization via a better inductive bias and at the same time potentially reducing the need of a large amount of training data. ",
+        "bbox": [
+            202,
+            734,
+            825,
+            844
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "The study of deep neural network techniques that can infer and use tree structures to form better representations of natural language sentences has received a great deal of attention in recent years (Bowman et al., 2016; Yogatama et al., 2016; Shen et al., 2017; Jacob et al., 2018; Choi et al., 2018; Williams et al., 2018; Shi et al., 2018). ",
+        "bbox": [
+            178,
+            857,
+            823,
+            886
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "image",
+        "img_path": "images/64f48480a31dc86ae48435f4c1df297a0a782560caa7f4f3f3948c909339a4bc.jpg",
+        "image_caption": [
+            "Interest expense in the 1988 third quarter was 75.3 million Interest expense in the 1988 third quarter was 75.3 million ",
+            "Figure 1: Binary parse tree inferred by our model (left) and its corresponding ground-truth (right). "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            204,
+            102,
+            795,
+            133
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            204,
+            823,
+            232
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Given a sentence, one straightforward way of predicting the corresponding latent tree structure is through a supervised syntactic parser. Trees produced by these parsers have been used to guide the composition of word semantics into sentence semantics (Socher et al., 2013; Bowman et al., 2015), or even to help next word prediction given previous words (Wu et al., 2017). However, supervised parsers are limiting for several reasons: i) few languages have comprehensive annotated data for supervised parser training; ii) in some domains, syntax rules tend to be broken (e.g. in tweets); and iii) languages change over time with use, so syntax rules may evolve. ",
+        "bbox": [
+            174,
+            239,
+            825,
+            337
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "On the other hand, grammar induction, defined as the task of learning the syntactic structure from raw corpora without access to expert-labeled data, remains an open problem. Many such recent attempts suffer from inducing a trivial structure (e.g., a left-branching or right-branching tree (Williams et al., 2018)), or encounter difficulties in training caused by learning branching policies with Reinforcement Learning (RL) (Yogatama et al., 2016). Furthermore, some methods are relatively complex to implement and train, like the PRPN model proposed in Shen et al. (2017). ",
+        "bbox": [
+            174,
+            343,
+            825,
+            428
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Recurrent neural networks (RNNs) have proven highly effective at the task of language modeling (Merity et al., 2017; Melis et al., 2017). RNNs explicitly impose a chain structure on the data. This assumption may seem at odds with the latent non-sequential structure of language and may pose several difficulties for the processing of natural language data with deep learning methods, giving rise to problems such as capturing long-term dependencies (Bengio et al., 2009), achieving good generalization (Bowman et al., 2015), handling negation (Socher et al., 2013), etc. Meanwhile, some evidence exists that LSTMs with sufficient capacity potentially implement syntactic processing mechanisms by encoding the tree structure implicitly, as shown by Gulordava et al. (2018); Kuncoro et al. (2018) and very recently by Lakretz et al. (2019). We believe that the following question remains: Can better models of language be obtained by architectures equipped with an inductive bias towards learning such latent tree structures? ",
+        "bbox": [
+            174,
+            434,
+            825,
+            587
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "In this work, we introduce ordered neurons, a new inductive bias for recurrent neural networks. This inductive bias promotes differentiation of the life cycle of information stored inside each neuron: high-ranking neurons will store long-term information which is kept for a large number of steps, while low-ranking neurons will store short-term information that can be rapidly forgotten. To avoid a strict division between high-ranking and low-ranking neurons, we propose a new activation function, the cumulative softmax, or cumax(), to actively allocate neurons to store long/short-term information. We use the cumax() function to produce a vector of master input and forget gates ensuring that when a given neuron is updated (erased), all of the neurons that follow it in the ordering are also updated (erased). Based on the cumax() and the LSTM architecture, we have designed a new model, ON-LSTM, that is biased towards performing tree-like composition operations. Our model achieves good performance on four tasks: language modeling, unsupervised constituency parsing, targeted syntactic evaluation (Marvin & Linzen, 2018) and logical inference (Bowman et al., 2015). The result on unsupervised constituency parsing suggests that the proposed inductive bias aligns with the syntax principles proposed by human experts better than previously proposed models. The experiments also show that ON-LSTM performs better than standard LSTM models in tasks requiring capturing long-term dependencies and achieves better generalization to longer sequences. ",
+        "bbox": [
+            174,
+            594,
+            825,
+            816
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2 RELATED WORK ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            837,
+            344,
+            852
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "There has been prior work leveraging tree structures for natural language tasks in the literature. Socher et al. (2010); Alvarez-Melis & Jaakkola (2016); Zhou et al. (2017); Zhang et al. (2015) use supervised learning on expert-labeled treebanks for predicting parse trees. Socher et al. (2013) and Tai et al. (2015) explicitly model the tree-structure using parsing information from an external parser. Later, Bowman et al. (2016) exploited guidance from a supervised parser (Klein & Manning, 2003) in order to train a stack-augmented neural network. ",
+        "bbox": [
+            176,
+            868,
+            823,
+            924
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            103,
+            821,
+            132
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Theoretically, RNNs and LSTMs can model data produced by context-free grammars and contextsensitive grammars (Gers & Schmidhuber, 2001). However, recent results suggest that introducing structure information into LSTMs is beneficial. Kuncoro et al. (2018) showed that RNNGs (Dyer et al., 2016), which have an explicit bias to model the syntactic structures, outperform LSTMs on the subject-verb agreement task (Linzen et al., 2016). In our paper, we run a more extensive suite of grammatical tests recently provided by Marvin & Linzen (2018). Bowman et al. (2014; 2015) also demonstrate that tree-structured models are more effective for downstream tasks whose data was generated by recursive programs. Interestingly, Shi et al. (2018) suggests that while the prescribed grammar tree may not be ideal, some sort of hierarchical structure, perhaps task dependent, might help. However, the problem of efficiently inferring such structures from observed data remains an open question. ",
+        "bbox": [
+            174,
+            138,
+            825,
+            291
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "The task of learning the underlying grammar from data is known as grammar induction (Chen, 1995; Cohen et al., 2011). Early work incorporated syntactic structure in the context of language modeling (Roark, 2001; Charniak, 2001; Chelba & Jelinek, 2000). More recently, there have been attempts at incorporating some structure for downstream tasks using neural models (Grefenstette et al., 2015; Sun et al., 2017; Joulin & Mikolov, 2015). Generally, these works augment a main recurrent model with a stack and focus on solving algorithmic tasks. Yogatama et al. (2018) focus on language modeling and syntactic evaluation tasks (Linzen et al., 2016) but they do not show the extent to which the structure learnt by the model align with gold-standard parse trees. Shen et al. (2017) introduced the Parsing-Reading-Predict Networks (PRPN) model, which attempts to perform parsing by solving a language modeling task. The model uses self-attention to compose previous states, where the range of attention is controlled by a learnt “syntactic distance”. The authors show that this value corresponds to the depth of the parse tree. However, the added complexity in using the PRPN model makes it unwieldy in practice. ",
+        "bbox": [
+            174,
+            299,
+            825,
+            478
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Another possible solution is to develop models with varying time-scales of recurrence as a way of capturing this hierarchy. El Hihi & Bengio (1996); Schmidhuber (1991); Lin et al. (1998) describe models that capture hierarchies at pre-determined time-scales. More recently, Koutnik et al. (2014) proposed Clockwork RNN, which segments the hidden state of a RNN by updating at different time-scales. These approaches typically make a strong assumption about the regularity of the hierarchy involved in modelling the data. Chung et al. (2016) proposed a method that, unlike the Clockwork RNN, would learn a multi-scale hierarchical recurrence. However, the model still has a pre-determined depth to the hierarchy, depending on the number of layers. Our work is more closely related to Rippel et al. (2014), which propose to induce a hierarchy in the representation units by applying “nested” dropout masks: units are not dropped independently at random but whenever a unit is dropped, all the units that follow in the ordering are also dropped. Our work can be seen as a soft relaxation of the dropout by means of the proposed cumax() activation. Moreover, we propose to condition the update masks on the particular input and apply our overall model to sequential data. Therefore, our model can adapt the structure to the observed data, while both Clockwork RNN and nested dropout impose a predefined hierarchy to hidden representations. ",
+        "bbox": [
+            173,
+            486,
+            825,
+            694
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3 ORDERED NEURONS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            715,
+            377,
+            732
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Given a sequence of tokens $S = ( x _ { 1 } , \\dots , x _ { T } )$ and its corresponding constituency tree (Figure 2(a)), our goal is to infer the unobserved tree structure while processing the observed sequence, i.e. while computing the hidden state $h _ { t }$ for each time step $t$ . At each time step, $h _ { t }$ would ideally contain a information about all the nodes on the path between the current leaf node $x _ { t }$ and the root S. In Figure 2(c), we illustrate how $h _ { t }$ would contain information about all the constituents that include the current token $x _ { t }$ even if those are only partially observed. This intuition suggests that each node in the tree can be represented by a set of neurons in the hidden states. However, while the dimensionality of the hidden state is fixed in advance, the length of the path connecting the leaf to the root of the tree may be different across different time steps and sentences. Therefore, a desiderata for the model is to dynamically reallocate the dimensions of the hidden state to each node. ",
+        "bbox": [
+            174,
+            750,
+            825,
+            888
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Given these requirements, we introduce ordered neurons, an inductive bias that forces neurons to represent information at different time-scales. In our model, high-ranking neurons contain long-term or global information that will last anywhere from several time steps to the entire sentence, representing nodes near the root of the tree. Low-ranking neurons encode short-term or local information that only last one or a few time steps, representing smaller constituents, as shown in Figure 2(b). The differentiation between high-ranking and low-ranking neurons is learnt in a completely data-driven fashion by controlling the update frequency of single neurons: to erase (or update) high-ranking neurons, the model should first erase (or update) all lower-ranking neurons. In other words, some neurons always update more (or less) frequently than the others, and that order is pre-determined as part of the model architecture. ",
+        "bbox": [
+            174,
+            895,
+            821,
+            924
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "image",
+        "img_path": "images/30a600b32cff4337192a9cce82dbad979d4481382ed0dfe4a930e1bf09913154.jpg",
+        "image_caption": [
+            "Figure 2: Correspondences between a constituency parse tree and the hidden states of the proposed ON-LSTM. A sequence of tokens $S = ( x _ { 1 } , x _ { 2 } , x _ { 3 } )$ and its corresponding constituency tree are illustrated in (a). We provide a block view of the tree structure in (b), where both S and VP nodes span more than one time step. The representation for high-ranking nodes should be relatively consistent across multiple time steps. (c) Visualization of the update frequency of groups of hidden state neurons. At each time step, given the input word, dark grey blocks are completely updated while light grey blocks are partially updated. The three groups of neurons have different update frequencies. Topmost groups update less frequently while lower groups are more frequently updated. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            171,
+            99,
+            826,
+            244
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            398,
+            825,
+            511
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "4 ON-LSTM ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            530,
+            299,
+            546
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "In this section, we present a new RNN unit, ON-LSTM (“ordered neurons LSTM”). The new model uses an architecture similar to the standard LSTM, reported below: ",
+        "bbox": [
+            173,
+            563,
+            821,
+            592
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/a87777f6bc3ea58f03946d45200096a8a019405f0c2ea0037796ddbb2f7a38cf.jpg",
+        "text": "$$\n\\begin{array} { r l } & { f _ { t } = \\sigma ( W _ { f } x _ { t } + U _ { f } h _ { t - 1 } + b _ { f } ) } \\\\ & { i _ { t } = \\sigma ( W _ { i } x _ { t } + U _ { i } h _ { t - 1 } + b _ { i } ) } \\\\ & { o _ { t } = \\sigma ( W _ { o } x _ { t } + U _ { o } h _ { t - 1 } + b _ { o } ) } \\\\ & { \\hat { c } _ { t } = \\operatorname { t a n h } ( W _ { c } x _ { t } + U _ { c } h _ { t - 1 } + b _ { c } ) } \\\\ & { h _ { t } = o _ { t } \\circ \\operatorname { t a n h } ( c _ { t } ) } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            385,
+            597,
+            612,
+            689
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "The difference with the LSTM is that we replace the update function for the cell state $c _ { t }$ with a new function that will be explained in the following sections. The forget gates $f _ { t }$ and input gates $i _ { t }$ are used to control the erasing and writing operation on cell states $c _ { t }$ , as before. Since the gates in the LSTM act independently on each neuron, it may be difficult in general to discern a hierarchy of information between the neurons. To this end, we propose to make the gate for each neuron dependent on the others by enforcing the order in which neurons should be updated. ",
+        "bbox": [
+            173,
+            693,
+            825,
+            779
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "4.1 ACTIVATION FUNCTION: cumax()",
+        "text_level": 1,
+        "bbox": [
+            176,
+            795,
+            450,
+            809
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "To enforce an order to the update frequency, we introduce a new activation function: ",
+        "bbox": [
+            174,
+            820,
+            725,
+            837
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/cc6baff3e16c5473bc668788b107bb91f75adbfb6bb3b882bbaa97a0ce057745.jpg",
+        "text": "$$\n\\hat { g } = \\mathrm { c u m a x } ( \\ldots ) = \\mathrm { c u m s u m } ( \\mathrm { s o f t m a x } ( \\ldots ) ) ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            349,
+            843,
+            647,
+            861
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "where cumsum denotes the cumulative sum. We will show that the vector $\\hat { g }$ can be seen as the expectation of a binary gate $g = ( 0 , . . . , 0 , 1 , . . . , 1 )$ . This binary gate splits the cell state into two segments: the 0-segment and the 1-segment. Thus, the model can apply different update rules on the two segments to differentiate long/short-term information. Denote by $d$ a categorical random ",
+        "bbox": [
+            174,
+            867,
+            825,
+            924
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "variable representing the index for the first 1 in $g$ : ",
+        "bbox": [
+            176,
+            103,
+            500,
+            118
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/ac315000b9dbda50dd580d1a8161eb8530241b617c9a71a77e8c187665caa860.jpg",
+        "text": "$$\np ( d ) = \\operatorname { s o f t m a x } ( . . . )\n$$",
+        "text_format": "latex",
+        "bbox": [
+            426,
+            125,
+            570,
+            142
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "The variable $d$ represents the split point between the two segments. We can compute the probability of the $k$ -th value in $g$ being 1 by evaluating the probability of the disjunction of any of the values before the $k$ -th being the split point, that is $\\mathbf { \\bar { \\Sigma } } d \\leq \\bar { k } = ( d = 0 ) \\lor ( d = \\bar { 1 } ) \\lor \\cdots \\lor ( d = k ) .$ . Since the categories are mutually exclusive, we can do this by computing the cumulative distribution function: ",
+        "bbox": [
+            173,
+            147,
+            825,
+            204
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/0843cd0309118ff94d8f8273a7cc5e27545896e7e3e2a473b6bf4053989ab780.jpg",
+        "text": "$$\np ( g _ { k } = 1 ) = p ( d \\leq k ) = \\sum _ { i \\leq k } p ( d = i )\n$$",
+        "text_format": "latex",
+        "bbox": [
+            369,
+            210,
+            627,
+            246
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Ideally, $g$ should take the form of a discrete variable. Unfortunately, computing gradients when a discrete variable is included in the computation graph is not trivial (Schulman et al., 2015), so in practice we use a continuous relaxation by computing the quantity $p ( d \\leq k )$ , obtained by taking a cumulative sum of the softmax. As $g _ { k }$ is binary, this is equivalent to computing $\\mathbb { E } [ g _ { k } ]$ . Hence, $\\hat { \\boldsymbol g } = \\mathbb { E } [ \\boldsymbol { g } ]$ . ",
+        "bbox": [
+            173,
+            251,
+            825,
+            323
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "4.2 STRUCTURED GATING MECHANISM ",
+        "text_level": 1,
+        "bbox": [
+            178,
+            338,
+            464,
+            353
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Based on the cumax() function, we introduce a master forget gate $\\tilde { f } _ { t }$ and a master input gate $\\tilde { i } _ { t }$ ",
+        "bbox": [
+            171,
+            362,
+            800,
+            380
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/62ddf31ce1498eb59b906cb059aa4d72aebb84f2d7c0f94e8aee323de71ccbee.jpg",
+        "text": "$$\n\\begin{array} { r l } & { \\tilde { f } _ { t } = \\operatorname { c u m a x } ( W _ { \\tilde { f } } x _ { t } + U _ { \\tilde { f } } h _ { t - 1 } + b _ { \\tilde { f } } ) } \\\\ & { \\tilde { i } _ { t } = 1 - \\operatorname { c u m a x } ( W _ { \\tilde { i } } x _ { t } + U _ { \\tilde { i } } h _ { t - 1 } + b _ { \\tilde { i } } ) } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            367,
+            385,
+            630,
+            429
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Following the properties of the cumax() activation, the values in the master forget gate are monotonically increasing from 0 to 1, and those in the master input gate are monotonically decreasing from 1 to 0. These gates serve as high-level control for the update operations of cell states. Using the master gates, we define a new update rule: ",
+        "bbox": [
+            174,
+            433,
+            823,
+            489
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/5ab6f64d67679b826edbb45d5f92ad3f03dbf458fa4d96c9a2f0794789d6850c.jpg",
+        "text": "$$\n\\begin{array} { r l } & { \\omega _ { t } = \\tilde { f } _ { t } \\circ \\tilde { i } _ { t } } \\\\ & { \\hat { f } _ { t } = f _ { t } \\circ \\omega _ { t } + ( \\tilde { f } _ { t } - \\omega _ { t } ) = \\tilde { f } _ { t } \\circ ( f _ { t } \\circ \\tilde { i } _ { t } + 1 - \\tilde { i } _ { t } ) } \\\\ & { \\hat { i } _ { t } = i _ { t } \\circ \\omega _ { t } + ( \\tilde { i } _ { t } - \\omega _ { t } ) = \\tilde { i } _ { t } \\circ ( i _ { t } \\circ \\tilde { f } _ { t } + 1 - \\tilde { f } _ { t } ) } \\\\ & { c _ { t } = \\hat { f } _ { t } \\circ c _ { t - 1 } + \\hat { i } _ { t } \\circ \\hat { c } _ { t } } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            333,
+            494,
+            665,
+            580
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "In order to explain the intuition behind the new update rule, we assume that the master gates are binary: ",
+        "bbox": [
+            173,
+            592,
+            823,
+            621
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "• The master forget gate $\\tilde { f } _ { t }$ controls the erasing behavior of the model. Suppose $\\tilde { f } _ { t } ~ =$ $( 0 , \\ldots , 0 , 1 , \\ldots , 1 )$ and the split point is $d _ { t } ^ { f }$ . Given the Eq. (12) and (14), the information stored in the first $d _ { t } ^ { f }$ neurons of the previous cell state $c _ { t - 1 }$ will be completely erased. In a parse tree (e.g. Figure 2(a)), this operation is akin to closing previous constituents. A large number of zeroed neurons, i.e. a large $d _ { t } ^ { f }$ , represents the end of a high-level constituent in the parse tree, as most of the information in the state will be discarded. Conversely, a small $d _ { t } ^ { f }$ represents the end of a low-level constituent as high-level information is kept for further processing. • The master input gate $\\tilde { i } _ { t }$ is meant to control the writing mechanism of the model. Assume that $\\tilde { i } _ { t } = ( 1 , \\cdot \\cdot \\cdot , \\bar { 1 } , 0 , \\cdot \\cdot \\cdot , 0 )$ and the split point is $d _ { t } ^ { i }$ . Given Eq. (13) and (14), a large $d _ { t } ^ { i }$ means that the current input $x _ { t }$ contains long-term information that needs to be preserved for several time steps. Conversely, a small $d _ { t } ^ { \\bar { i } }$ means that the current input $x _ { t }$ just provides local information that could be erased by $\\tilde { f } _ { t }$ in the next few time steps. The product of the two master gates $\\omega _ { t }$ represents the overlap of $\\tilde { f } _ { t }$ and $\\tilde { i } _ { t }$ . Whenever an overlap exists $( \\exists k , \\omega _ { t k } > 0 )$ , the corresponding segment of neurons encodes the incomplete constituents that contain some previous words and the current input word $x _ { t }$ . Since these constituents are incomplete, we want to update the information inside the respective blocks. The segment is further controlled by the $f _ { t }$ and $i _ { t }$ in the standard LSTM model to enable more fine-grained operations within blocks. For example, in Figure 2, the word $x _ { 3 }$ is nested into the constituents S and VP. At this time step, the overlap gray blocks would represent these constituents, such that $\\tilde { f } _ { t }$ and $\\tilde { i } _ { t }$ can decide whether to reset or update each individual neurons in these blocks. ",
+        "bbox": [
+            214,
+            631,
+            825,
+            924
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "table",
+        "img_path": "images/a9612cd27d0355d136dc43e69d158c2878a3fb592888a9236291ea3a3d1b0dea.jpg",
+        "table_caption": [
+            "Table 1: Single model perplexity on validation and test sets for the Penn Treebank language modeling task. Models labelled tied use weight tying on the embedding and softmax weights (Inan et al., 2016; Press & Wolf, 2017). Models labelled \\* focus on improving the softmax component of RNN language model. Their contribution is orthogonal to ours. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Model</td><td>Parameters</td><td>Validation</td><td>Test</td></tr><tr><td>Zaremba et al. (2014) - LSTM (large)</td><td>66M</td><td>82.2</td><td>78.4</td></tr><tr><td>Gal &amp; Ghahramani (2016) - Variational LSTM (large, MC)</td><td>66M</td><td>1</td><td>73.4</td></tr><tr><td>Kim et al. (2016) - CharCNN</td><td>19M</td><td>一</td><td>78.9</td></tr><tr><td>Merity etal.(2016)- Pointer Sentinel-LSTM</td><td>21M</td><td>72.4</td><td>70.9</td></tr><tr><td>Grave et al.(2016) - LSTM</td><td>1</td><td>1</td><td>82.3</td></tr><tr><td>Grave et al.(2016) -LSTM+ continuous cache pointer</td><td>一</td><td>一</td><td>72.1</td></tr><tr><td>Inan et al.(2016) - Variational LSTM(tied) +augmented loss</td><td>51M</td><td>71.1</td><td>68.5</td></tr><tr><td>Zilly et al. (2016) - Variational RHN (tied)</td><td>23M</td><td>67.9</td><td>65.4</td></tr><tr><td>Zoph &amp; Le (2016)- NAS Cell (tied)</td><td>54M</td><td>1</td><td>62.4</td></tr><tr><td>Shen et al.(2017) - PRPN-LM</td><td></td><td></td><td>62.0</td></tr><tr><td>Melis et al. (2017) - 4-layer skip connection LSTM (tied)</td><td>24M</td><td>60.9</td><td>58.3</td></tr><tr><td>Merity et al. (2017)-AWD-LSTM- 3-layer LSTM (tied)</td><td>24M</td><td>60.0</td><td>57.3</td></tr><tr><td>ON-LSTM- 3-layer (tied)</td><td>25M</td><td>58.29±0.10</td><td>56.17 ±0.12</td></tr><tr><td>Yang et al. (2017) - AWD-LSTM-MoS *</td><td>22M</td><td>56.5</td><td>54.4</td></tr></table>",
+        "bbox": [
+            176,
+            101,
+            820,
+            303
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            232,
+            397,
+            823,
+            441
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "As the master gates only focus on coarse-grained control, modeling them with the same dimensions as the hidden states is computationally expensive and unnecessary. In practice, we set $\\tilde { f } _ { t }$ and $\\tilde { i } _ { t }$ to be $\\begin{array} { r } { D _ { m } = \\frac { D } { C } } \\end{array}$ dimensional vectors, where $D$ is the dimension of hidden state, and $C$ is a chunk size factor. We repeat each dimension times, before the element-wise multiplication with $f _ { t }$ and $i _ { t }$ . The downsizing significantly reduces the number of extra parameters that we need to add to the LSTM. Therefore, every neuron within each $C$ -sized chunk shares the same master gates. ",
+        "bbox": [
+            174,
+            455,
+            825,
+            541
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "5 EXPERIMENTS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            564,
+            326,
+            580
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "We evaluate the proposed model on four tasks: language modeling, unsupervised constituency parsing, targeted syntactic evaluation (Marvin & Linzen, 2018), and logical inference (Bowman et al., 2015). ",
+        "bbox": [
+            174,
+            597,
+            823,
+            638
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "5.1 LANGUAGE MODELING ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            659,
+            377,
+            674
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Word-level language modeling is a macroscopic evaluation of the model’s ability to deal with various linguistic phenomena (e.g. co-occurence, syntactic structure, verb-subject agreement, etc). We evaluate our model by measuring perplexity on the Penn TreeBank (PTB) (Marcus et al., 1993; Mikolov, 2012) task. ",
+        "bbox": [
+            174,
+            686,
+            825,
+            742
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "For fair comparison, we closely follow the model hyper-parameters, regularization and optimization techniques introduced in AWD-LSTM (Merity et al., 2017). Our model uses a three-layer ONLSTM model with 1150 units in the hidden layer and an embedding of size 400. For master gates, the downsize factor $C = 1 0$ . The total number of parameters was slightly increased from 24 millions to 25 millions with additional matrices for computing master gates. We manually searched some of the dropout values for ON-LSTM based on the validation performance. The values used for dropout on the word vectors, the output between LSTM layers, the output of the final LSTM layer, and embedding dropout where (0.5, 0.3, 0.45, 0.1) respectively. A weight-dropout of 0.45 was applied to the recurrent weight matrices. ",
+        "bbox": [
+            173,
+            750,
+            825,
+            875
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "As shown in Table 1, our model performs better than the standard LSTM while sharing the same number of layers, embedding dimensions, and hidden states units. Recall that the master gates only control how information is stored in different neurons. It is interesting to note that we can improve the performance of a strong LSTM model without adding skip connections or a significant increase in the number of parameters. ",
+        "bbox": [
+            176,
+            882,
+            823,
+            924
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            103,
+            823,
+            132
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "5.2 UNSUPERVISED CONSTITUENCY PARSING",
+        "text_level": 1,
+        "bbox": [
+            174,
+            147,
+            504,
+            162
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "The unsupervised constituency parsing task compares the latent stree structure induced by the model with those annotated by human experts. Following the experiment settings proposed in Htut et al. (2018), we take our best model for the language modeling task, and test it on WSJ10 dataset and WSJ test set. WSJ10 has 7422 sentences, filtered from the WSJ dataset with the constraint of 10 words or less, after the removal of punctuation and null elements (Klein & Manning, 2002). The WSJ test set contains 2416 sentences with various lengths. It is worth noting that the WSJ10 test set contains sentences from the training, validation, and test set of the PTB dataset, while WSJ test uses the same set of sentences as the PTB test set. ",
+        "bbox": [
+            173,
+            174,
+            825,
+            286
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "To infer the tree structure of a sentence from a pre-trained model, we initialize the hidden states with the zero vector, then feed the sentence into the model as done in the language modeling task. At each time step, we compute an estimate of $d _ { t } ^ { f }$ : ",
+        "bbox": [
+            174,
+            292,
+            825,
+            337
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "equation",
+        "img_path": "images/0f6688139af842c204df0cb2b41a7d11fc102750eb36021c32100ec29f6f1f77.jpg",
+        "text": "$$\n\\hat { d } _ { t } ^ { f } = \\mathbb { E } \\left[ d _ { t } ^ { f } \\right] = \\sum _ { k = 1 } ^ { D _ { m } } k p _ { f } ( d _ { t } = k ) = \\sum _ { k = 1 } ^ { D _ { m } } \\sum _ { i = 1 } ^ { k } p _ { f } ( d _ { t } = k ) = D _ { m } - \\sum _ { k = 1 } ^ { D _ { m } } \\tilde { f } _ { t k }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            256,
+            340,
+            741,
+            383
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "where $p _ { f }$ is the probability distribution over split points associated to the master forget gate and $D _ { m }$ is the size of the hidden state. Given $\\hat { d } _ { t } ^ { f }$ , we can use the top-down greedy parsing algorithm proposed in Shen et al. (2017) for unsupervised constituency parsing. We first sort the $\\{ \\hat { d } _ { t } ^ { f } \\}$ in decreasing order. For the first $\\hat { d } _ { i } ^ { f }$ in the sorted sequence, we split the sentence into constituents $( ( x _ { < i } ) , ( \\bar { x _ { i } } , ( x _ { > i } ) ) )$ . Then, we recursively repeat this operation for constituents $( x _ { < i } )$ and $( x _ { > i } )$ , until each constituent contains only one word. ",
+        "bbox": [
+            173,
+            386,
+            825,
+            478
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "The performance is shown in Table 2. The second layer of ON-LSTM achieves state-of-the-art unsupervised constituency parsing results on the WSJ test set, while the first and third layers do not perform as well. One possible interpretation is that the first and last layers may be too focused on capturing local information useful for the language modeling task as they are directly exposed to input tokens and output predictions respectively, thus may not be encouraged to learn the more abstract tree structure. Since the WSJ test set contains sentences of various lengths which are unobserved during training, we find that ON-LSTM provides better generalization and robustness toward longer sentences than previous models. We also see that ON-LSTM model can provide strong results for phrase detection, including ADJP (adjective phrases), PP (prepositional phrases), and NP (noun phrases). This feature could benefit many downstream tasks, like question answering, named entity recognition, co-reference resolution, etc. ",
+        "bbox": [
+            173,
+            484,
+            825,
+            637
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "5.3 TARGETED SYNTACTIC EVALUATION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            654,
+            470,
+            669
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Targeted syntactic evaluation tasks have been proposed in Marvin & Linzen (2018). It is a collection of tasks that evaluate language models along three different structure-sensitive linguistic phenomena: subject-verb agreement, reflexive anaphora and negative polarity items. Given a large number of minimally different pairs of English sentences, each consisting of a grammatical and an ungrammatical sentence, a language model should assign a higher probability to a grammatical sentence than an ungrammatical one. ",
+        "bbox": [
+            174,
+            680,
+            825,
+            763
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Using the released codebase2 and the same settings proposed in Marvin & Linzen (2018), we train both our ON-LSTM model and a baseline LSTM language model on a 90 million word subset of Wikipedia. Both language models have two layers of 650 units, a batch size of 128, a dropout rate of 0.2, a learning rate of 20.0, and were trained for 40 epochs. The input embeddings have 200 dimensions and the output embeddings have 650 dimesions. ",
+        "bbox": [
+            174,
+            770,
+            825,
+            840
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Table 3 shows that the ON-LSTM performs better on the long-term dependency cases, while the baseline LSTM fares better on the short-term ones. This is possibly due to the relatively small num",
+        "bbox": [
+            176,
+            848,
+            821,
+            876
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "table",
+        "img_path": "images/60927e50e75e90f98684d21f9ba0ace7dc1d49301e3481b855a0682555b8ccd4.jpg",
+        "table_caption": [],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=\"3\">Model</td><td rowspan=\"3\">Training Data</td><td rowspan=\"3\">Training Object</td><td rowspan=\"3\">Vocab Size</td><td colspan=\"4\">Parsing F1</td><td colspan=\"6\"> Depth Accuracy on WSJ by Tag</td></tr><tr><td colspan=\"2\">WSJ10</td><td colspan=\"2\">WSJ</td><td rowspan=\"2\">WSJ max</td><td rowspan=\"2\"></td><td rowspan=\"2\">ADJP</td><td rowspan=\"2\">NP</td><td rowspan=\"2\">PP</td><td rowspan=\"2\">INTJ</td></tr><tr><td>μ（σ）</td><td>max</td><td>μ（σ）</td><td></td></tr><tr><td>PRPN-UP</td><td>AlINLI Train</td><td>LM</td><td>76k</td><td>66.3 (0.8)</td><td>68.5</td><td>38.3 (0.5)</td><td>39.8</td><td>5.8</td><td>28.7</td><td></td><td>65.5 32.7</td><td></td><td>0.0</td></tr><tr><td>PRPN-LM</td><td>AlINLI Train</td><td>LM</td><td>76k</td><td>52.4 (4.9)</td><td>58.1</td><td>35.0 (5.4)</td><td>42.8</td><td>6.1</td><td></td><td>37.8</td><td>59.7</td><td>61.5</td><td>100.0</td></tr><tr><td>PRPN-UP</td><td>WSJ Train</td><td>LM</td><td>15.8k</td><td>62.2 (3.9)</td><td>70.3</td><td>26.0 (2.3)</td><td>32.8</td><td>5.8</td><td></td><td>24.8</td><td>54.4</td><td>17.8</td><td>0.0</td></tr><tr><td>PRPN-LM</td><td>WSJ Train</td><td>LM</td><td>10k</td><td>70.5 (0.4)</td><td>71.3</td><td>37.4 (0.3)</td><td>38.1</td><td>5.9</td><td></td><td>26.2</td><td>63.9</td><td>24.4</td><td>0.0</td></tr><tr><td>ON-LSTM1st-layer</td><td>WSJ Train</td><td>LM</td><td>10k</td><td>35.2 (4.1)</td><td>42.8</td><td>20.0 (2.8)</td><td>24.0</td><td>5.6</td><td></td><td>38.1</td><td>23.8</td><td>18.3</td><td>100.0</td></tr><tr><td>ON-LSTM 2nd-layer</td><td>WSJ Train</td><td>LM</td><td>10k</td><td>65.1 (1.7)</td><td>66.8</td><td>47.7 (1.5)</td><td>49.4</td><td>5.6</td><td></td><td>46.2</td><td>61.4 55.4</td><td></td><td>0.0</td></tr><tr><td>ON-LSTM3rd-layer</td><td>WSJ Train</td><td>LM</td><td>10k</td><td>54.0 (3.9)</td><td>57.6</td><td>36.6 (3.3)</td><td>40.4</td><td>5.3</td><td></td><td>44.8</td><td>57.5 47.2</td><td></td><td>0.0</td></tr><tr><td>300D ST-Gumbel</td><td>AlINLI Train</td><td>NLI</td><td>1</td><td></td><td></td><td>19.0 (1.0)</td><td>20.1</td><td>1</td><td></td><td>15.6</td><td>18.8</td><td>9.9</td><td>59.4</td></tr><tr><td>w/o Leaf GRU</td><td>AlINLI Train</td><td>NLI</td><td></td><td></td><td></td><td>22.8 (1.6)</td><td>25.0</td><td></td><td></td><td>18.9</td><td>24.1</td><td>14.2</td><td>51.8</td></tr><tr><td>300D RL-SPINN</td><td>AlINLI Train</td><td>NLI</td><td></td><td></td><td></td><td>13.2 (0.0)</td><td>13.2</td><td></td><td></td><td>1.7</td><td>10.8</td><td>4.6</td><td>50.6</td></tr><tr><td>w/o Leaf GRU</td><td>AlINLI Train NLI</td><td></td><td></td><td></td><td></td><td>13.1 (0.1)</td><td>13.2</td><td>1</td><td></td><td>1.6</td><td>10.9</td><td>4.6</td><td>50.0</td></tr><tr><td>CCM</td><td>WSJ10 Full</td><td></td><td></td><td></td><td>71.9</td><td></td><td></td><td>1</td><td></td><td>1</td><td>1</td><td>1</td><td>1</td></tr><tr><td>DMV+CCM</td><td>WSJ10 Full</td><td></td><td></td><td></td><td>77.6</td><td></td><td></td><td></td><td></td><td>二</td><td></td><td>1</td><td>1</td></tr><tr><td>UML-DOP</td><td>WSJ10 Full</td><td></td><td></td><td></td><td>82.9</td><td></td><td></td><td></td><td></td><td>1</td><td>一</td><td>一</td><td>1</td></tr><tr><td>Random Trees</td><td></td><td></td><td></td><td>31.7 (0.3)</td><td>32.2</td><td>18.4 (0.1)</td><td>18.6</td><td>5.3</td><td></td><td>17.4</td><td>22.3</td><td>16.0</td><td>40.4</td></tr><tr><td>Balanced Trees</td><td></td><td></td><td></td><td>43.4 (0.0)</td><td></td><td>43.4 24.5 (0.0)</td><td>24.5</td><td>4.6</td><td></td><td>22.1</td><td>20.2</td><td>9.3</td><td>55.9</td></tr><tr><td>Left Branching</td><td></td><td></td><td></td><td>19.6 (0.0)</td><td>19.6</td><td>9.0 (0.0)</td><td>9.0</td><td>12.4</td><td></td><td>1</td><td>一</td><td></td><td>1</td></tr><tr><td>Right Branching</td><td></td><td></td><td></td><td>56.6 (0.0)</td><td>56.6</td><td>39.8 (0.0)</td><td>39.8</td><td>12.4</td><td></td><td>二</td><td></td><td></td><td>1</td></tr></table>",
+        "bbox": [
+            179,
+            101,
+            825,
+            366
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Table 2: Unlabeled parsing F1 results evaluated on the full WSJ10 and WSJ test set. Our language model has three layers, each of them provides a sequence of $\\hat { d } _ { t } ^ { f }$ . We provide the parsing performance for all layers. Results with RL-SPINN and ST-Gumbel are evaluated on the full WSJ (Williams et al., 2017). PRPN models are evaluated on the WSJ test set (Htut et al., 2018). We run the model with 5 different random seeds to calculate the average F1. The Accuracy columns represent the fraction of ground truth constituents of a given type that correspond to constituents in the model parses. We use the model with the best F1 score to report ADJP, NP, PP, and INTJ. WSJ10 baselines are from Klein & Manning (2002, CCM), Klein & Manning (2005, $\\mathrm { D M V + C C M }$ , and Bod (2006, UML-DOP). As the WSJ10 baselines are trained using POS tags, they are not strictly comparable with the latent tree learning results. Italics mark results that are worse than the random baseline. ",
+        "bbox": [
+            173,
+            376,
+            825,
+            517
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "ber of units in the hidden states, which is insufficient to take into account both long and short-term information. We also notice that the results for NPI test cases have unusually high variance across different hyper-parameters. This result maybe due to the non-syntactic cues discussed in Marvin & Linzen (2018). Despite this, ON-LSTM actually achieves better perplexity on the validation set. ",
+        "bbox": [
+            174,
+            546,
+            825,
+            602
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "5.4 LOGICAL INFERENCE ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            621,
+            362,
+            635
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "We also analyze the model’s performance on the logical inference task described in Bowman et al. (2015). This task is based on a language that has a vocabulary of six words and three logical operations, or, and, not. There are seven mutually exclusive logical relations that describe the relationship between two sentences: two types of entailment, equivalence, exhaustive and non-exhaustive contradiction, and two types of semantic independence. Similar to the natural language inference task, this logical inference task requires the model to predict the correct label given a pair of sentences. The train/test split is as described in the original codebase3, and $10 \\%$ of training set is set aside as the validation set. ",
+        "bbox": [
+            174,
+            646,
+            825,
+            757
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "We evaluate the ON-LSTM and the standard LSTM on this dataset. Given a pair of sentences $( s _ { 1 } , s _ { 2 } )$ , we feed both sentences into an RNN encoder, taking the last hidden state $( h _ { 1 } , h _ { 2 } )$ as the sentence embedding. The concatenation of $( h _ { 1 } , h _ { 2 } , h _ { 1 } \\circ h _ { 2 }$ , $\\mathrm { a b s } ( h _ { 1 } - h _ { 2 } ) )$ is used as input to a multi-layer classifier, which gives a probability distribution over seven labels. In our experiment, the RNN models were parameterised with 400 units in one hidden layer, and the input embedding size was 128. A dropout of 0.2 was applied between different layers. Both models are trained on sequences with 6 or less logical operations and tested on sequences with at most 12 operations. ",
+        "bbox": [
+            174,
+            765,
+            825,
+            863
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Figure 3 shows the performance of ON-LSTM and standard LSTM on the logical inference task. While both models achieve nearly $100 \\%$ accuracy on short sequences $\\left( \\le ~ 3 \\right)$ , ON-LSTM attains better performance on sequences longer then 3. The performance gap continues to increase on longer sequences $( \\geq 7 )$ that were not present during training. Hence, the ON-LSTM model shows better generalization while facing structured data with various lengths and comparing to the standard LSTM. A tree-structured model can achieve strong performance on this dataset (Bowman et al., 2015), since it is provided with the ground truth structure as input. The recursive application of the same composition function is well suited for this task. We also include the result of RRNet (Jacob et al., 2018), which can induce the latent tree structure from downstream tasks. Note that the results may not be comparable, because the hyper-parameters for training were not provided. ",
+        "bbox": [
+            176,
+            869,
+            823,
+            897
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "table",
+        "img_path": "images/ffbd055a21503e60f5bc385da5b86a698e0404db1b642e50e0aba0899ff0bb8f.jpg",
+        "table_caption": [],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>ON-LSTM LSTM</td></tr><tr><td>Short-Term Dependency</td></tr><tr><td>SUBJECT-VERB AGREEMENT:</td></tr><tr><td>Simple 0.99 1.00 0.98</td></tr><tr><td>In a sentential complement 0.95 0.92</td></tr><tr><td>Short VP coordination 0.89</td></tr><tr><td>In an object relative clause 0.84</td></tr><tr><td>In an object relative (no that) 0.78 0.81</td></tr><tr><td>REFLEXIVE ANAPHORA:</td></tr><tr><td>Simple 0.89 0.82</td></tr><tr><td>In a sentential complement 0.86 0.80</td></tr><tr><td>NEGATIVE POLARITY ITEMS:</td></tr><tr><td>Simple (grammatical vs.intrusive) 0.18 1.00</td></tr><tr><td>Simple (intrusive vs.ungrammatical) 0.50 0.01</td></tr><tr><td>Simple (grammatical vs.ungrammatical) 0.07 0.63</td></tr><tr><td>Long-Term Dependency</td></tr><tr><td>SUBJECT-VERB AGREEMENT: 0.74</td></tr><tr><td>Long VP coordination 0.74 0.67 0.68</td></tr><tr><td>Across a prepositional phrase Across a subject relative clause 0.66 0.60</td></tr><tr><td>Across an object relative clause 0.57 0.52</td></tr><tr><td>Across an object relative (no that) 0.54 0.51</td></tr><tr><td>REFLEXIVE ANAPHORA:</td></tr><tr><td>Across a relative clause 0.57 0.58</td></tr><tr><td>NEGATIVE POLARITY ITEMS:</td></tr><tr><td>0.59 0.95</td></tr><tr><td>Across a relative clause (grammatical vs.intrusive) 0.00</td></tr><tr><td>Across a relative clause (intrusive vs.ungrammatical) 0.20</td></tr><tr><td>Across a relative clause (grammatical vs.ungrammatical) 0.11 0.04</td></tr></table>",
+        "bbox": [
+            276,
+            102,
+            722,
+            473
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "image",
+        "img_path": "images/ed91d64cc37d6f0ca4506df1082e890ed2a4735029ba68080a4ceb7ae3aa00a6.jpg",
+        "image_caption": [
+            "Table 3: Overall accuracy for the ON-LSTM and LSTM on each test case. “Long-term dependency” means that an unrelated phrase (or a clause) exist between the targeted pair of words, while “shortterm dependency” means there is no such distraction. ",
+            "Figure 3: Test accuracy of the models, trained on short sequences $( \\leq 6 )$ in logic data. The horizontal axis indicates the length of the sequence, and the vertical axis indicates the accuracy of models performance on the corresponding test set. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            343,
+            558,
+            650,
+            713
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            811,
+            825,
+            924
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "6 CONCLUSION ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            102,
+            318,
+            117
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "In this paper, we propose ordered neurons, a novel inductive bias for recurrent neural networks. Based on this idea, we propose a novel recurrent unit, the ON-LSTM, which includes a new gating mechanism and a new activation function cumax(·). This brings recurrent neural networks closer to performing tree-like composition operations, by separately allocating hidden state neurons with long and short-term information. The model performance on unsupervised constituency parsing shows that the ON-LSTM induces the latent structure of natural language in a way that is coherent with human expert annotation. The inductive bias also enables ON-LSTM to achieve good performance on language modeling, long-term dependency, and logical inference tasks. ",
+        "bbox": [
+            174,
+            133,
+            825,
+            246
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "REFERENCES ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            268,
+            285,
+            284
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "David Alvarez-Melis and Tommi S Jaakkola. Tree-structured decoding with doubly-recurrent neural networks. 2016.   \nYoshua Bengio et al. Learning deep architectures for ai. Foundations and trends $\\textsuperscript { \\textregistered }$ in Machine Learning, 2(1):1–127, 2009.   \nRens Bod. An all-subtrees approach to unsupervised parsing. In Proceedings of the 21st International Conference on Computational Linguistics and the 44th annual meeting of the Association for Computational Linguistics, pp. 865–872. Association for Computational Linguistics, 2006.   \nSamuel R Bowman, Christopher Potts, and Christopher D Manning. Recursive neural networks can learn logical semantics. arXiv preprint arXiv:1406.1827, 2014.   \nSamuel R Bowman, Christopher D Manning, and Christopher Potts. Tree-structured composition in neural networks without tree-structured architectures. arXiv preprint arXiv:1506.04834, 2015.   \nSamuel R Bowman, Jon Gauthier, Abhinav Rastogi, Raghav Gupta, Christopher D Manning, and Christopher Potts. A fast unified model for parsing and sentence understanding. arXiv preprint arXiv:1603.06021, 2016.   \nEugene Charniak. Immediate-head parsing for language models. In Proceedings of the 39th Annual Meeting on Association for Computational Linguistics, pp. 124–131. Association for Computational Linguistics, 2001.   \nCiprian Chelba and Frederick Jelinek. Structured language modeling. Computer Speech & Language, 14(4):283–332, 2000.   \nStanley F Chen. Bayesian grammar induction for language modeling. In Proceedings of the 33rd annual meeting on Association for Computational Linguistics, pp. 228–235. Association for Computational Linguistics, 1995.   \nJihun Choi, Kang Min Yoo, and Sang-goo Lee. Learning to compose task-specific tree structures. In Proceedings of the 2018 Association for the Advancement of Artificial Intelligence (AAAI). and the 7th International Joint Conference on Natural Language Processing (ACL-IJCNLP), 2018.   \nNoam Chomsky. Three models for the description of language. IRE Transactions on information theory, 2(3):113–124, 1956.   \nNoam Chomsky. Aspects of the Theory of Syntax. The MIT Press, Cambridge, 1965. URL http:// www.amazon.com/Aspects-Theory-Syntax-Noam-Chomsky/dp/0262530074.   \nJunyoung Chung, Sungjin Ahn, and Yoshua Bengio. Hierarchical multiscale recurrent neural networks. arXiv preprint arXiv:1609.01704, 2016.   \nShay B Cohen, Dipanjan Das, and Noah A Smith. Unsupervised structure prediction with nonparallel multilingual guidance. In Proceedings of the Conference on Empirical Methods in Natural Language Processing, pp. 50–61. Association for Computational Linguistics, 2011. ",
+        "bbox": [
+            169,
+            289,
+            826,
+            928
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Stanislas Dehaene, Florent Meyniel, Catherine Wacongne, Liping Wang, and Christophe Pallier. The neural representation of sequences: from transition probabilities to algebraic patterns and linguistic trees. Neuron, 88(1):2–19, 2015. ",
+        "bbox": [
+            178,
+            103,
+            821,
+            146
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Chris Dyer, Adhiguna Kuncoro, Miguel Ballesteros, and Noah A Smith. Recurrent neural network grammars. In Proceedings of the 2016 Conference of the North American Chapter of the Association for Computational Linguistics: Human Language Technologies, pp. 199–209, 2016. ",
+        "bbox": [
+            178,
+            155,
+            821,
+            199
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Salah El Hihi and Yoshua Bengio. Hierarchical recurrent neural networks for long-term dependen cies. In Advances in neural information processing systems, pp. 493–499, 1996. ",
+        "bbox": [
+            176,
+            205,
+            818,
+            236
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Yarin Gal and Zoubin Ghahramani. A theoretically grounded application of dropout in recurrent neural networks. In Advances in neural information processing systems, pp. 1019–1027, 2016. ",
+        "bbox": [
+            174,
+            244,
+            820,
+            273
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Felix A Gers and E Schmidhuber. Lstm recurrent networks learn simple context-free and contextsensitive languages. IEEE Transactions on Neural Networks, 12(6):1333–1340, 2001. ",
+        "bbox": [
+            173,
+            281,
+            820,
+            311
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Edouard Grave, Armand Joulin, and Nicolas Usunier. Improving neural language models with a continuous cache. arXiv preprint arXiv:1612.04426, 2016. ",
+        "bbox": [
+            173,
+            319,
+            821,
+            349
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Edward Grefenstette, Karl Moritz Hermann, Mustafa Suleyman, and Phil Blunsom. Learning to transduce with unbounded memory. In Advances in Neural Information Processing Systems, pp. 1828–1836, 2015. ",
+        "bbox": [
+            173,
+            357,
+            823,
+            401
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Kristina Gulordava, Piotr Bojanowski, Edouard Grave, Tal Linzen, and Marco Baroni. Colorless green recurrent networks dream hierarchically. In Proc. of NAACL, pp. 1195–1205, 2018. ",
+        "bbox": [
+            174,
+            409,
+            823,
+            439
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Phu Mon Htut, Kyunghyun Cho, and Samuel R Bowman. Grammar induction with neural language models: An unusual replication. arXiv preprint arXiv:1808.10000, 2018. ",
+        "bbox": [
+            174,
+            446,
+            823,
+            477
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Hakan Inan, Khashayar Khosravi, and Richard Socher. Tying word vectors and word classifiers: A loss framework for language modeling. arXiv preprint arXiv:1611.01462, 2016. ",
+        "bbox": [
+            173,
+            484,
+            823,
+            515
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Athul Paul Jacob, Zhouhan Lin, Alessandro Sordoni, and Yoshua Bengio. Learning hierarchical structures on-the-fly with a recurrent-recursive model for sequences. In Proceedings of The Third Workshop on Representation Learning for NLP, pp. 154–158, 2018. ",
+        "bbox": [
+            173,
+            522,
+            823,
+            566
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Armand Joulin and Tomas Mikolov. Inferring algorithmic patterns with stack-augmented recurrent nets. In Advances in neural information processing systems, pp. 190–198, 2015. ",
+        "bbox": [
+            173,
+            574,
+            821,
+            604
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Yoon Kim, Yacine Jernite, David Sontag, and Alexander M Rush. Character-aware neural language models. In AAAI, pp. 2741–2749, 2016. ",
+        "bbox": [
+            174,
+            612,
+            823,
+            642
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Dan Klein and Christopher D Manning. A generative constituent-context model for improved grammar induction. In Proceedings of the 40th Annual Meeting on Association for Computational Linguistics, pp. 128–135. Association for Computational Linguistics, 2002. ",
+        "bbox": [
+            174,
+            650,
+            823,
+            694
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Dan Klein and Christopher D Manning. Accurate unlexicalized parsing. In Proceedings of the 41st Annual Meeting on Association for Computational Linguistics-Volume 1, pp. 423–430. Association for Computational Linguistics, 2003. ",
+        "bbox": [
+            176,
+            702,
+            821,
+            746
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Dan Klein and Christopher D Manning. Natural language grammar induction with a generative constituent-context model. Pattern recognition, 38(9):1407–1419, 2005. ",
+        "bbox": [
+            171,
+            753,
+            823,
+            784
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Hilda Koopman, Dominique Sportiche, and Edward Stabler. An introduction to syntactic analysis and theory, 2013. ",
+        "bbox": [
+            171,
+            791,
+            823,
+            820
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Jan Koutnik, Klaus Greff, Faustino Gomez, and Juergen Schmidhuber. A clockwork rnn. arXiv preprint arXiv:1402.3511, 2014. ",
+        "bbox": [
+            171,
+            829,
+            825,
+            858
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Adhiguna Kuncoro, Chris Dyer, John Hale, Dani Yogatama, Stephen Clark, and Phil Blunsom. Lstms can learn syntax-sensitive dependencies well, but modeling structure makes them better. In Proceedings of the 56th Annual Meeting of the Association for Computational Linguistics (Volume 1: Long Papers), volume 1, pp. 1426–1436, 2018. ",
+        "bbox": [
+            174,
+            867,
+            825,
+            924
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Yair Lakretz, German Kruszewski, Theo Desbordes, Dieuwke Hupkes, Stanislas Dehaene, and Marco Baroni. The emergence of number and syntax units in lstm language models. In Proc. of NAACL, 2019. ",
+        "bbox": [
+            174,
+            103,
+            823,
+            146
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Yann LeCun, Yoshua Bengio, and Geoffrey Hinton. Deep learning. Nature, 521(7553):436–444, 2015. ",
+        "bbox": [
+            174,
+            155,
+            821,
+            185
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Tsungnan Lin, Bill G Horne, Peter Tino, and C Lee Giles. Learning long-term dependencies is not as difficult with narx recurrent neural networks. Technical report, 1998. ",
+        "bbox": [
+            173,
+            194,
+            821,
+            223
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Tal Linzen, Emmanuel Dupoux, and Yoav Goldberg. Assessing the ability of lstms to learn syntaxsensitive dependencies. arXiv preprint arXiv:1611.01368, 2016. ",
+        "bbox": [
+            174,
+            233,
+            820,
+            263
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Mitchell P Marcus, Mary Ann Marcinkiewicz, and Beatrice Santorini. Building a large annotated corpus of english: The penn treebank. Computational linguistics, 19(2):313–330, 1993. ",
+        "bbox": [
+            173,
+            272,
+            823,
+            301
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Rebecca Marvin and Tal Linzen. Targeted syntactic evaluation of language models. arXiv preprint arXiv:1808.09031, 2018. ",
+        "bbox": [
+            173,
+            310,
+            823,
+            340
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Gabor Melis, Chris Dyer, and Phil Blunsom. On the state of the art of evaluation in neural language ´ models. arXiv preprint arXiv:1707.05589, 2017. ",
+        "bbox": [
+            173,
+            349,
+            823,
+            380
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Stephen Merity, Caiming Xiong, James Bradbury, and Richard Socher. Pointer sentinel mixture models. arXiv preprint arXiv:1609.07843, 2016. ",
+        "bbox": [
+            174,
+            387,
+            825,
+            417
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Stephen Merity, Nitish Shirish Keskar, and Richard Socher. Regularizing and Optimizing LSTM Language Models. arXiv preprint arXiv:1708.02182, 2017. ",
+        "bbox": [
+            171,
+            426,
+            823,
+            457
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Toma´s Mikolov. Statistical language models based on neural networks. ˇ Presentation at Google, Mountain View, 2nd April, 2012. ",
+        "bbox": [
+            169,
+            465,
+            823,
+            494
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Ofir Press and Lior Wolf. Using the output embedding to improve language models. In Proceedings of the 15th Conference of the European Chapter of the Association for Computational Linguistics: Volume 2, Short Papers, volume 2, pp. 157–163, 2017. ",
+        "bbox": [
+            178,
+            503,
+            823,
+            547
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Oren Rippel, Michael Gelbart, and Ryan Adams. Learning ordered representations with nested dropout. In International Conference on Machine Learning, pp. 1746–1754, 2014. ",
+        "bbox": [
+            174,
+            558,
+            821,
+            587
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Brian Roark. Probabilistic top-down parsing and language modeling. Computational linguistics, 27 (2):249–276, 2001. ",
+        "bbox": [
+            173,
+            595,
+            823,
+            626
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Dominiek Sandra and Marcus Taft. Morphological Structure, Lexical Representation and Lexical Access (RLE Linguistics C: Applied Linguistics): A Special Issue of Language and Cognitive Processes. Routledge, 2014. ",
+        "bbox": [
+            174,
+            633,
+            825,
+            678
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Jurgen Schmidhuber. Neural sequence chunkers. 1991. ¨ ",
+        "bbox": [
+            173,
+            686,
+            535,
+            703
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Jurgen Schmidhuber. Deep learning in neural networks: An overview.¨ Neural networks, 61:85–117, 2015. ",
+        "bbox": [
+            171,
+            712,
+            823,
+            741
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "John Schulman, Nicolas Heess, Theophane Weber, and Pieter Abbeel. Gradient estimation using stochastic computation graphs. In Advances in Neural Information Processing Systems, pp. 3528– 3536, 2015. ",
+        "bbox": [
+            173,
+            751,
+            823,
+            794
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Yikang Shen, Zhouhan Lin, Chin-Wei Huang, and Aaron Courville. Neural language modeling by jointly learning syntax and lexicon. arXiv preprint arXiv:1711.02013, 2017. ",
+        "bbox": [
+            171,
+            803,
+            823,
+            833
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Haoyue Shi, Hao Zhou, Jiaze Chen, and Lei Li. On tree-based neural sentence modeling. arXiv preprint arXiv:1808.09644, 2018. ",
+        "bbox": [
+            171,
+            842,
+            823,
+            872
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Richard Socher, Christopher D Manning, and Andrew Y Ng. Learning continuous phrase representations and syntactic parsing with recursive neural networks. In Proceedings of the NIPS-2010 Deep Learning and Unsupervised Feature Learning Workshop, volume 2010, pp. 1–9, 2010. ",
+        "bbox": [
+            174,
+            881,
+            825,
+            924
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Richard Socher, Alex Perelygin, Jean Wu, Jason Chuang, Christopher D Manning, Andrew $\\mathrm { N g }$ , and Christopher Potts. Recursive deep models for semantic compositionality over a sentiment treebank. In Proceedings of the 2013 conference on empirical methods in natural language processing, pp. 1631–1642, 2013. ",
+        "bbox": [
+            174,
+            103,
+            825,
+            160
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Guo-Zheng Sun, C Lee Giles, Hsing-Hen Chen, and Yee-Chun Lee. The neural network pushdown automaton: Model, stack and learning simulations. arXiv preprint arXiv:1711.05738, 2017. ",
+        "bbox": [
+            171,
+            167,
+            823,
+            198
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Kai Sheng Tai, Richard Socher, and Christopher D Manning. Improved semantic representations from tree-structured long short-term memory networks. arXiv preprint arXiv:1503.00075, 2015. ",
+        "bbox": [
+            174,
+            207,
+            821,
+            236
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Adina Williams, Nikita Nangia, and Samuel R Bowman. A broad-coverage challenge corpus for sentence understanding through inference. arXiv preprint arXiv:1704.05426, 2017. ",
+        "bbox": [
+            173,
+            243,
+            821,
+            273
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Adina Williams, Andrew Drozdov\\*, and Samuel R Bowman. Do latent tree learning models identify meaningful structure in sentences? Transactions of the Association of Computational Linguistics, 6:253–267, 2018. ",
+        "bbox": [
+            173,
+            281,
+            825,
+            324
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Shuangzhi Wu, Dongdong Zhang, Nan Yang, Mu Li, and Ming Zhou. Sequence-to-dependency neural machine translation. In Proceedings of the 55th Annual Meeting of the Association for Computational Linguistics (Volume 1: Long Papers), volume 1, pp. 698–707, 2017. ",
+        "bbox": [
+            174,
+            333,
+            825,
+            376
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Zhilin Yang, Zihang Dai, Ruslan Salakhutdinov, and William W Cohen. Breaking the softmax bottleneck: A high-rank rnn language model. arXiv preprint arXiv:1711.03953, 2017. ",
+        "bbox": [
+            173,
+            385,
+            823,
+            414
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Dani Yogatama, Phil Blunsom, Chris Dyer, Edward Grefenstette, and Wang Ling. Learning to compose words into sentences with reinforcement learning. arXiv preprint arXiv:1611.09100, 2016. ",
+        "bbox": [
+            173,
+            422,
+            826,
+            464
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Dani Yogatama, Yishu Miao, Gabor Melis, Wang Ling, Adhiguna Kuncoro, Chris Dyer, and Phil Blunsom. Memory architectures in recurrent neural network language models. 2018. ",
+        "bbox": [
+            174,
+            473,
+            823,
+            503
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Wojciech Zaremba, Ilya Sutskever, and Oriol Vinyals. Recurrent neural network regularization. arXiv preprint arXiv:1409.2329, 2014. ",
+        "bbox": [
+            174,
+            512,
+            821,
+            541
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Xingxing Zhang, Liang Lu, and Mirella Lapata. Top-down tree long short-term memory networks. arXiv preprint arXiv:1511.00060, 2015. ",
+        "bbox": [
+            174,
+            549,
+            821,
+            579
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Ganbin Zhou, Ping Luo, Rongyu Cao, Yijun Xiao, Fen Lin, Bo Chen, and Qing He. Generative neural machine for tree structures. CoRR, 2017. ",
+        "bbox": [
+            173,
+            587,
+            825,
+            616
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Julian Georg Zilly, Rupesh Kumar Srivastava, Jan Koutn´ık, and Jurgen Schmidhuber. Recurrent ¨ highway networks. arXiv preprint arXiv:1607.03474, 2016. ",
+        "bbox": [
+            171,
+            626,
+            825,
+            655
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Barret Zoph and Quoc V Le. Neural architecture search with reinforcement learning. arXiv preprint arXiv:1611.01578, 2016. ",
+        "bbox": [
+            169,
+            664,
+            825,
+            693
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "image",
+        "img_path": "images/dd6ff95e6ebe12f679c1c788e6d3f95aa5a1789f2e436a7f298d4852966b410e.jpg",
+        "image_caption": [
+            "Figure A.1: Left parses are from the 2nd layer of the ON-LSTM model, Right parses are converted from human expert annotations (removing all punctuations). "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            194,
+            137,
+            823,
+            522
+        ],
+        "page_idx": 13
+    }
+]

parse/train/BkrSv0lA-/BkrSv0lA-.md

@@ -0,0 +1,507 @@
+# LOSS-AWARE WEIGHT QUANTIZATION OF DEEP NET-WORKS
+
+Lu Hou, James T. Kwok   
+Department of Computer Science and Engineering   
+Hong Kong University of Science and Technology   
+Hong Kong   
+{lhouab, jamesk}@cse.ust.hk
+
+# ABSTRACT
+
+The huge size of deep networks hinders their use in small computing devices. In this paper, we consider compressing the network by weight quantization. We extend a recently proposed loss-aware weight binarization scheme to ternarization, with possibly different scaling parameters for the positive and negative weights, and $m$ -bit (where $m > 2$ ) quantization. Experiments on feedforward and recurrent neural networks show that the proposed scheme outperforms state-of-the-art weight quantization algorithms, and is as accurate (or even more accurate) than the full-precision network.
+
+# 1 INTRODUCTION
+
+The last decade has witnessed huge success of deep neural networks in various domains. Examples include computer vision, speech recognition, and natural language processing (LeCun et al., 2015). However, their huge size often hinders deployment to small computing devices such as cell phones and the internet of things. Many attempts have been recently made to reduce the model size. One common approach is to prune a trained dense network (Han et al., 2015; 2016). However, most of the pruned weights may come from the fully-connected layers where computations are cheap, and the resultant time reduction is insignificant. Li et al. (2017b) and Molchanov et al. (2017) proposed to prune filters in the convolutional neural networks based on their magnitudes or significance to the loss. However, the pruned network has to be retrained, which is again expensive.
+
+Another direction is to use more compact models. GoogleNet (Szegedy et al., 2015) and ResNet (He et al., 2016) replace the fully-connected layers with simpler global average pooling. However, they are also deeper. SqueezeNet (Iandola et al., 2016) reduces the model size by replacing most of the $3 \times 3$ filters with $1 \times 1$ filters. This is less efficient on smaller networks because the dense $1 \times 1$ convolutions are costly. MobileNet (Howard et al., 2017) compresses the model using separable depth-wise convolution. ShuffleNet (Zhang et al., 2017) utilizes pointwise group convolution and channel shuffle to reduce the computation cost while maintaining accuracy. However, highly optimized group convolution and depth-wise convolution implementations are required. Alternatively, Novikov et al. (2015) compressed the model by using a compact multilinear format to represent the dense weight matrix. The CP and Tucker decompositions have also been used on the kernel tensor in CNNs (Lebedev et al., 2014; Kim et al., 2016). However, they often need expensive fine-tuning.
+
+Another effective approach to compress the network and accelerate training is by quantizing each full-precision weight to a small number of bits. This can be further divided to two sub-categories, depending on whether pre-trained models are used (Lin et al., 2016a; Mellempudi et al., 2017) or the quantized model is trained from scratch (Courbariaux et al., 2015; Li et al., 2017a). Some of these also directly learn with low-precision weights, but they usually suffer from severe accuracy deterioration (Li et al., 2017a; Miyashita et al., 2016). By keeping the full-precision weights during learning, Courbariaux et al. (2015) pioneered the BinaryConnect algorithm, which uses only one bit for each weight while still achieving state-of-the-art classification results. Rastegari et al. (2016) further incorporated weight scaling, and obtained better results. Instead of simply finding the closest binary approximation of the full-precision weights, a loss-aware scheme is proposed in (Hou et al., 2017). Beyond binarization, TernaryConnect (Lin et al., 2016b) quantizes each weight to $\{ - 1 , 0 , 1 \}$ . Li & Liu (2016) and Zhu et al. (2017) added scaling to the ternarized weights, and DoReFa-Net (Zhou et al., 2016) further extended quantization to more than three levels. However, these methods do not consider the effect of quantization on the loss, and rely on heuristics in their procedures (Zhou et al., 2016; Zhu et al., 2017). Recently, a loss-aware low-bit quantized neural network is proposed in (Leng et al., 2017). However, it uses full-precision weights in the forward pass and the extra-gradient method (Vasilyev et al., 2010) for update, both of which are expensive.
+
+In this paper, we propose an efficient and disciplined ternarization scheme for network compression. Inspired by (Hou et al., 2017), we explicitly consider the effect of ternarization on the loss. This is formulated as an optimization problem which is then solved efficiently by the proximal Newton algorithm. When the loss surface’s curvature is ignored, the proposed method reduces to that of (Li & Liu, 2016), and is also related to the projection step of (Leng et al., 2017). Next, we extend it to (i) allow the use of different scaling parameters for the positive and negative weights; and (ii) the use of $m$ bits (where $m > 2$ ) for weight quantization. Experiments on both feedforward and recurrent neural networks show that the proposed quantization scheme outperforms state-of-the-art algorithms.
+
+Notations: For a vector $\mathbf { x }$ , $\sqrt { \mathbf { x } }$ denotes the element-wise square root (i.e., $[ { \sqrt { \mathbf { x } } } ] _ { i } = { \sqrt { x _ { i } } } )$ , $| \mathbf { x } |$ is the element-wise absolute value, $\begin{array} { r } { \| \mathbf { x } \| _ { p } = ( \sum _ { i } | x _ { i } | ^ { p } ) ^ { \frac { 1 } { p } } } \end{array}$ is its $p$ -norm, and $\mathrm { D i a g ( x ) }$ returns a diagonal matrix with $\mathbf { x }$ on the diagonal. For two vectors $\mathbf { x }$ and $\mathbf { y }$ , $\mathfrak { c } \odot$ y denotes the element-wise multiplication and $\mathbf { x } \oslash \mathbf { y }$ the element-wise division. Given a threshold $\Delta$ , $\mathbf { I } _ { \Delta } ( \mathbf { x } )$ returns a vector such that $[ { \bf I } _ { \Delta } ( { \bf x } ) ] _ { i } = 1$ if $x _ { i } > \Delta$ , $- 1$ if $x _ { i } < - \Delta$ , and 0 otherwise. $\mathbf { I } _ { \Delta } ^ { + } ( \mathbf { x } )$ considers only the positive threshold, i.e., $[ \mathbf { I } _ { \Delta } ^ { + } ( \mathbf { x } ) ] _ { i } = 1$ if $x _ { i } > \Delta$ , and 0 otherwise. Similarly, $[ \mathbf { I } _ { \Delta } ^ { - } ( \mathbf { x } ) ] _ { i } = - 1$ if $x _ { i } < - \Delta$ , and 0 otherwise. For a matrix $\mathbf { X }$ , vec $( \mathbf { X } )$ returns a vector by stacking all the columns of $\mathbf { X }$ , and diag $( \mathbf { X } )$ returns a vector whose entries are from the diagonal of $\mathbf { X }$ .
+
+# 2 RELATED WORK
+
+Let the full-precision weights from all $L$ layers be $\mathbf { w } ~ = ~ [ \mathbf { w } _ { 1 } ^ { \top } , \mathbf { w } _ { 2 } ^ { \top } , \dots , \mathbf { w } _ { L } ^ { \top } ] ^ { \top }$ , where $\begin{array} { r l } { \mathbf { w } _ { l } } & { { } = } \end{array}$ $\mathrm { v e c } ( \mathbf { W } _ { l } )$ , and $\mathbf { W } _ { l }$ is the weight matrix at layer $l$ . The corresponding quantized weights will be denoted $\hat { \mathbf { w } } = [ \hat { \mathbf { w } } _ { 1 } ^ { \top } , \hat { \mathbf { w } } _ { 2 } ^ { \top } , \ldots , \tilde { \mathbf { w } } _ { L } ^ { \top } ] ^ { \top }$ .
+
+# 2.1 WEIGHT BINARIZED NETWORKS
+
+In BinaryConnect (Courbariaux et al., 2015), each element of $\mathbf { w } _ { l }$ is binarized to $- 1$ or $+ 1$ by using the sign function: Binarize $( \mathbf { w } _ { l } ) = \mathrm { s i g n } ( \mathbf { w } _ { l } )$ . In the Binary-Weight-Network (BWN) (Rastegari et al., 2016), a scaling parameter is also included, i.e., Binarize $\left( \mathbf { w } _ { l } \right) = \alpha _ { l } \mathbf { b } _ { l }$ , where $\alpha _ { l } > 0$ , $\mathbf { b } _ { l } \in$ $\{ - 1 , + 1 \} ^ { n _ { l } }$ and $n _ { l }$ is the number of weights in $\mathbf { w } _ { l }$ . By minimizing the difference between $\mathbf { w } _ { l }$ and $\alpha _ { l } \mathbf { b } _ { l }$ , the optimal $\alpha _ { l } , \mathbf { b } _ { l }$ have the simple form: $\alpha _ { l } = \| \dot { \mathbf { w } } _ { l } \| _ { 1 } / n _ { l }$ , and ${ \bf b } _ { l } = \mathrm { s i g n } ( { \bf w } _ { l } )$ .
+
+Instead of simply finding the best binary approximation for the full-precision weight $\mathbf { w } _ { l } ^ { t }$ at iteration $t$ , the loss-aware binarized network (LAB) directly minimizes the loss w.r.t. the binarized weight $\alpha _ { l } ^ { t } \mathbf { b } _ { l } ^ { t }$ (Hou et al., 2017). Let $\mathbf { d } _ { l } ^ { t - 1 }$ be a vector containing the diagonal of an approximate Hessian of the loss. It can be shown that $\begin{array} { r } { \dot { \alpha } _ { l } ^ { t } = \lVert \mathbf { d } _ { l } ^ { t - 1 } \odot \mathbf { w } _ { l } ^ { t } \rVert _ { 1 } / \lVert \mathbf { d } _ { l } ^ { t - 1 } \rVert _ { 1 } } \end{array}$ and $\mathbf { b } _ { l } ^ { t } = \mathrm { s i g n } ( \mathbf { w } _ { l } ^ { t } )$ .
+
+# 2.2 WEIGHT TERNARIZED NETWORKS
+
+In a weight ternarized network, zero is used as an additional quantized value. In TernaryConnect (Lin et al., 2016b), each weight value is clipped to $[ - 1 , 1 ]$ before quantization, and then a non-negative weight $[ \mathbf { w } _ { l } ^ { t } ] _ { i }$ is stochastically quantized to 1 with probability $\left[ \mathbf { w } _ { l } ^ { t } \right] _ { i }$ (and 0 otherwise). When $\left[ \mathbf { w } _ { l } ^ { t } \right] _ { i }$ is negative, it is quantized to $- 1$ with probability $- [ \mathbf { w } _ { l } ^ { t } ] _ { i }$ , and 0 otherwise.
+
+In the ternary weight network (TWN) (Li & Liu, 2016), $\mathbf { w } _ { l } ^ { t }$ is quantized to $\hat { \mathbf { w } } _ { l } ^ { t } = \alpha _ { l } ^ { t } \mathbf { I } _ { \Delta _ { l } ^ { t } } ( \mathbf { w } _ { l } ^ { t } )$ , where $\Delta _ { l } ^ { t }$ is a threshold (i.e., $[ \hat { \mathbf { w } } _ { l } ^ { t } ] _ { i } = \alpha _ { l } ^ { t }$ if $[ \mathbf { w } _ { l } ^ { t } ] _ { i } > \Delta _ { l } ^ { t }$ , $- \alpha _ { l } ^ { t }$ if $[ { \bf w } _ { l } ^ { t } ] _ { i } < - \Delta _ { l } ^ { t }$ and 0 otherwise). To obtain $\Delta _ { l } ^ { t }$ and $\alpha _ { l } ^ { t }$ , TWN minimizes the $\ell _ { 2 }$ -distance between the full-precision and ternarized
+
+weights, leading to
+
+$$
+\Delta _ { l } ^ { t } = \arg \operatorname* { m a x } _ { \Delta > 0 } \frac { 1 } { \| \mathbf { I } _ { \Delta } ( \mathbf { w } _ { l } ^ { t } ) \| _ { 1 } } \left( \sum _ { i : [ \mathbf { w } _ { l } ^ { t } ] _ { i } ] > \Delta _ { l } ^ { t } } \vert [ \mathbf { w } _ { l } ^ { t } ] _ { i } \vert \right) ^ { 2 } , \alpha _ { l } ^ { t } = \frac { 1 } { \| \mathbf { I } _ { \Delta _ { l } ^ { t } } ( \mathbf { w } _ { l } ^ { t } ) \| _ { 1 } } \sum _ { i : [ \mathbf { w } _ { l } ^ { t } ] _ { i } ] > \Delta _ { l } ^ { t } } \vert [ \mathbf { w } _ { l } ^ { t } ] _ { i } \vert .
+$$
+
+However, $\Delta _ { l } ^ { t }$ in (1) is difficult to solve. Instead, TWN simply sets $\Delta _ { l } ^ { t } = 0 . 7 \cdot \mathbf { E } ( | \mathbf { w } _ { l } ^ { t } | )$ in practice.
+
+In TWN, one scaling parameter $( \alpha _ { l } ^ { t } )$ is used for both the positive and negative weights at layer $l$ . In the trained ternary quantization (TTQ) network (Zhu et al., 2017), different scaling parameters $( \alpha _ { l } ^ { t }$ and $\beta _ { l } ^ { t } .$ ) are used. The weight $\mathbf { w } _ { l } ^ { t }$ is thus quantized to $\hat { \mathbf { w } } _ { l } ^ { t } = \alpha _ { l } ^ { t } \mathbf { I } _ { \Delta _ { l } ^ { t } } ^ { + } ( \mathbf { w } _ { l } ^ { t } ) + \beta _ { l } ^ { t } \mathbf { I } _ { \Delta _ { l } ^ { t } } ^ { - } ( \mathbf { w } _ { l } ^ { t } )$ . The scaling parameters are learned by gradient descent. As for $\Delta _ { l } ^ { t }$ , two heuristics are used. The first sets $\Delta _ { l } ^ { t }$ to a constant fraction of $\operatorname* { m a x } ( | \mathbf { w } _ { l } ^ { t } | )$ , while the second sets $\Delta _ { l } ^ { t }$ such that at all layers are equally sparse.
+
+# 2.3 WEIGHT QUANTIZED NETWORKS
+
+In a weight quantized network, $m$ bits (where $\begin{array} { r l r } { m } & { { } \geq } & { 2 ) } \end{array}$ are used to represent each weight. Let $\mathcal { Q }$ be a set of $( 2 k + 1 )$ quantized values, where $\textit { k } ~ = ~ 2 ^ { m - 1 ^ { * } } - 1$ . The two popular choices of $\mathcal { Q }$ are $\{ - 1 , - \frac { k - 1 } { k } , \ldots , - \frac { 1 } { k } , 0 , \frac { 1 } { k } , \ldots , \frac { k - 1 } { k } , 1 \}$ (linear quantization), and $\left\{ - 1 , - { \frac { 1 } { 2 } } , \ldots , - { \frac { 1 } { 2 ^ { k - 1 } } } , 0 , { \frac { 1 } { 2 ^ { k - 1 } } } , \ldots , { \frac { 1 } { 2 } } , 1 \right\}$ (logarithmic quantization). By limiting the quantized values to powers of two, logarithmic quantization is advantageous in that expensive floating-point operations can be replaced by cheaper bit-shift operations. When $m = 2$ , both schemes reduce to $\mathcal { Q } = \{ - 1 , 0 , 1 \}$ .
+
+In the DoReFa-Net (Zhou et al., 2016), weight $\mathbf { w } _ { l } ^ { t }$ is heuristically quantized to $m$ -bit, with:1
+
+$$
+[ \hat { \mathbf { w } } _ { l } ^ { t } ] _ { i } = 2 \cdot \mathrm { q u a n t i z e } _ { m } \left( \frac { \operatorname { t a n h } ( [ \mathbf { w } _ { l } ^ { t } ] _ { i } ) } { 2 \operatorname* { m a x } ( | \operatorname { t a n h } ( [ \mathbf { w } _ { l } ^ { t } ] _ { i } ) | ) } + \frac { 1 } { 2 } \right) - 1
+$$
+
+in $\{ - 1 , - \frac { 2 ^ { m } - 2 } { 2 ^ { m } - 1 } , \ldots , - \frac { 1 } { 2 ^ { m } - 1 } , \frac { 1 } { 2 ^ { m } - 1 } , \ldots , \frac { 2 ^ { m } - 2 } { 2 ^ { m } - 1 } , 1 \}$ − 12m−1 , 12m−1 , . . . , 2m−22m−1 , 1}, where quantizem(x) = 2 $\ l _ { m } ( x ) \ = \ { \frac { 1 } { 2 ^ { m } - 1 } } \mathrm { r o u n d } ( ( 2 ^ { m } \ -$ $1 ) x$ ). Similar to loss-aware binarization (Hou et al., 2017), Leng et al. (2017) proposed a loss-aware quantized network called low-bit neural network (LBNN). The alternating direction method of multipliers (ADMM) (Boyd et al., 2011) is used for optimization. At the tth iteration, the full-precision weight $\mathbf { w } _ { l } ^ { t }$ is first updated by the method of extra-gradient (Vasilyev et al., 2010):
+
+$$
+\begin{array} { r } { \tilde { \mathbf { w } } _ { l } ^ { t } = \mathbf { w } _ { l } ^ { t - 1 } - \eta ^ { t } \nabla _ { l } \mathcal { L } ( \mathbf { w } _ { l } ^ { t - 1 } ) , \mathbf { w } _ { l } ^ { t } = \mathbf { w } _ { l } ^ { t - 1 } - \eta ^ { t } \nabla _ { l } \mathcal { L } ( \tilde { \mathbf { w } } _ { l } ^ { t } ) , } \end{array}
+$$
+
+where $\mathcal { L }$ is the augmented Lagrangian in the ADMM formulation, and $\eta ^ { t }$ is the stepsize. Next, $\mathbf { w } _ { l } ^ { t }$ is projected to the space of $m$ -bit quantized weights so that $\hat { \mathbf { w } } _ { l } ^ { t }$ is of the form $\alpha _ { l } \mathbf { b } _ { l }$ , where $\alpha _ { l } > 0$ , and $\mathbf { b } _ { l } \in \left\{ - 1 , - { \frac { 1 } { 2 } } , \ldots , - { \frac { 1 } { 2 ^ { k - 1 } } } , 0 , { \frac { 1 } { 2 ^ { k - 1 } } } , \ldots , { \frac { 1 } { 2 } } , 1 \right\}$ .
+
+# 3 LOSS-AWARE QUANTIZATION
+
+# 3.1 TERNARIZATION USING PROXIMAL NEWTON ALGORITHM
+
+In weight ternarization, TWN simply finds the closest ternary approximation of the full precision weight at each iteration, while TTQ sets the ternarization threshold heuristically. Inspired by LAB (for binarization), we consider the loss explicitly during quantization and obtain the quantization thresholds and scaling parameter by solving an optimization problem.
+
+As in TWN, the weight $\mathbf { w } _ { l }$ is ternarized as $\hat { \mathbf { w } } _ { l } = \alpha _ { l } \mathbf { b } _ { l }$ , where $\alpha _ { l } > 0$ and ${ \bf b } _ { l } \in \{ - 1 , 0 , 1 \} ^ { n _ { l } }$ . Given a loss function $\ell$ , we formulate weight ternarization as the following optimization problem:
+
+$$
+\operatorname* { m i n } _ { \hat { \mathbf { w } } } \ \ell ( \hat { \mathbf { w } } ) : \ \hat { \mathbf { w } } _ { l } = \alpha _ { l } \mathbf { b } _ { l } , \ \alpha _ { l } > 0 , \ \mathbf { b } _ { l } \in \mathcal { Q } ^ { n _ { l } } , \ l = 1 , \ldots , L ,
+$$
+
+where $\mathcal { Q }$ is the set of desired quantized values. As in LAB, we will solve this using the proximal Newton method (Lee et al., 2014; Rakotomamonjy et al., 2016). At iteration $t$ , the objective is replaced by the second-order expansion
+
+$$
+\ell ( \hat { \mathbf { w } } ^ { t - 1 } ) + \nabla \ell ( \hat { \mathbf { w } } ^ { t - 1 } ) ^ { \top } ( \hat { \mathbf { w } } - \hat { \mathbf { w } } ^ { t - 1 } ) + \frac { 1 } { 2 } ( \hat { \mathbf { w } } - \hat { \mathbf { w } } ^ { t - 1 } ) ^ { \top } \mathbf { H } ^ { t - 1 } ( \hat { \mathbf { w } } - \hat { \mathbf { w } } ^ { t - 1 } ) ,
+$$
+
+where $\mathbf { H } ^ { t - 1 }$ is an estimate of the Hessian of $\ell$ at $\hat { \mathbf { w } } ^ { t - 1 }$ . We use the diagonal equilibration preconditioner (Dauphin et al., 2015), which is robust in the presence of saddle points and also readily available in popular stochastic deep network optimizers such as Adam (Kingma & Ba, 2015). Let $\mathbf { D } _ { l }$ be the approximate diagonal Hessian at layer $l$ . We use $\mathbf { D } = \mathrm { D i a g } ( [ \mathrm { d i a g } ( \mathbf { \tilde { D _ { 1 } } } ) ^ { \top } , \dots , \mathrm { d i a g } ( \mathbf { \tilde { D } } _ { L } ) ^ { \top } ] ^ { \top } )$ as an estimate of $\mathbf { H }$ . Substituting (4) into (3), we solve the following subproblem at the tth iteration:
+
+$$
+\begin{array} { r l } { \operatorname* { m i n } _ { \hat { \mathbf { w } } ^ { t } } } & { \nabla \ell ( \hat { \mathbf { w } } ^ { t - 1 } ) ^ { \top } ( \hat { \mathbf { w } } ^ { t } - \hat { \mathbf { w } } ^ { t - 1 } ) + \displaystyle \frac { 1 } { 2 } ( \hat { \mathbf { w } } ^ { t } - \hat { \mathbf { w } } ^ { t - 1 } ) ^ { \top } \mathbf { D } ^ { t - 1 } ( \hat { \mathbf { w } } ^ { t } - \hat { \mathbf { w } } ^ { t - 1 } ) } \\ { \mathrm { s . t . } } & { \quad \hat { \mathbf { w } } _ { l } ^ { t } = \alpha _ { l } ^ { t } \mathbf { b } _ { l } ^ { t } , \ \alpha _ { l } ^ { t } > 0 , \ \mathbf { b } _ { l } ^ { t } \in \mathcal { Q } ^ { n _ { l } } , \ l = 1 , \dots , L . } \end{array}
+$$
+
+Proposition 3.1 The objective in (5) can be rewritten as
+
+$$
+\operatorname* { m i n } _ { \hat { \mathbf { w } } ^ { t } } \frac { 1 } { 2 } \sum _ { l = 1 } ^ { L } \left( \sqrt { \mathbf { d } _ { l } ^ { t - 1 } } ^ { \top } ( \hat { \mathbf { w } } _ { l } ^ { t } - \mathbf { w } _ { l } ^ { t } ) \right) ^ { 2 } ,
+$$
+
+where $\mathbf { d } _ { l } ^ { t - 1 } \equiv d i a g ( \mathbf { D } _ { l } ^ { t - 1 } )$ , and
+
+$$
+\mathbf { w } _ { l } ^ { t } \equiv \hat { \mathbf { w } } _ { l } ^ { t - 1 } - \nabla _ { l } \ell \big ( \hat { \mathbf { w } } ^ { t - 1 } \big ) \oslash \mathbf { d } _ { l } ^ { t - 1 } .
+$$
+
+Obviously, this objective can be minimized layer by layer. Each proximal Newton iteration thus consists of two steps: (i) Obtain $\mathbf { w } _ { l } ^ { t }$ in (7) by gradient descent along $\nabla _ { l } \ell \big ( \hat { \mathbf { w } } ^ { t - 1 } \big )$ , which is preconditioned by the adaptive learning rate $1 \bigcirc \mathbf { d } _ { l } ^ { t - 1 }$ so that the rescaled dimensions have similar curvatures; (ii) Quantize $\mathbf { w } _ { l } ^ { t }$ to $\hat { \mathbf { w } } _ { l } ^ { t }$ by minimizing the scaled difference between $\hat { \mathbf { w } } _ { l } ^ { t }$ and $\mathbf { w } _ { l } ^ { t }$ in (6). Intuitively, when the curvature is low $\big [ \mathbf { d } _ { l } ^ { t - 1 } \big ] _ { i }$ is small), the loss is not sensitive to the weight and ternarization error can be less penalized. When the loss surface is steep, ternarization has to be more accurate.
+
+Though the constraint in (6) is more complicated than that in LAB, interestingly the following simple relationship can still be obtained for weight ternarization.
+
+Proposition 3.2 With $\mathcal { Q } = \{ - 1 , 0 , 1 \}$ , and the optimal $\hat { \mathbf { w } } _ { l } ^ { t }$ in (6) of the form αb. For a fixed b, α = kbdt−1l wtl k1t−1 ; whereas when α is fixed, b = Iα/2(wtl ).
+
+Equivalently, b can be written as $\Pi _ { \mathcal { Q } } ( \mathbf { w } _ { l } ^ { t } / \alpha )$ , where $\Pi _ { \mathcal { Q } } ( \cdot )$ projects each entry of the input argument to the nearest element in $\mathcal { Q }$ . Further discussions on how to solve for $\alpha _ { l } ^ { t }$ will be presented in Sections 3.1.1 and 3.1.2. When the curvature is the same for all dimensions at layer $l$ , the following Corollary shows that the solution above reduces that of TWN.
+
+Corollary 3.1 When $\mathbf { D } _ { l } ^ { t - 1 } = \lambda \mathbf { I }$ , $\alpha _ { l } ^ { t }$ reduces to the TWN solution in $( l )$ with $\Delta _ { l } ^ { t } = \alpha _ { l } ^ { t } / 2$ .
+
+In other words, TWN corresponds to using the proximal gradient algorithm, while the proposed method corresponds to using the proximal Newton algorithm with diagonal Hessian. In composite optimization, it is known that the proximal Newton algorithm is more efficient than the proximal gradient algorithm (Lee et al., 2014; Rakotomamonjy et al., 2016). Moreover, note that the interesting relationship $\Delta _ { l } ^ { t } = \alpha _ { l } ^ { t } / 2$ is not observed in TWN, while TTQ completely neglects this relationship.
+
+In LBNN (Leng et al., 2017), its projection step uses an objective which is similar to (6), but without using the curvature information. Besides, their $\mathbf { w } _ { l } ^ { t }$ is updated with the extra-gradient in (2), which doubles the number of forward, backward and update steps, and can be costly. Moreover, LBNN uses full-precision weights in the forward pass, while all other quantization methods including ours use quantized weights (which eliminates most of the multiplications and thus faster training).
+
+When (i) $\ell$ is continuously differentiable with Lipschitz-continuous gradient (i.e., there exists $\beta > 0$ such that $\left\| \nabla \ell ( \mathbf { u } ) - \nabla \ell ( \mathbf { v } ) \right\| _ { 2 } \leq \beta \left\| \mathbf { u } - \mathbf { v } \right\| _ { 2 }$ for any $\mathbf { u } , \mathbf { v } ,$ ); (ii) $\ell$ is bounded from below; and (iii) $[ \mathbf { d } _ { l } ^ { t } ] _ { k } > \ddot { \beta \ } \forall l , \dot { k } , \dot { t } .$ , it can be shown that the objective of (3) produced by the proximal Newton algorithm (with solution in Proposition 3.2) converges (Hou et al., 2017). In practice, it is important to keep the full-precision weights during update (Courbariaux et al., 2015). Hence, we replace (7) by $\mathbf { w } _ { l } ^ { t } \dot { } - \mathbf { w } _ { l } ^ { t - 1 } \dot { } - \nabla _ { l } \ell ( \hat { \mathbf { w } } ^ { t - 1 } ) \bigcirc \mathbf { d } _ { l } ^ { t - 1 }$ . The whole procedure, which is called Loss-Aware Ternarization (LAT), is shown in Algorithm 3 of Appendix B. It is similar to Algorithm 1 of LAB (Hou et al., 2017), except that $\alpha _ { l } ^ { t }$ and $\mathbf { b } _ { l } ^ { t }$ are computed differently. In step 4, following (Li & Liu, 2016), we first rescale input $\mathbf { x } _ { l } ^ { t - 1 }$ with $\alpha _ { l }$ , so that multiplications in dot products and convolutions become additions. Algorithm 3 can also be easily extended to ternarize weights in recurrent networks. Interested readers are referred to (Hou et al., 2017) for details.
+
+# 3.1.1 EXACT SOLUTION OF $\alpha _ { l } ^ { t }$
+
+To simplify notations, we drop the superscripts and subscripts. From Proposition 3.2,
+
+$$
+\alpha = \frac { \| \mathbf { b } \odot \mathbf { d } \odot \mathbf { w } \| _ { 1 } } { \| \mathbf { b } \odot \mathbf { d } \| _ { 1 } } , \ \mathbf { b } = \mathbf { I } _ { \alpha / 2 } ( \mathbf { w } ) .
+$$
+
+We now consider how to solve for $\alpha$ . First, we introduce some notations. Given a vector $\mathbf { x } = [ x _ { 1 } , x _ { 2 } , \ldots , x _ { n } ]$ , and an indexing vector $\mathbf { s } \in \mathbb { R } ^ { n }$ whose entries are a permutation of $\{ 1 , \ldots , n \}$ , $\mathrm { p e r m } _ { \mathbf { s } } ( \mathbf { x } )$ returns the vector $[ x _ { s _ { 1 } } , x _ { s _ { 2 } } , \ldots x _ { s _ { n } } ]$ , and $\begin{array} { r } { \mathsf { c u m } ( \mathbf { x } ) = [ x _ { 1 } , \sum _ { i = 1 } ^ { 2 } x _ { i } , \hdots , \sum _ { i = 1 } ^ { n } x _ { i } ] } \end{array}$ returns partial sums for elements in $\mathbf { x }$ . For example, let $\mathbf { a } ~ = ~ \left[ 1 , - 1 , - 2 \right]$ , and $\mathbf { b } ~ = ~ [ 3 , 1 , 2 ]$ . Then, $\mathrm { \bar { p e r m } _ { b } ( a ) = [ - 2 , 1 , - 1 ] }$ and $\mathtt { c u m } ( \mathbf { a } ) = [ 1 , 0 ^ { \overline { { \prime } } } , - 2 ]$ .
+
+We sort elements of $| \mathbf { w } |$ in descending order, and let the vector containing the sorted indices be s. For example, if $\mathbf { w } = [ 1 , 0 , - 2 ]$ , then $\mathbf { s } = [ 3 , 1 , 2 ]$ . From (8),
+
+$$
+\alpha = \frac { \| \mathbf { I } _ { \alpha / 2 } ( \mathbf { w } ) \odot \mathbf { d } \odot \mathbf { w } \| _ { 1 } } { \| \mathbf { I } _ { \alpha / 2 } ( \mathbf { w } ) \odot \mathbf { d } \| _ { 1 } } = \frac { [ \mathrm { c u m } ( \mathrm { p e r m } _ { \mathbf { s } } ( | \mathbf { d } \odot \mathbf { w } | ) ) ] _ { j } } { [ \mathrm { c u m } ( \mathrm { p e r m } _ { \mathbf { s } } ( | \mathbf { d } | ) ) ] _ { j } } = 2 c _ { j } ,
+$$
+
+where $\mathbf { c } = \mathbf { c u m } ( \mathrm { p e r m } _ { \mathbf { s } } ( | \mathbf { d } \odot \mathbf { w } | ) ) \oslash \mathbf { c u m } ( \mathrm { p e r m } _ { \mathbf { s } } ( \mathbf { d } ) ) \oslash 2$ , and $j$ is the index such that
+
+$$
+[ \mathrm { p e r m } _ { \mathbf { s } } ( | \mathbf { w } | ) ] _ { j } > c _ { j } > [ \mathrm { p e r m } _ { \mathbf { s } } ( | \mathbf { w } | ) ] _ { j + 1 } .
+$$
+
+For simplicity of notations, let the dimensionality of w (and thus also of $\mathbf { c }$ ) be $n$ , and the operation find(condition $\mathbf { \tau } ( \mathbf { x } )$ ) returns all indices in $\mathbf { x }$ that satisfies the condition. It is easy to see that any $j$ satisfying (10) is in $S \equiv \mathrm { f i n d } ( [ \mathrm { p e r m } _ { \mathbf { s } } ( | { \mathbf { w } } | ) ] _ { [ 1 : ( n - 1 ) ] } - \mathbf { c } _ { [ 1 : ( n - 1 ) ] } ) \odot ( [ \mathrm { p e r m } _ { \mathbf { s } } ( | { \mathbf { w } } | ) ] _ { [ 2 : n ] } - \mathbf { c } _ { [ 1 : n - 1 ] } ) < \delta$ 0), where $\mathbf { c } _ { [ 1 : ( n - 1 ) ] }$ is the subvector of c with elements in the index range 1 to $n - 1$ . The optimal $\alpha \ : ( = \ : 2 c _ { j } )$ ) is then the one which yields the smallest objective in (6), which can be simplified by Proposition 3.3 below. The procedure is shown in Algorithm 1.
+
+Propositio $\begin{array} { r l r } & { } & { \textbf { n 3 3 } T h e o p t i m a l \alpha _ { l } ^ { t } \ o f ( 6 ) e q u a l s \ 2 \arg \operatorname* { m a x } _ { c _ { j } : j \in S } c _ { j } ^ { 2 } \cdot \big [ c u m ( p e r m _ { \mathrm { s } } ( \mathbf { d } _ { l } ^ { t - 1 } ) ) \big ] _ { j } . } \end{array}$
+
+# Algorithm 1 Exact solver of (6)
+
+1: Input: full-precision weight $\mathbf { w } _ { l } ^ { t }$ , diagonal entries of the approximate Hessian $\mathbf { d } _ { l } ^ { t - 1 }$ .   
+2: $\mathbf { s } = \arg \operatorname { s o r t } ( | \mathbf { w } _ { l } ^ { t } | )$ ;   
+3: $\mathbf { c } = \mathrm { c u m } ( \mathrm { p e r m } _ { \mathbf { s } } ( | \mathbf { d } _ { l } ^ { t - 1 } \odot \mathbf { w } _ { l } ^ { t } | ) ) \oslash \mathrm { c u m ( p e r m } _ { \mathbf { s } } ( \mathbf { d } _ { l } ^ { t - 1 } ) ) \oslash 2 ;$   
+4: $\begin{array} { r } { S = \mathrm { { f i n d } } ( ( \left[ { \mathrm { p e r m } } _ { \mathrm { s } } ( | \mathbf { w } _ { l } ^ { t } | ) \right] _ { [ 1 : ( n - 1 ) ] } - \mathbf { c } _ { [ 1 : ( n - 1 ) ] } ) ( } \end{array}$ $\odot$ ([perms(|wtl |)][2:n] − c[1:n−1]) < 0);   
+5: $\begin{array} { r } { \alpha _ { l } ^ { t } = 2 \arg \operatorname* { m a x } _ { c _ { j } : j \in \mathcal { S } } c _ { j } ^ { 2 } \cdot [ \mathsf { c u m } ( \mathsf { p e r m } _ { \mathsf { s } } ( \mathbf { d } _ { l } ^ { t - 1 } ) ) ] _ { j } } \end{array}$ ;   
+6: $\mathbf { b } _ { l } ^ { t } = \mathbf { I } _ { \alpha _ { l } ^ { t } / 2 } ( \mathbf { w } _ { l } ^ { t } )$ ;   
+7: Output: $\hat { \mathbf { w } } _ { l } ^ { t } = \alpha _ { l } ^ { t } \mathbf { b } _ { l } ^ { t }$ .
+
+# 3.1.2 APPROXIMATE SOLUTION OF $\alpha _ { l } ^ { t }$
+
+In case the sorting operation in step 2 is expensive, $\alpha _ { l } ^ { t }$ and $\mathbf { b } _ { l } ^ { t }$ can be obtained by alternating the iteration in Proposition 3.2 (Algorithm 2). Empirically, it converges very fast, usually in 5 iterations.
+
+# Algorithm 2 Approximate solver for (6).
+
+1: Input: $\mathbf { b } _ { l } ^ { t - 1 }$ , full-precision weight $\mathbf { w } _ { l } ^ { t }$ , diagonal entries of the approximate Hessian $\mathbf { d } _ { l } ^ { t - 1 }$ .   
+2: Initialize: $\alpha = 1 . 0$ , $\alpha _ { \mathrm { o l d } } = 0 . 0 , \mathbf { b } = \mathbf { b } _ { l } ^ { t - 1 }$ , $\epsilon = 1 0 ^ { - 6 }$ ;   
+3: while $| \alpha - \alpha _ { \mathrm { o l d } } | > \epsilon$ do   
+4: $\alpha _ { 0 } { } _ { \mathrm { l d } } = \alpha$ ;   
+5: $\begin{array} { r } { \alpha = \frac { \| \mathbf { b } \odot \mathbf { d } _ { l } ^ { t - 1 } \odot \mathbf { w } _ { l } ^ { t } \| _ { 1 } } { \| \mathbf { b } \odot \mathbf { d } _ { l } ^ { t - 1 } \| _ { 1 } } } \end{array}$ ;   
+6: $\mathbf { b } = \mathbf { I } _ { \alpha / 2 } ( \mathbf { w } _ { l } ^ { t } )$ ;   
+7: end while   
+8: Output: $\hat { \mathbf { w } } _ { l } ^ { t } = \alpha \mathbf { b }$ .
+
+# 3.2 EXTENSION TO TERNARIZATION WITH TWO SCALING PARAMETERS
+
+As in TTQ (Zhu et al., 2017), we can use different scaling parameters for the positive and negative weights in each layer. The optimization subproblem at the tth iteration then becomes:
+
+$$
+\begin{array} { r l } { \operatorname* { m i n } _ { \hat { \mathbf { w } } ^ { t } } } & { \nabla \ell ( \hat { \mathbf { w } } ^ { t - 1 } ) ^ { \top } ( \hat { \mathbf { w } } ^ { t } - \hat { \mathbf { w } } ^ { t - 1 } ) + \displaystyle \frac { 1 } { 2 } ( \hat { \mathbf { w } } ^ { t } - \hat { \mathbf { w } } ^ { t - 1 } ) ^ { \top } \mathbf { D } ^ { t - 1 } ( \hat { \mathbf { w } } ^ { t } - \hat { \mathbf { w } } ^ { t - 1 } ) } \\ { \mathrm { s . t . } } & { \quad \hat { \mathbf { w } } _ { l } ^ { t } \in \{ - \beta _ { l } ^ { t } , 0 , \alpha _ { l } ^ { t } \} ^ { n _ { l } } , \alpha _ { l } ^ { t } > 0 , \beta _ { l } ^ { t } > 0 , l = 1 , \ldots , L . } \end{array}
+$$
+
+Proposition 3.4 The optimal $\begin{array} { r l } & { \frac { \| \mathbf { p } _ { l } ^ { t } \odot \mathbf { d } _ { l } ^ { t - 1 } \odot \mathbf { w } _ { l } ^ { t } \| _ { 1 } } { \| \mathbf { p } _ { l } ^ { t } \odot \mathbf { d } _ { l } ^ { t - 1 } \| _ { 1 } } , \mathbf { p } _ { l } ^ { t } = \mathbf { I } _ { \alpha _ { l } ^ { t } / 2 } ^ { + } ( \mathbf { w } _ { l } ^ { t } ) , \beta _ { l } ^ { t } = \frac { \| \mathbf { q } _ { l } ^ { t } \odot \mathbf { d } _ { l } ^ { t - 1 } \odot \mathbf { w } _ { l } ^ { t } \| _ { 1 } } { \| \mathbf { q } _ { l } ^ { t } \odot \mathbf { d } _ { l } ^ { t - 1 } \| _ { 1 } } } \end{array}$ $\hat { \mathbf { w } } _ { l } ^ { t }$ in (5) is of the form , and $\begin{array} { r c l } { \hat { \mathbf { w } } _ { l } ^ { t } } & { = } & { \alpha _ { l } ^ { t } \mathbf { p } _ { l } ^ { t } + \beta _ { l } ^ { t } \mathbf { q } _ { l } ^ { t } } \end{array}$ $\mathbf { q } _ { l } ^ { t } = \mathbf { I } _ { \beta _ { l } ^ { t } / 2 } ^ { - } ( \mathbf { w } _ { l } ^ { t } )$ . , where $\begin{array} { r l } { \alpha _ { l } ^ { t } } & { { } = } \end{array}$
+
+The exact and approximate solutions for $\alpha _ { l } ^ { t }$ and $\beta _ { l } ^ { t }$ can be obtained in a similar way as in Sections 3.1.1 and 3.1.2. Details are in Appendix C.
+
+# 3.3 EXTENSION TO LOW-BIT QUANTIZATION
+
+For $m$ -bit quantization, we simply change the set $\mathcal { Q }$ of desired quantized values in (3) to one with $k = 2 ^ { m - 1 } - 1$ quantized values. The optimization still contains a gradient descent step with adaptive learning rates like LAT, and a quantization step which can be solved efficiently by alternating minimization of $( \alpha , \mathbf { b } )$ (similar to the procedure in Algorithm 2) using the following Proposition.
+
+Proposition 3.5 Let the optimal $\hat { \mathbf { w } } _ { l } ^ { t }$ in (6) be of the form αb. For a fixed b, $\begin{array} { r } { \alpha = \frac { \| \mathbf b \odot \mathbf d _ { l } ^ { t - 1 } \odot \mathbf w _ { l } ^ { t } \| _ { 1 } } { \| \mathbf b \odot \mathbf d _ { l } ^ { t - 1 } \| _ { 1 } } } \end{array}$ ; whereas when linear quantiza $\alpha$ is fixeon and $\mathbf { b } = \Pi _ { \mathcal { Q } } ( \frac { \mathbf { w } _ { l } ^ { t } } { \alpha } )$ $\begin{array} { r } { \mathcal { Q } = \left\{ - 1 , - \frac { k - 1 } { k } , \dots , - \frac { 1 } { k } , 0 , \frac { 1 } { k } , \dots , \frac { k - 1 } { k } , 1 \right\} } \end{array}$ forion. $\begin{array} { r } { \mathcal { Q } = \left\{ - 1 , - \frac { 1 } { 2 } , \ldots , - \frac { 1 } { 2 ^ { k - 1 } } , 0 , \frac { 1 } { 2 ^ { k - 1 } } , \ldots , \frac { 1 } { 2 } , 1 \right\} } \end{array}$
+
+# 4 EXPERIMENTS
+
+In this section, we perform experiments on both feedforward and recurrent neural networks. The following methods are compared: (i) the original full-precision network; (ii) weight-binarized networks, including BinaryConnect (Courbariaux et al., 2015), Binary-Weight-Network (BWN) (Rastegari et al., 2016), and Loss-Aware Binarized network (LAB) (Hou et al., 2017); (iii) weightternarized networks, including Ternary Weight Networks (TWN) (Li & Liu, 2016), Trained Ternary Quantization $( \mathrm { T T Q } ) ^ { 2 }$ (Zhu et al., 2017), the proposed Loss-Aware Ternarized network with exact solution (LATe), approximate solution (LATa), and with two scaling parameters (LAT2e and LAT2a); (iv) $m$ -bit-quantized networks (where $m > 2$ ), including DoReFa-Netm (Zhou et al., 2016), the proposed loss-aware quantized network with linear quantization (LAQm(linear)), and logarithmic quantization $\left( \mathrm { L A Q m } ( \log ) \right)$ . Since weight quantization can be viewed as a form of regularization (Courbariaux et al., 2015), we do not use other regularizers such as dropout and weight decay.
+
+# 4.1 FEEDFORWARD NETWORKS
+
+In this section, we perform experiments with the multilayer perceptron (on the MNIST data set) and convolutional neural networks (on CIFAR-10, CIFAR-100 and SVHN). For MNIST, CIFAR-10, and SVHN, the setup is similar to that in (Courbariaux et al., 2015; Hou et al., 2017). Details can be found in Appendix D. For CIFAR-100, we use 45, 000 images for training, another 5, 000 for validation, and the remaining 10, 000 for testing. The testing errors are shown in Table 1.
+
+Ternarization: On MNIST, CIFAR100 and SVHN, the weight-ternarized networks perform better than weight-binarized networks, and are comparable to the full-precision networks. Among the weight-ternarized networks, the proposed LAT and its variants have the lowest errors. On CIFAR-10, LATa has similar performance as the full-precision network, but is outperformed by BinaryConnect.
+
+Figure 1(a) shows convergence of the training loss for LATa on CIFAR-10, and Figure 1(b) shows the scaling parameter obtained at each CNN layer. As can be seen, the scaling parameters for the first and last layers (conv1 and linear3, respectively) are larger than the others. This agrees with the finding that, to maintain the activation variance and back-propagated gradients variance during the forward and backward propagations, the variance of the weights between the lth and $( l + 1 )$ th layers should roughly follow $2 / ( n _ { l } + n _ { l + 1 } )$ (Glorot & Bengio, 2010). Hence, as the input and output layers are small, larger scaling parameters are needed for their high-variance weights.
+
+Table 1: Testing errors $( \% )$ on the feedforward networks. Algorithm with the lowest error in each group is highlighted.   
+
+<table><tr><td rowspan=1 colspan=2></td><td rowspan=1 colspan=1>MNIST</td><td rowspan=1 colspan=1>CIFAR-10</td><td rowspan=1 colspan=1>CIFAR-100</td><td rowspan=1 colspan=1>SVHN</td></tr><tr><td rowspan=1 colspan=2>no binarization        full-precision</td><td rowspan=1 colspan=1>1.11</td><td rowspan=1 colspan=1>10.38</td><td rowspan=1 colspan=1>39.06</td><td rowspan=1 colspan=1>2.28</td></tr><tr><td rowspan=3 colspan=2>BinaryConnectbinarization              BWNLAB</td><td rowspan=1 colspan=1>1.28</td><td rowspan=1 colspan=1>9.86</td><td rowspan=1 colspan=1>46.42</td><td rowspan=1 colspan=1>2.45</td></tr><tr><td rowspan=1 colspan=1>1.31</td><td rowspan=1 colspan=1>10.51</td><td rowspan=1 colspan=1>43.62</td><td rowspan=1 colspan=1>2.54</td></tr><tr><td rowspan=1 colspan=1>1.18</td><td rowspan=1 colspan=1>10.50</td><td rowspan=1 colspan=1>43.06</td><td rowspan=1 colspan=1>2.35</td></tr><tr><td rowspan=9 colspan=2>TWN1 scaling       LATeternarization                    LATaTTQ2 scaling      LAT2eLAT2aDoReFa-Net33-bit quantization       LAQ3(linear)LAQ3(log)</td><td rowspan=1 colspan=1>1.23</td><td rowspan=1 colspan=1>10.64</td><td rowspan=1 colspan=1>43.49</td><td rowspan=1 colspan=1>2.37</td></tr><tr><td rowspan=1 colspan=1>1.15</td><td rowspan=1 colspan=1>10.47</td><td rowspan=1 colspan=1>39.10</td><td rowspan=1 colspan=1>2.30</td></tr><tr><td rowspan=1 colspan=1>1.14</td><td rowspan=1 colspan=1>10.38</td><td rowspan=1 colspan=1>39.19</td><td rowspan=1 colspan=1>2.30</td></tr><tr><td rowspan=1 colspan=1>1.20</td><td rowspan=1 colspan=1>10.59</td><td rowspan=1 colspan=1>42.09</td><td rowspan=1 colspan=1>2.38</td></tr><tr><td rowspan=1 colspan=1>1.20</td><td rowspan=1 colspan=1>10.45</td><td rowspan=1 colspan=1>39.01</td><td rowspan=1 colspan=1>2.34</td></tr><tr><td rowspan=1 colspan=1>1.19</td><td rowspan=1 colspan=1>10.48</td><td rowspan=1 colspan=1>38.84</td><td rowspan=1 colspan=1>2.35</td></tr><tr><td rowspan=1 colspan=1>1.31</td><td rowspan=1 colspan=1>10.54</td><td rowspan=1 colspan=1>45.05</td><td rowspan=1 colspan=1>2.39</td></tr><tr><td rowspan=1 colspan=1>LAQ3(linear)</td><td rowspan=1 colspan=1>1.20</td><td rowspan=1 colspan=1>10.67</td><td rowspan=1 colspan=1>38.70</td><td rowspan=1 colspan=1>2.34</td></tr><tr><td rowspan=1 colspan=1>1.16</td><td rowspan=1 colspan=1>10.52</td><td rowspan=1 colspan=1>38.50</td><td rowspan=1 colspan=1>2.29</td></tr></table>
+
+![](images/eda5efc5c0bcbe67150d97bd578b915518adc632343087d19a5a190f7a2ac9ce.jpg)  
+Figure 1: Convergence of the training loss and scaling parameter by LATa on CIFAR-10.
+
+Using Two Scaling Parameters: Compared to TTQ, the proposed LAT2 always has better performance. However, the extra flexibility of using two scaling parameters does not always translate to lower testing error. As can be seen, it outperforms algorithms with one scaling parameter only on CIFAR-100. We speculate this is because the capacities of deep networks are often larger than needed, and so the limited expressiveness of quantized weights may not significantly deteriorate performance. Indeed, as pointed out in (Courbariaux et al., 2015), weight quantization is a form of regularization, and can contribute positively to the performance.
+
+Using More Bits: Among the 3-bit quantization algorithms, the proposed scheme with logarithmic quantization has the best performance. It also outperforms the other quantization algorithms on CIFAR-100 and SVHN. However, as discussed above, more quantization flexibility is useful only when the weight-quantized network does not have enough capacity.
+
+# 4.2 RECURRENT NETWORKS
+
+In this section, we follow (Hou et al., 2017) and perform character-level language modeling experiments on the long short-term memory (LSTM) (Hochreiter & Schmidhuber, 1997). The training objective is the cross-entropy loss over all target sequences. Experiments are performed on three data sets: (i) Leo Tolstoy’s War and Peace; (ii) source code of the Linux Kernel; and (iii) Penn Treebank Corpus (Taylor et al., 2003). For the first two, we follow the setting in (Karpathy et al., 2016; Hou et al., 2017). For Penn Treebank, we follow the setting in (Mikolov & Zweig, 2012). In the experiment, we tried different initializations for TTQ and then report the best. Cross-entropy values on the test set are shown in Table 2.
+
+Table 2: Testing cross-entropy values on the LSTM. Algorithm with the lowest cross-entropy value in each group is highlighted.   
+
+<table><tr><td></td><td></td><td></td><td></td><td rowspan=1 colspan=1>War and Peace</td><td rowspan=1 colspan=1>Linux Kernel</td><td rowspan=1 colspan=1>PennTreebank</td></tr><tr><td rowspan=1 colspan=4>no binarization        full-precision</td><td rowspan=1 colspan=1>1.268</td><td rowspan=1 colspan=1>1.326</td><td rowspan=1 colspan=1>1.083</td></tr><tr><td rowspan=3 colspan=4>BinaryConnectbinarization              BWNLAB</td><td rowspan=1 colspan=1>2.942</td><td rowspan=1 colspan=1>3.532</td><td rowspan=1 colspan=1>1.737</td></tr><tr><td rowspan=1 colspan=3>BWN</td><td rowspan=1 colspan=1>1.313</td><td rowspan=1 colspan=1>1.307</td><td rowspan=1 colspan=1>1.078</td></tr><tr><td rowspan=1 colspan=1>1.291</td><td rowspan=1 colspan=1>1.305</td><td rowspan=1 colspan=1>1.081</td></tr><tr><td rowspan=6 colspan=4>TWN1 scaling       LATeternarization                    LATaTTQ2 scaling      LAT2eLAT2a</td><td rowspan=1 colspan=1>1.290</td><td rowspan=1 colspan=1>1.280</td><td rowspan=1 colspan=1>1.045</td></tr><tr><td rowspan=1 colspan=1>1.248</td><td rowspan=1 colspan=1>1.256</td><td rowspan=1 colspan=1>1.022</td></tr><tr><td rowspan=1 colspan=2></td><td rowspan=1 colspan=2>LATa</td><td rowspan=1 colspan=1>1.253</td><td rowspan=1 colspan=1>1.264</td><td rowspan=1 colspan=1>1.024</td></tr><tr><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>TTQ</td><td rowspan=1 colspan=1>1.272</td><td rowspan=1 colspan=1>1.302</td><td rowspan=1 colspan=1>1.031</td></tr><tr><td rowspan=1 colspan=1>ng</td><td rowspan=1 colspan=1>LAT2e</td><td rowspan=1 colspan=1>1.239</td><td rowspan=1 colspan=1>1.258</td><td rowspan=1 colspan=1>1.018</td></tr><tr><td rowspan=1 colspan=1>1.245</td><td rowspan=1 colspan=1>1.258</td><td rowspan=1 colspan=1>1.015</td></tr><tr><td rowspan=3 colspan=4>DoReFa-Net33-bit quantization       LAQ3(linear)LAQ3(log)</td><td rowspan=1 colspan=1>1.349</td><td rowspan=1 colspan=1>1.276</td><td rowspan=1 colspan=1>1.017</td></tr><tr><td rowspan=1 colspan=1>1.282</td><td rowspan=1 colspan=1>1.327</td><td rowspan=1 colspan=1>1.017</td></tr><tr><td rowspan=1 colspan=1>1.268</td><td rowspan=1 colspan=1>1.273</td><td rowspan=1 colspan=1>1.009</td></tr><tr><td rowspan=3 colspan=4>DoReFa-Net44-bit quantization      LAQ4 (linear)LAQ4 (log)</td><td rowspan=1 colspan=1>1.328</td><td rowspan=1 colspan=1>1.320</td><td rowspan=1 colspan=1>1.019</td></tr><tr><td rowspan=1 colspan=3>LAQ4 (linear)</td><td rowspan=1 colspan=1>1.294</td><td rowspan=1 colspan=1>1.337</td><td rowspan=1 colspan=1>1.046</td></tr><tr><td rowspan=1 colspan=1>1.272</td><td rowspan=1 colspan=1>1.319</td><td rowspan=1 colspan=1>1.016</td></tr></table>
+
+Ternarization: As in Section 4.1, the proposed LATe and LATa outperform the other weight ternarization schemes, and are even better than the full-precision network on all three data sets. Figure 2 shows convergence of the training and validation losses on War and Peace. Among the ternarization methods, LAT and its variants converge faster than both TWN and TTQ.
+
+![](images/23b6eac8f3b53626fc7f0001b687f6299b23c649d11fb997c0b3814340dd74f5.jpg)  
+Figure 2: Convergence of the training and validation losses on War and Peace.
+
+Using Two Scaling Parameters: LAT2e and LAT2a outperform TTQ on all three data sets. They also perform better than using one scaling parameter on War and Peace and Penn Treebank.
+
+Using More Bits: The proposed LAQ always outperforms DoReFa-Net when 3 or 4 bits are used. As noted in Section 4.1, using more bits does not necessarily yield better generalization performance, and ternarization (using 2 bits) yields the lowest validation loss on War and Peace and Linux Kernel. Moreover, logarithmic quantization is better than linear quantization. Figure 3 shows distributions of the input-to-hidden (full-precision and quantized) weights of the input gate trained after 20 epochs using LAQ3(linear) and LAQ3(log) (results on the other weights are similar). As can be seen, distributions of the full-precision weights are bell-shaped. Hence, logarithmic quantization can give finer resolutions to many of the weights which have small magnitudes.
+
+![](images/a1256e0f5b208ec0ba108c7f2906793e8ad96ccaaaa64a8a3505b1165501cdf7.jpg)  
+Figure 3: Distributions of the full-precision and LAQ3-quantized weights on War and Peace. Left ((a) and (b)): Linear quantization; Right ((c) and (d)): Logarithmic quantization.
+
+Quantized vs Full-precision Networks: The quantized networks often perform better than the fullprecision networks. We speculate that this is because deep networks often have larger-than-needed capacities, and so are less affected by the limited expressiveness of quantized weights. Moreover, low-bit quantization acts as regularization, and so contributes positively to the performance.
+
+# 5 CONCLUSION
+
+In this paper, we proposed a loss-aware weight quantization algorithm that directly considers the effect of quantization on the loss. The problem is solved using the proximal Newton algorithm. Each iteration consists of a preconditioned gradient descent step and a quantization step that projects fullprecision weights onto a set of quantized values. For ternarization, an exact solution and an efficient approximate solution are provided. The procedure is also extended to the use of different scaling parameters for the positive and negative weights, and to $m$ -bit (where $m > 2$ ) quantization. Experiments on both feedforward and recurrent networks show that the proposed quantization scheme outperforms the current state-of-the-art.
+
+# ACKNOWLEDGMENTS
+
+This research was supported in part by the Research Grants Council of the Hong Kong Special Administrative Region (Grant 614513). We thank the developers of Theano (Theano Development Team, 2016), Pylearn2 (Goodfellow et al., 2013) and Lasagne. We also thank NVIDIA for the gift of GPU card.
+
+# REFERENCES
+
+S. Boyd, N. Parikh, E. Chu, B. Peleato, and J. Eckstein. Distributed optimization and statistical learning via the alternating direction method of multipliers. Foundations and Trends in Machine Learning, 3(1):1–122, 2011.   
+M. Courbariaux, Y. Bengio, and J. P. David. BinaryConnect: Training deep neural networks with binary weights during propagations. In Advances in Neural Information Processing Systems, pp. 3105–3113, 2015.   
+Y. Dauphin, H. de Vries, and Y. Bengio. Equilibrated adaptive learning rates for non-convex optimization. In Advances in Neural Information Processing Systems, pp. 1504–1512, 2015.   
+X. Glorot and Y. Bengio. Understanding the difficulty of training deep feedforward neural networks. In International Conference on Artificial Intelligence and Statistics, pp. 249–256, 2010.   
+I. J. Goodfellow, D. Warde-Farley, P. Lamblin, V. Dumoulin, M. Mirza, R. Pascanu, J. Bergstra, F. Bastien, and Y. Bengio. Pylearn2: a machine learning research library. Preprint, 2013.   
+S. Han, J. Pool, J. Tran, and W. J. Dally. Learning both weights and connections for efficient neural network. In Advances in Neural Information Processing Systems, pp. 1135–1143, 2015.   
+S. Han, H. Mao, and W. J. Dally. Deep compression: Compressing deep neural network with pruning, trained quantization and Huffman coding. In International Conference on Learning Representations, 2016.   
+K. He, X. Zhang, S. Ren, and J. Sun. Deep residual learning for image recognition. In International Conference on Computer Vision and Pattern Recognition, pp. 770–778, 2016.   
+S. Hochreiter and J. Schmidhuber. Long short-term memory. Neural Computation, pp. 1735–1780, 1997.   
+L. Hou, Q. Yao, and J. T. Kwok. Loss-aware binarization of deep networks. In International Conference on Learning Representations, 2017.   
+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. Preprint arXiv:1704.04861, 2017.   
+F. N. Iandola, S. Han, M. W. Moskewicz, K. Ashraf, W. J. Dally, and K. Keutzer. Squeezenet: Alexnet-level accuracy with 50x fewer parameters and ${ < } 0 . 5 \mathrm { M B }$ model size. Preprint arXiv:1602.07360, 2016.   
+A. Karpathy, J. Johnson, and F. F. Li. Visualizing and understanding recurrent networks. In International Conference on Learning Representations, 2016.   
+Y. D. Kim, E. Park, S. Yoo, T. Choi, L. Yang, and D. Shin. Compression of deep convolutional neural networks for fast and low power mobile applications. In International Conference on Learning Representations, 2016.   
+D. Kingma and J. Ba. Adam: A method for stochastic optimization. In International Conference on Learning Representations, 2015.   
+V. Lebedev, Y. Ganin, M. Rakhuba, I. Oseledets, and V. Lempitsky. Speeding-up convolutional neural networks using fine-tuned cp-decomposition. Preprint arXiv:1412.6553, 2014.   
+Y. LeCun, Y. Bengio, and G. Hinton. Deep learning. Nature, 521(7553):436–444, 2015.   
+J. D. Lee, Y. Sun, and M. A. Saunders. Proximal Newton-type methods for minimizing composite functions. SIAM Journal on Optimization, 24(3):1420–1443, 2014.   
+C. Leng, H. Li, S. Zhu, and R. Jin. Extremely low bit neural network: Squeeze the last bit out with admm. Preprint arXiv:1707.09870, 2017.   
+F. Li and B. Liu. Ternary weight networks. Preprint arXiv:1605.04711, 2016.   
+H. Li, S. De, Z. Xu, C. Studer, H. Samet, and Goldstein T. Training quantized nets: A deeper understanding. In Advances in Neural Information Processing Systems, 2017a.   
+H. Li, A. Kadav, I. Durdanovic, H. Samet, and H. P. Graf. Pruning filters for efficient convnets. In International Conference on Learning Representations, 2017b.   
+D. Lin, S. Talathi, and S. Annapureddy. Fixed point quantization of deep convolutional networks. In International Conference on Machine Learning, pp. 2849–2858, 2016a.   
+Z. Lin, M. Courbariaux, R. Memisevic, and Y. Bengio. Neural networks with few multiplications. In International Conference on Learning Representations, 2016b.   
+N. Mellempudi, A. Kundu, D. Mudigere, D. Das, B. Kaul, and P. Dubey. Ternary neural networks with fine-grained quantization. Preprint arXiv:1705.01462, 2017.   
+T. Mikolov and G. Zweig. Context dependent recurrent neural network language model. IEEE Spoken Language Technology Workshop, 12:234–239, 2012.   
+D. Miyashita, E. H. Lee, and B. Murmann. Convolutional neural networks using logarithmic data representation. Preprint arXiv:1603.01025, 2016.   
+P. Molchanov, S. Tyree, T. Karras, T. Aila, and J. Kautz. Pruning convolutional neural networks for resource efficient transfer learning. In International Conference on Learning Representations, 2017.   
+A. Novikov, D. Podoprikhin, A. Osokin, and D. P. Vetrov. Tensorizing neural networks. In Advances in Neural Information Processing Systems, pp. 442–450, 2015.   
+A. Rakotomamonjy, R. Flamary, and G. Gasso. DC proximal Newton for nonconvex optimization problems. IEEE Transactions on Neural Networks and Learning Systems, 27(3):636–647, 2016.   
+M. Rastegari, V. Ordonez, J. Redmon, and A. Farhadi. XNOR-Net: ImageNet classification using binary convolutional neural networks. In European Conference on Computer Vision, 2016.   
+C. Szegedy, W. Liu, Y. Jia, P. Sermanet, S. Reed, D. Anguelov, D. Erhan, V. Vanhoucke, and A. Rabinovich. Going deeper with convolutions. In International Conference on Computer Vision and Pattern Recognition, pp. 1–9, 2015.   
+A. Taylor, M. Marcus, and B. Santorini. The Penn treebank: An overview. In Treebanks, pp. 5–22. Springer, 2003.   
+Theano Development Team. Theano: A Python framework for fast computation of mathematical expressions. Preprint arXiv:1605.02688, 2016.   
+F. P. Vasilyev, E. V. Khoroshilova, and A. S. Antipin. An extragradient method for finding the saddle point in an optimal control problem. Moscow University Computational Mathematics and Cybernetics, 34(3):113–118, 2010.   
+X. Zhang, X. Zhou, M. Lin, and J. Sun. ShuffleNet: An extremely efficient convolutional neural network for mobile devices. Preprint arXiv:1707.01083, 2017.   
+S. Zhou, Z. Ni, X. Zhou, H. Wen, Y. Wu, and Y. Zou. DoReFa-Net: Training low bitwidth convolutional neural networks with low bitwidth gradients. Preprint arXiv:1606.06160, 2016.   
+C. Zhu, S. Han, H. Mao, and W. J. Dally. Trained ternary quantization. In International Conference on Learning Representations, 2017.
+
+# A PROOFS
+
+A.1 PROOF OF PROPOSITION 3.1
+
+With $\mathbf { w } _ { l } ^ { t }$ in (7), the objective in (5) can be rewritten as
+
+$$
+\begin{array} { r l } {  { \nabla \ell ( \widetilde { \mathbf { w } } ^ { t - 1 } ) ^ { \top } ( \widetilde { \mathbf { w } } ^ { t } - \widetilde { \mathbf { w } } ^ { t - 1 } ) + \frac { 1 } { 2 } ( \widetilde { \mathbf { w } } ^ { t } - \widetilde { \mathbf { w } } ^ { t - 1 } ) ^ { \top } \mathbf { D } ^ { t - 1 } ( \widetilde { \mathbf { w } } ^ { t } - \widetilde { \mathbf { w } } ^ { t - 1 } ) } } \\ { = } & { \frac { 1 } { 2 } \sum _ { t = 1 } ^ { L } ( \sqrt { \mathbf { d } _ { t } ^ { t - 1 } } ^ { \top } ( \widetilde { \mathbf { w } } _ { t } ^ { t } - ( \widetilde { \mathbf { w } } _ { t } ^ { t - 1 } - \nabla _ { t } \ell ( \widetilde { \mathbf { w } } ^ { t - 1 } ) \mathcal { O } \mathbf { d } _ { t } ^ { t - 1 } ) ) ) ^ { 2 } + c _ { 1 } } \\ & { = } & { \frac { 1 } { 2 } \sum _ { t = 1 } ^ { L } ( \sqrt { \mathbf { d } _ { t } ^ { t - 1 } } ^ { \top } ( \widetilde { \mathbf { w } } _ { t } ^ { t } - \mathbf { w } _ { t } ^ { t } ) ) ^ { 2 } + c _ { 1 } } \\ { = } & { \frac { 1 } { 2 } \sum _ { t = 1 } ^ { L } ( \sqrt { \mathbf { d } _ { t } ^ { t - 1 } } ^ { \top } ( \alpha _ { t } ^ { t } \mathbf { b } _ { t } ^ { t } - \mathbf { w } _ { t } ^ { t } ) ) ^ { 2 } + c _ { 1 } } \\ & { = } & { \frac { 1 } { 2 } \sum _ { t = 1 } ^ { L } ( \sqrt { \mathbf { d } _ { t } ^ { t - 1 } } ^ { \top } ( \alpha _ { t } ^ { t } \mathbf { b } _ { t } ^ { t } - \mathbf { w } _ { t } ^ { t } ) ) ^ { 2 } + c _ { 1 } } \\ { = } & { \frac { 1 } { 2 } \sum _ { t = 1 } ^ { L } \frac { m } {  \mathbf { d } _ { t } ^ { t } - \mathbf { \Phi }  } \mathbf { d } _ { t } ^ { t } -  \mathbf { w } _ { t } ^ { t }  _ { t } -  \mathbf { w } _ { t } ^ { t }  _ { t } ^ { 2 } + c _ { 1 } , } \end{array}
+$$
+
+where $\begin{array} { r } { c _ { 1 } = - \frac { 1 } { 2 } \big ( \sqrt { \mathbf { d } _ { l } ^ { t - 1 } } ^ { \top } ( \nabla _ { l } \ell ( \hat { \mathbf { w } } ^ { t - 1 } ) \oslash \mathbf { d } _ { l } ^ { t - 1 } ) \big ) ^ { 2 } } \end{array}$ is independent of $\alpha _ { l } ^ { t }$ and $\mathbf { b } _ { l } ^ { t }$
+
+# A.2 PROOF OF PROPOSITION 3.2
+
+To simplify notations, we drop the subscript and superscript. Considering one particular layer, problem (6) is of the form:
+
+$$
+\begin{array} { r l } { \operatorname* { m i n } _ { \alpha , \mathbf { b } } } & { \displaystyle \frac { 1 } { 2 } \sum _ { i = 1 } ^ { n } d _ { i } ( \alpha b _ { i } - w _ { i } ) ^ { 2 } } \\ { \mathrm { s . t . } \quad } & { \displaystyle \alpha > 0 , b _ { i } \in \{ - 1 , 0 , 1 \} . } \end{array}
+$$
+
+When $\alpha$ is fixed,
+
+$$
+b _ { i } = \arg \operatorname* { m i n } _ { b _ { i } } \frac { 1 } { 2 } d _ { i } ( \alpha b _ { i } - w _ { i } ) ^ { 2 } = \frac { 1 } { 2 } d _ { i } \alpha ^ { 2 } ( b _ { i } - w _ { i } / \alpha ) ^ { 2 } = { \bf I } _ { \alpha / 2 } ( w _ { i } ) .
+$$
+
+When $\mathbf { b }$ is fixed,
+
+$$
+\begin{array} { r l } { \alpha ~ = } & { \arg \operatorname* { m i n } _ { \alpha } \frac { 1 } { 2 } \displaystyle \sum _ { i = 1 } ^ { n } d _ { i } ( \alpha b _ { i } - w _ { i } ) ^ { 2 } } \\ { = } & { \arg \operatorname* { m i n } _ { \alpha } \frac { 1 } { 2 } \| { \mathbf b } \odot { \mathbf b } \odot { \mathbf d } \| _ { 1 } \alpha ^ { 2 } - \| { \mathbf b } \odot { \mathbf d } \odot { \mathbf w } \| _ { 1 } \alpha + c _ { 2 } , } \\ { = } & { \arg \operatorname* { m i n } _ { \alpha } \frac { 1 } { 2 } \| { \mathbf b } \odot { \mathbf b } \odot { \mathbf d } \| _ { 1 } \left( \alpha - \frac { \| { \mathbf b } \odot { \mathbf d } \odot { \mathbf w } \| _ { 1 } } { \| { \mathbf b } \odot { \mathbf b } \odot { \mathbf d } \| _ { 1 } } \right) ^ { 2 } - \frac { 1 } { 2 } \| { \mathbf b } \odot { \mathbf d } \odot { \mathbf w } \| _ { 1 } ^ { 2 } + c _ { 2 } } \\ { = } & { \frac { \| { \mathbf b } \odot { \mathbf d } \odot { \mathbf w } \| _ { 1 } } { \| { \mathbf b } \odot { \mathbf c } \odot { \mathbf d } \| _ { 1 } } } \\ { = } & { \frac { \| { \mathbf b } \odot { \mathbf d } \odot { \mathbf w } \| _ { 1 } } { \| { \mathbf b } \odot { \mathbf d } \| _ { 1 } } . } \end{array}
+$$
+
+# A.3 PROOF OF COROLLARY 3.1
+
+When $\mathbf { D } _ { l } ^ { t - 1 } = \lambda \mathbf { I }$ , i.e., the curvature is the same for all dimensions in the lth layer, From Proposition 3.2,
+
+$$
+\alpha _ { l } ^ { t } = \frac { \| \mathbf { b } \odot \mathbf { d } _ { l } ^ { t - 1 } \odot \mathbf { w } _ { l } ^ { t } \| _ { 1 } } { \| \mathbf { b } \odot \mathbf { d } _ { l } ^ { t - 1 } \| _ { 1 } } = \frac { \| \mathbf { I } _ { \alpha _ { l } ^ { t } / 2 } ( \mathbf { w } _ { l } ^ { t } ) \odot \mathbf { w } _ { l } ^ { t } \| _ { 1 } } { \| \mathbf { I } _ { \alpha _ { l } ^ { t } / 2 } ( \mathbf { w } _ { l } ^ { t } ) \| _ { 1 } } = \frac { 1 } { \| \mathbf { I } _ { \Delta _ { l } ^ { t } } ( \mathbf { w } _ { l } ^ { t } ) \| _ { 1 } } \sum _ { i : [ \mathbf { w } _ { l } ^ { t } ] _ { i } > \Delta _ { l } ^ { t } } | [ \mathbf { w } _ { l } ^ { t } ] _ { i } | ,
+$$
+
+$$
+\Delta _ { l } ^ { t } = \frac { 1 } { 2 } \frac { \| \mathbf { I } _ { \alpha _ { l } ^ { t } / 2 } \odot \mathbf { w } _ { l } ^ { t } \| _ { 1 } } { \| \mathbf { I } _ { \alpha _ { l } ^ { t } / 2 } \| _ { 1 } } = \arg \operatorname* { m a x } _ { \Delta > 0 } \frac { 1 } { \| \mathbf { I } _ { \Delta } ( \mathbf { w } _ { l } ^ { t } ) \| _ { 1 } } \left( \sum _ { i : [ \mathbf { w } _ { l } ^ { t } ] _ { i } > \Delta } | [ \mathbf { w } _ { l } ^ { t } ] _ { i } | \right) ^ { 2 } .
+$$
+
+This is the same as the TWN solution in (1).
+
+# A.4 PROOF OF PROPOSITION 3.3
+
+For simplicity of notations, we drop the subscript and superscript. For each layer, we have an optimization problem of the form
+
+$$
+\begin{array} { r l } {  { \operatorname* { m i n } ( \sqrt { \mathbf { d } } ^ { \top } ( { \boldsymbol { \alpha } } { \mathbf { b } } - { \mathbf { w } } ) ) ^ { 2 } } } \\ { = } & { \ \arg \operatorname* { m i n } _ { \boldsymbol { \alpha } } \| { \mathbf { b } } \odot { \mathbf { b } } \odot { \mathbf { d } } \| _ { 1 } ( { \boldsymbol { \alpha } } - \frac { \| { \mathbf { b } } \odot { \mathbf { d } } \odot { \mathbf { w } } \| _ { 1 } } { \| { \mathbf { b } } \odot { \mathbf { b } } \odot { \mathbf { d } } \| _ { 1 } } ) ^ { 2 } - \frac { \| { \mathbf { b } } \odot { \mathbf { d } } \odot { \mathbf { w } } \| _ { 1 } ^ { 2 } } { \| { \mathbf { b } } \odot { \mathbf { b } } \odot { \mathbf { d } } \| _ { 1 } } } \\ { = } & { \ \arg \operatorname* { m i n } _ { \boldsymbol { \alpha } } \| { \mathbf { I } } _ { \alpha / 2 } ( { \mathbf { w } } ) \odot { \mathbf { I } } _ { \alpha / 2 } ( { \mathbf { w } } ) \odot { \mathbf { d } } \| _ { 1 } ( { \boldsymbol { \alpha } } - \frac { \| { \mathbf { I } } _ { \alpha / 2 } ( { \mathbf { w } } ) \odot { \mathbf { d } } \odot { \mathbf { w } } \| _ { 1 } } { \| { \mathbf { I } } _ { \alpha / 2 } ( { \mathbf { w } } ) \odot { \mathbf { I } } _ { \alpha / 2 } ( { \mathbf { w } } ) \odot { \mathbf { d } } \| _ { 1 } } ) ^ { 2 } - \frac { \| { \mathbf { I } } _ { \alpha / 2 } ( { \mathbf { w } } ) \odot { \mathbf { I } } _ { \alpha / 2 } ( { \mathbf { w } } ) \odot { \mathbf { I } } _ { \alpha / 2 } ( { \mathbf { w } } ) \| _ { 1 } } { \| { \mathbf { I } } _ { \alpha / 2 } ( { \mathbf { w } } ) \odot { \mathbf { I } } _ { \alpha / 2 } ( { \mathbf { w } } ) \odot { \mathbf { I } } _ { \alpha / 2 } ( { \mathbf { w } } ) \| _ { 1 } } } \\ { = } &  \ \arg \operatorname* { m i n } _ { \boldsymbol { \alpha } } - \frac  \| { \mathbf { I } } _ { \alpha / 2 } ( { \mathbf { w } } ) \odot { \mathbf { d } } \odot { \mathbf { w } } \| _ { 1 } \end{array}
+$$
+
+where the second equality holds as $\mathbf { b } = \mathbf { I } _ { \alpha / 2 } ( \mathbf { w } )$ . From (9), we have
+
+$$
+\begin{array} { r l } & { - \frac { \| \mathbf { I } _ { \alpha / 2 } ( \mathbf { w } ) \odot \mathbf { d } \odot \mathbf { w } \| _ { 1 } ^ { 2 } } { \| \mathbf { I } _ { \alpha / 2 } ( \mathbf { w } ) \odot \mathbf { d } \| _ { 1 } } } \\ & { \quad = \begin{array} { r l } { \displaystyle - \frac { \| \mathbf { I } _ { \alpha / 2 } ( \mathbf { w } ) \odot \mathbf { d } \odot \mathbf { w } \| _ { 1 } } { \| \mathbf { I } _ { \alpha / 2 } ( \mathbf { w } ) \odot \mathbf { d } \| _ { 1 } } . \frac { \| \mathbf { I } _ { \alpha / 2 } ( \mathbf { w } ) \odot \mathbf { d } \odot \mathbf { w } \| _ { 1 } } { \| \mathbf { I } _ { \alpha / 2 } ( \mathbf { w } ) \odot \mathbf { d } \| _ { 1 } } . \frac { \| \mathbf { I } _ { \alpha / 2 } ( \mathbf { w } ) \odot \mathbf { d } \| _ { 1 } } { \| \mathbf { I } _ { \alpha / 2 } ( \mathbf { w } ) \odot \mathbf { d } \| _ { 1 } } . } \end{array} } \\ & { \quad \quad = \begin{array} { r l } { \displaystyle - 2 c _ { j } \cdot [ \mathrm { c u m } ( \mathrm { p e r m } _ { \mathbf { s } } ( \mathbf { d } ) ) ] _ { j } } & { } \\ { \quad = } & { \displaystyle - 2 c _ { j } ^ { 2 } \cdot [ \mathrm { c u m } ( \mathrm { p e r m } _ { \mathbf { s } } ( \mathbf { d } ) ) ] _ { j } . } \end{array} } \end{array}
+$$
+
+# A.5 PROOF FOR PROPOSITION 3.4
+
+For simplicity of notations, we drop the subscript and superscript, and consider the optimization problem:
+
+$$
+\operatorname* { m i n } _ { \alpha , \mathbf { b } } \quad \frac { 1 } { 2 } \sum _ { i = 1 } ^ { n } d _ { i } ( \hat { w } _ { i } - w _ { i } ) ^ { 2 }
+$$
+
+Let $f ( \hat { w } _ { i } ) = ( \hat { w } _ { i } - w _ { i } ) ^ { 2 }$ . Then, $f ( \alpha ) = ( \alpha - w _ { i } ) ^ { 2 } , f ( 0 ) = w _ { i } ^ { 2 }$ , and $f ( - \beta ) = ( \beta + w _ { i } ) ^ { 2 }$ . It is easy to see that (i) if $w _ { i } > \alpha / 2 , f ( \alpha )$ is the smallest; (ii) if $w _ { i } < - \beta / 2 , f ( - 1 )$ is the smallest; (iii) if $- \beta / 2 \le w _ { i } \le \alpha / 2 , f ( 0 )$ is the smallest. In other words, the optimal $\hat { w } _ { i }$ satisfies
+
+$$
+\hat { w } _ { i } = \alpha \mathbf { I } _ { \alpha / 2 } ^ { + } ( w _ { i } ) + \beta \mathbf { I } _ { \beta / 2 } ^ { - } ( w _ { i } ) ,
+$$
+
+or equivalently, $\hat { \mathbf { w } } = \alpha \mathbf { p } + \beta \mathbf { q }$ , where $\mathbf { p } = \mathbf { I } _ { \alpha / 2 } ^ { + } ( \mathbf { w } )$ , and $\mathbf { q } = \mathbf { I } _ { \beta } ^ { - } ( \mathbf { w } )$
+
+Define $\mathbf { w } ^ { + }$ and $\mathbf { w } ^ { - }$ such that $[ \mathbf { w } ^ { + } ] _ { i } = \left\{ \begin{array} { l l } { w _ { i } } & { w _ { i } > 0 } \\ { 0 } & { \mathrm { o t h e r w i s e } , } \end{array} \right. \mathrm { a n d } \ [ \mathbf { w } ^ { - } ] _ { i } = \left\{ \begin{array} { l l } { w _ { i } } & { w _ { i } < 0 } \\ { 0 } & { \mathrm { o t h e r w i s e } . } \end{array} \right.$ Then,
+
+$$
+\frac { 1 } { 2 } \sum _ { i = 1 } ^ { n } d _ { i } ( \hat { w } _ { i } - w _ { i } ) ^ { 2 } = \frac { 1 } { 2 } \sum _ { i = 1 } ^ { n } d _ { i } ( \alpha p _ { i } - w _ { i } ^ { + } ) ^ { 2 } + \frac { 1 } { 2 } \sum _ { i = 1 } ^ { n } d _ { i } ( \beta q _ { i } - w _ { i } ^ { - } ) ^ { 2 } .
+$$
+
+The objective in (12) has two parts, and each part can be viewed as a special case of the ternarization step in Proposition 3.1 (considering only with positive or negative weights). Similar to the proof for Proposition 3.2, we can obtain that the optimal $\hat { \mathbf { w } } = \alpha \mathbf { p } + \beta \mathbf { q }$ satisfies
+
+$$
+\begin{array} { r } { \alpha = \frac { \| \mathbf { p } \odot \mathbf { d } \odot \mathbf { w } \| _ { 1 } } { \| \mathbf { p } \odot \mathbf { d } \| _ { 1 } } , \quad \mathbf { p } = \mathbf { I } _ { \alpha / 2 } ^ { + } ( \mathbf { w } ) , } \\ { \beta = \frac { \| \mathbf { q } \odot \mathbf { d } \odot \mathbf { w } \| _ { 1 } } { \| \mathbf { q } \odot \mathbf { d } \| _ { 1 } } , \quad \mathbf { q } = \mathbf { I } _ { \beta / 2 } ^ { - } ( \mathbf { w } ) . } \end{array}
+$$
+
+# A.6 PROOF OF PROPOSITION 3.5
+
+For simplicity of notations, we drop the subscript and superscript. Since $\begin{array} { r } { \frac { 1 } { 2 } ( \sqrt { \mathbf { d } } ^ { \top } ( \alpha \mathbf { b } - \mathbf { w } ) ) ^ { 2 } = } \end{array}$ $\textstyle { \frac { 1 } { 2 } } \sum _ { i = 1 } ^ { n } d _ { i } ( \alpha b _ { i } - w _ { i } ) ^ { 2 }$ for each layer, we simply consider the optimization problem:
+
+$$
+\begin{array} { r l } { \operatorname* { m i n } _ { \boldsymbol { \alpha } , \mathbf { b } } } & { \displaystyle \frac { 1 } { 2 } \sum _ { i = 1 } ^ { n } d _ { i } ( { \boldsymbol { \alpha } } b _ { i } - w _ { i } ) ^ { 2 } } \\ { \mathrm { s . t . } } & { \boldsymbol { \alpha } > 0 , b _ { i } \in \mathcal { Q } . } \end{array}
+$$
+
+When $\alpha$ is fixed,
+
+$$
+b _ { i } = \arg \operatorname* { m i n } _ { b _ { i } } \frac { 1 } { 2 } d _ { i } ( \alpha b _ { i } - w _ { i } ) ^ { 2 } = \frac { 1 } { 2 } d _ { i } \alpha ^ { 2 } ( b _ { i } - w _ { i } / \alpha ) ^ { 2 } = \Pi _ { \mathcal { Q } } \left( \frac { w _ { i } } { \alpha } \right) .
+$$
+
+When $\mathbf { b }$ is fixed,
+
+$$
+{ \begin{array} { r c l } { \alpha } & { = } & { \displaystyle \operatorname { a r g m i n } _ { \alpha } { \frac { 1 } { 2 } } \sum _ { i = 1 } ^ { n } d _ { i } ( \alpha b _ { i } - w _ { i } ) ^ { 2 } } \\ & { = } & { \displaystyle \operatorname { a r g m i n } _ { \alpha } { \frac { 1 } { 2 } } \| \mathbf { b \odot b \odot d } \| _ { 1 } \alpha ^ { 2 } - \| \mathbf { b \odot d \odot w } \| _ { 1 } \alpha + c _ { 2 } } \\ & { = } & { \displaystyle \operatorname { a r g m i n } _ { \alpha } { \frac { 1 } { 2 } } \| \mathbf { b \odot b \odot d } \| _ { 1 } \left( \alpha - { \frac { \| \mathbf { b \odot d \odot w } \| _ { 1 } } { \| \mathbf { b \odot b \odot d } \| _ { 1 } } } \right) ^ { 2 } - { \frac { 1 } { 2 } } { \frac { \| \mathbf { b \odot d \odot w } \| _ { 1 } ^ { 2 } } { \| \mathbf { b \odot b \odot d } \| _ { 1 } } } } \\ & { = } & { \displaystyle { \frac { \| \mathbf { b \odot d \odot w } \| _ { 1 } } { \| \mathbf { b \odot b \odot d } \| _ { 1 } } } } \\ & { = } & { \displaystyle { \frac { \| \mathbf { b \odot d \odot d } \| _ { 1 } } { \| \mathbf { b \odot d } \| _ { 1 } } } . } \end{array} }
+$$
+
+# B LOSS-AWARE TERNARIZATION ALGORITHM (LAT)
+
+The whole procedure of LAT is shown in Algorithm 3.
+
+# C EXACT AND APPROXIMATE SOLUTIONS FOR TERNARIZATION WITH TWO SCALING PARAMETERS
+
+Let there be $n _ { 1 }$ positive elements and $n _ { 2 }$ negative elements in $\mathbf { w } _ { l }$ . For a $n$ -dimensional vector $\mathbf { x } = [ x _ { 1 } , x _ { 2 } , \ldots , x _ { n } ]$ , define inverse $\mathbf { \Phi } : ( \mathbf { x } ) = [ x _ { n } , x _ { n - 1 } , \ldots , x _ { 1 } ]$ . As is shown in (12), the objective can be separated into two parts, and each part can be viewed as a special case of ternarization step in Proposition 3.1, dealing only with positive or negative weights. Thus the exact and approximate solutions for $\alpha _ { l } ^ { t }$ and $\beta _ { l } ^ { t }$ can separately be derived in a similar way as that of using one scaling parameter. The exact and approximate solutions for $\alpha _ { l } ^ { t }$ and $\beta _ { l } ^ { t }$ for layer-l at the tth time step are shown in Algorithms 4 and 5.
+
+# D EXPERIMENTAL DETAILS
+
+# D.1 SETUP FOR FEEDFORWARD NETWORKS
+
+The setup for the four data sets are as follows:
+
+1. MNIST: This contains $2 8 \times 2 8$ gray images from 10 digit classes. We use 50, 000 images for training, another 10, 000 for validation, and the remaining 10, 000 for testing. We use the 4-layer model:
+
+$$
+7 8 4 F C - 2 0 4 8 F C - 2 0 4 8 F C - 2 0 4 8 F C - 1 0 S V M ,
+$$
+
+where $F C$ is a fully-connected layer, and $S V M$ is a $\ell _ { 2 }$ -SVM output layer using the square hinge loss. Batch normalization with a minibatch size 100, is used to accelerate learning. The maximum number of epochs is 50. The learning rate starts at 0.01, and decays by a factor of 0.1 at epochs 15 and 25.
+
+Algorithm 3 Loss-Aware Ternarization (LAT) for training a feedforward neural network.
+
+Input: Minibatch $\{ ( \mathbf { x } _ { 0 } ^ { t } , \mathbf { y } ^ { t } ) \}$ , current full-precision weights $\left\{ \mathbf { w } _ { l } ^ { t } \right\}$ , first moment $\{ \mathbf { m } _ { l } ^ { t - 1 } \}$ , second moment $\{ \mathbf { v } _ { l } ^ { t - 1 } \}$ , and learning rate $\eta ^ { t }$ .
+
+1: Forward Propagation   
+2: for $l = 1$ to $L$ do   
+3: compute $\alpha _ { l } ^ { t }$ and $\mathbf { b } _ { l } ^ { t }$ using Algorithm 1 or 2;   
+4: rescale the layer- $\mathbf { \nabla } \cdot \mathbf { \vec { \tau } }$ input: $\tilde { \mathbf { x } } _ { l - 1 } ^ { t } = \alpha _ { l } ^ { t } \mathbf { x } _ { l - 1 } ^ { t }$ ;   
+5: compute $\mathbf { z } _ { l } ^ { t }$ with input $\tilde { \mathbf { x } } _ { l - 1 } ^ { t }$ and binary weight $\mathbf { b } _ { l } ^ { t }$ ;   
+6: apply batch-normalization and nonlinear activation to $\mathbf { z } _ { l } ^ { t }$ to obtain $\mathbf { x } _ { l } ^ { t }$ ;   
+7: end for   
+8: compute the loss $\ell$ using $\mathbf { x } _ { L } ^ { t }$ and $\mathbf { y } ^ { t }$ ;   
+9: Backward Propagation   
+10: initialize output layer’s activation’s gradient $\frac { \partial \ell } { \partial \mathbf { x } _ { L } ^ { t } }$ ;   
+11: for $l = L$ to 2 do   
+12: compute $\frac { \partial \ell } { \partial \mathbf { x } _ { l - 1 } ^ { t } }$ usin g ∂ \`∂ x t , α tl an d b tl ;   
+13: end for   
+14: Update parameters using Adam   
+15: for $l = 1$ to $L$ do   
+16: compute gradients $\nabla _ { l } \ell ( \hat { \mathbf { w } } ^ { t } )$ using $\frac { \partial \ell } { \partial \mathbf { x } _ { l } ^ { t } }$ and $\mathbf { x } _ { l - 1 } ^ { t }$ ;   
+17: update first moment $\mathbf { m } _ { l } ^ { t } = \beta _ { 1 } \mathbf { m } _ { l } ^ { t - 1 } + ( 1 - \beta _ { 1 } ) \nabla _ { l } \ell ( \hat { \mathbf { w } } ^ { t } )$ ;   
+18: update second moment $\mathbf { v } _ { l } ^ { t } = \beta _ { 2 } \mathbf { v } _ { l } ^ { t - 1 } + ( 1 - \beta _ { 2 } ) ( \nabla _ { l } \ell ( \hat { \mathbf { w } } ^ { t } ) \odot \nabla _ { l } \ell ( \hat { \mathbf { w } } ^ { t } ) ) ;$ ;   
+19: compute unbiased first moment $\hat { \mathbf { m } } _ { l } ^ { t } = \mathbf { m } _ { l } ^ { t } / ( 1 - \beta _ { 1 } ^ { t } )$ ;   
+20: compute unbiased second moment $\hat { \mathbf { v } } _ { l } ^ { t } = \mathbf { v } _ { l } ^ { t } / ( 1 - \beta _ { 2 } ^ { t } )$ ;   
+21: compute current curvature matrix $\begin{array} { r } { \mathbf { d } _ { l } ^ { t } = \frac { 1 } { \eta ^ { t } } \left( \epsilon \mathbf { 1 } + \sqrt { \hat { \mathbf { v } } _ { l } ^ { t } } \right) } \end{array}$ ;   
+22: update full-precision weights $\mathbf { w } _ { l } ^ { t + 1 } = \mathbf { w } _ { l } ^ { t } - \hat { \mathbf { m } } _ { l } ^ { t } \oslash \mathbf { d } _ { l } ^ { t }$ ;   
+23: update learning rate $\eta ^ { t + 1 } =$ UpdateLearningrate $( \eta ^ { t } , t + 1 )$ ;
+
+24: end for
+
+Algorithm 4 Exact solver for $\hat { \mathbf { w } } _ { l } ^ { t }$ with two scaling parameters.
+
+1: Input: full-precision weight $\mathbf { w } _ { l } ^ { t }$ , diagonal entries of the approximate Hessian $\mathbf { d } _ { l } ^ { t - 1 }$ .   
+2: $\mathbf { s } _ { 1 } = \arg \operatorname { s o r t } ( \mathbf { w } _ { l } ^ { t } )$ ;   
+3: $\mathbf { c } _ { 1 } = \mathrm { c u m } ( \mathrm { p e r m } _ { \mathbf { s } _ { 1 } } ( | \mathbf { d } _ { l } ^ { t - 1 } \odot \mathbf { w } _ { l } ^ { t } | ) ) \oslash \mathrm { c u m } ( \mathrm { p e r m } _ { \mathbf { s } _ { 1 } } ( | \mathbf { d } _ { l } ^ { t - 1 } | ) ) \oslash 2 ;$   
+4: $\mathfrak { I } _ { 1 } = \mathrm { H n d } [ ( [ \mathrm { p e r m } _ { \mathbf { s } _ { 1 } } ( \mathbf { w } _ { l } ^ { t } ) ] _ { [ 1 : ( n _ { 1 } - 1 ) ] } - [ \mathbf { c } _ { 1 } ] _ { [ 1 : ( n _ { 1 } - 1 ) ] } )$ [perms1 (wtl )][2:n1] − [c1][1:n1−1]) < 0);   
+5: $\begin{array} { r } { \alpha _ { l } ^ { t } = 2 \arg \operatorname* { m a x } _ { c _ { i } , i \in \cal S _ { 1 } } [ { \bf c } _ { 1 } ] _ { i } ^ { 2 } \cdot [ { \bf c u m ( p e r m _ { s _ { 1 } } ( | { \bf d } } _ { l } ^ { t - 1 } | ) ) ] _ { i } . } \end{array}$ ;   
+6: $\mathbf { p } _ { l } ^ { t } = \mathbf { I } _ { \alpha / 2 } ^ { + } ( \mathbf { w } _ { l } ^ { t } )$ ;   
+7: $\mathbf { s } _ { 2 } = \operatorname { i n v e r s e } ( \mathbf { s } _ { 1 } )$ ;   
+8: $\begin{array} { r l } & { \mathbf { c } _ { 2 } = \mathrm { c u m } ( \mathrm { p e r m } _ { \mathbf { s } _ { 2 } } ( | \mathbf { d } _ { l } ^ { t - 1 } \odot \mathbf { w } _ { l } ^ { t } | ) ) \oslash \mathrm { c u m } ( \mathrm { p e r m } _ { \mathbf { s } _ { 2 } } ( | \mathbf { d } _ { l } ^ { t - 1 } | ) ) \oslash 2 ; } \\ & { S _ { 2 } = \mathrm { f u n d } ( ( [ - \mathrm { p e r m } _ { \mathbf { s } _ { 2 } } ( \mathbf { w } _ { l } ^ { t } ) ] [ \mathbf { 1 } _ { : ( n _ { 2 } - 1 ) ] } - [ \mathbf { c } _ { 2 } ] [ \mathbf { 1 } _ { : ( n _ { 2 } - 1 ) ] } ) \odot ( [ - \mathrm { p e r m } _ { \mathbf { s } _ { 2 } } ( \mathbf { w } _ { l } ^ { t } ) ] _ { [ 2 : n _ { 2 } ] } - [ \mathbf { c } _ { 2 } ] _ { [ 1 : n _ { 2 } - 1 ] } ) < } \\ & { 0 ; } \\ & { \beta _ { l } ^ { t } = 2 \mathrm { a r g } \operatorname* { m a x } _ { c _ { i } , i \in S _ { 2 } } [ \mathbf { c } _ { 2 } ] _ { i } ^ { 2 } \odot [ \mathrm { c u m } ( \mathrm { p e r m } _ { \mathbf { s } _ { 2 } } ( | \mathbf { d } _ { l } ^ { t - 1 } | ) ) ] _ { i } ; } \end{array}$   
+9:   
+10:   
+11: $\mathbf { q } _ { l } ^ { t } = \mathbf { I } _ { \beta / 2 } ^ { - } ( \mathbf { w } _ { l } ^ { t } )$ ;   
+12: Output: $\hat { \mathbf { w } } _ { l } ^ { t } = \alpha _ { l } ^ { t } \mathbf { p } _ { l } ^ { t } + \beta _ { l } ^ { t } \mathbf { q } _ { l } ^ { t }$ .
+
+2. CIFAR-10: This contains $3 2 \times 3 2$ color images from 10 object classes. We use 45, 000 images for training, another $5 , 0 0 0$ for validation, and the remaining $1 0 , 0 0 0$ for testing. The images are preprocessed with global contrast normalization and ZCA whitening. We use the VGG-like architecture:
+
+$$
+( 2 \times 1 2 8 C 3 ) - M P 2 - ( 2 \times 2 5 6 C 3 ) - M P 2 - ( 2 \times 5 1 2 C 3 ) - M P 2 - ( 2 \times 1 0 2 4 F C ) - 1 0 S V M ,
+$$
+
+where $C 3$ is a $3 \times 3$ ReLU convolution layer, and $M P 2$ is a $2 \times 2$ max-pooling layer. Batch normalization with a minibatch size of 50, is used. The maximum number of epochs
+
+Algorithm 5 Approximate solver for $\hat { \mathbf { w } } _ { l } ^ { t }$ with two scaling parameters
+
+1: Input: $\mathbf { b } _ { l } ^ { t - 1 }$ , full-precision weight $\mathbf { w } _ { l } ^ { t }$ , and diagonal entries of approximate Hessian $\mathbf { d } _ { l } ^ { t - 1 }$ .   
+2: Initialize: $\alpha = 1 . 0 , \alpha _ { \mathrm { o l d } } = 0 . 0 , \beta = 1 . 0 , \beta _ { o } = 0 . 0 , \mathbf { b } = \mathbf { b } _ { l } ^ { t - 1 } , \mathbf { p } = \mathbf { I } _ { 0 } ^ { + } ( \mathbf { b } ) , \mathbf { q } = \mathbf { I } _ { 0 } ^ { - } ( \mathbf { b } ) , \epsilon = 0 .$   
+$1 0 ^ { - 6 }$ .   
+3: while $| \alpha - \alpha _ { \mathrm { o l d } } | > \epsilon$ and $| \beta - \beta _ { \mathrm { o l d } } | > \epsilon$ do   
+4: $\alpha _ { \mathrm { o l d } } = \alpha$ , $\beta _ { \mathrm { o l d } } = \beta$ ;   
+5: $\begin{array} { r } { \alpha = \frac { \| \mathbf { p } \odot \mathbf { d } _ { l } ^ { t - 1 } \odot \mathbf { w } _ { l } ^ { t } \| _ { 1 } } { \| \mathbf { p } \odot \mathbf { d } _ { l } ^ { t - 1 } \| _ { 1 } } } \end{array}$ ;   
+6: $\mathbf { p } = \mathbf { I } _ { \alpha / 2 } ^ { + } ( \mathbf { w } _ { l } ^ { t } )$ ;   
+7: $\begin{array} { r } { \beta = \frac { \| \mathbf { q } \odot \mathbf { d } _ { l } ^ { t - 1 } \odot \mathbf { w } _ { l } ^ { t } \| _ { 1 } } { \| \mathbf { q } \odot \mathbf { d } _ { l } ^ { t - 1 } \| _ { 1 } } } \end{array}$ ;   
+8: $\mathbf { q } = \mathbf { I } _ { \beta / 2 } ^ { - } \big ( \mathbf { w } _ { l } ^ { t } \big )$ ;   
+9: end while   
+10: Output: $\hat { \mathbf { w } } _ { l } ^ { t } = \alpha \mathbf { p } + \beta \mathbf { q }$ .
+
+is 200. The learning rate for the weight-binarized network starts at 0.03 while for all the other networks starts at 0.002, and decays by a factor of 0.5 after every 15 epochs.
+
+3. CIFAR-100: This contains $3 2 \times 3 2$ color images from 100 object classes. We use 45, 000 images for training, another $5 , 0 0 0$ for validation, and the remaining $1 0 , 0 0 0$ for testing. The images are preprocessed with global contrast normalization and ZCA whitening. We use the VGG-like architecture:
+
+$$
+( 2 \times 1 2 8 C 3 ) - M P 2 - ( 2 \times 2 5 6 C 3 ) - M P 2 - ( 2 \times 5 1 2 C 3 ) - M P 2 - ( 2 \times 1 0 2 4 F C ) - 1 0 0 S V M .
+$$
+
+Batch normalization with a minibatch size of 100, is used. The maximum number of epochs is 200. The learning rate starts at 0.0005, and decays by a factor of 0.5 after every 15 epochs.
+
+4. SVHN: This contains $3 2 \times 3 2$ color images from 10 digit classes. We use 598, 388 images for training, another 6, 000 for validation, and the remaining 26, 032 for testing. The images are preprocessed with global and local contrast normalization. The model used is:
+
+$$
+( 2 \times 6 4 C 3 ) - M P 2 - ( 2 \times 1 2 8 C 3 ) - M P 2 - ( 2 \times 2 5 6 C 3 ) - M P 2 - ( 2 \times 1 0 2 4 F C ) - 1 0 S V M .
+$$
+
+Batch normalization with a minibatch size of 50, is used. The maximum number of epochs is 50. The learning rate starts at 0.001 for the weight-binarized network, and 0.0005 for the other networks. It then decays by a factor of 0.1 at epochs 15 and 25.
+
+# D.2 SETUP FOR RECURRENT NETWORKS
+
+The setup for the three data sets are as follows:
+
+1. Leo Tolstoy’s War and Peace: It consists of 3258K characters of almost entirely English text with minimal markup and a vocabulary size of 87. We use the same training/validation/test set split as in (Karpathy et al., 2016; Hou et al., 2017).   
+2. The source code of the Linux Kernel: This consists of 621K characters and a vocabulary size of 101. We use the same training/validation/test set split as in (Karpathy et al., 2016; Hou et al., 2017).   
+3. The Penn Treebank data set (Taylor et al., 2003): This has been frequently used for language modeling. It contains 50 different characters, including English characters, numbers, and punctuations. We follow the setting in (Mikolov & Zweig, 2012), with 5,017K characters for training, 393K for validation, and 442K characters for testing.
+
+We use a one-layer LSTM with 512 cells. The maximum number of epochs is 200, and the number of time steps is 100. The initial learning rate is 0.002. After 10 epochs, it is decayed by a factor of 0.98 after each epoch. The weights are initialized uniformly in [0.08, 0.08]. After each iteration, the gradients are clipped to the range $[ - 5 , 5 ]$ . All the updated weights are clipped to $[ - 1 , 1 ]$ for binarization and ternarization methods, but not for $m$ -bit (where $m > 2$ ) quantization methods.

parse/train/BydjJte0-/BydjJte0-.md

@@ -0,0 +1,385 @@
+# TOWARDS REVERSE-ENGINEERING BLACK-BOX NEURAL NETWORKS
+
+Seong Joon Oh, Max Augustin, Bernt Schiele, Mario Fritz   
+Max-Planck Institute for Informatics, Saarland Informatics Campus, Saarbrucken, Germany ¨   
+{joon,maxaug,schiele,mfritz}@mpi-inf.mpg.de
+
+# ABSTRACT
+
+Many deployed learned models are black boxes: given input, returns output. Internal information about the model, such as the architecture, optimisation procedure, or training data, is not disclosed explicitly as it might contain proprietary information or make the system more vulnerable. This work shows that such attributes of neural networks can be exposed from a sequence of queries. This has multiple implications. On the one hand, our work exposes the vulnerability of black-box neural networks to different types of attacks – we show that the revealed internal information helps generate more effective adversarial examples against the black box model. On the other hand, this technique can be used for better protection of private content from automatic recognition models using adversarial examples. Our paper suggests that it is actually hard to draw a line between white box and black box models. The code is available at goo.gl/MbYfsv.
+
+# 1 INTRODUCTION
+
+Black-box models take a sequence of query inputs, and return corresponding outputs, while keeping internal states such as model architecture hidden. They are deployed as black boxes usually on purpose – for protecting intellectual properties or privacy-sensitive training data. Our work aims at inferring information about the internals of black box models – ultimately turning them into white box models. Such a reverse-engineering of a black box model has many implications. On the one hand, it has legal implications to intellectual properties (IP) involving neural networks – internal information about the model can be proprietary and a key IP, and the training data may be privacy sensitive. Disclosing hidden details may also render the model more susceptible to attacks from adversaries. On the other hand, gaining information about a black-box model can be useful in other scenarios. E.g. there has been work on utilising adversarial examples for protecting private regions (e.g. faces) in photographs from automatic recognisers (Oh et al., 2017). In such scenarios, gaining more knowledge on the recognisers will increase the chance of protecting one’s privacy. Either way, it is a crucial research topic to investigate the type and amount of information that can be gained from a black-box access to a model. We make a first step towards understanding the connection between white box and black box approaches – which were previously thought of as distinct classes.
+
+We introduce the term “model attributes” to refer to various types of information about a trained neural network model. We group them into three types: (1) architecture (e.g. type of non-linear activation), (2) optimisation process (e.g. SGD or ADAM?), and (3) training data (e.g. which dataset?). We approach the problem as a standard supervised learning task applied over models. First, collect a diverse set of white-box models (“meta-training set”) that are expected to be similar to the target black box at least to a certain extent. Then, over the collected meta-training set, train another model (“metamodel”) that takes a model as input and returns the corresponding model attributes as output. Importantly, since we want to predict attributes at test time for black-box models, the only information available for attribute prediction is the query input-output pairs. As we will see in the experiments, such input-output pairs allow to predict model attributes surprisingly well.
+
+In summary, we contribute: (1) Investigation of the type and amount of internal information about the black-box model that can be extracted from querying; (2) Novel metamodel methods that not only reason over outputs from static query inputs, but also actively optimise query inputs that can extract more information; (3) Study of factors like size of the meta-training set, quantity and quality of queries, and the dissimilarity between the meta-training models and the test black box (generalisability); (4) Empirical verification that revealed information leads to greater susceptibility of a black-box model to an adversarial example based attack.
+
+# 2 RELATED WORK
+
+There has been a line of work on extracting and exploiting information from black-box learned models. We first describe papers on extracting information (model extraction and membership inference attacks), and then discuss ones on attacking the network using the extracted information (adversarial image perturbations $( A I P )$ ).
+
+Model extraction attacks either reconstruct the exact model parameters or build an avatar model that maximises the likelihood of the query input-output pairs from the target model (Tramer et al., 2016; Papernot et al., 2017). Tramer et al. (2016) have shown the efficacy of equation solving attacks and the avatar method in retrieving internal parameters of non-neural network models. Papernot et al. (2017) have also used the avatar approach with the end goal of generating adversarial examples. While the avatar approach first assumes model hyperparameters like model family (architecture) and training data, we discriminatively train a metamodel to predict those hyperparameters themselves. As such, our approach is complementary to the avatar approach.
+
+Membership inference attacks determine if a given data sample has been included in the training data (Ateniese et al., 2015; Shokri et al., 2017). In particular, Ateniese et al. (2015) also trains a decision tree metamodel over a set of classifiers trained on different datasets. This work goes far beyond only inferring the training data by showing that even the model architecture and optimisation process can be inferred.
+
+Using the obtained cues, one can launch more effective, focused attacks on the black box. We use adversarial image perturbations (AIPs) as an example of such attack. AIPs are small perturbations over the input such that the network is mislead. Research on this topic has flourished recently after it was shown that the needed amount of perturbation to completely mislead an image classifier is nearly invisible (Szegedy et al., 2014; Goodfellow et al., 2015; Moosavi-Dezfooli et al., 2017).
+
+Most effective AIPs require gradients of the target network. Some papers proposed different ways to attack black boxes. They can be grouped into three approaches. (1) Approximate gradients by numerical gradients (Narodytska & Kasiviswanathan, 2017; Chen et al., 2017). The caveat is that thousands and millions of queries are needed to compute a single AIP, depending on the image size. (2) Use the avatar approach to train a white box network that is supposedly similar to the target (Papernot et al., 2016b;a; Hayes & Danezis, 2017). We note again that our metamodel is complementary to the avatar approach – the avatar network hyperparemters can be determined by the metamodel. (3) Exploit transferability of adversarial examples; it has been shown that AIPs generated against one network can also fool other networks (Moosavi-Dezfooli et al., 2017; Liu et al., 2017). Liu et al. (2017) in particular have shown that generating AIPs against an ensemble of networks make it more transferable. We show in this work that the AIPs transfer better within an architecture family (e.g. ResNet or DenseNet) than across, and that such a property can be exploited by our metamodel for generating more targetted AIPs.
+
+# 3 METAMODELS
+
+We want to find out the type and amount of internal information about a black-box model that can be revealed from a sequence of queries. We approach this by first building metamodels for predicting model attributes, and then evaluating their performance on black-box models. Our
+
+![](images/40c4de6dd36b1ba4ed9b256dedf985e4afdfa323aff9d4b892a0bd2ae01de12d.jpg)  
+Figure 1: Overview of our approach.
+
+main approach, metamodel, is described in figure 1. In a nutshell, the metamodel is a classifier of classifiers. Specifically, The metamodel submits $n$ query inputs $\left[ x ^ { i } \right] _ { i = 1 } ^ { n }$ to a black box model $f$ ; the metamodel takes corresponding model outputs $\left[ f ( x ^ { i } ) \right] _ { i = 1 } ^ { n }$ as an input, and returns predicted model attributes as output. As we will describe in detail, the metamodel not only learns to infer model attributes from query outputs from a static set of inputs, but also searches for query inputs that are designed to extract greater amount of information from the target models.
+
+In this section, our main methods are introduced in the context of MNIST digit classifiers. While MNIST classifiers are not fully representative of generic learned models, they have a computational edge: it takes only five minutes to train each of them with reasonable performance. We could thus prepare a diverse set of 11k MNIST classifiers within 40 GPU days for the meta-training and evaluation of our metamodels. We stress, however, that the proposed approach is generic with respect to the task, data, and the type of models. We also focus on 12 model attributes (table 1) that cover hyperparameters for common neural network MNIST classifiers, but again the range of predictable attributes are not confined to this list.
+
+# 3.1 COLLECTING A DATASET OF CLASSIFIERS
+
+We need a dataset of classifiers to train and evaluate metamodels. We explain how MNIST-NETS has been constructed, a dataset of 11k MNIST digit classifiers; the procedure is task and data generic.
+
+# BASE NETWORK SKELETON
+
+Every model in MNIST-NETS shares the same convnet skeleton architecture: “ $N$ conv blocks $M$ fc blocks $ ~ 1$ linear classifier”. Each conv block has the following structure: “ks $\times$ ks convolution optional $2 \times 2$ max-pooling non-linear activation”, where ks (kernel size) and the activation type are to be chosen. Each fc block has the structure: “00linear mapping non-linear activation optional dropout” This convnet structure already covers many LeNet (LeCun et al., 1998) variants, one of the best performing architectures on MNIST1.
+
+# INCREASING DIVERSITY
+
+In order to learn generalisable features, the metamodel needs to be trained over a diverse set of models. The base architecture described above already has several free parameters like the number of layers ( $N$ and $M ,$ ), the existence of dropout or maxpooling layers, or the type of nonlinear activation.
+
+Table 1: MNIST classifier attributes. Italicised attributes are derived from other attributes.   
+
+<table><tr><td></td><td>Code</td><td>Attribute</td><td>Values</td></tr><tr><td>AAieeiteee</td><td>act drop pool ks #conv #fc</td><td>Activation Dropout Max pooling Conv ker. size #Conv layers #FC layers</td><td>ReLU,PReLU,ELU,Tanh Yes,No Yes,No 3,5 2,3,4 2,3,4</td></tr><tr><td>0</td><td>#par ens alg</td><td>#Parameters Ensemble Algorithm</td><td>214, ： 221 Yes,No SGD,ADAM,RMSprop</td></tr><tr><td>0</td><td>bs split size</td><td>Batch size Data split Data size</td><td>64,128,256 Allo,Halfo/1, Quarter0/1/2/3 All, Half, Quarter</td></tr></table>
+
+Apart from the architectural hyperparameters, we increase diversity along two more axes – optimisation process and the training data. Along the optimisation axis, we vary optimisation algorithm (SGD, ADAM, or
+
+RMSprop) and the training batch size (64, 128, 256). We also consider training MNIST classifiers on either on the entire MNIST training set $( \mathrm { A l l } _ { 0 }$ , 60k), one of the two disjoint halves $\mathrm { ( H a l f _ { 0 / 1 } }$ , 30k), or one of the four disjoint quarters (Quarte $\Gamma _ { 0 / 1 / 2 / 3 }$ , $1 5 \mathrm { k } )$ ).
+
+See table 1 for the comprehensive list of 12 model attributes altered in MNIST-NETS. The number of trainable parameters (#par) and the training data size (size) are not directly controlled but derived from the other attributes. We also augment MNIST-NETS with ensembles of classifiers (ens), whose procedure will be described later.
+
+# SAMPLING AND TRAINING
+
+The number of all possible combinations of controllable options in table 1 is 18, 144. We also select random seeds that control the initialisation and training data shuffling from $\{ 0 , \cdots , 9 9 9 \}$ , resulting in 18, 144, 000 unique models. Training such a large number of models is intractable; we have sampled (without replacement) and trained 10, 000 of them. All the models have been trained with learning rate 0.1 and momentum 0.5 for 100 epochs. It takes around 5 minutes to train each model on a GPU machine (GeForce GTX TITAN); training of 10k classifiers has taken 40 GPU days.
+
+# PRUNING AND AUGMENTING
+
+In order to make sure that MNIST-NETS realistically represents commonly used MNIST classifiers, we have pruned low-performance classifiers (validation accuracy $< 9 8 \%$ ), resulting in 8, 582 classifiers. Ensembles of trained classifiers have been constructed by grouping the identical classifiers (modulo random seed). Given $t$ identical ones, we have augmented MNIST-NETS with 2, · · · , $t$ combinations. The ensemble augmentation has resulted in 11, 282 final models. See appendix table 6 for statistics of attributes – due to large sample size all the attributes are evenly covered.
+
+# TRAIN-EVAL SPLITS
+
+Attribute prediction can get arbitrarily easy by including the black-box model (or similar ones) in the meta-training set. We introduce multiple splits of MNIST-NETS with varying requirements on generalization. Unless stated otherwise, every split has 5, 000 training (meta-training), 1, 000 testing (black box), and 5, 282 leftover models.
+
+The Random (R) split randomly (uniform weights) assigns training and test splits, respectively. Under the R split, the training and test models come from the same distribution. We introduce harder Extrapolation (E) splits. We separate a few attributes between the training and test splits. They are designed to simulate more difficult domain gaps when the meta-training models are significantly different from the black box. Specific examples of E splits will be shown in $\ S 4$ .
+
+# 3.2 METAMODEL METHODS
+
+The metamodel predicts the attribute of a black-box model $g$ in the test split by submitting $n$ query inputs and observing the outputs. It is trained over meta-training models $f$ in the training split $( f \sim \mathcal { F } )$ . We propose three approaches for the metamodels – we collectively name them kennen2. See figure 2 for an overview.
+
+# K E N N E N-O: REASON OVER OUTPUT
+
+kennen-o first selects a fixed set of queries $[ x ^ { i } ] _ { i = 1 \cdots n }$ from a dataset. Both during training and testing, always these queries are submitted. kennen $\scriptscriptstyle - \bigcirc$ learns a classifier $m _ { \theta }$ to map from the order-sensitively concatenated $n$ query outputs, $[ f ( x ^ { i } ) ] _ { i = 1 \cdots n }$ $( n \times 1 0$ dim for MNIST), to the simultaneous prediction of 12 attributes in $f$ . The training objective is:
+
+$$
+\operatorname* { m i n } _ { \theta } { } _ { f \sim \mathcal { F } } \left[ \sum _ { a = 1 } ^ { 1 2 } \mathcal { L } \left( m _ { \theta } ^ { a } \left( [ f ( x ^ { i } ) ] _ { i = 1 } ^ { n } \right) , y ^ { a } \right) \right]
+$$
+
+![](images/356980c8e1f698f631961d53b145ff3b64f47856bd5bb5f38b04ed21d2117b22.jpg)  
+Figure 2: Training procedure for metamodels kennen-o (top) and kennen-i (bottom).
+
+where $\mathcal { F }$ is the distribution of meta-training models, $y ^ { a }$ is the ground truth label of attribute $a$ , and $\mathcal { L }$ is the cross-entropy loss. With the learned parameter $\tilde { \theta }$ $m _ { \tilde { \theta } } ^ { a } \left( [ g ( x ^ { i } ) ] _ { i = 1 } ^ { n } \right)$ gives the prediction of attribute $a$ for the black box $g$ .
+
+In our experiments, we model the classifier $m _ { \theta }$ via multilayer perceptron (MLP) with two hidden layers with 1000 hidden units. The last layer consists of 12 parallel linear layers for a simultaneous prediction of the attributes. In our preliminary experiments, MLP has performed better than the linear classifiers. The optimisation problem in equation 1 is solved via SGD by approximating the expectation over $f \sim \mathbb { F }$ by an empirical sum over the training split classifiers for 200 epochs.
+
+For query inputs, we have used a random subset of $n$ images from the validation set (both for MNIST and ImageNet experiments). The performance is not sensitive to the choice of queries (see appendix $\ S C _ { \iota }$ ). Next methods $( \mathrm { k e n n e n - i } / \mathrm { i } \circ )$ describe how to actively craft query inputs, potentially outside the natural image distribution.
+
+Note that kennen $- \bigcirc$ can be applied to any type of model (e.g. non-neural networks) with any output structure, as long as the output can be embedded in an Euclidean space. We will show that this method can effectively extract information from $f$ even if the output is a top-k ranking.
+
+# K E N N E N-I: CRAFT INPUT
+
+kennen $- \dot { \beth }$ crafts a single query input $\tilde { x }$ over the meta-training models that is trained to repurpose a digit classifier $f$ into a model attribute classifier for a single attribute $a$ . The crafted input drives the classifier to leak internal information via digit prediction. The learned input is submitted to the test black-box model $g$ , and the attribute is predicted by reading off its digit prediction $g ( \tilde { x } )$ . For example, kennen $- \dot { \mathtt { 1 } }$ for max-pooling layer prediction crafts an input $x$ that is predicted as “1” for generic MNIST digit classifiers with max-pooling layers and $ { { } ^ { 6 } }  { 0 ^ { 9 } }$ for ones without. See figure 3 for visual examples.
+
+We describe in detail how kennen-i learns this input. The training objective is:
+
+$$
+\operatorname* { m i n } _ { x : { \mathrm { i m a g e } } } \ { \underset { f \sim { \mathcal F } } { \mathbb E } } \left[ { \mathcal { L } } \left( f ( x ) , y ^ { a } \right) \right]
+$$
+
+where $f ( x )$ is the 10-dimensional output of the digit classifier $f$ . The condition $x :$ image ensures the input stays a valid image $x \in [ \breve { 0 } , 1 ] ^ { D }$ with image dimension $D$ . The loss $\mathcal { L }$ , together with the attribute label $y ^ { a }$ of $f$ , guides the digit prediction $f ( x )$ to reveal the attribute $a$ instead. Note that the optimisation problem is identical
+
+![](images/70b3c4a49d589b795fa6ec8c81ba3073bfac876f45b0d3e297f1b9cf56732ef2.jpg)  
+Figure 3: Inputs designed to extract internal details from MNIST digit classifiers. E.g. feeding the middle image reveals the existence of a maxpooling layer with $9 4 . 8 \%$ chance.
+
+to the training of digit classifiers except that the ground truth is the attribute label rather than the digit label, that the loss is averaged over the models instead of the images, and that the input $x$ instead of the model $f$ is optimised. With the learned query input $\tilde { x }$ , the attribute for the black box $g$ is predicted by $g ( \tilde { x } )$ . In particular, we do not use gradient information from $g$ .
+
+We initialise $x$ with a random sample from the MNIST validation set (random noise or uniform gray initialisation gives similar performances), and run SGD for 200 epochs. For each iteration $x$ is truncated back to $[ \bar { 0 } , 1 ] ^ { D }$ to enforce the constraint.
+
+While being simple and effective, kennen-i can only predict a single attribute at a time, and cannot predict attributes with more than 10 classes (for digit classifiers). kennen-io introduced below overcomes these limitations. kennen $- \dot { \beth }$ may also be unrealistic when the exploration needs to be stealthy: it submits unnatural images to the system. Also unlike kennen-o, kennen $^ { - \dot { 1 } }$ requires end-to-end differentiability of the training models $f \sim \mathcal { F }$ , although it still requires only black-box access to test models $g$ .
+
+# K E N N E N-I O: COMBINED APPROACH
+
+We overcome the drawbacks of kennen-i that it can only predict one attribute at a time and that the number of predictable classes by attaching an additional interpretation module on top of the output. Our final method kennen-io combines kennen-i and kennen-o approaches: both input generator and output interpreters are used. Being able to reason over multiple query outputs via MLP layers, kennen-io supports the optimisation of multiple query inputs as well.
+
+Specifically, the kennen-io training objective is given by:
+
+$$
+\operatorname* { m i n } _ { [ x ^ { i } ] _ { i = 1 } ^ { n } : \mathrm { i m a g e s } } \operatorname* { m i n } _ { \theta } \underset { f \sim \mathcal { F } } { \mathbb { E } } \left[ \sum _ { a = 1 } ^ { 1 2 } \mathcal { L } \left( m _ { \theta } ^ { a } \left( [ f ( x ^ { i } ) ] _ { i = 1 } ^ { n } \right) , y ^ { a } \right) \right] .
+$$
+
+Note that the formulation is identical to that for kennen $- \bigcirc$ (equation 1), except that the second minimisation problem regarding the query inputs is added. With learned parameters $\tilde { \theta }$ and $[ \tilde { x } ^ { i } ] _ { i = 1 } ^ { n }$ ,
+
+Table 2: Comparison of metamodel methods. See table 1 for the full names of attributes. 100 queries are used for every method below, except for kennen-i which uses a single query. The “Output” column shows the output representation: “prob” (vector of probabilities for each digit class), “ranking” (a sorted list of digits according to their likelihood), “top-1” (most likely digit), or “bottom-1” (least likely digit).   
+
+<table><tr><td rowspan="2">Method</td><td rowspan="2"> Output</td><td colspan="8">architecture</td><td colspan="2">optim</td><td colspan="2">data</td></tr><tr><td>act</td><td>drop</td><td>pool</td><td>ks</td><td>#conv</td><td></td><td></td><td>#fc #par ens</td><td>algbs</td><td></td><td>size split</td><td>avg</td></tr><tr><td>Chance</td><td>-</td><td>25.0</td><td>50.0</td><td>50.0</td><td>50.0</td><td>33.3</td><td>33.3</td><td>12.5 50.0</td><td></td><td>33.3 33.3</td><td></td><td>33.3 14.3</td><td>34.9</td></tr><tr><td>kennen-o</td><td>prob</td><td>80.6</td><td>94.6</td><td>94.9</td><td>84.6</td><td>67.1</td><td>77.3</td><td>41.7 54.0</td><td></td><td>71.8 50.4</td><td></td><td>73.8 90.0</td><td>73.4</td></tr><tr><td>kennen-o</td><td>ranking</td><td>63.7</td><td>93.8</td><td>90.8</td><td>80.0</td><td>63.0</td><td>73.7</td><td>44.1</td><td>62.4</td><td>65.3 47.0</td><td>66.2</td><td>86.6</td><td>69.7</td></tr><tr><td>kennen-o</td><td>bottom-1</td><td>48.6</td><td>80.0</td><td>73.6</td><td>64.0</td><td>48.9</td><td>63.1</td><td></td><td>28.7 52.8</td><td>53.6 41.9</td><td></td><td>45.9 51.4</td><td>54.4</td></tr><tr><td>kennen-o</td><td>top-1</td><td>31.2</td><td>56.9</td><td>58.8</td><td>49.9</td><td>38.9</td><td>33.7</td><td>19.6</td><td>50.0</td><td>36.1 35.3</td><td>33.3</td><td>30.7</td><td>39.5</td></tr><tr><td>kennen-i</td><td>top-1</td><td>43.5</td><td>77.0</td><td>94.8</td><td>88.5</td><td>54.5</td><td>41.0</td><td>32.3</td><td>46.5</td><td>45.7 37.0</td><td></td><td>42.6 29.3</td><td>52.7</td></tr><tr><td>kennen-io</td><td>score</td><td>88.4 95.8</td><td></td><td></td><td>99.5 97.7</td><td>80.3</td><td>80.2</td><td>45.2</td><td>60.2</td><td>79.3 54.3</td><td></td><td>84.8 95.6</td><td>80.1</td></tr></table>
+
+the attribute $a$ for the black box $g$ is predicted by $m _ { \tilde { \theta } } ^ { a } \ : \left( [ g ( \tilde { x } ^ { i } ) ] _ { i = 1 } ^ { n } \right)$ . Again, we require end-to-end differentiability of meta-training models $f$ , but only the black-box access for the test model $g$ .
+
+To improve stability against covariate shift, we initialise $m _ { \theta }$ with kennen-o for 200 epochs. Afterwards, gradient updates of $[ x ^ { i } ] _ { i = 1 } ^ { n }$ and $\theta$ alternate every 50 epochs, for 200 additional epochs.
+
+# 4 REVERSE-ENGINEERING BLACK-BOX MNIST DIGIT CLASSIFIERS
+
+We have introduced a procedure for constructing a dataset of classifiers (MNIST-NETS) as well as novel metamodels (kennen variants) that learn to extract information from black-box classifiers. In this section, we evaluate the ability of kennen to extract information from black-box MNIST digit classifiers. We measure the class-balanced attribute prediction accuracy for each attribute $a$ in the list of 12 attributes in table 1.
+
+# ATTRIBUTE PREDICTION
+
+See table 2 for the main results of our metamodels, kennen-o/i/io, on the Random split. Unless stated otherwise, metamodels are trained with 5, 000 training split classifiers.
+
+Given $n = 1 0 0$ queries with probability output, kennen-o already performs far above the random chance in predicting 12 diverse attributes ( $7 3 . 4 \%$ versus $3 4 . 9 \%$ on average); neural network output indeed contains rich information about the black box. In particular, the presence of dropout $( 9 4 . 6 \% )$ or max-pooling $( 9 4 . 9 \% )$ has been predicted with high precision. As we will see in $\ S 4 . 3$ , outputs of networks trained with dropout layers form clusters, explaining the good prediction performance.
+
+It is surprising that optimisation details like algorithm $( 7 1 . 8 \% )$ and batch size $( 5 0 . 4 \% )$ can also be predicted well above the random chance $3 3 . 3 \%$ for both). We observe that the training data attributes are also predicted with high accuracy $( 7 1 . 8 \%$ and $9 0 . 0 \%$ for size and split).
+
+# COMPARING METHODS K E N N E N-O/I/I O
+
+Table 2 shows the comparison of kennen-o/i/io. kennen $- \dot { \mathtt { 1 } }$ has a relatively low performance (average $5 2 . 7 \% )$ ), but kennen-i relies on a cheap resource: 1 query with single-label output. kennen-i is also performant at predicting the kernel size $( 8 8 . 5 \% )$ and pooling $( 9 4 . 8 \% )$ , attributes that are closely linked to spatial structure of the input. We conjecture kennen-i is relatively effective for such attributes. kennen-io is superior to kennen $- \phantom { } _ { \mathsf { O } } / \mathrm { i }$ for all the attributes with average accuracy $8 0 . 1 \%$ .
+
+# 4.1 FACTOR ANALYSIS
+
+We examine potential factors that contribute to the successful prediction of black box internal attributes. We measure the prediction accuracy of our metamodels as we vary (1) the number of meta-training models, (2) the number of queries, and (3) the quality of query output.
+
+![](images/2b1ecd72ed511fabda0412e1a7ed42739ad7148745224f27bedbfd0d155955ed.jpg)  
+Figure 4: kennen $- \bigcirc$ performance of against the size of meta-training set (left), number of queries (middle), and quality of queries (right). Unless stated otherwise, we use 100 probability outputs and 5k models to train kennen-o. Each curve is linearly scaled such that random chance (0 training data, 0 query, or top-0) performs $0 \%$ , and the perfect predictor performs $100 \%$ .
+
+# NUMBER OF TRAINING MODELS
+
+We have trained kennen $- \bigcirc$ with different number of the meta-training classifiers, ranging from 100 to 5, 000. See figure 4 (left) for the trend. We observe a diminishing return, but also that the performance has not saturated – collecting larger meta-training set will improve the performance.
+
+# NUMBER OF QUERIES
+
+See figure 4 (middle) for the kennen-o performance against the number of queries with probability output. The average performance saturates after $\sim 5 0 0$ queries. On the other hand, with only $\sim 1 0 0$ queries, we already retrieve ample information about the neural network.
+
+# QUALITY OF OUTPUT
+
+Many black-box models return top- $\mathbf { \nabla } \cdot \mathbf { k }$ ranking (e.g. Facebook face recogniser), or single-label output. We represent top- $\mathbf { \nabla } \cdot \mathbf { k }$ ranking outputs by assigning exponentially decaying probabilities up to $k$ digits and a small probability $\epsilon$ to the remaining.
+
+See table 2 for the kennen $- \bigcirc$ performance comparison among 100 probability, top-10 ranking, bottom-1, and top-1 outputs, with average accuracies $7 3 . 4 \%$ , $6 9 . 7 \%$ , $5 4 . 4 \%$ , and $3 9 . 5 \%$ , respectively. While performance drops with coarser outputs, when compared to random chance $( 3 4 . 9 \% )$ , 100 single-label bottom-1 outputs already leak a great amount of information about the black box $( 5 4 . 4 \% )$ . It is also notable that bottom-1 outputs contain much more information than do the top1 outputs; note that for high-performance classifiers top-1 predictions are rather uniform across models and thus have much less freedom to leak auxiliary information. Figure 4 (right) shows the interpolation from top-1 to top-10 (i.e. top-9) ranking. We observe from the jump at $k = 2$ that the second likely predictions (top-2) contain far more information than the most likely ones (top-1). For $k \geq 3$ , each additional output label exhibits a diminishing return.
+
+# 4.2 WHAT IF THE BLACK-BOX IS QUITE DIFFERENT FROM META-TRAINING MODELS?
+
+So far we have seen results on the Random (R) split. In realistic scenarios, the meta-training model distribution may not be fully covering possible black box models. We show how damaging such a scenario is through Extrapolation (E) split experiments.
+
+# EVALUATION
+
+E-splits split the training and testing models based on one or more attributes (§3.1). For example, we may assign shallower models (#layers $\leq 1 0$ ) to the training split and deeper ones (#layers $\it { i } ^ { \scriptsize { 1 0 } \mathrm { ) } }$ to the testing split. In this example, we refer to #layers as the splitting attribute. Since for an E-split, some classes of the splitting attributes have zero training examples, we only evaluate the prediction accuracies over the non-splitting attributes. When the set of splitting attributes is $\tilde { A }$ , a subset of the entire attribute set $A$ , we define $E$ -split accuracy or $\operatorname { E . A c c } ( { \tilde { A } } )$ to be the mean prediction accuracy over the non-splitting attributes $A \setminus { \tilde { A } }$ . For easier comparison, we report the normalised accuracy (N.Acc) that shows the how much percentage of the R-split accuracy is achieved in the E-split setup on the non-splitting attributes $A \setminus { \tilde { A } }$ . Specifically:
+
+$$
+\mathrm { N . A c c } ( \tilde { A } ) = \frac { \mathrm { E . A c c } ( \tilde { A } ) - \mathrm { C h a n c e } ( \tilde { A } ) } { \mathrm { R . A c c } ( \tilde { A } ) - \mathrm { C h a n c e } ( \tilde { A } ) } \times 1 0 0 \%
+$$
+
+where ${ \mathrm { R . A c c } } ( { \tilde { A } } )$ and Chance $( { \tilde { A } } )$ are the means of the R-split and Chance-level accuracies over $A \setminus { \tilde { A } }$ . Note that N.Acc is $100 \%$ if the E-split performance is at the level of R-split and $0 \%$ if it is at chance level.
+
+# RESULTS
+
+The normalised accuracies for R-split and multiple E-splits are presented in table 3. We consider three axes of choices of splitting attributes for the E-split: architecture (#conv and #fc), optimisation (alg and bs), and data (size). For example, “E-#conv-#fc” row presents results when metamodel is trained on shallower nets (2 or 3 conv/fc layers each) compared to the test black box model (4 conv and fc layers each).
+
+Not surprisingly, E-split performances are lower than R-split ones $( \mathrm { N . A c c } < 1 0 0 \% )$ ; it is advisable to cover all the expected black-box attributes during meta-training. Nonetheless, E-split performances of kennen-io are still far above the chance level $( \mathrm { N . A c c } \ge 7 0 \% \gg$ $0 \%$ ); failing to cover a few attributes during meta-training is not too damaging.
+
+Table 3: Normalised accuracies (see text) of kennen-o and kennen-io on R and E splits. We denote E-split with splitting attributes attr1 and attr2 as “E-attr1-attr2”. Splitting criteria are also shown. When there are two splitting attributes, the first attribute inherits the previous row criteria.   
+
+<table><tr><td rowspan=2 colspan=9>kennen-Split         Train      Test        。    ioR                          =          100  100</td></tr><tr><td rowspan=1 colspan=1>100</td><td rowspan=1 colspan=1>100</td></tr><tr><td rowspan=1 colspan=1>E-#conv</td><td></td><td rowspan=1 colspan=1>2.3</td><td></td><td rowspan=1 colspan=1>4</td><td></td><td rowspan=1 colspan=1>87.5</td><td></td><td rowspan=1 colspan=1>92.0</td></tr><tr><td rowspan=1 colspan=1>E-#conv-#fc</td><td></td><td rowspan=1 colspan=1>2.3</td><td></td><td rowspan=1 colspan=1>4</td><td></td><td rowspan=1 colspan=1>77.1</td><td></td><td rowspan=1 colspan=1>80.7</td></tr><tr><td rowspan=1 colspan=1>E-alg</td><td></td><td rowspan=1 colspan=1>SGD,ADAM</td><td></td><td rowspan=1 colspan=1>RMSprop</td><td></td><td rowspan=1 colspan=1>83.0</td><td></td><td rowspan=1 colspan=1>88.5</td></tr><tr><td rowspan=1 colspan=1>E-alg-bs</td><td></td><td rowspan=1 colspan=1>64,128</td><td></td><td rowspan=1 colspan=1>256</td><td></td><td rowspan=1 colspan=1>64.2</td><td></td><td rowspan=1 colspan=1>70.0</td></tr><tr><td rowspan=1 colspan=1>E-split</td><td></td><td rowspan=1 colspan=1>Quartero/1</td><td></td><td rowspan=1 colspan=1>Quarter2/3</td><td></td><td rowspan=1 colspan=1>83.5</td><td></td><td rowspan=1 colspan=1>89.3</td></tr><tr><td rowspan=1 colspan=1>E-size</td><td></td><td rowspan=1 colspan=1>Quarter</td><td></td><td rowspan=1 colspan=1>Half,All</td><td></td><td rowspan=1 colspan=1>81.7</td><td></td><td rowspan=1 colspan=1>86.8</td></tr><tr><td rowspan=1 colspan=1>Chance</td><td></td><td rowspan=1 colspan=1></td><td></td><td rowspan=1 colspan=1></td><td></td><td rowspan=1 colspan=1>0.0</td><td></td><td rowspan=1 colspan=1>0.0</td></tr></table>
+
+Comparing kennen-o and kennen-io for their generalisability, we observe that kennen-io consistently outperforms kennen-o under severe extrapolation (around $5 ~ { \mathsf { p p } }$ better N.Acc). It is left as a future work to investigate the intriguing fact that utilising out-of-domain query inputs improves the generalisation of metamodel.
+
+# 4.3 WHY AND HOW DOES METAMODEL WORK?
+
+It is surprising that metamodels can extract inner details with great precision and generalisability. This section provides a glimpse of why and how this is possible via metamodel input and output analyses. Full answers to those questions is beyond the scope of the paper.
+
+# METAMODEL INPUT (T-SNE)
+
+We analyse the inputs to our metamodels (i.e. query outputs from black-box models) to convince ourselves that the inputs do contain discriminative features for model attributes. As the input is high dimensional (1000 when the number of queries is $n = 1 0 0 ,$ ), we use the t-SNE (van der Maaten & Hinton, Nov 2008) visualisation method. Roughly speaking, t-SNE embeds high dimensional data points onto the 2-dimensional plane such that the pairwise distances are best respected. We then colour-code the embedded data points according to the model attributes. Clusters of same-coloured points indicate highly discriminative features.
+
+The visualisation of input data points are shown in Appendix figures 9 and 10 for kennen-o and kennen-io, respectively. For experimental details, see Appendix $\ S _ { \mathrm { D } }$ . In the case of kennen-o, we observe that some attributes form clear clusters in the input space – e.g. Tanh in act, binary dropout attribute, and RMSprop in alg. For the other attributes, however, it seems that the clusters are too complicated to be represented in a 2-dimensional space. For kennen-io (figure 10), we observe improved clusters for pool and ks. By submitting crafted query inputs, kennen-io induces query outputs to be better clustered, increasing the chance of successful prediction.
+
+METAMODEL OUTPUT (CONFUSION MATRIX)
+
+We show confusion matrices of kennen-o/io to analyse the failure modes. See Appendix figures 11 and 12. For kennen-o and kennen-io alike, we observe that the confusion occurs more frequently with similar classes. For attributes #conv and #fc, more confusion occurs between $( 2 , 3 )$ or $( 3 , 4 )$ than between $( 2 , 4 )$ . A similar trend is observed for #par and bs. This is a strong indication that (1) there exists semantic attribute information in the neural network outputs (e.g. number of layers, parameters, or size of training batch) and (2) the metamodels learn semantic information that can generalise, as opposed to merely relying on artifacts. This observation agrees with a conclusion of the extrapolation experiments in $\ S 4 . 2$ : the metamodels generalise.
+
+Compared to those of kennen $- \bigcirc$ , kennen $- \dot { \beth } \bigcirc$ confusion matrices exhibit greater concentration of masses both on the correct class (diagonals) and among similar attribute classes (1-off diagonals for #conv, #fc, #par, bs, and size). The former re-confirms the greater accuracy, while the latter indicates the improved ability to extract more semantic and generalisable features from the query outputs. This, again, agrees with $\ S 4 . 2$ : kennen-io generalises better than kennen $- \bigcirc$ .
+
+# 4.4 DISCUSSION
+
+We have verified through our novel kennen metamodels that black-box access to a neural network exposes much internal information. We have shown that only 100 single-label outputs already reveals a great deal about a black box. When the black-box classifier is quite different from the metatraining classifiers, the performance of our best metamodel – kennen-io– decreases; however, the prediction accuracy for black box internal information is still surprisingly high.
+
+# 5 REVERSE-ENGINEERING AND ATTACKING IMAGENET CLASSIFIERS
+
+While MNIST experiments are computationally cheap and a massive number of controlled experiments is possible, we provide additional ImageNet experiments for practical implications on realistic image classifiers. In this section, we use kennen $- \circ$ introduced in $\ S 3$ to predict a single attribute of black-box ImageNet classifiers – the architecture family (e.g. ResNet or VGG?). In this section, we go a step further to use the extracted information to attack black boxes with adversarial examples.
+
+# 5.1 DATASET OF IMAGENET CLASSIFIERS
+
+It is computationally prohibitive to train $O ( 1 0 k )$ ImageNet classifiers from scratch as in the previous section. We have resorted to 19 PyTorch3 pretrained ImageNet classifiers. The 19 classifiers come from five families: Squeezenet, VGG, VGG-BatchNorm, ResNet, and DenseNet, each with 2, 4, 4, 5, and 4 variants, respectively (Iandola et al., 2016; Simonyan & Zisserman, 2015; Ioffe & Szegedy, 2015; He et al., 2016; Huang et al., 2017). See Appendix table 7 for the the summary of the 19 classifiers. We observe both large intra-family diversity and small inter-family separability in terms of #layers, #parameters, and performances. The family prediction task is not as trivial as e.g. simply inferring the performance.
+
+# 5.2 CLASSIFIER FAMILY PREDICTION
+
+We predict the classifier family (S, V, B, R, D) from the black-box query output, using the method kennen-o, with the same MLP architecture (§3). kennen-i and kennen-io have not been used for computational reasons, but can also be used in principle. We conduct 10 cross validations (random sampling of single test network from each family) for evaluation. We also perform 10 random sampling of the queries from ImageNet validation set. In total 100 random tries are averaged.
+
+Results: compared to the random chance $( 2 0 . 0 \% )$ , 100 queries result in high kennen $- \bigcirc$ performance $( 9 0 . 4 \% )$ . With 1, 000 queries, the prediction performance is even $9 4 . 8 \%$ .
+
+# 5.3 ATTACKING IMAGENET CLASSIFIERS
+
+In this section we attack ImageNet classifiers with adversarial image perturbations (AIPs). We show that the knowledge about the black box architecture family makes the attack more effective.
+
+# ADVERSARIAL IMAGE PERTURBATION (AIP)
+
+AIPs are carefully crafted additive perturbations on the input image for the purpose of misleading the target model to predict wrong labels (Goodfellow et al., 2015). Among variants of AIPs, we use efficient and robust GAMAN (Oh et al., 2017). See appendix figure 7 for examples of AIPs; the perturbation is nearly invisible.
+
+# TRANSFERABILITY OF AIPS
+
+Typical AIP algorithms require gradients from the target network, which is not available for a black box. Mainly three approaches for generating AIPs against black boxes have been proposed: (1) numerical gradient, (2) avatar network, or (3) transferability. We show that our metamodel strengthens the transferability based attack.
+
+Table 4: Transferability of adversarial examples within and across families. We report misclassification rates.   
+
+<table><tr><td rowspan=2 colspan=7>Target familyGen   S V B R DClean 3832283029</td></tr><tr><td rowspan=1 colspan=1>38</td><td rowspan=1 colspan=1>32</td><td rowspan=1 colspan=1>28</td><td rowspan=1 colspan=1>30</td><td rowspan=1 colspan=1>29</td></tr><tr><td rowspan=1 colspan=1>S</td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>64</td><td rowspan=1 colspan=1>49</td><td rowspan=1 colspan=1>45</td><td rowspan=1 colspan=1>39</td><td rowspan=1 colspan=1>35</td></tr><tr><td rowspan=1 colspan=1>V</td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>62</td><td rowspan=1 colspan=1>96</td><td rowspan=1 colspan=1>9</td><td rowspan=1 colspan=1>57</td><td rowspan=1 colspan=1>52</td></tr><tr><td rowspan=1 colspan=1>B</td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>50</td><td rowspan=1 colspan=1>85</td><td rowspan=1 colspan=1>95</td><td rowspan=1 colspan=1>47</td><td rowspan=1 colspan=1>44</td></tr><tr><td rowspan=1 colspan=1>R</td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>64</td><td rowspan=1 colspan=1>72</td><td rowspan=1 colspan=1>78</td><td rowspan=1 colspan=1>87</td><td rowspan=1 colspan=1>77</td></tr><tr><td rowspan=1 colspan=1>D</td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>58</td><td rowspan=1 colspan=1>63</td><td rowspan=1 colspan=1>70</td><td rowspan=1 colspan=1>76</td><td rowspan=1 colspan=1>90</td></tr><tr><td rowspan=1 colspan=1>Ens</td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>70</td><td rowspan=1 colspan=1>93</td><td rowspan=1 colspan=1>93</td><td rowspan=1 colspan=1>75</td><td rowspan=1 colspan=1>80</td></tr></table>
+
+We hypothesize and empirically show that AIPs transfer better within the architecture family than across. Using this property, we first predict the family of the black box (e.g. ResNet), and then generate AIPs against a few instances in the family (e.g. ResNet101, ResNet152). The generation of AIPs against multiple targets has been proposed by Liu et al. (2017), but we are the first to systemically show that AIPs generalise better within a family when they are generated against multiple instances from the same family.
+
+We first verify our hypothesis that AIPs transfer better within a family. Within-family: we do a leave-one-out cross validation – generate AIPs using all but one instances of the family and test on the holdout. Not using the exact test black box, this gives a lower bound on the within-family performance. Across-family: still leave out one random instance from the generating family to match the generating set size with the within-family cases. We also include the use-all case (Ens): generate AIPs with one network from each family.
+
+See table 4 for the results. We report the misclassification rate, defined as 100−top-1 accuracy, on 100 random ImageNet validation images. We observe that the within-family performances dominate the across-family ones (diagonal entries versus the others in each row); if the target black box family is identified, one can generate more effective AIPs. Finally, trying to target all network (“Ens”) is not as effective as focusing resources (diagonal entries).
+
+# METAMODEL ENABLES MORE EFFECTIVE ATTACKS
+
+We empirically show that the reverse-engineering enables more effective attacks. We consider multiple scenarios. “White box” means the target model is fully known, and the AIP is generated specifically for this model. “Black box” means the exact target is unknown, but we make a distinction when the family is known (“Family black box”).
+
+See table 5 for the misclassification rates (MC) in different scenarios. When the target is fully specified (white box), MC is $100 \%$ . When neither the exact target nor the family is known, AIPs are generated against multiple families $( 8 2 . 2 \% )$ . When the reverse-engineering takes place, and AIPs are generated over the predicted family, attacks become more effective $( 8 5 . 7 \% )$ . We almost reach the family-oracle case $( 8 6 . 2 \% )$ .
+
+Table 5: Black-box ImageNet classifier misclassification rates (MC) for different approaches.   
+
+<table><tr><td>Scenario</td><td>Generating nets</td><td>MC(%)</td></tr><tr><td>White box</td><td>Single white box</td><td>100.0</td></tr><tr><td>Family black box</td><td>GT family</td><td>86.2</td></tr><tr><td>Black box whitened</td><td>Predicted family</td><td>85.7</td></tr><tr><td>Black box</td><td>Multiple families</td><td>82.2</td></tr></table>
+
+# 5.4 DISCUSSION
+
+Our metamodel can predict architecture families for ImageNet classifiers with high accuracy. We additionally show that this reverse-engineering enables more focused attack on black-boxes.
+
+# 6 CONCLUSION
+
+We have presented first results on the inference of diverse neural network attributes from a sequence of input-output queries. Our novel metamodel methods, kennen, can successfully predict attributes related not only to the architecture but also to training hyperparameters (optimisation algorithm and dataset) even in difficult scenarios (e.g. single-label output, or a distribution gap between the metatraining models and the target black box). We have additionally shown in ImageNet experiments that reverse-engineering a black box makes it more vulnerable to adversarial examples.
+
+# ACKNOWLEDGMENTS
+
+This research was supported by the German Research Foundation (DFG CRC 1223). We thank Seong Ah Choi for her help with the method names, graphics, and colour palettes.
+
+# REFERENCES
+
+Giuseppe Ateniese, Giovanni Felici, Liugi V. Mancini, Angelo Spognardi, Antonio Villani, and Domenico Vitali. Hacking smart machines with smarter ones: How to extract meaningful data from machine learning classifiers. In IJSN, 2015.
+
+Pin-Yu Chen, Huan Zhang, Yash Sharma, Jinfeng Yi, and Cho-Jui Hsieh. Zoo: Zeroth order optimization based black-box attacks to deep neural networks without training substitute models. In ACMCCS-W, 2017.
+
+Ian J Goodfellow, Jonathon Shlens, and Christian Szegedy. Explaining and harnessing adversarial examples. In ICLR, 2015.
+
+Jamie Hayes and George Danezis. Machine learning as an adversarial service: Learning black-box adversarial examples. 2017.
+
+Kaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. Deep residual learning for image recognition. In CVPR, 2016.
+
+Gao Huang, Zhuang Liu, Laurens van der Maaten, and Kilian Q Weinberger. Densely connected convolutional networks. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, 2017.
+
+Forrest N. Iandola, Song Han, Matthew W. Moskewicz, Khalid Ashraf, William J. Dally, and Kurt Keutzer. Squeezenet: Alexnet-level accuracy with $5 0 \mathrm { x }$ fewer parameters and ${ < } 0 . 5 \mathrm { m b }$ model size. arXiv, 2016.
+
+Sergey Ioffe and Christian Szegedy. Batch normalization: Accelerating deep network training by reducing internal covariate shift. In ICML, 2015.
+
+Yann LeCun, Leon Bottou, Yoshua Bengio, and Patrick Haffner. Gradient-based learning applied to ´ document recognition. Proceedings of the IEEE, 1998.
+
+Yanpei Liu, Xinyun Chen, Chang Liu, and Dawn Song. Delving into transferable adversarial examples and black-box attacks. In ICLR, 2017.
+
+Seyed-Mohsen Moosavi-Dezfooli, Alhussein Fawzi, Omar Fawzi, and Pascal Frossard. Universal adversarial perturbations. In CVPR, 2017.
+
+Nina Narodytska and Shiva Prasad Kasiviswanathan. Simple black-box adversarial perturbations for deep networks. In CVPRW, 2017.
+
+S. J. Oh, Mario Fritz, and Bernt Schiele. Adversarial image perturbation for privacy protection a game theory perspective. In ICCV, 2017.
+
+Nicolas Papernot, Patrick McDaniel, and Ian Goodfellow. Transferability in machine learning: from phenomena to black-box attacks using adversarial samples. arXiv, 2016a.
+
+Nicolas Papernot, Patrick McDaniel, Ian Goodfellow, Somesh Jha, Z. Berkay Celik, and Anathram Swami. Practical black-box attacks against deep learning systems using adversarial examples. 2016b.
+
+Nicolas Papernot, Patrick McDaniel, Ian Goodfellow, Somesh Jha, Z Berkay Celik, and Ananthram Swami. Practical black-box attacks against deep learning systems using adversarial examples. In ASIACCS, 2017.
+
+Reza Shokri, Marco Stronati, Congzheng Song, and Vitaly Shmatikov. Membership inference attacks against machine learning models. In SP, 2017.
+
+K. Simonyan and A. Zisserman. Very deep convolutional networks for large-scale image recognition. In ICLR, 2015.
+
+Christian Szegedy, Wojciech Zaremba, Ilya Sutskever, Joan Bruna, Dumitru Erhan, Ian Goodfellow, and Rob Fergus. Intriguing properties of neural networks. In ICLR, 2014.
+
+Florian Tramer, Fan Zhang, Ari Juels, Michael K. Reiter, and Thomas Ristenpart. Stealing machine learning models via prediction apis. In USENIX, 2016.
+
+L.J.P van der Maaten and G.E. Hinton. Visualizing high-dimensional data using t-sne. Journal of Machine Learning Research, 9: 25792605, Nov 2008.
+
+APPENDIX
+
+A MNIST-NETS STATISTICS
+
+We show the statistics of MNIST-NETS, our dataset of MNIST classifiers, in table 6.
+
+B MORE K E N N E N-I O RESULTS
+
+We complement the kennen-o results in the main paper (figure 4) with kennen-io results. See figure 5. Similarly for kennen-o, kennen-io shows a diminishing return as the number of training models and the number of queries increase. While the performance saturates with $1 , 0 0 0$ queries, it does not fully saturate with 5, 000 training samples.
+
+# C ON FINDING THE OPTIMAL SET OF QUERIES
+
+kennen-o selects a random set of queries from MNIST validation set (§3.2). We measure the sensitivity of kennen-o performance with respect to the choice of queries, and discuss the possibility to optimise the set of queries.
+
+With 1, 10, or 100 queries, we have trained kennen-o with 100 independent samples of query sets. The mean and standard deviations are shown in figure 6. The sensitivity is greater for smaller number of queries, but still minute ${ \mathrm { ( 1 . 2 p p } }$ standard deviation).
+
+Instead of solving the combinatorial problem of finding the optimal set of query inputs from a dataset, we have proposed kennen-io that efficiently solves a continuous optimisation problem to find a set of query inputs from the entire input space. We have compared kennen-io against kennen-o with multiple query samples in figure 6. We observe that kennen-io is better than kennen-o with all 100 query set samples at each level.
+
+We remark that there exists a trade-off between detectability and effectiveness of exploration. While kennen-io extracts information from target model more effectively, it increases the detectability of attack by submitting out-of-domain inputs. If it is possible to optimise or sample the set of natural queries from a dataset or distribution of natural inputs, it will be a strong attack; developing such a method would be an interesting future work.
+
+# D T-SNE VISUALISATION OF METAMODEL INPUTS
+
+We describe the detailed procedure for the metamodel input visualisation experiment (discussed in $\ S 4 . 3 )$ . First, 1000 test-split (Random split) black-box models are collected. For each model, 100 query images are passed (sampled at random from MNIST validation set), resulting in $1 0 0 \times 1 0$ dimensional input data points. We have used t-SNE(van der Maaten & Hinton, Nov 2008) to embed the data points onto the 2-dimensional plane. Each data point is coloured according to each attribute class. The results for kennen-o and kennen-io are shown in figures 9 and 10. Since t-SNE is sensitive to initialisation, we have run the embedding ten times with different random initialisations; the qualitative observations are largely identical.
+
+# E VISUAL EXAMPLES OF AIPS
+
+In this section, we show examples of AIPs. See figure 7 for the examples of AIPs and the perturbed images. The perturbation is nearly invisible to human eyes. We have also generated AIPs with respect to a diverse set of architecture families (S, V, B, R, D, SVBRD) at multiple $L _ { 2 }$ norm levels. See figure 8; the same image results in a diverse set of patterns depending on the architecture family.
+
+Table 6: Distribution of attributes in MNIST-NETS, and attribute-wise classification performance (on MNIST validation set). Observe that the attributes are evenly distributed and the corresponding classification accuracies also do not correlate much with the attributes. We thus make sure that the classification accuracy alone cannot be a strong cue for predicting attributes.   
+
+<table><tr><td rowspan="2"></td><td colspan="4">arch/act</td><td colspan="2">arch/drop</td><td colspan="2">arch/pool</td><td colspan="2">arch/ks</td><td colspan="3">arch/#conv</td><td colspan="3">arch/#fc</td></tr><tr><td>Tanh PReLU</td><td></td><td>ReLU</td><td>ELU</td><td>YesNo</td><td></td><td>YesNo</td><td></td><td>5</td><td>3</td><td>2</td><td>3</td><td>4</td><td>2</td><td>3</td><td>4</td></tr><tr><td>Ratio</td><td>24.8</td><td>24.9</td><td>25.3</td><td>25.1</td><td>49.8 50.3</td><td></td><td>49.9 50.2</td><td></td><td>50.3 49.7</td><td></td><td></td><td></td><td>34.0 33.4 32.7</td><td></td><td>33.1 33.5 33.4</td><td></td></tr><tr><td>max</td><td>99.4</td><td>99.4</td><td>99.5</td><td>99.4</td><td>99.5 99.4</td><td></td><td>99.4 99.5</td><td></td><td>99.5 99.4</td><td></td><td>99.4 99.4 99.5</td><td></td><td></td><td></td><td>99.4 99.4 99.5</td><td></td></tr><tr><td>median</td><td>98.6</td><td>98.7</td><td>98.7</td><td>98.7</td><td>98.7 98.6</td><td></td><td>98.7 98.5</td><td></td><td>98.7 98.6</td><td></td><td>98.6 98.7 98.7</td><td></td><td></td><td></td><td>98.7 98.6 98.6</td><td></td></tr><tr><td>mean</td><td>98.6</td><td>98.7</td><td>98.7</td><td>98.7</td><td>98.7 98.6</td><td></td><td>98.7 98.6</td><td></td><td>98.7 98.6</td><td></td><td>98.6 98.7 98.7</td><td></td><td></td><td></td><td>98.7 98.6 98.6</td><td></td></tr><tr><td>min</td><td>98.0</td><td>98.0</td><td>98.0</td><td>98.0</td><td>98.0 98.0</td><td></td><td>98.0 98.0</td><td></td><td>98.0 98.0</td><td></td><td>98.098.0 98.0</td><td></td><td></td><td></td><td>98.0 98.0 98.0</td><td></td></tr><tr><td colspan="3" rowspan="8"></td><td rowspan="8"></td><td colspan="3">opt/alg</td><td colspan="3"></td><td colspan="2"></td><td colspan="3"></td><td colspan="3"></td></tr><tr><td colspan="3"></td><td colspan="3">ADAM SGD</td><td colspan="3">opt/bs 64 128 256</td><td colspan="3">data/size all half</td><td colspan="3"></td></tr><tr><td colspan="3"></td><td colspan="3">RMSprop</td><td colspan="3"></td><td colspan="3"></td><td colspan="3">quarter</td></tr><tr><td colspan="3">Ratio</td><td colspan="3">33.8 32.5</td><td colspan="3">33.7 32.9 33.6</td><td colspan="3">533.7 14.8 28.5</td><td colspan="3">56.8</td></tr><tr><td colspan="3">max</td><td colspan="3">99.2 99.4</td><td colspan="3">99.5 99.399.4 99.5</td><td colspan="3">99.5 99.3</td><td colspan="3">99.1</td></tr><tr><td colspan="3">median</td><td colspan="3">98.6 98.7</td><td colspan="3">98.7 98.6 98.7</td><td colspan="3">98.7 99.0 98.8</td><td colspan="3">98.5</td></tr><tr><td colspan="3">mean</td><td colspan="3">98.6 98.7 98.0</td><td colspan="3">98.6 98.7 98.6</td><td colspan="3">98.9 98.8</td><td colspan="3">98.5</td></tr><tr><td colspan="3">min</td><td colspan="3">98.0</td><td colspan="3">98.7 98.0</td><td colspan="2">98.0 98.0 98.0</td><td colspan="3">98.098.0 98.0</td><td colspan="3"></td></tr></table>
+
+![](images/2591ebc40c456a41a0360c3af7b74b2f60d31409457f2281d7ae496eeeda3910.jpg)  
+Figure 5: Performance of kennen $- \dot { \textrm { \scriptsize 1 0 } }$ with different number of queries (Left) and size of training set (Right). The curves are linearly scaled per attribute such that random chance performs $0 \%$ , and perfect predictor performs $100 \%$ .
+
+![](images/aa21f340358fa8cad0b129db92e2fb3d4c40bfc2a1e89e2663eb439b519487c5.jpg)  
+Figure 6: kennen $- \mathrm { { O } / \ i \mathrm { { O } } }$ performance at different number of queries. kennen $- \bigcirc$ is shown with 100 independent query samples per level (black dots) – the dots are spread horizontally for visualisation purpose. Their mean (curve) and $\pm 2$ standard deviations (error bars) are also shown.
+
+Table 7: Details of ImageNet classifiers. We describe each family Squeezenet, VGG, VGGBatchNorm, ResNet, and DenseNet verbally, and show key model statistics for each member in the family. We observe intra-family diversity (e.g. R) and inter-family similarity (e.g. between V and B) in terms of the top-5 validation error and the number of trainable parameters.   
+
+<table><tr><td></td><td colspan="2">S (2016)</td><td colspan="4">V (2014)</td><td colspan="4">B (2015)</td><td colspan="4">R (2015)</td><td colspan="4">D (2016)</td></tr><tr><td>Description</td><td colspan="2">Lightweight convnet</td><td colspan="4">Conv layers followed by fc layers</td><td colspan="4">VGG with batch normalisation</td><td colspan="4">Very deep convnet with residual connections</td><td colspan="4">ResNet with dense residual connections</td></tr><tr><td>Members</td><td>v1.0</td><td>v1.1</td><td>11</td><td>13</td><td>16</td><td>19</td><td>11</td><td>13</td><td>16 19</td><td>18</td><td>34</td><td>50</td><td>101</td><td>152</td><td>121</td><td>161</td><td>169</td><td>201</td></tr><tr><td>#layers</td><td>26</td><td>26</td><td>11</td><td>13</td><td>16</td><td>19</td><td>11</td><td>13</td><td>19</td><td>21</td><td>37</td><td>54</td><td>105</td><td>156</td><td>121</td><td>161</td><td>169</td><td>201</td></tr><tr><td>log10 #params</td><td>6.1</td><td>6.1</td><td>8.1</td><td>8.1</td><td>8.1</td><td>8.2</td><td>8.1 8.1</td><td>16 8.1</td><td>8.2</td><td>7.1</td><td>7.3</td><td>7.4</td><td>7.6</td><td>7.8</td><td>6.9</td><td>7.3</td><td>7.5</td><td>7.2</td></tr><tr><td>Top-1 error</td><td>41.9</td><td>41.8</td><td>31.0</td><td>30.1</td><td>28.4</td><td>27.6</td><td>29.6 28.5</td><td>26.6</td><td>25.8</td><td>30.2</td><td>26.7</td><td>23.9</td><td>22.6</td><td>21.7</td><td>25.4</td><td>24.0</td><td>22.8</td><td>22.4</td></tr><tr><td>Top-5 error</td><td>19.6</td><td>19.4</td><td>11.4</td><td>10.8</td><td>9.6</td><td>9.1</td><td>10.2</td><td>9.6 8.5</td><td>8.2</td><td>10.9</td><td>8.6</td><td>7.1</td><td>6.4</td><td>5.9</td><td>7.8</td><td>6.2</td><td>7.0</td><td>6.4</td></tr></table>
+
+![](images/bf5f50605242e71d8714b65ce09748d1a4de804897781b1689fa39fecbf062ff.jpg)  
+Figure 7: AIP for an ImageNet classifier. The perturbations are generated at $L _ { 2 } = 1 \times 1 0 ^ { - 4 }$ .
+
+![](images/5ad329b4862dc9d727077dbd3e8c8a0e70389e50c9c1ef70f12e0c450a4551fe.jpg)  
+Figure 8: Adversarial perturbations for the same input image (top) generated with diverse ImageNet classifier families (S, V, B, R, D, SVBRD) at different norm constraints. The perturbation images are normalised at the maximal perturbation for visualisation. We observe diverse patterns across classifier families within the same $L _ { 2 }$ ball.
+
+![](images/76b5a3910a0ddc1981803ceb3fd42b8e0abb3fefa1ad7b58c923dd8d81d2f467.jpg)  
+Figure 9: Probability query output embedded into 2-D plane via t-SNE. The same embedding is shown with different colour-coding for each attribute. These are the inputs to the kennen-o metamodel.
+
+![](images/24a46d86731c74bd03a2de2526a5535bc021c7a9115fc93e23cd5657e9281234.jpg)  
+Figure 10: Probability query output embedded into 2-D plane via t-SNE. The same embedding is shown with different colour-coding for each attribute. These are the inputs to the kennen-io metamodel.
+
+![](images/4088da2d25ceb3cef49fe2d8472ffbecf90dcea69d2d683b57443f059825d002.jpg)  
+Figure 11: Confusion matrices for kennen-o.
+
+![](images/b8aac91e5361fcdf1816e7b129d6e82f5dc65b213b34f2ad27f67b4aa5370d66.jpg)  
+Figure 12: Confusion matrices for kennen-io.

parse/train/BydjJte0-/BydjJte0-_content_list.json

@@ -0,0 +1,2104 @@
+[
+    {
+        "type": "text",
+        "text": "TOWARDS REVERSE-ENGINEERING BLACK-BOX NEURAL NETWORKS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            98,
+            598,
+            146
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Seong Joon Oh, Max Augustin, Bernt Schiele, Mario Fritz   \nMax-Planck Institute for Informatics, Saarland Informatics Campus, Saarbrucken, Germany ¨   \n{joon,maxaug,schiele,mfritz}@mpi-inf.mpg.de ",
+        "bbox": [
+            183,
+            169,
+            784,
+            212
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "ABSTRACT ",
+        "text_level": 1,
+        "bbox": [
+            454,
+            248,
+            544,
+            263
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Many deployed learned models are black boxes: given input, returns output. Internal information about the model, such as the architecture, optimisation procedure, or training data, is not disclosed explicitly as it might contain proprietary information or make the system more vulnerable. This work shows that such attributes of neural networks can be exposed from a sequence of queries. This has multiple implications. On the one hand, our work exposes the vulnerability of black-box neural networks to different types of attacks – we show that the revealed internal information helps generate more effective adversarial examples against the black box model. On the other hand, this technique can be used for better protection of private content from automatic recognition models using adversarial examples. Our paper suggests that it is actually hard to draw a line between white box and black box models. The code is available at goo.gl/MbYfsv. ",
+        "bbox": [
+            233,
+            280,
+            764,
+            446
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 INTRODUCTION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            474,
+            336,
+            491
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Black-box models take a sequence of query inputs, and return corresponding outputs, while keeping internal states such as model architecture hidden. They are deployed as black boxes usually on purpose – for protecting intellectual properties or privacy-sensitive training data. Our work aims at inferring information about the internals of black box models – ultimately turning them into white box models. Such a reverse-engineering of a black box model has many implications. On the one hand, it has legal implications to intellectual properties (IP) involving neural networks – internal information about the model can be proprietary and a key IP, and the training data may be privacy sensitive. Disclosing hidden details may also render the model more susceptible to attacks from adversaries. On the other hand, gaining information about a black-box model can be useful in other scenarios. E.g. there has been work on utilising adversarial examples for protecting private regions (e.g. faces) in photographs from automatic recognisers (Oh et al., 2017). In such scenarios, gaining more knowledge on the recognisers will increase the chance of protecting one’s privacy. Either way, it is a crucial research topic to investigate the type and amount of information that can be gained from a black-box access to a model. We make a first step towards understanding the connection between white box and black box approaches – which were previously thought of as distinct classes. ",
+        "bbox": [
+            173,
+            507,
+            825,
+            715
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "We introduce the term “model attributes” to refer to various types of information about a trained neural network model. We group them into three types: (1) architecture (e.g. type of non-linear activation), (2) optimisation process (e.g. SGD or ADAM?), and (3) training data (e.g. which dataset?). We approach the problem as a standard supervised learning task applied over models. First, collect a diverse set of white-box models (“meta-training set”) that are expected to be similar to the target black box at least to a certain extent. Then, over the collected meta-training set, train another model (“metamodel”) that takes a model as input and returns the corresponding model attributes as output. Importantly, since we want to predict attributes at test time for black-box models, the only information available for attribute prediction is the query input-output pairs. As we will see in the experiments, such input-output pairs allow to predict model attributes surprisingly well. ",
+        "bbox": [
+            174,
+            722,
+            823,
+            861
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "In summary, we contribute: (1) Investigation of the type and amount of internal information about the black-box model that can be extracted from querying; (2) Novel metamodel methods that not only reason over outputs from static query inputs, but also actively optimise query inputs that can extract more information; (3) Study of factors like size of the meta-training set, quantity and quality of queries, and the dissimilarity between the meta-training models and the test black box (generalisability); (4) Empirical verification that revealed information leads to greater susceptibility of a black-box model to an adversarial example based attack. ",
+        "bbox": [
+            174,
+            868,
+            823,
+            924
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            103,
+            823,
+            146
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2 RELATED WORK ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            170,
+            344,
+            186
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "There has been a line of work on extracting and exploiting information from black-box learned models. We first describe papers on extracting information (model extraction and membership inference attacks), and then discuss ones on attacking the network using the extracted information (adversarial image perturbations $( A I P )$ ). ",
+        "bbox": [
+            174,
+            204,
+            825,
+            261
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Model extraction attacks either reconstruct the exact model parameters or build an avatar model that maximises the likelihood of the query input-output pairs from the target model (Tramer et al., 2016; Papernot et al., 2017). Tramer et al. (2016) have shown the efficacy of equation solving attacks and the avatar method in retrieving internal parameters of non-neural network models. Papernot et al. (2017) have also used the avatar approach with the end goal of generating adversarial examples. While the avatar approach first assumes model hyperparameters like model family (architecture) and training data, we discriminatively train a metamodel to predict those hyperparameters themselves. As such, our approach is complementary to the avatar approach. ",
+        "bbox": [
+            174,
+            267,
+            825,
+            380
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Membership inference attacks determine if a given data sample has been included in the training data (Ateniese et al., 2015; Shokri et al., 2017). In particular, Ateniese et al. (2015) also trains a decision tree metamodel over a set of classifiers trained on different datasets. This work goes far beyond only inferring the training data by showing that even the model architecture and optimisation process can be inferred. ",
+        "bbox": [
+            174,
+            386,
+            825,
+            455
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Using the obtained cues, one can launch more effective, focused attacks on the black box. We use adversarial image perturbations (AIPs) as an example of such attack. AIPs are small perturbations over the input such that the network is mislead. Research on this topic has flourished recently after it was shown that the needed amount of perturbation to completely mislead an image classifier is nearly invisible (Szegedy et al., 2014; Goodfellow et al., 2015; Moosavi-Dezfooli et al., 2017). ",
+        "bbox": [
+            174,
+            462,
+            825,
+            532
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Most effective AIPs require gradients of the target network. Some papers proposed different ways to attack black boxes. They can be grouped into three approaches. (1) Approximate gradients by numerical gradients (Narodytska & Kasiviswanathan, 2017; Chen et al., 2017). The caveat is that thousands and millions of queries are needed to compute a single AIP, depending on the image size. (2) Use the avatar approach to train a white box network that is supposedly similar to the target (Papernot et al., 2016b;a; Hayes & Danezis, 2017). We note again that our metamodel is complementary to the avatar approach – the avatar network hyperparemters can be determined by the metamodel. (3) Exploit transferability of adversarial examples; it has been shown that AIPs generated against one network can also fool other networks (Moosavi-Dezfooli et al., 2017; Liu et al., 2017). Liu et al. (2017) in particular have shown that generating AIPs against an ensemble of networks make it more transferable. We show in this work that the AIPs transfer better within an architecture family (e.g. ResNet or DenseNet) than across, and that such a property can be exploited by our metamodel for generating more targetted AIPs. ",
+        "bbox": [
+            173,
+            540,
+            825,
+            719
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "3 METAMODELS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            744,
+            326,
+            761
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "We want to find out the type and amount of internal information about a black-box model that can be revealed from a sequence of queries. We approach this by first building metamodels for predicting model attributes, and then evaluating their performance on black-box models. Our ",
+        "bbox": [
+            174,
+            780,
+            485,
+            862
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "image",
+        "img_path": "images/40c4de6dd36b1ba4ed9b256dedf985e4afdfa323aff9d4b892a0bd2ae01de12d.jpg",
+        "image_caption": [
+            "Figure 1: Overview of our approach. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            504,
+            744,
+            834,
+            824
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "main approach, metamodel, is described in figure 1. In a nutshell, the metamodel is a classifier of classifiers. Specifically, The metamodel submits $n$ query inputs $\\left[ x ^ { i } \\right] _ { i = 1 } ^ { n }$ to a black box model $f$ ; the metamodel takes corresponding model outputs $\\left[ f ( x ^ { i } ) \\right] _ { i = 1 } ^ { n }$ as an input, and returns predicted model attributes as output. As we will describe in detail, the metamodel not only learns to infer model attributes from query outputs from a static set of inputs, but also searches for query inputs that are designed to extract greater amount of information from the target models. ",
+        "bbox": [
+            174,
+            863,
+            825,
+            924
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            171,
+            103,
+            821,
+            132
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "In this section, our main methods are introduced in the context of MNIST digit classifiers. While MNIST classifiers are not fully representative of generic learned models, they have a computational edge: it takes only five minutes to train each of them with reasonable performance. We could thus prepare a diverse set of 11k MNIST classifiers within 40 GPU days for the meta-training and evaluation of our metamodels. We stress, however, that the proposed approach is generic with respect to the task, data, and the type of models. We also focus on 12 model attributes (table 1) that cover hyperparameters for common neural network MNIST classifiers, but again the range of predictable attributes are not confined to this list. ",
+        "bbox": [
+            174,
+            138,
+            825,
+            250
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3.1 COLLECTING A DATASET OF CLASSIFIERS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            268,
+            498,
+            281
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "We need a dataset of classifiers to train and evaluate metamodels. We explain how MNIST-NETS has been constructed, a dataset of 11k MNIST digit classifiers; the procedure is task and data generic. ",
+        "bbox": [
+            173,
+            292,
+            823,
+            321
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "BASE NETWORK SKELETON ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            338,
+            364,
+            351
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Every model in MNIST-NETS shares the same convnet skeleton architecture: “ $N$ conv blocks $M$ fc blocks $ ~ 1$ linear classifier”. Each conv block has the following structure: “ks $\\times$ ks convolution optional $2 \\times 2$ max-pooling non-linear activation”, where ks (kernel size) and the activation type are to be chosen. Each fc block has the structure: “00linear mapping non-linear activation optional dropout” This convnet structure already covers many LeNet (LeCun et al., 1998) variants, one of the best performing architectures on MNIST1. ",
+        "bbox": [
+            174,
+            361,
+            823,
+            444
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "INCREASING DIVERSITY ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            462,
+            341,
+            473
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "In order to learn generalisable features, the metamodel needs to be trained over a diverse set of models. The base architecture described above already has several free parameters like the number of layers ( $N$ and $M ,$ ), the existence of dropout or maxpooling layers, or the type of nonlinear activation. ",
+        "bbox": [
+            174,
+            484,
+            419,
+            608
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "table",
+        "img_path": "images/73d0bce289d6dd93dfeb09a33beee54fe8244f080c86358e07de71352c4dd938.jpg",
+        "table_caption": [
+            "Table 1: MNIST classifier attributes. Italicised attributes are derived from other attributes. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td></td><td>Code</td><td>Attribute</td><td>Values</td></tr><tr><td>AAieeiteee</td><td>act drop pool ks #conv #fc</td><td>Activation Dropout Max pooling Conv ker. size #Conv layers #FC layers</td><td>ReLU,PReLU,ELU,Tanh Yes,No Yes,No 3,5 2,3,4 2,3,4</td></tr><tr><td>0</td><td>#par ens alg</td><td>#Parameters Ensemble Algorithm</td><td>214, ： 221 Yes,No SGD,ADAM,RMSprop</td></tr><tr><td>0</td><td>bs split size</td><td>Batch size Data split Data size</td><td>64,128,256 Allo,Halfo/1, Quarter0/1/2/3 All, Half, Quarter</td></tr></table>",
+        "bbox": [
+            431,
+            496,
+            823,
+            693
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Apart from the architectural hyperparameters, we increase diversity along two more axes – optimisation process and the training data. Along the optimisation axis, we vary optimisation algorithm (SGD, ADAM, or ",
+        "bbox": [
+            174,
+            617,
+            419,
+            699
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "RMSprop) and the training batch size (64, 128, 256). We also consider training MNIST classifiers on either on the entire MNIST training set $( \\mathrm { A l l } _ { 0 }$ , 60k), one of the two disjoint halves $\\mathrm { ( H a l f _ { 0 / 1 } }$ , 30k), or one of the four disjoint quarters (Quarte $\\Gamma _ { 0 / 1 / 2 / 3 }$ , $1 5 \\mathrm { k } )$ ). ",
+        "bbox": [
+            174,
+            700,
+            825,
+            743
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "See table 1 for the comprehensive list of 12 model attributes altered in MNIST-NETS. The number of trainable parameters (#par) and the training data size (size) are not directly controlled but derived from the other attributes. We also augment MNIST-NETS with ensembles of classifiers (ens), whose procedure will be described later. ",
+        "bbox": [
+            174,
+            748,
+            825,
+            804
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "SAMPLING AND TRAINING ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            821,
+            356,
+            833
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "The number of all possible combinations of controllable options in table 1 is 18, 144. We also select random seeds that control the initialisation and training data shuffling from $\\{ 0 , \\cdots , 9 9 9 \\}$ , resulting in 18, 144, 000 unique models. Training such a large number of models is intractable; we have sampled (without replacement) and trained 10, 000 of them. All the models have been trained with learning rate 0.1 and momentum 0.5 for 100 epochs. It takes around 5 minutes to train each model on a GPU machine (GeForce GTX TITAN); training of 10k classifiers has taken 40 GPU days. ",
+        "bbox": [
+            174,
+            844,
+            825,
+            900
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            171,
+            103,
+            823,
+            132
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "PRUNING AND AUGMENTING ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            148,
+            374,
+            161
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "In order to make sure that MNIST-NETS realistically represents commonly used MNIST classifiers, we have pruned low-performance classifiers (validation accuracy $< 9 8 \\%$ ), resulting in 8, 582 classifiers. Ensembles of trained classifiers have been constructed by grouping the identical classifiers (modulo random seed). Given $t$ identical ones, we have augmented MNIST-NETS with 2, · · · , $t$ combinations. The ensemble augmentation has resulted in 11, 282 final models. See appendix table 6 for statistics of attributes – due to large sample size all the attributes are evenly covered. ",
+        "bbox": [
+            174,
+            171,
+            825,
+            255
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "TRAIN-EVAL SPLITS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            272,
+            313,
+            285
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Attribute prediction can get arbitrarily easy by including the black-box model (or similar ones) in the meta-training set. We introduce multiple splits of MNIST-NETS with varying requirements on generalization. Unless stated otherwise, every split has 5, 000 training (meta-training), 1, 000 testing (black box), and 5, 282 leftover models. ",
+        "bbox": [
+            174,
+            295,
+            825,
+            351
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "The Random (R) split randomly (uniform weights) assigns training and test splits, respectively. Under the R split, the training and test models come from the same distribution. We introduce harder Extrapolation (E) splits. We separate a few attributes between the training and test splits. They are designed to simulate more difficult domain gaps when the meta-training models are significantly different from the black box. Specific examples of E splits will be shown in $\\ S 4$ . ",
+        "bbox": [
+            174,
+            358,
+            825,
+            428
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3.2 METAMODEL METHODS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            445,
+            377,
+            459
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "The metamodel predicts the attribute of a black-box model $g$ in the test split by submitting $n$ query inputs and observing the outputs. It is trained over meta-training models $f$ in the training split $( f \\sim \\mathcal { F } )$ . We propose three approaches for the metamodels – we collectively name them kennen2. See figure 2 for an overview. ",
+        "bbox": [
+            174,
+            472,
+            825,
+            526
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "K E N N E N-O: REASON OVER OUTPUT ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            544,
+            423,
+            556
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "kennen-o first selects a fixed set of queries $[ x ^ { i } ] _ { i = 1 \\cdots n }$ from a dataset. Both during training and testing, always these queries are submitted. kennen $\\scriptscriptstyle - \\bigcirc$ learns a classifier $m _ { \\theta }$ to map from the order-sensitively concatenated $n$ query outputs, $[ f ( x ^ { i } ) ] _ { i = 1 \\cdots n }$ $( n \\times 1 0$ dim for MNIST), to the simultaneous prediction of 12 attributes in $f$ . The training objective is: ",
+        "bbox": [
+            174,
+            568,
+            485,
+            679
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/caf86415c86c9f6743b787463445d5b42fddae8a2306eb423ab8056d0bdb1ce1.jpg",
+        "text": "$$\n\\operatorname* { m i n } _ { \\theta } { } _ { f \\sim \\mathcal { F } } \\left[ \\sum _ { a = 1 } ^ { 1 2 } \\mathcal { L } \\left( m _ { \\theta } ^ { a } \\left( [ f ( x ^ { i } ) ] _ { i = 1 } ^ { n } \\right) , y ^ { a } \\right) \\right]\n$$",
+        "text_format": "latex",
+        "bbox": [
+            187,
+            684,
+            467,
+            729
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "image",
+        "img_path": "images/356980c8e1f698f631961d53b145ff3b64f47856bd5bb5f38b04ed21d2117b22.jpg",
+        "image_caption": [
+            "Figure 2: Training procedure for metamodels kennen-o (top) and kennen-i (bottom). "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            500,
+            569,
+            825,
+            771
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "where $\\mathcal { F }$ is the distribution of meta-training models, $y ^ { a }$ is the ground truth label of attribute $a$ , and $\\mathcal { L }$ is the cross-entropy loss. With the learned parameter $\\tilde { \\theta }$ $m _ { \\tilde { \\theta } } ^ { a } \\left( [ g ( x ^ { i } ) ] _ { i = 1 } ^ { n } \\right)$ gives the prediction of attribute $a$ for the black box $g$ . ",
+        "bbox": [
+            174,
+            750,
+            485,
+            823
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "In our experiments, we model the classifier $m _ { \\theta }$ via multilayer perceptron (MLP) with two hidden layers with 1000 hidden units. The last layer consists of 12 parallel linear layers for a simultaneous prediction of the attributes. In our preliminary experiments, MLP has performed better than the linear classifiers. The optimisation problem in equation 1 is solved via SGD by approximating the expectation over $f \\sim \\mathbb { F }$ by an empirical sum over the training split classifiers for 200 epochs. ",
+        "bbox": [
+            174,
+            829,
+            825,
+            900
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "For query inputs, we have used a random subset of $n$ images from the validation set (both for MNIST and ImageNet experiments). The performance is not sensitive to the choice of queries (see appendix $\\ S C _ { \\iota }$ ). Next methods $( \\mathrm { k e n n e n - i } / \\mathrm { i } \\circ )$ describe how to actively craft query inputs, potentially outside the natural image distribution. ",
+        "bbox": [
+            174,
+            103,
+            823,
+            160
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Note that kennen $- \\bigcirc$ can be applied to any type of model (e.g. non-neural networks) with any output structure, as long as the output can be embedded in an Euclidean space. We will show that this method can effectively extract information from $f$ even if the output is a top-k ranking. ",
+        "bbox": [
+            174,
+            166,
+            823,
+            209
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "K E N N E N-I: CRAFT INPUT ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            226,
+            356,
+            238
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "kennen $- \\dot { \\beth }$ crafts a single query input $\\tilde { x }$ over the meta-training models that is trained to repurpose a digit classifier $f$ into a model attribute classifier for a single attribute $a$ . The crafted input drives the classifier to leak internal information via digit prediction. The learned input is submitted to the test black-box model $g$ , and the attribute is predicted by reading off its digit prediction $g ( \\tilde { x } )$ . For example, kennen $- \\dot { \\mathtt { 1 } }$ for max-pooling layer prediction crafts an input $x$ that is predicted as “1” for generic MNIST digit classifiers with max-pooling layers and $ { { } ^ { 6 } }  { 0 ^ { 9 } }$ for ones without. See figure 3 for visual examples. ",
+        "bbox": [
+            173,
+            247,
+            825,
+            344
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "We describe in detail how kennen-i learns this input. The training objective is: ",
+        "bbox": [
+            173,
+            353,
+            485,
+            381
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/9bc57c9350ae6f2312cb334927550de6b2e1b1b80faac21f4c521ceba622009e.jpg",
+        "text": "$$\n\\operatorname* { m i n } _ { x : { \\mathrm { i m a g e } } } \\ { \\underset { f \\sim { \\mathcal F } } { \\mathbb E } } \\left[ { \\mathcal { L } } \\left( f ( x ) , y ^ { a } \\right) \\right]\n$$",
+        "text_format": "latex",
+        "bbox": [
+            243,
+            386,
+            416,
+            411
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "where $f ( x )$ is the 10-dimensional output of the digit classifier $f$ . The condition $x :$ image ensures the input stays a valid image $x \\in [ \\breve { 0 } , 1 ] ^ { D }$ with image dimension $D$ . The loss $\\mathcal { L }$ , together with the attribute label $y ^ { a }$ of $f$ , guides the digit prediction $f ( x )$ to reveal the attribute $a$ instead. Note that the optimisation problem is identical ",
+        "bbox": [
+            174,
+            416,
+            485,
+            515
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "image",
+        "img_path": "images/70b3c4a49d589b795fa6ec8c81ba3073bfac876f45b0d3e297f1b9cf56732ef2.jpg",
+        "image_caption": [
+            "Figure 3: Inputs designed to extract internal details from MNIST digit classifiers. E.g. feeding the middle image reveals the existence of a maxpooling layer with $9 4 . 8 \\%$ chance. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            506,
+            344,
+            813,
+            449
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "to the training of digit classifiers except that the ground truth is the attribute label rather than the digit label, that the loss is averaged over the models instead of the images, and that the input $x$ instead of the model $f$ is optimised. With the learned query input $\\tilde { x }$ , the attribute for the black box $g$ is predicted by $g ( \\tilde { x } )$ . In particular, we do not use gradient information from $g$ . ",
+        "bbox": [
+            174,
+            515,
+            825,
+            570
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "We initialise $x$ with a random sample from the MNIST validation set (random noise or uniform gray initialisation gives similar performances), and run SGD for 200 epochs. For each iteration $x$ is truncated back to $[ \\bar { 0 } , 1 ] ^ { D }$ to enforce the constraint. ",
+        "bbox": [
+            176,
+            577,
+            823,
+            619
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "While being simple and effective, kennen-i can only predict a single attribute at a time, and cannot predict attributes with more than 10 classes (for digit classifiers). kennen-io introduced below overcomes these limitations. kennen $- \\dot { \\beth }$ may also be unrealistic when the exploration needs to be stealthy: it submits unnatural images to the system. Also unlike kennen-o, kennen $^ { - \\dot { 1 } }$ requires end-to-end differentiability of the training models $f \\sim \\mathcal { F }$ , although it still requires only black-box access to test models $g$ . ",
+        "bbox": [
+            174,
+            626,
+            825,
+            710
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "K E N N E N-I O: COMBINED APPROACH ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            727,
+            429,
+            739
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "We overcome the drawbacks of kennen-i that it can only predict one attribute at a time and that the number of predictable classes by attaching an additional interpretation module on top of the output. Our final method kennen-io combines kennen-i and kennen-o approaches: both input generator and output interpreters are used. Being able to reason over multiple query outputs via MLP layers, kennen-io supports the optimisation of multiple query inputs as well. ",
+        "bbox": [
+            174,
+            748,
+            825,
+            819
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Specifically, the kennen-io training objective is given by: ",
+        "bbox": [
+            173,
+            825,
+            570,
+            840
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/3e530c3a866ad689f9dbaa83c08e3ed515a3324068bc80b6213faae36bf44826.jpg",
+        "text": "$$\n\\operatorname* { m i n } _ { [ x ^ { i } ] _ { i = 1 } ^ { n } : \\mathrm { i m a g e s } } \\operatorname* { m i n } _ { \\theta } \\underset { f \\sim \\mathcal { F } } { \\mathbb { E } } \\left[ \\sum _ { a = 1 } ^ { 1 2 } \\mathcal { L } \\left( m _ { \\theta } ^ { a } \\left( [ f ( x ^ { i } ) ] _ { i = 1 } ^ { n } \\right) , y ^ { a } \\right) \\right] .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            313,
+            845,
+            683,
+            888
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Note that the formulation is identical to that for kennen $- \\bigcirc$ (equation 1), except that the second minimisation problem regarding the query inputs is added. With learned parameters $\\tilde { \\theta }$ and $[ \\tilde { x } ^ { i } ] _ { i = 1 } ^ { n }$ , ",
+        "bbox": [
+            174,
+            893,
+            825,
+            924
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "table",
+        "img_path": "images/cdbc4c5fd6a47d5ef9756b879b73126b373c53e5fdfa1d3cdf84158f03c907fb.jpg",
+        "table_caption": [
+            "Table 2: Comparison of metamodel methods. See table 1 for the full names of attributes. 100 queries are used for every method below, except for kennen-i which uses a single query. The “Output” column shows the output representation: “prob” (vector of probabilities for each digit class), “ranking” (a sorted list of digits according to their likelihood), “top-1” (most likely digit), or “bottom-1” (least likely digit). "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=\"2\">Method</td><td rowspan=\"2\"> Output</td><td colspan=\"8\">architecture</td><td colspan=\"2\">optim</td><td colspan=\"2\">data</td></tr><tr><td>act</td><td>drop</td><td>pool</td><td>ks</td><td>#conv</td><td></td><td></td><td>#fc #par ens</td><td>algbs</td><td></td><td>size split</td><td>avg</td></tr><tr><td>Chance</td><td>-</td><td>25.0</td><td>50.0</td><td>50.0</td><td>50.0</td><td>33.3</td><td>33.3</td><td>12.5 50.0</td><td></td><td>33.3 33.3</td><td></td><td>33.3 14.3</td><td>34.9</td></tr><tr><td>kennen-o</td><td>prob</td><td>80.6</td><td>94.6</td><td>94.9</td><td>84.6</td><td>67.1</td><td>77.3</td><td>41.7 54.0</td><td></td><td>71.8 50.4</td><td></td><td>73.8 90.0</td><td>73.4</td></tr><tr><td>kennen-o</td><td>ranking</td><td>63.7</td><td>93.8</td><td>90.8</td><td>80.0</td><td>63.0</td><td>73.7</td><td>44.1</td><td>62.4</td><td>65.3 47.0</td><td>66.2</td><td>86.6</td><td>69.7</td></tr><tr><td>kennen-o</td><td>bottom-1</td><td>48.6</td><td>80.0</td><td>73.6</td><td>64.0</td><td>48.9</td><td>63.1</td><td></td><td>28.7 52.8</td><td>53.6 41.9</td><td></td><td>45.9 51.4</td><td>54.4</td></tr><tr><td>kennen-o</td><td>top-1</td><td>31.2</td><td>56.9</td><td>58.8</td><td>49.9</td><td>38.9</td><td>33.7</td><td>19.6</td><td>50.0</td><td>36.1 35.3</td><td>33.3</td><td>30.7</td><td>39.5</td></tr><tr><td>kennen-i</td><td>top-1</td><td>43.5</td><td>77.0</td><td>94.8</td><td>88.5</td><td>54.5</td><td>41.0</td><td>32.3</td><td>46.5</td><td>45.7 37.0</td><td></td><td>42.6 29.3</td><td>52.7</td></tr><tr><td>kennen-io</td><td>score</td><td>88.4 95.8</td><td></td><td></td><td>99.5 97.7</td><td>80.3</td><td>80.2</td><td>45.2</td><td>60.2</td><td>79.3 54.3</td><td></td><td>84.8 95.6</td><td>80.1</td></tr></table>",
+        "bbox": [
+            173,
+            172,
+            826,
+            308
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "the attribute $a$ for the black box $g$ is predicted by $m _ { \\tilde { \\theta } } ^ { a } \\ : \\left( [ g ( \\tilde { x } ^ { i } ) ] _ { i = 1 } ^ { n } \\right)$ . Again, we require end-to-end differentiability of meta-training models $f$ , but only the black-box access for the test model $g$ . ",
+        "bbox": [
+            174,
+            330,
+            823,
+            363
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "To improve stability against covariate shift, we initialise $m _ { \\theta }$ with kennen-o for 200 epochs. Afterwards, gradient updates of $[ x ^ { i } ] _ { i = 1 } ^ { n }$ and $\\theta$ alternate every 50 epochs, for 200 additional epochs. ",
+        "bbox": [
+            174,
+            368,
+            823,
+            398
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "4 REVERSE-ENGINEERING BLACK-BOX MNIST DIGIT CLASSIFIERS ",
+        "text_level": 1,
+        "bbox": [
+            171,
+            417,
+            758,
+            434
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "We have introduced a procedure for constructing a dataset of classifiers (MNIST-NETS) as well as novel metamodels (kennen variants) that learn to extract information from black-box classifiers. In this section, we evaluate the ability of kennen to extract information from black-box MNIST digit classifiers. We measure the class-balanced attribute prediction accuracy for each attribute $a$ in the list of 12 attributes in table 1. ",
+        "bbox": [
+            174,
+            449,
+            825,
+            520
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "ATTRIBUTE PREDICTION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            536,
+            343,
+            549
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "See table 2 for the main results of our metamodels, kennen-o/i/io, on the Random split. Unless stated otherwise, metamodels are trained with 5, 000 training split classifiers. ",
+        "bbox": [
+            174,
+            560,
+            823,
+            588
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Given $n = 1 0 0$ queries with probability output, kennen-o already performs far above the random chance in predicting 12 diverse attributes ( $7 3 . 4 \\%$ versus $3 4 . 9 \\%$ on average); neural network output indeed contains rich information about the black box. In particular, the presence of dropout $( 9 4 . 6 \\% )$ or max-pooling $( 9 4 . 9 \\% )$ has been predicted with high precision. As we will see in $\\ S 4 . 3$ , outputs of networks trained with dropout layers form clusters, explaining the good prediction performance. ",
+        "bbox": [
+            174,
+            594,
+            825,
+            665
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "It is surprising that optimisation details like algorithm $( 7 1 . 8 \\% )$ and batch size $( 5 0 . 4 \\% )$ can also be predicted well above the random chance $3 3 . 3 \\%$ for both). We observe that the training data attributes are also predicted with high accuracy $( 7 1 . 8 \\%$ and $9 0 . 0 \\%$ for size and split). ",
+        "bbox": [
+            174,
+            671,
+            825,
+            714
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "COMPARING METHODS K E N N E N-O/I/I O ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            731,
+            464,
+            743
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Table 2 shows the comparison of kennen-o/i/io. kennen $- \\dot { \\mathtt { 1 } }$ has a relatively low performance (average $5 2 . 7 \\% )$ ), but kennen-i relies on a cheap resource: 1 query with single-label output. kennen-i is also performant at predicting the kernel size $( 8 8 . 5 \\% )$ and pooling $( 9 4 . 8 \\% )$ , attributes that are closely linked to spatial structure of the input. We conjecture kennen-i is relatively effective for such attributes. kennen-io is superior to kennen $- \\phantom { } _ { \\mathsf { O } } / \\mathrm { i }$ for all the attributes with average accuracy $8 0 . 1 \\%$ . ",
+        "bbox": [
+            174,
+            753,
+            825,
+            838
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "4.1 FACTOR ANALYSIS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            856,
+            343,
+            869
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "We examine potential factors that contribute to the successful prediction of black box internal attributes. We measure the prediction accuracy of our metamodels as we vary (1) the number of meta-training models, (2) the number of queries, and (3) the quality of query output. ",
+        "bbox": [
+            176,
+            882,
+            823,
+            924
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "image",
+        "img_path": "images/2b1ecd72ed511fabda0412e1a7ed42739ad7148745224f27bedbfd0d155955ed.jpg",
+        "image_caption": [
+            "Figure 4: kennen $- \\bigcirc$ performance of against the size of meta-training set (left), number of queries (middle), and quality of queries (right). Unless stated otherwise, we use 100 probability outputs and 5k models to train kennen-o. Each curve is linearly scaled such that random chance (0 training data, 0 query, or top-0) performs $0 \\%$ , and the perfect predictor performs $100 \\%$ . "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            205,
+            101,
+            821,
+            234
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "NUMBER OF TRAINING MODELS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            323,
+            393,
+            335
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "We have trained kennen $- \\bigcirc$ with different number of the meta-training classifiers, ranging from 100 to 5, 000. See figure 4 (left) for the trend. We observe a diminishing return, but also that the performance has not saturated – collecting larger meta-training set will improve the performance. ",
+        "bbox": [
+            176,
+            345,
+            825,
+            388
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "NUMBER OF QUERIES ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            404,
+            323,
+            416
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "See figure 4 (middle) for the kennen-o performance against the number of queries with probability output. The average performance saturates after $\\sim 5 0 0$ queries. On the other hand, with only $\\sim 1 0 0$ queries, we already retrieve ample information about the neural network. ",
+        "bbox": [
+            176,
+            428,
+            823,
+            469
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "QUALITY OF OUTPUT ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            486,
+            321,
+            498
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Many black-box models return top- $\\mathbf { \\nabla } \\cdot \\mathbf { k }$ ranking (e.g. Facebook face recogniser), or single-label output. We represent top- $\\mathbf { \\nabla } \\cdot \\mathbf { k }$ ranking outputs by assigning exponentially decaying probabilities up to $k$ digits and a small probability $\\epsilon$ to the remaining. ",
+        "bbox": [
+            176,
+            508,
+            823,
+            551
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "See table 2 for the kennen $- \\bigcirc$ performance comparison among 100 probability, top-10 ranking, bottom-1, and top-1 outputs, with average accuracies $7 3 . 4 \\%$ , $6 9 . 7 \\%$ , $5 4 . 4 \\%$ , and $3 9 . 5 \\%$ , respectively. While performance drops with coarser outputs, when compared to random chance $( 3 4 . 9 \\% )$ , 100 single-label bottom-1 outputs already leak a great amount of information about the black box $( 5 4 . 4 \\% )$ . It is also notable that bottom-1 outputs contain much more information than do the top1 outputs; note that for high-performance classifiers top-1 predictions are rather uniform across models and thus have much less freedom to leak auxiliary information. Figure 4 (right) shows the interpolation from top-1 to top-10 (i.e. top-9) ranking. We observe from the jump at $k = 2$ that the second likely predictions (top-2) contain far more information than the most likely ones (top-1). For $k \\geq 3$ , each additional output label exhibits a diminishing return. ",
+        "bbox": [
+            174,
+            558,
+            825,
+            696
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "4.2 WHAT IF THE BLACK-BOX IS QUITE DIFFERENT FROM META-TRAINING MODELS? ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            714,
+            769,
+            727
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "So far we have seen results on the Random (R) split. In realistic scenarios, the meta-training model distribution may not be fully covering possible black box models. We show how damaging such a scenario is through Extrapolation (E) split experiments. ",
+        "bbox": [
+            176,
+            739,
+            823,
+            781
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "EVALUATION ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            797,
+            264,
+            810
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "E-splits split the training and testing models based on one or more attributes (§3.1). For example, we may assign shallower models (#layers $\\leq 1 0$ ) to the training split and deeper ones (#layers $\\it { i } ^ { \\scriptsize { 1 0 } \\mathrm { ) } }$ to the testing split. In this example, we refer to #layers as the splitting attribute. Since for an E-split, some classes of the splitting attributes have zero training examples, we only evaluate the prediction accuracies over the non-splitting attributes. When the set of splitting attributes is $\\tilde { A }$ , a subset of the entire attribute set $A$ , we define $E$ -split accuracy or $\\operatorname { E . A c c } ( { \\tilde { A } } )$ to be the mean prediction accuracy over the non-splitting attributes $A \\setminus { \\tilde { A } }$ . For easier comparison, we report the normalised accuracy (N.Acc) that shows the how much percentage of the R-split accuracy is achieved in the E-split setup on the non-splitting attributes $A \\setminus { \\tilde { A } }$ . Specifically: ",
+        "bbox": [
+            174,
+            820,
+            825,
+            924
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            171,
+            103,
+            823,
+            133
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "equation",
+        "img_path": "images/d7c43ff2df226128d195212f6348ee63d74d868a577a4fb9c74fee98f20f7f23.jpg",
+        "text": "$$\n\\mathrm { N . A c c } ( \\tilde { A } ) = \\frac { \\mathrm { E . A c c } ( \\tilde { A } ) - \\mathrm { C h a n c e } ( \\tilde { A } ) } { \\mathrm { R . A c c } ( \\tilde { A } ) - \\mathrm { C h a n c e } ( \\tilde { A } ) } \\times 1 0 0 \\%\n$$",
+        "text_format": "latex",
+        "bbox": [
+            339,
+            142,
+            656,
+            181
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "where ${ \\mathrm { R . A c c } } ( { \\tilde { A } } )$ and Chance $( { \\tilde { A } } )$ are the means of the R-split and Chance-level accuracies over $A \\setminus { \\tilde { A } }$ . Note that N.Acc is $100 \\%$ if the E-split performance is at the level of R-split and $0 \\%$ if it is at chance level. ",
+        "bbox": [
+            174,
+            191,
+            825,
+            237
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "RESULTS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            257,
+            236,
+            270
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "The normalised accuracies for R-split and multiple E-splits are presented in table 3. We consider three axes of choices of splitting attributes for the E-split: architecture (#conv and #fc), optimisation (alg and bs), and data (size). For example, “E-#conv-#fc” row presents results when metamodel is trained on shallower nets (2 or 3 conv/fc layers each) compared to the test black box model (4 conv and fc layers each). ",
+        "bbox": [
+            174,
+            281,
+            483,
+            406
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Not surprisingly, E-split performances are lower than R-split ones $( \\mathrm { N . A c c } < 1 0 0 \\% )$ ; it is advisable to cover all the expected black-box attributes during meta-training. Nonetheless, E-split performances of kennen-io are still far above the chance level $( \\mathrm { N . A c c } \\ge 7 0 \\% \\gg$ $0 \\%$ ); failing to cover a few attributes during meta-training is not too damaging. ",
+        "bbox": [
+            174,
+            414,
+            483,
+            525
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "table",
+        "img_path": "images/318b4465a40382c81bea8c238cab94914699dbe415050aad0a3985769df98912.jpg",
+        "table_caption": [
+            "Table 3: Normalised accuracies (see text) of kennen-o and kennen-io on R and E splits. We denote E-split with splitting attributes attr1 and attr2 as “E-attr1-attr2”. Splitting criteria are also shown. When there are two splitting attributes, the first attribute inherits the previous row criteria. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=2 colspan=9>kennen-Split         Train      Test        。    ioR                          =          100  100</td></tr><tr><td rowspan=1 colspan=1>100</td><td rowspan=1 colspan=1>100</td></tr><tr><td rowspan=1 colspan=1>E-#conv</td><td></td><td rowspan=1 colspan=1>2.3</td><td></td><td rowspan=1 colspan=1>4</td><td></td><td rowspan=1 colspan=1>87.5</td><td></td><td rowspan=1 colspan=1>92.0</td></tr><tr><td rowspan=1 colspan=1>E-#conv-#fc</td><td></td><td rowspan=1 colspan=1>2.3</td><td></td><td rowspan=1 colspan=1>4</td><td></td><td rowspan=1 colspan=1>77.1</td><td></td><td rowspan=1 colspan=1>80.7</td></tr><tr><td rowspan=1 colspan=1>E-alg</td><td></td><td rowspan=1 colspan=1>SGD,ADAM</td><td></td><td rowspan=1 colspan=1>RMSprop</td><td></td><td rowspan=1 colspan=1>83.0</td><td></td><td rowspan=1 colspan=1>88.5</td></tr><tr><td rowspan=1 colspan=1>E-alg-bs</td><td></td><td rowspan=1 colspan=1>64,128</td><td></td><td rowspan=1 colspan=1>256</td><td></td><td rowspan=1 colspan=1>64.2</td><td></td><td rowspan=1 colspan=1>70.0</td></tr><tr><td rowspan=1 colspan=1>E-split</td><td></td><td rowspan=1 colspan=1>Quartero/1</td><td></td><td rowspan=1 colspan=1>Quarter2/3</td><td></td><td rowspan=1 colspan=1>83.5</td><td></td><td rowspan=1 colspan=1>89.3</td></tr><tr><td rowspan=1 colspan=1>E-size</td><td></td><td rowspan=1 colspan=1>Quarter</td><td></td><td rowspan=1 colspan=1>Half,All</td><td></td><td rowspan=1 colspan=1>81.7</td><td></td><td rowspan=1 colspan=1>86.8</td></tr><tr><td rowspan=1 colspan=1>Chance</td><td></td><td rowspan=1 colspan=1></td><td></td><td rowspan=1 colspan=1></td><td></td><td rowspan=1 colspan=1>0.0</td><td></td><td rowspan=1 colspan=1>0.0</td></tr></table>",
+        "bbox": [
+            500,
+            375,
+            820,
+            523
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Comparing kennen-o and kennen-io for their generalisability, we observe that kennen-io consistently outperforms kennen-o under severe extrapolation (around $5 ~ { \\mathsf { p p } }$ better N.Acc). It is left as a future work to investigate the intriguing fact that utilising out-of-domain query inputs improves the generalisation of metamodel. ",
+        "bbox": [
+            174,
+            531,
+            826,
+            588
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "4.3 WHY AND HOW DOES METAMODEL WORK? ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            608,
+            511,
+            622
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "It is surprising that metamodels can extract inner details with great precision and generalisability. This section provides a glimpse of why and how this is possible via metamodel input and output analyses. Full answers to those questions is beyond the scope of the paper. ",
+        "bbox": [
+            174,
+            635,
+            825,
+            678
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "METAMODEL INPUT (T-SNE) ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            696,
+            369,
+            710
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "We analyse the inputs to our metamodels (i.e. query outputs from black-box models) to convince ourselves that the inputs do contain discriminative features for model attributes. As the input is high dimensional (1000 when the number of queries is $n = 1 0 0 ,$ ), we use the t-SNE (van der Maaten & Hinton, Nov 2008) visualisation method. Roughly speaking, t-SNE embeds high dimensional data points onto the 2-dimensional plane such that the pairwise distances are best respected. We then colour-code the embedded data points according to the model attributes. Clusters of same-coloured points indicate highly discriminative features. ",
+        "bbox": [
+            174,
+            722,
+            825,
+            819
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "The visualisation of input data points are shown in Appendix figures 9 and 10 for kennen-o and kennen-io, respectively. For experimental details, see Appendix $\\ S _ { \\mathrm { D } }$ . In the case of kennen-o, we observe that some attributes form clear clusters in the input space – e.g. Tanh in act, binary dropout attribute, and RMSprop in alg. For the other attributes, however, it seems that the clusters are too complicated to be represented in a 2-dimensional space. For kennen-io (figure 10), we observe improved clusters for pool and ks. By submitting crafted query inputs, kennen-io induces query outputs to be better clustered, increasing the chance of successful prediction. ",
+        "bbox": [
+            174,
+            825,
+            825,
+            924
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "METAMODEL OUTPUT (CONFUSION MATRIX) ",
+        "bbox": [
+            176,
+            104,
+            482,
+            117
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "We show confusion matrices of kennen-o/io to analyse the failure modes. See Appendix figures 11 and 12. For kennen-o and kennen-io alike, we observe that the confusion occurs more frequently with similar classes. For attributes #conv and #fc, more confusion occurs between $( 2 , 3 )$ or $( 3 , 4 )$ than between $( 2 , 4 )$ . A similar trend is observed for #par and bs. This is a strong indication that (1) there exists semantic attribute information in the neural network outputs (e.g. number of layers, parameters, or size of training batch) and (2) the metamodels learn semantic information that can generalise, as opposed to merely relying on artifacts. This observation agrees with a conclusion of the extrapolation experiments in $\\ S 4 . 2$ : the metamodels generalise. ",
+        "bbox": [
+            174,
+            131,
+            825,
+            242
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Compared to those of kennen $- \\bigcirc$ , kennen $- \\dot { \\beth } \\bigcirc$ confusion matrices exhibit greater concentration of masses both on the correct class (diagonals) and among similar attribute classes (1-off diagonals for #conv, #fc, #par, bs, and size). The former re-confirms the greater accuracy, while the latter indicates the improved ability to extract more semantic and generalisable features from the query outputs. This, again, agrees with $\\ S 4 . 2$ : kennen-io generalises better than kennen $- \\bigcirc$ . ",
+        "bbox": [
+            174,
+            250,
+            825,
+            318
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "4.4 DISCUSSION ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            340,
+            302,
+            356
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "We have verified through our novel kennen metamodels that black-box access to a neural network exposes much internal information. We have shown that only 100 single-label outputs already reveals a great deal about a black box. When the black-box classifier is quite different from the metatraining classifiers, the performance of our best metamodel – kennen-io– decreases; however, the prediction accuracy for black box internal information is still surprisingly high. ",
+        "bbox": [
+            174,
+            369,
+            825,
+            439
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "5 REVERSE-ENGINEERING AND ATTACKING IMAGENET CLASSIFIERS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            465,
+            767,
+            482
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "While MNIST experiments are computationally cheap and a massive number of controlled experiments is possible, we provide additional ImageNet experiments for practical implications on realistic image classifiers. In this section, we use kennen $- \\circ$ introduced in $\\ S 3$ to predict a single attribute of black-box ImageNet classifiers – the architecture family (e.g. ResNet or VGG?). In this section, we go a step further to use the extracted information to attack black boxes with adversarial examples. ",
+        "bbox": [
+            174,
+            500,
+            825,
+            570
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "5.1 DATASET OF IMAGENET CLASSIFIERS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            593,
+            472,
+            608
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "It is computationally prohibitive to train $O ( 1 0 k )$ ImageNet classifiers from scratch as in the previous section. We have resorted to 19 PyTorch3 pretrained ImageNet classifiers. The 19 classifiers come from five families: Squeezenet, VGG, VGG-BatchNorm, ResNet, and DenseNet, each with 2, 4, 4, 5, and 4 variants, respectively (Iandola et al., 2016; Simonyan & Zisserman, 2015; Ioffe & Szegedy, 2015; He et al., 2016; Huang et al., 2017). See Appendix table 7 for the the summary of the 19 classifiers. We observe both large intra-family diversity and small inter-family separability in terms of #layers, #parameters, and performances. The family prediction task is not as trivial as e.g. simply inferring the performance. ",
+        "bbox": [
+            174,
+            621,
+            825,
+            733
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "5.2 CLASSIFIER FAMILY PREDICTION ",
+        "text_level": 1,
+        "bbox": [
+            178,
+            756,
+            441,
+            770
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "We predict the classifier family (S, V, B, R, D) from the black-box query output, using the method kennen-o, with the same MLP architecture (§3). kennen-i and kennen-io have not been used for computational reasons, but can also be used in principle. We conduct 10 cross validations (random sampling of single test network from each family) for evaluation. We also perform 10 random sampling of the queries from ImageNet validation set. In total 100 random tries are averaged. ",
+        "bbox": [
+            174,
+            784,
+            825,
+            854
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Results: compared to the random chance $( 2 0 . 0 \\% )$ , 100 queries result in high kennen $- \\bigcirc$ performance $( 9 0 . 4 \\% )$ . With 1, 000 queries, the prediction performance is even $9 4 . 8 \\%$ . ",
+        "bbox": [
+            176,
+            861,
+            820,
+            890
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "5.3 ATTACKING IMAGENET CLASSIFIERS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            103,
+            467,
+            117
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "In this section we attack ImageNet classifiers with adversarial image perturbations (AIPs). We show that the knowledge about the black box architecture family makes the attack more effective. ",
+        "bbox": [
+            174,
+            132,
+            823,
+            160
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "ADVERSARIAL IMAGE PERTURBATION (AIP) ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            184,
+            480,
+            198
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "AIPs are carefully crafted additive perturbations on the input image for the purpose of misleading the target model to predict wrong labels (Goodfellow et al., 2015). Among variants of AIPs, we use efficient and robust GAMAN (Oh et al., 2017). See appendix figure 7 for examples of AIPs; the perturbation is nearly invisible. ",
+        "bbox": [
+            176,
+            210,
+            825,
+            266
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "TRANSFERABILITY OF AIPS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            290,
+            369,
+            303
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Typical AIP algorithms require gradients from the target network, which is not available for a black box. Mainly three approaches for generating AIPs against black boxes have been proposed: (1) numerical gradient, (2) avatar network, or (3) transferability. We show that our metamodel strengthens the transferability based attack. ",
+        "bbox": [
+            174,
+            316,
+            612,
+            386
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "table",
+        "img_path": "images/65f0b82ca763eef29a04d96718aea3ae5c13836ad006402b2b690e57e9fdd720.jpg",
+        "table_caption": [
+            "Table 4: Transferability of adversarial examples within and across families. We report misclassification rates. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=2 colspan=7>Target familyGen   S V B R DClean 3832283029</td></tr><tr><td rowspan=1 colspan=1>38</td><td rowspan=1 colspan=1>32</td><td rowspan=1 colspan=1>28</td><td rowspan=1 colspan=1>30</td><td rowspan=1 colspan=1>29</td></tr><tr><td rowspan=1 colspan=1>S</td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>64</td><td rowspan=1 colspan=1>49</td><td rowspan=1 colspan=1>45</td><td rowspan=1 colspan=1>39</td><td rowspan=1 colspan=1>35</td></tr><tr><td rowspan=1 colspan=1>V</td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>62</td><td rowspan=1 colspan=1>96</td><td rowspan=1 colspan=1>9</td><td rowspan=1 colspan=1>57</td><td rowspan=1 colspan=1>52</td></tr><tr><td rowspan=1 colspan=1>B</td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>50</td><td rowspan=1 colspan=1>85</td><td rowspan=1 colspan=1>95</td><td rowspan=1 colspan=1>47</td><td rowspan=1 colspan=1>44</td></tr><tr><td rowspan=1 colspan=1>R</td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>64</td><td rowspan=1 colspan=1>72</td><td rowspan=1 colspan=1>78</td><td rowspan=1 colspan=1>87</td><td rowspan=1 colspan=1>77</td></tr><tr><td rowspan=1 colspan=1>D</td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>58</td><td rowspan=1 colspan=1>63</td><td rowspan=1 colspan=1>70</td><td rowspan=1 colspan=1>76</td><td rowspan=1 colspan=1>90</td></tr><tr><td rowspan=1 colspan=1>Ens</td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>70</td><td rowspan=1 colspan=1>93</td><td rowspan=1 colspan=1>93</td><td rowspan=1 colspan=1>75</td><td rowspan=1 colspan=1>80</td></tr></table>",
+        "bbox": [
+            625,
+            351,
+            821,
+            502
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "We hypothesize and empirically show that AIPs transfer better within the architecture family than across. Using this property, we first predict the family of the black box (e.g. ResNet), and then generate AIPs against a few instances in the family (e.g. ResNet101, ResNet152). The generation of AIPs against multiple targets has been proposed by Liu et al. (2017), but we are the first to systemically show that AIPs generalise better within a family when they are generated against multiple instances from the same family. ",
+        "bbox": [
+            174,
+            393,
+            614,
+            505
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "We first verify our hypothesis that AIPs transfer better within a family. Within-family: we do a leave-one-out cross validation – generate AIPs using all but one instances of the family and test on the holdout. Not using the exact test black box, this gives a lower bound on the within-family performance. Across-family: still leave out one random instance from the generating family to match the generating set size with the within-family cases. We also include the use-all case (Ens): generate AIPs with one network from each family. ",
+        "bbox": [
+            174,
+            511,
+            825,
+            594
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "See table 4 for the results. We report the misclassification rate, defined as 100−top-1 accuracy, on 100 random ImageNet validation images. We observe that the within-family performances dominate the across-family ones (diagonal entries versus the others in each row); if the target black box family is identified, one can generate more effective AIPs. Finally, trying to target all network (“Ens”) is not as effective as focusing resources (diagonal entries). ",
+        "bbox": [
+            174,
+            602,
+            825,
+            671
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "METAMODEL ENABLES MORE EFFECTIVE ATTACKS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            695,
+            524,
+            708
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "We empirically show that the reverse-engineering enables more effective attacks. We consider multiple scenarios. “White box” means the target model is fully known, and the AIP is generated specifically for this model. “Black box” means the exact target is unknown, but we make a distinction when the family is known (“Family black box”). ",
+        "bbox": [
+            174,
+            722,
+            825,
+            777
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "See table 5 for the misclassification rates (MC) in different scenarios. When the target is fully specified (white box), MC is $100 \\%$ . When neither the exact target nor the family is known, AIPs are generated against multiple families $( 8 2 . 2 \\% )$ . When the reverse-engineering takes place, and AIPs are generated over the predicted family, attacks become more effective $( 8 5 . 7 \\% )$ . We almost reach the family-oracle case $( 8 6 . 2 \\% )$ . ",
+        "bbox": [
+            174,
+            785,
+            483,
+            922
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "table",
+        "img_path": "images/29c02aff1a08af189770212c633260418daf83a942c4965c0d16135a7fea2cbb.jpg",
+        "table_caption": [
+            "Table 5: Black-box ImageNet classifier misclassification rates (MC) for different approaches. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Scenario</td><td>Generating nets</td><td>MC(%)</td></tr><tr><td>White box</td><td>Single white box</td><td>100.0</td></tr><tr><td>Family black box</td><td>GT family</td><td>86.2</td></tr><tr><td>Black box whitened</td><td>Predicted family</td><td>85.7</td></tr><tr><td>Black box</td><td>Multiple families</td><td>82.2</td></tr></table>",
+        "bbox": [
+            498,
+            827,
+            834,
+            909
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "5.4 DISCUSSION ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            103,
+            302,
+            117
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Our metamodel can predict architecture families for ImageNet classifiers with high accuracy. We additionally show that this reverse-engineering enables more focused attack on black-boxes. ",
+        "bbox": [
+            174,
+            130,
+            823,
+            159
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "6 CONCLUSION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            179,
+            318,
+            195
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "We have presented first results on the inference of diverse neural network attributes from a sequence of input-output queries. Our novel metamodel methods, kennen, can successfully predict attributes related not only to the architecture but also to training hyperparameters (optimisation algorithm and dataset) even in difficult scenarios (e.g. single-label output, or a distribution gap between the metatraining models and the target black box). We have additionally shown in ImageNet experiments that reverse-engineering a black box makes it more vulnerable to adversarial examples. ",
+        "bbox": [
+            174,
+            210,
+            825,
+            295
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "ACKNOWLEDGMENTS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            313,
+            326,
+            325
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "This research was supported by the German Research Foundation (DFG CRC 1223). We thank Seong Ah Choi for her help with the method names, graphics, and colour palettes. ",
+        "bbox": [
+            176,
+            335,
+            823,
+            364
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "REFERENCES ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            386,
+            285,
+            401
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Giuseppe Ateniese, Giovanni Felici, Liugi V. Mancini, Angelo Spognardi, Antonio Villani, and Domenico Vitali. Hacking smart machines with smarter ones: How to extract meaningful data from machine learning classifiers. In IJSN, 2015. ",
+        "bbox": [
+            174,
+            409,
+            825,
+            452
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Pin-Yu Chen, Huan Zhang, Yash Sharma, Jinfeng Yi, and Cho-Jui Hsieh. Zoo: Zeroth order optimization based black-box attacks to deep neural networks without training substitute models. In ACMCCS-W, 2017. ",
+        "bbox": [
+            174,
+            462,
+            825,
+            505
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Ian J Goodfellow, Jonathon Shlens, and Christian Szegedy. Explaining and harnessing adversarial examples. In ICLR, 2015. ",
+        "bbox": [
+            171,
+            515,
+            823,
+            544
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Jamie Hayes and George Danezis. Machine learning as an adversarial service: Learning black-box adversarial examples. 2017. ",
+        "bbox": [
+            173,
+            554,
+            823,
+            583
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Kaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. Deep residual learning for image recognition. In CVPR, 2016. ",
+        "bbox": [
+            173,
+            593,
+            821,
+            622
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Gao Huang, Zhuang Liu, Laurens van der Maaten, and Kilian Q Weinberger. Densely connected convolutional networks. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, 2017. ",
+        "bbox": [
+            173,
+            632,
+            825,
+            675
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Forrest N. Iandola, Song Han, Matthew W. Moskewicz, Khalid Ashraf, William J. Dally, and Kurt Keutzer. Squeezenet: Alexnet-level accuracy with $5 0 \\mathrm { x }$ fewer parameters and ${ < } 0 . 5 \\mathrm { m b }$ model size. arXiv, 2016. ",
+        "bbox": [
+            173,
+            685,
+            825,
+            728
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Sergey Ioffe and Christian Szegedy. Batch normalization: Accelerating deep network training by reducing internal covariate shift. In ICML, 2015. ",
+        "bbox": [
+            169,
+            738,
+            823,
+            767
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Yann LeCun, Leon Bottou, Yoshua Bengio, and Patrick Haffner. Gradient-based learning applied to ´ document recognition. Proceedings of the IEEE, 1998. ",
+        "bbox": [
+            171,
+            777,
+            825,
+            806
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Yanpei Liu, Xinyun Chen, Chang Liu, and Dawn Song. Delving into transferable adversarial examples and black-box attacks. In ICLR, 2017. ",
+        "bbox": [
+            173,
+            816,
+            823,
+            845
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Seyed-Mohsen Moosavi-Dezfooli, Alhussein Fawzi, Omar Fawzi, and Pascal Frossard. Universal adversarial perturbations. In CVPR, 2017. ",
+        "bbox": [
+            173,
+            856,
+            823,
+            885
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Nina Narodytska and Shiva Prasad Kasiviswanathan. Simple black-box adversarial perturbations for deep networks. In CVPRW, 2017. ",
+        "bbox": [
+            174,
+            895,
+            823,
+            924
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "S. J. Oh, Mario Fritz, and Bernt Schiele. Adversarial image perturbation for privacy protection a game theory perspective. In ICCV, 2017. ",
+        "bbox": [
+            171,
+            103,
+            825,
+            132
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Nicolas Papernot, Patrick McDaniel, and Ian Goodfellow. Transferability in machine learning: from phenomena to black-box attacks using adversarial samples. arXiv, 2016a. ",
+        "bbox": [
+            171,
+            140,
+            823,
+            170
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Nicolas Papernot, Patrick McDaniel, Ian Goodfellow, Somesh Jha, Z. Berkay Celik, and Anathram Swami. Practical black-box attacks against deep learning systems using adversarial examples. 2016b. ",
+        "bbox": [
+            174,
+            178,
+            823,
+            220
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Nicolas Papernot, Patrick McDaniel, Ian Goodfellow, Somesh Jha, Z Berkay Celik, and Ananthram Swami. Practical black-box attacks against deep learning systems using adversarial examples. In ASIACCS, 2017. ",
+        "bbox": [
+            176,
+            231,
+            823,
+            272
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Reza Shokri, Marco Stronati, Congzheng Song, and Vitaly Shmatikov. Membership inference attacks against machine learning models. In SP, 2017. ",
+        "bbox": [
+            173,
+            281,
+            823,
+            310
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "K. Simonyan and A. Zisserman. Very deep convolutional networks for large-scale image recognition. In ICLR, 2015. ",
+        "bbox": [
+            173,
+            319,
+            821,
+            348
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Christian Szegedy, Wojciech Zaremba, Ilya Sutskever, Joan Bruna, Dumitru Erhan, Ian Goodfellow, and Rob Fergus. Intriguing properties of neural networks. In ICLR, 2014. ",
+        "bbox": [
+            174,
+            357,
+            823,
+            387
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Florian Tramer, Fan Zhang, Ari Juels, Michael K. Reiter, and Thomas Ristenpart. Stealing machine learning models via prediction apis. In USENIX, 2016. ",
+        "bbox": [
+            173,
+            395,
+            821,
+            424
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "L.J.P van der Maaten and G.E. Hinton. Visualizing high-dimensional data using t-sne. Journal of Machine Learning Research, 9: 25792605, Nov 2008. ",
+        "bbox": [
+            174,
+            433,
+            823,
+            462
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "APPENDIX ",
+        "bbox": [
+            176,
+            102,
+            264,
+            118
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "A MNIST-NETS STATISTICS ",
+        "bbox": [
+            176,
+            136,
+            428,
+            151
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "We show the statistics of MNIST-NETS, our dataset of MNIST classifiers, in table 6. ",
+        "bbox": [
+            178,
+            166,
+            732,
+            183
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "B MORE K E N N E N-I O RESULTS ",
+        "bbox": [
+            174,
+            202,
+            447,
+            218
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "We complement the kennen-o results in the main paper (figure 4) with kennen-io results. See figure 5. Similarly for kennen-o, kennen-io shows a diminishing return as the number of training models and the number of queries increase. While the performance saturates with $1 , 0 0 0$ queries, it does not fully saturate with 5, 000 training samples. ",
+        "bbox": [
+            174,
+            233,
+            825,
+            290
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "C ON FINDING THE OPTIMAL SET OF QUERIES ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            310,
+            568,
+            325
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "kennen-o selects a random set of queries from MNIST validation set (§3.2). We measure the sensitivity of kennen-o performance with respect to the choice of queries, and discuss the possibility to optimise the set of queries. ",
+        "bbox": [
+            176,
+            340,
+            823,
+            383
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "With 1, 10, or 100 queries, we have trained kennen-o with 100 independent samples of query sets. The mean and standard deviations are shown in figure 6. The sensitivity is greater for smaller number of queries, but still minute ${ \\mathrm { ( 1 . 2 p p } }$ standard deviation). ",
+        "bbox": [
+            174,
+            390,
+            823,
+            433
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Instead of solving the combinatorial problem of finding the optimal set of query inputs from a dataset, we have proposed kennen-io that efficiently solves a continuous optimisation problem to find a set of query inputs from the entire input space. We have compared kennen-io against kennen-o with multiple query samples in figure 6. We observe that kennen-io is better than kennen-o with all 100 query set samples at each level. ",
+        "bbox": [
+            174,
+            439,
+            825,
+            508
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "We remark that there exists a trade-off between detectability and effectiveness of exploration. While kennen-io extracts information from target model more effectively, it increases the detectability of attack by submitting out-of-domain inputs. If it is possible to optimise or sample the set of natural queries from a dataset or distribution of natural inputs, it will be a strong attack; developing such a method would be an interesting future work. ",
+        "bbox": [
+            174,
+            516,
+            825,
+            587
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "D T-SNE VISUALISATION OF METAMODEL INPUTS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            607,
+            606,
+            622
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "We describe the detailed procedure for the metamodel input visualisation experiment (discussed in $\\ S 4 . 3 )$ . First, 1000 test-split (Random split) black-box models are collected. For each model, 100 query images are passed (sampled at random from MNIST validation set), resulting in $1 0 0 \\times 1 0$ dimensional input data points. We have used t-SNE(van der Maaten & Hinton, Nov 2008) to embed the data points onto the 2-dimensional plane. Each data point is coloured according to each attribute class. The results for kennen-o and kennen-io are shown in figures 9 and 10. Since t-SNE is sensitive to initialisation, we have run the embedding ten times with different random initialisations; the qualitative observations are largely identical. ",
+        "bbox": [
+            174,
+            637,
+            825,
+            750
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "E VISUAL EXAMPLES OF AIPS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            770,
+            441,
+            785
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "In this section, we show examples of AIPs. See figure 7 for the examples of AIPs and the perturbed images. The perturbation is nearly invisible to human eyes. We have also generated AIPs with respect to a diverse set of architecture families (S, V, B, R, D, SVBRD) at multiple $L _ { 2 }$ norm levels. See figure 8; the same image results in a diverse set of patterns depending on the architecture family. ",
+        "bbox": [
+            174,
+            801,
+            825,
+            857
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "table",
+        "img_path": "images/e0b442d1a0e3e2737714c27387823185056671dc36ef7e214aff81ca756300b6.jpg",
+        "table_caption": [
+            "Table 6: Distribution of attributes in MNIST-NETS, and attribute-wise classification performance (on MNIST validation set). Observe that the attributes are evenly distributed and the corresponding classification accuracies also do not correlate much with the attributes. We thus make sure that the classification accuracy alone cannot be a strong cue for predicting attributes. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=\"2\"></td><td colspan=\"4\">arch/act</td><td colspan=\"2\">arch/drop</td><td colspan=\"2\">arch/pool</td><td colspan=\"2\">arch/ks</td><td colspan=\"3\">arch/#conv</td><td colspan=\"3\">arch/#fc</td></tr><tr><td>Tanh PReLU</td><td></td><td>ReLU</td><td>ELU</td><td>YesNo</td><td></td><td>YesNo</td><td></td><td>5</td><td>3</td><td>2</td><td>3</td><td>4</td><td>2</td><td>3</td><td>4</td></tr><tr><td>Ratio</td><td>24.8</td><td>24.9</td><td>25.3</td><td>25.1</td><td>49.8 50.3</td><td></td><td>49.9 50.2</td><td></td><td>50.3 49.7</td><td></td><td></td><td></td><td>34.0 33.4 32.7</td><td></td><td>33.1 33.5 33.4</td><td></td></tr><tr><td>max</td><td>99.4</td><td>99.4</td><td>99.5</td><td>99.4</td><td>99.5 99.4</td><td></td><td>99.4 99.5</td><td></td><td>99.5 99.4</td><td></td><td>99.4 99.4 99.5</td><td></td><td></td><td></td><td>99.4 99.4 99.5</td><td></td></tr><tr><td>median</td><td>98.6</td><td>98.7</td><td>98.7</td><td>98.7</td><td>98.7 98.6</td><td></td><td>98.7 98.5</td><td></td><td>98.7 98.6</td><td></td><td>98.6 98.7 98.7</td><td></td><td></td><td></td><td>98.7 98.6 98.6</td><td></td></tr><tr><td>mean</td><td>98.6</td><td>98.7</td><td>98.7</td><td>98.7</td><td>98.7 98.6</td><td></td><td>98.7 98.6</td><td></td><td>98.7 98.6</td><td></td><td>98.6 98.7 98.7</td><td></td><td></td><td></td><td>98.7 98.6 98.6</td><td></td></tr><tr><td>min</td><td>98.0</td><td>98.0</td><td>98.0</td><td>98.0</td><td>98.0 98.0</td><td></td><td>98.0 98.0</td><td></td><td>98.0 98.0</td><td></td><td>98.098.0 98.0</td><td></td><td></td><td></td><td>98.0 98.0 98.0</td><td></td></tr><tr><td colspan=\"3\" rowspan=\"8\"></td><td rowspan=\"8\"></td><td colspan=\"3\">opt/alg</td><td colspan=\"3\"></td><td colspan=\"2\"></td><td colspan=\"3\"></td><td colspan=\"3\"></td></tr><tr><td colspan=\"3\"></td><td colspan=\"3\">ADAM SGD</td><td colspan=\"3\">opt/bs 64 128 256</td><td colspan=\"3\">data/size all half</td><td colspan=\"3\"></td></tr><tr><td colspan=\"3\"></td><td colspan=\"3\">RMSprop</td><td colspan=\"3\"></td><td colspan=\"3\"></td><td colspan=\"3\">quarter</td></tr><tr><td colspan=\"3\">Ratio</td><td colspan=\"3\">33.8 32.5</td><td colspan=\"3\">33.7 32.9 33.6</td><td colspan=\"3\">533.7 14.8 28.5</td><td colspan=\"3\">56.8</td></tr><tr><td colspan=\"3\">max</td><td colspan=\"3\">99.2 99.4</td><td colspan=\"3\">99.5 99.399.4 99.5</td><td colspan=\"3\">99.5 99.3</td><td colspan=\"3\">99.1</td></tr><tr><td colspan=\"3\">median</td><td colspan=\"3\">98.6 98.7</td><td colspan=\"3\">98.7 98.6 98.7</td><td colspan=\"3\">98.7 99.0 98.8</td><td colspan=\"3\">98.5</td></tr><tr><td colspan=\"3\">mean</td><td colspan=\"3\">98.6 98.7 98.0</td><td colspan=\"3\">98.6 98.7 98.6</td><td colspan=\"3\">98.9 98.8</td><td colspan=\"3\">98.5</td></tr><tr><td colspan=\"3\">min</td><td colspan=\"3\">98.0</td><td colspan=\"3\">98.7 98.0</td><td colspan=\"2\">98.0 98.0 98.0</td><td colspan=\"3\">98.098.0 98.0</td><td colspan=\"3\"></td></tr></table>",
+        "bbox": [
+            207,
+            196,
+            790,
+            373
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "image",
+        "img_path": "images/2591ebc40c456a41a0360c3af7b74b2f60d31409457f2281d7ae496eeeda3910.jpg",
+        "image_caption": [
+            "Figure 5: Performance of kennen $- \\dot { \\textrm { \\scriptsize 1 0 } }$ with different number of queries (Left) and size of training set (Right). The curves are linearly scaled per attribute such that random chance performs $0 \\%$ , and perfect predictor performs $100 \\%$ . "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            207,
+            416,
+            784,
+            593
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "image",
+        "img_path": "images/aa21f340358fa8cad0b129db92e2fb3d4c40bfc2a1e89e2663eb439b519487c5.jpg",
+        "image_caption": [
+            "Figure 6: kennen $- \\mathrm { { O } / \\ i \\mathrm { { O } } }$ performance at different number of queries. kennen $- \\bigcirc$ is shown with 100 independent query samples per level (black dots) – the dots are spread horizontally for visualisation purpose. Their mean (curve) and $\\pm 2$ standard deviations (error bars) are also shown. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            364,
+            696,
+            629,
+            848
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "table",
+        "img_path": "images/f918e4619912745c68698b0cc958755370ace4425bac4ea81390b40a874f332e.jpg",
+        "table_caption": [
+            "Table 7: Details of ImageNet classifiers. We describe each family Squeezenet, VGG, VGGBatchNorm, ResNet, and DenseNet verbally, and show key model statistics for each member in the family. We observe intra-family diversity (e.g. R) and inter-family similarity (e.g. between V and B) in terms of the top-5 validation error and the number of trainable parameters. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td></td><td colspan=\"2\">S (2016)</td><td colspan=\"4\">V (2014)</td><td colspan=\"4\">B (2015)</td><td colspan=\"4\">R (2015)</td><td colspan=\"4\">D (2016)</td></tr><tr><td>Description</td><td colspan=\"2\">Lightweight convnet</td><td colspan=\"4\">Conv layers followed by fc layers</td><td colspan=\"4\">VGG with batch normalisation</td><td colspan=\"4\">Very deep convnet with residual connections</td><td colspan=\"4\">ResNet with dense residual connections</td></tr><tr><td>Members</td><td>v1.0</td><td>v1.1</td><td>11</td><td>13</td><td>16</td><td>19</td><td>11</td><td>13</td><td>16 19</td><td>18</td><td>34</td><td>50</td><td>101</td><td>152</td><td>121</td><td>161</td><td>169</td><td>201</td></tr><tr><td>#layers</td><td>26</td><td>26</td><td>11</td><td>13</td><td>16</td><td>19</td><td>11</td><td>13</td><td>19</td><td>21</td><td>37</td><td>54</td><td>105</td><td>156</td><td>121</td><td>161</td><td>169</td><td>201</td></tr><tr><td>log10 #params</td><td>6.1</td><td>6.1</td><td>8.1</td><td>8.1</td><td>8.1</td><td>8.2</td><td>8.1 8.1</td><td>16 8.1</td><td>8.2</td><td>7.1</td><td>7.3</td><td>7.4</td><td>7.6</td><td>7.8</td><td>6.9</td><td>7.3</td><td>7.5</td><td>7.2</td></tr><tr><td>Top-1 error</td><td>41.9</td><td>41.8</td><td>31.0</td><td>30.1</td><td>28.4</td><td>27.6</td><td>29.6 28.5</td><td>26.6</td><td>25.8</td><td>30.2</td><td>26.7</td><td>23.9</td><td>22.6</td><td>21.7</td><td>25.4</td><td>24.0</td><td>22.8</td><td>22.4</td></tr><tr><td>Top-5 error</td><td>19.6</td><td>19.4</td><td>11.4</td><td>10.8</td><td>9.6</td><td>9.1</td><td>10.2</td><td>9.6 8.5</td><td>8.2</td><td>10.9</td><td>8.6</td><td>7.1</td><td>6.4</td><td>5.9</td><td>7.8</td><td>6.2</td><td>7.0</td><td>6.4</td></tr></table>",
+        "bbox": [
+            173,
+            301,
+            862,
+            393
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "image",
+        "img_path": "images/bf5f50605242e71d8714b65ce09748d1a4de804897781b1689fa39fecbf062ff.jpg",
+        "image_caption": [
+            "Figure 7: AIP for an ImageNet classifier. The perturbations are generated at $L _ { 2 } = 1 \\times 1 0 ^ { - 4 }$ . "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            184,
+            662,
+            836,
+            757
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "image",
+        "img_path": "images/5ad329b4862dc9d727077dbd3e8c8a0e70389e50c9c1ef70f12e0c450a4551fe.jpg",
+        "image_caption": [
+            "Figure 8: Adversarial perturbations for the same input image (top) generated with diverse ImageNet classifier families (S, V, B, R, D, SVBRD) at different norm constraints. The perturbation images are normalised at the maximal perturbation for visualisation. We observe diverse patterns across classifier families within the same $L _ { 2 }$ ball. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            236,
+            241,
+            815,
+            891
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "image",
+        "img_path": "images/76b5a3910a0ddc1981803ceb3fd42b8e0abb3fefa1ad7b58c923dd8d81d2f467.jpg",
+        "image_caption": [
+            "Figure 9: Probability query output embedded into 2-D plane via t-SNE. The same embedding is shown with different colour-coding for each attribute. These are the inputs to the kennen-o metamodel. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            169,
+            212,
+            828,
+            750
+        ],
+        "page_idx": 16
+    },
+    {
+        "type": "image",
+        "img_path": "images/24a46d86731c74bd03a2de2526a5535bc021c7a9115fc93e23cd5657e9281234.jpg",
+        "image_caption": [
+            "Figure 10: Probability query output embedded into 2-D plane via t-SNE. The same embedding is shown with different colour-coding for each attribute. These are the inputs to the kennen-io metamodel. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            171,
+            219,
+            826,
+            747
+        ],
+        "page_idx": 17
+    },
+    {
+        "type": "image",
+        "img_path": "images/4088da2d25ceb3cef49fe2d8472ffbecf90dcea69d2d683b57443f059825d002.jpg",
+        "image_caption": [
+            "Figure 11: Confusion matrices for kennen-o. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            174,
+            198,
+            808,
+            796
+        ],
+        "page_idx": 18
+    },
+    {
+        "type": "image",
+        "img_path": "images/b8aac91e5361fcdf1816e7b129d6e82f5dc65b213b34f2ad27f67b4aa5370d66.jpg",
+        "image_caption": [
+            "Figure 12: Confusion matrices for kennen-io. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            174,
+            198,
+            808,
+            796
+        ],
+        "page_idx": 19
+    }
+]

parse/train/GWRkOYr4jxQ/GWRkOYr4jxQ.md

@@ -0,0 +1,301 @@
+# Luna: Linear Unified Nested Attention
+
+Xuezhe Ma∗ ISI, USC xuezhema@isi.edu
+
+Xiang Kong∗ LTI, CMU xiangk@cs.cmu.edu
+
+Sinong Wang∗ Facebook AI sinongwang@fb.com
+
+Chunting Zhou LTI, CMU chuntinz@cs.cmu.edu
+
+Jonathan May ISI, USC jonmay@isi.edu
+
+Hao Ma, Luke Zettlemoyer Facebook AI {haom, lsz}@fb.com
+
+# Abstract
+
+The quadratic computational and memory complexities of the Transformer’s attention mechanism have limited its scalability for modeling long sequences. In this paper, we propose Luna, a linear unified nested attention mechanism that approximates softmax attention with two nested linear attention functions, yielding only linear (as opposed to quadratic) time and space complexity. As compared to a more traditional attention mechanism, Luna introduces an additional sequence with a fixed length as input and an additional corresponding output, which allows Luna to perform attention operation linearly, while also storing adequate contextual information. We perform extensive evaluations on three benchmarks of sequence modeling tasks: long-context sequence modeling, neural machine translation and masked language modeling for large-scale pretraining. Competitive or even better experimental results demonstrate both the effectiveness and efficiency of Luna compared to a variety of strong baseline methods including the full-rank attention and other efficient sparse and dense attention methods. The implementation of our model is available at https://github.com/XuezheMax/fairseq-apollo.
+
+# 1 Introduction
+
+Transformers (Vaswani et al., 2017) are surprisingly versatile models that preform well on a wide range of language and vision tasks, including machine translation (Vaswani et al., 2017; Ott et al., 2018), language understanding (Devlin et al., 2019), image recognition (Dosovitskiy et al., 2020) and bioinformatics (Madani et al., 2020). Attention (Bahdanau et al., 2015) provides the key mechanism that captures contextual information from the entire sequence by modeling pairwise interactions between the inputs at every timestep. However, a common weakness of Transformers is their quadratic time and memory complexity within the attention mechanism w.r.t the length of the input sequence, which prohibitively restricts their potential application to tasks requiring longer input sequences.
+
+![](images/7370598fea7f6182bfeab93b22c2fcc488a37f690b5af9dd24427ccc46f8ff15.jpg)  
+Figure 1: Trade-off between accuracy (y-axis), speed (x-axis) and memory (cir-radius) on LRA.
+
+A number of techniques have been recently introduced to improve the time and memory efficiency of Transformer models (‘xformers’) (Tay et al., 2020b, 2021). One popular technique is using sparsity to restrict the attention field range, such as local attention (Parmar et al., 2018), blockwise attention (Qiu et al., 2019), strided attention patterns (Child et al., 2019; Beltagy et al., 2020), compressed attention (Liu et al., 2018), and attention with learnable patterns (Kitaev et al., 2020; Tay et al., 2020a; Roy et al., 2021). Another emerging approach is to improve efficiency by leveraging low-rank approximations of the attention matrix. Linformer (Wang et al., 2020), for example, projects the length dimension of key and value matrices to a fixed-dimensional representation by assuming low-rank structure in the full-rank attention matrix. Recently, some kernel-based methods, such as Linear Transformer (Katharopoulos et al., 2020), Performer (Choromanski et al., 2020) and Random Feature Attention (Peng et al., 2021), attempt to efficiently approximate regular (softmax) full-rank attention through kernelization. Although these models demonstrate better asymptotic complexity for long sequences, their efficiency gains are less prominent for moderate length sequences and their performance remains behind Transformers with regular attention.
+
+In this work, we propose a linear unified nested attention mechanism (Luna), which uses two nested attention functions to approximate the regular softmax attention in Transformer (§2). Specifically, with the first attention function, Luna packs the input sequence into a sequence of fixed length. Then, the packed sequence is unpacked using the second attention function (§3.1). As compared to a more traditional attention mechanism, Luna introduces an additional sequence with a fixed length as input and an additional corresponding output. Importantly, the extra input allows Luna to perform attention operation linearly as efficiently as Linformer (Wang et al., 2020), while also storing adequate contextual information. Unlike Linformer, Luna is capable of modeling variable-length sequences and autoregressive (causal) attention (§3.4). We perform extensive experiments on three sequence modeling tasks, including long-context sequence modeling, neural machine translation, and masked language modeling for large-scale pretraining and downstream task finetuning. Compared to a variety of strong baseline models, Luna achieves competitive or even better performance, while acquiring prominent gains of efficiency in both speed and memory (see Figure 1). More importantly, Luna manages to obtain superior performance with small projection lengths such as 16 (§4).
+
+# 2 Background
+
+# 2.1 Attention
+
+The traditional attention mechanism is a function:
+
+$$
+Y = \mathrm { A t t n } ( X , C ) = \omega \left( { \frac { X W _ { Q } ( C W _ { K } ) ^ { T } } { \sqrt { d } } } \right) C W _ { V }
+$$
+
+where the attention function Attn $\colon \mathbb { R } ^ { n \times d } \times \mathbb { R } ^ { m \times d } \to \mathbb { R } ^ { n \times d }$ takes as inputs two sequences: the query sequence $\ b { X } \in \mathbb { R } ^ { n \times d }$ with length $n$ and the context sequence $C \in \mathbb { R } ^ { m \times d }$ with length $m$ , and output one sequence $Y \in \mathbb { R } ^ { n \times d }$ with the same length $n$ as the query $X$ . $d$ is the embedding dimension, and $W _ { Q }$ , $W _ { K }$ , $W _ { V } \in \mathbb { R } ^ { d \times d }$ are three learnable parameters that project the input sequences into the space of query, key and value matrices: $Q = X \bar { W } _ { Q } , K = C \bar { W _ { K } } , \bar { V } = C \bar { W _ { V } } . c$ $\omega$ is an activation function, e.g. the softmax function in regular attention. Note that the formulation in (1) is applicable to both cross-attention where $C$ and $X$ are the representations from Transformer encoder and decoder, respectively, and self-attention where $X$ and $C$ are the same sequence $X = C$ ). In practice, the multi-head variant of attention (Vaswani et al., 2017), which performs the attention function $h$ times in parallel, is commonly used. Throughout this paper, we omit $h$ for simplicity.
+
+In particular, the matrix $\begin{array} { r } { A = \omega ( \frac { Q K ^ { T } } { \sqrt { d _ { k } } } ) \in \mathbb { R } ^ { n \times m } } \end{array}$ in (1) is called the attention matrix which specifies the alignment scores between every pair of tokens in sequences of queries $X$ and contexts $C$ Calculating $A$ takes $O ( n m )$ time and space, which is quadratic with respect to the sequence length and becomes a significant bottleneck when processing long sequences.
+
+# 2.2 Transformer Layers
+
+The other two key components of Transformer, besides attention, are position-wise feed-forward networks (FFN) and layer normalization (Ba et al., 2016). Technically, the position-wise feedforward layer operates on each position independently and layer normalization plays a crucial role in controlling the gradient scales (Xiong et al., 2020). Each Transformer layer can be expressed as:
+
+$$
+\begin{array} { r } { \begin{array} { r c l } { X _ { A } } & { = } & { \mathrm { L a y e r N o r m } ( \mathrm { A t t n } ( X , C ) + X ) } \\ { X ^ { \prime } } & { = } & { \mathrm { L a y e r N o r m } ( \mathrm { F F N } ( X _ { A } ) + X _ { A } ) } \end{array} } \end{array}
+$$
+
+where $X$ and $C$ are the two input sequences and $X ^ { \prime }$ is the output of the Transformer layer. The Transformer layer in (2) adopts the original post-layer normalization architecture (Vaswani et al., 2017; Devlin et al., 2019) that places layer normalization after residual connection, rather than pre-layer normalization (Vaswani et al., 2018; Wang et al., 2019).
+
+![](images/918c2cc6b4f018e1517fb6cc3fb341bdc218caeafcdd64ae16ca3b80e4ce5063.jpg)  
+Figure 2: Illustration of the architecture of one Transformer encoder layer (left) versus one Luna encoder layer (right).
+
+# 3 Linear Unified Nested Attention (Luna)
+
+Our goal is to design an efficient attention mechanism to solve the quadratic complexity problem of full attention. We first introduce the proposed linear unified nested attention mechanism, named Luna attention (§3.1), and the architecture of each Luna layer (§3.2). Then, we present the variant of Luna for causal attention, named Luna causal attention (§3.3). Finally, we discuss the differences between Luna and three closely related models: Linformer (Wang et al., 2019), Set Transformer (Lee et al., 2019) (§3.4) and Shared Workspace (Goyal et al., 2021).
+
+# 3.1 Pack and Unpack Attention
+
+The key idea behind Luna is to decouple the regular attention function in (1) into two nested attention operations, both of which have linear efficiency. To achieve this, besides the original query and context input sequences, Luna introduces an extra input that is a sequence with fixed (constant) length. With this extra input as the query sequence, Luna uses its first attention, named pack attention, to pack the context sequence into a fixed-length sequence. Formally, let $P \in \mathbb { R } ^ { l \times d }$ denote the extra input sequence with fixed length $l$ . The pack attention first packs $C$ to $Y _ { P }$ with $P$ as the query sequence:
+
+$$
+Y _ { P } = \mathrm { A t t n } ( P , C )
+$$
+
+where $\mathrm { A t t n } ( \cdot , \cdot )$ is the regular attention function in (1), $C \in \mathbb { R } ^ { m \times d }$ is the context sequence, and $Y _ { P } \in \mathbb { R } ^ { l \times d }$ is the output of the pack attention, which is named the packed context. Since the length of $P$ is a constant $l$ , the complexity of pack attention is $O ( l m )$ , which is linear with respect to $m$ .
+
+To unpack the sequence back to the length of the original query sequence $X$ , Luna leverages its second attention, named unpack attention:
+
+$$
+Y _ { X } = \mathrm { A t t n } ( X , Y _ { P } )
+$$
+
+where $\ b { X } \in \mathbb { R } ^ { n \times d }$ is the original query sequence. Similar to pack attention, the complexity of unpack attention is $O ( l n )$ , which is also linear with repect to $n$ .
+
+Encoding Contextual Information in $P$ . The next question is where the extra input sequence $P$ comes from. One straightforward choice is to format $P$ as a learnable parameter of each Luna layer. One obvious drawback of this method, however, is that $P$ would not capture any contextual information. To enhance the capacity of the Luna model, we propose to formulate $Y _ { P }$ as an additional output of each Luna layer, corresponding to $P$ . Formally, the Luna attention function LunaAttn $( \cdot , \cdot , \cdot )$ takes three sequences as input and generates two sequence as output:
+
+$$
+Y _ { X } , Y _ { P } = \operatorname { L u n a A t t n } ( X , P , C )
+$$
+
+where the computation of $Y _ { P }$ and $Y _ { X }$ is in (3) and (4). By stacking multiple layers of Luna attention, the output $Y _ { P }$ from the previous layer, which captures contextual information of $C$ , is employed as the input $P$ of the next layer. For the first layer of Luna, we formulate $P$ as learnable positional embeddings2 (Vaswani et al., 2017).
+
+Reducing the Number of Parameters. Due to the two nested attention operations, there are two sets of parameters $( W _ { Q }$ , $W _ { K }$ , $W _ { V } )$ ) in a single Luna attention function. There are several techniques to reduce the number of parameters, such as parameter sharing (Xia et al., 2019). In this work, we follow Wang et al. (2020) to share $W _ { K }$ and $W _ { Q }$ in each layer, and conduct experiments to analyze performance decline against Luna with full sets of parameters (§4.2).
+
+# 3.2 Luna Layers
+
+The Luna attention is used as a drop-in-replacement for the regular attention. We incorporate the position-wise feed-forward network and layer normalization into Luna layers. Concretely, layer normalization is applied to both $Y _ { X }$ and $Y _ { P }$ , while FFN only to $Y _ { X }$ :
+
+$$
+\begin{array} { r c l } { Y _ { X } , Y _ { P } } & { = } & { \operatorname { L u n a A t t n } ( X , P , C ) } \\ { X _ { A } , P _ { A } } & { = } & { \operatorname { L a y e r N o r m } ( Y _ { X } + X ) , \operatorname { L a y e r N o r m } ( Y _ { P } + P ) } \\ { X ^ { \prime } , P ^ { \prime } } & { = } & { \operatorname { L a y e r N o r m } ( \operatorname { F F N } ( X _ { A } ) + X _ { A } ) , P _ { A } } \end{array}
+$$
+
+where $X ^ { \prime }$ and $P ^ { \prime }$ are the two outputs of the Luna layer. The graphical specification of one Luna layer is illustrated in Figure 2.
+
+# 3.3 Luna Causal Attention
+
+As discussed in Tay et al. (2020b), the ability to support causal autoregressive decoding, i.e. attending solely to the past and current tokens, is required when designing efficient self-attention mechanisms. However, due to the pack attention that packs the long sequence $X$ into a fixed (shorter) length, it is not straight-forward to support causal attention in Luna.
+
+To design causal attention in Luna, we need to assume that the input $P$ contains no information of $X$ , i.e. $P$ will not leak any future information of $X$ to the history. Before we describe the Luna causal attention mechanism, we first define a causal function $f : \mathbb { R } ^ { n \times d _ { 1 } } \times \mathbb { R } ^ { n \times d _ { 1 } } \times \mathbb { R } ^ { n \times d _ { 2 } } \to \mathbb { R } ^ { n \times d _ { 2 } }$ :
+
+$$
+F \triangleq f ( X , Y , Z ) , { \mathrm { ~ w h e r e ~ } } F _ { t } = { \frac { 1 } { t } } X _ { t } \sum _ { j = 1 } ^ { t } Y _ { j } ^ { T } Z _ { j }
+$$
+
+where $F \in \mathbb { R } ^ { n \times d _ { 2 } }$ and $F _ { t }$ denotes the $t { \cdot }$ -th row of $F$ . From the definition of $f$ in (7), we see that $F _ { t }$ can only access the information of the past and present row of $X$ , $Y$ and $Z$ .
+
+To perform Luna causal attention, we first compute the attention matrix of the pack attention: $A _ { p a c k } = \omega ( P X ^ { T } / \sqrt { d } )$ . For simplicity, we omit the learnable parameters, e.g. $W _ { Q } , \ W _ { K } , \ W _ { V }$ in (1). Note that for $A _ { p a c k }$ , we cannot use the softmax function for $\omega$ , as the normalization term in softmax leaks future information of $X$ to the history. Inspired by the causal attention mechanism in Linear Transformer (Katharopoulos et al., 2020), we use two activation functions: 1) $\omega ( \cdot ) = \mathrm { e l u } ( \cdot ) + 1$ based on the exponential linear unit (Clevert et al., 2016); 2) $\omega ( \cdot ) = \mathrm { s o f t p l u s } ( \cdot )$ based on the softplus function (Glorot et al., 2011). With the causal function $f$ in (7), we compute the attention matrix of the unpack attention: $A _ { u n p a c k } = \omega ( f ( X , X , A _ { p a c k } ^ { T } ) )$ . Unlike $A _ { p a c k }$ , we can use $\omega ( \cdot ) = \mathrm { s o f t m a x } ( \cdot )$ for $A _ { u n p a c k }$ , because the normalization is along the $l$ -dimension rather than the $n$ -dimension of $X$ . Finally, the output $\mathrm { Y }$ is computed by $Y = f ( A _ { u n p a c k } , A _ { p a c k } ^ { T } , X )$ .
+
+The complexity of the causal attention in Luna is still linear: $O ( l n )$ . One drawback of Luna causal attention, similar to the causal attention in Random Feature Attention (RFA) (Peng et al., 2021) and Linear Transformer (Katharopoulos et al., 2020), is its sequential computation for each timestep $t$ .
+
+The sources of $P$ . In the formulation of causal attention, $P$ is expected to contain no information about $X$ . Thus, we need to formulate $P$ based on the usage mode of the causal attention. For the encoder-decoder mode in sequence-to-sequence modeling (e.g. for machine translation), we can use packed output from the Luna encoder as $P$ . For the decoder-only mode (e.g. for language modeling), $P$ might be formulated as a learnable parameter of each layer.
+
+Table 1: Experimental results on the long range arena (LRA) benchmark. For Luna, we explore three projected dimensions: 16, 128 and 256. ‘Avg. (w/o rtl)’ denotes the averaged accuracy over all tasks excluding Retrieval. The performance of previous works are from Tay et al. (2021).   
+
+<table><tr><td>Models</td><td>ListOps</td><td>Text</td><td>Retrieval</td><td>Image</td><td>Pathfinder</td><td>Avg.</td><td>Avg. (w/o rtl)</td></tr><tr><td>Transformer Transformer (re-impl)</td><td>36.37 37.11</td><td>64.27 65.21</td><td>57.46 79.14</td><td>42.44</td><td>71.40</td><td>54.39</td><td>53.62</td></tr><tr><td></td><td></td><td></td><td></td><td>42.94</td><td>71.83</td><td>59.24</td><td>54.27</td></tr><tr><td>Local Attention</td><td>15.82</td><td>52.98</td><td>53.39</td><td>41.46</td><td>66.63</td><td>46.06</td><td>44.22</td></tr><tr><td>Sparse Trans.</td><td>17.07</td><td>63.58</td><td>59.59</td><td>44.24</td><td>71.71</td><td>51.24</td><td>49.15</td></tr><tr><td>Longformer</td><td>35.63</td><td>62.85</td><td>56.89</td><td>42.22</td><td>69.71</td><td>53.46</td><td>52.60</td></tr><tr><td>Linformer</td><td>35.70</td><td>53.94</td><td>52.27</td><td>38.56</td><td>76.34</td><td>51.36</td><td>51.14</td></tr><tr><td>Reformer</td><td>37.27</td><td>56.10</td><td>53.40</td><td>38.07</td><td>68.50</td><td>50.67</td><td>49.99</td></tr><tr><td>Sinkhorn Trans.</td><td>33.67</td><td>61.20 61.68</td><td>53.83</td><td>41.23</td><td>67.45</td><td>51.39</td><td>50.89</td></tr><tr><td>Synthesizer</td><td>36.99 36.05</td><td>64.02</td><td>54.67</td><td>41.61</td><td>69.45</td><td>52.88</td><td>52.43</td></tr><tr><td>BigBird Linear Trans.</td><td>16.13</td><td>65.90</td><td>59.29 53.09</td><td>40.83 42.34</td><td>74.87 75.30</td><td>55.01</td><td>53.94</td></tr><tr><td>Performer</td><td>18.01</td><td>65.40</td><td>53.82</td><td>42.77</td><td>77.05</td><td>50.55 51.41</td><td>49.92</td></tr><tr><td></td><td>37.43</td><td></td><td></td><td></td><td></td><td></td><td>50.81</td></tr><tr><td>Luna-16</td><td>38.01</td><td>65.74 65.74</td><td>79.38 79.55</td><td>46.39</td><td>78.36</td><td>61.46</td><td>56.98</td></tr><tr><td>Luna-128</td><td>37.98</td><td></td><td></td><td>47.47</td><td>78.89</td><td>61.93</td><td>57.53</td></tr><tr><td>Luna-256</td><td></td><td>65.78</td><td>79.56</td><td>47.86</td><td>78.55</td><td>61.95</td><td>57.54</td></tr></table>
+
+# 3.4 Discussion
+
+Relation to Linformer and Shared Workspace. One previous work closely related to Luna is Linformer (Wang et al., 2019). Linformer linearly projects the context sequence $C \in \mathbb { R } ^ { m \times d }$ into a sequence with fixed length $l$ : $C ^ { \prime } = E C$ , where $\dot { C } ^ { \prime } \in \mathbf { \mathbb { R } } ^ { l \times d }$ is the projected context sequence and $E \in \mathbb { R } ^ { l \times m }$ is the learnable projection matrix of each layer. Then, the attention operation is applied on the query $X$ and the projected context $C ^ { \prime }$ . The pack attention in Luna is a generalization of the linear projection in Linformer. There are two main advantages to Luna over Linformer: i) with pack attention as the projection method, Luna is able to model sequences with various lengths. In contrast, Linformer requires the length of all input sequences to be the same $m$ , due to the projection matrix $E$ , whose shape depends on $m$ . ii) Luna achieves better expressiveness than Linear, not only due to the general projection method but also by encoding adequate contextual information into the projection via $P$ (see $\ S 3 . 1 \ r .$ ). Experimental improvements over non-contextual projection demonstrate the effectiveness of Luna (see $\ S 4 . 2 )$ . In contemporaneous and individual work, Goyal et al. (2021) formulate contextual $p$ as a shared global workspace, which shares similar instantiation with Luna.
+
+Relation to Set Transformer. The additional input $P$ in Luna can be regarded as a side memory module that can access the entire sequence to gather contextual information. From this view of point, Luna is also closely related to Set Transformer (Lee et al., 2019), an early model to integrate side memory module in Transformers. Similar to the projection matrix in Linformer, the inducing points in Set Transformer are learnable parameters. Thus, these inducing points might be formulated as the non-contextual version of $P$ in Luna. Moreover, Set Transformer is designed for set-input problems, which are problems wherein the input is a set of features and the model is thereby invariant to permutation or ordering of the input features (Tay et al., 2020b), while Luna attention is used as a drop-in replacement for regular softmax attention.
+
+# 4 Experiments
+
+# 4.1 Long-Context Sequence Modeling
+
+We evaluate the effectiveness and efficiency of Luna on the Long Range Arena (LRA) benchmark recently introduced by Tay et al. (2021), which is designed for the purpose of evaluating efficient Transformer models under the long-context scenario. They collect five tasks in this benchmark which are ListOps (Nangia and Bowman, 2018), byte-level text classification (Text; Maas et al., 2011), byte-level document retrieval (Retrieval; Radev et al., 2013), image classification on sequences of pixels (Image; Krizhevsky et al., 2009) and Pathfinder (Linsley et al., 2018). These tasks consist of input sequences ranging from 1K to 8K tokens and span across a variety of data types and modalities.
+
+Table 2: Training speed and peak memory consumption comparison of different models on byte-level text classification with various input lengths (1K, 2K, 3K and 4K). The best model is in boldface.   
+
+<table><tr><td>Model</td><td colspan="4"> Steps per second 个</td><td colspan="4">Peak Memory Usage (GB)↓</td></tr><tr><td>Transformer</td><td>1K 1.0</td><td>2K 1.0</td><td>3K 1.0</td><td>4K</td><td>1K 1.00</td><td>2K 1.00</td><td>3K 1.00</td><td>4K 1.00</td></tr><tr><td></td><td></td><td></td><td></td><td>1.0</td><td></td><td></td><td></td><td></td></tr><tr><td>Local Attention</td><td>1.1</td><td>1.7</td><td>3.2</td><td>5.3</td><td>0.49</td><td>0.29</td><td>0.19</td><td>0.14</td></tr><tr><td>Linformer Reformer</td><td>1.2</td><td>1.9</td><td>3.7</td><td>5.5</td><td>0.44</td><td>0.21</td><td>0.18</td><td>0.10</td></tr><tr><td>Sinkhorn Trans</td><td>0.5 1.1</td><td>0.4 1.6</td><td>0.7</td><td>0.8</td><td>0.56 0.55</td><td>0.37 0.31</td><td>0.28</td><td>0.24 0.16</td></tr><tr><td>Synthesizer</td><td>1.1</td><td>1.2</td><td>2.9</td><td>3.8</td><td>0.76</td><td></td><td>0.21</td><td>0.74</td></tr><tr><td>BigBird</td><td></td><td>0.8</td><td>2.9</td><td>1.4 1.1</td><td></td><td>0.75</td><td>0.74</td><td>0.30</td></tr><tr><td>Linear Trans.</td><td>0.9</td><td>1.9</td><td>1.2</td><td>5.6</td><td>0.91 0.44</td><td>0.56</td><td>0.40</td><td>0.11</td></tr><tr><td>Performer</td><td>1.1 1.2</td><td>1.9</td><td>3.7 3.8</td><td>5.7</td><td>0.44</td><td>0.22 0.22</td><td>0.15 0.15</td><td>0.11</td></tr><tr><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td></tr><tr><td>Luna-16</td><td>1.2</td><td>1.8</td><td>3.7</td><td>5.5</td><td>0.44 0.49</td><td>0.23</td><td>0.17</td><td>0.10</td></tr><tr><td>Luna-128</td><td>1.1</td><td>1.7</td><td>3.4</td><td>5.1</td><td></td><td>0.28</td><td>0.21</td><td>0.14</td></tr><tr><td>Luna-256</td><td>1.1</td><td>1.7</td><td>3.3</td><td>4.9</td><td>0.60</td><td>0.33</td><td>0.23</td><td>0.16</td></tr></table>
+
+To ensure fair comparisons, for all tasks except for the task Retrieval, we closely follow the model configurations in Tay et al. (2021) such as data preprocessing, data split, model architecture, etc. For the task of Retrieval, we find that models are not fully converged when being trained for 5K steps as stated in Tay et al. (2021). Therefore, we train models for 20K steps for this task and obtain much better results. For a direct comparison, besides the average performance of models across all tasks, we also report the average accuracy on tasks excluding Retrieval. We run each experiment for five times with different random seeds and report the average accuracy. The hyper-parameters for each task are shown in Appendix A.1.
+
+Results. The results of various models on the LRA benchmark are presented in Table 1. For our proposed method, we report results from models of three different projected dimensions (16, 128 and 256). First, we note that Luna achieves good results on all tasks consistently compared to the Transformer model and significantly outperforms all the other baseline methods in terms of the average accuracy. By taking a closer look at the accuracy for each individual task, Luna wins over baseline models on three out of five tasks and performs comparably with the best performed model on the other two tasks, i.e. ListOps and byte-level text classification. Notably, Luna improves over the Transformer model on image classification and pathfinder by a large margin. Second, we observe that although Luna achieves the best average performance with a projection dimension of 256, it also performs considerably well with smaller projection dimensions (16 and 128). This demonstrates the effectiveness of Luna even with small projected dimensions.
+
+Memory and Speed Efficiency. Luna employs two nested linear attention functions to reduce the time and memory complexity compared to the vanilla softmax attention. Here, we examine the speed and memory footprint of various models with varying input lengths (1K, 2K, 3K and 4K). Following Tay et al. (2021), all models are evaluated on the byte-level classification task with the same batch size. The result is shown in Table 2.
+
+Considering the memory efficiency, Luna with a projected dimension of 16 is highly memoryefficient, which is only $10 \%$ of the vanilla Transformer at 4K input sequence length. With larger projected dimensions, i.e. 128 and 256, Luna requires more memory but is still competitive compared to other efficient Transformer models. In terms of time efficiency, Luna-16 speeds up over the standard Transformer by 1.2-5.5 times, varying by the sequence length. Compared to other efficient Transformers, Luna-16 performs comparably with the fastest models, i.e. Performer and Linformer. Overall, our models achieve competitive advantage both in time- and memory-efficiency over other models, while attaining the best performance on the LRA benchmark (see Figure 1).
+
+In addition, we plot the trade-off among memory, time and averaged LRA score without task Retrieval in Figure 1. Models such as Linformer and Performer have faster speed and small memory requirement with the sacrifice of performance. However, besides competitive time- and memory-efficiency, Luna models retain superior performance even with a small projected dimension $\left( l { = } 1 6 \right)$ .
+
+Contextual information in $P$ of Luna. Recently, a popular method to model the classification task using Transformerbased models is to prepend a special symbol, [CLS], to every input example. The last hidden state of this symbol is regarded as the aggregate sequence representation. In Luna, we introduce an extra model input $P$ which not only allows us to efficiently compute the attention mechanism but learn contextual information as well. Theoretically, the $P$ from the
+
+Table 3: Performance comparison of two sentence representation methods on LRA benchmark.   
+
+<table><tr><td>Models</td><td>ListOps</td><td>Text</td><td>Retrieval</td><td>Avg.</td></tr><tr><td>Luna-16,[CLS]</td><td>37.43</td><td>65.74</td><td>79.38</td><td>60.85</td></tr><tr><td>Luna-16, P</td><td>38.06</td><td>65.81</td><td>80.22</td><td>61.36</td></tr><tr><td>Luna-128, [CLS]</td><td>38.01</td><td>65.74</td><td>79.55</td><td>61.10</td></tr><tr><td>Luna-128,P</td><td>38.27</td><td>65.89</td><td>80.27</td><td>61.48</td></tr><tr><td>Luna-256, [CLS]</td><td>37.98</td><td>65.78</td><td>79.56</td><td>61.11</td></tr><tr><td>Luna-256, P</td><td>38.36</td><td>66.07</td><td>80.25</td><td>61.56</td></tr></table>
+
+last layer is capable of learning the representation of the input sequence. To validate this, we extract $P$ at the last layer and employ the mean pooling strategy over positions to obtain the final feature for classification. We test its performance on three long-text modeling tasks in LRA (Tay et al., 2021), i.e., ListOps, Text and Retrieval and report results in Table 3. We find that $P$ -based methods obtain better scores across all tasks against the [CLS]-based one, validating the powerful ability of $P$ to encode contextual information of the input sequence.
+
+# 4.2 Machine translation
+
+To evaluate Luna on sequence-to-sequence modeling, we conduct experiments on a standard machine translation benchmark, i.e. WMT’14 English-German $\mathbf { E N } {  } \mathbf { D E }$ ) dataset (4.5M sentence pairs). The data split and preprocessing steps follow those of Vaswani et al. (2017), using the scripts from FairSeq (Ott et al., 2019). We share the source and target vocabularies within the language pair, with 37K byte pair encoding (BPE) types (Sennrich et al., 2016). The Luna models closely follow the architecture of Transformer-base: 6 encoder and decoder layers with 8 attention heads and $d _ { \mathrm { m o d e l } } / d _ { \mathrm { h i d d e n } } = 5 1 2 / 2 0 4 8$ . We train the Transformer-base model with two optimization methods: Adam (Kingma and Ba, 2015) and
+
+Table 4: Test BLEU on WMT’14 EN DE.   
+
+<table><tr><td>Model</td><td>BLEU</td><td> # Param.</td></tr><tr><td>Transformer-base (Adam) Transformer-base (Apollo)</td><td>27.8</td><td>64.9M</td></tr><tr><td>RFA (k = 256)</td><td>28.3 27.2</td><td>64.9M 66.2M</td></tr><tr><td>Luna-16, elu, tied kv Luna-32,elu, tied kv</td><td>27.1 27.3</td><td>69.6M 69.7M</td></tr><tr><td>Luna-16,softplus, tied kv Luna-32, softplus, tied kv</td><td>27.3 27.5</td><td>69.6M 69.7M</td></tr><tr><td>Luna-16, elu</td><td>27.4</td><td>77.5M</td></tr><tr><td>Luna-32, elu</td><td>27.6</td><td></td></tr><tr><td></td><td></td><td>77.6M</td></tr><tr><td>Luna-16, softplus Luna-32, softplus</td><td>27.6 27.8</td><td>77.5M</td></tr></table>
+
+Apollo (Ma, 2020), and find Apollo achieves better performance. Therefore, we use Apollo as the optimizer for all Luna models. For each experiment, we conduct distributed training across eight NVIDIA Tesla V100 GPUs with maximum batch size of 8192 tokens per GPU. Further details are provided in Appendix A.2.
+
+Results. Table 4 presents the results of Luna on the test set BLEU scores of WMT’ $1 4 \mathrm { E N } {  } \mathrm { D E }$ , along with Transformer-base and Random Feature Attention (RFA) as baselines. Different from Peng et al. (2021) where the random feature attention is applied only to decoders, the RFA model in Table 4 applies random feature attention in both the encoder and decoder for a fair comparison. $k = 2 5 6$ is the number of feature maps in RFA. For Luna, we report performance of models with different projected lengths: $l = 1 6$ and $l = 3 2$ , different activation functions in (7): $\mathrm { e l u } ( \cdot ) + 1$ and softplus $( \cdot )$ , and w./w.o parameter sharing.
+
+From Table 4, the first observation is that softplus $( \cdot )$ consistently outperforms $\mathrm { e l u } ( \cdot ) + 1$ . Thus, we use softplus $( \cdot )$ as the default activation function in the implementation. Another interesting observation is that Luna with a small projected length $( l = 1 6$ ) obtains similar performance to RFA with $k = 2 5 6$ feature maps. Luna with $l = 3 2$ achieves competitive performance, but still falls behind the Transformer-base model. Further improving the machine translation performance of Luna is left to future work. We also report the number of parameters of different models. At last, we evaluate Luna w./w.o parameter sharing. Although there are two sets of parameters in a single Luna attention function $( W _ { Q } , \ W _ { K } , \ W _ { V } )$ , as mentioned in $\ S 3 . 1$ , we tie $W _ { k }$ with $W _ { v }$ to reduce the number of parameters, and the performance decline is marginal. As a result, Luna with shared parameters has $7 \%$ and $5 \%$ more parameters compared to the vanilla Transformer and RFA models.
+
+Effect of Encoding Contextual Information into $P$ . As discussed in $\ S 3 . 4$ , one advantage of Luna against Linformer is to incorporate contextual $P$ by formulating it as an extra input. To investigate the importance of this design, we conduct experiments on WMT’14 to compare Luna with the baseline model where $P$ is formulated as a non-contextual learnable parameter of each layer.
+
+Table 5: Dev and Test BLEU   
+
+<table><tr><td>Model</td><td>Dev.</td><td>Test</td></tr><tr><td>Non-Contextual</td><td>24.4</td><td>25.2</td></tr><tr><td>Contextual</td><td>25.9</td><td>27.3</td></tr></table>
+
+For both the contextual and non-contextual models, we train Luna with $l = 1 6$ , parameter sharing and softplus. Table 5 lists the BLEU scores on the development and test sets. Luna with contextual $P$ significantly outperforms the baseline with non-contextual $P$ , demonstrating the effectiveness of this design in Luna.
+
+# 4.3 Masked Language Modeling for Large-Scale Pretraining
+
+One popular application of Transformer is to pretrain a large-scale language model on a large amount of data which can then be fine-tuned on a wide range of downstream tasks, such as BERT (Devlin et al., 2019), RoBERTa (Liu et al., 2019), etc. Therefore, we pretrain a Luna-based language model with RoBERTa-base model configuration on two versions of data as our pretraining set: 1) BERT version with BookCorpus (Zhu et al., 2015) and English Wikipedia (totally 16GB), 2) RoBERTa version with BookCorpus, English Wikipedia, CC-News (Nagel, 2016), OpenWebText (Gokaslan and Cohen, 2019) and Stories (Trinh and Le, 2018) (totally 160GB). For Luna models, we set $l = 1 2 8$ . On the larger training corpus (160GB), we train models w./w.o parameter sharing, respectively. We compare our models with RoBERTa-base, BERT-base and Linformer which are trained on the same training data. Experimental details are provided in Appendix A.3.
+
+Finetuning Luna After obtaining the pretrained Luna-based language model, we finetune it on various natural language processing tasks, including sentiment classification (SST-2; Socher et al., 2013), natural language inference (QNLI; Rajpurkar et al., 2016), textual similarity (QQP; Chen et al., 2018, question answering (RACE (Lai et al., 2017) and CommonsenseQA (CSQA; Talmor et al., 2019). For GLUE tasks, following Liu et al. (2019), we consider a limited hyperparameter sweep for each task, with batch sizes $\in \{ 1 6 , 3 2 \}$ and learning rate $\in \{ 5 e ^ { - 6 } , 1 e ^ { - 5 } , \dot { 2 } e ^ { - 5 } \}$ , with a linear warmup for the first $6 \%$ of steps followed by a linear decay to 0. Finetuning is performed for 20 epochs with early stopping based on each task’s evaluation metric on the dev set3. For QA tasks, we concatenate each candidate answer with the corresponding question and passage. We then encode every candidate and pass the [CLS] output at the last layer through a fully-connected layer, which is used to predict the correct answer. We truncate question-answer pairs that are longer than 128 tokens and, if needed, the passage so that the total length is at most 512 tokens. Following Liu et al. (2019), we try a small range of possible values for hyperparameters, i.e., batch size $\in \left\{ 1 6 , 3 2 \right\}$ , learning rate $\bar { \in } \{ 1 e ^ { - 5 } , 2 e ^ { - 5 } , 3 e ^ { - 5 } \}$ and dropout $\in \{ 0 . \dot { 0 } , 0 . \dot { 1 } , 0 . 2 \}$ . For other configurations such as warm-up steps, optimizer, we follow thoses in Liu et al. (2019).
+
+The result is reported in Table 6. We observe that on the smaller dataset (16GB) our Luna model has similar or slightly better downstream results compared to other pretrained language models. On QNLI and SST-2, Luna models obtain the best performance among all models, reaffirming the effectiveness of Luna in pre-training. This demonstrates the strong ability of Luna for language representations. On the larger dataset (160GB), however, the performance of Luna is slightly worse than RoBERTa with vanilla Transformer architecture. One possible reason is that the capacity of Luna is not as sufficient as vanilla Transformer, due to the efficient attention mechanism. This is supported by the evidence that Luna with full sets of parameters achieves better performance than that with parameter-sharing, because Luna with full sets of parameters has better capacity.
+
+# 5 Related Work
+
+There has been signficiant prior work on improving the efficiency of Transformers, besides the three closely related works discussed in $\ S 3 . 4$ . The common techniques include, but are not limited to, weight sharing (Dehghani et al., 2018), quantization (Shen et al., 2020; Fan et al., 2020), sparse attention (Parmar et al., 2018; Kitaev et al., 2020), side memory module (Lee et al., 2019; Gupta and Berant, 2020; Goyal et al., 2021), and low-rank or compressed context (Wang et al., 2019; Ainslie et al., 2020). In this section, we briefly review some recently proposed methods. For a detailed overview we refer the readers to Tay et al. (2020b).
+
+Table 6: Performance of various models on development set of benchmark natural language understanding tasks. Bold face indicates best performance.   
+
+<table><tr><td rowspan="2">Model</td><td rowspan="2">data</td><td colspan="3">GLUE</td><td colspan="2">QA</td></tr><tr><td>SST-2</td><td>QNLI</td><td>QQP</td><td>RACE</td><td>CSQA</td></tr><tr><td>BERT-base</td><td>16GB</td><td>92.7</td><td>88.4</td><td>89.6</td><td>64.2</td><td>53.3</td></tr><tr><td>RoBERTa-base</td><td>16GB</td><td>93.1</td><td>90.9</td><td>90.9</td><td>65.6</td><td>-</td></tr><tr><td>Linformer-128</td><td>16GB</td><td>92.4</td><td>90.4</td><td>90.2</td><td>1</td><td>1</td></tr><tr><td>Luna-128, tied kv</td><td>16GB</td><td>93.1</td><td>91.2</td><td>90.8</td><td>65.2</td><td>53.1</td></tr><tr><td>RoBERTa-base</td><td>160GB</td><td>94.8</td><td>92.8</td><td>91.9</td><td>73.50</td><td>63.61</td></tr><tr><td>Luna-128, tied kv</td><td>160GB</td><td>94.3</td><td>91.5</td><td>91.2</td><td>71.50</td><td>61.48</td></tr><tr><td>Luna-128</td><td>160GB</td><td>94.6</td><td>92.2</td><td>91.3</td><td>72.25</td><td>62.08</td></tr></table>
+
+Sparse Attention The general idea of these methods is that, instead of attending to the whole sequence, each token only access to a fixed, predefined range such as local neighborhoods and strided or “dilated” windows. Popular methods include local attention (Parmar et al., 2018), blockwise attention (Qiu et al., 2019), strided attention patterns (Child et al., 2019; Beltagy et al., 2020), and compressed attention (Liu et al., 2018). To make this range more flexible, Reformer (Kitaev et al., 2020) employs a hash-based similarity measure to efficiently cluster tokens into chunks and Routing Transformer(Roy et al., 2021) employ online $\mathbf { k }$ -means clustering on the tokens. The Sinkhorn sorting Network (Tay et al., 2020a) exposes the sparsity in attention weights by learning to sort blocks of the input sequence.
+
+Kernel Methods. A recently popular method to improve the efficiency of Transformers is to avoid explicitly computing the $m \times n$ attention matrix $A$ in (1) by re-writing it with kernels. Typical models leveraging kernelization are Linear Transformer (Katharopoulos et al., 2020), Performer (Choromanski et al., 2020) and Random Feature Attention (Peng et al., 2021). Since kernels are a form of approximation of the attention matrix, they can be also viewed as a form of low-rank method (Choromanski et al., 2020) that compresses the context to a shorter length, such as Linformer (Wang et al., 2019) and the proposed Luna model.
+
+Recurrence. The simplest technique to reduce the complexity of Transformer is to chunk input sequences into fixed blocks, with the obvious disadvantage of losing contextual information from past chunks. As discussed in Tay et al. (2020b), these models can be regarded as fixed pattern models. Transformer-XL (Dai et al., 2019) proposed a natural extension to the blockwise method to connect these blocks via a recurrence mechanism. Compressive Transformer (Rae et al., 2020) further extends Transformer-XL by maintaining a fine-grained memory of past chunk activations, which are discarded in Transformer-XL. Technically, Luna can be adapted to a recurrence method, by simply using $P$ as an inherent memory module to maintain the recurrence across segments.
+
+# 6 Conclusion
+
+We have introduced Luna, a simple, efficient and effective linear attention mechanism used as a drop-in substitute for regular softmax attention. By introducing an extra input with the fixed length, Luna is capable of capturing adequate contextual information while performing attention operations linearly. On three sequence modeling tasks, i.e., long-context sequence modeling, neural machine translation, and large-scale pretraining and finetuning, Luna achieves comparable or even better performance than a variety of strong baselines, while acquiring prominent gains of efficiency in both speed and memory. In future work, we are interested in combining Luna with recurrence methods where $P$ can be used as a running memory across segments of inputs. Another interesting direction would be to apply Luna to other tasks with long input sequences, such as document-level summarization and translation.
+
+# Acknowledgments and Disclosure of Funding
+
+This material is based on research sponsored by Air Force Research Laboratory (AFRL) under agreement number FA8750-19-1-1000. The U.S. Government is authorized to reproduce and distribute reprints for Government purposes notwithstanding any copyright notation therein. Xiang Kong was supported by U.S. DARPA AIDA Program No. FA8750-18-2-0014. The views and conclusions contained herein are those of the authors and should not be interpreted as necessarily representing the official policies or endorsements, either expressed or implied, of Air Force Laboratory, DARPA or the U.S. Government.
+
+# References
+
+Joshua Ainslie, Santiago Ontanon, Chris Alberti, Vaclav Cvicek, Zachary Fisher, Philip Pham, Anirudh Ravula, Sumit Sanghai, Qifan Wang, and Li Yang. Etc: Encoding long and structured inputs in transformers. In Proceedings of the 2020 Conference on Empirical Methods in Natural Language Processing (EMNLP), pages 268–284, 2020.   
+Jimmy Lei Ba, Jamie Ryan Kiros, and Geoffrey E Hinton. Layer normalization. arXiv preprint arXiv:1607.06450, 2016.   
+Dzmitry Bahdanau, Kyunghyun Cho, and Yoshua Bengio. Neural machine translation by jointly learning to align and translate. In International Conference on Learning Representations (ICLR), 2015.   
+Iz Beltagy, Matthew E Peters, and Arman Cohan. Longformer: The long-document transformer. arXiv preprint arXiv:2004.05150, 2020.   
+Zihan Chen, Hongbo Zhang, Xiaoji Zhang, and Leqi Zhao. Quora question pairs. University of Waterloo, 2018.   
+Rewon Child, Scott Gray, Alec Radford, and Ilya Sutskever. Generating long sequences with sparse transformers. arXiv preprint arXiv:1904.10509, 2019.   
+Krzysztof Choromanski, Valerii Likhosherstov, David Dohan, Xingyou Song, Andreea Gane, Tamas Sarlos, Peter Hawkins, Jared Davis, Afroz Mohiuddin, Lukasz Kaiser, et al. Rethinking attention with performers. arXiv preprint arXiv:2009.14794, 2020.   
+Djork-Arné Clevert, Thomas Unterthiner, and Sepp Hochreiter. Fast and accurate deep network learning by exponential linear units (elus). In International Conference on Learning Representations (ICLR), 2016.   
+Zihang Dai, Zhilin Yang, Yiming Yang, Jaime G Carbonell, Quoc Le, and Ruslan Salakhutdinov. Transformer-xl: Attentive language models beyond a fixed-length context. In Proceedings of the 57th Annual Meeting of the Association for Computational Linguistics, pages 2978–2988, 2019.   
+Mostafa Dehghani, Stephan Gouws, Oriol Vinyals, Jakob Uszkoreit, and Lukasz Kaiser. Universal transformers. In International Conference on Learning Representations (ICLR), 2018.   
+Jacob Devlin, Ming-Wei Chang, Kenton Lee, and Kristina Toutanova. Bert: Pre-training of deep bidirectional transformers for language understanding. In Proceedings of the 2019 Conference of the North American Chapter of the Association for Computational Linguistics: Human Language Technologies, Volume 1 (Long and Short Papers), pages 4171–4186, 2019.   
+Alexey Dosovitskiy, Lucas Beyer, Alexander Kolesnikov, Dirk Weissenborn, Xiaohua Zhai, Thomas Unterthiner, Mostafa Dehghani, Matthias Minderer, Georg Heigold, Sylvain Gelly, et al. An image is worth 16x16 words: Transformers for image recognition at scale. arXiv preprint arXiv:2010.11929, 2020.   
+Angela Fan, Pierre Stock, Benjamin Graham, Edouard Grave, Remi Gribonval, Herve Jegou, and Armand Joulin. Training with quantization noise for extreme fixed-point compression. arXiv preprint arXiv:2004.07320, 2020.
+
+Xavier Glorot, Antoine Bordes, and Yoshua Bengio. Deep sparse rectifier neural networks. In Proceedings of the fourteenth international conference on artificial intelligence and statistics, pages 315–323. JMLR Workshop and Conference Proceedings, 2011.
+
+Aaron Gokaslan and Vanya Cohen. Openwebtext corpus. URl: https://skylion007. github. io/OpenWebTextCorpus, 2019.
+
+Anirudh Goyal, Aniket Didolkar, Alex Lamb, Kartikeya Badola, Nan Rosemary Ke, Nasim Rahaman, Jonathan Binas, Charles Blundell, Michael Mozer, and Yoshua Bengio. Coordination among neural modules through a shared global workspace. arXiv preprint arXiv:2103.01197, 2021.
+
+Ankit Gupta and Jonathan Berant. Gmat: Global memory augmentation for transformers. arXiv preprint arXiv:2006.03274, 2020.
+
+Angelos Katharopoulos, Apoorv Vyas, Nikolaos Pappas, and François Fleuret. Transformers are rnns: Fast autoregressive transformers with linear attention. In International Conference on Machine Learning, pages 5156–5165. PMLR, 2020.
+
+Diederik P Kingma and Jimmy Ba. Adam: A method for stochastic optimization. In International Conference on Learning Representations, 2015.
+
+Nikita Kitaev, Łukasz Kaiser, and Anselm Levskaya. Reformer: The efficient transformer. arXiv preprint arXiv:2001.04451, 2020.
+
+Alex Krizhevsky et al. Learning multiple layers of features from tiny images. Technical Report. University of Toronto, 2009.
+
+Guokun Lai, Qizhe Xie, Hanxiao Liu, Yiming Yang, and Eduard Hovy. Race: Large-scale reading comprehension dataset from examinations. In Proceedings of the 2017 Conference on Empirical Methods in Natural Language Processing, pages 785–794, 2017.
+
+Juho Lee, Yoonho Lee, Jungtaek Kim, Adam Kosiorek, Seungjin Choi, and Yee Whye Teh. Set transformer: A framework for attention-based permutation-invariant neural networks. In International Conference on Machine Learning, pages 3744–3753. PMLR, 2019.
+
+Drew Linsley, Junkyung Kim, Vijay Veerabadran, Charles Windolf, and Thomas Serre. Learning long-range spatial dependencies with horizontal gated recurrent units. In S. Bengio, H. Wallach, H. Larochelle, K. Grauman, N. Cesa-Bianchi, and R. Garnett, editors, Advances in Neural Information Processing Systems, volume 31. Curran Associates, Inc., 2018. URL https://proceedings.neurips.cc/paper/2018/file/ec8956637a99787bd197eacd77acce5e-Paper.pdf.
+
+Peter J Liu, Mohammad Saleh, Etienne Pot, Ben Goodrich, Ryan Sepassi, Lukasz Kaiser, and Noam Shazeer. Generating wikipedia by summarizing long sequences. In International Conference on Learning Representations (ICLR), 2018.
+
+Yinhan Liu, Myle Ott, Naman Goyal, Jingfei Du, Mandar Joshi, Danqi Chen, Omer Levy, Mike Lewis, Luke Zettlemoyer, and Veselin Stoyanov. Roberta: A robustly optimized bert pretraining approach. arXiv preprint arXiv:1907.11692, 2019.
+
+Ilya Loshchilov and Frank Hutter. Decoupled weight decay regularization. In International Conference on Learning Representations, 2019.
+
+Xuezhe Ma. Apollo: An adaptive parameter-wise diagonal quasi-newton method for nonconvex stochastic optimization. arXiv preprint arXiv:2009.13586, 2020.
+
+Andrew Maas, Raymond E Daly, Peter T Pham, Dan Huang, Andrew Y Ng, and Christopher Potts. Learning word vectors for sentiment analysis. In Proceedings of the 49th annual meeting of the association for computational linguistics: Human language technologies, pages 142–150, 2011.
+
+Ali Madani, Bryan McCann, Nikhil Naik, Nitish Shirish Keskar, Namrata Anand, Raphael R Eguchi, Possu Huang, and Richard Socher. Progen: Language modeling for protein generation. bioRxiv, 2020.
+
+Sebastian Nagel. Cc-news. URL: http://web. archive. org/save/http://commoncrawl. org/2016/10/newsdatasetavailable, 2016.
+
+Nikita Nangia and Samuel Bowman. Listops: A diagnostic dataset for latent tree learning. In Proceedings of the 2018 Conference of the North American Chapter of the Association for Computational Linguistics: Student Research Workshop, pages 92–99, 2018.
+
+Myle Ott, Sergey Edunov, David Grangier, and Michael Auli. Scaling neural machine translation. In Proceedings of the Third Conference on Machine Translation: Research Papers, pages 1–9, 2018.
+
+Myle Ott, Sergey Edunov, Alexei Baevski, Angela Fan, Sam Gross, Nathan Ng, David Grangier, and Michael Auli. fairseq: A fast, extensible toolkit for sequence modeling. In Proceedings of NAACL-HLT 2019: Demonstrations, 2019.
+
+Niki Parmar, Ashish Vaswani, Jakob Uszkoreit, Lukasz Kaiser, Noam Shazeer, Alexander Ku, and Dustin Tran. Image transformer. In International Conference on Machine Learning, pages 4055–4064. PMLR, 2018.
+
+Hao Peng, Nikolaos Pappas, Dani Yogatama, Roy Schwartz, Noah Smith, and Lingpeng Kong. Random feature attention. In International Conference on Learning Representations, 2021. URL https://openreview.net/forum?id $=$ QtTKTdVrFBB.
+
+Jiezhong Qiu, Hao Ma, Omer Levy, Scott Wen-tau Yih, Sinong Wang, and Jie Tang. Blockwise self-attention for long document understanding. arXiv preprint arXiv:1911.02972, 2019.
+
+Dragomir R Radev, Pradeep Muthukrishnan, Vahed Qazvinian, and Amjad Abu-Jbara. The acl anthology network corpus. Language Resources and Evaluation, 47(4):919–944, 2013.
+
+Jack W Rae, Anna Potapenko, Siddhant M Jayakumar, Chloe Hillier, and Timothy P Lillicrap. Compressive transformers for long-range sequence modeling. In International Conference on Learning Representations (ICLR), 2020.
+
+Pranav Rajpurkar, Jian Zhang, Konstantin Lopyrev, and Percy Liang. Squad: $^ { 1 0 0 , 0 0 0 + }$ questions for machine comprehension of text. In Proceedings of the 2016 Conference on Empirical Methods in Natural Language Processing, pages 2383–2392, 2016.
+
+Aurko Roy, Mohammad Saffar, Ashish Vaswani, and David Grangier. Efficient content-based sparse attention with routing transformers. Transactions of the Association for Computational Linguistics, 9:53–68, 2021.
+
+Rico Sennrich, Barry Haddow, and Alexandra Birch. Neural machine translation of rare words with subword units. In Proceedings of the 54th Annual Meeting of the Association for Computational Linguistics (Volume 1: Long Papers), pages 1715–1725, 2016.
+
+Sheng Shen, Zhen Dong, Jiayu Ye, Linjian Ma, Zhewei Yao, Amir Gholami, Michael W Mahoney, and Kurt Keutzer. Q-bert: Hessian based ultra low precision quantization of bert. In Proceedings of the AAAI Conference on Artificial Intelligence, volume 34, pages 8815–8821, 2020.
+
+Richard Socher, Alex Perelygin, Jean Wu, Jason Chuang, Christopher D Manning, Andrew $\mathrm { \Delta Y N g }$ , and Christopher Potts. Recursive deep models for semantic compositionality over a sentiment treebank. In Proceedings of the 2013 conference on empirical methods in natural language processing, pages 1631–1642, 2013.
+
+Christian Szegedy, Vincent Vanhoucke, Sergey Ioffe, Jon Shlens, and Zbigniew Wojna. Rethinking the inception architecture for computer vision. In Proceedings of the IEEE conference on computer vision and pattern recognition, pages 2818–2826, 2016.
+
+Alon Talmor, Jonathan Herzig, Nicholas Lourie, and Jonathan Berant. Commonsenseqa: A question answering challenge targeting commonsense knowledge. In Proceedings of the 2019 Conference of the North American Chapter of the Association for Computational Linguistics: Human Language Technologies, Volume 1 (Long and Short Papers), pages 4149–4158, 2019.
+
+Yi Tay, Dara Bahri, Liu Yang, Donald Metzler, and Da-Cheng Juan. Sparse sinkhorn attention. In International Conference on Machine Learning, pages 9438–9447. PMLR, 2020a.
+
+Yi Tay, Mostafa Dehghani, Dara Bahri, and Donald Metzler. Efficient transformers: A survey. arXiv preprint arXiv:2009.06732, 2020b.
+
+Yi Tay, Mostafa Dehghani, Samira Abnar, Yikang Shen, Dara Bahri, Philip Pham, Jinfeng Rao, Liu Yang, Sebastian Ruder, and Donald Metzler. Long range arena : A benchmark for efficient transformers. In International Conference on Learning Representations, 2021. URL https: //openreview.net/forum?id=qVyeW-grC2k.   
+Trieu H Trinh and Quoc V Le. A simple method for commonsense reasoning. arXiv preprint arXiv:1806.02847, 2018.   
+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, pages 5998–6008, 2017.   
+Ashish Vaswani, Samy Bengio, Eugene Brevdo, Francois Chollet, Aidan Gomez, Stephan Gouws, Llion Jones, Łukasz Kaiser, Nal Kalchbrenner, Niki Parmar, et al. Tensor2tensor for neural machine translation. In Proceedings of the 13th Conference of the Association for Machine Translation in the Americas (Volume 1: Research Track), pages 193–199, 2018.   
+Qiang Wang, Bei Li, Tong Xiao, Jingbo Zhu, Changliang Li, Derek F Wong, and Lidia S Chao. Learning deep transformer models for machine translation. In Proceedings of the 57th Annual Meeting of the Association for Computational Linguistics, pages 1810–1822, 2019.   
+Sinong Wang, Belinda Li, Madian Khabsa, Han Fang, and Hao Ma. Linformer: Self-attention with linear complexity. arXiv preprint arXiv:2006.04768, 2020.   
+Yingce Xia, Tianyu He, Xu Tan, Fei Tian, Di He, and Tao Qin. Tied transformers: Neural machine translation with shared encoder and decoder. In Proceedings of the AAAI Conference on Artificial Intelligence, volume 33, pages 5466–5473, 2019.   
+Ruibin Xiong, Yunchang Yang, Di He, Kai Zheng, Shuxin Zheng, Chen Xing, Huishuai Zhang, Yanyan Lan, Liwei Wang, and Tieyan Liu. On layer normalization in the transformer architecture. In International Conference on Machine Learning, pages 10524–10533. PMLR, 2020.   
+Yukun Zhu, Ryan Kiros, Rich Zemel, Ruslan Salakhutdinov, Raquel Urtasun, Antonio Torralba, and Sanja Fidler. Aligning books and movies: Towards story-like visual explanations by watching movies and reading books. In Proceedings of the IEEE international conference on computer vision, pages 19–27, 2015.

parse/train/GWRkOYr4jxQ/GWRkOYr4jxQ_content_list.json

@@ -0,0 +1,1503 @@
+[
+    {
+        "type": "text",
+        "text": "Luna: Linear Unified Nested Attention ",
+        "text_level": 1,
+        "bbox": [
+            261,
+            122,
+            736,
+            147
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Xuezhe Ma∗ ISI, USC xuezhema@isi.edu ",
+        "bbox": [
+            225,
+            196,
+            364,
+            238
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Xiang Kong∗ LTI, CMU xiangk@cs.cmu.edu ",
+        "bbox": [
+            421,
+            196,
+            568,
+            238
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Sinong Wang∗ Facebook AI sinongwang@fb.com ",
+        "bbox": [
+            625,
+            196,
+            774,
+            239
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Chunting Zhou LTI, CMU chuntinz@cs.cmu.edu ",
+        "bbox": [
+            210,
+            260,
+            375,
+            301
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Jonathan May ISI, USC jonmay@isi.edu ",
+        "bbox": [
+            421,
+            261,
+            542,
+            301
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Hao Ma, Luke Zettlemoyer Facebook AI {haom, lsz}@fb.com ",
+        "bbox": [
+            586,
+            260,
+            785,
+            301
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Abstract ",
+        "text_level": 1,
+        "bbox": [
+            462,
+            318,
+            535,
+            333
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "The quadratic computational and memory complexities of the Transformer’s attention mechanism have limited its scalability for modeling long sequences. In this paper, we propose Luna, a linear unified nested attention mechanism that approximates softmax attention with two nested linear attention functions, yielding only linear (as opposed to quadratic) time and space complexity. As compared to a more traditional attention mechanism, Luna introduces an additional sequence with a fixed length as input and an additional corresponding output, which allows Luna to perform attention operation linearly, while also storing adequate contextual information. We perform extensive evaluations on three benchmarks of sequence modeling tasks: long-context sequence modeling, neural machine translation and masked language modeling for large-scale pretraining. Competitive or even better experimental results demonstrate both the effectiveness and efficiency of Luna compared to a variety of strong baseline methods including the full-rank attention and other efficient sparse and dense attention methods. The implementation of our model is available at https://github.com/XuezheMax/fairseq-apollo. ",
+        "bbox": [
+            232,
+            348,
+            766,
+            555
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 Introduction ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            579,
+            310,
+            595
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Transformers (Vaswani et al., 2017) are surprisingly versatile models that preform well on a wide range of language and vision tasks, including machine translation (Vaswani et al., 2017; Ott et al., 2018), language understanding (Devlin et al., 2019), image recognition (Dosovitskiy et al., 2020) and bioinformatics (Madani et al., 2020). Attention (Bahdanau et al., 2015) provides the key mechanism that captures contextual information from the entire sequence by modeling pairwise interactions between the inputs at every timestep. However, a common weakness of Transformers is their quadratic time and memory complexity within the attention mechanism w.r.t the length of the input sequence, which prohibitively restricts their potential application to tasks requiring longer input sequences. ",
+        "bbox": [
+            174,
+            607,
+            504,
+            827
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "image",
+        "img_path": "images/7370598fea7f6182bfeab93b22c2fcc488a37f690b5af9dd24427ccc46f8ff15.jpg",
+        "image_caption": [
+            "Figure 1: Trade-off between accuracy (y-axis), speed (x-axis) and memory (cir-radius) on LRA. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            521,
+            573,
+            816,
+            790
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "A number of techniques have been recently introduced to improve the time and memory efficiency of Transformer models (‘xformers’) (Tay et al., 2020b, 2021). One popular technique is using sparsity to restrict the attention field range, such as local attention (Parmar et al., 2018), blockwise attention (Qiu et al., 2019), strided attention patterns (Child et al., 2019; Beltagy et al., 2020), compressed attention (Liu et al., 2018), and attention with learnable patterns (Kitaev et al., 2020; Tay et al., 2020a; Roy et al., 2021). Another emerging approach is to improve efficiency by leveraging low-rank approximations of the attention matrix. Linformer (Wang et al., 2020), for example, projects the length dimension of key and value matrices to a fixed-dimensional representation by assuming low-rank structure in the full-rank attention matrix. Recently, some kernel-based methods, such as Linear Transformer (Katharopoulos et al., 2020), Performer (Choromanski et al., 2020) and Random Feature Attention (Peng et al., 2021), attempt to efficiently approximate regular (softmax) full-rank attention through kernelization. Although these models demonstrate better asymptotic complexity for long sequences, their efficiency gains are less prominent for moderate length sequences and their performance remains behind Transformers with regular attention. ",
+        "bbox": [
+            174,
+            834,
+            825,
+            890
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            90,
+            825,
+            229
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "In this work, we propose a linear unified nested attention mechanism (Luna), which uses two nested attention functions to approximate the regular softmax attention in Transformer (§2). Specifically, with the first attention function, Luna packs the input sequence into a sequence of fixed length. Then, the packed sequence is unpacked using the second attention function (§3.1). As compared to a more traditional attention mechanism, Luna introduces an additional sequence with a fixed length as input and an additional corresponding output. Importantly, the extra input allows Luna to perform attention operation linearly as efficiently as Linformer (Wang et al., 2020), while also storing adequate contextual information. Unlike Linformer, Luna is capable of modeling variable-length sequences and autoregressive (causal) attention (§3.4). We perform extensive experiments on three sequence modeling tasks, including long-context sequence modeling, neural machine translation, and masked language modeling for large-scale pretraining and downstream task finetuning. Compared to a variety of strong baseline models, Luna achieves competitive or even better performance, while acquiring prominent gains of efficiency in both speed and memory (see Figure 1). More importantly, Luna manages to obtain superior performance with small projection lengths such as 16 (§4). ",
+        "bbox": [
+            173,
+            236,
+            825,
+            429
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2 Background ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            440,
+            308,
+            458
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2.1 Attention ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            463,
+            279,
+            478
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "The traditional attention mechanism is a function: ",
+        "bbox": [
+            174,
+            486,
+            501,
+            500
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "equation",
+        "img_path": "images/970729d08c786e09b9bdb9d2dd574342038645c3fc62549f0c4b91c8c3aa7f5c.jpg",
+        "text": "$$\nY = \\mathrm { A t t n } ( X , C ) = \\omega \\left( { \\frac { X W _ { Q } ( C W _ { K } ) ^ { T } } { \\sqrt { d } } } \\right) C W _ { V }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            333,
+            498,
+            663,
+            532
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "where the attention function Attn $\\colon \\mathbb { R } ^ { n \\times d } \\times \\mathbb { R } ^ { m \\times d } \\to \\mathbb { R } ^ { n \\times d }$ takes as inputs two sequences: the query sequence $\\ b { X } \\in \\mathbb { R } ^ { n \\times d }$ with length $n$ and the context sequence $C \\in \\mathbb { R } ^ { m \\times d }$ with length $m$ , and output one sequence $Y \\in \\mathbb { R } ^ { n \\times d }$ with the same length $n$ as the query $X$ . $d$ is the embedding dimension, and $W _ { Q }$ , $W _ { K }$ , $W _ { V } \\in \\mathbb { R } ^ { d \\times d }$ are three learnable parameters that project the input sequences into the space of query, key and value matrices: $Q = X \\bar { W } _ { Q } , K = C \\bar { W _ { K } } , \\bar { V } = C \\bar { W _ { V } } . c$ $\\omega$ is an activation function, e.g. the softmax function in regular attention. Note that the formulation in (1) is applicable to both cross-attention where $C$ and $X$ are the representations from Transformer encoder and decoder, respectively, and self-attention where $X$ and $C$ are the same sequence $X = C$ ). In practice, the multi-head variant of attention (Vaswani et al., 2017), which performs the attention function $h$ times in parallel, is commonly used. Throughout this paper, we omit $h$ for simplicity. ",
+        "bbox": [
+            173,
+            531,
+            825,
+            671
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "In particular, the matrix $\\begin{array} { r } { A = \\omega ( \\frac { Q K ^ { T } } { \\sqrt { d _ { k } } } ) \\in \\mathbb { R } ^ { n \\times m } } \\end{array}$ in (1) is called the attention matrix which specifies the alignment scores between every pair of tokens in sequences of queries $X$ and contexts $C$ Calculating $A$ takes $O ( n m )$ time and space, which is quadratic with respect to the sequence length and becomes a significant bottleneck when processing long sequences. ",
+        "bbox": [
+            174,
+            676,
+            825,
+            739
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2.2 Transformer Layers ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            747,
+            354,
+            762
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "The other two key components of Transformer, besides attention, are position-wise feed-forward networks (FFN) and layer normalization (Ba et al., 2016). Technically, the position-wise feedforward layer operates on each position independently and layer normalization plays a crucial role in controlling the gradient scales (Xiong et al., 2020). Each Transformer layer can be expressed as: ",
+        "bbox": [
+            173,
+            770,
+            825,
+            825
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "equation",
+        "img_path": "images/018e5a9073abf3a8de3be79058dceeec751df386a222c258e0cd9ce7a379e226.jpg",
+        "text": "$$\n\\begin{array} { r } { \\begin{array} { r c l } { X _ { A } } & { = } & { \\mathrm { L a y e r N o r m } ( \\mathrm { A t t n } ( X , C ) + X ) } \\\\ { X ^ { \\prime } } & { = } & { \\mathrm { L a y e r N o r m } ( \\mathrm { F F N } ( X _ { A } ) + X _ { A } ) } \\end{array} } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            357,
+            827,
+            638,
+            858
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "where $X$ and $C$ are the two input sequences and $X ^ { \\prime }$ is the output of the Transformer layer. The Transformer layer in (2) adopts the original post-layer normalization architecture (Vaswani et al., 2017; Devlin et al., 2019) that places layer normalization after residual connection, rather than pre-layer normalization (Vaswani et al., 2018; Wang et al., 2019). ",
+        "bbox": [
+            174,
+            856,
+            825,
+            911
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "image",
+        "img_path": "images/918c2cc6b4f018e1517fb6cc3fb341bdc218caeafcdd64ae16ca3b80e4ce5063.jpg",
+        "image_caption": [
+            "Figure 2: Illustration of the architecture of one Transformer encoder layer (left) versus one Luna encoder layer (right). "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            225,
+            87,
+            772,
+            304
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3 Linear Unified Nested Attention (Luna) ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            359,
+            535,
+            377
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Our goal is to design an efficient attention mechanism to solve the quadratic complexity problem of full attention. We first introduce the proposed linear unified nested attention mechanism, named Luna attention (§3.1), and the architecture of each Luna layer (§3.2). Then, we present the variant of Luna for causal attention, named Luna causal attention (§3.3). Finally, we discuss the differences between Luna and three closely related models: Linformer (Wang et al., 2019), Set Transformer (Lee et al., 2019) (§3.4) and Shared Workspace (Goyal et al., 2021). ",
+        "bbox": [
+            173,
+            390,
+            825,
+            474
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3.1 Pack and Unpack Attention ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            486,
+            406,
+            502
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "The key idea behind Luna is to decouple the regular attention function in (1) into two nested attention operations, both of which have linear efficiency. To achieve this, besides the original query and context input sequences, Luna introduces an extra input that is a sequence with fixed (constant) length. With this extra input as the query sequence, Luna uses its first attention, named pack attention, to pack the context sequence into a fixed-length sequence. Formally, let $P \\in \\mathbb { R } ^ { l \\times d }$ denote the extra input sequence with fixed length $l$ . The pack attention first packs $C$ to $Y _ { P }$ with $P$ as the query sequence: ",
+        "bbox": [
+            173,
+            508,
+            825,
+            593
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/4e65e5d2017981df12bfb1a5954d29798f0e90f73693103f5dae89b41de54380.jpg",
+        "text": "$$\nY _ { P } = \\mathrm { A t t n } ( P , C )\n$$",
+        "text_format": "latex",
+        "bbox": [
+            437,
+            599,
+            560,
+            616
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "where $\\mathrm { A t t n } ( \\cdot , \\cdot )$ is the regular attention function in (1), $C \\in \\mathbb { R } ^ { m \\times d }$ is the context sequence, and $Y _ { P } \\in \\mathbb { R } ^ { l \\times d }$ is the output of the pack attention, which is named the packed context. Since the length of $P$ is a constant $l$ , the complexity of pack attention is $O ( l m )$ , which is linear with respect to $m$ . ",
+        "bbox": [
+            174,
+            622,
+            825,
+            667
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "To unpack the sequence back to the length of the original query sequence $X$ , Luna leverages its second attention, named unpack attention: ",
+        "bbox": [
+            174,
+            672,
+            825,
+            702
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/ae55c6bf56ad6ed250873f5e0bdc150219594e576260dea12766f7783edfe34c.jpg",
+        "text": "$$\nY _ { X } = \\mathrm { A t t n } ( X , Y _ { P } )\n$$",
+        "text_format": "latex",
+        "bbox": [
+            431,
+            708,
+            566,
+            726
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "where $\\ b { X } \\in \\mathbb { R } ^ { n \\times d }$ is the original query sequence. Similar to pack attention, the complexity of unpack attention is $O ( l n )$ , which is also linear with repect to $n$ . ",
+        "bbox": [
+            174,
+            733,
+            825,
+            762
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Encoding Contextual Information in $P$ . The next question is where the extra input sequence $P$ comes from. One straightforward choice is to format $P$ as a learnable parameter of each Luna layer. One obvious drawback of this method, however, is that $P$ would not capture any contextual information. To enhance the capacity of the Luna model, we propose to formulate $Y _ { P }$ as an additional output of each Luna layer, corresponding to $P$ . Formally, the Luna attention function LunaAttn $( \\cdot , \\cdot , \\cdot )$ takes three sequences as input and generates two sequence as output: ",
+        "bbox": [
+            173,
+            768,
+            825,
+            853
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/09230833a3a1611d474490851049ba66488c57193e050bdae3fccae29869a5c8.jpg",
+        "text": "$$\nY _ { X } , Y _ { P } = \\operatorname { L u n a A t t n } ( X , P , C )\n$$",
+        "text_format": "latex",
+        "bbox": [
+            393,
+            859,
+            604,
+            876
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "where the computation of $Y _ { P }$ and $Y _ { X }$ is in (3) and (4). By stacking multiple layers of Luna attention, the output $Y _ { P }$ from the previous layer, which captures contextual information of $C$ , is employed as the input $P$ of the next layer. For the first layer of Luna, we formulate $P$ as learnable positional embeddings2 (Vaswani et al., 2017). ",
+        "bbox": [
+            173,
+            882,
+            825,
+            911
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            90,
+            823,
+            119
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Reducing the Number of Parameters. Due to the two nested attention operations, there are two sets of parameters $( W _ { Q }$ , $W _ { K }$ , $W _ { V } )$ ) in a single Luna attention function. There are several techniques to reduce the number of parameters, such as parameter sharing (Xia et al., 2019). In this work, we follow Wang et al. (2020) to share $W _ { K }$ and $W _ { Q }$ in each layer, and conduct experiments to analyze performance decline against Luna with full sets of parameters (§4.2). ",
+        "bbox": [
+            173,
+            127,
+            825,
+            198
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3.2 Luna Layers ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            214,
+            302,
+            229
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "The Luna attention is used as a drop-in-replacement for the regular attention. We incorporate the position-wise feed-forward network and layer normalization into Luna layers. Concretely, layer normalization is applied to both $Y _ { X }$ and $Y _ { P }$ , while FFN only to $Y _ { X }$ : ",
+        "bbox": [
+            174,
+            239,
+            825,
+            284
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/d95a5785aa5007bf6dceba668ec074737a3b6a2d37dd42310eb1191dbf080fba.jpg",
+        "text": "$$\n\\begin{array} { r c l } { Y _ { X } , Y _ { P } } & { = } & { \\operatorname { L u n a A t t n } ( X , P , C ) } \\\\ { X _ { A } , P _ { A } } & { = } & { \\operatorname { L a y e r N o r m } ( Y _ { X } + X ) , \\operatorname { L a y e r N o r m } ( Y _ { P } + P ) } \\\\ { X ^ { \\prime } , P ^ { \\prime } } & { = } & { \\operatorname { L a y e r N o r m } ( \\operatorname { F F N } ( X _ { A } ) + X _ { A } ) , P _ { A } } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            290,
+            289,
+            704,
+            337
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "where $X ^ { \\prime }$ and $P ^ { \\prime }$ are the two outputs of the Luna layer. The graphical specification of one Luna layer is illustrated in Figure 2. ",
+        "bbox": [
+            171,
+            343,
+            825,
+            372
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3.3 Luna Causal Attention ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            388,
+            372,
+            404
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "As discussed in Tay et al. (2020b), the ability to support causal autoregressive decoding, i.e. attending solely to the past and current tokens, is required when designing efficient self-attention mechanisms. However, due to the pack attention that packs the long sequence $X$ into a fixed (shorter) length, it is not straight-forward to support causal attention in Luna. ",
+        "bbox": [
+            174,
+            414,
+            826,
+            470
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "To design causal attention in Luna, we need to assume that the input $P$ contains no information of $X$ , i.e. $P$ will not leak any future information of $X$ to the history. Before we describe the Luna causal attention mechanism, we first define a causal function $f : \\mathbb { R } ^ { n \\times d _ { 1 } } \\times \\mathbb { R } ^ { n \\times d _ { 1 } } \\times \\mathbb { R } ^ { n \\times d _ { 2 } } \\to \\mathbb { R } ^ { n \\times d _ { 2 } }$ : ",
+        "bbox": [
+            173,
+            476,
+            825,
+            518
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/b4f8b25764c645e3a0a21b1bab7446f00f27cd65f51a5591ff3e6daa981b86ee.jpg",
+        "text": "$$\nF \\triangleq f ( X , Y , Z ) , { \\mathrm { ~ w h e r e ~ } } F _ { t } = { \\frac { 1 } { t } } X _ { t } \\sum _ { j = 1 } ^ { t } Y _ { j } ^ { T } Z _ { j }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            343,
+            525,
+            655,
+            570
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "where $F \\in \\mathbb { R } ^ { n \\times d _ { 2 } }$ and $F _ { t }$ denotes the $t { \\cdot }$ -th row of $F$ . From the definition of $f$ in (7), we see that $F _ { t }$ can only access the information of the past and present row of $X$ , $Y$ and $Z$ . ",
+        "bbox": [
+            171,
+            579,
+            823,
+            608
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "To perform Luna causal attention, we first compute the attention matrix of the pack attention: $A _ { p a c k } = \\omega ( P X ^ { T } / \\sqrt { d } )$ . For simplicity, we omit the learnable parameters, e.g. $W _ { Q } , \\ W _ { K } , \\ W _ { V }$ in (1). Note that for $A _ { p a c k }$ , we cannot use the softmax function for $\\omega$ , as the normalization term in softmax leaks future information of $X$ to the history. Inspired by the causal attention mechanism in Linear Transformer (Katharopoulos et al., 2020), we use two activation functions: 1) $\\omega ( \\cdot ) = \\mathrm { e l u } ( \\cdot ) + 1$ based on the exponential linear unit (Clevert et al., 2016); 2) $\\omega ( \\cdot ) = \\mathrm { s o f t p l u s } ( \\cdot )$ based on the softplus function (Glorot et al., 2011). With the causal function $f$ in (7), we compute the attention matrix of the unpack attention: $A _ { u n p a c k } = \\omega ( f ( X , X , A _ { p a c k } ^ { T } ) )$ . Unlike $A _ { p a c k }$ , we can use $\\omega ( \\cdot ) = \\mathrm { s o f t m a x } ( \\cdot )$ for $A _ { u n p a c k }$ , because the normalization is along the $l$ -dimension rather than the $n$ -dimension of $X$ . Finally, the output $\\mathrm { Y }$ is computed by $Y = f ( A _ { u n p a c k } , A _ { p a c k } ^ { T } , X )$ . ",
+        "bbox": [
+            173,
+            613,
+            826,
+            760
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "The complexity of the causal attention in Luna is still linear: $O ( l n )$ . One drawback of Luna causal attention, similar to the causal attention in Random Feature Attention (RFA) (Peng et al., 2021) and Linear Transformer (Katharopoulos et al., 2020), is its sequential computation for each timestep $t$ . ",
+        "bbox": [
+            174,
+            765,
+            823,
+            808
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "The sources of $P$ . In the formulation of causal attention, $P$ is expected to contain no information about $X$ . Thus, we need to formulate $P$ based on the usage mode of the causal attention. For the encoder-decoder mode in sequence-to-sequence modeling (e.g. for machine translation), we can use packed output from the Luna encoder as $P$ . For the decoder-only mode (e.g. for language modeling), $P$ might be formulated as a learnable parameter of each layer. ",
+        "bbox": [
+            174,
+            815,
+            825,
+            886
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "table",
+        "img_path": "images/38698b06b1fd768192a59c0fdcf08a83f562e60b16f84dff9c109f690ae66559.jpg",
+        "table_caption": [
+            "Table 1: Experimental results on the long range arena (LRA) benchmark. For Luna, we explore three projected dimensions: 16, 128 and 256. ‘Avg. (w/o rtl)’ denotes the averaged accuracy over all tasks excluding Retrieval. The performance of previous works are from Tay et al. (2021). "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Models</td><td>ListOps</td><td>Text</td><td>Retrieval</td><td>Image</td><td>Pathfinder</td><td>Avg.</td><td>Avg. (w/o rtl)</td></tr><tr><td>Transformer Transformer (re-impl)</td><td>36.37 37.11</td><td>64.27 65.21</td><td>57.46 79.14</td><td>42.44</td><td>71.40</td><td>54.39</td><td>53.62</td></tr><tr><td></td><td></td><td></td><td></td><td>42.94</td><td>71.83</td><td>59.24</td><td>54.27</td></tr><tr><td>Local Attention</td><td>15.82</td><td>52.98</td><td>53.39</td><td>41.46</td><td>66.63</td><td>46.06</td><td>44.22</td></tr><tr><td>Sparse Trans.</td><td>17.07</td><td>63.58</td><td>59.59</td><td>44.24</td><td>71.71</td><td>51.24</td><td>49.15</td></tr><tr><td>Longformer</td><td>35.63</td><td>62.85</td><td>56.89</td><td>42.22</td><td>69.71</td><td>53.46</td><td>52.60</td></tr><tr><td>Linformer</td><td>35.70</td><td>53.94</td><td>52.27</td><td>38.56</td><td>76.34</td><td>51.36</td><td>51.14</td></tr><tr><td>Reformer</td><td>37.27</td><td>56.10</td><td>53.40</td><td>38.07</td><td>68.50</td><td>50.67</td><td>49.99</td></tr><tr><td>Sinkhorn Trans.</td><td>33.67</td><td>61.20 61.68</td><td>53.83</td><td>41.23</td><td>67.45</td><td>51.39</td><td>50.89</td></tr><tr><td>Synthesizer</td><td>36.99 36.05</td><td>64.02</td><td>54.67</td><td>41.61</td><td>69.45</td><td>52.88</td><td>52.43</td></tr><tr><td>BigBird Linear Trans.</td><td>16.13</td><td>65.90</td><td>59.29 53.09</td><td>40.83 42.34</td><td>74.87 75.30</td><td>55.01</td><td>53.94</td></tr><tr><td>Performer</td><td>18.01</td><td>65.40</td><td>53.82</td><td>42.77</td><td>77.05</td><td>50.55 51.41</td><td>49.92</td></tr><tr><td></td><td>37.43</td><td></td><td></td><td></td><td></td><td></td><td>50.81</td></tr><tr><td>Luna-16</td><td>38.01</td><td>65.74 65.74</td><td>79.38 79.55</td><td>46.39</td><td>78.36</td><td>61.46</td><td>56.98</td></tr><tr><td>Luna-128</td><td>37.98</td><td></td><td></td><td>47.47</td><td>78.89</td><td>61.93</td><td>57.53</td></tr><tr><td>Luna-256</td><td></td><td>65.78</td><td>79.56</td><td>47.86</td><td>78.55</td><td>61.95</td><td>57.54</td></tr></table>",
+        "bbox": [
+            176,
+            150,
+            812,
+            381
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "3.4 Discussion ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            400,
+            287,
+            414
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Relation to Linformer and Shared Workspace. One previous work closely related to Luna is Linformer (Wang et al., 2019). Linformer linearly projects the context sequence $C \\in \\mathbb { R } ^ { m \\times d }$ into a sequence with fixed length $l$ : $C ^ { \\prime } = E C$ , where $\\dot { C } ^ { \\prime } \\in \\mathbf { \\mathbb { R } } ^ { l \\times d }$ is the projected context sequence and $E \\in \\mathbb { R } ^ { l \\times m }$ is the learnable projection matrix of each layer. Then, the attention operation is applied on the query $X$ and the projected context $C ^ { \\prime }$ . The pack attention in Luna is a generalization of the linear projection in Linformer. There are two main advantages to Luna over Linformer: i) with pack attention as the projection method, Luna is able to model sequences with various lengths. In contrast, Linformer requires the length of all input sequences to be the same $m$ , due to the projection matrix $E$ , whose shape depends on $m$ . ii) Luna achieves better expressiveness than Linear, not only due to the general projection method but also by encoding adequate contextual information into the projection via $P$ (see $\\ S 3 . 1 \\ r .$ ). Experimental improvements over non-contextual projection demonstrate the effectiveness of Luna (see $\\ S 4 . 2 )$ . In contemporaneous and individual work, Goyal et al. (2021) formulate contextual $p$ as a shared global workspace, which shares similar instantiation with Luna. ",
+        "bbox": [
+            173,
+            424,
+            825,
+            604
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Relation to Set Transformer. The additional input $P$ in Luna can be regarded as a side memory module that can access the entire sequence to gather contextual information. From this view of point, Luna is also closely related to Set Transformer (Lee et al., 2019), an early model to integrate side memory module in Transformers. Similar to the projection matrix in Linformer, the inducing points in Set Transformer are learnable parameters. Thus, these inducing points might be formulated as the non-contextual version of $P$ in Luna. Moreover, Set Transformer is designed for set-input problems, which are problems wherein the input is a set of features and the model is thereby invariant to permutation or ordering of the input features (Tay et al., 2020b), while Luna attention is used as a drop-in replacement for regular softmax attention. ",
+        "bbox": [
+            174,
+            612,
+            825,
+            738
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "4 Experiments ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            757,
+            312,
+            775
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "4.1 Long-Context Sequence Modeling ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            787,
+            449,
+            804
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "We evaluate the effectiveness and efficiency of Luna on the Long Range Arena (LRA) benchmark recently introduced by Tay et al. (2021), which is designed for the purpose of evaluating efficient Transformer models under the long-context scenario. They collect five tasks in this benchmark which are ListOps (Nangia and Bowman, 2018), byte-level text classification (Text; Maas et al., 2011), byte-level document retrieval (Retrieval; Radev et al., 2013), image classification on sequences of pixels (Image; Krizhevsky et al., 2009) and Pathfinder (Linsley et al., 2018). These tasks consist of input sequences ranging from 1K to 8K tokens and span across a variety of data types and modalities. ",
+        "bbox": [
+            174,
+            814,
+            825,
+            911
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "table",
+        "img_path": "images/c5ca3ca84e9e89114c1df9a2bb1344a86ef2427693718b4c95a1ff12a0ad8007.jpg",
+        "table_caption": [
+            "Table 2: Training speed and peak memory consumption comparison of different models on byte-level text classification with various input lengths (1K, 2K, 3K and 4K). The best model is in boldface. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Model</td><td colspan=\"4\"> Steps per second 个</td><td colspan=\"4\">Peak Memory Usage (GB)↓</td></tr><tr><td>Transformer</td><td>1K 1.0</td><td>2K 1.0</td><td>3K 1.0</td><td>4K</td><td>1K 1.00</td><td>2K 1.00</td><td>3K 1.00</td><td>4K 1.00</td></tr><tr><td></td><td></td><td></td><td></td><td>1.0</td><td></td><td></td><td></td><td></td></tr><tr><td>Local Attention</td><td>1.1</td><td>1.7</td><td>3.2</td><td>5.3</td><td>0.49</td><td>0.29</td><td>0.19</td><td>0.14</td></tr><tr><td>Linformer Reformer</td><td>1.2</td><td>1.9</td><td>3.7</td><td>5.5</td><td>0.44</td><td>0.21</td><td>0.18</td><td>0.10</td></tr><tr><td>Sinkhorn Trans</td><td>0.5 1.1</td><td>0.4 1.6</td><td>0.7</td><td>0.8</td><td>0.56 0.55</td><td>0.37 0.31</td><td>0.28</td><td>0.24 0.16</td></tr><tr><td>Synthesizer</td><td>1.1</td><td>1.2</td><td>2.9</td><td>3.8</td><td>0.76</td><td></td><td>0.21</td><td>0.74</td></tr><tr><td>BigBird</td><td></td><td>0.8</td><td>2.9</td><td>1.4 1.1</td><td></td><td>0.75</td><td>0.74</td><td>0.30</td></tr><tr><td>Linear Trans.</td><td>0.9</td><td>1.9</td><td>1.2</td><td>5.6</td><td>0.91 0.44</td><td>0.56</td><td>0.40</td><td>0.11</td></tr><tr><td>Performer</td><td>1.1 1.2</td><td>1.9</td><td>3.7 3.8</td><td>5.7</td><td>0.44</td><td>0.22 0.22</td><td>0.15 0.15</td><td>0.11</td></tr><tr><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td></tr><tr><td>Luna-16</td><td>1.2</td><td>1.8</td><td>3.7</td><td>5.5</td><td>0.44 0.49</td><td>0.23</td><td>0.17</td><td>0.10</td></tr><tr><td>Luna-128</td><td>1.1</td><td>1.7</td><td>3.4</td><td>5.1</td><td></td><td>0.28</td><td>0.21</td><td>0.14</td></tr><tr><td>Luna-256</td><td>1.1</td><td>1.7</td><td>3.3</td><td>4.9</td><td>0.60</td><td>0.33</td><td>0.23</td><td>0.16</td></tr></table>",
+        "bbox": [
+            250,
+            136,
+            743,
+            358
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "To ensure fair comparisons, for all tasks except for the task Retrieval, we closely follow the model configurations in Tay et al. (2021) such as data preprocessing, data split, model architecture, etc. For the task of Retrieval, we find that models are not fully converged when being trained for 5K steps as stated in Tay et al. (2021). Therefore, we train models for 20K steps for this task and obtain much better results. For a direct comparison, besides the average performance of models across all tasks, we also report the average accuracy on tasks excluding Retrieval. We run each experiment for five times with different random seeds and report the average accuracy. The hyper-parameters for each task are shown in Appendix A.1. ",
+        "bbox": [
+            173,
+            377,
+            825,
+            489
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Results. The results of various models on the LRA benchmark are presented in Table 1. For our proposed method, we report results from models of three different projected dimensions (16, 128 and 256). First, we note that Luna achieves good results on all tasks consistently compared to the Transformer model and significantly outperforms all the other baseline methods in terms of the average accuracy. By taking a closer look at the accuracy for each individual task, Luna wins over baseline models on three out of five tasks and performs comparably with the best performed model on the other two tasks, i.e. ListOps and byte-level text classification. Notably, Luna improves over the Transformer model on image classification and pathfinder by a large margin. Second, we observe that although Luna achieves the best average performance with a projection dimension of 256, it also performs considerably well with smaller projection dimensions (16 and 128). This demonstrates the effectiveness of Luna even with small projected dimensions. ",
+        "bbox": [
+            174,
+            497,
+            825,
+            650
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Memory and Speed Efficiency. Luna employs two nested linear attention functions to reduce the time and memory complexity compared to the vanilla softmax attention. Here, we examine the speed and memory footprint of various models with varying input lengths (1K, 2K, 3K and 4K). Following Tay et al. (2021), all models are evaluated on the byte-level classification task with the same batch size. The result is shown in Table 2. ",
+        "bbox": [
+            174,
+            657,
+            825,
+            727
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Considering the memory efficiency, Luna with a projected dimension of 16 is highly memoryefficient, which is only $10 \\%$ of the vanilla Transformer at 4K input sequence length. With larger projected dimensions, i.e. 128 and 256, Luna requires more memory but is still competitive compared to other efficient Transformer models. In terms of time efficiency, Luna-16 speeds up over the standard Transformer by 1.2-5.5 times, varying by the sequence length. Compared to other efficient Transformers, Luna-16 performs comparably with the fastest models, i.e. Performer and Linformer. Overall, our models achieve competitive advantage both in time- and memory-efficiency over other models, while attaining the best performance on the LRA benchmark (see Figure 1). ",
+        "bbox": [
+            173,
+            733,
+            825,
+            844
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "In addition, we plot the trade-off among memory, time and averaged LRA score without task Retrieval in Figure 1. Models such as Linformer and Performer have faster speed and small memory requirement with the sacrifice of performance. However, besides competitive time- and memory-efficiency, Luna models retain superior performance even with a small projected dimension $\\left( l { = } 1 6 \\right)$ . ",
+        "bbox": [
+            174,
+            851,
+            823,
+            906
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Contextual information in $P$ of Luna. Recently, a popular method to model the classification task using Transformerbased models is to prepend a special symbol, [CLS], to every input example. The last hidden state of this symbol is regarded as the aggregate sequence representation. In Luna, we introduce an extra model input $P$ which not only allows us to efficiently compute the attention mechanism but learn contextual information as well. Theoretically, the $P$ from the ",
+        "bbox": [
+            174,
+            92,
+            441,
+            257
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "table",
+        "img_path": "images/7c11532fa781dcfac49f1f40ae28d150b0d52815dcf7838ee5826d7b013278db.jpg",
+        "table_caption": [
+            "Table 3: Performance comparison of two sentence representation methods on LRA benchmark. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Models</td><td>ListOps</td><td>Text</td><td>Retrieval</td><td>Avg.</td></tr><tr><td>Luna-16,[CLS]</td><td>37.43</td><td>65.74</td><td>79.38</td><td>60.85</td></tr><tr><td>Luna-16, P</td><td>38.06</td><td>65.81</td><td>80.22</td><td>61.36</td></tr><tr><td>Luna-128, [CLS]</td><td>38.01</td><td>65.74</td><td>79.55</td><td>61.10</td></tr><tr><td>Luna-128,P</td><td>38.27</td><td>65.89</td><td>80.27</td><td>61.48</td></tr><tr><td>Luna-256, [CLS]</td><td>37.98</td><td>65.78</td><td>79.56</td><td>61.11</td></tr><tr><td>Luna-256, P</td><td>38.36</td><td>66.07</td><td>80.25</td><td>61.56</td></tr></table>",
+        "bbox": [
+            452,
+            128,
+            823,
+            247
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "last layer is capable of learning the representation of the input sequence. To validate this, we extract $P$ at the last layer and employ the mean pooling strategy over positions to obtain the final feature for classification. We test its performance on three long-text modeling tasks in LRA (Tay et al., 2021), i.e., ListOps, Text and Retrieval and report results in Table 3. We find that $P$ -based methods obtain better scores across all tasks against the [CLS]-based one, validating the powerful ability of $P$ to encode contextual information of the input sequence. ",
+        "bbox": [
+            174,
+            257,
+            825,
+            340
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "4.2 Machine translation ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            358,
+            352,
+            372
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "To evaluate Luna on sequence-to-sequence modeling, we conduct experiments on a standard machine translation benchmark, i.e. WMT’14 English-German $\\mathbf { E N } {  } \\mathbf { D E }$ ) dataset (4.5M sentence pairs). The data split and preprocessing steps follow those of Vaswani et al. (2017), using the scripts from FairSeq (Ott et al., 2019). We share the source and target vocabularies within the language pair, with 37K byte pair encoding (BPE) types (Sennrich et al., 2016). The Luna models closely follow the architecture of Transformer-base: 6 encoder and decoder layers with 8 attention heads and $d _ { \\mathrm { m o d e l } } / d _ { \\mathrm { h i d d e n } } = 5 1 2 / 2 0 4 8$ . We train the Transformer-base model with two optimization methods: Adam (Kingma and Ba, 2015) and ",
+        "bbox": [
+            174,
+            385,
+            485,
+            604
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "table",
+        "img_path": "images/997603d0798504b29125f0c817529806bfb6d185bb208cef17a1bb71820e0639.jpg",
+        "table_caption": [
+            "Table 4: Test BLEU on WMT’14 EN DE. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Model</td><td>BLEU</td><td> # Param.</td></tr><tr><td>Transformer-base (Adam) Transformer-base (Apollo)</td><td>27.8</td><td>64.9M</td></tr><tr><td>RFA (k = 256)</td><td>28.3 27.2</td><td>64.9M 66.2M</td></tr><tr><td>Luna-16, elu, tied kv Luna-32,elu, tied kv</td><td>27.1 27.3</td><td>69.6M 69.7M</td></tr><tr><td>Luna-16,softplus, tied kv Luna-32, softplus, tied kv</td><td>27.3 27.5</td><td>69.6M 69.7M</td></tr><tr><td>Luna-16, elu</td><td>27.4</td><td>77.5M</td></tr><tr><td>Luna-32, elu</td><td>27.6</td><td></td></tr><tr><td></td><td></td><td>77.6M</td></tr><tr><td>Luna-16, softplus Luna-32, softplus</td><td>27.6 27.8</td><td>77.5M</td></tr></table>",
+        "bbox": [
+            498,
+            409,
+            815,
+            598
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Apollo (Ma, 2020), and find Apollo achieves better performance. Therefore, we use Apollo as the optimizer for all Luna models. For each experiment, we conduct distributed training across eight NVIDIA Tesla V100 GPUs with maximum batch size of 8192 tokens per GPU. Further details are provided in Appendix A.2. ",
+        "bbox": [
+            174,
+            604,
+            825,
+            660
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Results. Table 4 presents the results of Luna on the test set BLEU scores of WMT’ $1 4 \\mathrm { E N } {  } \\mathrm { D E }$ , along with Transformer-base and Random Feature Attention (RFA) as baselines. Different from Peng et al. (2021) where the random feature attention is applied only to decoders, the RFA model in Table 4 applies random feature attention in both the encoder and decoder for a fair comparison. $k = 2 5 6$ is the number of feature maps in RFA. For Luna, we report performance of models with different projected lengths: $l = 1 6$ and $l = 3 2$ , different activation functions in (7): $\\mathrm { e l u } ( \\cdot ) + 1$ and softplus $( \\cdot )$ , and w./w.o parameter sharing. ",
+        "bbox": [
+            173,
+            670,
+            825,
+            767
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "From Table 4, the first observation is that softplus $( \\cdot )$ consistently outperforms $\\mathrm { e l u } ( \\cdot ) + 1$ . Thus, we use softplus $( \\cdot )$ as the default activation function in the implementation. Another interesting observation is that Luna with a small projected length $( l = 1 6$ ) obtains similar performance to RFA with $k = 2 5 6$ feature maps. Luna with $l = 3 2$ achieves competitive performance, but still falls behind the Transformer-base model. Further improving the machine translation performance of Luna is left to future work. We also report the number of parameters of different models. At last, we evaluate Luna w./w.o parameter sharing. Although there are two sets of parameters in a single Luna attention function $( W _ { Q } , \\ W _ { K } , \\ W _ { V } )$ , as mentioned in $\\ S 3 . 1$ , we tie $W _ { k }$ with $W _ { v }$ to reduce the number of parameters, and the performance decline is marginal. As a result, Luna with shared parameters has $7 \\%$ and $5 \\%$ more parameters compared to the vanilla Transformer and RFA models. ",
+        "bbox": [
+            173,
+            772,
+            825,
+            911
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Effect of Encoding Contextual Information into $P$ . As discussed in $\\ S 3 . 4$ , one advantage of Luna against Linformer is to incorporate contextual $P$ by formulating it as an extra input. To investigate the importance of this design, we conduct experiments on WMT’14 to compare Luna with the baseline model where $P$ is formulated as a non-contextual learnable parameter of each layer. ",
+        "bbox": [
+            174,
+            92,
+            594,
+            174
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "table",
+        "img_path": "images/b0442e8973e28a1065cdd7d3f66e788635340615ac8a5dcee4d947e74bb85106.jpg",
+        "table_caption": [
+            "Table 5: Dev and Test BLEU "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Model</td><td>Dev.</td><td>Test</td></tr><tr><td>Non-Contextual</td><td>24.4</td><td>25.2</td></tr><tr><td>Contextual</td><td>25.9</td><td>27.3</td></tr></table>",
+        "bbox": [
+            606,
+            116,
+            816,
+            171
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "For both the contextual and non-contextual models, we train Luna with $l = 1 6$ , parameter sharing and softplus. Table 5 lists the BLEU scores on the development and test sets. Luna with contextual $P$ significantly outperforms the baseline with non-contextual $P$ , demonstrating the effectiveness of this design in Luna. ",
+        "bbox": [
+            174,
+            174,
+            826,
+            229
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "4.3 Masked Language Modeling for Large-Scale Pretraining ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            246,
+            607,
+            261
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "One popular application of Transformer is to pretrain a large-scale language model on a large amount of data which can then be fine-tuned on a wide range of downstream tasks, such as BERT (Devlin et al., 2019), RoBERTa (Liu et al., 2019), etc. Therefore, we pretrain a Luna-based language model with RoBERTa-base model configuration on two versions of data as our pretraining set: 1) BERT version with BookCorpus (Zhu et al., 2015) and English Wikipedia (totally 16GB), 2) RoBERTa version with BookCorpus, English Wikipedia, CC-News (Nagel, 2016), OpenWebText (Gokaslan and Cohen, 2019) and Stories (Trinh and Le, 2018) (totally 160GB). For Luna models, we set $l = 1 2 8$ . On the larger training corpus (160GB), we train models w./w.o parameter sharing, respectively. We compare our models with RoBERTa-base, BERT-base and Linformer which are trained on the same training data. Experimental details are provided in Appendix A.3. ",
+        "bbox": [
+            173,
+            271,
+            825,
+            410
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Finetuning Luna After obtaining the pretrained Luna-based language model, we finetune it on various natural language processing tasks, including sentiment classification (SST-2; Socher et al., 2013), natural language inference (QNLI; Rajpurkar et al., 2016), textual similarity (QQP; Chen et al., 2018, question answering (RACE (Lai et al., 2017) and CommonsenseQA (CSQA; Talmor et al., 2019). For GLUE tasks, following Liu et al. (2019), we consider a limited hyperparameter sweep for each task, with batch sizes $\\in \\{ 1 6 , 3 2 \\}$ and learning rate $\\in \\{ 5 e ^ { - 6 } , 1 e ^ { - 5 } , \\dot { 2 } e ^ { - 5 } \\}$ , with a linear warmup for the first $6 \\%$ of steps followed by a linear decay to 0. Finetuning is performed for 20 epochs with early stopping based on each task’s evaluation metric on the dev set3. For QA tasks, we concatenate each candidate answer with the corresponding question and passage. We then encode every candidate and pass the [CLS] output at the last layer through a fully-connected layer, which is used to predict the correct answer. We truncate question-answer pairs that are longer than 128 tokens and, if needed, the passage so that the total length is at most 512 tokens. Following Liu et al. (2019), we try a small range of possible values for hyperparameters, i.e., batch size $\\in \\left\\{ 1 6 , 3 2 \\right\\}$ , learning rate $\\bar { \\in } \\{ 1 e ^ { - 5 } , 2 e ^ { - 5 } , 3 e ^ { - 5 } \\}$ and dropout $\\in \\{ 0 . \\dot { 0 } , 0 . \\dot { 1 } , 0 . 2 \\}$ . For other configurations such as warm-up steps, optimizer, we follow thoses in Liu et al. (2019). ",
+        "bbox": [
+            174,
+            416,
+            825,
+            625
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "The result is reported in Table 6. We observe that on the smaller dataset (16GB) our Luna model has similar or slightly better downstream results compared to other pretrained language models. On QNLI and SST-2, Luna models obtain the best performance among all models, reaffirming the effectiveness of Luna in pre-training. This demonstrates the strong ability of Luna for language representations. On the larger dataset (160GB), however, the performance of Luna is slightly worse than RoBERTa with vanilla Transformer architecture. One possible reason is that the capacity of Luna is not as sufficient as vanilla Transformer, due to the efficient attention mechanism. This is supported by the evidence that Luna with full sets of parameters achieves better performance than that with parameter-sharing, because Luna with full sets of parameters has better capacity. ",
+        "bbox": [
+            174,
+            631,
+            825,
+            756
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "5 Related Work ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            773,
+            321,
+            791
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "There has been signficiant prior work on improving the efficiency of Transformers, besides the three closely related works discussed in $\\ S 3 . 4$ . The common techniques include, but are not limited to, weight sharing (Dehghani et al., 2018), quantization (Shen et al., 2020; Fan et al., 2020), sparse attention (Parmar et al., 2018; Kitaev et al., 2020), side memory module (Lee et al., 2019; Gupta and Berant, 2020; Goyal et al., 2021), and low-rank or compressed context (Wang et al., 2019; Ainslie et al., 2020). In this section, we briefly review some recently proposed methods. For a detailed overview we refer the readers to Tay et al. (2020b). ",
+        "bbox": [
+            173,
+            805,
+            825,
+            876
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "table",
+        "img_path": "images/e4870d06b9215a8518d1c4e1f450f7bb9caa42a926549d2688eb896be46d6d1d.jpg",
+        "table_caption": [
+            "Table 6: Performance of various models on development set of benchmark natural language understanding tasks. Bold face indicates best performance. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=\"2\">Model</td><td rowspan=\"2\">data</td><td colspan=\"3\">GLUE</td><td colspan=\"2\">QA</td></tr><tr><td>SST-2</td><td>QNLI</td><td>QQP</td><td>RACE</td><td>CSQA</td></tr><tr><td>BERT-base</td><td>16GB</td><td>92.7</td><td>88.4</td><td>89.6</td><td>64.2</td><td>53.3</td></tr><tr><td>RoBERTa-base</td><td>16GB</td><td>93.1</td><td>90.9</td><td>90.9</td><td>65.6</td><td>-</td></tr><tr><td>Linformer-128</td><td>16GB</td><td>92.4</td><td>90.4</td><td>90.2</td><td>1</td><td>1</td></tr><tr><td>Luna-128, tied kv</td><td>16GB</td><td>93.1</td><td>91.2</td><td>90.8</td><td>65.2</td><td>53.1</td></tr><tr><td>RoBERTa-base</td><td>160GB</td><td>94.8</td><td>92.8</td><td>91.9</td><td>73.50</td><td>63.61</td></tr><tr><td>Luna-128, tied kv</td><td>160GB</td><td>94.3</td><td>91.5</td><td>91.2</td><td>71.50</td><td>61.48</td></tr><tr><td>Luna-128</td><td>160GB</td><td>94.6</td><td>92.2</td><td>91.3</td><td>72.25</td><td>62.08</td></tr></table>",
+        "bbox": [
+            245,
+            136,
+            748,
+            282
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            304,
+            825,
+            333
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Sparse Attention The general idea of these methods is that, instead of attending to the whole sequence, each token only access to a fixed, predefined range such as local neighborhoods and strided or “dilated” windows. Popular methods include local attention (Parmar et al., 2018), blockwise attention (Qiu et al., 2019), strided attention patterns (Child et al., 2019; Beltagy et al., 2020), and compressed attention (Liu et al., 2018). To make this range more flexible, Reformer (Kitaev et al., 2020) employs a hash-based similarity measure to efficiently cluster tokens into chunks and Routing Transformer(Roy et al., 2021) employ online $\\mathbf { k }$ -means clustering on the tokens. The Sinkhorn sorting Network (Tay et al., 2020a) exposes the sparsity in attention weights by learning to sort blocks of the input sequence. ",
+        "bbox": [
+            174,
+            349,
+            825,
+            474
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Kernel Methods. A recently popular method to improve the efficiency of Transformers is to avoid explicitly computing the $m \\times n$ attention matrix $A$ in (1) by re-writing it with kernels. Typical models leveraging kernelization are Linear Transformer (Katharopoulos et al., 2020), Performer (Choromanski et al., 2020) and Random Feature Attention (Peng et al., 2021). Since kernels are a form of approximation of the attention matrix, they can be also viewed as a form of low-rank method (Choromanski et al., 2020) that compresses the context to a shorter length, such as Linformer (Wang et al., 2019) and the proposed Luna model. ",
+        "bbox": [
+            174,
+            492,
+            826,
+            589
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Recurrence. The simplest technique to reduce the complexity of Transformer is to chunk input sequences into fixed blocks, with the obvious disadvantage of losing contextual information from past chunks. As discussed in Tay et al. (2020b), these models can be regarded as fixed pattern models. Transformer-XL (Dai et al., 2019) proposed a natural extension to the blockwise method to connect these blocks via a recurrence mechanism. Compressive Transformer (Rae et al., 2020) further extends Transformer-XL by maintaining a fine-grained memory of past chunk activations, which are discarded in Transformer-XL. Technically, Luna can be adapted to a recurrence method, by simply using $P$ as an inherent memory module to maintain the recurrence across segments. ",
+        "bbox": [
+            174,
+            606,
+            825,
+            718
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "6 Conclusion ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            739,
+            299,
+            757
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "We have introduced Luna, a simple, efficient and effective linear attention mechanism used as a drop-in substitute for regular softmax attention. By introducing an extra input with the fixed length, Luna is capable of capturing adequate contextual information while performing attention operations linearly. On three sequence modeling tasks, i.e., long-context sequence modeling, neural machine translation, and large-scale pretraining and finetuning, Luna achieves comparable or even better performance than a variety of strong baselines, while acquiring prominent gains of efficiency in both speed and memory. In future work, we are interested in combining Luna with recurrence methods where $P$ can be used as a running memory across segments of inputs. Another interesting direction would be to apply Luna to other tasks with long input sequences, such as document-level summarization and translation. ",
+        "bbox": [
+            174,
+            772,
+            825,
+            911
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Acknowledgments and Disclosure of Funding ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            88,
+            553,
+            107
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "This material is based on research sponsored by Air Force Research Laboratory (AFRL) under agreement number FA8750-19-1-1000. The U.S. Government is authorized to reproduce and distribute reprints for Government purposes notwithstanding any copyright notation therein. Xiang Kong was supported by U.S. DARPA AIDA Program No. FA8750-18-2-0014. The views and conclusions contained herein are those of the authors and should not be interpreted as necessarily representing the official policies or endorsements, either expressed or implied, of Air Force Laboratory, DARPA or the U.S. Government. ",
+        "bbox": [
+            174,
+            121,
+            826,
+            218
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "References ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            238,
+            266,
+            255
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Joshua Ainslie, Santiago Ontanon, Chris Alberti, Vaclav Cvicek, Zachary Fisher, Philip Pham, Anirudh Ravula, Sumit Sanghai, Qifan Wang, and Li Yang. Etc: Encoding long and structured inputs in transformers. In Proceedings of the 2020 Conference on Empirical Methods in Natural Language Processing (EMNLP), pages 268–284, 2020.   \nJimmy Lei Ba, Jamie Ryan Kiros, and Geoffrey E Hinton. Layer normalization. arXiv preprint arXiv:1607.06450, 2016.   \nDzmitry Bahdanau, Kyunghyun Cho, and Yoshua Bengio. Neural machine translation by jointly learning to align and translate. In International Conference on Learning Representations (ICLR), 2015.   \nIz Beltagy, Matthew E Peters, and Arman Cohan. Longformer: The long-document transformer. arXiv preprint arXiv:2004.05150, 2020.   \nZihan Chen, Hongbo Zhang, Xiaoji Zhang, and Leqi Zhao. Quora question pairs. University of Waterloo, 2018.   \nRewon Child, Scott Gray, Alec Radford, and Ilya Sutskever. Generating long sequences with sparse transformers. arXiv preprint arXiv:1904.10509, 2019.   \nKrzysztof Choromanski, Valerii Likhosherstov, David Dohan, Xingyou Song, Andreea Gane, Tamas Sarlos, Peter Hawkins, Jared Davis, Afroz Mohiuddin, Lukasz Kaiser, et al. Rethinking attention with performers. arXiv preprint arXiv:2009.14794, 2020.   \nDjork-Arné Clevert, Thomas Unterthiner, and Sepp Hochreiter. Fast and accurate deep network learning by exponential linear units (elus). In International Conference on Learning Representations (ICLR), 2016.   \nZihang Dai, Zhilin Yang, Yiming Yang, Jaime G Carbonell, Quoc Le, and Ruslan Salakhutdinov. Transformer-xl: Attentive language models beyond a fixed-length context. In Proceedings of the 57th Annual Meeting of the Association for Computational Linguistics, pages 2978–2988, 2019.   \nMostafa Dehghani, Stephan Gouws, Oriol Vinyals, Jakob Uszkoreit, and Lukasz Kaiser. Universal transformers. In International Conference on Learning Representations (ICLR), 2018.   \nJacob Devlin, Ming-Wei Chang, Kenton Lee, and Kristina Toutanova. Bert: Pre-training of deep bidirectional transformers for language understanding. In Proceedings of the 2019 Conference of the North American Chapter of the Association for Computational Linguistics: Human Language Technologies, Volume 1 (Long and Short Papers), pages 4171–4186, 2019.   \nAlexey Dosovitskiy, Lucas Beyer, Alexander Kolesnikov, Dirk Weissenborn, Xiaohua Zhai, Thomas Unterthiner, Mostafa Dehghani, Matthias Minderer, Georg Heigold, Sylvain Gelly, et al. An image is worth 16x16 words: Transformers for image recognition at scale. arXiv preprint arXiv:2010.11929, 2020.   \nAngela Fan, Pierre Stock, Benjamin Graham, Edouard Grave, Remi Gribonval, Herve Jegou, and Armand Joulin. Training with quantization noise for extreme fixed-point compression. arXiv preprint arXiv:2004.07320, 2020. ",
+        "bbox": [
+            171,
+            252,
+            828,
+            917
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Xavier Glorot, Antoine Bordes, and Yoshua Bengio. Deep sparse rectifier neural networks. In Proceedings of the fourteenth international conference on artificial intelligence and statistics, pages 315–323. JMLR Workshop and Conference Proceedings, 2011. ",
+        "bbox": [
+            174,
+            90,
+            823,
+            133
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Aaron Gokaslan and Vanya Cohen. Openwebtext corpus. URl: https://skylion007. github. io/OpenWebTextCorpus, 2019. ",
+        "bbox": [
+            169,
+            141,
+            825,
+            170
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Anirudh Goyal, Aniket Didolkar, Alex Lamb, Kartikeya Badola, Nan Rosemary Ke, Nasim Rahaman, Jonathan Binas, Charles Blundell, Michael Mozer, and Yoshua Bengio. Coordination among neural modules through a shared global workspace. arXiv preprint arXiv:2103.01197, 2021. ",
+        "bbox": [
+            174,
+            178,
+            825,
+            222
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Ankit Gupta and Jonathan Berant. Gmat: Global memory augmentation for transformers. arXiv preprint arXiv:2006.03274, 2020. ",
+        "bbox": [
+            169,
+            228,
+            823,
+            257
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Angelos Katharopoulos, Apoorv Vyas, Nikolaos Pappas, and François Fleuret. Transformers are rnns: Fast autoregressive transformers with linear attention. In International Conference on Machine Learning, pages 5156–5165. PMLR, 2020. ",
+        "bbox": [
+            174,
+            266,
+            825,
+            309
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Diederik P Kingma and Jimmy Ba. Adam: A method for stochastic optimization. In International Conference on Learning Representations, 2015. ",
+        "bbox": [
+            171,
+            316,
+            825,
+            345
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Nikita Kitaev, Łukasz Kaiser, and Anselm Levskaya. Reformer: The efficient transformer. arXiv preprint arXiv:2001.04451, 2020. ",
+        "bbox": [
+            171,
+            353,
+            825,
+            382
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Alex Krizhevsky et al. Learning multiple layers of features from tiny images. Technical Report. University of Toronto, 2009. ",
+        "bbox": [
+            171,
+            390,
+            823,
+            419
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Guokun Lai, Qizhe Xie, Hanxiao Liu, Yiming Yang, and Eduard Hovy. Race: Large-scale reading comprehension dataset from examinations. In Proceedings of the 2017 Conference on Empirical Methods in Natural Language Processing, pages 785–794, 2017. ",
+        "bbox": [
+            174,
+            426,
+            823,
+            470
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Juho Lee, Yoonho Lee, Jungtaek Kim, Adam Kosiorek, Seungjin Choi, and Yee Whye Teh. Set transformer: A framework for attention-based permutation-invariant neural networks. In International Conference on Machine Learning, pages 3744–3753. PMLR, 2019. ",
+        "bbox": [
+            176,
+            477,
+            823,
+            521
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Drew Linsley, Junkyung Kim, Vijay Veerabadran, Charles Windolf, and Thomas Serre. Learning long-range spatial dependencies with horizontal gated recurrent units. In S. Bengio, H. Wallach, H. Larochelle, K. Grauman, N. Cesa-Bianchi, and R. Garnett, editors, Advances in Neural Information Processing Systems, volume 31. Curran Associates, Inc., 2018. URL https://proceedings.neurips.cc/paper/2018/file/ec8956637a99787bd197eacd77acce5e-Paper.pdf. ",
+        "bbox": [
+            173,
+            527,
+            825,
+            598
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Peter J Liu, Mohammad Saleh, Etienne Pot, Ben Goodrich, Ryan Sepassi, Lukasz Kaiser, and Noam Shazeer. Generating wikipedia by summarizing long sequences. In International Conference on Learning Representations (ICLR), 2018. ",
+        "bbox": [
+            176,
+            606,
+            823,
+            650
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Yinhan Liu, Myle Ott, Naman Goyal, Jingfei Du, Mandar Joshi, Danqi Chen, Omer Levy, Mike Lewis, Luke Zettlemoyer, and Veselin Stoyanov. Roberta: A robustly optimized bert pretraining approach. arXiv preprint arXiv:1907.11692, 2019. ",
+        "bbox": [
+            174,
+            656,
+            826,
+            700
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Ilya Loshchilov and Frank Hutter. Decoupled weight decay regularization. In International Conference on Learning Representations, 2019. ",
+        "bbox": [
+            174,
+            708,
+            823,
+            737
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Xuezhe Ma. Apollo: An adaptive parameter-wise diagonal quasi-newton method for nonconvex stochastic optimization. arXiv preprint arXiv:2009.13586, 2020. ",
+        "bbox": [
+            173,
+            744,
+            823,
+            773
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Andrew Maas, Raymond E Daly, Peter T Pham, Dan Huang, Andrew Y Ng, and Christopher Potts. Learning word vectors for sentiment analysis. In Proceedings of the 49th annual meeting of the association for computational linguistics: Human language technologies, pages 142–150, 2011. ",
+        "bbox": [
+            173,
+            781,
+            825,
+            825
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Ali Madani, Bryan McCann, Nikhil Naik, Nitish Shirish Keskar, Namrata Anand, Raphael R Eguchi, Possu Huang, and Richard Socher. Progen: Language modeling for protein generation. bioRxiv, 2020. ",
+        "bbox": [
+            174,
+            832,
+            825,
+            876
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Sebastian Nagel. Cc-news. URL: http://web. archive. org/save/http://commoncrawl. org/2016/10/newsdatasetavailable, 2016. ",
+        "bbox": [
+            176,
+            882,
+            821,
+            911
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Nikita Nangia and Samuel Bowman. Listops: A diagnostic dataset for latent tree learning. In Proceedings of the 2018 Conference of the North American Chapter of the Association for Computational Linguistics: Student Research Workshop, pages 92–99, 2018. ",
+        "bbox": [
+            176,
+            90,
+            825,
+            133
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Myle Ott, Sergey Edunov, David Grangier, and Michael Auli. Scaling neural machine translation. In Proceedings of the Third Conference on Machine Translation: Research Papers, pages 1–9, 2018. ",
+        "bbox": [
+            171,
+            141,
+            826,
+            171
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Myle Ott, Sergey Edunov, Alexei Baevski, Angela Fan, Sam Gross, Nathan Ng, David Grangier, and Michael Auli. fairseq: A fast, extensible toolkit for sequence modeling. In Proceedings of NAACL-HLT 2019: Demonstrations, 2019. ",
+        "bbox": [
+            174,
+            179,
+            825,
+            222
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Niki Parmar, Ashish Vaswani, Jakob Uszkoreit, Lukasz Kaiser, Noam Shazeer, Alexander Ku, and Dustin Tran. Image transformer. In International Conference on Machine Learning, pages 4055–4064. PMLR, 2018. ",
+        "bbox": [
+            174,
+            229,
+            825,
+            273
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Hao Peng, Nikolaos Pappas, Dani Yogatama, Roy Schwartz, Noah Smith, and Lingpeng Kong. Random feature attention. In International Conference on Learning Representations, 2021. URL https://openreview.net/forum?id $=$ QtTKTdVrFBB. ",
+        "bbox": [
+            173,
+            281,
+            826,
+            325
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Jiezhong Qiu, Hao Ma, Omer Levy, Scott Wen-tau Yih, Sinong Wang, and Jie Tang. Blockwise self-attention for long document understanding. arXiv preprint arXiv:1911.02972, 2019. ",
+        "bbox": [
+            173,
+            333,
+            823,
+            363
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Dragomir R Radev, Pradeep Muthukrishnan, Vahed Qazvinian, and Amjad Abu-Jbara. The acl anthology network corpus. Language Resources and Evaluation, 47(4):919–944, 2013. ",
+        "bbox": [
+            173,
+            369,
+            823,
+            400
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Jack W Rae, Anna Potapenko, Siddhant M Jayakumar, Chloe Hillier, and Timothy P Lillicrap. Compressive transformers for long-range sequence modeling. In International Conference on Learning Representations (ICLR), 2020. ",
+        "bbox": [
+            173,
+            407,
+            825,
+            450
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Pranav Rajpurkar, Jian Zhang, Konstantin Lopyrev, and Percy Liang. Squad: $^ { 1 0 0 , 0 0 0 + }$ questions for machine comprehension of text. In Proceedings of the 2016 Conference on Empirical Methods in Natural Language Processing, pages 2383–2392, 2016. ",
+        "bbox": [
+            174,
+            459,
+            826,
+            502
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Aurko Roy, Mohammad Saffar, Ashish Vaswani, and David Grangier. Efficient content-based sparse attention with routing transformers. Transactions of the Association for Computational Linguistics, 9:53–68, 2021. ",
+        "bbox": [
+            174,
+            510,
+            826,
+            553
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Rico Sennrich, Barry Haddow, and Alexandra Birch. Neural machine translation of rare words with subword units. In Proceedings of the 54th Annual Meeting of the Association for Computational Linguistics (Volume 1: Long Papers), pages 1715–1725, 2016. ",
+        "bbox": [
+            173,
+            560,
+            826,
+            604
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Sheng Shen, Zhen Dong, Jiayu Ye, Linjian Ma, Zhewei Yao, Amir Gholami, Michael W Mahoney, and Kurt Keutzer. Q-bert: Hessian based ultra low precision quantization of bert. In Proceedings of the AAAI Conference on Artificial Intelligence, volume 34, pages 8815–8821, 2020. ",
+        "bbox": [
+            173,
+            612,
+            825,
+            656
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Richard Socher, Alex Perelygin, Jean Wu, Jason Chuang, Christopher D Manning, Andrew $\\mathrm { \\Delta Y N g }$ , and Christopher Potts. Recursive deep models for semantic compositionality over a sentiment treebank. In Proceedings of the 2013 conference on empirical methods in natural language processing, pages 1631–1642, 2013. ",
+        "bbox": [
+            174,
+            664,
+            826,
+            719
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Christian Szegedy, Vincent Vanhoucke, Sergey Ioffe, Jon Shlens, and Zbigniew Wojna. Rethinking the inception architecture for computer vision. In Proceedings of the IEEE conference on computer vision and pattern recognition, pages 2818–2826, 2016. ",
+        "bbox": [
+            173,
+            728,
+            823,
+            772
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Alon Talmor, Jonathan Herzig, Nicholas Lourie, and Jonathan Berant. Commonsenseqa: A question answering challenge targeting commonsense knowledge. In Proceedings of the 2019 Conference of the North American Chapter of the Association for Computational Linguistics: Human Language Technologies, Volume 1 (Long and Short Papers), pages 4149–4158, 2019. ",
+        "bbox": [
+            173,
+            780,
+            826,
+            837
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Yi Tay, Dara Bahri, Liu Yang, Donald Metzler, and Da-Cheng Juan. Sparse sinkhorn attention. In International Conference on Machine Learning, pages 9438–9447. PMLR, 2020a. ",
+        "bbox": [
+            173,
+            844,
+            821,
+            875
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Yi Tay, Mostafa Dehghani, Dara Bahri, and Donald Metzler. Efficient transformers: A survey. arXiv preprint arXiv:2009.06732, 2020b. ",
+        "bbox": [
+            176,
+            882,
+            821,
+            911
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Yi Tay, Mostafa Dehghani, Samira Abnar, Yikang Shen, Dara Bahri, Philip Pham, Jinfeng Rao, Liu Yang, Sebastian Ruder, and Donald Metzler. Long range arena : A benchmark for efficient transformers. In International Conference on Learning Representations, 2021. URL https: //openreview.net/forum?id=qVyeW-grC2k.   \nTrieu H Trinh and Quoc V Le. A simple method for commonsense reasoning. arXiv preprint arXiv:1806.02847, 2018.   \nAshish 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, pages 5998–6008, 2017.   \nAshish Vaswani, Samy Bengio, Eugene Brevdo, Francois Chollet, Aidan Gomez, Stephan Gouws, Llion Jones, Łukasz Kaiser, Nal Kalchbrenner, Niki Parmar, et al. Tensor2tensor for neural machine translation. In Proceedings of the 13th Conference of the Association for Machine Translation in the Americas (Volume 1: Research Track), pages 193–199, 2018.   \nQiang Wang, Bei Li, Tong Xiao, Jingbo Zhu, Changliang Li, Derek F Wong, and Lidia S Chao. Learning deep transformer models for machine translation. In Proceedings of the 57th Annual Meeting of the Association for Computational Linguistics, pages 1810–1822, 2019.   \nSinong Wang, Belinda Li, Madian Khabsa, Han Fang, and Hao Ma. Linformer: Self-attention with linear complexity. arXiv preprint arXiv:2006.04768, 2020.   \nYingce Xia, Tianyu He, Xu Tan, Fei Tian, Di He, and Tao Qin. Tied transformers: Neural machine translation with shared encoder and decoder. In Proceedings of the AAAI Conference on Artificial Intelligence, volume 33, pages 5466–5473, 2019.   \nRuibin Xiong, Yunchang Yang, Di He, Kai Zheng, Shuxin Zheng, Chen Xing, Huishuai Zhang, Yanyan Lan, Liwei Wang, and Tieyan Liu. On layer normalization in the transformer architecture. In International Conference on Machine Learning, pages 10524–10533. PMLR, 2020.   \nYukun Zhu, Ryan Kiros, Rich Zemel, Ruslan Salakhutdinov, Raquel Urtasun, Antonio Torralba, and Sanja Fidler. Aligning books and movies: Towards story-like visual explanations by watching movies and reading books. In Proceedings of the IEEE international conference on computer vision, pages 19–27, 2015. ",
+        "bbox": [
+            169,
+            90,
+            826,
+            565
+        ],
+        "page_idx": 12
+    }
+]

parse/train/rkecl1rtwB/rkecl1rtwB.md

@@ -0,0 +1,320 @@
+# PAIRNORM: TACKLING OVERSMOOTHING IN GNNS
+
+Lingxiao Zhao Carnegie Mellon University Pittsburgh, PA 15213, USA {lingxia1}@andrew.cmu.edu
+
+Leman Akoglu Carnegie Mellon University Pittsburgh, PA 15213, USA {lakoglu}@andrew.cmu.edu
+
+# ABSTRACT
+
+The performance of graph neural nets (GNNs) is known to gradually decrease with increasing number of layers. This decay is partly attributed to oversmoothing, where repeated graph convolutions eventually make node embeddings indistinguishable. We take a closer look at two different interpretations, aiming to quantify oversmoothing. Our main contribution is PAIRNORM, a novel normalization layer that is based on a careful analysis of the graph convolution operator, which prevents all node embeddings from becoming too similar. What is more, PAIRNORM is fast, easy to implement without any change to network architecture nor any additional parameters, and is broadly applicable to any GNN. Experiments on real-world graphs demonstrate that PAIRNORM makes deeper GCN, GAT, and SGC models more robust against oversmoothing, and significantly boosts performance for a new problem setting that benefits from deeper GNNs. Code is available at https://github.com/LingxiaoShawn/PairNorm.
+
+# 1 INTRODUCTION
+
+Graph neural networks (GNNs) is a family of neural networks that can learn from graph structured data. Starting with the success of GCN (Kipf & Welling, 2017) on achieving state-of-the-art performance on semi-supervised classification, several variants of GNNs have been developed for this task; including GraphSAGE (Hamilton et al., 2017), GAT (Velickovic et al., 2018), SGC (Wu et al., 2019), and GMNN (Qu et al., 2019) to name a few most recent ones.
+
+A key issue with GNNs is their depth limitations. It has been observed that deeply stacking the layers often results in significant drops in performance for GNNs, such as GCN and GAT, even beyond just a few (2–4) layers. This drop is associated with a number of factors; including the vanishing gradients in back-propagation, overfitting due to the increasing number of parameters, as well as the phenomenon called oversmoothing. Li et al. (2018) was the first to call attention to the oversmoothing problem. Having shown that the graph convolution is a type of Laplacian smoothing, they proved that after repeatedly applying Laplacian smoothing many times, the features of the nodes in the (connected) graph would converge to similar values—the issue coined as “oversmoothing”. In effect, oversmoothing hurts classification performance by causing the node representations to be indistinguishable across different classes. Later, several others have alluded to the same problem (Xu et al., 2018; Klicpera et al., 2019; Rong et al., 2019; Li et al., 2019) (See §5 Related Work).
+
+In this work, we address the oversmoothing problem in deep GNNs. Specifically, we propose (to the best of our knowledge) the first normalization layer for GNNs that is applied in-between intermediate layers during training. Our normalization has the effect of preventing the output features of distant nodes to be too similar or indistinguishable, while at the same time allowing those of connected nodes in the same cluster become more similar. We summarize our main contributions as follows.
+
+• Normalization to Tackle Oversmoothing in GNNs: We introduce a normalization scheme, called PAIRNORM, that makes GNNs significantly more robust to oversmoothing and as a result enables the training of deeper models without sacrificing performance. Our proposed scheme capitalizes on the understanding that most GNNs perform a special form of Laplacian smoothing, which makes node features more similar to one another. The key idea is to ensure that the total pairwise feature distances remains a constant across layers, which in turn leads to distant pairs having less similar features, preventing feature mixing across clusters.
+
+• Speed and Generality: PAIRNORM is very straightforward to implement and introduces no additional parameters. It is simply applied to the output features of each layer (except the last one) consisting of simple operations, in particular centering and scaling, that are linear in the input size. Being a simple normalization step between layers, PAIRNORM is not specific to any particular GNN but rather applies broadly.
+
+• Use Case for Deeper GNNs: While PAIRNORM prevents performance from dropping significantly with increasing number of layers, it does not necessarily yield increased performance in absolute terms. We find that this is because shallow architectures with no more than 2–4 layers is sufficient for the often-used benchmark datasets in the literature. In response, we motivate a real-world scenario wherein a notable portion of the nodes have no feature vectors. In such settings, nodes benefit from a larger range (i.e., neighborhood, hence a deeper GNN) to “recover” effective feature representations. Through extensive experiments, we show that GNNs employing our PAIRNORM significantly outperform the ‘vanilla’ GNNs when deeper models are beneficial to the classification task.
+
+# 2 UNDERSTANDING OVERSMOOTHING
+
+In this work, we consider the semi-supervised node classification (SSNC) problem on a graph. In the general setting, a graph $\mathcal { G } = ( \nu , \mathcal { E } , \mathbf { X } )$ is given in which each node $i \in \mathcal V$ is associated with a feature vector $\mathbf { x } _ { i } \in \mathbb { R } ^ { \breve { d } }$ where $\mathbf { X } = [ \mathbf { x } _ { 1 } , \ldots , \mathbf { x } _ { n } ] ^ { T }$ denotes the feature matrix, and a subset $\nu _ { l } \subset \nu$ of the nodes are labeled, i.e. $y _ { i } \in \{ 1 , \ldots , c \}$ for each $i \in \mathcal { V } _ { l }$ where $c$ is the number of classes. Let $\mathbf { A } \in \mathbb { R } ^ { n \times n }$ be the adjacency matrix and $\mathbf { D } = \mathrm { d i a g } ( d e g _ { 1 } , \dots , d e g _ { n } ) \in \mathbb { R } ^ { n \times n }$ be the degree matrix of $\mathcal { G }$ . Let $\tilde { \mathbf { A } } = \mathbf { A } + \mathbf { I }$ and $\tilde { \mathbf { D } } = \mathbf { D } + \mathbf { I }$ denote the augmented adjacency and degree matrices with added self-loops on all nodes, respectively. Let $\tilde { \mathbf { A } } _ { \mathrm { s y m } } = \tilde { \mathbf { D } } ^ { - 1 / 2 } \tilde { \mathbf { A } } \tilde { \mathbf { D } } ^ { - 1 / 2 }$ and $\tilde { \mathbf { A } } _ { \mathrm { r w } } = \tilde { \mathbf { D } } ^ { - 1 } \tilde { \mathbf { A } }$ denote symmetrically and nonsymmetrically normalized adjacency matrices with self-loops.
+
+The task is to learn a hypothesis that predicts $y _ { i }$ from $\mathbf { x } _ { i }$ that generalizes to the unlabeled nodes $\mathcal { V } _ { u } = \mathcal { V } \backslash \mathcal { V } _ { l }$ . In Section 3.2, we introduce a variant of this setting where only a subset $\mathcal { F } \subset \mathcal { V }$ of the nodes have feature vectors and the rest are missing.
+
+# 2.1 THE OVERSMOOTHING PROBLEM
+
+Although GNNs like GCN and GAT achieve state-of-the-art results in a variety of graph-based tasks, these models are not very well-understood, especially why they work for the SSNC problem where only a small amount of training data is available. The success appears to be limited to shallow GNNs, where the performance gradually decreases with the increasing number of layers. This decrease is often attributed to three contributing factors: (1) overfitting due to increasing number of parameters, (2) difficulty of training due to vanishing gradients, and (3) oversmoothing due to many graph convolutions.
+
+Among these, perhaps the least understood one is oversmoothing, which indeed lacks a formal definition. In their analysis of GCN’s working mechanism, Li et al. (2018) showed that the graph convolution of GCN is a special form of Laplacian smoothing. The standard form being $( { \bf I } - \gamma { \bf I } ) { \bf X } +$ $\gamma \tilde { \mathbf { A } } _ { \mathrm { r w } } \mathbf { X }$ , the graph convolution lets $\gamma = 1$ and uses the symmetrically normalized Laplacian to obtain $\begin{array} { r } { \tilde { \mathbf { X } } = \bar { \hat { \mathbf { A } } } _ { \mathrm { s y m } } \mathbf { \bar { X } } } \end{array}$ , where the new features $\tilde { \bf x }$ of a node is the weighted average of its own and its neighbors’ features. This smoothing allows the node representations within the same cluster become more similar, and in turn helps improve SSNC performance under the cluster assumption (Chapelle et al., 2006). However when GCN goes deep, the performance can suffer from oversmoothing where node representations from different clusters become mixed up. Let us refer to this issue of node representations becoming too similar as node-wise oversmoothing.
+
+Another way of thinking about oversmoothing is as follows. Repeatedly applying Laplacian smoothing too many times would drive node features to a stationary point, washing away all the information from these features. Let $\mathbf { x } _ { \cdot j } \in \mathbb { R } ^ { n }$ denote the $j$ -th column of $\mathbf { X }$ . Then, for any $\mathbf { x } _ { \cdot j } \in \mathbb { R } ^ { n }$ :
+
+$$
+\operatorname* { l i m } _ { k \to \infty } \tilde { \mathbf { A } } _ { \mathrm { s y m } } ^ { k } \mathbf { x } _ { \cdot j } = \pi _ { j } \quad \mathrm { a n d } \quad \frac { \pi _ { j } } { \| \pi _ { j } \| _ { 1 } } = \pi \ ,
+$$
+
+where the normalized solution $\pi \in \mathbb { R } ^ { n }$ satisfies $\begin{array} { r } { \pi _ { i } = \frac { \sqrt { d e g _ { i } } } { \sum _ { i } \sqrt { d e g _ { i } } } } \end{array}$ for all $i \in [ n ]$ . Notice that $\pi$ is independent of the values $\mathbf { x } _ { \cdot j }$ of the input feature and is only a function of the graph structure (i.e., degree). In other words, (Laplacian) oversmoothing washes away the signal from all the features, making them indistinguishable. We will refer to this viewpoint as feature-wise oversmoothing.
+
+To this end we propose two measures, row-diff and col-diff, to quantify these two types of oversmoothing. Let $\bar { \mathbf { H } } ^ { ( k ) } \in \mathbb { R } ^ { n \times d }$ be the representation matrix after $k$ graph convolutions, i.e. $\mathbf { H } ^ { ( k ) } = \tilde { \mathbf { A } } _ { \mathrm { s y m } } ^ { k } \mathbf { X }$ . Let $\mathbf { h } _ { i } ^ { ( k ) } \in \mathbb { R } ^ { d }$ be the $i$ -th row of $\mathbf { H } ^ { ( k ) }$ and $\mathbf { h } _ { . i } ^ { ( k ) } \in \mathbb { R } ^ { n }$ be the $i$ -th column of $\mathbf { H } ^ { ( k ) }$ . Then we define row-diff $( \mathbf { H } ^ { ( k ) } )$ and col-diff $( \mathbf { H } ^ { ( k ) } )$ as follows.
+
+$$
+\mathrm { r o w } \mathrm { - } \mathrm { d i f f } ( { \bf H } ^ { ( k ) } ) = \frac { 1 } { n ^ { 2 } } \sum _ { i , j \in [ n ] } \left\| { \bf h } _ { i } ^ { ( k ) } - { \bf h } _ { j } ^ { ( k ) } \right\| _ { 2 }
+$$
+
+$$
+\mathrm { c o l - d i f f } ( \mathbf { H } ^ { ( k ) } ) = \frac { 1 } { d ^ { 2 } } \sum _ { i , j \in [ d ] } \left\| \mathbf { h } _ { \cdot i } ^ { ( k ) } / \| \mathbf { h } _ { \cdot i } ^ { ( k ) } \| _ { 1 } - \mathbf { h } _ { \cdot j } ^ { ( k ) } / \| \mathbf { h } _ { \cdot j } ^ { ( k ) } \| _ { 1 } \right\| _ { 2 }
+$$
+
+The row-diff measure is the average of all pairwise distances between the node features (i.e., rows of the representation matrix) and quantifies node-wise oversmoothing, whereas col-diff is the average of pairwise distances between $L _ { 1 }$ -normalized1) columns of the representation matrix and quantifies feature-wise oversmoothing.
+
+# 2.2 STUDYING OVERSMOOTHING WITH SGC
+
+Although oversmoothing can be a cause of performance drop with increasing number of layers in GCN, adding more layers also leads to more parameters (due to learned linear projections $\mathbf { W } ^ { ( k ) }$ at each layer $k$ ) which magnify the potential of overfitting. Furthermore, deeper models also make the training harder as backpropagation suffers from vanishing gradients.
+
+In order to decouple the effect of oversmoothing from these other two factors, we study the oversmoothing problem using the SGC model (Wu et al., 2019). (Results on other GNNs are presented in $\ S 4 .$ ) SGC is simplified from GCN by removing all projection parameters of graph convolution layers and all nonlinear activations between layers. The estimation of SGC is simply written as:
+
+$$
+\widehat { \pmb { Y } } = \mathrm { s o f t m a x } ( \tilde { \bf A } _ { \mathrm { s y m } } ^ { K } \pmb { X } \pmb { W } )
+$$
+
+where $K$ is the number of graph convolutions, and $\mathbf { W } \in \mathbb { R } ^ { d \times c }$ denote the learnable parameters of a logistic regression classifier.
+
+Note that SGC has a fixed number of parameters that does not depend on the number of graph convolutions (i.e. layers). In effect, it is guarded against the influence of overfitting and vanishing gradient problem with more layers. This leaves us only with oversmoothing as a possible cause of performance degradation with increasing $K$ . Interestingly, the simplicity of SGC does not seem to be a sacrifice; it has been observed that it achieves similar or better accuracy in various relational classification tasks (Wu et al., 2019).
+
+![](images/e056fc17fa24311b801e0f4522c2a7c33f2c12d1537a95d34e7c694479f35e62.jpg)  
+Figure 1: (best in color) SGC’s performance (dashed lines) with increasing graph convolutions $( K )$ on Cora dataset (train/val/test split is $3 \% / 1 0 \% / 8 7 \% )$ ). For each $K$ , we train SGC in 500 epochs, save the model with the best validation accuracy, and report all measures based on the saved model. Measures row-diff and col-diff are computed based on the final layer representation of the saved model. (Solid lines depict after applying our method PAIRNORM, which we discuss in $\ S 3 . 2 .$ )
+
+Dashed lines in Figure 1 illustrate the performance of SGC on the Cora dataset as we increase the number of layers $( K )$ . The training (cross-entropy) loss monotonically increases with larger $K$ , potentially because graph convolution mixes node representations with their neighbors’ and makes them less distinguishable (training becomes harder). On the other hand, graph convolutions (i.e., smoothing) improve generalization ability, reducing the gap between training and validation/test loss up to $K = 4$ , after which (over)smoothing begins to hurt performance. The row-diff and col-diff both continue decreasing monotonically with $K$ , providing supporting evidence for oversmoothing.
+
+# 3 TACKLING OVERSMOOTHING
+
+# 3.1 PROPOSED PAIRNORM
+
+We start by establishing a connection between graph convolution and an optimization problem, that is graph-regularized least squares (GRLS), as shown by NT $\&$ Maehara (2019). Let $\bar { \mathbf { X } } \in \mathbb { R } ^ { n \times d }$ be a new node representation matrix, with $\bar { \mathbf { x } } _ { i } \in \mathbb { R } ^ { d }$ depicting the $i$ -th row of $\bar { \bf X }$ . Then the GRLS problem is given as
+
+$$
+\underset { \bar { \mathbf { X } } } { \mathrm { m i n } } \sum _ { i \in \mathcal { V } } \| \bar { \mathbf { x } } _ { i } - \mathbf { x } _ { i } \| _ { \bar { \mathbf { D } } } ^ { 2 } + \sum _ { ( i , j ) \in \mathcal { E } } \| \bar { \mathbf { x } } _ { i } - \bar { \mathbf { x } } _ { j } \| _ { 2 } ^ { 2 }
+$$
+
+where $\| \mathbf { z } _ { i } \| _ { \tilde { \mathbf { D } } } ^ { 2 } = \mathbf { z } _ { i } ^ { T } \tilde { \mathbf { D } } \mathbf { z } _ { i }$ . The first term can be seen as total degree-weighted least squares. The second is a graph-regularization term that measures the variation of the new features over the graph structure. The goal of the optimization problem can be stated as estimating new “denoised” features $\bar { \mathbf { x } } _ { i }$ ’s that are not too far off of the input features $\mathbf { x } _ { i }$ ’s and are smooth over the graph structure.
+
+The GRLS problem has a closed form solution $\bar { \mathbf { X } } = ( 2 \mathbf { I } - \tilde { \mathbf { A } } _ { \mathrm { r w } } ) ^ { - 1 } \mathbf { X }$ , for which $\tilde { \mathbf { A } } _ { \mathrm { r w } } \mathbf { X }$ is the firstorder Taylor approximation, that is $\tilde { \mathbf { A } } _ { \mathrm { r w } } \mathbf { X } \approx \bar { \mathbf { X } }$ . By exchanging $\tilde { \mathbf { A } } _ { \mathrm { r w } }$ with $\tilde { \mathbf { A } } _ { \mathrm { s y m } }$ we obtain the same form as the graph convolution, i.e., $\tilde { \mathbf { X } } = \tilde { \mathbf { A } } _ { \mathrm { s y m } } \mathbf { X } \approx \bar { \mathbf { X } }$ . As such, graph convolution can be viewed as an approximate solution of (5), where it minimizes the variation over the graph structure while keeping the new representations close to the original.
+
+The optimization problem in (5) facilitates a closer look to the oversmoothing problem of graph convolution. Ideally, we want to obtain smoothing over nodes within the same cluster, however avoid smoothing over nodes from different clusters. The objective in (5) dictates only the first goal via the graph-regularization term. It is thus prone to oversmoothing when convolutions are applied repeatedly. To circumvent the issue and fulfill both goals simultaneously, we can add a negative term such as the sum of distances between disconnected pairs as follows.
+
+$$
+\operatorname* { m i n } _ { \bar { \mathbf { X } } } \sum _ { i \in \mathcal { V } } \| \bar { \mathbf { x } } _ { i } - \mathbf { x } _ { i } \| _ { \bar { \mathbf { D } } } ^ { 2 } + \sum _ { ( i , j ) \in \mathcal { E } } \| \bar { \mathbf { x } } _ { i } - \bar { \mathbf { x } } _ { j } \| _ { 2 } ^ { 2 } - \lambda \sum _ { ( i , j ) \notin \mathcal { E } } \| \bar { \mathbf { x } } _ { i } - \bar { \mathbf { x } } _ { j } \| _ { 2 } ^ { 2 }
+$$
+
+where $\lambda$ is a balancing scalar to account for different volume and importance of the two goals.2 By deriving the closed-form solution of (6) and approximating it with first-order Taylor expansion, one can get a revised graph convolution operator with hyperparameter $\lambda$ . In this paper, we take a different route. Instead of a completely new graph convolution operator, we propose a general and efficient “patch”, called PAIRNORM, that can be applied to any form of graph convolution having the potential of oversmoothing.
+
+Let $\tilde { \mathbf { X } }$ (the output of graph convolution) and $\dot { \bf X }$ respectively be the input and output of PAIRNORM. Observing that the output of graph convolution $\begin{array} { r } { \tilde { \mathbf { X } } = \tilde { \mathbf { A } } _ { \mathrm { s y m } } \tilde { \mathbf { X } } } \end{array}$ only achieves the first goal, PAIRNORM serves as a normalization layer that works on $\tilde { \mathbf { X } }$ to achieve the second goal of keeping disconnected pair representations farther off. Specifically, PAIRNORM normalizes $\bar { \bar { \mathbf { X } } }$ such that the total pairwise squared distance $\begin{array} { r } { \mathrm { T P S D } ( \dot { \mathbf { X } } ) : = \bar { \sum _ { i , j \in [ n ] } } \| \dot { \mathbf { x } } _ { i } - \dot { \mathbf { x } } _ { j } \| _ { 2 } ^ { 2 } } \end{array}$ is the same as $\mathrm { T P S D } ( \mathbf { X } )$ . That is,
+
+$$
+\sum _ { ( i , j ) \in \mathcal { E } } \| \dot { \mathbf { x } } _ { i } - \dot { \mathbf { x } } _ { j } \| _ { 2 } ^ { 2 } + \sum _ { ( i , j ) \not \in \mathcal { E } } \| \dot { \mathbf { x } } _ { i } - \dot { \mathbf { x } } _ { j } \| _ { 2 } ^ { 2 } = \sum _ { ( i , j ) \in \mathcal { E } } \| { \mathbf { x } } _ { i } - { \mathbf { x } } _ { j } \| _ { 2 } ^ { 2 } + \sum _ { ( i , j ) \not \in \mathcal { E } } \| { \mathbf { x } } _ { i } - { \mathbf { x } } _ { j } \| _ { 2 } ^ { 2 } .
+$$
+
+By keeping the total pairwise squared distance unchanged, the term $\begin{array} { r } { \sum _ { ( i , j ) \notin \mathcal { E } } \| \dot { \mathbf { x } } _ { i } - \dot { \mathbf { x } } _ { j } \| _ { 2 } ^ { 2 } } \end{array}$ is guaranteed to be at least as large as the original value $\begin{array} { r } { \sum _ { ( i , j ) \notin \mathcal { E } } \| \mathbf { x } _ { i } - \mathbf { x } _ { j } \| _ { 2 } ^ { 2 } } \end{array}$ since the other term $\begin{array} { r } { \sum _ { ( i , j ) \in \mathcal { E } } \| \dot { \bf x } _ { i } - \dot { \bf x } _ { j } \| _ { 2 } ^ { 2 } \approx \sum _ { ( i , j ) \in \mathcal { E } } \| \tilde { \bf x } _ { i } - \tilde { \bf x } _ { j } \| _ { 2 } ^ { 2 } } \end{array}$ is shrunk through the graph convolution.
+
+In practice, instead of always tracking the original value $\mathrm { T P S D } ( \mathbf { X } )$ , we can maintain a constant TPSD value $C$ across all layers, where $C$ is a hyperparameter that could be tuned per dataset.
+
+To normalize $\tilde { \mathbf { X } }$ to constant TPSD, we need to first compute $\mathrm { T P S D } ( \tilde { \mathbf { X } } )$ . Directly computing TPSD involves $n ^ { 2 }$ pairwise distances that is $\mathcal { O } ( n ^ { 2 } d )$ , which can be time consuming for large datasets.
+
+Equivalently, normalization can be done via a two-step approach where TPSD is rewritten as3
+
+$$
+\begin{array} { r c l } { \mathrm { T P S D } ( \tilde { \mathbf { X } } ) } & { = } & { \displaystyle \sum _ { i , j \in [ n ] } \| \tilde { \mathbf { x } } _ { i } - \tilde { \mathbf { x } } _ { j } \| _ { 2 } ^ { 2 } } & { = } & { \displaystyle 2 n ^ { 2 } \bigg ( \frac { 1 } { n } \sum _ { i = 1 } ^ { n } \| \tilde { \mathbf { x } } _ { i } \| _ { 2 } ^ { 2 } - \| \frac { 1 } { n } \sum _ { i = 1 } ^ { n } \tilde { \mathbf { x } } _ { i } \| _ { 2 } ^ { 2 } \bigg ) ~ . } \end{array}
+$$
+
+The first term (ignoring the scale $2 n ^ { 2 }$ ) in Eq. (8) represents the mean squared length of node representations, and the second term depicts the squared length of the mean of node representations. To simplify the computation of (8), we subtract the row-wise mean from each $\widetilde { \mathbf { x } } _ { i }$ , i.e., $\begin{array} { r } { \tilde { \mathbf { x } } _ { i } ^ { c } = \tilde { \mathbf { x } } _ { i } - \frac { 1 } { n } \sum _ { i } ^ { n } \tilde { \mathbf { x } } _ { i } ^ { \cdot } } \end{array}$ where $\tilde { \mathbf { x } } _ { i } ^ { c }$ denotes the centered representation. Note that this shifting does not affect the TPSD, and furthermore drives the term $\begin{array} { r } { \| \frac { 1 } { n } \sum _ { i = 1 } ^ { n } \tilde { \mathbf { x } } _ { i } \| _ { 2 } ^ { 2 } } \end{array}$ to zero, where computing $\mathrm { T P S D } ( \tilde { \mathbf { X } } )$ boils down to calculating the squared Frobenius norm of $\tilde { \mathbf { X } } ^ { c }$ and overall takes $\mathcal { O } ( n d )$ . That is,
+
+In summary, our proposed PAIRNORM (with input $\tilde { \mathbf { X } }$ and output $\dot { \bf X }$ ) can be written as a two-step, center-and-scale, normalization procedure:
+
+$$
+\begin{array} { l } { \displaystyle \widetilde { \mathbf { x } } _ { i } ^ { c } = \widetilde { \mathbf { x } } _ { i } - \frac { 1 } { n } \sum _ { i = 1 } ^ { n } \widetilde { \mathbf { x } } _ { i } } \\ { \displaystyle \dot { \mathbf { x } } _ { i } = s \cdot \frac { \widetilde { \mathbf { x } } _ { i } ^ { c } } { \sqrt { \frac { 1 } { n } \sum _ { i = 1 } ^ { n } \| \widetilde { \mathbf { x } } _ { i } ^ { c } \| _ { 2 } ^ { 2 } } } = s \sqrt { n } \cdot \frac { \widetilde { \mathbf { x } } _ { i } ^ { c } } { \sqrt { \| \widetilde { \mathbf { X } } ^ { c } \| _ { F } ^ { 2 } } } } \end{array}
+$$
+
+After scaling the data remains centered, that is, $\begin{array} { r } { \| \sum _ { i = 1 } ^ { n } \dot { \bf x } _ { i } \| _ { 2 } ^ { 2 } = 0 } \end{array}$ . In Eq. (11), $s$ is a hyperparameter that determines $C$ . Specifically,
+
+$$
+\mathrm { T P S D } ( { \dot { \mathbf { X } } } ) = 2 n \| { \dot { \mathbf { X } } } \| _ { F } ^ { 2 } = 2 n \sum _ { i } \| s \cdot { \frac { { \tilde { \mathbf { x } } } _ { i } ^ { c } } { \sqrt { { \frac { 1 } { n } } \sum _ { i } \| { \tilde { \mathbf { x } } } _ { i } ^ { c } \| _ { 2 } ^ { 2 } } } } \| _ { 2 } ^ { 2 } = 2 n { \frac { s ^ { 2 } } { { \frac { 1 } { n } } \sum _ { i } \| { \tilde { \mathbf { x } } } _ { i } ^ { c } \| _ { 2 } ^ { 2 } } } \sum _ { i } \| { \tilde { \mathbf { x } } } _ { i } ^ { c } \| _ { 2 } ^ { 2 } = 2 n ^ { 2 } s ^ { 2 }
+$$
+
+Then, $\dot { \mathbf { X } } : = \operatorname { P A I R N O R M } ( \tilde { \mathbf { X } } )$ has row-wise mean 0 (i.e., is centered) and constant total pairwise squared distance $C = 2 n ^ { 2 } s ^ { 2 }$ . An illustration of PAIRNORM is given in Figure 2. The output of PAIRNORM is input to the next convolution layer.
+
+![](images/2ff10cf2c9b16a85d50a14972c75e76d008f98564f6afd7d7414e2f0a2e29a43.jpg)  
+Figure 2: Illustration of PAIRNORM, comprising centering and rescaling steps.
+
+We also derive a variant of PAIRNORM by replacing Pni=1 $\textstyle \sum _ { i = 1 } ^ { n } \| \tilde { \mathbf { x } } _ { i } ^ { c } \| _ { 2 } ^ { 2 }$ in Eq. (11) with $n \| \tilde { \mathbf { x } } _ { i } ^ { c } \| _ { 2 } ^ { 2 }$ , such that the scaling step computes $\begin{array} { r l r } { \dot { \bf x } _ { i } } & { { } = } & { s } \end{array}$ $\frac { \tilde { \mathbf { x } } _ { i } ^ { c } } { \| \tilde { \mathbf { x } } _ { i } ^ { c } \| _ { 2 } }$ . We call it PAIRNORM-SI (for Scale Individually), which imposes more restriction on node representations, such that all have the same $L _ { 2 }$ -norm s. In practice we found that both PAIRNORM and PAIRNORM-SI work well for SGC, whereas PAIRNORM-SI provides better and more stable results for GCN and
+
+![](images/b9b02294bb59dc6d8e0bda469d7e4ba2d7b2027c3126730591eccadd3fd0a7e2.jpg)  
+Figure 3: (best in color) Performance comparison of the original (dashed) vs. PAIRNORM-enhanced (solid) GCN and GAT models with increasing layers on Cora.
+
+GAT. The reason why GCN and GAT require stricter normalization may be because they have more parameters and are more prone to overfitting. In Appx. A.6 we provide additional measures to demonstrate why PAIRNORM and PAIRNORM-SI work. In all experiments, we employ PAIRNORM for SGC and PAIRNORM-SI for both GCN and GAT.
+
+PAIRNORM is effective and efficient in solving the oversmoothing problem of GNNs. As a general normalization layer, it can be used for any GNN. Solid lines in Figure 1 present the performance of SGC on Cora with increasing number of layers, where we employ PAIRNORM after each graph convolution layer, as compared to ‘vanilla’ versions. Similarly, Figure 3 is for GCN and GAT (PAIRNORM is applied after the activation of each graph convolution). Note that the performance decay with PAIRNORM-at-work is much slower. (See Fig.s 5–6 in Appx. A.3 for other datasets.)
+
+While PAIRNORM enables deeper models that are more robust to oversmoothing, it may seem odd that the overall test accuracy does not improve. In fact, the benchmark graph datasets often used in the literature require no more than 4 layers, after which performance decays (even if slowly). In the next section, we present a realistic use case setting for which deeper models are more likely to provide higher performance, where the benefit of PAIRNORM becomes apparent.
+
+# 3.2 A CASE WHERE DEEPER GNNS ARE BENEFICIAL
+
+In general, oversmoothing gets increasingly more severe as the number of layers goes up. A task would benefit from employing PAIRNORM more if it required a large number of layers to achieve its best performance. To this effect we study the “missing feature setting”, where a subset of the nodes lack feature vectors. Let $\mathcal { M } \subseteq \mathcal { V } _ { u }$ be the set where $\forall m \in \mathcal { M } , \mathbf { x } _ { m } = \varnothing$ , i.e., all of their features are missing. We denote with $p = | \mathcal { M } | / | \mathcal { V } _ { u } |$ the missing fraction. We call this variant of the task as semi-supervised node classification with missing vectors (SSNC-MV). Intuitively, one would require a larger number of propagation steps (hence, a deeper GNN) to be able to “recover” effective feature representations for these nodes.
+
+SSNC-MV is a general and realistic problem that finds several applications in the real world. For example, the credit lending problem of identifying low- vs. high-risk customers (nodes) can be modeled as SSNC-MV where a large fraction of nodes do not exhibit any meaningful features (e.g., due to low-volume activity). In fact, many graph-based classification tasks with the cold-start issue (entity with no history) can be cast into SSNC-MV. To our knowledge, this is the first work to study the SSNC-MV problem using GNN models.
+
+Figure 4 presents the performance of SGC, GCN, and GAT models on Cora with increasing number of layers, where we remove feature vectors from all the unlabeled nodes, i.e. $p = 1$ . The models with PAIRNORM achieve a higher test accuracy compared to those without, which they typically reach at a larger number of layers. (See Fig. 7 in Appx. A.4 for results on other datasets.)
+
+![](images/0abf2f40b7df4f3cbaf62dab4285a89478bce20eb97fadcdd87298fb24504034.jpg)  
+Figure 4: (best in color) Comparison of ‘vanilla’ vs. PAIRNORM-enhanced SGC, GCN, and GAT performance on Cora for $p = 1$ . Green diamond symbols depict the layer at which validation accuracy peaks. PAIRNORM boosts overall performance by enabling more robust deep GNNs.
+
+# 4 EXPERIMENTS
+
+In section 3 we have shown the robustness of PAIRNORM-enhanced models against increasing number of layers in SSNC problem. In this section we design extensive experiments to evaluate the effectiveness of PAIRNORM under the SSNC-MV setting, over SGC, GCN and GAT models.
+
+# 4.1 EXPERIMENT SETUP
+
+Datasets. We use 4 well-known benchmark datasets in GNN domain: Cora, Citeseer, Pubmed (Sen et al., 2008), and CoauthorCS (Shchur et al., 2018). Their statistics are reported in Appx. A.2. For Cora, Citeseer and Pubmed, we use the same dataset splits as Kipf & Welling (2017), where all nodes outside train and validation are used as test set. For CoauthorCS, we randomly split all nodes into train/val/test as $3 \% / 1 0 \% / 8 7 \%$ , and keep the same split for all experiments.
+
+Models. We use three different GNN models as our base model: SGC (Wu et al., 2019), GCN (Kipf & Welling, 2017), and GAT (Velickovic et al., 2018). We compare our PAIRNORM with residual connection method (He et al., 2016) over base models (except SGC since there is no “residual connected” SGC), as we surprisingly find it can slow down oversmoothing and benefit SSNCMV problem. Similar to us, residual connection is a general technique that can be applied to any model without changing its architecture. We focus on the comparison between the base models and PAIRNORM-enhanced models, rather than achieving the state of the art performance for SSNC and SSNC-MV. There exist a few other work addressing oversmoothing (Klicpera et al., 2019; Li et al., 2018; Rong et al., 2019; Xu et al., 2018) however they design specialized architectures and not simple “patch” procedures like PAIRNORM that can be applied on top of any GNN.
+
+Hyperparameters. We choose the hyperparameter $s$ of PAIRNORM from $\{ 0 . 1 , 1 , 1 0 , 5 0 , 1 0 0 \}$ over validation set for SGC, while keeping it fixed at $s = 1$ for both GCN and GAT due to resource limitations. We set the #hidden units of GCN and GAT (#attention heads is set to 1) to 32 and 64 respectively for all datasets. Dropout with rate 0.6 and $L _ { 2 }$ regularization with penalty $5 \cdot 1 0 ^ { - 4 } $ are applied to GCN and GAT. For SGC, we vary number of layers in $\{ 1 , 2 , \ldots 1 0 , 1 5 , \ldots , 6 0 \}$ and for GCN and GAT in $\{ 2 , 4 , \dots , 1 2 , 1 5 , 2 0 , \dots , 3 0 \}$ .
+
+Configurations. For PAIRNORM-enhanced models, we apply PAIRNORM after each graph convolution layer (i.e., after activation if any) in the base model. For residual-connected models with $t$ skip steps, we connect the output of $l$ -th layer to $( l + t )$ -th, that is, $\mathbf { H } _ { \mathrm { n e w } } ^ { ( l + t ) } = \mathbf { H } ^ { ( l + t ) } + \mathbf { H } ^ { ( l ) }$ where $\mathbf { H } ^ { ( \bar { l } ) }$ denotes the output of $l$ -th graph convolution (after activation). For the SSNC-MV setting, we randomly erase $p$ fraction of the feature vectors from nodes in validation and test sets (for which we input vector $\mathbf { 0 } \in \mathbb { R } ^ { d }$ ), whereas all training (labeled) nodes keep their original features (See 3.2). We run each experiment within 1000 epochs 5 times and report the average performance. We mainly use a single GTX-1080ti GPU, with some SGC experiments ran on an Intel i7-8700k CPU.
+
+# 4.2 EXPERIMENT RESULTS
+
+We first show the global performance gain of applying PAIRNORM to SGC for SSNC-MV under varying feature missing rates as shown in Table 1. PAIRNORM-enhanced SGC performs similar or better over $0 \%$ missing, while it significantly outperforms vanilla SGC for most other settings, especially for larger missing rates. #L denotes the best number of layers for the model that yields the largest average validation accuracy (over 5 runs), for which we report the average test accuracy (Acc). Notice the larger #L values for SGC-PN compared to vanilla SGC, which shows the power of PAIRNORM for enabling “deep” SGC models by effectively tackling oversmoothing.
+
+Similar to Wu et al. (2019) who showed that the simple SGC model achieves comparable or better performance as other GNNs for various tasks, we found PAIRNORM-enhanced SGC to follow the same trend when compared with PAIRNORM-enhanced GCN and GAT, for all SSNC-MV settings. Due to its simplicity and extreme efficiency, we believe PAIRNORM-enhanced SGC sets a strong baseline for the SSNC-MV problem.
+
+Table 1: Comparison of ‘vanilla’ vs. PAIRNORM-enhanced SGC performance in Cora, Citeseer, Pubmed, and CoauthorCS for SSNC-MV problem, with missing rate ranging from $0 \%$ to $1 0 0 \%$ . Showing test accuracy at #L ( $K$ in Eq. 4) layers, at which model achieves best validation accuracy.   
+
+<table><tr><td colspan="2">Missing Percentage Dataset Method</td><td colspan="2">0% Acc #L</td><td colspan="2">20% Acc #L</td><td colspan="2">40% Acc #L</td><td colspan="2">60% Acc #L</td><td colspan="2">80% Acc #L</td><td colspan="2">100% Acc #L</td></tr><tr><td rowspan="2">Cora</td><td>SGC</td><td>0.815</td><td>4</td><td>0.806</td><td>5</td><td>|0.786</td><td>3</td><td>0.742</td><td>4</td><td>0.733</td><td></td><td>310.423</td><td>315</td></tr><tr><td>SGC-PN</td><td>0.811</td><td>7</td><td>0.799</td><td>7</td><td>0.797</td><td>7</td><td>0.783</td><td>20</td><td>0.780</td><td>25</td><td>0.745</td><td>40</td></tr><tr><td rowspan="2">Citeseer</td><td>SGC</td><td>0.689</td><td>10</td><td>0.684</td><td>6</td><td>0.668</td><td>8</td><td>0.657</td><td></td><td>9 0.565</td><td></td><td>80.290</td><td>2</td></tr><tr><td>SGC-PN</td><td>0.706</td><td>3</td><td>0.695</td><td>3</td><td>0.653</td><td>4</td><td>0.641</td><td></td><td>5 0.590</td><td></td><td>500.486</td><td>50</td></tr><tr><td rowspan="2">Pubmed</td><td>SGC</td><td>0.754</td><td>1</td><td>0.748</td><td></td><td>0.723</td><td></td><td>410.746</td><td></td><td>20.659</td><td></td><td>30.399</td><td>35</td></tr><tr><td>SGC-PN</td><td>0.782</td><td>9</td><td>0.781</td><td>1 7</td><td>0.778</td><td></td><td>600.782</td><td></td><td>7 0.772</td><td></td><td>600.719</td><td>40</td></tr><tr><td rowspan="2">CoauthorCs</td><td>SGC</td><td>0.914</td><td>1</td><td>10.898</td><td></td><td>0.877</td><td></td><td>210.824</td><td></td><td>210.751</td><td></td><td>40.318</td><td>2</td></tr><tr><td>SGC-PN</td><td>0.915</td><td>2</td><td>0.909</td><td>22</td><td>0.899</td><td>3</td><td>0.891</td><td></td><td>4 0.880</td><td></td><td>80.860</td><td>20</td></tr></table>
+
+We next employ PAIRNORM-SI for GCN and GAT under the same setting, comparing it with the residual (skip) connections technique. Results are shown in Table 2 and Table 3 respectively for GCN and GAT. Due to space and resource limitations, we only show results for $0 \%$ and $1 0 0 \%$ missing rate scenarios. (We provide results for other missing rates $( 7 0 , 8 0 , 9 0 \% )$ over 1 run only in Appx. A.5.) We observe similar trend for GCN and GAT: (1) vanilla model suffers from performance drop under SSNC-MV with increasing missing rate; (2) both residual connections and PAIRNORM-SI enable deeper models and improve performance (note the larger $\# \mathrm { L }$ and Acc); (3) GCN-PN and
+
+GAT-PN achieve performance that is comparable or better than just using skips; (4) performance can be further improved (albeit slightly) by using skips along with PAIRNORM-SI.4
+
+Table 2: Comparison of ‘vanilla’ and (PAIRNORM-SI/ residual)-enhanced GCN performance on Cora, Citeseer, Pubmed, and CoauthorCS for SSNC-MV problem, with $0 \%$ and $1 0 0 \%$ feature missing rate. $t$ represents the skip-step of residual connection. (See A.5 Fig. 8 for more settings.)   
+
+<table><tr><td rowspan="2">Dataset Missing(%) Method</td><td colspan="3">Cora</td><td colspan="4">Citeseer</td><td colspan="4">Pubmed</td><td colspan="4">CoauthorCs</td></tr><tr><td colspan="2">0% Acc #L</td><td colspan="2">100% Acc #L</td><td colspan="2">0% Acc #L</td><td colspan="2">100% Acc #L</td><td colspan="2">0% Acc #L</td><td colspan="2">100% Acc #L</td><td colspan="2">0% Acc #L</td><td colspan="2">100% Acc #L</td></tr><tr><td>GCN</td><td>|0.821</td><td>2|0.582</td><td></td><td>2</td><td>0.695</td><td>0.313</td><td></td><td>2</td><td>|0.779</td><td>2|0.449</td><td></td><td>2</td><td>|0.877</td><td></td><td>210.452</td><td>4</td></tr><tr><td></td><td></td><td></td><td></td><td></td><td></td><td>2</td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td></tr><tr><td>GCN-PN GCN-t1</td><td>[0.790 0.822</td><td>2</td><td>0.731</td><td>10</td><td>0.660</td><td></td><td>0.498</td><td>8</td><td>0.780</td><td>30</td><td>0.745</td><td>25 25</td><td>10.910 0.898</td><td>2</td><td>0.846 0.727</td><td>12 12</td></tr><tr><td>GCN-t1-PN</td><td>0.780</td><td>2 2</td><td>0.721 0.724</td><td>15 30</td><td>0.696 0.648</td><td></td><td>0.441 0.465</td><td>12 10</td><td>0.780 0.756</td><td>2 15</td><td>0.656 0.690</td><td>12</td><td>0.898</td><td>2 2</td><td>0.830</td><td>20</td></tr><tr><td>GCN-t2</td><td>0.820</td><td>2</td><td>0.722</td><td>10</td><td>0.691</td><td></td><td>0.432</td><td>20</td><td>0.779</td><td>2</td><td>0.645</td><td>20</td><td>0.882</td><td>4</td><td>0.630</td><td>20</td></tr><tr><td>GCN-t2-PN</td><td>0.785</td><td>4</td><td>0.740</td><td>30</td><td>0.650</td><td>22222</td><td>0.508</td><td>12</td><td>0.770</td><td>15</td><td>0.725</td><td>30</td><td>0.911</td><td>2</td><td>0.839</td><td>20</td></tr></table>
+
+Table 3: Comparison of ‘vanilla’ and (PAIRNORM-SI/ residual)-enhanced GAT performance on Cora, Citeseer, Pubmed, and CoauthorCS for SSNC-MV problem, with $0 \%$ and $1 0 0 \%$ feature missing rate. $t$ represents the skip-step of residual connection. (See A.5 Fig. 9 for more settings.)   
+
+<table><tr><td rowspan="2">Dataset Missing(%) Method</td><td rowspan="2">0%</td><td colspan="2">Cora 100%</td><td colspan="4">Citeseer</td><td colspan="4">Pubmed</td><td colspan="4">Coauthorcs</td></tr><tr><td colspan="2"></td><td colspan="2">0% Acc #L</td><td colspan="2">100% Acc #L</td><td colspan="2">0% Acc #L</td><td colspan="2">100% Acc #L</td><td colspan="2">0% Acc #L</td><td colspan="2">100% Acc #L</td></tr><tr><td></td><td>Acc #L 0.823</td><td></td><td>Acc #L</td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td></tr><tr><td>GAT</td><td></td><td>2|</td><td>0.653</td><td>4</td><td>0.693</td><td>210.428</td><td></td><td>4 |0.774</td><td></td><td>6|0.631</td><td></td><td>4 [0.892</td><td></td><td>4|0.737</td><td>4</td></tr><tr><td>GAT-PN</td><td>0.787</td><td>2</td><td>0.718</td><td>6</td><td>0.670</td><td>2 0.483</td><td>4</td><td>0.774</td><td>12</td><td>0.714</td><td>10</td><td>0.916</td><td>2</td><td>0.843</td><td>8</td></tr><tr><td>GAT-t1</td><td>0.822 0.787</td><td>2</td><td>0.706</td><td>8</td><td>0.693</td><td>2 0.461</td><td>6</td><td>0.769</td><td>4</td><td>0.698</td><td>8</td><td>0.899</td><td>4 2</td><td>0.842</td><td>10</td></tr><tr><td>GAT-t1-PN GAT-t2</td><td>0.820</td><td>2 2</td><td>0.710 0.691</td><td>10</td><td>0.658</td><td>6 0.500 0.461</td><td>10 6</td><td>0.757 0.774</td><td>4 8</td><td>0.684 0.702</td><td>12 8</td><td>0.911 0.895</td><td></td><td>0.844 0.803</td><td>20</td></tr><tr><td>GAT-t2-PN</td><td>0.788</td><td>4</td><td>0.738</td><td>8 12</td><td>s0.692 0.672</td><td>2 4 0.517</td><td>10</td><td>0.776</td><td>15</td><td>0.704</td><td>12</td><td>0.917</td><td>4 2</td><td>0.855</td><td>6 30</td></tr></table>
+
+# 5 RELATED WORK
+
+Oversmoothing in GNNs: Li et al. (2018) was the first to call attention to the oversmoothing problem. Xu et al. (2018) introduced Jumping Knowledge Networks, which employ skip connections for multi-hop message passing and also enable different neighborhood ranges. Klicpera et al. (2019) proposed a propagation scheme based on personalized Pagerank that ensures locality (via teleports) which in turn prevents oversmoothing. Li et al. (2019) built on ideas from ResNet to use residual as well as dense connections to train deep GCNs. DropEdge Rong et al. (2019) proposed to alleviate oversmoothing through message passing reduction via removing a certain fraction of edges at random from the input graph. These are all specialized solutions that introduce additional parameters and/or a different network architecture.
+
+Normalization Schemes for Deep-NNs: There exist various normalization schemes proposed for deep neural networks, including batch normalization Ioffe & Szegedy (2015), weight normalization Salimans & Kingma (2016), layer normalization Ba et al. (2016), and so on. Conceptually these have substantially different goals (e.g., reducing training time), and were not proposed for graph neural networks nor the oversmoothing problem therein. Important difference to note is that larger depth in regular neural-nets does not translate to more hops of propagation on a graph structure.
+
+# 6 CONCLUSION
+
+We investigated the oversmoothing problem in GNNs and proposed PAIRNORM, a novel normalization layer that boosts the robustness of deep GNNs against oversmoothing. PAIRNORM is fast to compute, requires no change in network architecture nor any extra parameters, and can be applied to any GNN. Experiments on real-world classification tasks showed the effectiveness of PAIRNORM, where it provides performance gains when the task benefits from more layers. Future work will explore other use cases of deeper GNNs that could further showcase PAIRNORM’s advantages.
+
+# REFERENCES
+
+Jimmy Lei Ba, Jamie Ryan Kiros, and Geoffrey E Hinton. Layer normalization. CoRR, abs/1607.06450, 2016.
+
+Olivier Chapelle, Bernhard Scholkopf, and Alexander Zien. ¨ Semi-Supervised Learning. 2006.
+
+William L. Hamilton, Zhitao Ying, and Jure Leskovec. Inductive representation learning on large graphs. In NIPS, pp. 1024–1034, 2017.
+
+Kaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. Deep Residual Learning for Image Recognition. In Proceedings of 2016 IEEE Conference on Computer Vision and Pattern Recognition, pp. 770–778. IEEE, 2016.
+
+Sergey Ioffe and Christian Szegedy. Batch normalization: Accelerating deep network training by reducing internal covariate shift. CoRR, abs/1502.03167, 2015.
+
+Thomas N. Kipf and Max Welling. Semi-supervised classification with graph convolutional networks. In International Conference on Learning Representations (ICLR). OpenReview.net, 2017.
+
+Johannes Klicpera, Aleksandar Bojchevski, and Stephan Gunnemann. Combining neural networks ¨ with personalized pagerank for classification on graphs. In International Conference on Learning Representations (ICLR), 2019.
+
+Guohao Li, Matthias Muller, Ali Thabet, and Bernard Ghanem. Can GCNs go as deep as CNNs? ¨ CoRR, abs/1904.03751, 2019.
+
+Qimai Li, Zhichao Han, and Xiao-Ming Wu. Deeper Insights into Graph Convolutional Networks for Semi-Supervised Learning. In Proceedings of the 32nd AAAI Conference on Artificial Intelligence, pp. 3538–3545, 2018.
+
+Hoang NT and Takanori Maehara. Revisiting graph neural networks: All we have is low-pass filters. CoRR, abs/1905.09550, 2019.
+
+Meng Qu, Yoshua Bengio, and Jian Tang. Gmnn: Graph markov neural networks. In International Conference on Machine Learning, pp. 5241–5250, 2019.
+
+Yu Rong, Wenbing Huang, Tingyang Xu, and Junzhou Huang. The truly deep graph convolutional networks for node classification. CoRR, abs/1907.10903, 2019.
+
+Tim Salimans and Durk P Kingma. Weight normalization: A simple reparameterization to accelerate training of deep neural networks. In Advances in Neural Information Processing Systems, pp. 901–909, 2016.
+
+Prithviraj Sen, Galileo Namata, Mustafa Bilgic, Lise Getoor, Brian Galligher, and Tina Eliassi-Rad. Collective classification in network data. AI magazine, 29(3):93–93, 2008.
+
+Oleksandr Shchur, Maximilian Mumme, Aleksandar Bojchevski, and Stephan Gunnemann. Pitfalls ¨ of graph neural network evaluation. arXiv preprint arXiv:1811.05868, 2018.
+
+Petar Velickovic, Guillem Cucurull, Arantxa Casanova, Adriana Romero, Pietro Li, and Yoshua Bengio. Graph attention networks. In International Conference on Learning Representations (ICLR). OpenReview.net, 2018.
+
+Felix Wu, Amauri H. Souza Jr., Tianyi Zhang, Christopher Fifty, Tao Yu, and Kilian Q. Weinberger. Simplifying graph convolutional networks. In ICML, volume 97 of Proceedings of Machine Learning Research, pp. 6861–6871. PMLR, 2019.
+
+Keyulu Xu, Chengtao Li, Yonglong Tian, Tomohiro Sonobe, Ken-ichi Kawarabayashi, and Stefanie Jegelka. Representation Learning on Graphs with Jumping Knowledge Networks. In Proceedings of the 35th International Conference on Machine Learning, volume 80, pp. 5453–5462, 2018.
+
+# A APPENDIX
+
+A.1 DERIVATION OF EQ. 8
+
+$$
+\begin{array} { l } { { \displaystyle \mathrm { T P S D } ( \widetilde { \mathbf { X } } ) = \sum _ { i , j \in [ n ] } \big \| \widetilde { \mathbf { x } } _ { i } - \widetilde { \mathbf { x } } _ { j } \big \| _ { 2 } ^ { 2 } = \sum _ { i , j \in [ n ] } \big ( \widetilde { \mathbf { x } } _ { i } - \widetilde { \mathbf { x } } _ { j } \big ) ^ { T } ( \widetilde { \mathbf { x } } _ { i } - \mathbf { y } ) } } \\ { { \displaystyle = \sum _ { i , j \in [ n ] } \big ( \widetilde { \mathbf { x } } _ { i } ^ { T } \widetilde { \mathbf { x } } _ { j } + \widetilde { \mathbf { x } } _ { j } ^ { T } \widetilde { \mathbf { x } } _ { j } - 2 \widetilde { \mathbf { x } } _ { i } ^ { T } \widetilde { \mathbf { x } } _ { j } \big ) } } \\ { { \displaystyle = 2 n \sum _ { i } \sum _ { j \in [ n ] } \widetilde { \mathbf { x } } _ { i } ^ { T } \widetilde { \mathbf { x } } _ { i } - 2 \sum _ { j \in [ n ] } \widetilde { \mathbf { x } } _ { i } ^ { T } \widetilde { \mathbf { x } } _ { j } } } \\ { { \displaystyle \quad = 2 n \sum _ { i } \sum _ { j \in [ n ] } \widetilde { \mathbf { x } } _ { i } \widetilde { \mathbf { x } } _ { i } - 2 \sum _ { i } \sum _ { j \in [ n ] } \widetilde { \mathbf { x } } _ { i } ^ { T } \widetilde { \mathbf { x } } _ { j } } } \\ { { \displaystyle \qquad \quad = 2 n \sum _ { i \in [ n ] } \big \| \widetilde { \mathbf { x } } _ { i } \big \| _ { 2 } ^ { 2 } - 2 1 ^ { T } \widetilde { \mathbf { x } } \widetilde { \mathbf { x } } ^ { T } \widetilde { \mathbf { 1 } } } } \\ { { \displaystyle \qquad \quad = 2 n \sum _ { i \in [ n ] } \big \| \widetilde { \mathbf { x } } _ { i } \big \| _ { 2 } ^ { 2 } - 2 \big \| \mathbf { 1 } ^ { T } \widetilde { \mathbf { x } } _ { i } \big \| _ { 2 } ^ { 2 } } } \\ { { \displaystyle \qquad \quad = 2 n \Big ( \Big \frac { 1 } { n } \sum _ { i = [ n ] } ^ { n } \big \| \widetilde { \mathbf { x } } _ { i } \big \| _ { 2 } ^ { 2 } - \big \| \widetilde { \mathbf { x } } _ { i } ^ { n } \big \| _ { 2 } ^ { 2 } } } \\   \displaystyle \qquad = 2 n ^ { 2 } \ \end{array}
+$$
+
+# A.2 DATASET STATISTICS
+
+Table 4: Dataset statistics.   
+A.3 ADDITIONAL PERFORMANCE PLOTS WITH INCREASING NUMBER OF LAYERS   
+
+<table><tr><td>Name</td><td>#Nodes</td><td>#Edges</td><td>#Features</td><td></td><td>#Classes Label Rate</td></tr><tr><td>Cora</td><td>2708</td><td>5429</td><td>1433</td><td>7</td><td>0.052</td></tr><tr><td>Citeseer</td><td>3327</td><td>4732</td><td>3703</td><td>6</td><td>0.036</td></tr><tr><td>Pubmed</td><td>19717</td><td>44338</td><td>500</td><td>3</td><td>0.003</td></tr><tr><td>CoauthorCs</td><td>18333</td><td>81894</td><td>6805</td><td>15</td><td>0.030</td></tr></table>
+
+![](images/627b136f2cb683067e12832795e6ab454ee952b0c4cb0e3f50066ebbd4663f7f.jpg)  
+Figure 5: Comparison of ‘vanilla’ vs. PAIRNORM-enhanced SGC, corresponding to Figure 1, for datasets (from top to bottom) Citeseer, Pubmed, and CoauthorCS. PAIRNORM provides improved robustness to performance decay due to oversmoothing with increasing number of layers.
+
+![](images/49c210931fea9be9fc78e0736ea00e7ac768d1712531f097d61e2630ee97e36d.jpg)  
+Figure 6: Comparison of ‘vanilla’ (dashed) vs. PAIRNORM-enhanced (solid) GCN (left) and GAT (right) models, corresponding to Figure 3, for datasets (from top to bottom) Citeseer, Pubmed, and CoauthorCS. PAIRNORM provides improved robustness against performance decay with increasing number of layers.
+
+![](images/c779b80742b69bdd2c24cbb61a97edec6470afb721283fa9b9345251c88a1009.jpg)  
+A.4 ADDITIONAL PERFORMANCE PLOTS WITH INCREASING NUMBER OF LAYERS UNDER SSNC-MV WITH $p = 1$   
+Figure 7: Comparison of ‘vanilla’ (dashed) vs. PAIRNORM-enhanced (solid) (from left to right) SGC, GCN, and GAT model performance under SSNC-MV for $p = 1$ , corresponding to Figure 4, for datasets (from top to bottom) Citeseer, Pubmed, and CoauthorCS. Green diamond symbols depict the layer at which validation accuracy peaks. PAIRNORM boosts overall performance by enabling more robust deep GNNs.
+
+# A.5 ADDITIONAL EXPERIMENTS UNDER SSNC-MV WITH INCREASING MISSING FRACTION $p$
+
+In this section we report additional experiment results under the SSNC-MV setting with varying missing fraction, in particular $p = \{ 0 . \bar { 7 } , 0 . 8 , 0 . 9 , 1 \}$ and also report the base case where $p = 0$ for comparison.
+
+Figure 8 presents results on all four datasets for GCN vs. PAIRNORM-enhanced GCN (denoted PN for short). The models without any skip connections are denoted by $^ { * } { } _ { - 0 }$ , with one-hop skip connection by $^ { * } { } ^ { 1 }$ , and with one and two-hop skip connections by $^ { * } { } _ { - 2 }$ . Barcharts on the right report the best layer that each model produced the highest validation accuracy, and those on the left report the corresponding test accuracy. Figure 9 presents corresponding results for GAT.
+
+We discuss the take-aways from these figures on the following page.
+
+![](images/0d7b7c1a20f1eb72557237ef6542228cae1c28b9d6f51fdf4f24b4c7317739e1.jpg)  
+Figure 8: Supplementary results to Table 2 for GCN on (from top to bottom) Cora, Citeseer, Pubmed, and CoauthorCS.
+
+We make the following observations based on Figures 8 and 9:
+
+• Performance of ‘vanilla’ GCN and GAT models without skip connections (i.e., GCN-0 and GAT-0) drop monotonically as we increase missing fraction $p$ .   
+• PAIRNORM-enhanced ‘vanilla’ models (PN-0, no skips) perform comparably or better than GCN-0 and GAT-0 in all cases, especially as $p$ increases. In other words, with PAIRNORM at work, model performance is more robust against missing data. Best number of layers for GCN-0 as we increase $p$ only changes between 2-4. For GAT-0, it changes mostly between 2-6.   
+• PAIRNORM-enhanced ‘vanilla’ models (PN-0, no skips) can go deeper, i.e., they can leverage a larger range of #layers (2-12) as we increase $p$ . Specifically, GCN-PN-0 (GAT-PN-0) uses equal number or more layers than GCN-0 (GAT-0) in almost all cases. Without any normalization, adding skip connections helps—GCN/GAT-1 and GCN/GAT-2 are better than GCN/GAT-0, especially as we increase $p$ .   
+• With PAIRNORM but no-skip, performance is comparable or better than just adding skips.   
+• Adding skips on top of PAIRNORM does not seem to introduce any notable gains.
+
+In summary, simply employing our PAIRNORM for GCN and GAT provides robustness against oversmoothing that allows them to go deeper and achieve improved performance under SSNC-MV.
+
+![](images/5af8696357db4e766480670d62df5ad543dd644da4d5b8e2682680e390593102.jpg)  
+Figure 9: Supplementary results to Table 3 for GAT on (from top to bottom) Cora, Citeseer, Pubmed, and CoauthorCS.
+
+A.6 CASE STUDY: ADDITIONAL MEASURES FOR PAIRNORM AND PAIRNORM-SI WITH SGC AND GCN
+
+To better understand why PAIRNORM and PAIRNORM-SI are helpful for training deep GNNs, we report additional measures for (SGC and GCN) with (PAIRNORM and PAIRNORM-SI) over the Cora dataset. In the main text, we claim TPSD (total pairwise squared distances) is constant across layers for SGC with PAIRNORM (for GCN/GAT this is not guaranteed because of the influence of activation function and dropout layer). In this section we empirically measure pairwise (squared) distances for both SGC and GCN, with PAIRNORM and PAIRNORM-SI.
+
+# A.6.1 SGC WITH PAIRNORM AND PAIRNORM-SI
+
+To verify our analysis of PAIRNORM for SGC, and understand how the variant of PAIRNORM (PAIRNORM-SI) works, we measure the average pairwise squared distance (APSD) as well as the average pairwise distance (APD) between the representations for two categories of node pairs: (1) connected pairs (nodes that are directly connected in graph) and (2) random pairs (uniformly randomly chosen among the node set). APSD of random pairs reflects the TPSD, and APD of random pairs reflects the total pairwise distance (TPD). Under the homophily assumption of the labels w.r.t. the graph structure, we want APD or APSD of connected pairs to be small while keeping APD or APSD of random pairs relatively large.
+
+The results are shown in Figure 10. Without normalization, SGC suffers from fast diminishing APD and APSD of random pairs. As we have proved, PAIRNORM normalizes APSD to be constant across layers, however it does not normalize APD, which appears to decrease linearly with increasing number of layers. Surprisingly, although PAIRNORM-SI is not theoretically proved to have a constant APSD and APD, empirically it achieves more stable APSD and APD than PAIRNORM. We were not able to prove this phenomenon mathematically, and leave it for further investigation.
+
+![](images/ae436f7f59e77acf1dd9f6d7e0e09d9a1facf14cb62996a08d1daa89db8c6452.jpg)  
+Figure 10: Measuring average distance (squared and not-squared) between representations at each layer for SGC, SGC with PAIRNORM, and SGC with PAIRNORM-SI. The setting is the same with Figure 1 and they share the same performance.
+
+APD does not capture the full information of the distribution of pairwise distances. To show how the distribution changes by increasing number of layers, we use Tensorboard to plot the histograms of pairwise distances, as shown in Figure 11. Comparing SGC and SGC with PAIRNORM, adding PAIRNORM keeps the left shift (shrinkage) of the distribution of random pair distances much slower than without normalization, while still sharing similar behavior of the distribution of connected pairwise distances. PAIRNORM-SI seems to be more powerful in keeping the median and mean of the distribution of random pair distances stable, while “spreading” the distribution out by increasing the variance. The performance of PAIRNORM and PAIRNORM-SI are similar, however it seems that PAIRNORM-SI is more powerful in stabilizing TPD and TPSD.
+
+![](images/7b388377adcaf83d05c83715ca45a5300a22c8267be76f9fe92a56df0c7bbc16.jpg)  
+Figure 11: Measuring distribution of distances between representations at each layer for SGC, SGC with PAIRNORM, and SGC with PAIRNORM-SI. Supplementary results for Figure 10.
+
+# A.6.2 GCN WITH PAIRNORM AND PAIRNORM-SI
+
+![](images/59f7ec91fe51b33cfef45e58655597546a89d6fe981618538c32b87c2f03cd05.jpg)  
+Figure 12: Measuring average distance (squared and not-squared) between representations at each layer for GCN, GCN with PAIRNORM, and GCN with PAIRNORM-SI. We trained three 12-layer GCNs with #hidden ${ \boldsymbol { \mathrm { \Omega } } } = 1 2 8$ and dropout $_ { = 0 . 6 }$ in 1000 epochs. Respective test set accuracies are $3 1 . 0 9 \%$ , $7 7 . 7 7 \%$ , $7 5 . 0 9 \%$ . Note that the scale of distances is not comparable across models, since they have learnable parameters that scale these distances differently.
+
+The formal analysis for PAIRNORM and PAIRNORM-SI is based on SGC. GCN (and other GNNs) has learnable parameters, dropout layers, and activation layers, all of which complicate direct mathematical analyses. Here we perform similar empirical measurements for pairwise distances to get a rough sense of how PAIRNORM and PAIRNORM-SI work with GCN based on the Cora dataset. Figures 12 and 13 demonstrate how PAIRNORM and PAIRNORM-SI can help train a relatively deep (12 layers) GCN.
+
+Notice that oversmoothing occurs very quickly for GCN without any normalization, where both connected and random pair distances reach zero (!). In contrast, GCN with PAIRNORM or PAIRNORMSI is able to keep random pair distances relatively apart while allowing connected pair distances to shrink. As also stated in main text, using PAIRNORM-SI for GCN and GAT is relatively more stable than using PAIRNORM in general cases (notice the near-constant random pair distances in the rightmost subfigures). There are several possible explanations for why PAIRNORM-SI is more stable. First, as shown in Figure 10 and Figure 12, PAIRNORM-SI not only keeps APSD stable but also APD, further, the plots of distributions of pairwise distances (Figures 11 and 13) also show the power of PAIRNORM-SI (notice the large gap between smaller connected pairwise distances and the larger random pairwise distances). Second, we conjecture that restricting representations to reside on a sphere can make training stable and faster, which we also observe empirically by studying the training curves. Third, GCN and GAT tend to overfit easily for the SSNC problem, due to many learnable parameters across layers and limited labeled input data, therefore it is possible that adding more restriction on these models helps reduce overfitting.
+
+![](images/4e87bc839305a4fe876fef59f9a350aa8fa1909a4e79ba5c49503a628a339763.jpg)  
+Figure 13: Measuring distribution of distances between representations at each layer for GCN, GCN with PAIRNORM, and GCN with PAIRNORM-SI. Supplementary results for Figure 12.
+
+All in all, these empirical measurements as illustrated throughout the figures in this section demonstrates that PAIRNORM and PAIRNORM-SI successfully address the oversmoothing problem for deep GNNs. Our work is the first to propose a normalization layer specifically designed for graph neural networks, which we hope will kick-start more work in this area toward training more robust and effective GNNs.

parse/train/rkecl1rtwB/rkecl1rtwB_content_list.json

@@ -0,0 +1,1669 @@
+[
+    {
+        "type": "text",
+        "text": "PAIRNORM: TACKLING OVERSMOOTHING IN GNNS ",
+        "text_level": 1,
+        "bbox": [
+            171,
+            99,
+            797,
+            121
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Lingxiao Zhao Carnegie Mellon University Pittsburgh, PA 15213, USA {lingxia1}@andrew.cmu.edu ",
+        "bbox": [
+            184,
+            145,
+            428,
+            202
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Leman Akoglu Carnegie Mellon University Pittsburgh, PA 15213, USA {lakoglu}@andrew.cmu.edu ",
+        "bbox": [
+            511,
+            145,
+            745,
+            202
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "ABSTRACT ",
+        "text_level": 1,
+        "bbox": [
+            454,
+            238,
+            544,
+            252
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "The performance of graph neural nets (GNNs) is known to gradually decrease with increasing number of layers. This decay is partly attributed to oversmoothing, where repeated graph convolutions eventually make node embeddings indistinguishable. We take a closer look at two different interpretations, aiming to quantify oversmoothing. Our main contribution is PAIRNORM, a novel normalization layer that is based on a careful analysis of the graph convolution operator, which prevents all node embeddings from becoming too similar. What is more, PAIRNORM is fast, easy to implement without any change to network architecture nor any additional parameters, and is broadly applicable to any GNN. Experiments on real-world graphs demonstrate that PAIRNORM makes deeper GCN, GAT, and SGC models more robust against oversmoothing, and significantly boosts performance for a new problem setting that benefits from deeper GNNs. Code is available at https://github.com/LingxiaoShawn/PairNorm. ",
+        "bbox": [
+            233,
+            273,
+            764,
+            454
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 INTRODUCTION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            482,
+            336,
+            497
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Graph neural networks (GNNs) is a family of neural networks that can learn from graph structured data. Starting with the success of GCN (Kipf & Welling, 2017) on achieving state-of-the-art performance on semi-supervised classification, several variants of GNNs have been developed for this task; including GraphSAGE (Hamilton et al., 2017), GAT (Velickovic et al., 2018), SGC (Wu et al., 2019), and GMNN (Qu et al., 2019) to name a few most recent ones. ",
+        "bbox": [
+            174,
+            513,
+            825,
+            582
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "A key issue with GNNs is their depth limitations. It has been observed that deeply stacking the layers often results in significant drops in performance for GNNs, such as GCN and GAT, even beyond just a few (2–4) layers. This drop is associated with a number of factors; including the vanishing gradients in back-propagation, overfitting due to the increasing number of parameters, as well as the phenomenon called oversmoothing. Li et al. (2018) was the first to call attention to the oversmoothing problem. Having shown that the graph convolution is a type of Laplacian smoothing, they proved that after repeatedly applying Laplacian smoothing many times, the features of the nodes in the (connected) graph would converge to similar values—the issue coined as “oversmoothing”. In effect, oversmoothing hurts classification performance by causing the node representations to be indistinguishable across different classes. Later, several others have alluded to the same problem (Xu et al., 2018; Klicpera et al., 2019; Rong et al., 2019; Li et al., 2019) (See §5 Related Work). ",
+        "bbox": [
+            174,
+            589,
+            825,
+            742
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "In this work, we address the oversmoothing problem in deep GNNs. Specifically, we propose (to the best of our knowledge) the first normalization layer for GNNs that is applied in-between intermediate layers during training. Our normalization has the effect of preventing the output features of distant nodes to be too similar or indistinguishable, while at the same time allowing those of connected nodes in the same cluster become more similar. We summarize our main contributions as follows. ",
+        "bbox": [
+            176,
+            750,
+            825,
+            819
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "• Normalization to Tackle Oversmoothing in GNNs: We introduce a normalization scheme, called PAIRNORM, that makes GNNs significantly more robust to oversmoothing and as a result enables the training of deeper models without sacrificing performance. Our proposed scheme capitalizes on the understanding that most GNNs perform a special form of Laplacian smoothing, which makes node features more similar to one another. The key idea is to ensure that the total pairwise feature distances remains a constant across layers, which in turn leads to distant pairs having less similar features, preventing feature mixing across clusters. ",
+        "bbox": [
+            191,
+            827,
+            823,
+            924
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "• Speed and Generality: PAIRNORM is very straightforward to implement and introduces no additional parameters. It is simply applied to the output features of each layer (except the last one) consisting of simple operations, in particular centering and scaling, that are linear in the input size. Being a simple normalization step between layers, PAIRNORM is not specific to any particular GNN but rather applies broadly. ",
+        "bbox": [
+            191,
+            103,
+            825,
+            172
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "• Use Case for Deeper GNNs: While PAIRNORM prevents performance from dropping significantly with increasing number of layers, it does not necessarily yield increased performance in absolute terms. We find that this is because shallow architectures with no more than 2–4 layers is sufficient for the often-used benchmark datasets in the literature. In response, we motivate a real-world scenario wherein a notable portion of the nodes have no feature vectors. In such settings, nodes benefit from a larger range (i.e., neighborhood, hence a deeper GNN) to “recover” effective feature representations. Through extensive experiments, we show that GNNs employing our PAIRNORM significantly outperform the ‘vanilla’ GNNs when deeper models are beneficial to the classification task. ",
+        "bbox": [
+            191,
+            174,
+            825,
+            299
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2 UNDERSTANDING OVERSMOOTHING ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            314,
+            509,
+            330
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "In this work, we consider the semi-supervised node classification (SSNC) problem on a graph. In the general setting, a graph $\\mathcal { G } = ( \\nu , \\mathcal { E } , \\mathbf { X } )$ is given in which each node $i \\in \\mathcal V$ is associated with a feature vector $\\mathbf { x } _ { i } \\in \\mathbb { R } ^ { \\breve { d } }$ where $\\mathbf { X } = [ \\mathbf { x } _ { 1 } , \\ldots , \\mathbf { x } _ { n } ] ^ { T }$ denotes the feature matrix, and a subset $\\nu _ { l } \\subset \\nu$ of the nodes are labeled, i.e. $y _ { i } \\in \\{ 1 , \\ldots , c \\}$ for each $i \\in \\mathcal { V } _ { l }$ where $c$ is the number of classes. Let $\\mathbf { A } \\in \\mathbb { R } ^ { n \\times n }$ be the adjacency matrix and $\\mathbf { D } = \\mathrm { d i a g } ( d e g _ { 1 } , \\dots , d e g _ { n } ) \\in \\mathbb { R } ^ { n \\times n }$ be the degree matrix of $\\mathcal { G }$ . Let $\\tilde { \\mathbf { A } } = \\mathbf { A } + \\mathbf { I }$ and $\\tilde { \\mathbf { D } } = \\mathbf { D } + \\mathbf { I }$ denote the augmented adjacency and degree matrices with added self-loops on all nodes, respectively. Let $\\tilde { \\mathbf { A } } _ { \\mathrm { s y m } } = \\tilde { \\mathbf { D } } ^ { - 1 / 2 } \\tilde { \\mathbf { A } } \\tilde { \\mathbf { D } } ^ { - 1 / 2 }$ and $\\tilde { \\mathbf { A } } _ { \\mathrm { r w } } = \\tilde { \\mathbf { D } } ^ { - 1 } \\tilde { \\mathbf { A } }$ denote symmetrically and nonsymmetrically normalized adjacency matrices with self-loops. ",
+        "bbox": [
+            173,
+            344,
+            825,
+            462
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "The task is to learn a hypothesis that predicts $y _ { i }$ from $\\mathbf { x } _ { i }$ that generalizes to the unlabeled nodes $\\mathcal { V } _ { u } = \\mathcal { V } \\backslash \\mathcal { V } _ { l }$ . In Section 3.2, we introduce a variant of this setting where only a subset $\\mathcal { F } \\subset \\mathcal { V }$ of the nodes have feature vectors and the rest are missing. ",
+        "bbox": [
+            174,
+            468,
+            825,
+            511
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2.1 THE OVERSMOOTHING PROBLEM ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            517,
+            446,
+            532
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Although GNNs like GCN and GAT achieve state-of-the-art results in a variety of graph-based tasks, these models are not very well-understood, especially why they work for the SSNC problem where only a small amount of training data is available. The success appears to be limited to shallow GNNs, where the performance gradually decreases with the increasing number of layers. This decrease is often attributed to three contributing factors: (1) overfitting due to increasing number of parameters, (2) difficulty of training due to vanishing gradients, and (3) oversmoothing due to many graph convolutions. ",
+        "bbox": [
+            174,
+            539,
+            825,
+            636
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Among these, perhaps the least understood one is oversmoothing, which indeed lacks a formal definition. In their analysis of GCN’s working mechanism, Li et al. (2018) showed that the graph convolution of GCN is a special form of Laplacian smoothing. The standard form being $( { \\bf I } - \\gamma { \\bf I } ) { \\bf X } +$ $\\gamma \\tilde { \\mathbf { A } } _ { \\mathrm { r w } } \\mathbf { X }$ , the graph convolution lets $\\gamma = 1$ and uses the symmetrically normalized Laplacian to obtain $\\begin{array} { r } { \\tilde { \\mathbf { X } } = \\bar { \\hat { \\mathbf { A } } } _ { \\mathrm { s y m } } \\mathbf { \\bar { X } } } \\end{array}$ , where the new features $\\tilde { \\bf x }$ of a node is the weighted average of its own and its neighbors’ features. This smoothing allows the node representations within the same cluster become more similar, and in turn helps improve SSNC performance under the cluster assumption (Chapelle et al., 2006). However when GCN goes deep, the performance can suffer from oversmoothing where node representations from different clusters become mixed up. Let us refer to this issue of node representations becoming too similar as node-wise oversmoothing. ",
+        "bbox": [
+            173,
+            642,
+            825,
+            787
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Another way of thinking about oversmoothing is as follows. Repeatedly applying Laplacian smoothing too many times would drive node features to a stationary point, washing away all the information from these features. Let $\\mathbf { x } _ { \\cdot j } \\in \\mathbb { R } ^ { n }$ denote the $j$ -th column of $\\mathbf { X }$ . Then, for any $\\mathbf { x } _ { \\cdot j } \\in \\mathbb { R } ^ { n }$ : ",
+        "bbox": [
+            174,
+            792,
+            825,
+            835
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "equation",
+        "img_path": "images/82388152ad6519e68a07230dd3707974febc877ac192a824baf9567b82009667.jpg",
+        "text": "$$\n\\operatorname* { l i m } _ { k \\to \\infty } \\tilde { \\mathbf { A } } _ { \\mathrm { s y m } } ^ { k } \\mathbf { x } _ { \\cdot j } = \\pi _ { j } \\quad \\mathrm { a n d } \\quad \\frac { \\pi _ { j } } { \\| \\pi _ { j } \\| _ { 1 } } = \\pi \\ ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            362,
+            835,
+            635,
+            866
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "where the normalized solution $\\pi \\in \\mathbb { R } ^ { n }$ satisfies $\\begin{array} { r } { \\pi _ { i } = \\frac { \\sqrt { d e g _ { i } } } { \\sum _ { i } \\sqrt { d e g _ { i } } } } \\end{array}$ for all $i \\in [ n ]$ . Notice that $\\pi$ is independent of the values $\\mathbf { x } _ { \\cdot j }$ of the input feature and is only a function of the graph structure (i.e., degree). In other words, (Laplacian) oversmoothing washes away the signal from all the features, making them indistinguishable. We will refer to this viewpoint as feature-wise oversmoothing. ",
+        "bbox": [
+            176,
+            875,
+            825,
+            910
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            169,
+            103,
+            823,
+            132
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "To this end we propose two measures, row-diff and col-diff, to quantify these two types of oversmoothing. Let $\\bar { \\mathbf { H } } ^ { ( k ) } \\in \\mathbb { R } ^ { n \\times d }$ be the representation matrix after $k$ graph convolutions, i.e. $\\mathbf { H } ^ { ( k ) } = \\tilde { \\mathbf { A } } _ { \\mathrm { s y m } } ^ { k } \\mathbf { X }$ . Let $\\mathbf { h } _ { i } ^ { ( k ) } \\in \\mathbb { R } ^ { d }$ be the $i$ -th row of $\\mathbf { H } ^ { ( k ) }$ and $\\mathbf { h } _ { . i } ^ { ( k ) } \\in \\mathbb { R } ^ { n }$ be the $i$ -th column of $\\mathbf { H } ^ { ( k ) }$ . Then we define row-diff $( \\mathbf { H } ^ { ( k ) } )$ and col-diff $( \\mathbf { H } ^ { ( k ) } )$ as follows. ",
+        "bbox": [
+            174,
+            138,
+            825,
+            203
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/4ac3ac188c096d869ba243d4d81d9eb52cd305151ece77e2a43a7b96d38fc034.jpg",
+        "text": "$$\n\\mathrm { r o w } \\mathrm { - } \\mathrm { d i f f } ( { \\bf H } ^ { ( k ) } ) = \\frac { 1 } { n ^ { 2 } } \\sum _ { i , j \\in [ n ] } \\left\\| { \\bf h } _ { i } ^ { ( k ) } - { \\bf h } _ { j } ^ { ( k ) } \\right\\| _ { 2 }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            292,
+            202,
+            584,
+            241
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/60e9c600e4adcd475295d645a0d56b1edc2bfa3b47644af825bd88bb321d812e.jpg",
+        "text": "$$\n\\mathrm { c o l - d i f f } ( \\mathbf { H } ^ { ( k ) } ) = \\frac { 1 } { d ^ { 2 } } \\sum _ { i , j \\in [ d ] } \\left\\| \\mathbf { h } _ { \\cdot i } ^ { ( k ) } / \\| \\mathbf { h } _ { \\cdot i } ^ { ( k ) } \\| _ { 1 } - \\mathbf { h } _ { \\cdot j } ^ { ( k ) } / \\| \\mathbf { h } _ { \\cdot j } ^ { ( k ) } \\| _ { 1 } \\right\\| _ { 2 }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            299,
+            243,
+            702,
+            281
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "The row-diff measure is the average of all pairwise distances between the node features (i.e., rows of the representation matrix) and quantifies node-wise oversmoothing, whereas col-diff is the average of pairwise distances between $L _ { 1 }$ -normalized1) columns of the representation matrix and quantifies feature-wise oversmoothing. ",
+        "bbox": [
+            174,
+            281,
+            825,
+            337
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "2.2 STUDYING OVERSMOOTHING WITH SGC ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            343,
+            498,
+            358
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Although oversmoothing can be a cause of performance drop with increasing number of layers in GCN, adding more layers also leads to more parameters (due to learned linear projections $\\mathbf { W } ^ { ( k ) }$ at each layer $k$ ) which magnify the potential of overfitting. Furthermore, deeper models also make the training harder as backpropagation suffers from vanishing gradients. ",
+        "bbox": [
+            174,
+            364,
+            825,
+            422
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "In order to decouple the effect of oversmoothing from these other two factors, we study the oversmoothing problem using the SGC model (Wu et al., 2019). (Results on other GNNs are presented in $\\ S 4 .$ ) SGC is simplified from GCN by removing all projection parameters of graph convolution layers and all nonlinear activations between layers. The estimation of SGC is simply written as: ",
+        "bbox": [
+            174,
+            429,
+            825,
+            484
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/3797d2d699baa795d9d26352d5119fdbe62352e177f850181808e4ed21ded221.jpg",
+        "text": "$$\n\\widehat { \\pmb { Y } } = \\mathrm { s o f t m a x } ( \\tilde { \\bf A } _ { \\mathrm { s y m } } ^ { K } \\pmb { X } \\pmb { W } )\n$$",
+        "text_format": "latex",
+        "bbox": [
+            406,
+            484,
+            591,
+            505
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "where $K$ is the number of graph convolutions, and $\\mathbf { W } \\in \\mathbb { R } ^ { d \\times c }$ denote the learnable parameters of a logistic regression classifier. ",
+        "bbox": [
+            174,
+            506,
+            823,
+            535
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Note that SGC has a fixed number of parameters that does not depend on the number of graph convolutions (i.e. layers). In effect, it is guarded against the influence of overfitting and vanishing gradient problem with more layers. This leaves us only with oversmoothing as a possible cause of performance degradation with increasing $K$ . Interestingly, the simplicity of SGC does not seem to be a sacrifice; it has been observed that it achieves similar or better accuracy in various relational classification tasks (Wu et al., 2019). ",
+        "bbox": [
+            173,
+            541,
+            825,
+            626
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "image",
+        "img_path": "images/e056fc17fa24311b801e0f4522c2a7c33f2c12d1537a95d34e7c694479f35e62.jpg",
+        "image_caption": [
+            "Figure 1: (best in color) SGC’s performance (dashed lines) with increasing graph convolutions $( K )$ on Cora dataset (train/val/test split is $3 \\% / 1 0 \\% / 8 7 \\% )$ ). For each $K$ , we train SGC in 500 epochs, save the model with the best validation accuracy, and report all measures based on the saved model. Measures row-diff and col-diff are computed based on the final layer representation of the saved model. (Solid lines depict after applying our method PAIRNORM, which we discuss in $\\ S 3 . 2 .$ ) "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            176,
+            638,
+            820,
+            734
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Dashed lines in Figure 1 illustrate the performance of SGC on the Cora dataset as we increase the number of layers $( K )$ . The training (cross-entropy) loss monotonically increases with larger $K$ , potentially because graph convolution mixes node representations with their neighbors’ and makes them less distinguishable (training becomes harder). On the other hand, graph convolutions (i.e., smoothing) improve generalization ability, reducing the gap between training and validation/test loss up to $K = 4$ , after which (over)smoothing begins to hurt performance. The row-diff and col-diff both continue decreasing monotonically with $K$ , providing supporting evidence for oversmoothing. ",
+        "bbox": [
+            174,
+            828,
+            825,
+            900
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            171,
+            103,
+            825,
+            133
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3 TACKLING OVERSMOOTHING ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            147,
+            449,
+            164
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3.1 PROPOSED PAIRNORM ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            179,
+            372,
+            195
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "We start by establishing a connection between graph convolution and an optimization problem, that is graph-regularized least squares (GRLS), as shown by NT $\\&$ Maehara (2019). Let $\\bar { \\mathbf { X } } \\in \\mathbb { R } ^ { n \\times d }$ be a new node representation matrix, with $\\bar { \\mathbf { x } } _ { i } \\in \\mathbb { R } ^ { d }$ depicting the $i$ -th row of $\\bar { \\bf X }$ . Then the GRLS problem is given as ",
+        "bbox": [
+            173,
+            202,
+            825,
+            257
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/0fbea636bb0b76a3ccb5945b64ab868ee476e342ab2caad3b7572a32c6d04975.jpg",
+        "text": "$$\n\\underset { \\bar { \\mathbf { X } } } { \\mathrm { m i n } } \\sum _ { i \\in \\mathcal { V } } \\| \\bar { \\mathbf { x } } _ { i } - \\mathbf { x } _ { i } \\| _ { \\bar { \\mathbf { D } } } ^ { 2 } + \\sum _ { ( i , j ) \\in \\mathcal { E } } \\| \\bar { \\mathbf { x } } _ { i } - \\bar { \\mathbf { x } } _ { j } \\| _ { 2 } ^ { 2 }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            356,
+            256,
+            642,
+            292
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "where $\\| \\mathbf { z } _ { i } \\| _ { \\tilde { \\mathbf { D } } } ^ { 2 } = \\mathbf { z } _ { i } ^ { T } \\tilde { \\mathbf { D } } \\mathbf { z } _ { i }$ . The first term can be seen as total degree-weighted least squares. The second is a graph-regularization term that measures the variation of the new features over the graph structure. The goal of the optimization problem can be stated as estimating new “denoised” features $\\bar { \\mathbf { x } } _ { i }$ ’s that are not too far off of the input features $\\mathbf { x } _ { i }$ ’s and are smooth over the graph structure. ",
+        "bbox": [
+            174,
+            294,
+            825,
+            353
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "The GRLS problem has a closed form solution $\\bar { \\mathbf { X } } = ( 2 \\mathbf { I } - \\tilde { \\mathbf { A } } _ { \\mathrm { r w } } ) ^ { - 1 } \\mathbf { X }$ , for which $\\tilde { \\mathbf { A } } _ { \\mathrm { r w } } \\mathbf { X }$ is the firstorder Taylor approximation, that is $\\tilde { \\mathbf { A } } _ { \\mathrm { r w } } \\mathbf { X } \\approx \\bar { \\mathbf { X } }$ . By exchanging $\\tilde { \\mathbf { A } } _ { \\mathrm { r w } }$ with $\\tilde { \\mathbf { A } } _ { \\mathrm { s y m } }$ we obtain the same form as the graph convolution, i.e., $\\tilde { \\mathbf { X } } = \\tilde { \\mathbf { A } } _ { \\mathrm { s y m } } \\mathbf { X } \\approx \\bar { \\mathbf { X } }$ . As such, graph convolution can be viewed as an approximate solution of (5), where it minimizes the variation over the graph structure while keeping the new representations close to the original. ",
+        "bbox": [
+            173,
+            359,
+            825,
+            438
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "The optimization problem in (5) facilitates a closer look to the oversmoothing problem of graph convolution. Ideally, we want to obtain smoothing over nodes within the same cluster, however avoid smoothing over nodes from different clusters. The objective in (5) dictates only the first goal via the graph-regularization term. It is thus prone to oversmoothing when convolutions are applied repeatedly. To circumvent the issue and fulfill both goals simultaneously, we can add a negative term such as the sum of distances between disconnected pairs as follows. ",
+        "bbox": [
+            173,
+            443,
+            825,
+            526
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/2a97a7f94d9fe1296b38921bee678ea16715ad02dc1e89ee90e9bf0dd7b962ca.jpg",
+        "text": "$$\n\\operatorname* { m i n } _ { \\bar { \\mathbf { X } } } \\sum _ { i \\in \\mathcal { V } } \\| \\bar { \\mathbf { x } } _ { i } - \\mathbf { x } _ { i } \\| _ { \\bar { \\mathbf { D } } } ^ { 2 } + \\sum _ { ( i , j ) \\in \\mathcal { E } } \\| \\bar { \\mathbf { x } } _ { i } - \\bar { \\mathbf { x } } _ { j } \\| _ { 2 } ^ { 2 } - \\lambda \\sum _ { ( i , j ) \\notin \\mathcal { E } } \\| \\bar { \\mathbf { x } } _ { i } - \\bar { \\mathbf { x } } _ { j } \\| _ { 2 } ^ { 2 }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            276,
+            526,
+            722,
+            563
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "where $\\lambda$ is a balancing scalar to account for different volume and importance of the two goals.2 By deriving the closed-form solution of (6) and approximating it with first-order Taylor expansion, one can get a revised graph convolution operator with hyperparameter $\\lambda$ . In this paper, we take a different route. Instead of a completely new graph convolution operator, we propose a general and efficient “patch”, called PAIRNORM, that can be applied to any form of graph convolution having the potential of oversmoothing. ",
+        "bbox": [
+            173,
+            563,
+            825,
+            648
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Let $\\tilde { \\mathbf { X } }$ (the output of graph convolution) and $\\dot { \\bf X }$ respectively be the input and output of PAIRNORM. Observing that the output of graph convolution $\\begin{array} { r } { \\tilde { \\mathbf { X } } = \\tilde { \\mathbf { A } } _ { \\mathrm { s y m } } \\tilde { \\mathbf { X } } } \\end{array}$ only achieves the first goal, PAIRNORM serves as a normalization layer that works on $\\tilde { \\mathbf { X } }$ to achieve the second goal of keeping disconnected pair representations farther off. Specifically, PAIRNORM normalizes $\\bar { \\bar { \\mathbf { X } } }$ such that the total pairwise squared distance $\\begin{array} { r } { \\mathrm { T P S D } ( \\dot { \\mathbf { X } } ) : = \\bar { \\sum _ { i , j \\in [ n ] } } \\| \\dot { \\mathbf { x } } _ { i } - \\dot { \\mathbf { x } } _ { j } \\| _ { 2 } ^ { 2 } } \\end{array}$ is the same as $\\mathrm { T P S D } ( \\mathbf { X } )$ . That is, ",
+        "bbox": [
+            173,
+            654,
+            825,
+            736
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/fe14a36c9438f001dba794e1a97338c8f6a65f951577090b28dbef4dd94b2576.jpg",
+        "text": "$$\n\\sum _ { ( i , j ) \\in \\mathcal { E } } \\| \\dot { \\mathbf { x } } _ { i } - \\dot { \\mathbf { x } } _ { j } \\| _ { 2 } ^ { 2 } + \\sum _ { ( i , j ) \\not \\in \\mathcal { E } } \\| \\dot { \\mathbf { x } } _ { i } - \\dot { \\mathbf { x } } _ { j } \\| _ { 2 } ^ { 2 } = \\sum _ { ( i , j ) \\in \\mathcal { E } } \\| { \\mathbf { x } } _ { i } - { \\mathbf { x } } _ { j } \\| _ { 2 } ^ { 2 } + \\sum _ { ( i , j ) \\not \\in \\mathcal { E } } \\| { \\mathbf { x } } _ { i } - { \\mathbf { x } } _ { j } \\| _ { 2 } ^ { 2 } .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            196,
+            737,
+            782,
+            772
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "By keeping the total pairwise squared distance unchanged, the term $\\begin{array} { r } { \\sum _ { ( i , j ) \\notin \\mathcal { E } } \\| \\dot { \\mathbf { x } } _ { i } - \\dot { \\mathbf { x } } _ { j } \\| _ { 2 } ^ { 2 } } \\end{array}$ is guaranteed to be at least as large as the original value $\\begin{array} { r } { \\sum _ { ( i , j ) \\notin \\mathcal { E } } \\| \\mathbf { x } _ { i } - \\mathbf { x } _ { j } \\| _ { 2 } ^ { 2 } } \\end{array}$ since the other term $\\begin{array} { r } { \\sum _ { ( i , j ) \\in \\mathcal { E } } \\| \\dot { \\bf x } _ { i } - \\dot { \\bf x } _ { j } \\| _ { 2 } ^ { 2 } \\approx \\sum _ { ( i , j ) \\in \\mathcal { E } } \\| \\tilde { \\bf x } _ { i } - \\tilde { \\bf x } _ { j } \\| _ { 2 } ^ { 2 } } \\end{array}$ is shrunk through the graph convolution. ",
+        "bbox": [
+            173,
+            773,
+            825,
+            827
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "In practice, instead of always tracking the original value $\\mathrm { T P S D } ( \\mathbf { X } )$ , we can maintain a constant TPSD value $C$ across all layers, where $C$ is a hyperparameter that could be tuned per dataset. ",
+        "bbox": [
+            174,
+            832,
+            823,
+            862
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "To normalize $\\tilde { \\mathbf { X } }$ to constant TPSD, we need to first compute $\\mathrm { T P S D } ( \\tilde { \\mathbf { X } } )$ . Directly computing TPSD involves $n ^ { 2 }$ pairwise distances that is $\\mathcal { O } ( n ^ { 2 } d )$ , which can be time consuming for large datasets. ",
+        "bbox": [
+            176,
+            868,
+            820,
+            898
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Equivalently, normalization can be done via a two-step approach where TPSD is rewritten as3 ",
+        "bbox": [
+            171,
+            103,
+            787,
+            118
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/d2c51f3f4a475927c18db0bab73292f4a1dde27d6af293dbcea11245158c21e2.jpg",
+        "text": "$$\n\\begin{array} { r c l } { \\mathrm { T P S D } ( \\tilde { \\mathbf { X } } ) } & { = } & { \\displaystyle \\sum _ { i , j \\in [ n ] } \\| \\tilde { \\mathbf { x } } _ { i } - \\tilde { \\mathbf { x } } _ { j } \\| _ { 2 } ^ { 2 } } & { = } & { \\displaystyle 2 n ^ { 2 } \\bigg ( \\frac { 1 } { n } \\sum _ { i = 1 } ^ { n } \\| \\tilde { \\mathbf { x } } _ { i } \\| _ { 2 } ^ { 2 } - \\| \\frac { 1 } { n } \\sum _ { i = 1 } ^ { n } \\tilde { \\mathbf { x } } _ { i } \\| _ { 2 } ^ { 2 } \\bigg ) ~ . } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            246,
+            117,
+            748,
+            160
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "The first term (ignoring the scale $2 n ^ { 2 }$ ) in Eq. (8) represents the mean squared length of node representations, and the second term depicts the squared length of the mean of node representations. To simplify the computation of (8), we subtract the row-wise mean from each $\\widetilde { \\mathbf { x } } _ { i }$ , i.e., $\\begin{array} { r } { \\tilde { \\mathbf { x } } _ { i } ^ { c } = \\tilde { \\mathbf { x } } _ { i } - \\frac { 1 } { n } \\sum _ { i } ^ { n } \\tilde { \\mathbf { x } } _ { i } ^ { \\cdot } } \\end{array}$ where $\\tilde { \\mathbf { x } } _ { i } ^ { c }$ denotes the centered representation. Note that this shifting does not affect the TPSD, and furthermore drives the term $\\begin{array} { r } { \\| \\frac { 1 } { n } \\sum _ { i = 1 } ^ { n } \\tilde { \\mathbf { x } } _ { i } \\| _ { 2 } ^ { 2 } } \\end{array}$ to zero, where computing $\\mathrm { T P S D } ( \\tilde { \\mathbf { X } } )$ boils down to calculating the squared Frobenius norm of $\\tilde { \\mathbf { X } } ^ { c }$ and overall takes $\\mathcal { O } ( n d )$ . That is, ",
+        "bbox": [
+            173,
+            161,
+            825,
+            252
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "In summary, our proposed PAIRNORM (with input $\\tilde { \\mathbf { X } }$ and output $\\dot { \\bf X }$ ) can be written as a two-step, center-and-scale, normalization procedure: ",
+        "bbox": [
+            174,
+            273,
+            826,
+            301
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/7698a4e1afffe1f97e0d320ea22a3071e2c3eeb0d04e2127a7395799ae5d52bf.jpg",
+        "text": "$$\n\\begin{array} { l } { \\displaystyle \\widetilde { \\mathbf { x } } _ { i } ^ { c } = \\widetilde { \\mathbf { x } } _ { i } - \\frac { 1 } { n } \\sum _ { i = 1 } ^ { n } \\widetilde { \\mathbf { x } } _ { i } } \\\\ { \\displaystyle \\dot { \\mathbf { x } } _ { i } = s \\cdot \\frac { \\widetilde { \\mathbf { x } } _ { i } ^ { c } } { \\sqrt { \\frac { 1 } { n } \\sum _ { i = 1 } ^ { n } \\| \\widetilde { \\mathbf { x } } _ { i } ^ { c } \\| _ { 2 } ^ { 2 } } } = s \\sqrt { n } \\cdot \\frac { \\widetilde { \\mathbf { x } } _ { i } ^ { c } } { \\sqrt { \\| \\widetilde { \\mathbf { X } } ^ { c } \\| _ { F } ^ { 2 } } } } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            281,
+            301,
+            594,
+            387
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "After scaling the data remains centered, that is, $\\begin{array} { r } { \\| \\sum _ { i = 1 } ^ { n } \\dot { \\bf x } _ { i } \\| _ { 2 } ^ { 2 } = 0 } \\end{array}$ . In Eq. (11), $s$ is a hyperparameter that determines $C$ . Specifically, ",
+        "bbox": [
+            174,
+            386,
+            821,
+            415
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/17f5e6afca0614ec6b55df9d8e247ff3886dcdef6778d3e569054b8eed61eaa6.jpg",
+        "text": "$$\n\\mathrm { T P S D } ( { \\dot { \\mathbf { X } } } ) = 2 n \\| { \\dot { \\mathbf { X } } } \\| _ { F } ^ { 2 } = 2 n \\sum _ { i } \\| s \\cdot { \\frac { { \\tilde { \\mathbf { x } } } _ { i } ^ { c } } { \\sqrt { { \\frac { 1 } { n } } \\sum _ { i } \\| { \\tilde { \\mathbf { x } } } _ { i } ^ { c } \\| _ { 2 } ^ { 2 } } } } \\| _ { 2 } ^ { 2 } = 2 n { \\frac { s ^ { 2 } } { { \\frac { 1 } { n } } \\sum _ { i } \\| { \\tilde { \\mathbf { x } } } _ { i } ^ { c } \\| _ { 2 } ^ { 2 } } } \\sum _ { i } \\| { \\tilde { \\mathbf { x } } } _ { i } ^ { c } \\| _ { 2 } ^ { 2 } = 2 n ^ { 2 } s ^ { 2 }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            187,
+            414,
+            807,
+            458
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Then, $\\dot { \\mathbf { X } } : = \\operatorname { P A I R N O R M } ( \\tilde { \\mathbf { X } } )$ has row-wise mean 0 (i.e., is centered) and constant total pairwise squared distance $C = 2 n ^ { 2 } s ^ { 2 }$ . An illustration of PAIRNORM is given in Figure 2. The output of PAIRNORM is input to the next convolution layer. ",
+        "bbox": [
+            176,
+            469,
+            823,
+            513
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "image",
+        "img_path": "images/2ff10cf2c9b16a85d50a14972c75e76d008f98564f6afd7d7414e2f0a2e29a43.jpg",
+        "image_caption": [
+            "Figure 2: Illustration of PAIRNORM, comprising centering and rescaling steps. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            299,
+            522,
+            692,
+            606
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "We also derive a variant of PAIRNORM by replacing Pni=1 $\\textstyle \\sum _ { i = 1 } ^ { n } \\| \\tilde { \\mathbf { x } } _ { i } ^ { c } \\| _ { 2 } ^ { 2 }$ in Eq. (11) with $n \\| \\tilde { \\mathbf { x } } _ { i } ^ { c } \\| _ { 2 } ^ { 2 }$ , such that the scaling step computes $\\begin{array} { r l r } { \\dot { \\bf x } _ { i } } & { { } = } & { s } \\end{array}$ $\\frac { \\tilde { \\mathbf { x } } _ { i } ^ { c } } { \\| \\tilde { \\mathbf { x } } _ { i } ^ { c } \\| _ { 2 } }$ . We call it PAIRNORM-SI (for Scale Individually), which imposes more restriction on node representations, such that all have the same $L _ { 2 }$ -norm s. In practice we found that both PAIRNORM and PAIRNORM-SI work well for SGC, whereas PAIRNORM-SI provides better and more stable results for GCN and ",
+        "bbox": [
+            174,
+            631,
+            446,
+            804
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "image",
+        "img_path": "images/b9b02294bb59dc6d8e0bda469d7e4ba2d7b2027c3126730591eccadd3fd0a7e2.jpg",
+        "image_caption": [
+            "Figure 3: (best in color) Performance comparison of the original (dashed) vs. PAIRNORM-enhanced (solid) GCN and GAT models with increasing layers on Cora. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            462,
+            631,
+            818,
+            734
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "GAT. The reason why GCN and GAT require stricter normalization may be because they have more parameters and are more prone to overfitting. In Appx. A.6 we provide additional measures to demonstrate why PAIRNORM and PAIRNORM-SI work. In all experiments, we employ PAIRNORM for SGC and PAIRNORM-SI for both GCN and GAT. ",
+        "bbox": [
+            174,
+            805,
+            825,
+            861
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "PAIRNORM is effective and efficient in solving the oversmoothing problem of GNNs. As a general normalization layer, it can be used for any GNN. Solid lines in Figure 1 present the performance of SGC on Cora with increasing number of layers, where we employ PAIRNORM after each graph convolution layer, as compared to ‘vanilla’ versions. Similarly, Figure 3 is for GCN and GAT (PAIRNORM is applied after the activation of each graph convolution). Note that the performance decay with PAIRNORM-at-work is much slower. (See Fig.s 5–6 in Appx. A.3 for other datasets.) ",
+        "bbox": [
+            176,
+            867,
+            823,
+            896
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            103,
+            823,
+            160
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "While PAIRNORM enables deeper models that are more robust to oversmoothing, it may seem odd that the overall test accuracy does not improve. In fact, the benchmark graph datasets often used in the literature require no more than 4 layers, after which performance decays (even if slowly). In the next section, we present a realistic use case setting for which deeper models are more likely to provide higher performance, where the benefit of PAIRNORM becomes apparent. ",
+        "bbox": [
+            174,
+            166,
+            825,
+            236
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "3.2 A CASE WHERE DEEPER GNNS ARE BENEFICIAL",
+        "text_level": 1,
+        "bbox": [
+            174,
+            242,
+            560,
+            257
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "In general, oversmoothing gets increasingly more severe as the number of layers goes up. A task would benefit from employing PAIRNORM more if it required a large number of layers to achieve its best performance. To this effect we study the “missing feature setting”, where a subset of the nodes lack feature vectors. Let $\\mathcal { M } \\subseteq \\mathcal { V } _ { u }$ be the set where $\\forall m \\in \\mathcal { M } , \\mathbf { x } _ { m } = \\varnothing$ , i.e., all of their features are missing. We denote with $p = | \\mathcal { M } | / | \\mathcal { V } _ { u } |$ the missing fraction. We call this variant of the task as semi-supervised node classification with missing vectors (SSNC-MV). Intuitively, one would require a larger number of propagation steps (hence, a deeper GNN) to be able to “recover” effective feature representations for these nodes. ",
+        "bbox": [
+            173,
+            263,
+            825,
+            376
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "SSNC-MV is a general and realistic problem that finds several applications in the real world. For example, the credit lending problem of identifying low- vs. high-risk customers (nodes) can be modeled as SSNC-MV where a large fraction of nodes do not exhibit any meaningful features (e.g., due to low-volume activity). In fact, many graph-based classification tasks with the cold-start issue (entity with no history) can be cast into SSNC-MV. To our knowledge, this is the first work to study the SSNC-MV problem using GNN models. ",
+        "bbox": [
+            173,
+            382,
+            825,
+            467
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Figure 4 presents the performance of SGC, GCN, and GAT models on Cora with increasing number of layers, where we remove feature vectors from all the unlabeled nodes, i.e. $p = 1$ . The models with PAIRNORM achieve a higher test accuracy compared to those without, which they typically reach at a larger number of layers. (See Fig. 7 in Appx. A.4 for results on other datasets.) ",
+        "bbox": [
+            173,
+            473,
+            823,
+            530
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "image",
+        "img_path": "images/0abf2f40b7df4f3cbaf62dab4285a89478bce20eb97fadcdd87298fb24504034.jpg",
+        "image_caption": [
+            "Figure 4: (best in color) Comparison of ‘vanilla’ vs. PAIRNORM-enhanced SGC, GCN, and GAT performance on Cora for $p = 1$ . Green diamond symbols depict the layer at which validation accuracy peaks. PAIRNORM boosts overall performance by enabling more robust deep GNNs. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            207,
+            534,
+            787,
+            657
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "4 EXPERIMENTS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            710,
+            326,
+            726
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "In section 3 we have shown the robustness of PAIRNORM-enhanced models against increasing number of layers in SSNC problem. In this section we design extensive experiments to evaluate the effectiveness of PAIRNORM under the SSNC-MV setting, over SGC, GCN and GAT models. ",
+        "bbox": [
+            173,
+            741,
+            823,
+            784
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "4.1 EXPERIMENT SETUP ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            790,
+            357,
+            805
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Datasets. We use 4 well-known benchmark datasets in GNN domain: Cora, Citeseer, Pubmed (Sen et al., 2008), and CoauthorCS (Shchur et al., 2018). Their statistics are reported in Appx. A.2. For Cora, Citeseer and Pubmed, we use the same dataset splits as Kipf & Welling (2017), where all nodes outside train and validation are used as test set. For CoauthorCS, we randomly split all nodes into train/val/test as $3 \\% / 1 0 \\% / 8 7 \\%$ , and keep the same split for all experiments. ",
+        "bbox": [
+            174,
+            811,
+            825,
+            881
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Models. We use three different GNN models as our base model: SGC (Wu et al., 2019), GCN (Kipf & Welling, 2017), and GAT (Velickovic et al., 2018). We compare our PAIRNORM with residual connection method (He et al., 2016) over base models (except SGC since there is no “residual connected” SGC), as we surprisingly find it can slow down oversmoothing and benefit SSNCMV problem. Similar to us, residual connection is a general technique that can be applied to any model without changing its architecture. We focus on the comparison between the base models and PAIRNORM-enhanced models, rather than achieving the state of the art performance for SSNC and SSNC-MV. There exist a few other work addressing oversmoothing (Klicpera et al., 2019; Li et al., 2018; Rong et al., 2019; Xu et al., 2018) however they design specialized architectures and not simple “patch” procedures like PAIRNORM that can be applied on top of any GNN. ",
+        "bbox": [
+            176,
+            882,
+            823,
+            924
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            103,
+            825,
+            200
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Hyperparameters. We choose the hyperparameter $s$ of PAIRNORM from $\\{ 0 . 1 , 1 , 1 0 , 5 0 , 1 0 0 \\}$ over validation set for SGC, while keeping it fixed at $s = 1$ for both GCN and GAT due to resource limitations. We set the #hidden units of GCN and GAT (#attention heads is set to 1) to 32 and 64 respectively for all datasets. Dropout with rate 0.6 and $L _ { 2 }$ regularization with penalty $5 \\cdot 1 0 ^ { - 4 } $ are applied to GCN and GAT. For SGC, we vary number of layers in $\\{ 1 , 2 , \\ldots 1 0 , 1 5 , \\ldots , 6 0 \\}$ and for GCN and GAT in $\\{ 2 , 4 , \\dots , 1 2 , 1 5 , 2 0 , \\dots , 3 0 \\}$ . ",
+        "bbox": [
+            174,
+            202,
+            825,
+            285
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Configurations. For PAIRNORM-enhanced models, we apply PAIRNORM after each graph convolution layer (i.e., after activation if any) in the base model. For residual-connected models with $t$ skip steps, we connect the output of $l$ -th layer to $( l + t )$ -th, that is, $\\mathbf { H } _ { \\mathrm { n e w } } ^ { ( l + t ) } = \\mathbf { H } ^ { ( l + t ) } + \\mathbf { H } ^ { ( l ) }$ where $\\mathbf { H } ^ { ( \\bar { l } ) }$ denotes the output of $l$ -th graph convolution (after activation). For the SSNC-MV setting, we randomly erase $p$ fraction of the feature vectors from nodes in validation and test sets (for which we input vector $\\mathbf { 0 } \\in \\mathbb { R } ^ { d }$ ), whereas all training (labeled) nodes keep their original features (See 3.2). We run each experiment within 1000 epochs 5 times and report the average performance. We mainly use a single GTX-1080ti GPU, with some SGC experiments ran on an Intel i7-8700k CPU. ",
+        "bbox": [
+            174,
+            285,
+            825,
+            401
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "4.2 EXPERIMENT RESULTS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            409,
+            375,
+            421
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "We first show the global performance gain of applying PAIRNORM to SGC for SSNC-MV under varying feature missing rates as shown in Table 1. PAIRNORM-enhanced SGC performs similar or better over $0 \\%$ missing, while it significantly outperforms vanilla SGC for most other settings, especially for larger missing rates. #L denotes the best number of layers for the model that yields the largest average validation accuracy (over 5 runs), for which we report the average test accuracy (Acc). Notice the larger #L values for SGC-PN compared to vanilla SGC, which shows the power of PAIRNORM for enabling “deep” SGC models by effectively tackling oversmoothing. ",
+        "bbox": [
+            174,
+            429,
+            825,
+            527
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Similar to Wu et al. (2019) who showed that the simple SGC model achieves comparable or better performance as other GNNs for various tasks, we found PAIRNORM-enhanced SGC to follow the same trend when compared with PAIRNORM-enhanced GCN and GAT, for all SSNC-MV settings. Due to its simplicity and extreme efficiency, we believe PAIRNORM-enhanced SGC sets a strong baseline for the SSNC-MV problem. ",
+        "bbox": [
+            174,
+            534,
+            825,
+            604
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "table",
+        "img_path": "images/39d65723fe4096cd49057c52dcdb68dfdc36fb0eb85efd9ea315f3859c346bf3.jpg",
+        "table_caption": [
+            "Table 1: Comparison of ‘vanilla’ vs. PAIRNORM-enhanced SGC performance in Cora, Citeseer, Pubmed, and CoauthorCS for SSNC-MV problem, with missing rate ranging from $0 \\%$ to $1 0 0 \\%$ . Showing test accuracy at #L ( $K$ in Eq. 4) layers, at which model achieves best validation accuracy. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td colspan=\"2\">Missing Percentage Dataset Method</td><td colspan=\"2\">0% Acc #L</td><td colspan=\"2\">20% Acc #L</td><td colspan=\"2\">40% Acc #L</td><td colspan=\"2\">60% Acc #L</td><td colspan=\"2\">80% Acc #L</td><td colspan=\"2\">100% Acc #L</td></tr><tr><td rowspan=\"2\">Cora</td><td>SGC</td><td>0.815</td><td>4</td><td>0.806</td><td>5</td><td>|0.786</td><td>3</td><td>0.742</td><td>4</td><td>0.733</td><td></td><td>310.423</td><td>315</td></tr><tr><td>SGC-PN</td><td>0.811</td><td>7</td><td>0.799</td><td>7</td><td>0.797</td><td>7</td><td>0.783</td><td>20</td><td>0.780</td><td>25</td><td>0.745</td><td>40</td></tr><tr><td rowspan=\"2\">Citeseer</td><td>SGC</td><td>0.689</td><td>10</td><td>0.684</td><td>6</td><td>0.668</td><td>8</td><td>0.657</td><td></td><td>9 0.565</td><td></td><td>80.290</td><td>2</td></tr><tr><td>SGC-PN</td><td>0.706</td><td>3</td><td>0.695</td><td>3</td><td>0.653</td><td>4</td><td>0.641</td><td></td><td>5 0.590</td><td></td><td>500.486</td><td>50</td></tr><tr><td rowspan=\"2\">Pubmed</td><td>SGC</td><td>0.754</td><td>1</td><td>0.748</td><td></td><td>0.723</td><td></td><td>410.746</td><td></td><td>20.659</td><td></td><td>30.399</td><td>35</td></tr><tr><td>SGC-PN</td><td>0.782</td><td>9</td><td>0.781</td><td>1 7</td><td>0.778</td><td></td><td>600.782</td><td></td><td>7 0.772</td><td></td><td>600.719</td><td>40</td></tr><tr><td rowspan=\"2\">CoauthorCs</td><td>SGC</td><td>0.914</td><td>1</td><td>10.898</td><td></td><td>0.877</td><td></td><td>210.824</td><td></td><td>210.751</td><td></td><td>40.318</td><td>2</td></tr><tr><td>SGC-PN</td><td>0.915</td><td>2</td><td>0.909</td><td>22</td><td>0.899</td><td>3</td><td>0.891</td><td></td><td>4 0.880</td><td></td><td>80.860</td><td>20</td></tr></table>",
+        "bbox": [
+            218,
+            655,
+            776,
+            814
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "We next employ PAIRNORM-SI for GCN and GAT under the same setting, comparing it with the residual (skip) connections technique. Results are shown in Table 2 and Table 3 respectively for GCN and GAT. Due to space and resource limitations, we only show results for $0 \\%$ and $1 0 0 \\%$ missing rate scenarios. (We provide results for other missing rates $( 7 0 , 8 0 , 9 0 \\% )$ over 1 run only in Appx. A.5.) We observe similar trend for GCN and GAT: (1) vanilla model suffers from performance drop under SSNC-MV with increasing missing rate; (2) both residual connections and PAIRNORM-SI enable deeper models and improve performance (note the larger $\\# \\mathrm { L }$ and Acc); (3) GCN-PN and ",
+        "bbox": [
+            173,
+            825,
+            825,
+            924
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "GAT-PN achieve performance that is comparable or better than just using skips; (4) performance can be further improved (albeit slightly) by using skips along with PAIRNORM-SI.4 ",
+        "bbox": [
+            171,
+            103,
+            823,
+            132
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "table",
+        "img_path": "images/cf23c7abdbff13e158246489c4ab4456274b743e56d4e93f41a5e359d710f70c.jpg",
+        "table_caption": [
+            "Table 2: Comparison of ‘vanilla’ and (PAIRNORM-SI/ residual)-enhanced GCN performance on Cora, Citeseer, Pubmed, and CoauthorCS for SSNC-MV problem, with $0 \\%$ and $1 0 0 \\%$ feature missing rate. $t$ represents the skip-step of residual connection. (See A.5 Fig. 8 for more settings.) "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=\"2\">Dataset Missing(%) Method</td><td colspan=\"3\">Cora</td><td colspan=\"4\">Citeseer</td><td colspan=\"4\">Pubmed</td><td colspan=\"4\">CoauthorCs</td></tr><tr><td colspan=\"2\">0% Acc #L</td><td colspan=\"2\">100% Acc #L</td><td colspan=\"2\">0% Acc #L</td><td colspan=\"2\">100% Acc #L</td><td colspan=\"2\">0% Acc #L</td><td colspan=\"2\">100% Acc #L</td><td colspan=\"2\">0% Acc #L</td><td colspan=\"2\">100% Acc #L</td></tr><tr><td>GCN</td><td>|0.821</td><td>2|0.582</td><td></td><td>2</td><td>0.695</td><td>0.313</td><td></td><td>2</td><td>|0.779</td><td>2|0.449</td><td></td><td>2</td><td>|0.877</td><td></td><td>210.452</td><td>4</td></tr><tr><td></td><td></td><td></td><td></td><td></td><td></td><td>2</td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td></tr><tr><td>GCN-PN GCN-t1</td><td>[0.790 0.822</td><td>2</td><td>0.731</td><td>10</td><td>0.660</td><td></td><td>0.498</td><td>8</td><td>0.780</td><td>30</td><td>0.745</td><td>25 25</td><td>10.910 0.898</td><td>2</td><td>0.846 0.727</td><td>12 12</td></tr><tr><td>GCN-t1-PN</td><td>0.780</td><td>2 2</td><td>0.721 0.724</td><td>15 30</td><td>0.696 0.648</td><td></td><td>0.441 0.465</td><td>12 10</td><td>0.780 0.756</td><td>2 15</td><td>0.656 0.690</td><td>12</td><td>0.898</td><td>2 2</td><td>0.830</td><td>20</td></tr><tr><td>GCN-t2</td><td>0.820</td><td>2</td><td>0.722</td><td>10</td><td>0.691</td><td></td><td>0.432</td><td>20</td><td>0.779</td><td>2</td><td>0.645</td><td>20</td><td>0.882</td><td>4</td><td>0.630</td><td>20</td></tr><tr><td>GCN-t2-PN</td><td>0.785</td><td>4</td><td>0.740</td><td>30</td><td>0.650</td><td>22222</td><td>0.508</td><td>12</td><td>0.770</td><td>15</td><td>0.725</td><td>30</td><td>0.911</td><td>2</td><td>0.839</td><td>20</td></tr></table>",
+        "bbox": [
+            192,
+            181,
+            802,
+            314
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "table",
+        "img_path": "images/bb959ec3417f3840995c7c29944fe7f37068c014179d29bad9de3e8aca6289f2.jpg",
+        "table_caption": [
+            "Table 3: Comparison of ‘vanilla’ and (PAIRNORM-SI/ residual)-enhanced GAT performance on Cora, Citeseer, Pubmed, and CoauthorCS for SSNC-MV problem, with $0 \\%$ and $1 0 0 \\%$ feature missing rate. $t$ represents the skip-step of residual connection. (See A.5 Fig. 9 for more settings.) "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=\"2\">Dataset Missing(%) Method</td><td rowspan=\"2\">0%</td><td colspan=\"2\">Cora 100%</td><td colspan=\"4\">Citeseer</td><td colspan=\"4\">Pubmed</td><td colspan=\"4\">Coauthorcs</td></tr><tr><td colspan=\"2\"></td><td colspan=\"2\">0% Acc #L</td><td colspan=\"2\">100% Acc #L</td><td colspan=\"2\">0% Acc #L</td><td colspan=\"2\">100% Acc #L</td><td colspan=\"2\">0% Acc #L</td><td colspan=\"2\">100% Acc #L</td></tr><tr><td></td><td>Acc #L 0.823</td><td></td><td>Acc #L</td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td></tr><tr><td>GAT</td><td></td><td>2|</td><td>0.653</td><td>4</td><td>0.693</td><td>210.428</td><td></td><td>4 |0.774</td><td></td><td>6|0.631</td><td></td><td>4 [0.892</td><td></td><td>4|0.737</td><td>4</td></tr><tr><td>GAT-PN</td><td>0.787</td><td>2</td><td>0.718</td><td>6</td><td>0.670</td><td>2 0.483</td><td>4</td><td>0.774</td><td>12</td><td>0.714</td><td>10</td><td>0.916</td><td>2</td><td>0.843</td><td>8</td></tr><tr><td>GAT-t1</td><td>0.822 0.787</td><td>2</td><td>0.706</td><td>8</td><td>0.693</td><td>2 0.461</td><td>6</td><td>0.769</td><td>4</td><td>0.698</td><td>8</td><td>0.899</td><td>4 2</td><td>0.842</td><td>10</td></tr><tr><td>GAT-t1-PN GAT-t2</td><td>0.820</td><td>2 2</td><td>0.710 0.691</td><td>10</td><td>0.658</td><td>6 0.500 0.461</td><td>10 6</td><td>0.757 0.774</td><td>4 8</td><td>0.684 0.702</td><td>12 8</td><td>0.911 0.895</td><td></td><td>0.844 0.803</td><td>20</td></tr><tr><td>GAT-t2-PN</td><td>0.788</td><td>4</td><td>0.738</td><td>8 12</td><td>s0.692 0.672</td><td>2 4 0.517</td><td>10</td><td>0.776</td><td>15</td><td>0.704</td><td>12</td><td>0.917</td><td>4 2</td><td>0.855</td><td>6 30</td></tr></table>",
+        "bbox": [
+            191,
+            361,
+            805,
+            494
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "5 RELATED WORK ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            508,
+            344,
+            525
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Oversmoothing in GNNs: Li et al. (2018) was the first to call attention to the oversmoothing problem. Xu et al. (2018) introduced Jumping Knowledge Networks, which employ skip connections for multi-hop message passing and also enable different neighborhood ranges. Klicpera et al. (2019) proposed a propagation scheme based on personalized Pagerank that ensures locality (via teleports) which in turn prevents oversmoothing. Li et al. (2019) built on ideas from ResNet to use residual as well as dense connections to train deep GCNs. DropEdge Rong et al. (2019) proposed to alleviate oversmoothing through message passing reduction via removing a certain fraction of edges at random from the input graph. These are all specialized solutions that introduce additional parameters and/or a different network architecture. ",
+        "bbox": [
+            173,
+            540,
+            825,
+            665
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Normalization Schemes for Deep-NNs: There exist various normalization schemes proposed for deep neural networks, including batch normalization Ioffe & Szegedy (2015), weight normalization Salimans & Kingma (2016), layer normalization Ba et al. (2016), and so on. Conceptually these have substantially different goals (e.g., reducing training time), and were not proposed for graph neural networks nor the oversmoothing problem therein. Important difference to note is that larger depth in regular neural-nets does not translate to more hops of propagation on a graph structure. ",
+        "bbox": [
+            174,
+            666,
+            825,
+            750
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "6 CONCLUSION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            765,
+            318,
+            781
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "We investigated the oversmoothing problem in GNNs and proposed PAIRNORM, a novel normalization layer that boosts the robustness of deep GNNs against oversmoothing. PAIRNORM is fast to compute, requires no change in network architecture nor any extra parameters, and can be applied to any GNN. Experiments on real-world classification tasks showed the effectiveness of PAIRNORM, where it provides performance gains when the task benefits from more layers. Future work will explore other use cases of deeper GNNs that could further showcase PAIRNORM’s advantages. ",
+        "bbox": [
+            174,
+            796,
+            825,
+            881
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "REFERENCES ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            102,
+            287,
+            118
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Jimmy Lei Ba, Jamie Ryan Kiros, and Geoffrey E Hinton. Layer normalization. CoRR, abs/1607.06450, 2016. ",
+        "bbox": [
+            173,
+            132,
+            825,
+            161
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Olivier Chapelle, Bernhard Scholkopf, and Alexander Zien. ¨ Semi-Supervised Learning. 2006. ",
+        "bbox": [
+            174,
+            170,
+            790,
+            185
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "William L. Hamilton, Zhitao Ying, and Jure Leskovec. Inductive representation learning on large graphs. In NIPS, pp. 1024–1034, 2017. ",
+        "bbox": [
+            174,
+            194,
+            820,
+            223
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Kaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. Deep Residual Learning for Image Recognition. In Proceedings of 2016 IEEE Conference on Computer Vision and Pattern Recognition, pp. 770–778. IEEE, 2016. ",
+        "bbox": [
+            176,
+            232,
+            823,
+            275
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Sergey Ioffe and Christian Szegedy. Batch normalization: Accelerating deep network training by reducing internal covariate shift. CoRR, abs/1502.03167, 2015. ",
+        "bbox": [
+            173,
+            284,
+            821,
+            313
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Thomas N. Kipf and Max Welling. Semi-supervised classification with graph convolutional networks. In International Conference on Learning Representations (ICLR). OpenReview.net, 2017. ",
+        "bbox": [
+            173,
+            320,
+            823,
+            352
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Johannes Klicpera, Aleksandar Bojchevski, and Stephan Gunnemann. Combining neural networks ¨ with personalized pagerank for classification on graphs. In International Conference on Learning Representations (ICLR), 2019. ",
+        "bbox": [
+            171,
+            358,
+            823,
+            402
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Guohao Li, Matthias Muller, Ali Thabet, and Bernard Ghanem. Can GCNs go as deep as CNNs? ¨ CoRR, abs/1904.03751, 2019. ",
+        "bbox": [
+            173,
+            410,
+            823,
+            440
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Qimai Li, Zhichao Han, and Xiao-Ming Wu. Deeper Insights into Graph Convolutional Networks for Semi-Supervised Learning. In Proceedings of the 32nd AAAI Conference on Artificial Intelligence, pp. 3538–3545, 2018. ",
+        "bbox": [
+            173,
+            448,
+            823,
+            492
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Hoang NT and Takanori Maehara. Revisiting graph neural networks: All we have is low-pass filters. CoRR, abs/1905.09550, 2019. ",
+        "bbox": [
+            173,
+            500,
+            821,
+            530
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Meng Qu, Yoshua Bengio, and Jian Tang. Gmnn: Graph markov neural networks. In International Conference on Machine Learning, pp. 5241–5250, 2019. ",
+        "bbox": [
+            173,
+            537,
+            823,
+            568
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Yu Rong, Wenbing Huang, Tingyang Xu, and Junzhou Huang. The truly deep graph convolutional networks for node classification. CoRR, abs/1907.10903, 2019. ",
+        "bbox": [
+            174,
+            575,
+            823,
+            604
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Tim Salimans and Durk P Kingma. Weight normalization: A simple reparameterization to accelerate training of deep neural networks. In Advances in Neural Information Processing Systems, pp. 901–909, 2016. ",
+        "bbox": [
+            174,
+            613,
+            823,
+            656
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Prithviraj Sen, Galileo Namata, Mustafa Bilgic, Lise Getoor, Brian Galligher, and Tina Eliassi-Rad. Collective classification in network data. AI magazine, 29(3):93–93, 2008. ",
+        "bbox": [
+            171,
+            664,
+            821,
+            694
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Oleksandr Shchur, Maximilian Mumme, Aleksandar Bojchevski, and Stephan Gunnemann. Pitfalls ¨ of graph neural network evaluation. arXiv preprint arXiv:1811.05868, 2018. ",
+        "bbox": [
+            171,
+            702,
+            823,
+            732
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Petar Velickovic, Guillem Cucurull, Arantxa Casanova, Adriana Romero, Pietro Li, and Yoshua Bengio. Graph attention networks. In International Conference on Learning Representations (ICLR). OpenReview.net, 2018. ",
+        "bbox": [
+            173,
+            739,
+            825,
+            784
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Felix Wu, Amauri H. Souza Jr., Tianyi Zhang, Christopher Fifty, Tao Yu, and Kilian Q. Weinberger. Simplifying graph convolutional networks. In ICML, volume 97 of Proceedings of Machine Learning Research, pp. 6861–6871. PMLR, 2019. ",
+        "bbox": [
+            173,
+            791,
+            823,
+            835
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Keyulu Xu, Chengtao Li, Yonglong Tian, Tomohiro Sonobe, Ken-ichi Kawarabayashi, and Stefanie Jegelka. Representation Learning on Graphs with Jumping Knowledge Networks. In Proceedings of the 35th International Conference on Machine Learning, volume 80, pp. 5453–5462, 2018. ",
+        "bbox": [
+            174,
+            843,
+            826,
+            887
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "A APPENDIX ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            102,
+            299,
+            117
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "A.1 DERIVATION OF EQ. 8 ",
+        "bbox": [
+            176,
+            133,
+            374,
+            148
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "equation",
+        "img_path": "images/fa2db0323ee062b173bbf75fbbe53d3843a69a716d76354d19d0ed59959bd6ae.jpg",
+        "text": "$$\n\\begin{array} { l } { { \\displaystyle \\mathrm { T P S D } ( \\widetilde { \\mathbf { X } } ) = \\sum _ { i , j \\in [ n ] } \\big \\| \\widetilde { \\mathbf { x } } _ { i } - \\widetilde { \\mathbf { x } } _ { j } \\big \\| _ { 2 } ^ { 2 } = \\sum _ { i , j \\in [ n ] } \\big ( \\widetilde { \\mathbf { x } } _ { i } - \\widetilde { \\mathbf { x } } _ { j } \\big ) ^ { T } ( \\widetilde { \\mathbf { x } } _ { i } - \\mathbf { y } ) } } \\\\ { { \\displaystyle = \\sum _ { i , j \\in [ n ] } \\big ( \\widetilde { \\mathbf { x } } _ { i } ^ { T } \\widetilde { \\mathbf { x } } _ { j } + \\widetilde { \\mathbf { x } } _ { j } ^ { T } \\widetilde { \\mathbf { x } } _ { j } - 2 \\widetilde { \\mathbf { x } } _ { i } ^ { T } \\widetilde { \\mathbf { x } } _ { j } \\big ) } } \\\\ { { \\displaystyle = 2 n \\sum _ { i } \\sum _ { j \\in [ n ] } \\widetilde { \\mathbf { x } } _ { i } ^ { T } \\widetilde { \\mathbf { x } } _ { i } - 2 \\sum _ { j \\in [ n ] } \\widetilde { \\mathbf { x } } _ { i } ^ { T } \\widetilde { \\mathbf { x } } _ { j } } } \\\\ { { \\displaystyle \\quad = 2 n \\sum _ { i } \\sum _ { j \\in [ n ] } \\widetilde { \\mathbf { x } } _ { i } \\widetilde { \\mathbf { x } } _ { i } - 2 \\sum _ { i } \\sum _ { j \\in [ n ] } \\widetilde { \\mathbf { x } } _ { i } ^ { T } \\widetilde { \\mathbf { x } } _ { j } } } \\\\ { { \\displaystyle \\qquad \\quad = 2 n \\sum _ { i \\in [ n ] } \\big \\| \\widetilde { \\mathbf { x } } _ { i } \\big \\| _ { 2 } ^ { 2 } - 2 1 ^ { T } \\widetilde { \\mathbf { x } } \\widetilde { \\mathbf { x } } ^ { T } \\widetilde { \\mathbf { 1 } } } } \\\\ { { \\displaystyle \\qquad \\quad = 2 n \\sum _ { i \\in [ n ] } \\big \\| \\widetilde { \\mathbf { x } } _ { i } \\big \\| _ { 2 } ^ { 2 } - 2 \\big \\| \\mathbf { 1 } ^ { T } \\widetilde { \\mathbf { x } } _ { i } \\big \\| _ { 2 } ^ { 2 } } } \\\\ { { \\displaystyle \\qquad \\quad = 2 n \\Big ( \\Big \\frac { 1 } { n } \\sum _ { i = [ n ] } ^ { n } \\big \\| \\widetilde { \\mathbf { x } } _ { i } \\big \\| _ { 2 } ^ { 2 } - \\big \\| \\widetilde { \\mathbf { x } } _ { i } ^ { n } \\big \\| _ { 2 } ^ { 2 } } } \\\\   \\displaystyle \\qquad = 2 n ^ { 2 } \\ \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            292,
+            157,
+            684,
+            386
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "A.2 DATASET STATISTICS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            392,
+            367,
+            406
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "table",
+        "img_path": "images/a554c32dc185ce07e2a8626a7dcb6dd9f3d9989fe5d46ae06df462b0468b407a.jpg",
+        "table_caption": [
+            "Table 4: Dataset statistics. ",
+            "A.3 ADDITIONAL PERFORMANCE PLOTS WITH INCREASING NUMBER OF LAYERS "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Name</td><td>#Nodes</td><td>#Edges</td><td>#Features</td><td></td><td>#Classes Label Rate</td></tr><tr><td>Cora</td><td>2708</td><td>5429</td><td>1433</td><td>7</td><td>0.052</td></tr><tr><td>Citeseer</td><td>3327</td><td>4732</td><td>3703</td><td>6</td><td>0.036</td></tr><tr><td>Pubmed</td><td>19717</td><td>44338</td><td>500</td><td>3</td><td>0.003</td></tr><tr><td>CoauthorCs</td><td>18333</td><td>81894</td><td>6805</td><td>15</td><td>0.030</td></tr></table>",
+        "bbox": [
+            272,
+            445,
+            725,
+            529
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "image",
+        "img_path": "images/627b136f2cb683067e12832795e6ab454ee952b0c4cb0e3f50066ebbd4663f7f.jpg",
+        "image_caption": [
+            "Figure 5: Comparison of ‘vanilla’ vs. PAIRNORM-enhanced SGC, corresponding to Figure 1, for datasets (from top to bottom) Citeseer, Pubmed, and CoauthorCS. PAIRNORM provides improved robustness to performance decay due to oversmoothing with increasing number of layers. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            205,
+            570,
+            789,
+            851
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "image",
+        "img_path": "images/49c210931fea9be9fc78e0736ea00e7ac768d1712531f097d61e2630ee97e36d.jpg",
+        "image_caption": [
+            "Figure 6: Comparison of ‘vanilla’ (dashed) vs. PAIRNORM-enhanced (solid) GCN (left) and GAT (right) models, corresponding to Figure 3, for datasets (from top to bottom) Citeseer, Pubmed, and CoauthorCS. PAIRNORM provides improved robustness against performance decay with increasing number of layers. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            240,
+            227,
+            754,
+            718
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "image",
+        "img_path": "images/c779b80742b69bdd2c24cbb61a97edec6470afb721283fa9b9345251c88a1009.jpg",
+        "image_caption": [
+            "A.4 ADDITIONAL PERFORMANCE PLOTS WITH INCREASING NUMBER OF LAYERS UNDER SSNC-MV WITH $p = 1$ ",
+            "Figure 7: Comparison of ‘vanilla’ (dashed) vs. PAIRNORM-enhanced (solid) (from left to right) SGC, GCN, and GAT model performance under SSNC-MV for $p = 1$ , corresponding to Figure 4, for datasets (from top to bottom) Citeseer, Pubmed, and CoauthorCS. Green diamond symbols depict the layer at which validation accuracy peaks. PAIRNORM boosts overall performance by enabling more robust deep GNNs. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            186,
+            147,
+            825,
+            607
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "A.5 ADDITIONAL EXPERIMENTS UNDER SSNC-MV WITH INCREASING MISSING FRACTION $p$ ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            103,
+            748,
+            132
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "In this section we report additional experiment results under the SSNC-MV setting with varying missing fraction, in particular $p = \\{ 0 . \\bar { 7 } , 0 . 8 , 0 . 9 , 1 \\}$ and also report the base case where $p = 0$ for comparison. ",
+        "bbox": [
+            176,
+            138,
+            826,
+            180
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Figure 8 presents results on all four datasets for GCN vs. PAIRNORM-enhanced GCN (denoted PN for short). The models without any skip connections are denoted by $^ { * } { } _ { - 0 }$ , with one-hop skip connection by $^ { * } { } ^ { 1 }$ , and with one and two-hop skip connections by $^ { * } { } _ { - 2 }$ . Barcharts on the right report the best layer that each model produced the highest validation accuracy, and those on the left report the corresponding test accuracy. Figure 9 presents corresponding results for GAT. ",
+        "bbox": [
+            173,
+            188,
+            825,
+            258
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "We discuss the take-aways from these figures on the following page. ",
+        "bbox": [
+            173,
+            265,
+            620,
+            280
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "image",
+        "img_path": "images/0d7b7c1a20f1eb72557237ef6542228cae1c28b9d6f51fdf4f24b4c7317739e1.jpg",
+        "image_caption": [
+            "Figure 8: Supplementary results to Table 2 for GCN on (from top to bottom) Cora, Citeseer, Pubmed, and CoauthorCS. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            183,
+            291,
+            830,
+            835
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "We make the following observations based on Figures 8 and 9: ",
+        "bbox": [
+            174,
+            103,
+            583,
+            118
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "• Performance of ‘vanilla’ GCN and GAT models without skip connections (i.e., GCN-0 and GAT-0) drop monotonically as we increase missing fraction $p$ .   \n• PAIRNORM-enhanced ‘vanilla’ models (PN-0, no skips) perform comparably or better than GCN-0 and GAT-0 in all cases, especially as $p$ increases. In other words, with PAIRNORM at work, model performance is more robust against missing data. Best number of layers for GCN-0 as we increase $p$ only changes between 2-4. For GAT-0, it changes mostly between 2-6.   \n• PAIRNORM-enhanced ‘vanilla’ models (PN-0, no skips) can go deeper, i.e., they can leverage a larger range of #layers (2-12) as we increase $p$ . Specifically, GCN-PN-0 (GAT-PN-0) uses equal number or more layers than GCN-0 (GAT-0) in almost all cases. Without any normalization, adding skip connections helps—GCN/GAT-1 and GCN/GAT-2 are better than GCN/GAT-0, especially as we increase $p$ .   \n• With PAIRNORM but no-skip, performance is comparable or better than just adding skips.   \n• Adding skips on top of PAIRNORM does not seem to introduce any notable gains. ",
+        "bbox": [
+            215,
+            125,
+            825,
+            319
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "In summary, simply employing our PAIRNORM for GCN and GAT provides robustness against oversmoothing that allows them to go deeper and achieve improved performance under SSNC-MV. ",
+        "bbox": [
+            173,
+            325,
+            823,
+            354
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "image",
+        "img_path": "images/5af8696357db4e766480670d62df5ad543dd644da4d5b8e2682680e390593102.jpg",
+        "image_caption": [
+            "Figure 9: Supplementary results to Table 3 for GAT on (from top to bottom) Cora, Citeseer, Pubmed, and CoauthorCS. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            183,
+            368,
+            831,
+            867
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "A.6 CASE STUDY: ADDITIONAL MEASURES FOR PAIRNORM AND PAIRNORM-SI WITH SGC AND GCN ",
+        "bbox": [
+            173,
+            103,
+            821,
+            132
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "To better understand why PAIRNORM and PAIRNORM-SI are helpful for training deep GNNs, we report additional measures for (SGC and GCN) with (PAIRNORM and PAIRNORM-SI) over the Cora dataset. In the main text, we claim TPSD (total pairwise squared distances) is constant across layers for SGC with PAIRNORM (for GCN/GAT this is not guaranteed because of the influence of activation function and dropout layer). In this section we empirically measure pairwise (squared) distances for both SGC and GCN, with PAIRNORM and PAIRNORM-SI. ",
+        "bbox": [
+            174,
+            138,
+            825,
+            222
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "A.6.1 SGC WITH PAIRNORM AND PAIRNORM-SI ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            238,
+            529,
+            252
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "To verify our analysis of PAIRNORM for SGC, and understand how the variant of PAIRNORM (PAIRNORM-SI) works, we measure the average pairwise squared distance (APSD) as well as the average pairwise distance (APD) between the representations for two categories of node pairs: (1) connected pairs (nodes that are directly connected in graph) and (2) random pairs (uniformly randomly chosen among the node set). APSD of random pairs reflects the TPSD, and APD of random pairs reflects the total pairwise distance (TPD). Under the homophily assumption of the labels w.r.t. the graph structure, we want APD or APSD of connected pairs to be small while keeping APD or APSD of random pairs relatively large. ",
+        "bbox": [
+            174,
+            262,
+            825,
+            375
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "The results are shown in Figure 10. Without normalization, SGC suffers from fast diminishing APD and APSD of random pairs. As we have proved, PAIRNORM normalizes APSD to be constant across layers, however it does not normalize APD, which appears to decrease linearly with increasing number of layers. Surprisingly, although PAIRNORM-SI is not theoretically proved to have a constant APSD and APD, empirically it achieves more stable APSD and APD than PAIRNORM. We were not able to prove this phenomenon mathematically, and leave it for further investigation. ",
+        "bbox": [
+            174,
+            381,
+            825,
+            465
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "image",
+        "img_path": "images/ae436f7f59e77acf1dd9f6d7e0e09d9a1facf14cb62996a08d1daa89db8c6452.jpg",
+        "image_caption": [
+            "Figure 10: Measuring average distance (squared and not-squared) between representations at each layer for SGC, SGC with PAIRNORM, and SGC with PAIRNORM-SI. The setting is the same with Figure 1 and they share the same performance. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            183,
+            483,
+            813,
+            724
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "APD does not capture the full information of the distribution of pairwise distances. To show how the distribution changes by increasing number of layers, we use Tensorboard to plot the histograms of pairwise distances, as shown in Figure 11. Comparing SGC and SGC with PAIRNORM, adding PAIRNORM keeps the left shift (shrinkage) of the distribution of random pair distances much slower than without normalization, while still sharing similar behavior of the distribution of connected pairwise distances. PAIRNORM-SI seems to be more powerful in keeping the median and mean of the distribution of random pair distances stable, while “spreading” the distribution out by increasing the variance. The performance of PAIRNORM and PAIRNORM-SI are similar, however it seems that PAIRNORM-SI is more powerful in stabilizing TPD and TPSD. ",
+        "bbox": [
+            174,
+            797,
+            825,
+            924
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "image",
+        "img_path": "images/7b388377adcaf83d05c83715ca45a5300a22c8267be76f9fe92a56df0c7bbc16.jpg",
+        "image_caption": [
+            "Figure 11: Measuring distribution of distances between representations at each layer for SGC, SGC with PAIRNORM, and SGC with PAIRNORM-SI. Supplementary results for Figure 10. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            178,
+            102,
+            823,
+            335
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "text",
+        "text": "A.6.2 GCN WITH PAIRNORM AND PAIRNORM-SI ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            400,
+            532,
+            415
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "image",
+        "img_path": "images/59f7ec91fe51b33cfef45e58655597546a89d6fe981618538c32b87c2f03cd05.jpg",
+        "image_caption": [
+            "Figure 12: Measuring average distance (squared and not-squared) between representations at each layer for GCN, GCN with PAIRNORM, and GCN with PAIRNORM-SI. We trained three 12-layer GCNs with #hidden ${ \\boldsymbol { \\mathrm { \\Omega } } } = 1 2 8$ and dropout $_ { = 0 . 6 }$ in 1000 epochs. Respective test set accuracies are $3 1 . 0 9 \\%$ , $7 7 . 7 7 \\%$ , $7 5 . 0 9 \\%$ . Note that the scale of distances is not comparable across models, since they have learnable parameters that scale these distances differently. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            181,
+            435,
+            813,
+            678
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "text",
+        "text": "The formal analysis for PAIRNORM and PAIRNORM-SI is based on SGC. GCN (and other GNNs) has learnable parameters, dropout layers, and activation layers, all of which complicate direct mathematical analyses. Here we perform similar empirical measurements for pairwise distances to get a rough sense of how PAIRNORM and PAIRNORM-SI work with GCN based on the Cora dataset. Figures 12 and 13 demonstrate how PAIRNORM and PAIRNORM-SI can help train a relatively deep (12 layers) GCN. ",
+        "bbox": [
+            174,
+            776,
+            825,
+            861
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "text",
+        "text": "Notice that oversmoothing occurs very quickly for GCN without any normalization, where both connected and random pair distances reach zero (!). In contrast, GCN with PAIRNORM or PAIRNORMSI is able to keep random pair distances relatively apart while allowing connected pair distances to shrink. As also stated in main text, using PAIRNORM-SI for GCN and GAT is relatively more stable than using PAIRNORM in general cases (notice the near-constant random pair distances in the rightmost subfigures). There are several possible explanations for why PAIRNORM-SI is more stable. First, as shown in Figure 10 and Figure 12, PAIRNORM-SI not only keeps APSD stable but also APD, further, the plots of distributions of pairwise distances (Figures 11 and 13) also show the power of PAIRNORM-SI (notice the large gap between smaller connected pairwise distances and the larger random pairwise distances). Second, we conjecture that restricting representations to reside on a sphere can make training stable and faster, which we also observe empirically by studying the training curves. Third, GCN and GAT tend to overfit easily for the SSNC problem, due to many learnable parameters across layers and limited labeled input data, therefore it is possible that adding more restriction on these models helps reduce overfitting. ",
+        "bbox": [
+            174,
+            867,
+            823,
+            924
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            103,
+            825,
+            242
+        ],
+        "page_idx": 16
+    },
+    {
+        "type": "image",
+        "img_path": "images/4e87bc839305a4fe876fef59f9a350aa8fa1909a4e79ba5c49503a628a339763.jpg",
+        "image_caption": [
+            "Figure 13: Measuring distribution of distances between representations at each layer for GCN, GCN with PAIRNORM, and GCN with PAIRNORM-SI. Supplementary results for Figure 12. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            173,
+            257,
+            823,
+            492
+        ],
+        "page_idx": 16
+    },
+    {
+        "type": "text",
+        "text": "All in all, these empirical measurements as illustrated throughout the figures in this section demonstrates that PAIRNORM and PAIRNORM-SI successfully address the oversmoothing problem for deep GNNs. Our work is the first to propose a normalization layer specifically designed for graph neural networks, which we hope will kick-start more work in this area toward training more robust and effective GNNs. ",
+        "bbox": [
+            174,
+            546,
+            825,
+            616
+        ],
+        "page_idx": 16
+    }
+]