Add files using upload-large-folder tool

parse/train/0WASBV4xkhy/0WASBV4xkhy_content_list.json

@@ -0,0 +1,1490 @@
+[
+    {
+        "type": "text",
+        "text": "Towards a Theoretical Framework of Out-of-Distribution Generalization ",
+        "text_level": 1,
+        "bbox": [
+            272,
+            122,
+            725,
+            172
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Chuanlong XieHuawei Noah’s Ark Labxie.chuanlong@huawei.com",
+        "bbox": [
+            377,
+            215,
+            584,
+            257
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Haotian Ye   \nPeking University   \nPazhou Lab   \nhaotianye@pku.edu.cn ",
+        "bbox": [
+            184,
+            215,
+            359,
+            271
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Tianle Cai Peking University caitianle1998@pku.edu.cn ",
+        "bbox": [
+            604,
+            215,
+            812,
+            257
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Ruichen Li ",
+        "text_level": 1,
+        "bbox": [
+            218,
+            292,
+            297,
+            305
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Zhenguo Li ",
+        "text_level": 1,
+        "bbox": [
+            400,
+            292,
+            483,
+            306
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Liwei Wang ",
+        "text_level": 1,
+        "bbox": [
+            637,
+            292,
+            725,
+            306
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Peking University xk-lrc@pku.edu.cn ",
+        "bbox": [
+            184,
+            306,
+            331,
+            333
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Huawei Noah’s Ark Lab Li.Zhenguo@huawei.com ",
+        "bbox": [
+            352,
+            306,
+            532,
+            333
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Key Laboratory of Machine Perception, MOE, School of EECS, Institute for Artificial Intelligence, Peking University wanglw@cis.pku.edu.cn ",
+        "bbox": [
+            552,
+            305,
+            812,
+            376
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Abstract ",
+        "text_level": 1,
+        "bbox": [
+            462,
+            411,
+            535,
+            426
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Generalization to out-of-distribution (OOD) data is one of the central problems in modern machine learning. Recently, there is a surge of attempts to propose algorithms that mainly build upon the idea of extracting invariant features. Although intuitively reasonable, theoretical understanding of what kind of invariance can guarantee OOD generalization is still limited, and generalization to arbitrary out-of-distribution is clearly impossible. In this work, we take the first step towards rigorous and quantitative definitions of 1) what is OOD; and 2) what does it mean by saying an OOD problem is learnable. We also introduce a new concept of expansion function, which characterizes to what extent the variance is amplified in the test domains over the training domains, and therefore give a quantitative meaning of invariant features. Based on these, we prove OOD generalization error bounds. It turns out that OOD generalization largely depends on the expansion function. As recently pointed out by [21], any OOD learning algorithm without a model selection module is incomplete. Our theory naturally induces a model selection criterion. Extensive experiments on benchmark OOD datasets demonstrate that our model selection criterion has a significant advantage over baselines. ",
+        "bbox": [
+            233,
+            441,
+            766,
+            662
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 Introduction ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            686,
+            310,
+            704
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "One of the most fundamental assumptions of classic supervised learning is the “i.i.d. assumption”, which states that the training and the test data are independent and identically distributed. However, this assumption can be easily violated in a reality [8, 10, 11, 17, 38, 48, 56] where the test data usually have a different distribution than the training data. This motivates the research on the out-ofdistribution (OOD) generalization, or domain generalization problem, which assumes access only to data drawn from a set $\\mathcal { E } _ { a v a i l }$ of available domains during training, and the goal is to generalize to a larger domain set ${ \\mathcal { E } } _ { a l l }$ including unseen domains. ",
+        "bbox": [
+            174,
+            718,
+            825,
+            815
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "To generalize to OOD data, most existing algorithms attempt to learn features that are invariant to a certain extent across training domains in the hope that such invariance also holds in unseen domains. For example, distributional matching-based methods [20, 35, 55] seek to learn features that have the same distribution across different domains; IRM [5] and its variants [1, 32, 33] learn feature representations such that the optimal linear classifier on top of the representation matches across domains. ",
+        "bbox": [
+            174,
+            821,
+            825,
+            904
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "35th Conference on Neural Information Processing Systems (NeurIPS 2021). ",
+        "bbox": [
+            174,
+            922,
+            629,
+            936
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Though the idea of learning invariant features is intuitively reasonable, there is only limited theoretical understanding of what kind of invariance can guarantee OOD generalization. Clearly, generalization to an arbitrary out-of-distribution domain is impossible and in practice, the features can hardly be absolutely invariant from $\\mathcal { E } _ { a v a i l }$ to ${ \\mathcal { E } } _ { a l l }$ unless all the domains are identical. So it is necessary to first formulate what OOD data can be generalized to, or, what is the relation between the available training domain set $\\mathcal { E } _ { a v a i l }$ and the entire domain set ${ \\mathcal { E } } _ { a l l }$ . Meanwhile, to what extent the invariance of features on $\\mathcal { E } _ { a v a i l }$ can be preserved in ${ \\mathcal { E } } _ { a l l }$ should be rigorously characterized. ",
+        "bbox": [
+            174,
+            92,
+            825,
+            188
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "In this paper, we take the first step towards a general OOD framework by quantitatively formalizing the relationship between $\\mathcal { E } _ { a v a i l }$ and ${ \\mathcal { E } } _ { a l l }$ in terms of the distributions of features and provide OOD generalization guarantees based on our quantification of the difficulty of OOD generalization problem. Specifically, we first rigorously formulate the intuition of invariant features used in previous works by introducing the “variation” and “informativeness” (Definition 3.1 and 3.2) of each feature. Our theoretical insight can then be informally stated as: for learnable OOD problems, if a feature is informative for the classification task as well as invariant over $\\mathcal { E } _ { a v a i l }$ , then it is still invariant over ${ \\mathcal { E } } _ { a l l }$ . In other words, invariance of informative features in $\\mathcal { E } _ { a v a i l }$ can be preserved in ${ \\mathcal { E } } _ { a l l }$ . We further introduce a class of functions, dubbed expansion function (Definition 3.3), to quantitatively characterize to what extent the variance of features on $\\mathcal { E } _ { a v a i l }$ is amplified on ${ \\mathcal { E } } _ { a l l }$ . ",
+        "bbox": [
+            174,
+            194,
+            825,
+            333
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Based on our formulation, we derive theoretical guarantees on the OOD generalization error, i.e., the gap of largest error between the domain in $\\mathcal { E } _ { a v a i l }$ and domain in ${ \\mathcal { E } } _ { a l l }$ . Specifically, we prove the upper and lower bound of OOD generalization error in terms of the expansion function and the variation of learned features over $\\mathcal { E } _ { a v a i l }$ . Our results theoretically confirm that 1) the expansion function can reflect the difficulty of OOD generalization problem, i.e., problems with more rapidly increasing expansion functions are harder and have worse generalization guarantees; 2) the generalization error gap can tend to zero when the variation of learned features tend to zero, so minimizing the variation in $\\mathcal { E } _ { a v a i l }$ can reduce the generalization error. ",
+        "bbox": [
+            174,
+            339,
+            825,
+            449
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "As pointed out by Gulrajani and Lopez-Paz [21], any OOD algorithm without a specified model selection criterion is not complete. Since ${ \\mathcal { E } } _ { a l l }$ is unseen, hyper-parameters can only be chosen according to $\\mathcal { E } _ { a v a i l }$ . Previous selection methods mainly focus on validation accuracy over $\\mathcal { E } _ { a v a i l }$ which is only a biased metric of OOD performance. On the contrary, a promising model selection method should instead be predictive of OOD performance. Inspired by our bounds, we propose a model selection method to select models with high validation accuracy and low variation, which corresponds to the upper bound of OOD error. The introduction of a model’s variation relieves the problem of classic selection methods, in which models that overfit $\\mathcal { E } _ { a v a i l }$ tend to be selected. Experimental results show that our method can outperform baselines and select models with higher OOD accuracy. ",
+        "bbox": [
+            174,
+            457,
+            825,
+            594
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Contributions. We summarize our major contributions here: ",
+        "bbox": [
+            174,
+            622,
+            583,
+            636
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "• We introduce a quantitative and rigorous formulation of OOD generalization problem that characterizes the relation of invariance over the training domain set $\\mathcal { E } _ { a v a i l }$ and test domain set ${ \\mathcal { E } } _ { a l l }$ . The core quantity in our characterization, the expansion function, determines the difficulty of an OOD generalization problem. ",
+        "bbox": [
+            173,
+            654,
+            826,
+            709
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "• We prove novel OOD generalization error bounds based on our formulation. The upper and lower bounds together indicate that the expansion function well characterizes the OOD generalization ability of features with different levels of variation. ",
+        "bbox": [
+            174,
+            724,
+            823,
+            766
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "• We design a model selection criterion that is inspired by our generalization bounds. Our criterion takes both the performance on training domains and the variation of models into consideration and is predictive of OOD performance according to our bounds. Experimental results demonstrate our selection criterion can choose models with higher OOD accuracy. ",
+        "bbox": [
+            173,
+            782,
+            825,
+            838
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "The rest of the paper is organized as follows: Section 2 is our preliminary. In Section 3, we give our theoretical formulation. Section 4 gives our generalization bound. We propose our model selection method in Section 5. In Section 6 we conduct experiments on expansion function and model selection. We review more related works in Section 7 and conclude our work in Section 8. ",
+        "bbox": [
+            176,
+            856,
+            825,
+            911
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2 Preliminary ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            88,
+            305,
+            107
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Throughout the paper, we consider a multi-class classification task $\\mathcal { X } \\to \\mathcal { Y } = \\{ 1 , . . . , K \\}$ .1 Let ${ \\mathcal { E } } _ { a l l }$ be the domain set we want to generalize to, and $\\mathcal { E } _ { a v a i l } \\subseteq \\mathcal { E } _ { a l l }$ be the available domain set, i.e., all domains we have during the training procedure. We denote $( X ^ { e } , Y ^ { e } )$ to be the input-label pair drawn from the data distribution of domain $e$ . The OOD generalization goal is to find a classifier $f ^ { * }$ that minimizes the worst-domain loss on ${ \\mathcal { E } } _ { a l l }$ : ",
+        "bbox": [
+            174,
+            119,
+            825,
+            190
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/92ece3d80a18d8b09d86d490b1aa6271dee39a3b130e884626dc355a67e41bdf.jpg",
+        "text": "$$\nf ^ { * } = \\underset { f \\in \\mathcal { F } } { \\mathrm { a r g m i n } } \\mathcal { L } ( \\mathcal { E } _ { a l l } , f ) , \\mathcal { L } ( \\mathcal { E } , f ) \\triangleq \\underset { e \\in \\mathcal { E } } { \\mathrm { m a x } } \\mathbb { E } \\big [ \\ell \\big ( f ( X ^ { e } ) , Y ^ { e } \\big ) \\big ]\n$$",
+        "text_format": "latex",
+        "bbox": [
+            300,
+            195,
+            696,
+            224
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "where $\\mathcal { F } : \\mathcal { X } \\xrightarrow { } \\mathbb { R } ^ { K }$ is the the hypothetical space and $\\ell ( \\cdot , \\cdot )$ is a loss function. Similar to previous works [5, 16, 27, 33], we assume that $f$ can be decomposed into $g \\circ h$ , where $g \\in \\mathcal { G } : \\mathbb { R } ^ { d }  \\mathbb { R } ^ { K }$ is the top classifier and $h : \\mathcal { X }  \\mathbb { R } ^ { d }$ is a $d$ -dimensional feature extractor, i.e., ",
+        "bbox": [
+            173,
+            232,
+            825,
+            276
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/ee0a57e21bd4e230b25e434833fe9ced52367d0fd15ac040eda84f95a58b070d.jpg",
+        "text": "$$\nh ( x ) = ( \\phi _ { 1 } ( x ) , \\phi _ { 2 } ( x ) , \\ldots , \\phi _ { d } ( x ) ) ^ { \\top } , \\quad \\phi _ { i } \\in \\Phi .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            323,
+            284,
+            640,
+            303
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Here $\\Phi$ is the set of scalar feature maps which map $\\mathcal { X }$ to $\\mathbb { R }$ and $d$ is fixed. We will call each $\\phi \\in \\Phi$ a feature for simplicity. Given a domain $e$ , we denote the $d$ -dimensional random vector $h ( X ^ { e } )$ as $h ^ { e }$ , one-dimensional feature $\\phi ( X ^ { e } )$ as $\\phi ^ { e }$ , and the conditional distribution of $h ^ { e } , \\phi ^ { e }$ given $Y ^ { e } = y$ as $\\mathbb { P } ( h ^ { e } | y ) , \\mathbb { P } ( \\phi ^ { e } | y )$ . For simplicity, we assume the data distribution is balanced in every domain, i.e., $P ( Y ^ { e } = y ) = \\frac { 1 } { K } , \\forall y \\in \\mathcal { Y } , e \\in \\mathcal { E } _ { a l l }$ . Our framework can be easily extended to the case where the balanced assumption is removed, with an additional term corresponding to the imbalance adding to the generalization bounds. ",
+        "bbox": [
+            173,
+            309,
+            826,
+            407
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3 Framework of OOD Generalization Problem ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            426,
+            580,
+            444
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "The main challenge of formalizing the OOD generalization problem is to mathematically describe the connection between $\\mathcal { E } _ { a v a i l }$ and ${ \\mathcal { E } } _ { a l l }$ and how generalization depends on this relation. Towards this goal, we introduce several quantities to characterize the relation of feature distributions over different domains and bridge $\\mathcal { E } _ { a v a i l }$ and ${ \\mathcal { E } } _ { a l l }$ by expansion function (Definition 3.3) over the quantities we have introduced. Our framework is motivated by the understanding that, in an OOD generalization task, certain “property” of “good” features in $\\mathcal { E } _ { a v a i l }$ should be “preserved” in ${ \\mathcal { E } } _ { a l l }$ (the reason is described in Section 1). In Section 3.1, we will go into details on what we mean by “property” (variation, Definition 3.1), “good” (informativeness, Definition 3.2), and “preserved” (measured by expansion function). In Section 6.2, we further illustrate the key concepts in our framework by a real-world OOD problem. ",
+        "bbox": [
+            173,
+            457,
+            826,
+            597
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3.1 Formalizing OOD Problem by Quantifying Feature Distribution ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            612,
+            658,
+            628
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "We first introduce the concepts “variation\" and “informativeness\" of a feature $\\phi$ . The first one is what we expect to be preserved in ${ \\mathcal { E } } _ { a l l }$ and the second one characterizes what features will be considered. Specifically, let $\\rho ( \\mathbb { P } , \\mathbb { Q } )$ be a symmetric “distance” of two distributions. Note that $\\rho$ can have many choices, like $L _ { 2 }$ Distance, Total Variation and symmetric KL-divergence, etc. The variation and informativeness are defined as follows: ",
+        "bbox": [
+            173,
+            638,
+            825,
+            708
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Definition 3.1 (Variation). The variation of feature $\\phi ( \\cdot )$ across a domain set $\\mathcal { E }$ is ",
+        "bbox": [
+            173,
+            712,
+            705,
+            728
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/b5e6d90d4f6e707f43d0a5fd09cd50b46b59f7364145ae7e58a3a5a8d9599fbf.jpg",
+        "text": "$$\n\\mathcal { V } _ { \\rho } ( \\phi , \\mathcal { E } ) = \\operatorname* { m a x } _ { y \\in \\mathcal { V } } \\operatorname* { s u p } _ { e , e ^ { \\prime } \\in \\mathcal { E } } \\rho \\big ( \\mathbb { P } ( \\phi ^ { e } | y ) , \\mathbb { P } ( \\phi ^ { e ^ { \\prime } } | y ) \\big ) .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            348,
+            736,
+            648,
+            765
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "A feature $\\phi ( \\cdot )$ is $\\varepsilon$ -invariant across $\\mathcal { E }$ , $i f \\varepsilon \\geq \\mathcal { V } ( \\phi , \\mathcal { E } )$ (We omit the subscript $\\rho$ in case of no ambiguity). Definition 3.2 (Informativeness). The informativeness of feature $\\phi ( \\cdot )$ across a domain set $\\mathcal { E }$ is ",
+        "bbox": [
+            171,
+            772,
+            828,
+            808
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/b5d2d9f29351ffd114b5530974aa3d8ba7d34f3c8275c029e6a978717a1c0731.jpg",
+        "text": "$$\n\\mathcal { T } _ { \\rho } ( \\phi , \\mathcal { E } ) = \\frac { 1 } { K ( K - 1 ) } \\sum _ { \\stackrel { y \\neq y ^ { \\prime } } { y , y ^ { \\prime } \\in y } } \\operatorname* { m i n } _ { e \\in \\mathcal { E } } \\rho \\big ( \\mathbb { P } ( \\phi ^ { e } | y ) , \\mathbb { P } ( \\phi ^ { e } | y ^ { \\prime } ) \\big ) .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            292,
+            813,
+            671,
+            864
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "A feature $\\phi ( \\cdot )$ is $\\delta$ -informative across $\\varepsilon$ , if $\\quad \\delta \\leq { \\mathcal { I } } ( \\phi , { \\mathcal { E } } )$ . ",
+        "bbox": [
+            171,
+            871,
+            539,
+            887
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "The variation $\\mathcal { V } ( \\phi , \\mathcal { E } )$ measures the stability of $\\phi ( \\cdot )$ over the domains in $\\mathcal { E }$ and the informativeness ${ \\mathcal { T } } ( \\phi , { \\mathcal { E } } )$ captures the ability of $\\phi ( \\cdot )$ to distinguish different labels. We would like to highlight that the variation and informativeness are defined on each one-dimensional feature $\\phi ( \\cdot )$ . Unlike previous distance between distributions defined in $d$ -dimensional space, our definitions are more reasonable and practical, since it can be easily calculated and analyzed. ",
+        "bbox": [
+            174,
+            90,
+            825,
+            161
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "We are now ready to introduce the core quantity for connecting $\\mathcal { E } _ { a v a i l }$ and ${ \\mathcal { E } } _ { a l l }$ . Our motivation, as elaborated in the introduction section, is that, if a feature is informative for the classification task and invariant over $\\mathcal { E } _ { a v a i l }$ , then to enable OOD generalization from $\\mathcal { E } _ { a v a i l }$ to ${ \\mathcal { E } } _ { a l l }$ , it should be still invariant over ${ \\mathcal { E } } _ { a l l }$ . So the relation between $\\mathcal { V } ( \\phi , \\mathcal { E } _ { a v a i l } )$ and $\\mathinner { \\gamma \\mathopen { \\left( \\phi , \\mathcal { E } _ { a l l } \\right) } }$ of an informative feature captures the feasibility and difficulty of OOD generalization. To quantitatively measure this relation, we define the following function class: ",
+        "bbox": [
+            174,
+            166,
+            825,
+            251
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Definition 3.3 (Expansion Function). We say a function $s : \\mathbb { R } ^ { + } \\cup \\{ 0 \\}  \\mathbb { R } ^ { + } \\cup \\{ 0 , + \\infty \\}$ is an expansion function, iff the following properties hold: 1) $s ( \\cdot )$ is monotonically increasing and $s ( x ) \\geq x , \\forall x \\geq 0 ; 2 ,$ ) $\\begin{array} { r } { \\operatorname* { l i m } _ { x  0 ^ { + } } s ( x ) = s ( 0 ) = 0 } \\end{array}$ . ",
+        "bbox": [
+            174,
+            255,
+            825,
+            297
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "This function class gives a full characterization of how the variation between $\\mathcal { E } _ { a v a i l }$ and ${ \\mathcal { E } } _ { a l l }$ is related. Based on this function class, we can introduce our formulation of the learnability of OOD generalization as follows: ",
+        "bbox": [
+            174,
+            309,
+            825,
+            351
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Definition 3.4 (Learnability). Let $\\Phi$ be the feature space and $\\rho$ be a distribution distance. We say an OOD generalization problem from $\\mathcal { E } _ { a v a i l }$ to ${ \\mathcal { E } } _ { a l l }$ is learnable if there exists an expansion function $s ( \\cdot )$ and $\\delta \\geq 0$ , such that: for all $\\phi \\in \\Phi$ satisfying ${ \\mathcal { T } } _ { \\rho } ( \\phi , { \\mathcal { E } } _ { a v a i l } ) \\geq \\delta$ , we have $s ( \\mathcal { V } _ { \\rho } ( \\phi , \\mathcal { E } _ { a v a i l } ) ) \\geq$ $\\mathcal { V } _ { \\rho } \\big ( \\phi , \\mathcal { E } _ { a l l } \\big )$ . If such $s ( \\cdot )$ and $\\delta$ exist, we further call this problem $( s ( \\cdot ) , \\delta )$ -learnable. If an $o o D$ generalization problem is not learnable, we call $i t$ unlearnable. ",
+        "bbox": [
+            174,
+            356,
+            825,
+            425
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "To understand the intuition and rationality of our formulation, several discussions are in order. ",
+        "bbox": [
+            171,
+            436,
+            787,
+            452
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Properties of the expansion function. In Definition 3.3, we highlight two properties of the expansion function. The first property comes naturally from the monotonicity properties of variation: any $\\varepsilon _ { 1 }$ -invariant feature is also $\\varepsilon _ { 2 }$ -invariant for $\\varepsilon _ { 2 } \\geq \\varepsilon _ { 1 }$ ; and $\\mathcal { V } ( \\phi , \\mathcal { E } _ { 1 } ) \\leq \\mathcal { V } ( \\phi , \\mathcal { E } _ { 2 } )$ for any ${ \\mathcal { E } } _ { 1 } \\subseteq { \\mathcal { E } } _ { 2 }$ . The monotonicity also implies that larger ${ \\mathcal { E } } _ { a l l }$ will induce larger $s ( \\cdot ) ^ { 2 }$ and it is also harder to be generalized to. From this view, we can see that the scale of $s ( \\cdot )$ can reflect the difficulty of OOD generalization. The second property is more crucial since it formulates the intuition that if an informative feature is almost invariant in $\\mathcal { E } _ { a v a i l }$ , it should remain invariant in ${ \\mathcal { E } } _ { a l l }$ . Without this assumption, OOD generalization can never be guaranteed because we cannot predict whether an invariant and informative feature in $\\mathcal { E } _ { a v a i l }$ will vary severely in unseen ${ \\mathcal { E } } _ { a l l }$ . ",
+        "bbox": [
+            173,
+            467,
+            826,
+            592
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Necessity of informativeness. We include a seemingly redundant quantity informativeness in the definition of learnability. However, this term is necessary because only informative features are responsible for the performance of classification. Non-informative but invariant features over $\\mathcal { E } _ { a v a i l }$ may only capture some noise that is irrelevant to the classification problem, and we shall not expect the noise to be invariant over ${ \\mathcal { E } } _ { a l l }$ . Moreover, we show in Figure 1 that in practice, many invariant but useless features in $\\mathcal { E } _ { a v a i l }$ vary a lot in ${ \\mathcal { E } } _ { a l l }$ , and adding the constraint of informativeness makes the expansion function reasonable. In addition, there are multiple choices of $( s ( \\cdot ) , \\delta )$ to make an OOD generalization problem learnable: larger $\\delta$ will filter out more features, and so $\\dot { s } ( \\cdot )$ can be smaller (flatter). This multiplicity will result in a trade-off between $s ( \\cdot )$ and $\\delta$ , which will be discussed in Section 6.2. ",
+        "bbox": [
+            174,
+            607,
+            825,
+            746
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Two extreme cases: i.i.d. & unlearnable. To better understand the concept of learnability, we consider two extreme cases. (1) The first example is when all data from different $\\textit { e } \\in \\mathcal { E } _ { a l l }$ are identically distributed, i.e., the classic supervised learning setting. This problem is $( s ( \\cdot ) , 0 )$ -learnable with $s ( x ) = x$ , implying no extra difficulty in OOD generalization. (2) As an example of unlearnable, consider the following case (modified from Colored MNIST [5]): For $e \\in \\mathcal { E } _ { a v a i l }$ , images with label 0 always has a red background while images with label 1 has a blue background. For $e \\in \\mathcal { E } _ { a l l } \\ \\backslash \\ \\mathcal { E } _ { a v a i l }$ , this relationship is entirely inverse. Since data from different $e \\in \\mathcal { E } _ { a v a i l }$ are identically distributed but different from other $e \\in \\mathcal { E } _ { a l l }$ , no expansion function can make it learnable, i.e., it is OOD-unlearnable. ",
+        "bbox": [
+            173,
+            761,
+            825,
+            873
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "The unlearnability of this case also coincides with our intuition: Without prior knowledge, it is not clear from merely the training data, whether the task is to distinguish digit 0 from 1, or to distinguish color red from blue. As a result, generalization to ${ \\mathcal { E } } _ { a l l }$ cannot be guaranteed. ",
+        "bbox": [
+            173,
+            90,
+            825,
+            133
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "4 Generalization Bound ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            151,
+            390,
+            170
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "In this section, we consider an OOD generalization problem from $\\mathcal { E } _ { a v a i l }$ to ${ \\mathcal { E } } _ { a l l }$ , and our goal is to analyze the OOD generalization error of classifier $f = g \\circ h$ defined by ",
+        "bbox": [
+            173,
+            183,
+            823,
+            212
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/f61601e575911b7b38e2ff41bc91c80f1ca3bdfad17110177fbe71a235a390ce.jpg",
+        "text": "$$\n\\mathrm { e r r } ( f ) = \\mathcal { L } ( \\mathcal { E } _ { a l l } , f ) - \\mathcal { L } ( \\mathcal { E } _ { a v a i l } , f ) ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            362,
+            217,
+            599,
+            234
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "where we assume the loss function $l ( \\cdot , \\cdot )$ is bounded by $[ 0 , C ]$ . We prove two upper bounds (4.1, 4.2) as well as a lower bound (4.3) for $\\operatorname { e r r } ( f )$ based on our formulation. Our bounds together provide a complete characterization of the difficulty of OOD generalization. Since we expect that an invariant classifier can generalize to unseen domains, we hope to bound $\\operatorname { e r r } ( f )$ in terms of the certain variation of $f$ . To this end, we define the variation and informativeness of $f$ in terms of its features, i.e., ",
+        "bbox": [
+            173,
+            238,
+            825,
+            309
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/37ed4f7a0dc7d2319bdc5086f2478da0e7cc992b3f71f92313ccf9703cd17289.jpg",
+        "text": "$$\n\\begin{array} { r l r } { \\mathcal { V } ^ { \\operatorname* { s u p } } ( h , \\mathcal { E } _ { a v a i l } ) } & { \\triangleq } & { \\underset { \\beta \\in S ^ { d - 1 } } { \\operatorname* { s u p } } \\mathcal { V } ( \\beta ^ { \\top } h , \\mathcal { E } _ { a v a i l } ) , } \\\\ { \\mathcal { T } ^ { \\operatorname* { i n f } } ( h , \\mathcal { E } _ { a v a i l } ) } & { \\triangleq } & { \\underset { \\beta \\in S ^ { d - 1 } } { \\operatorname* { i n f } } \\mathcal { T } ( \\beta ^ { \\top } h , \\mathcal { E } _ { a v a i l } ) , } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            348,
+            313,
+            647,
+            372
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "where $( \\beta ^ { \\top } h ) ( x ) = \\beta ^ { \\top } h ( x )$ is a feature and $S ^ { d - 1 } = \\{ \\beta \\in \\mathbb { R } ^ { d } : \\| \\beta \\| _ { 2 } = 1 \\}$ is the unit $( d - 1 )$ -sphere. ",
+        "bbox": [
+            171,
+            376,
+            825,
+            395
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Necessity of using supremum over linear combination. One seemingly plausible definition of the variation of a classifier $f$ can be the supremum over all $\\mathcal { V } ( \\phi _ { i } , \\mathcal { E } _ { a v a i l } ) , i \\in [ d ]$ . However, as is shown in Appendix 1, it is possible that two high-dimensional joint distributions have close marginal distribution in each dimension, while they do not overlap. In other words, there exist cases where $\\mathcal { V } ( \\phi _ { i } , \\mathcal { E } _ { a l l } ) = 0 , \\forall i \\in [ d ]$ but after applying the top model $g$ over $\\phi _ { i }$ ’s, the distribution varies a lot in $\\mathcal { E } _ { a v a i l }$ . Our definition comes from the simple idea that the class of top model $\\mathcal { G }$ is at least a linear space, so we should at least consider the variation of every (normalized) linear combination of $h ( \\cdot )$ With this, we can guarantee the joint distribution distance is still small. ",
+        "bbox": [
+            173,
+            406,
+            825,
+            518
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Theorem 4.1 (Main Theorem). Suppose we have learned a classifier $f ( x ) = g ( h ( x ) )$ such that $\\forall e \\in \\mathcal { E } _ { a l l }$ and $\\forall y \\in \\mathcal { V } ;$ $, p _ { h ^ { e } | Y ^ { e } } ( h | y ) \\in L ^ { 2 } ( \\mathbb R ^ { d } )$ . Denote the characteristic function of random variable $h ^ { e } | Y ^ { e }$ as $\\hat { p } _ { h ^ { e } | Y ^ { e } } ( t | y ) = \\mathbb { E } [ \\exp \\{ i \\langle t , h ^ { e } \\rangle \\} | Y ^ { e } = y ]$ . Assume the hypothetical space $\\mathcal { F }$ satisfies the following regularity conditions that $\\exists \\alpha , M _ { 1 } , M _ { 2 } > 0 , \\forall f \\in \\mathcal { F } , \\forall e \\in \\mathcal { E } _ { a l l } , y \\in \\mathcal { V }$ , ",
+        "bbox": [
+            173,
+            521,
+            825,
+            582
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/ee4b4c076d84f9c894a2e146552ae306c55f38d76c671d508d171889b7b12f9f.jpg",
+        "text": "$$\n\\int _ { h \\in \\mathbb { R } ^ { d } } p _ { h ^ { e } | Y ^ { e } } ( h | y ) | h | ^ { \\alpha } \\mathrm { d } h \\leq M _ { 1 } \\quad a n d \\quad \\int _ { t \\in \\mathbb { R } ^ { d } } | \\hat { p } _ { h ^ { e } | Y ^ { e } } ( t | y ) | | t | ^ { \\alpha } \\mathrm { d } t \\leq M _ { 2 } .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            251,
+            585,
+            745,
+            619
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "$I f ( \\mathcal { E } _ { a v a i l } , \\mathcal { E } _ { a l l } )$ is $\\left( s ( \\cdot ) , \\mathcal { T } ^ { i n f } ( h , \\mathcal { E } _ { a v a i l } ) \\right)$ -learnable under $\\Phi$ with Total Variation $\\rho ^ { 3 }$ , then we have ",
+        "bbox": [
+            174,
+            625,
+            802,
+            641
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/47d72154cd89cf0c6271de3f68baa90e658deea6245d64bec4f750c758b38256.jpg",
+        "text": "$$\n\\operatorname { e r r } ( f ) \\leq O \\left( s \\left( \\mathcal { V } _ { \\rho } ^ { s u p } ( h , \\mathcal { E } _ { a v a i l } ) \\right) ^ { \\frac { \\alpha ^ { 2 } } { ( \\alpha + d ) ^ { 2 } } } \\right) .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            349,
+            647,
+            616,
+            676
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Here $\\rho$ is total variation distance, and $O ( \\cdot )$ depends on $d , C , \\alpha , M _ { 1 } , M _ { 2 }$ . ",
+        "bbox": [
+            176,
+            681,
+            648,
+            696
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "The above theorem holds for a general classifier learned by any algorithms. Due to its generality, we need to introduce some technical regularity conditions on the density function. The assumption (4) assume the decay rate of density and its characteristic function, which is common in the literature, e.g. [14]. This theorem demonstrates that, the generalization error can be bounded by a function of the variation of $h$ , and it converges to 0 as the variation approaches to 0. Under some special but typical case where the top model $g$ is linear, we can further show that even without the regularity conditions in Theorem 4.1, we have a much better (linear) convergence rate. ",
+        "bbox": [
+            173,
+            705,
+            826,
+            804
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Theorem 4.2 (Linear Top Model). Consider any loss satisfying $\\begin{array} { r } { \\ell ( \\hat { y } , y ) = \\sum _ { k = 1 } ^ { K } \\ell _ { 0 } ( \\hat { y } _ { k } , y _ { k } ) } \\end{array}$ .4 For any classifier with linear top model $g$ , i.e., ",
+        "bbox": [
+            173,
+            809,
+            823,
+            839
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/fd483c8cfb69d41c51abea8bfcbef01bb15ff1bdd62fa9a0e20893ef0103bc4c.jpg",
+        "text": "$$\nf ( x ) = A h ( x ) + b w i t h A \\in \\mathbb { R } ^ { K \\times d } , b \\in \\mathbb { R } ^ { K } ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            318,
+            843,
+            647,
+            862
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "$i f ( \\mathcal { E } _ { a v a i l } , \\mathcal { E } _ { a l l } )$ is $\\left( s ( \\cdot ) , \\mathcal { T } ^ { i n f } ( h , \\mathcal { E } _ { a v a i l } ) \\right)$ -learnable under $\\Phi$ with Total Variation $\\rho$ , then we have ",
+        "bbox": [
+            171,
+            90,
+            797,
+            108
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "equation",
+        "img_path": "images/bff65b7e956cd09791c5ed2c8933cda9684cbbae3c4dc554a897bdb02f4ed4da.jpg",
+        "text": "$$\n\\mathrm { e r r } ( f ) \\leq O \\Bigl ( s \\bigl ( \\mathcal { V } ^ { s u p } ( h , \\mathcal { E } _ { a v a i l } ) \\bigr ) \\Bigr ) .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            369,
+            113,
+            594,
+            140
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Here $O ( \\cdot )$ depends only on d and $C$ . ",
+        "bbox": [
+            174,
+            145,
+            413,
+            160
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Discussion. Theorem 4.1 shows that, for any model, the generalization gap depends largely on the model’s variation captured by $\\mathcal { V } ^ { \\mathrm { s u p } } ( h , \\mathcal { E } _ { a v a i l } )$ . The result is irrelevant to the algorithm and provides a guarantee for the generalization gap from $\\mathcal { E } _ { a v a i l }$ to ${ \\mathcal { E } } _ { a l l }$ , so long as the learned model $f$ is invariant, i.e. $\\mathcal { V } ^ { \\mathrm { s u p } } ( h , \\mathcal { E } _ { a v a i l } )$ is small. When $s ( \\cdot )$ is fixed, a model with smaller $\\mathcal { V } ^ { \\mathrm { s u p } } ( h , \\mathcal { E } _ { a v a i l } )$ results in a smaller gap, which matches our understanding that invariant features in $\\mathcal { E } _ { a v a i l }$ are somehow invariant in ${ \\mathcal { E } } _ { a l l }$ . When $\\mathcal { V } ^ { \\mathrm { s u p } } ( h , \\mathcal { E } _ { a v a i l } )$ is fixed, more difficult generalization will generate a larger expansion function, which leads to a larger gap. For the Gaussian class with bounded mean and variance, $\\alpha \\gg d$ and the convergent rate is almost linear. ",
+        "bbox": [
+            173,
+            174,
+            826,
+            286
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "However, without any constraint to $g$ , the convergent rate might be small. Theorem 4.2 then offers a generalization bound with a linear convergent rate under mild assumptions when $g$ is linear, which is common in reality. It relaxes the concentration assumption (Formula 4) and asks only for the integrability of the density. The convergent rate is identical to the convergent rate of the expansion function, showing that $s ( \\cdot )$ captures the generalization quite well. ",
+        "bbox": [
+            173,
+            291,
+            825,
+            362
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Proof Sketch of Theorem 4.1. The proof of the main result, Theorem 4.1, is decomposed into the following steps. First, we transform $\\operatorname { e r r } ( f )$ into the Total Variation of joint distributions of features in different domains (Step 1). To bound the Total Variation, it is sufficient to bound the distance of the corresponding Fourier transform, and further, it is equivalent to bound the Radon transform of joint distributions (Step 2). Eventually, we show that $\\mathcal { V } ^ { \\mathrm { s u p } } ( \\beta ^ { \\top } h , \\mathcal { E } _ { a v a i l } )$ can be used to bound the Radon transform, which finishes the proof (Step 3). ",
+        "bbox": [
+            173,
+            375,
+            825,
+            460
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Step 1. The OOD generalization error can be bounded as: ",
+        "bbox": [
+            173,
+            464,
+            553,
+            479
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "equation",
+        "img_path": "images/9c22961cf79642649ac7052d3371c49427c7a1ab896566ae2ddd688515f2d0dd.jpg",
+        "text": "$$\n\\mathrm { e r r } ( f ) \\le \\operatorname* { s u p } _ { ( e , e ^ { \\prime } ) \\in ( \\mathcal { E } _ { a v a i l } , \\mathcal { E } _ { a l l } ) } \\frac { C } { K } \\sum _ { y \\in \\mathcal { Y } } \\int _ { h \\in \\mathbb { R } ^ { d } } \\big | p _ { h ^ { e } | Y ^ { e } } ( h | y ) - p _ { h ^ { e ^ { \\prime } } | Y ^ { e ^ { \\prime } } } ( h | y ) ) \\big | \\mathrm { d } h .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            232,
+            484,
+            733,
+            525
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Step 2. According to the assumption (4), the dominant term in (7) is ",
+        "bbox": [
+            173,
+            536,
+            622,
+            551
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "equation",
+        "img_path": "images/8d84abc42db5ac0bce20ba33a361ed49a07b3c2d298320a7da3642158de97201.jpg",
+        "text": "$$\n\\int _ { | h | \\leq r _ { 1 } } \\Big | \\int _ { | t | \\leq r _ { 2 } } e ^ { - i \\langle h , t \\rangle } \\big ( \\hat { p } _ { h ^ { e } | Y ^ { e } } ( t | y ) - \\hat { p } _ { h ^ { e ^ { \\prime } } | Y ^ { e ^ { \\prime } } } ( t | y ) \\big ) \\big ) \\mathrm { d } t \\Big | \\mathrm { d } t ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            281,
+            555,
+            681,
+            592
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "where $r _ { 1 }$ and $r _ { 2 }$ are well-selected scalars that depend on $s \\big ( \\mathcal { V } _ { \\rho } ^ { \\mathrm { s u p } } ( h , \\mathcal { E } _ { a v a i l } ) \\big )$ . By the Projection Theorem [31, 42] and the Fourier Inversion Formula, (8) is bounded above by ",
+        "bbox": [
+            173,
+            597,
+            826,
+            627
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "equation",
+        "img_path": "images/49950396e3d8096d0baf981fde2f0be38a8c185cda445644133fe0a23d73c6a7.jpg",
+        "text": "$$\nO ( r _ { 1 } ^ { d } r _ { 2 } ^ { d } ) \\times \\int _ { u \\in \\mathbb { R } } \\big | \\mathscr { R } _ { e ^ { \\prime } } ( \\beta , u ) - \\mathscr { R } _ { e } ( \\beta , u ) \\big | \\mathrm { d } u ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            333,
+            632,
+            630,
+            666
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "where $\\mathcal { R } _ { e } ( \\beta , u )$ is the Radon transform of $p _ { h ^ { e } | Y ^ { e } } ( t | y )$ . ",
+        "bbox": [
+            174,
+            671,
+            534,
+            688
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Step 3. The right-hand side of Formula 8 can be bounded by $O \\big ( r _ { 1 } ^ { d } r _ { 2 } ^ { d } s \\big ( \\mathcal { V } _ { \\rho } ^ { \\mathrm { s u p } } ( h , \\mathcal { E } _ { a v a i l } ) \\big ) \\big )$ . We finish the proof by selecting appropriate $r _ { 1 }$ and $r _ { 2 }$ to balance the rate of the dominant term and other minor terms. For more details, please see Appendix 2 for the complete proofs. ",
+        "bbox": [
+            173,
+            694,
+            825,
+            737
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Now we turn to the lower bound of $\\operatorname { e r r } ( f )$ ",
+        "bbox": [
+            174,
+            742,
+            452,
+            757
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Theorem 4.3 (Lower Bound). Consider 0-1 loss: $\\ell ( \\hat { y } , y ) = \\mathbb { I } ( \\hat { y } \\neq y )$ . For any $\\delta > 0$ and any exps.t. $k x \\leq s ( x ) < + \\infty , x \\in [ 0 , t ]$ $\\begin{array} { r } { s _ { + } ^ { \\prime } ( 0 ) \\triangleq \\operatorname* { l i m } _ { x \\to 0 ^ { + } } \\frac { s ( x ) - s ( 0 ) } { x } \\in ( 1 , + \\infty ) } \\end{array}$ s(x)−s(0) ∈ (1, +∞); 2) exists k > 1, t > 0, $C _ { 0 }$ $O O D$ generaliz $( \\mathcal { E } _ { a v a i l } , \\mathcal { E } _ { a l l } )$ that is $( s ( \\cdot ) , \\delta )$ -learnable under linear feature space $\\Phi$ w.r.t symmetric $K L$ -divergence $\\rho$ , s.t. $\\forall \\varepsilon \\ \\in \\ [ 0 , \\frac { t } { 2 } ] .$ , the optimal classifier $f$ satisfying $\\mathcal { V } ^ { s u p } ( h , \\mathcal { E } _ { a v a i l } ) = \\varepsilon$ will have the OOD generalization error lower bounded by ",
+        "bbox": [
+            173,
+            761,
+            825,
+            848
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "equation",
+        "img_path": "images/b71427ee15ff225ca02625e3250ad817c12b27937efe9a03a49e7ec1eee529f3.jpg",
+        "text": "$$\n\\mathrm { e r r } ( f ) \\geq C _ { 0 } \\cdot s ( \\mathcal { V } ^ { s u p } ( h , \\mathcal { E } _ { a v a i l } ) ) .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            372,
+            853,
+            593,
+            871
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Theorem 4.3 shows that $\\operatorname { e r r } ( f )$ of optimal classifier $f$ is lower bounded by its variation. Here “optimal” means the classifier that minimize $\\mathcal { L } ( f , \\mathcal { E } _ { a v a i l } )$ . Altogether, the above three theorems offer a bidirectional control of OOD generalization error, showing that our formulation can offer a fine-grained description of most OOD generalization problem in a theoretical way. To pursue a good OOD performance, OOD algorithm should focus on improving predictive performance on $\\mathcal { E } _ { a v a i l }$ and controlling the variation $\\mathcal { V } ^ { \\mathrm { s u p } } ( h , \\mathcal { E } _ { a v a i l } )$ simultaneously. Note that this bound starts from population error, and we call for future works to combine our generalization bound and traditional bound from data samples to population error, giving a more complete characterization of the problem. ",
+        "bbox": [
+            171,
+            882,
+            823,
+            912
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            90,
+            825,
+            175
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "5 Variation as a Factor of Model Selection Criterion ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            194,
+            622,
+            212
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "As is pointed out in [21], model selection has a significant effect on domain generalization, and any OOD algorithm without a model selection criterion is not complete. [21] trained more than 45,900 models with different algorithms, and results show that when traditional selection methods are applied, none of OOD algorithms can outperform ERM [58] by a significant margin. This result is not strange, since traditional selection methods focus mainly on (validation) accuracy, which is biased in OOD generalization [21, 63]. A very typical example is Colored MNIST [5], where the image is colored according to the label, but the relationship varies across domains. As explained in [5], ERM principle will only capture this spurious feature (color) and performs badly in ${ \\mathcal { E } } _ { a l l }$ . Since ERM is exactly minimizing loss in $\\mathcal { E } _ { a v a i l }$ , any model selection method using validation accuracy alone is likely to choose ERM rather than any other OOD algorithm [63]. Thus no algorithm will have a significant improvement compared to ERM. ",
+        "bbox": [
+            173,
+            227,
+            825,
+            380
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "A natural question arises: what else can we use, in addition to accuracy? Theorem 4.1 points out that, learning feature with small variation across $\\mathcal { E } _ { a v a i l }$ is important for decreasing OOD generalization error. Once a model $f$ achieves a small $\\mathcal { V } ^ { \\mathrm { s u p } } ( h , \\mathcal { E } _ { a v a i l } )$ , then $\\operatorname { e r r } ( f )$ will be small. If the validation accuracy is also high, we shall know that the OOD accuracy will remain high. To this end, we propose our heuristic selection criterion (Algorithm 1). Instead of considering validation accuracy alone, we combine it with feature variation and select the model with high validation accuracy as well as low variation. ",
+        "bbox": [
+            173,
+            386,
+            825,
+            482
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Algorithm 1: Model Selection ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            501,
+            377,
+            515
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Input: available dataset $\\mathcal { X } _ { a v a i l } = ( \\mathcal { X } _ { t r a i n } , \\mathcal { X } _ { v a l } )$ , candidate models set $\\mathcal { M }$ , var_acc_rate $r _ { 0 }$ .   \nfor $f = g \\circ h$ in $\\mathcal { M }$ do for $i$ in $[ d ]$ do $\\hat { \\mathcal { V } } _ { i } \\gets \\operatorname* { m a x } _ { y \\in \\mathcal { V } , \\mathcal { X } ^ { e } \\neq \\mathcal { X } ^ { e ^ { \\prime } } \\in \\mathcal { X } _ { a v a i l } }$ Total Variation $( \\mathbb { P } ( \\phi _ { i } ^ { e } | y ) , \\mathbb { P } ( \\phi _ { i } ^ { e ^ { \\prime } } | y ) )$ ; .Use GPU KDE end $\\mathcal { V } _ { f } \\gets \\mathrm { m e a n } _ { i \\in [ d ] } \\hat { \\mathcal { V } } _ { i }$ $\\operatorname { A c c } _ { f } $ compute validation accuracy of $f$ using $\\mathcal { X } _ { v a l }$   \nend   \nRetur ${ \\mathfrak { n } } \\operatorname { a r g m a x } _ { f \\in { \\mathcal { M } } } ( \\operatorname { A c c } _ { f } - r _ { 0 } \\mathcal { V } _ { f } )$ ",
+        "bbox": [
+            173,
+            517,
+            810,
+            657
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "We briefly explain Algorithm 1 here. For each candidate model, we calculate its variation using the average of each feature’s variation, i.e., $\\begin{array} { r } { \\frac { 1 } { d } \\sum _ { i \\in [ d ] } \\mathcal { V } ( \\phi _ { i } , \\mathcal { X } _ { a v a i l } ) } \\end{array}$ . When deriving the bounds, we use $\\mathcal { V } ^ { \\mathrm { s u p } }$ instead of their average because we need to consider the worst case, i.e., the worst top model. In practice, we find out that the average of $\\mathcal { V } ( \\phi _ { i } , \\mathcal { X } _ { a v a i l } )$ is enough to improve selection. ",
+        "bbox": [
+            174,
+            679,
+            825,
+            738
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Our criterion of model selection is ",
+        "bbox": [
+            174,
+            744,
+            400,
+            758
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "equation",
+        "img_path": "images/f4a8d3348d12ad167259139dedde77e64f96549c3f99a91438c1b14e5a3f0957.jpg",
+        "text": "$$\n\\operatorname { A c c } _ { f } { - r _ { 0 } \\gamma _ { f } } ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            434,
+            767,
+            531,
+            784
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "i.e., we select a model with high validation accuracy and low variation simultaneously. Here $r _ { 0 }$ is a hyper-parameter representing the concrete relationship between $\\operatorname { e r r } ( f )$ and $\\mathcal { V } _ { f }$ . Although we have already used one hyper-parameter to help select multiple hyper-parameter combinations, it is natural to ask whether we can further get rid of the selection of $r _ { 0 }$ . Since $r _ { 0 }$ represents the relationship between variation and accuracy, which is actually determined by the unknown expansion function, explicitly calculating $r _ { 0 }$ is not possible. However, we can empirically estimate $r _ { 0 }$ using $\\begin{array} { r } { r _ { 0 } = \\frac { \\mathrm { S t d } _ { f \\in \\hat { \\mathcal { M } } } \\mathrm { A c c } _ { f } } { \\mathrm { S t d } _ { f \\in \\hat { \\mathcal { M } } } \\mathcal { V } _ { f } } } \\end{array}$ where $\\hat { \\mathcal { M } } \\subset \\mathcal { M }$ is the model with not bad validation accuracy. We do not use the whole set $\\mathcal { M }$ because some OOD algorithms will perform extremely bad when the penalty is huge, and these models will influence our estimation of the ratio. Since high validation means large informativeness in learned features, the use of $\\hat { \\mathcal { M } }$ is an implicit application of informative assumption. ",
+        "bbox": [
+            173,
+            791,
+            825,
+            912
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            171,
+            90,
+            825,
+            122
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "As shown in Section 6.1, our method can select models with higher OOD accuracy in various OOD datasets. We also explain in Appendix 3 why our method can outperform the traditional method in Color MNIST, where the dataset is hand-make and simple enough to calculate the expansion function. ",
+        "bbox": [
+            174,
+            127,
+            825,
+            170
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "6 Experiments ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            188,
+            312,
+            205
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "In this section, we conduct experiments to compare our model selection criterion (Section 5) with the baseline method5 [21]. Since both the variation and informativeness in Definition 3.1 are based on one-dimensional features, we can directly estimate these quantities feature-by-feature and design model selection method based on them. To verify the existence of the expansion function and to see what it’s like in a real-world dataset, we plot nearly 2 million features trained in a common-used OOD dataset and compute their variation and informativeness. We then draw the expansion function for this problem. ",
+        "bbox": [
+            174,
+            218,
+            825,
+            315
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "6.1 Experiments on Model Selection ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            330,
+            437,
+            345
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "In this section, we conduct experiments to compare the performance of models selected by our method and by validation accuracy. We train models on different datasets, different $\\mathcal { E } _ { a v a i l }$ , and select models according to a different selection criteria. We then compare the OOD accuracy of selected models. ",
+        "bbox": [
+            174,
+            356,
+            825,
+            411
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Settings We train our model on three benchmark OOD datasets (PACS [34], OfficeHome [59], VLCS [57]) and consider all possible selections of $( \\mathcal { E } _ { a v a i l } , \\mathcal { E } _ { a l l } )$ . We choose ResNet–50 as our network architecture. We use ERM [58] and four common-used OOD algorithms (CORAL [55], Inter-domain Mixup [62], Group DRO [51], and IRM [5]). For each environment setup, we train 200 models using different algorithms, penalties, learning rates, and epoch. After training, we employ different selection methods and compare the OOD accuracy of the selected models. As stated in Section 5, we use the standard deviation of $\\nu$ and validation accuracy in $\\hat { \\mathcal { M } }$ to estimate $r _ { 0 }$ , where ${ \\hat { \\mathcal { M } } } = \\{ f \\in { \\mathcal { M } } : \\operatorname { A c c } _ { f } \\geq \\operatorname* { m a x } _ { \\hat { f } } \\operatorname { A c c } _ { \\hat { f } } - 0 . 1 \\}$ . Note that calculating $\\mathcal { V } ( \\phi _ { i } , \\mathcal { X } _ { a v a i l } )$ takes calculus many times, so we design a parallel GPU kernel density estimation to speed up the whole process a hundred times and manage to finish one model in seconds. For more details about the experiments, see Appendix 4. ",
+        "bbox": [
+            173,
+            425,
+            826,
+            584
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "table",
+        "img_path": "images/cb2470f47e4fb512f2684a9e17c4e49890f16f65e01308e130f28a69279cde8a.jpg",
+        "table_caption": [
+            "Table 1: Model Selection Result. “Env” denotes the unseen domain during training. “Val” denotes the OOD accuracy of model selected by validation accuracy. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=\"3\">PACS</td><td>Env</td><td>A</td><td>C</td><td>P</td><td>S</td><td>avg</td><td>acc inc</td></tr><tr><td>Val</td><td>85.20%</td><td>80.42%</td><td>96.17%</td><td>77.86%</td><td>84.91%</td><td>1</td></tr><tr><td>Ours</td><td>88.72%</td><td>81.74%</td><td>96.83%</td><td>79.00%</td><td>86.57%</td><td>1.66%↑</td></tr><tr><td rowspan=\"3\">OfficeHome</td><td>Env</td><td>A</td><td>C</td><td>P</td><td>R</td><td>avg</td><td>acc inc</td></tr><tr><td>Val</td><td>61.85%</td><td>55.56%</td><td>74.72%</td><td>76.25%</td><td>67.09%</td><td>-</td></tr><tr><td>Ours</td><td>65.76%</td><td>55.07%</td><td>75.20%</td><td>76.31%</td><td>68.09%</td><td>1.00%↑</td></tr><tr><td rowspan=\"3\">VLCS</td><td>Env</td><td>C</td><td>L</td><td>S</td><td>V</td><td>avg</td><td>acc inc</td></tr><tr><td>Val</td><td>97.46%</td><td>64.83%</td><td>69.50%6</td><td>70.97%</td><td>75.69%</td><td>1</td></tr><tr><td>Ours</td><td>97.81%</td><td>66.98%</td><td>69.50%</td><td>70.97%</td><td>76.32%</td><td>0.63%↑</td></tr></table>",
+        "bbox": [
+            200,
+            643,
+            797,
+            775
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Result We summarize our experimental results in Table 1. For each environment setup, we select the best model according to Algorithm 1 and validation accuracy. The results show that on all datasets, our selection criterion significantly outperforms the validation accuracy in average OOD accuracy. For a more detailed comparison, our method improves the OOD accuracy in most of the 12 setups. Our experiments demonstrate that our criterion can help select models with higher OOD accuracy. ",
+        "bbox": [
+            173,
+            792,
+            826,
+            863
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "image",
+        "img_path": "images/c514b7d4698237506faccba2638407d1bd68cc2a61ac79a424f03d7abc31b464.jpg",
+        "image_caption": [
+            "Figure 1: The expansion function of the OOD generalization problem on Office-Home. The $\\mathbf { X } ^ { } -$ -axis stands for $\\mathcal { V } ( \\phi , \\mathcal { E } _ { a v a i l } )$ and the y-axis for $\\mathcal { V } ( \\phi , \\mathcal { E } _ { a l l } )$ . There are approximately 2 million points in each image, with each point representing a feature, and its color represents its informativeness. The solid red line stands for the expansion function under the corresponding $\\delta$ . When $\\delta$ increases, the expansion function decreases. When $\\delta = 0$ , no expansion function can make it learnable. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            191,
+            121,
+            810,
+            234
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "One may wonder if the expansion function really exists and what it will look like for a real-world OOD generalization task. In this section, we consider the OOD dataset Office-Home [59]. We explicitly plot millions of features’ $\\mathcal { V } _ { \\rho } \\big ( \\phi , \\mathcal { E } _ { a v a i l } \\big )$ and $\\mathcal { V } _ { \\rho } \\big ( \\phi , \\mathcal { E } _ { a l l } \\big )$ with Total Variation $\\rho$ to see what the expansion function is like in this task. We take the architecture as ResNet-50 [23], and we trained thousands of models with more than five algorithms, obtaining about 2 million features. The results are in Figure 1. ",
+        "bbox": [
+            174,
+            327,
+            825,
+            411
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Existence of $s ( \\cdot )$ . When $\\delta = 0$ , some non-informative features are nearly 0-invariant across $\\mathcal { E } _ { a v a i l }$ but are varying across ${ \\mathcal { E } } _ { a l l }$ , so no expansion function can make this task learnable, i.e., this task is NOT $( s ( \\cdot ) , 0 )$ for any expansion function. But as $\\delta$ increases, only informative features are left, and now we can find appropriate $s ( \\cdot )$ to make it learnable. We can clearly realize from the figure that $s ( \\cdot )$ do exist when $\\delta \\geq 0 . 1 5$ . ",
+        "bbox": [
+            174,
+            424,
+            825,
+            494
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Trade-off between $s ( \\cdot )$ and $\\delta$ . The second phenomenon is that the slope of $s ( \\cdot )$ decreases as $\\delta$ increases, showing a trade-off between $s ( \\cdot )$ and $\\delta$ . Although this trade-off comes naturally from the definition of learnability, it has a deep meaning. As is shown in Section 4, $\\operatorname { e r r } ( f )$ is bounded by $O ( s ( \\varepsilon ) )$ where $\\varepsilon$ is the variation of the model. To make the bound tighter, a natural idea is to choose a flatter $s ( \\cdot )$ . However, a flatter $s ( \\cdot )$ corresponds to a larger $\\delta$ . Typically, learning a model to meet this higher informativeness requirement is more difficult, and it is possible that the algorithm achieves this by capturing more domain-specific features, which will therefore increase the variation of the model, $\\varepsilon$ . As a result, we are not sure whether $s ( \\varepsilon )$ will increase or decrease. We believe this is also the essence of model selection: i.e., to trade-off between the variation and informativeness of a model, which is done in Formula 11. ",
+        "bbox": [
+            173,
+            508,
+            825,
+            647
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "7 More Related Works ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            665,
+            379,
+            683
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Domain generalization [12, 39], or OOD generalization, has drawn much attention recently [21, 30]. The goal is to learn a model from several training domains and expect good performance on unseen test domains. [60, 64] offer a comprehensive survey. A popular solution is to extract domain-invariant feature representation. [45] and [49] proved that when the model is linear, the invariance under training domains can help discover invariant features on test domains. [5] introduces the invariant prediction into neural networks and proposes a practical objective function. After that, a lot of works arise from the view of causal discovery, distributional robustness and conditional independence [1, 7, 16, 15, 26, 32, 33, 43, 51, 61]. On the other hand, some works point out the weakness of existing methods from the theoretical and experimental perspectives [2, 21, 29, 41, 50]. ",
+        "bbox": [
+            173,
+            696,
+            825,
+            821
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "The OOD generalization requires restrictions on how the target domains may differ. A straightforward approach is to define a set of test domains around the training domain using some distribution distance measure [6, 13, 19, 25, 51, 53, 54, 61]. Another feasible route is the causal framework which is robust to the test distributions caused by interventions[44, 46] on variables, e.g., [5, 24, 36, 37, 40, 47, 49, 52]. The principle of these methods is that a causal model is invariant and can achieve the minimal worstcase risk [4, 22, 44, 49]. Since the test distribution is unknown, additional assumptions are required for generalization analysis. [12, 18, 39] assume that the domains are generated from a hyper-distribution and measures the average risk estimation error bound. [3] derives a risk bound for any linear combination of training domains. For more related results in domain adaptation, a closed field where the test domains can be seen but are unlabeled, please see [9, 10, 28]. ",
+        "bbox": [
+            174,
+            828,
+            825,
+            911
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            92,
+            825,
+            147
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "8 Conclusion ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            166,
+            299,
+            184
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "In this paper, we take the first step towards a rigorous theoretical framework of OOD generalization. We propose a mathematical formulation to characterize the learnability of OOD generalization problem. Based on our framework, we prove generalization bounds and give guarantees for OOD generalization error. Inspired by our bound, we design a model selection criterion to check the model’s variation and validation accuracy simultaneously. Experiments show that our metric has a significant advantage over the traditional selection method. ",
+        "bbox": [
+            174,
+            198,
+            825,
+            280
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Acknowledgments and Disclosure of Funding ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            299,
+            553,
+            318
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Authors are thankful to the anonymous reviewers for their helpful and constructive feedback. ",
+        "bbox": [
+            171,
+            332,
+            779,
+            347
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "References ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            364,
+            266,
+            381
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "[1] Kartik Ahuja, Karthikeyan Shanmugam, Kush Varshney, and Amit Dhurandhar. Invariant risk minimization games. arXiv preprint arXiv:2002.04692, 2020.   \n[2] Kartik Ahuja, Jun Wang, Amit Dhurandhar, Karthikeyan Shanmugam, and Kush R Varshney. Empirical or invariant risk minimization? a sample complexity perspective. arXiv preprint arXiv:2010.16412, 2020.   \n[3] Isabela Albuquerque, João Monteiro, Tiago H Falk, and Ioannis Mitliagkas. Adversarial target-invariant representation learning for domain generalization. arXiv preprint arXiv:1911.00804, 2019.   \n[4] John Aldrich. Autonomy. Oxford Economic Papers, 41(1):15–34, 1989.   \n[5] Martin Arjovsky, Léon Bottou, Ishaan Gulrajani, and David Lopez-Paz. Invariant risk minimization. arXiv preprint arXiv:1907.02893, 2019.   \n[6] J Andrew Bagnell. Robust supervised learning. In Proceedings of the national conference on artificial intelligence, volume 20, page 714. Menlo Park, CA; Cambridge, MA; London; AAAI Press; MIT Press; 1999, 2005.   \n[7] Haoyue Bai, Rui Sun, Lanqing Hong, Fengwei Zhou, Nanyang Ye, Han-Jia Ye, S-H Gary Chan, and Zhenguo Li. Decaug: Out-of-distribution generalization via decomposed feature representation and semantic augmentation. arXiv preprint arXiv:2012.09382, 2020.   \n[8] Sara Beery, Grant Van Horn, and Pietro Perona. Recognition in terra incognita. In Proceedings of the European Conference on Computer Vision (ECCV), September 2018.   \n[9] Shai Ben-David, John Blitzer, Koby Crammer, Fernando Pereira, et al. Analysis of representations for domain adaptation. Advances in neural information processing systems, 19:137, 2007.   \n[10] Shai Ben-David, John Blitzer, Koby Crammer, Alex Kulesza, Fernando Pereira, and Jennifer Wortman Vaughan. A theory of learning from different domains. Machine learning, 79(1):151–175, 2010.   \n[11] Yoshua Bengio, Tristan Deleu, Nasim Rahaman, Nan Rosemary Ke, Sebastien Lachapelle, Olexa Bilaniuk, Anirudh Goyal, and Christopher Pal. A meta-transfer objective for learning to disentangle causal mechanisms. In International Conference on Learning Representations, 2019.   \n[12] Gilles Blanchard, Gyemin Lee, and Clayton Scott. Generalizing from several related classification tasks to a new unlabeled sample. Advances in neural information processing systems, 24:2178–2186, 2011.   \n[13] Jose Blanchet, Yang Kang, Karthyek Murthy, and Fan Zhang. Data-driven optimal transport cost selection for distributionally robust optimization. In 2019 Winter Simulation Conference (WSC), pages 3740–3751. IEEE, 2019.   \n[14] Laurent Cavalier. Efficient estimation of a density in a problem of tomography. Annals of Statistics, pages 630–647, 2000.   \n[15] Shiyu Chang, Yang Zhang, Mo Yu, and Tommi Jaakkola. Invariant rationalization. In International Conference on Machine Learning, pages 1448–1458. PMLR, 2020.   \n[16] Elliot Creager, Joern-Henrik Jacobsen, and Richard Zemel. Exchanging lessons between algorithmic fairness and domain generalization, 2021. URL https://openreview.net/forum?id=DC1Im3MkGG.   \n[17] Alex J DeGrave, Joseph D Janizek, and Su-In Lee. Ai for radiographic covid-19 detection selects shortcuts over signal. medRxiv, 2020.   \n[18] Aniket Anand Deshmukh, Yunwen Lei, Srinagesh Sharma, Urun Dogan, James W Cutler, and Clayton Scott. A generalization error bound for multi-class domain generalization. arXiv preprint arXiv:1905.10392, 2019.   \n[19] Peyman Mohajerin Esfahani and Daniel Kuhn. Data-driven distributionally robust optimization using the wasserstein metric: Performance guarantees and tractable reformulations. Mathematical Programming, 171(1-2):115–166, 2018.   \n[20] Yaroslav Ganin, Evgeniya Ustinova, Hana Ajakan, Pascal Germain, Hugo Larochelle, François Laviolette, Mario Marchand, and Victor Lempitsky. Domain-adversarial training of neural networks. The journal of machine learning research, 17(1):2096–2030, 2016.   \n[21] Ishaan Gulrajani and David Lopez-Paz. In search of lost domain generalization. arXiv preprint arXiv:2007.01434, 2020.   \n[22] Trygve Haavelmo. The probability approach in econometrics. Econometrica: Journal of the Econometric Society, pages iii–115, 1944.   \n[23] Kaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. Deep residual learning for image recognition. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition (CVPR), June 2016.   \n[24] Christina Heinze-Deml and Nicolai Meinshausen. Conditional variance penalties and domain shift robustness. Machine Learning, 110(2):303–348, 2021.   \n[25] Zhaolin Hu and L Jeff Hong. Kullback-leibler divergence constrained distributionally robust optimization. Available at Optimization Online, 2013.   \n[26] Wengong Jin, Regina Barzilay, and Tommi Jaakkola. Domain extrapolation via regret minimization. arXiv preprint arXiv:2006.03908, 2020.   \n[27] Wengong Jin, Regina Barzilay, and Tommi S. Jaakkola. Enforcing predictive invariance across structured biomedical domains, 2021. URL https://openreview.net/forum?id $=$ JywMsiz_NtO.   \n[28] Fredrik D Johansson, David Sontag, and Rajesh Ranganath. Support and invertibility in domain-invariant representations. In The 22nd International Conference on Artificial Intelligence and Statistics, pages 527–536. PMLR, 2019.   \n[29] Pritish Kamath, Akilesh Tangella, Danica J Sutherland, and Nathan Srebro. Does invariant risk minimization capture invariance? arXiv preprint arXiv:2101.01134, 2021.   \n[30] Pang Wei Koh, Shiori Sagawa, Henrik Marklund, Sang Michael Xie, Marvin Zhang, Akshay Balsubramani, Weihua Hu, Michihiro Yasunaga, Richard Lanas Phillips, Sara Beery, et al. Wilds: A benchmark of in-the-wild distribution shifts. arXiv preprint arXiv:2012.07421, 2020.   \n[31] Aleksandr Petrovich Korostelev and Alexandre B Tsybakov. Minimax theory of image reconstruction, volume 82. Springer Science & Business Media, 2012.   \n[32] Masanori Koyama and Shoichiro Yamaguchi. Out-of-distribution generalization with maximal invariant predictor. arXiv preprint arXiv:2008.01883, 2020.   \n[33] David Krueger, Ethan Caballero, Joern-Henrik Jacobsen, Amy Zhang, Jonathan Binas, Remi Le Priol, and Aaron Courville. Out-of-distribution generalization via risk extrapolation (rex). arXiv preprint arXiv:2003.00688, 2020.   \n[34] Da Li, Yongxin Yang, Yi-Zhe Song, and Timothy M Hospedales. Deeper, broader and artier domain generalization. In Proceedings of the IEEE international conference on computer vision, pages 5542–5550, 2017.   \n[35] Haoliang Li, Sinno Jialin Pan, Shiqi Wang, and Alex C Kot. Domain generalization with adversarial feature learning. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pages 5400–5409, 2018.   \n[36] Sara Magliacane, Thijs van Ommen, Tom Claassen, Stephan Bongers, Philip Versteeg, and Joris M Mooij. Domain adaptation by using causal inference to predict invariant conditional distributions. arXiv preprint arXiv:1707.06422, 2017.   \n[37] Nicolai Meinshausen. Causality from a distributional robustness point of view. In 2018 IEEE Data Science Workshop (DSW), pages 6–10. IEEE, 2018.   \n[38] Jose G Moreno-Torres, Troy Raeder, Rocío Alaiz-Rodríguez, Nitesh V Chawla, and Francisco Herrera. A unifying view on dataset shift in classification. Pattern recognition, 45(1):521–530, 2012.   \n[39] Krikamol Muandet, David Balduzzi, and Bernhard Schölkopf. Domain generalization via invariant feature representation. In International Conference on Machine Learning, pages 10–18, 2013.   \n[40] Jens Müller, Robert Schmier, Lynton Ardizzone, Carsten Rother, and Ullrich Köthe. Learning robust models using the principle of independent causal mechanisms. arXiv preprint arXiv:2010.07167, 2020.   \n[41] Vaishnavh Nagarajan, Anders Andreassen, and Behnam Neyshabur. Understanding the failure modes of out-of-distribution generalization. arXiv preprint arXiv:2010.15775, 2020.   \n[42] Frank Natterer. The mathematics of computerized tomography. SIAM, 2001.   \n[43] Giambattista Parascandolo, Alexander Neitz, Antonio Orvieto, Luigi Gresele, and Bernhard Schölkopf. Learning explanations that are hard to vary. arXiv preprint arXiv:2009.00329, 2020.   \n[44] Judea Pearl. Causality. Cambridge university press, 2009.   \n[45] Jonas Peters, Peter Bühlmann, and Nicolai Meinshausen. Causal inference by using invariant prediction: identification and confidence intervals. Journal of the Royal Statistical Society. Series B (Statistical Methodology), pages 947–1012, 2016.   \n[46] Jonas Peters, Dominik Janzing, and Bernhard Schölkopf. Elements of causal inference: foundations and learning algorithms. The MIT Press, 2017.   \n[47] Niklas Pfister, Evan G Williams, Jonas Peters, Ruedi Aebersold, and Peter Bühlmann. Stabilizing variable selection and regression. arXiv preprint arXiv:1911.01850, 2019.   \n[48] Benjamin Recht, Rebecca Roelofs, Ludwig Schmidt, and Vaishaal Shankar. Do imagenet classifiers generalize to imagenet? In International Conference on Machine Learning, pages 5389–5400. PMLR, 2019.   \n[49] Mateo Rojas-Carulla, Bernhard Schölkopf, Richard Turner, and Jonas Peters. Invariant models for causal transfer learning. The Journal of Machine Learning Research, 19(1):1309–1342, 2018.   \n[50] Elan Rosenfeld, Pradeep Ravikumar, and Andrej Risteski. The risks of invariant risk minimization. arXiv preprint arXiv:2010.05761, 2020.   \n[51] Shiori Sagawa, Pang Wei Koh, Tatsunori B Hashimoto, and Percy Liang. Distributionally robust neural networks. In International Conference on Learning Representations, 2019.   \n[52] Bernhard Schölkopf, Dominik Janzing, Jonas Peters, Eleni Sgouritsa, Kun Zhang, and Joris Mooij. On causal and anticausal learning. arXiv preprint arXiv:1206.6471, 2012.   \n[53] Soroosh Shafieezadeh Abadeh, Peyman M Mohajerin Esfahani, and Daniel Kuhn. Distributionally robust logistic regression. Advances in Neural Information Processing Systems, 28:1576–1584, 2015.   \n[54] Aman Sinha, Hongseok Namkoong, and John Duchi. Certifying some distributional robustness with principled adversarial training. In International Conference on Learning Representations, 2018.   \n[55] Baochen Sun and Kate Saenko. Deep coral: Correlation alignment for deep domain adaptation. In European conference on computer vision, pages 443–450. Springer, 2016.   \n[56] Rohan Taori, Achal Dave, Vaishaal Shankar, Nicholas Carlini, Benjamin Recht, and Ludwig Schmidt. Measuring robustness to natural distribution shifts in image classification. Advances in Neural Information Processing Systems, 33, 2020.   \n[57] Antonio Torralba and Alexei A Efros. Unbiased look at dataset bias. In CVPR 2011, pages 1521–1528. IEEE, 2011.   \n[58] Vladimir Vapnik. Principles of risk minimization for learning theory. In Advances in neural information processing systems, pages 831–838, 1992.   \n[59] Hemanth Venkateswara, Jose Eusebio, Shayok Chakraborty, and Sethuraman Panchanathan. Deep hashing network for unsupervised domain adaptation. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pages 5018–5027, 2017.   \n[60] Jindong Wang, Cuiling Lan, Chang Liu, Yidong Ouyang, Wenjun Zeng, and Tao Qin. Generalizing to unseen domains: A survey on domain generalization. arXiv preprint arXiv:2103.03097, 2021.   \n[61] Chuanlong Xie, Fei Chen, Yue Liu, and Zhenguo Li. Risk variance penalization. arXiv preprint arXiv:2006.07544, 2020.   \n[62] Shen Yan, Huan Song, Nanxiang Li, Lincan Zou, and Liu Ren. Improve unsupervised domain adaptation with mixup training. arXiv preprint arXiv:2001.00677, 2020.   \n[63] Haotian Ye, Chuanlong Xie, Yue Liu, and Zhenguo Li. Out-of-distribution generalization analysis via influence function. arXiv preprint arXiv:2101.08521, 2021.   \n[64] Kaiyang Zhou, Ziwei Liu, Yu Qiao, Tao Xiang, and Chen Change Loy. Domain generalization: A survey. arXiv preprint arXiv:2103.02503, 2021. ",
+        "bbox": [
+            174,
+            380,
+            826,
+            912
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            171,
+            50,
+            828,
+            920
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            171,
+            61,
+            828,
+            922
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            171,
+            92,
+            828,
+            308
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Checklist ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            332,
+            254,
+            348
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "1. For all authors... ",
+        "bbox": [
+            169,
+            359,
+            295,
+            373
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "(a) Do the main claims made in the abstract and introduction accurately reflect the paper’s contributions and scope? [Yes]   \n(b) Did you describe the limitations of your work? [Yes] See Section 5.   \n(c) Did you discuss any potential negative societal impacts of your work? [N/A]   \n(d) Have you read the ethics review guidelines and ensured that your paper conforms to them? [Yes] ",
+        "bbox": [
+            174,
+            377,
+            825,
+            455
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "2. If you are including theoretical results... ",
+        "bbox": [
+            168,
+            459,
+            449,
+            473
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "(a) Did you state the full set of assumptions of all theoretical results? [Yes] (b) Did you include complete proofs of all theoretical results? [Yes] ",
+        "bbox": [
+            174,
+            478,
+            669,
+            508
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "3. If you ran experiments... ",
+        "bbox": [
+            168,
+            513,
+            348,
+            527
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "(a) Did you include the code, data, and instructions needed to reproduce the main experimental results (either in the supplemental material or as a URL)? [Yes]   \n(b) Did you specify all the training details (e.g., data splits, hyperparameters, how they were chosen)? [Yes] In the appendix.   \n(c) Did you report error bars (e.g., with respect to the random seed after running experiments multiple times)? [N/A]   \n(d) Did you include the total amount of compute and the type of resources used (e.g., type of GPUs, internal cluster, or cloud provider)? [Yes] ",
+        "bbox": [
+            174,
+            531,
+            826,
+            650
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "4. If you are using existing assets (e.g., code, data, models) or curating/releasing new assets... ",
+        "bbox": [
+            166,
+            655,
+            782,
+            669
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "(a) If your work uses existing assets, did you cite the creators? [Yes] We use [21] and we cite it in Section 6.   \n(b) Did you mention the license of the assets? [N/A]   \n(c) Did you include any new assets either in the supplemental material or as a URL? [No]   \n(d) Did you discuss whether and how consent was obtained from people whose data you’re using/curating? [Yes]   \n(e) Did you discuss whether the data you are using/curating contains personally identifiable information or offensive content? [N/A] ",
+        "bbox": [
+            173,
+            672,
+            826,
+            794
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "5. If you used crowdsourcing or conducted research with human subjects... ",
+        "bbox": [
+            169,
+            797,
+            661,
+            813
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "(a) Did you include the full text of instructions given to participants and screenshots, if applicable? [N/A]   \n(b) Did you describe any potential participant risks, with links to Institutional Review Board (IRB) approvals, if applicable? [N/A]   \n(c) Did you include the estimated hourly wage paid to participants and the total amount spent on participant compensation? [N/A] ",
+        "bbox": [
+            173,
+            816,
+            826,
+            906
+        ],
+        "page_idx": 12
+    }
+]

parse/train/BJOFETxR-/BJOFETxR-.md

@@ -0,0 +1,320 @@
+# LEARNING TO REPRESENT PROGRAMS WITH GRAPHS
+
+Miltiadis Allamanis   
+Microsoft Research   
+Cambridge, UK   
+miallama@microsoft.com   
+Marc Brockschmidt   
+Microsoft Research   
+Cambridge, UK   
+mabrocks@microsoft.com
+
+Mahmoud Khademi∗ Simon Fraser University Burnaby, BC, Canada mkhademi@sfu.ca
+
+# ABSTRACT
+
+Learning tasks on source code (i.e., formal languages) have been considered recently, but most work has tried to transfer natural language methods and does not capitalize on the unique opportunities offered by code’s known sematics. For example, long-range dependencies induced by using the same variable or function in distant locations are often not considered. We propose to use graphs to represent both the syntactic and semantic structure of code and use graph-based deep learning methods to learn to reason over program structures.
+
+In this work, we present how to construct graphs from source code and how to scale Gated Graph Neural Networks training to such large graphs. We evaluate our method on two tasks: VARNAMING, in which a network attempts to predict the name of a variable given its usage, and VARMISUSE, in which the network learns to reason about selecting the correct variable that should be used at a given program location. Our comparison to methods that use less structured program representations shows the advantages of modeling known structure, and suggests that our models learn to infer meaningful names and to solve the VARMISUSE task in many cases. Additionally, our testing showed that VARMISUSE identifies a number of bugs in mature open-source projects.
+
+# 1 INTRODUCTION
+
+The advent of large repositories of source code as well as scalable machine learning methods naturally leads to the idea of “big code”, i.e., largely unsupervised methods that support software engineers by generalizing from existing source code (Allamanis et al., 2017). Currently, existing deep learning models of source code capture its shallow, textual structure, e.g. as a sequence of tokens (Hindle et al., 2012; Raychev et al., 2014; Allamanis et al., 2016), as parse trees (Maddison & Tarlow, 2014; Bielik et al., 2016), or as a flat dependency networks of variables (Raychev et al., 2015). Such models miss out on the opportunity to capitalize on the rich and well-defined semantics of source code. In this work, we take a step to alleviate this by including two additional signal sources in source code: data flow and type hierarchies. We do this by encoding programs as graphs, in which edges represent syntactic relationships (e.g. “token before/after”) as well as semantic relationships (“variable last used/written here”, “formal parameter for argument is called stream”, etc.). Our key insight is that exposing these semantics explicitly as structured input to a machine learning model lessens the requirements on amounts of training data, model capacity and training regime and allows us to solve tasks that are beyond the current state of the art.
+
+We explore two tasks to illustrate the advantages of exposing more semantic structure of programs. First, we consider the VARNAMING task (Allamanis et al., 2014; Raychev et al., 2015), in which given some source code, the “correct” variable name is inferred as a sequence of subtokens. This requires some understanding of how a variable is used, i.e., requires reasoning about lines of code far apart in the source file. Secondly, we introduce the variable misuse prediction task (VARMISUSE), in which the network aims to infer which variable should be used in a program location. To illustrate the task, Figure 1 shows a slightly simplified snippet of a bug our model detected in a popular open-source project. Specifically, instead of the variable clazz, variable first should have been used in the yellow highlighted slot. Existing static analysis methods cannot detect such issues, even though a software engineer would easily identify this as an error from experience.
+
+![](images/1bc113e2a4c0fb9e0e51adeae6b01b6e7ddf6b162f6335e7e776d43b92e616d2.jpg)  
+Figure 1: A snippet of a detected bug in RavenDB an open-source C# project. The code has been slightly simplified. Our model detects correctly that the variable used in the highlighted (yellow) slot is incorrect. Instead, first should have been placed at the slot. We reported this problem which was fixed in PR 4138.
+
+To achieve high accuracy on these tasks, we need to learn representations of program semantics. For both tasks, we need to learn the semantic role of a variable (e.g., “is it a counter?”, “is it a filename?”). Additionally, for VARMISUSE, learning variable usage semantics (e.g., “a filename is needed here”) is required. This “fill the blank element” task is related to methods for learning distributed representations of natural language words, such as Word2Vec (Mikolov et al., 2013) and GLoVe (Pennington et al., 2014). However, we can learn from a much richer structure such as data flow information. This work is a step towards learning program representations, and we expect them to be valuable in a wide range of other tasks, such as code completion (“this is the variable you are looking for”) and more advanced bug finding (“you should lock before using this object”).
+
+To summarize, our contributions are: (i) We define the VARMISUSE task as a challenge for machine learning modeling of source code, that requires to learn (some) semantics of programs (cf. section 3). (ii) We present deep learning models for solving the VARNAMING and VARMISUSE tasks by modeling the code’s graph structure and learning program representations over those graphs (cf. section 4). (iii) We evaluate our models on a large dataset of 2.9 million lines of real-world source code, showing that our best model achieves $3 2 . 9 \%$ accuracy on the VARNAMING task and $8 5 . 5 \%$ accuracy on the VARMISUSE task, beating simpler baselines (cf. section 5). (iv) We document practical relevance of VARMISUSE by summarizing some bugs that we found in mature open-source software projects $( c f .$ subsection 5.3). Our implementation of graph neural networks (on a simpler task) can be found at https://github.com/Microsoft/gated-graph-neural-network-samples and the dataset can be found at https://aka.ms/iclr18-prog-graphs-dataset.
+
+# 2 RELATED WORK
+
+Our work builds upon the recent field of using machine learning for source code artifacts (Allamanis et al., 2017). For example, Hindle et al. (2012); Bhoopchand et al. (2016) model the code as a sequence of tokens, while Maddison & Tarlow (2014); Raychev et al. (2016) model the syntax tree structure of code. All works on language models of code find that predicting variable and method identifiers is one of biggest challenges in the task.
+
+Closest to our work is the work of Allamanis et al. (2015) who learn distributed representations of variables using all their usages to predict their names. However, they do not use data flow information and we are not aware of any model that does so. Raychev et al. (2015) and Bichsel et al. (2016) use conditional random fields to model a variety of relationships between variables, AST elements and types to predict variable names and types (resp. to deobfuscate Android apps), but without considering the flow of data explicitly. In these works, all variable usages are deterministically known beforehand (as the code is complete and remains unmodified), as in Allamanis et al. (2014; 2015).
+
+Our work is remotely related to work on program synthesis using sketches (Solar-Lezama, 2008) and automated code transplantation (Barr et al., 2015). However, these approaches require a set of specifications (e.g. input-output examples, test suites) to complete the gaps, rather than statistics learned from big code. These approaches can be thought as complementary to ours, since we learn to statistically complete the gaps without any need for specifications, by learning common variable usage patterns from code.
+
+Neural networks on graphs (Gori et al., 2005; Li et al., 2015; Defferrard et al., 2016; Kipf & Welling, 2016; Gilmer et al., 2017) adapt a variety of deep learning methods to graph-structured input. They have been used in a series of applications, such as link prediction and classification (Grover & Leskovec, 2016) and semantic role labeling in NLP (Marcheggiani & Titov, 2017). Somewhat related to source code is the work of Wang et al. (2017) who learn graph-based representations of mathematical formulas for premise selection in theorem proving.
+
+# 3 THE VARMISUSE TASK
+
+Detecting variable misuses in code is a task that requires understanding and reasoning about program semantics. To successfully tackle the task one needs to infer the role and function of the program elements and understand how they relate. For example, given a program such as Fig. 1, the task is to automatically detect that the marked use of $\mathtt { C 1 a z z }$ is a mistake and that first should be used instead. While this task resembles standard code completion, it differs significantly in its scope and purpose, by considering only variable identifiers and a mostly complete program.
+
+Task Description We view a source code file as a sequence of tokens $t _ { 0 } \ldots t _ { N } = \mathcal { T }$ , in which some tokens $t _ { \lambda _ { 0 } } , t _ { \lambda _ { 1 } } \ldots$ are variables. Furthermore, let $\mathbb { V } _ { t } \subset \mathbb { V }$ refer to the set of all type-correct variables in scope at the location of $t$ , i.e., those variables that can be used at $t$ without raising a compiler error. We call a token $t o k _ { \lambda }$ where we want to predict the correct variable usage a slot. We define a separate task for each slot $t _ { \lambda }$ : Given $t _ { 0 } \ldots t _ { \lambda - 1 }$ and $t _ { \lambda + 1 } , \dots , t _ { N }$ , correctly select $t _ { \lambda }$ from $\mathbb { V } _ { t _ { \lambda } }$ . For training and evaluation purposes, a correct solution is one that simply matches the ground truth, but note that in practice, several possible assignments could be considered correct (i.e., when several variables refer to the same value in memory).
+
+# 4 MODEL: PROGRAMS AS GRAPHS
+
+In this section, we discuss how to transform program source code into program graphs and learn representations over them. These program graphs not only encode the program text but also the semantic information that can be obtained using standard compiler tools.
+
+Gated Graph Neural Networks Our work builds on Gated Graph Neural Networks (Li et al., 2015) (GGNN) and we summarize them here. A graph $\mathcal { G } = ( \nu , \pmb { \varepsilon } , \pmb { X } )$ is composed of a set of nodes $\nu$ , node features $\boldsymbol { X }$ , and a list of directed edge sets $\pmb { \mathcal { E } } = ( \mathcal { E } _ { 1 } , \ldots , \mathcal { E } _ { K } )$ where $K$ is the number of edge types. We annotate each $v \in \mathcal V$ with a real-valued vector $\pmb { x } ^ { ( v ) } \in \mathbb { R } ^ { D }$ representing the features of the node (e.g., the embedding of a string label of that node).
+
+We associate every node $v$ with a state vector $\mathbf { \Omega } _ { h } ( v )$ , initialized from the node label $\pmb { x } ^ { ( v ) }$ . The sizes of the state vector and feature vector are typically the same, but we can use larger state vectors through padding of node features. To propagate information throughout the graph, “messages” of type $k$ are sent from each $v$ to its neighbors, where each message is computed from its current state vector as m(vk $m _ { k } ^ { ( v ) } = f _ { k } ( { \pmb h } ^ { ( v ) } )$ . Here, $f _ { k }$ can be an arbitrary function; we choose a linear layer in our case. By computing messages for all graph edges at the same time, all states can be updated at the same time. In particular, a new state for a node $v$ is computed by aggregating all incoming messages as $\tilde { m } ^ { ( v ) } = g ( \{ m _ { k } ^ { ( u ) } \ |$ there is an edge of type $k$ from $u$ to $v \}$ ). $g$ is an aggregation function, which we implement as elementwise summation. Given the aggregated message $\tilde { m } ^ { ( v ) }$ and the current state vector $\mathbf { \Omega } _ { h } ( v )$ of node $v$ , the state of the next time step $\boldsymbol { h ^ { \prime } } ^ { ( v ) }$ is computed as $\pmb { h } ^ { \prime ( v ) } = \mathbf { G } \mathbf { R } \mathbf { U } ( \tilde { \pmb { m } } ^ { ( v ) } , \pmb { h } ^ { ( v ) } )$ , where GRU is the recurrent cell function of gated recurrent unit (GRU) (Cho et al., 2014). The
+
+(a) Simplified syntax graph for line 2 of Fig. 1, where blue rounded boxes are syntax nodes, black rectangular boxes syntax tokens, blue edges Child edges and double black edges NextToken edges.
+
+![](images/f0957bde3bf55bfd9fc41e58429404103dadf9736f4a693bec1cc3c471bc40e7.jpg)  
+Figure 2: Examples of graph edges used in program representation.
+
+![](images/83a96cffbd0f2a1c8368982c7c4bae4e01f2122dfee415273de350b2c11528e5.jpg)
+
+(b) Data flow edges for $\begin{array} { r l r } { ( \overline { { \bf x } } ) ^ { 1 } , \overline { { \boldsymbol { \mathbf { y } } } }  } & { { } = } &  { \bf F o o ( \begin{array} { l } { ) } \ ; } \end{array} \end{array}$ while $\left. \overline { { \mathbf { x } } } \right. ^ { 3 } \ > \ \mathsf { 0 } .$ ) $\underline { { \nabla } } \mathbf { \Sigma } ^ { 4 } \mathbf { \Sigma } = \underline { { \nabla } } \mathbf { \bar { x } } \mathbf { \Sigma } ^ { 5 } \mathbf { \Sigma } ^ { \subset } \mathbf { \Sigma } \boxed { \nabla } \mathbf { \bar { y } } \mathbf { \Sigma } ^ { 6 }$ (indices added for clarity), with red dotted LastUse edges, green dashed LastWrite edges and dashdotted purple ComputedFrom edges.
+
+dynamics defined by the above equations are repeated for a fixed number of time steps. Then, we use the state vectors from the last time step as the node representations.1
+
+Program Graphs We represent program source code as graphs and use different edge types to model syntactic and semantic relationships between different tokens. The backbone of a program graph is the program’s abstract syntax tree (AST), consisting of syntax nodes (corresponding to nonterminals in the programming language’s grammar) and syntax tokens (corresponding to terminals). We label syntax nodes with the name of the nonterminal from the program’s grammar, whereas syntax tokens are labeled with the string that they represent. We use Child edges to connect nodes according to the AST. As this does not induce an order on children of a syntax node, we additionally add NextToken edges connecting each syntax token to its successor. An example of this is shown in Fig. 2a.
+
+To capture the flow of control and data through a program, we add additional edges connecting different uses and updates of syntax tokens corresponding to variables. For such a token $v$ , let $\mathcal { D } ^ { R } ( v )$ be the set of syntax tokens at which the variable could have been used last. This set may contain several nodes (for example, when using a variable after a conditional in which it was used in both branches), and even syntax tokens that follow in the program code (in the case of loops). Similarly, let $\mathcal { D } ^ { W } ( v )$ be the set of syntax tokens at which the variable was last written to. Using these, we add LastRead (resp. LastWrite) edges connecting $v$ to all elements of $\mathcal { D } ^ { R } ( v )$ (resp. $\tilde { \mathcal { D } } ^ { W } ( v ) )$ . Additionally, whenever we observe an assignment $v = e x p r$ , we connect $v$ to all variable tokens occurring in expr using ComputedFrom edges. An example of such semantic edges is shown in Fig. 2b.
+
+We extend the graph to chain all uses of the same variable using LastLexicalUse edges (independent of data flow, i.e., in if (...) { ... v ...} else { ... v ...}, we link the two occurrences of $v$ ). We also connect return tokens to the method declaration using ReturnsTo edges (this creates a “shortcut” to its name and type). Inspired by Rice et al. (2017), we connect arguments in method calls to the formal parameters that they are matched to with FormalArgName edges, i.e., if we observe a call Foo(bar) and a method declaration Foo(InputStream stream), we connect the bar token to the stream token. Finally, we connect every token corresponding to a variable to enclosing guard expressions that use the variable with GuardedBy and GuardedByNegation edges. For example, in if ( $\mathrm { ~ \bf ~ \cdot ~ x ~ } > \mathrm { ~ \bf ~ y ~ }$ ) { ... x ...} else $\{ \ \begin{array} { r l } { \mathrm { ~ \texttt ~ { ~ . ~ . ~ } ~ } \underline { { \mathrm { ~ y ~ } } } \mathrm { ~ . ~ . ~ . ~ } \} } \end{array}$ , we add a GuardedBy edge from $\underline { { \boldsymbol { \mathrm { X } } } }$ (resp. a GuardedByNegation edge from y) to the AST node corresponding to $\mathrm { ~  ~ { ~ x ~ } ~ } > \mathrm { ~  ~ { ~ y ~ } ~ }$ .
+
+Finally, for all types of edges we introduce their respective backwards edges (transposing the adjacency matrix), doubling the number of edges and edge types. Backwards edges help with propagating information faster across the GGNN and make the model more expressive.
+
+Leveraging Variable Type Information We assume a statically typed language and that the source code can be compiled, and thus each variable has a (known) type $\tau ( v )$ . To use it, we define a learnable embedding function $\mathbf { r } ( \tau )$ for known types and additionally define an “UNKTYPE” for all unknown/unrepresented types. We also leverage the rich type hierarchy that is available in many object-oriented languages. For this, we map a variable’s type $\tau ( v )$ to the set of its supertypes, i.e. $\tau ^ { * } \bar { ( } v ) = \{ \tau : \tau ( v ) \quad$ implements type $\tau \} \cup \{ \bar { \tau } ( v ) \}$ . We then compute the type representation $\mathbf { r } ^ { * } ( v )$ of a variable $v$ as the element-wise maximum of $\{ \mathbf { r } ( \tau ) : \tau \in \tau ^ { * } ( v ) \}$ . We chose the maximum here, as it is a natural pooling operation for representing partial ordering relations (such as type lattices). Using all types in $\tau ^ { * } ( v )$ allows us to generalize to unseen types that implement common supertypes or interfaces. For example, List ${ \tt < K > }$ has multiple concrete types (e.g. List<int>, List<string>). Nevertheless, these types implement a common interface (IList) and share common characteristics. During training, we randomly select a non-empty subset of $\tau ^ { * } ( v )$ which ensures training of all known types in the lattice. This acts both like a dropout mechanism and allows us to learn a good representation for all types in the type lattice.
+
+Initial Node Representation To compute the initial node state, we combine information from the textual representation of the token and its type. Concretely, we split the name of a node representing a token into subtokens (e.g. classTypes will be split into two subtokens class and types) on camelCase and pascal_case. We then average the embeddings of all subtokens to retrieve an embedding for the node name. Finally, we concatenate the learned type representation $\mathbf { r } ^ { * } ( v )$ , computed as discussed earlier, with the node name representation, and pass it through a linear layer to obtain the initial representations for each node in the graph.
+
+Programs Graphs for VARNAMING Given a program and an existing variable $v$ , we build a program graph as discussed above and then replace the variable name in all corresponding variable tokens by a special ${ < } S \mathrm { L O T } >$ token. To predict a name, we use the initial node labels computed as the concatenation of learnable token embeddings and type embeddings as discussed above, run GGNN propagation for 8 time steps2 and then compute a variable usage representation by averaging the representations for all ${ < } S \mathrm { L O T } >$ tokens. This representation is then used as the initial state of a one-layer GRU, which predicts the target name as a sequence of subtokens (e.g., the name inputStreamBuffer is treated as the sequence [input, stream, buffer]). We train this graph2seq architecture using a maximum likelihood objective. In section 5, we report the accuracy for predicting the exact name and the F1 score for predicting its subtokens.
+
+Program Graphs for VARMISUSE To model VARMISUSE with program graphs we need to modify the graph. First, to compute a context representation $\mathbf { } c ( t )$ for a slot $t$ where we want to predict the used variable, we insert a new node $v _ { < S \tt L O T > }$ at the position of $t$ , corresponding to a “hole” at this point, and connect it to the remaining graph using all applicable edges that do not depend on the chosen variable at the slot (i.e., everything but LastUse, LastWrite, LastLexicalUse, and GuardedBy edges). Then, to compute the usage representation $\mathbf { u } ( t , v )$ of each candidate variable $v$ at the target slot, we insert a “candidate” node $v _ { t , v }$ for all $v$ in $\mathbb { V } _ { t }$ , and connect it to the graph by inserting the LastUse, LastWrite and LastLexicalUse edges that would be used if the variable were to be used at this slot. Each of these candidate nodes represents the speculative placement of the variable within the scope.
+
+Using the initial node representations, concatenated with an extra bit that is set to one for the candidate nodes $v _ { t , v }$ , we run GGNN propagation for 8 time steps.2 The context and usage representation are then the final node states of the nodes, i.e., $\pmb { c } ( t ) = \pmb { h } ^ { ( v _ { < \mathrm { S L O T } > } ) }$ and $\mathbf { u } ( t , v ) = h ^ { ( v _ { t , v } ) }$ . Finally, the correct variable usage at the location is computed as arg $\textstyle \operatorname* { m a x } _ { v } W [ c ( t ) , \mathbf { u } ( t , v ) ]$ where $W$ is a linear layer that uses the concatenation of $\mathbf { } c ( t )$ and $\mathbf { u } ( t , v )$ . We train using a max-margin objective.
+
+# 4.1 IMPLEMENTATION
+
+Using GGNNs for sets of large, diverse graphs requires some engineering effort, as efficient batching is hard in the presence of diverse shapes. An important observation is that large graphs are normally very sparse, and thus a representation of edges as an adjacency list would usually be advantageous to reduce memory consumption. In our case, this can be easily implemented using a sparse tensor representation, allowing large batch sizes that exploit the parallelism of modern GPUs efficiently. A second key insight is to represent a batch of graphs as one large graph with many disconnected components. This just requires appropriate pre-processing to make node identities unique. As this makes batch construction somewhat CPU-intensive, we found it useful to prepare minibatches on a separate thread. Our TensorFlow (Abadi et al., 2016) implementation scales to 55 graphs per second during training and 219 graphs per second during test-time using a single NVidia GeForce GTX Titan X with graphs having on average 2,228 (median 936) nodes and 8,350 (median 3,274) edges and 8 GGNN unrolling iterations, all 20 edge types (forward and backward edges for 10 original edge types) and the size of the hidden layer set to 64. The number of types of edges in the GGNN contributes proportionally to the running time. For example, a GGNN run for our ablation study using only the two most common edge types (NextToken, Child) achieves 105 graphs/second during training and 419 graphs/second at test time with the same hyperparameters. Our (generic) implementation of GGNNs is available at https://github.com/Microsoft/ gated-graph-neural-network-samples, using a simpler demonstration task.
+
+# 5 EVALUATION
+
+Dataset We collected a dataset for the VARMISUSE task from open source $C ^ { \# }$ projects on GitHub. To select projects, we picked the top-starred (non-fork) projects in GitHub. We then filtered out projects that we could not (easily) compile in full using Roslyn3, as we require a compilation to extract precise type information for the code (including those types present in external libraries). Our final dataset contains 29 projects from a diverse set of domains (compilers, databases, . . . ) with about 2.9 million non-empty lines of code. A full table is shown in Appendix D.
+
+For the task of detecting variable misuses, we collect data from all projects by selecting all variable usage locations, filtering out variable declarations, where at least one other type-compatible replacement variable is in scope. The task is then to infer the correct variable that originally existed in that location. Thus, by construction there is at least one type-correct replacement variable, i.e. picking it would not raise an error during type checking. In our test datasets, at each slot there are on average 3.8 type-correct alternative variables (median 3, $\sigma = 2 . 6$ ).
+
+From our dataset, we selected two projects as our development set. From the rest of the projects, we selected three projects for UNSEENPROJTEST to allow testing on projects with completely unknown structure and types. We split the remaining 23 projects into train/validation/test sets in the proportion 60-10-30, splitting along files (i.e., all examples from one source file are in the same set). We call the test set obtained like this SEENPROJTEST.
+
+Baselines For VARMISUSE, we consider two bidirectional RNN-based baselines. The local model (LOC) is a simple two-layer bidirectional GRU run over the tokens before and after the target location. For this baseline, $\mathbf { } c ( t )$ is set to the slot representation computed by the RNN, and the usage context of each variable $\mathbf { u } ( t , v )$ is the embedding of the name and type of the variable, computed in the same way as the initial node labels in the GGNN. This baseline allows us to evaluate how important the usage context information is for this task. The flat dataflow model (AVGBIRNN) is an extension to LOC, where the usage representation $\mathbf { u } ( t , v )$ is computed using another two-layer bidirectional RNN run over the tokens before/after each usage, and then averaging over the computed representations at the variable token $v$ . The local context, $\mathbf { } c ( t )$ , is identical to LOC. AVGBIRNN is a significantly stronger baseline that already takes some structural information into account, as the averaging over all variables usages helps with long-range dependencies. Both models pick the variable that maximizes $\boldsymbol { c } ( t ) ^ { T } \mathbf { u } ( t , v )$ .
+
+For VARNAMING, we replace LOC by AVGLBL, which uses a log-bilinear model for 4 left and 4 right context tokens of each variable usage, and then averages over these context representations (this corresponds to the model in Allamanis et al. (2015)). We also test AVGBIRNN on VARNAMING, which essentially replaces the log-bilinear context model by a bidirectional RNN.
+
+Table 1: Evaluation of models. SEENPROJTEST refers to the test set containing projects that have files in the training set, UNSEENPROJTEST refers to projects that have no files in the training data. Results averaged over two runs.   
+
+<table><tr><td></td><td colspan="4">SEENPROJTEST</td><td colspan="4">UNSEENPROJTEST</td></tr><tr><td></td><td>Loc</td><td>AVGLBL</td><td>AVGBIRNN</td><td>GGNN</td><td>Loc</td><td>AVGLBL</td><td>AVGBIRNN</td><td>GGNN</td></tr><tr><td>VARMISUSE</td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td></tr><tr><td>Accuracy (%)</td><td>50.0</td><td>二</td><td>73.7</td><td>85.5</td><td>28.9</td><td></td><td>60.2</td><td>78.2</td></tr><tr><td>PR AUC</td><td>0.788</td><td></td><td>0.941</td><td>0.980</td><td>0.611</td><td></td><td>0.895</td><td>0.958</td></tr><tr><td>VARNAMING Accuracy (%)</td><td></td><td>36.1</td><td>42.9</td><td></td><td></td><td></td><td></td><td></td></tr><tr><td></td><td></td><td></td><td></td><td>53.6</td><td></td><td>22.7</td><td>23.4</td><td>44.0</td></tr><tr><td>F1 (%)</td><td></td><td>44.0</td><td>50.1</td><td>65.8</td><td></td><td>30.6</td><td>32.0</td><td>62.0</td></tr></table>
+
+Table 2: Ablation study for the GGNN model on SEENPROJTEST for the two tasks.   
+
+<table><tr><td>Ablation Description</td><td colspan="2">Accuracy (%) VARMISUSE</td></tr><tr><td></td><td></td><td>VARNAMING</td></tr><tr><td>Standard Model (reported in Table 1)</td><td>85.5</td><td>53.6</td></tr><tr><td>Only NextToken, Child, LastUse_LastWrite edges</td><td>80.6</td><td>31.2</td></tr><tr><td>Only semantic edges (all but NextToken, Child) Only syntax edges (NextToken, Child)</td><td>78.4 55.3</td><td>52.9 34.3</td></tr><tr><td>Node Labels: Tokens instead of subtokens</td><td></td><td></td></tr><tr><td>Node Labels:Disabled</td><td>85.6 84.3</td><td>34.5</td></tr><tr><td></td><td></td><td>31.8</td></tr></table>
+
+# 5.1 QUANTITATIVE EVALUATION
+
+Table 1 shows the evaluation results of the models for both tasks.4 As LOC captures very little information, it performs relatively badly. AVGLBL and AVGBIRNN, which capture information from many variable usage sites, but do not explicitly encode the rich structure of the problem, still lag behind the GGNN by a wide margin. The performance difference is larger for VARMISUSE, since the structure and the semantics of code are far more important within this setting.
+
+Generalization to new projects Generalizing across a diverse set of source code projects with different domains is an important challenge in machine learning. We repeat the evaluation using the UNSEENPROJTEST set stemming from projects that have no files in the training set. The right side of Table 1 shows that our models still achieve good performance, although it is slightly lower compared to SEENPROJTEST. This is expected since the type lattice is mostly unknown in UNSEENPROJTEST.
+
+We believe that the dominant problem in applying a trained model to an unknown project (i.e., domain) is the fact that its type hierarchy is unknown and the used vocabulary (e.g. in variables, method and class names, etc.) can differ substantially.
+
+Ablation Study To study the effect of some of the design choices for our models, we have run some additional experiments and show their results in Table 2. First, we varied the edges used in the program graph. We find that restricting the model to syntactic information has a large impact on performance on both tasks, whereas restricting it to semantic edges seems to mostly impact performance on VARMISUSE. Similarly, the ComputedFrom, FormalArgName and ReturnsTo edges give a small boost on VARMISUSE, but greatly improve performance on VARNAMING. As evidenced by the experiments with the node label representation, syntax node and token names seem to matter little for VARMISUSE, but naturally have a great impact on VARNAMING.
+
+# 5.2 QUALITATIVE EVALUATION
+
+Figure 3 illustrates the predictions that GGNN makes on a sample test snippet. The snippet recursively searches for the global directives file by gradually descending into the root folder. Reasoning about the correct variable usages is hard, even for humans, but the GGNN correctly predicts the variable usages at all locations except two (slot 1 and 8). As a software engineer is writing the code, it is imaginable that she may make a mistake misusing one variable in the place of another. Since all variables are string variables, no type errors will be raised. As the probabilities in Fig. 3 suggest most potential variable misuses can be flagged by the model yielding valuable warnings to software engineers. Additional samples with comments can be found in Appendix B.
+
+![](images/cd8c9c73a863608276a7923a4347ae44724d33325aed2f76dd26669048968bd2.jpg)  
+Figure 3: VARMISUSE predictions on slots within a snippet of the SEENPROJTEST set for the ServiceStack project. Additional visualizations are available in Appendix B. The underlined tokens are the correct tokens. The model has to select among a number of string variables at each slot, where all of them represent some kind of path. The GGNN accurately predicts the correct variable usage in 11 out of the 13 slots reasoning about the complex ways the variables interact among them.
+
+![](images/1a46d813f5e2a8d4ca1585320818302c03d99347f9237a6ad178e6da4a0a1573.jpg)  
+Figure 4: A bug found (yellow) in RavenDB open-source project. The code unnecessarily ensures that the buffer is of size length rather than size (which our model predicts as the correct variable here).
+
+Furthermore, Appendix C shows samples of pairs of code snippets that share similar representations as computed by the cosine similarity of the usage representation $\mathbf { u } ( t , v )$ of GGNN. The reader can notice that the network learns to group variable usages that share semantic similarities together. For example, checking for null before the use of a variable yields similar distributed representations across code segments (Sample 1 in Appendix C).
+
+# 5.3 DISCOVERED VARIABLE MISUSE BUGS
+
+We have used our VARMISUSE model to identify likely locations of bugs in RavenDB (a document database) and Roslyn (Microsoft’s $C ^ { \# }$ compiler framework). For this, we manually reviewed a sample of the top 500 locations in both projects where our model was most confident about a choosing a variable differing from the ground truth, and found three bugs in each of the projects.
+
+Figs. 1,4,5 show the issues discovered in RavenDB. The bug in Fig. 1 was possibly caused by copy-pasting, and cannot be easily caught by traditional methods. A compiler will not warn about unused variables (since first is used) and virtually nobody would write a test testing another test. Fig. 4 shows an issue that, although not critical, can lead to increased memory consumption. Fig. 5 shows another issue arising from a non-informative error message. We privately reported three additional bugs to the Roslyn developers, who have fixed the issues in the meantime (cf. https://github.com/dotnet/roslyn/pull/23437). One of the reported bugs could cause a crash in Visual Studio when using certain Roslyn features.
+
+![](images/336e106c897c8cfa8eb64fc3ca64fbd06fdd03a060af8c210b6cbadf7e1fcc42.jpg)  
+Figure 5: A bug found (yellow) in the RavenDB open-source project. Although backupFilename is found to be invalid by IsValidBackup, the user is notified that backupLocation is invalid instead.
+
+Finding these issues in widely released and tested code suggests that our model can be useful during the software development process, complementing classic program analysis tools. For example, one usage scenario would be to guide the code reviewing process to locations a VARMISUSE model has identified as unusual, or use it as a prior to focus testing or expensive code analysis efforts.
+
+# 6 DISCUSSION & CONCLUSIONS
+
+Although source code is well understood and studied within other disciplines such as programming language research, it is a relatively new domain for deep learning. It presents novel opportunities compared to textual or perceptual data, as its (local) semantics are well-defined and rich additional information can be extracted using well-known, efficient program analyses. On the other hand, integrating this wealth of structured information poses an interesting challenge. Our VARMISUSE task exposes these opportunities, going beyond simpler tasks such as code completion. We consider it as a first proxy for the core challenge of learning the meaning of source code, as it requires to probabilistically refine standard information included in type systems.
+
+# REFERENCES
+
+Martín Abadi, Ashish Agarwal, Paul Barham, Eugene Brevdo, Zhifeng Chen, Craig Citro, Greg S Corrado, Andy Davis, Jeffrey Dean, Matthieu Devin, et al. Tensorflow: Large-scale machine learning on heterogeneous distributed systems. arXiv preprint arXiv:1603.04467, 2016.   
+Miltiadis Allamanis, Earl T Barr, Christian Bird, and Charles Sutton. Learning natural coding conventions. In Foundations of Software Engineering (FSE), 2014.   
+Miltiadis Allamanis, Earl T Barr, Christian Bird, and Charles Sutton. Suggesting accurate method and class names. In Foundations of Software Engineering (FSE), 2015.   
+Miltiadis Allamanis, Hao Peng, and Charles Sutton. A convolutional attention network for extreme summarization of source code. In International Conference on Machine Learning (ICML), pp. 2091–2100, 2016.   
+Miltiadis Allamanis, Earl T Barr, Premkumar Devanbu, and Charles Sutton. A survey of machine learning for big code and naturalness. arXiv preprint arXiv:1709.06182, 2017.   
+Earl T Barr, Mark Harman, Yue Jia, Alexandru Marginean, and Justyna Petke. Automated software transplantation. In International Symposium on Software Testing and Analysis (ISSTA), 2015.   
+Al Bessey, Ken Block, Ben Chelf, Andy Chou, Bryan Fulton, Seth Hallem, Charles Henri-Gros, Asya Kamsky, Scott McPeak, and Dawson Engler. A few billion lines of code later: using static analysis to find bugs in the real world. Communications of the ACM, 53(2):66–75, 2010.   
+Avishkar Bhoopchand, Tim Rocktäschel, Earl Barr, and Sebastian Riedel. Learning Python code suggestion with a sparse pointer network. arXiv preprint arXiv:1611.08307, 2016.
+
+Benjamin Bichsel, Veselin Raychev, Petar Tsankov, and Martin Vechev. Statistical deobfuscation of android applications. In Conference on Computer and Communications Security (CCS), 2016.
+
+Pavol Bielik, Veselin Raychev, and Martin Vechev. PHOG: probabilistic model for code. In International Conference on Machine Learning (ICML), 2016.
+
+Kyunghyun Cho, Bart van Merriënboer, Dzmitry Bahdanau, and Yoshua Bengio. On the properties of neural machine translation: Encoder–decoder approaches. Syntax, Semantics and Structure in Statistical Translation, 2014.
+
+Michaël Defferrard, Xavier Bresson, and Pierre Vandergheynst. Convolutional neural networks on graphs with fast localized spectral filtering. In Neural Information Processing Systems (NIPS), pp. 3844–3852, 2016.
+
+Justin Gilmer, Samuel S. Schoenholz, Patrick F. Riley, Oriol Vinyals, and George E. Dahl. Neural message passing for quantum chemistry. arXiv preprint arXiv:1704.01212, 2017.
+
+Marco Gori, Gabriele Monfardini, and Franco Scarselli. A new model for learning in graph domains. In IEEE International Joint Conference Neural Networks (IJCNN). IEEE, 2005.
+
+Aditya Grover and Jure Leskovec. node2vec: Scalable feature learning for networks. In International Conference on Knowledge Discovery and Data Mining (SIGKDD), pp. 855–864. ACM, 2016.
+
+Abram Hindle, Earl T Barr, Zhendong Su, Mark Gabel, and Premkumar Devanbu. On the naturalness of software. In International Conference on Software Engineering (ICSE), 2012.
+
+Thomas N Kipf and Max Welling. Semi-supervised classification with graph convolutional networks. arXiv preprint arXiv:1609.02907, 2016.
+
+Yujia Li, Daniel Tarlow, Marc Brockschmidt, and Richard Zemel. Gated graph sequence neural networks. In International Conference on Learning Representations (ICLR), 2015.
+
+Chris J Maddison and Daniel Tarlow. Structured generative models of natural source code. In International Conference on Machine Learning (ICML), 2014.
+
+Diego Marcheggiani and Ivan Titov. Encoding sentences with graph convolutional networks for semantic role labeling. In ACL, 2017.
+
+Tomas Mikolov, Ilya Sutskever, Kai Chen, Greg S Corrado, and Jeff Dean. Distributed representations of words and phrases and their compositionality. In Neural Information Processing Systems (NIPS), 2013.
+
+Jeffrey Pennington, Richard Socher, and Christopher D Manning. GloVe: Global vectors for word representation. In EMNLP, 2014.
+
+Veselin Raychev, Martin Vechev, and Eran Yahav. Code completion with statistical language models. In Programming Languages Design and Implementation (PLDI), pp. 419–428, 2014.
+
+Veselin Raychev, Martin Vechev, and Andreas Krause. Predicting program properties from Big Code. In Principles of Programming Languages (POPL), 2015.
+
+Veselin Raychev, Pavol Bielik, and Martin Vechev. Probabilistic model for code with decision trees. In Object-Oriented Programming, Systems, Languages, and Applications (OOPSLA), 2016.
+
+Andrew Rice, Edward Aftandilian, Ciera Jaspan, Emily Johnston, Michael Pradel, and Yulissa Arroyo-Paredes. Detecting argument selection defects. Proceedings of the ACM on Programming Languages, 1(OOPSLA):104, 2017.
+
+Michael Schlichtkrull, Thomas N. Kipf, Peter Bloem, Rianne van den Berg, Ivan Titov, and Max Welling. Modeling relational data with graph convolutional network. arXiv preprint arXiv:1703.06103, 2017.
+
+Armando Solar-Lezama. Program synthesis by sketching. University of California, Berkeley, 2008.
+
+Mingzhe Wang, Yihe Tang, Jian Wang, and Jia Deng. Premise selection for theorem proving by deep graph embedding. In Advances in Neural Information Processing Systems, pp. 2783–2793, 2017.
+
+![](images/8d4734049cdf665102b0203edbfe7d102c214d1ca0e59c1e940ccf68db6434c3.jpg)  
+Figure 6: Precision-Recall and ROC curves for the GGNN model on VARMISUSE. Note that the $y$ axis starts from $50 \%$ .
+
+Table 3: Performance of GGNN model on VARMISUSE per number of type-correct, in-scope candidate variables. Here we compute the performance of the full GGNN model that uses subtokens.   
+
+<table><tr><td># of candidates</td><td>2</td><td>3</td><td>4</td><td></td><td>6or7</td><td>8+</td></tr><tr><td>Accuracy On SEENPROJTEST (%)</td><td>91.6</td><td>84.5</td><td>81.8</td><td>78.6</td><td>75.1</td><td>77.5</td></tr><tr><td>Accuracy On UNSEENPROJTEST (%)</td><td>85.7</td><td>77.1</td><td>75.7</td><td>69.0</td><td>71.5</td><td>62.4</td></tr></table>
+
+# A PERFORMANCE CURVES
+
+Figure 6 shows the ROC and precision-recall curves for the GGNN model. As the reader may observe, setting a false positive rate to $10 \%$ we get a true positive rate5 of $73 \%$ for the SEENPROJTEST and $69 \%$ for the unseen test. This suggests that this model can be practically used at a high precision setting with acceptable performance.
+
+# B VARMISUSE PREDICTION SAMPLES
+
+Below we list a set of samples from our SEENPROJTEST projects with comments about the model performance. Code comments and formatting may have been altered for typesetting reasons. The ground truth choice is underlined.
+
+# Sample 1
+
+![](images/abfe6409dabc3b628a3cb9baa2fdc14d3f39bb8b79f6efc499c55f175cb161d8.jpg)
+
+. The model correctly predicts all variables in the loop.
+
+# Sample 2
+
+![](images/67d1357095f3d80bff9433916647f24a7195c8a63c4dcc5ead0f08be17f5bdaf.jpg)
+
+#1 name: $86 \%$ , DIR_PATH: $14 \%$ #2 path: $90 \%$ , name: $8 \%$ , DIR_PATH: $2 \%$ #3 path: $76 \%$ , name: $16 \%$ , DIR_PATH: $8 \%$
+
+$\triangleright$ String variables are not confused their semantic role is inferred correctly.
+
+# Sample 3
+
+[global::System.Diagnostics.DebuggerNonUserCodeAttribute]   
+public void MergeFrom(pb::CodedInputStream input) { uint tag; while ((tag $=$ input.ReadTag()) $\ ! = ~ 0$ ) { switch(tag) { default: input.SkipLastField(); break; case 10: { #1 .AddEntriesFrom(input, _repeated_payload_codec); break; } }   
+}
+
+#1 Payload: $66 \%$ , payload_: $44 \%$
+
+$\triangleright$ The model is commonly confused by aliases, i.e. variables that point to the same location in memory.   
+In this sample, either choice would have yielded identical behavior.
+
+# Sample 4
+
+![](images/a45880cd7de37c697125e92c3c541033a38ec7e20081fe1d6ce9b55998761b1c.jpg)
+
+#1 gate: $9 9 \%$ , _observers: $1 \%$ #2 _isDisposed: $90 \%$ , _isStopped: $8 \%$ , HasObservers: $2 \%$
+
+. The ReturnsTo edge can help predict variables that otherwise would have been impossible.
+
+# Sample 5
+
+![](images/382d0a5b3bd9d9fd228858bebcaa0e6dfce97d4d8f24faa63d9010e590be558b.jpg)
+
+#1 error: $93 \%$ , _exception: $7 \%$   
+#2 error: $98 \%$ , _exception: $2 \%$   
+#3 _gate: $100 \%$ , _observers: $0 \%$   
+#4 isStopped: $86 \%$ , _isDisposed: $13 \%$ , HasObservers: $1 \%$   
+#5 isStopped: $91 \%$ , _isDisposed: $9 \%$ , HasObservers: $0 \%$   
+#6 _exception: $100 \%$ , error: $0 \%$   
+#7 error: $98 \%$ , _exception: $2 \%$   
+#8 _exception: $9 9 \%$ , error: $1 \%$
+
+$\triangleright$ The model predicts the correct variables from all slots apart from the last. Reasoning about the last one, requires interprocedural understanding of the code across the class file.
+
+# Sample 6
+
+private bool BecomingCommand(object message) if (ReceiveCommand #1 return true; if #2 .ToString() $= =$ #3 #4 .Tell #5 else return false; return true;   
+}
+
+#1 message: $100 \%$ , Response: $0 \%$ , Message: $0 \%$ #2 message: $100 \%$ , Response: $0 \%$ , Message: $0 \%$ #3 Response: $91 \%$ , Message: $9 \%$ #4 Probe: $98 \%$ , AskedForDelete: $2 \%$ #5 Response: $98 \%$ , Message: $2 \%$
+
+. The model predicts correctly all usages except from the one in slot #3. Reasoning about this snippet requires additional semantic information about the intent of the code.
+
+# Sample 7
+
+var response $=$ ResultsFilter(typeof(TResponse), #1 #2 , request);
+
+#1 httpMethod: $9 9 \%$ , absoluteUrl: $1 \%$ , UserName: $0 \%$ , UserAgent: $0 \%$ #2 absoluteUrl: $9 9 \%$ , httpMethod: $1 \%$ , UserName: $0 \%$ , UserAgent: $0 \%$
+
+$\triangleright$ The model knows about selecting the correct string parameters because it matches them to the formal parameter names.
+
+# Sample 8
+
+if #1 $> =$ #2 ) throw new InvalidOperationException(Strings_Core.FAILED_CLOCK_MONITORING)
+
+#1 n: $100 \%$ , MAXERROR: $0 \%$ , SYNC_MAXRETRIES: $0 \%$ #2 MAXERROR: $62 \%$ , SYNC_MAXRETRIES: $22 \%$ , n: $16 \%$
+
+$\triangleright$ It is hard for the model to reason about conditionals, especially with rare constants as in slot #2.
+
+# C NEAREST NEIGHBOR OF GGNN USAGE REPRESENTATIONS
+
+Here we show pairs of nearest neighbors based on the cosine similarity of the learned representations $\mathbf { u } ( t , v )$ . Each slot $t$ is marked in dark blue and all usages of $v$ are marked in yellow (i.e. variableName ). This is a set of hand-picked examples showing good and bad examples. A brief description follows after each pair.
+
+# Sample 1
+
+![](images/3af9a60fadeb14347e4f874e0c1dc803122c0a76e9fdc856fd08d2c98658db62.jpg)
+
+$\triangleright$ Slots that are checked for null-ness have similar representations.
+
+# Sample 2
+
+![](images/d1ada4fdbb0e1a6e130ce0b48d0b02926d9a7f74e9bd9bde7dc55ae52c59ef8f.jpg)
+
+$\triangleright$ Slots that follow similar API protocols have similar representations. Note that the function HasAddress is a local function, seen only in the testset.
+
+# Sample 3
+
+![](images/2138340e86ff73ed6c4633db684eb824cdcf8b0c1f5f5434c9e65b177116c2f6.jpg)
+
+$\triangleright$ Adding elements to a collection-like object yields similar representations.
+
+# D DATASET
+
+The collected dataset and its characteristics are listed in Table 4. The full dataset as a set of projects and its parsed JSON will become available online.
+
+Table 4: Projects in our dataset. Ordered alphabetically. kLOC measures the number of non-empty lines of C# code. Projects marked with Devwere used as a development set. Projects marked with †were in the test-only dataset. The rest of the projects were split into train-validation-test. The dataset contains in total about 2.9MLOC.   
+
+<table><tr><td>Name</td><td>Git SHA</td><td>kLOCs</td><td>Slots</td><td>Vars</td><td>Description</td></tr><tr><td>Akka.NET</td><td>719335a1</td><td>240</td><td>51.3k</td><td>51.2k</td><td>Actor-based Concurrent &amp;Distributed Framework</td></tr><tr><td>AutoMapper</td><td>2ca7c2b5</td><td>46</td><td>3.7k</td><td>10.7k</td><td>Object-to-Object Mapping Library</td></tr><tr><td>BenchmarkDotNet</td><td>1670ca34</td><td>28</td><td>5.1k</td><td>6.1k</td><td>Benchmarking Library</td></tr><tr><td>BotBuilder</td><td>190117c3</td><td>44</td><td>6.4k</td><td>8.7k</td><td>SDK for Building Bots</td></tr><tr><td>choco</td><td>93985688</td><td>36</td><td>3.8k</td><td>5.2k</td><td>Windows Package Manager</td></tr><tr><td>commandline†</td><td>09677b16</td><td>11</td><td>1.1k</td><td>2.3k</td><td>Command Line Parser</td></tr><tr><td>CommonMark.NETDev</td><td>f3d54530</td><td>14</td><td>2.6k</td><td>1.4k</td><td>Markdown Parser</td></tr><tr><td>Dapper</td><td>931c700d</td><td>18</td><td>3.3k</td><td>4.7k</td><td>Object Mapper Library</td></tr><tr><td>EntityFramework</td><td>fa0b7ec8</td><td>263</td><td>33.4k</td><td>39.3k</td><td>Object-Relational Mapper</td></tr><tr><td>Hangfire</td><td>ffc4912f</td><td>33</td><td>3.6k</td><td>6.1k</td><td>Background Job Processing Library</td></tr><tr><td>Humanizert</td><td>cclla77e</td><td>27</td><td>2.4k</td><td>4.4k</td><td>String Manipulation and Formatting</td></tr><tr><td>Lean†</td><td>f574bfd7</td><td>190</td><td>26.4k</td><td>28.3k</td><td>Algorithmic Trading Engine</td></tr><tr><td>Nancy</td><td>72elf614</td><td>70</td><td>7.5k</td><td>15.7</td><td>HTTP Service Framework</td></tr><tr><td>Newtonsoft.Json</td><td>6057d9b8</td><td>123</td><td>14.9k</td><td>16.1k</td><td> JSON Library</td></tr><tr><td>Ninject</td><td>7006297f</td><td>13</td><td>0.7k</td><td>2.1k</td><td>Code Injection Library</td></tr><tr><td>NLog</td><td>643e326a</td><td>75</td><td>8.3k</td><td>11.0k</td><td>Logging Library</td></tr><tr><td>Opserver</td><td>51b032e7</td><td>24</td><td>3.7k</td><td>4.5k</td><td>Monitoring System</td></tr><tr><td>OptiKey</td><td>7d35c718</td><td>34</td><td>6.1k</td><td>3.9k</td><td>Assistive On-Screen Keyboard</td></tr><tr><td>orleans Polly</td><td>e0d6a150 0afdbc32</td><td>300 32</td><td>30.7k 3.8k</td><td>35.6k 9.1k</td><td>Distributed Virtual Actor Model</td></tr><tr><td></td><td></td><td></td><td></td><td></td><td>Resilience &amp; Transient Fault Handling Library</td></tr><tr><td>quartznet</td><td>b33e6f86</td><td>49</td><td>9.6k</td><td>9.8k</td><td>Scheduler</td></tr><tr><td>ravendbDev</td><td>55230922</td><td>647</td><td>78.0k</td><td>82.7k</td><td>Document Database</td></tr><tr><td>RestSharp</td><td>70de357b</td><td>20</td><td>4.0k</td><td>4.5k</td><td>REST and HTTP API Client Library</td></tr><tr><td>Rx.NET</td><td>2d146fe5</td><td>180</td><td>14.0k</td><td>21.9k</td><td>Reactive Language Extensions</td></tr><tr><td>scriptcs</td><td>f3cc8bcb</td><td>18</td><td>2.7k</td><td>4.3k</td><td>C# Text Editor</td></tr><tr><td>ServiceStack</td><td>6d59da75</td><td>231</td><td>38.0k</td><td>46.2k</td><td>Web Framework</td></tr><tr><td>ShareX</td><td>718dd711</td><td>125</td><td>22.3k</td><td>18.1k</td><td>Sharing Application</td></tr><tr><td>SignalR</td><td>fa88089e</td><td>53</td><td>6.5k</td><td>10.5k</td><td>Push Notification Framework</td></tr><tr><td>Wox</td><td>cdaf6272</td><td>13</td><td>2.0k</td><td>2.1k</td><td>Application Launcher</td></tr></table>
+
+For this work, we released a large portion of the data, with the exception of projects with a GPL license. The data can be found at https://aka.ms/iclr18-prog-graphs-dataset. Since we are excluding some projects from the data, below we report the results, averaged over three runs, on the published dataset:   
+
+<table><tr><td></td><td>Accuracy (%)</td><td>PR AUC</td></tr><tr><td>SEENPROJTEST</td><td>84.0</td><td>0.976</td></tr><tr><td>UNSEENPROJTEST</td><td>74.1</td><td>0.934</td></tr></table>

parse/train/BJOFETxR-/BJOFETxR-_content_list.json

@@ -0,0 +1,1690 @@
+[
+    {
+        "type": "text",
+        "text": "LEARNING TO REPRESENT PROGRAMS WITH GRAPHS ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            98,
+            816,
+            121
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Miltiadis Allamanis   \nMicrosoft Research   \nCambridge, UK   \nmiallama@microsoft.com   \nMarc Brockschmidt   \nMicrosoft Research   \nCambridge, UK   \nmabrocks@microsoft.com ",
+        "bbox": [
+            183,
+            145,
+            401,
+            200
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            596,
+            145,
+            813,
+            200
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Mahmoud Khademi∗ Simon Fraser University Burnaby, BC, Canada mkhademi@sfu.ca ",
+        "bbox": [
+            183,
+            222,
+            344,
+            277
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "ABSTRACT ",
+        "text_level": 1,
+        "bbox": [
+            454,
+            314,
+            544,
+            329
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Learning tasks on source code (i.e., formal languages) have been considered recently, but most work has tried to transfer natural language methods and does not capitalize on the unique opportunities offered by code’s known sematics. For example, long-range dependencies induced by using the same variable or function in distant locations are often not considered. We propose to use graphs to represent both the syntactic and semantic structure of code and use graph-based deep learning methods to learn to reason over program structures. ",
+        "bbox": [
+            233,
+            347,
+            764,
+            443
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "In this work, we present how to construct graphs from source code and how to scale Gated Graph Neural Networks training to such large graphs. We evaluate our method on two tasks: VARNAMING, in which a network attempts to predict the name of a variable given its usage, and VARMISUSE, in which the network learns to reason about selecting the correct variable that should be used at a given program location. Our comparison to methods that use less structured program representations shows the advantages of modeling known structure, and suggests that our models learn to infer meaningful names and to solve the VARMISUSE task in many cases. Additionally, our testing showed that VARMISUSE identifies a number of bugs in mature open-source projects. ",
+        "bbox": [
+            233,
+            446,
+            764,
+            584
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 INTRODUCTION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            612,
+            334,
+            627
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "The advent of large repositories of source code as well as scalable machine learning methods naturally leads to the idea of “big code”, i.e., largely unsupervised methods that support software engineers by generalizing from existing source code (Allamanis et al., 2017). Currently, existing deep learning models of source code capture its shallow, textual structure, e.g. as a sequence of tokens (Hindle et al., 2012; Raychev et al., 2014; Allamanis et al., 2016), as parse trees (Maddison & Tarlow, 2014; Bielik et al., 2016), or as a flat dependency networks of variables (Raychev et al., 2015). Such models miss out on the opportunity to capitalize on the rich and well-defined semantics of source code. In this work, we take a step to alleviate this by including two additional signal sources in source code: data flow and type hierarchies. We do this by encoding programs as graphs, in which edges represent syntactic relationships (e.g. “token before/after”) as well as semantic relationships (“variable last used/written here”, “formal parameter for argument is called stream”, etc.). Our key insight is that exposing these semantics explicitly as structured input to a machine learning model lessens the requirements on amounts of training data, model capacity and training regime and allows us to solve tasks that are beyond the current state of the art. ",
+        "bbox": [
+            174,
+            643,
+            825,
+            838
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "We explore two tasks to illustrate the advantages of exposing more semantic structure of programs. First, we consider the VARNAMING task (Allamanis et al., 2014; Raychev et al., 2015), in which given some source code, the “correct” variable name is inferred as a sequence of subtokens. This requires some understanding of how a variable is used, i.e., requires reasoning about lines of code far apart in the source file. Secondly, we introduce the variable misuse prediction task (VARMISUSE), in which the network aims to infer which variable should be used in a program location. To illustrate the task, Figure 1 shows a slightly simplified snippet of a bug our model detected in a popular open-source project. Specifically, instead of the variable clazz, variable first should have been used in the yellow highlighted slot. Existing static analysis methods cannot detect such issues, even though a software engineer would easily identify this as an error from experience. ",
+        "bbox": [
+            174,
+            845,
+            825,
+            901
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "image",
+        "img_path": "images/1bc113e2a4c0fb9e0e51adeae6b01b6e7ddf6b162f6335e7e776d43b92e616d2.jpg",
+        "image_caption": [
+            "Figure 1: A snippet of a detected bug in RavenDB an open-source C# project. The code has been slightly simplified. Our model detects correctly that the variable used in the highlighted (yellow) slot is incorrect. Instead, first should have been placed at the slot. We reported this problem which was fixed in PR 4138. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            169,
+            102,
+            825,
+            214
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            304,
+            825,
+            388
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "To achieve high accuracy on these tasks, we need to learn representations of program semantics. For both tasks, we need to learn the semantic role of a variable (e.g., “is it a counter?”, “is it a filename?”). Additionally, for VARMISUSE, learning variable usage semantics (e.g., “a filename is needed here”) is required. This “fill the blank element” task is related to methods for learning distributed representations of natural language words, such as Word2Vec (Mikolov et al., 2013) and GLoVe (Pennington et al., 2014). However, we can learn from a much richer structure such as data flow information. This work is a step towards learning program representations, and we expect them to be valuable in a wide range of other tasks, such as code completion (“this is the variable you are looking for”) and more advanced bug finding (“you should lock before using this object”). ",
+        "bbox": [
+            174,
+            395,
+            825,
+            521
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "To summarize, our contributions are: (i) We define the VARMISUSE task as a challenge for machine learning modeling of source code, that requires to learn (some) semantics of programs (cf. section 3). (ii) We present deep learning models for solving the VARNAMING and VARMISUSE tasks by modeling the code’s graph structure and learning program representations over those graphs (cf. section 4). (iii) We evaluate our models on a large dataset of 2.9 million lines of real-world source code, showing that our best model achieves $3 2 . 9 \\%$ accuracy on the VARNAMING task and $8 5 . 5 \\%$ accuracy on the VARMISUSE task, beating simpler baselines (cf. section 5). (iv) We document practical relevance of VARMISUSE by summarizing some bugs that we found in mature open-source software projects $( c f .$ subsection 5.3). Our implementation of graph neural networks (on a simpler task) can be found at https://github.com/Microsoft/gated-graph-neural-network-samples and the dataset can be found at https://aka.ms/iclr18-prog-graphs-dataset. ",
+        "bbox": [
+            173,
+            526,
+            826,
+            680
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2 RELATED WORK ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            710,
+            344,
+            728
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Our work builds upon the recent field of using machine learning for source code artifacts (Allamanis et al., 2017). For example, Hindle et al. (2012); Bhoopchand et al. (2016) model the code as a sequence of tokens, while Maddison & Tarlow (2014); Raychev et al. (2016) model the syntax tree structure of code. All works on language models of code find that predicting variable and method identifiers is one of biggest challenges in the task. ",
+        "bbox": [
+            174,
+            750,
+            825,
+            819
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Closest to our work is the work of Allamanis et al. (2015) who learn distributed representations of variables using all their usages to predict their names. However, they do not use data flow information and we are not aware of any model that does so. Raychev et al. (2015) and Bichsel et al. (2016) use conditional random fields to model a variety of relationships between variables, AST elements and types to predict variable names and types (resp. to deobfuscate Android apps), but without considering the flow of data explicitly. In these works, all variable usages are deterministically known beforehand (as the code is complete and remains unmodified), as in Allamanis et al. (2014; 2015). ",
+        "bbox": [
+            174,
+            825,
+            825,
+            924
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Our work is remotely related to work on program synthesis using sketches (Solar-Lezama, 2008) and automated code transplantation (Barr et al., 2015). However, these approaches require a set of specifications (e.g. input-output examples, test suites) to complete the gaps, rather than statistics learned from big code. These approaches can be thought as complementary to ours, since we learn to statistically complete the gaps without any need for specifications, by learning common variable usage patterns from code. ",
+        "bbox": [
+            174,
+            103,
+            825,
+            186
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Neural networks on graphs (Gori et al., 2005; Li et al., 2015; Defferrard et al., 2016; Kipf & Welling, 2016; Gilmer et al., 2017) adapt a variety of deep learning methods to graph-structured input. They have been used in a series of applications, such as link prediction and classification (Grover & Leskovec, 2016) and semantic role labeling in NLP (Marcheggiani & Titov, 2017). Somewhat related to source code is the work of Wang et al. (2017) who learn graph-based representations of mathematical formulas for premise selection in theorem proving. ",
+        "bbox": [
+            174,
+            194,
+            825,
+            279
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3 THE VARMISUSE TASK ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            304,
+            400,
+            320
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Detecting variable misuses in code is a task that requires understanding and reasoning about program semantics. To successfully tackle the task one needs to infer the role and function of the program elements and understand how they relate. For example, given a program such as Fig. 1, the task is to automatically detect that the marked use of $\\mathtt { C 1 a z z }$ is a mistake and that first should be used instead. While this task resembles standard code completion, it differs significantly in its scope and purpose, by considering only variable identifiers and a mostly complete program. ",
+        "bbox": [
+            174,
+            339,
+            825,
+            422
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Task Description We view a source code file as a sequence of tokens $t _ { 0 } \\ldots t _ { N } = \\mathcal { T }$ , in which some tokens $t _ { \\lambda _ { 0 } } , t _ { \\lambda _ { 1 } } \\ldots$ are variables. Furthermore, let $\\mathbb { V } _ { t } \\subset \\mathbb { V }$ refer to the set of all type-correct variables in scope at the location of $t$ , i.e., those variables that can be used at $t$ without raising a compiler error. We call a token $t o k _ { \\lambda }$ where we want to predict the correct variable usage a slot. We define a separate task for each slot $t _ { \\lambda }$ : Given $t _ { 0 } \\ldots t _ { \\lambda - 1 }$ and $t _ { \\lambda + 1 } , \\dots , t _ { N }$ , correctly select $t _ { \\lambda }$ from $\\mathbb { V } _ { t _ { \\lambda } }$ . For training and evaluation purposes, a correct solution is one that simply matches the ground truth, but note that in practice, several possible assignments could be considered correct (i.e., when several variables refer to the same value in memory). ",
+        "bbox": [
+            174,
+            444,
+            825,
+            556
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "4 MODEL: PROGRAMS AS GRAPHS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            582,
+            478,
+            598
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "In this section, we discuss how to transform program source code into program graphs and learn representations over them. These program graphs not only encode the program text but also the semantic information that can be obtained using standard compiler tools. ",
+        "bbox": [
+            174,
+            617,
+            823,
+            659
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Gated Graph Neural Networks Our work builds on Gated Graph Neural Networks (Li et al., 2015) (GGNN) and we summarize them here. A graph $\\mathcal { G } = ( \\nu , \\pmb { \\varepsilon } , \\pmb { X } )$ is composed of a set of nodes $\\nu$ , node features $\\boldsymbol { X }$ , and a list of directed edge sets $\\pmb { \\mathcal { E } } = ( \\mathcal { E } _ { 1 } , \\ldots , \\mathcal { E } _ { K } )$ where $K$ is the number of edge types. We annotate each $v \\in \\mathcal V$ with a real-valued vector $\\pmb { x } ^ { ( v ) } \\in \\mathbb { R } ^ { D }$ representing the features of the node (e.g., the embedding of a string label of that node). ",
+        "bbox": [
+            174,
+            680,
+            825,
+            752
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "We associate every node $v$ with a state vector $\\mathbf { \\Omega } _ { h } ( v )$ , initialized from the node label $\\pmb { x } ^ { ( v ) }$ . The sizes of the state vector and feature vector are typically the same, but we can use larger state vectors through padding of node features. To propagate information throughout the graph, “messages” of type $k$ are sent from each $v$ to its neighbors, where each message is computed from its current state vector as m(vk $m _ { k } ^ { ( v ) } = f _ { k } ( { \\pmb h } ^ { ( v ) } )$ . Here, $f _ { k }$ can be an arbitrary function; we choose a linear layer in our case. By computing messages for all graph edges at the same time, all states can be updated at the same time. In particular, a new state for a node $v$ is computed by aggregating all incoming messages as $\\tilde { m } ^ { ( v ) } = g ( \\{ m _ { k } ^ { ( u ) } \\ |$ there is an edge of type $k$ from $u$ to $v \\}$ ). $g$ is an aggregation function, which we implement as elementwise summation. Given the aggregated message $\\tilde { m } ^ { ( v ) }$ and the current state vector $\\mathbf { \\Omega } _ { h } ( v )$ of node $v$ , the state of the next time step $\\boldsymbol { h ^ { \\prime } } ^ { ( v ) }$ is computed as $\\pmb { h } ^ { \\prime ( v ) } = \\mathbf { G } \\mathbf { R } \\mathbf { U } ( \\tilde { \\pmb { m } } ^ { ( v ) } , \\pmb { h } ^ { ( v ) } )$ , where GRU is the recurrent cell function of gated recurrent unit (GRU) (Cho et al., 2014). The ",
+        "bbox": [
+            174,
+            758,
+            825,
+            924
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "(a) Simplified syntax graph for line 2 of Fig. 1, where blue rounded boxes are syntax nodes, black rectangular boxes syntax tokens, blue edges Child edges and double black edges NextToken edges. ",
+        "bbox": [
+            173,
+            219,
+            482,
+            270
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "image",
+        "img_path": "images/f0957bde3bf55bfd9fc41e58429404103dadf9736f4a693bec1cc3c471bc40e7.jpg",
+        "image_caption": [
+            "Figure 2: Examples of graph edges used in program representation. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            196,
+            114,
+            459,
+            215
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "image",
+        "img_path": "images/83a96cffbd0f2a1c8368982c7c4bae4e01f2122dfee415273de350b2c11528e5.jpg",
+        "image_caption": [],
+        "image_footnote": [],
+        "bbox": [
+            522,
+            102,
+            771,
+            198
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "(b) Data flow edges for $\\begin{array} { r l r } { ( \\overline { { \\bf x } } ) ^ { 1 } , \\overline { { \\boldsymbol { \\mathbf { y } } } }  } & { { } = } &  { \\bf F o o ( \\begin{array} { l } { ) } \\ ; } \\end{array} \\end{array}$ while $\\left. \\overline { { \\mathbf { x } } } \\right. ^ { 3 } \\ > \\ \\mathsf { 0 } .$ ) $\\underline { { \\nabla } } \\mathbf { \\Sigma } ^ { 4 } \\mathbf { \\Sigma } = \\underline { { \\nabla } } \\mathbf { \\bar { x } } \\mathbf { \\Sigma } ^ { 5 } \\mathbf { \\Sigma } ^ { \\subset } \\mathbf { \\Sigma } \\boxed { \\nabla } \\mathbf { \\bar { y } } \\mathbf { \\Sigma } ^ { 6 }$ (indices added for clarity), with red dotted LastUse edges, green dashed LastWrite edges and dashdotted purple ComputedFrom edges. ",
+        "bbox": [
+            516,
+            205,
+            825,
+            270
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "dynamics defined by the above equations are repeated for a fixed number of time steps. Then, we use the state vectors from the last time step as the node representations.1 ",
+        "bbox": [
+            173,
+            314,
+            821,
+            342
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Program Graphs We represent program source code as graphs and use different edge types to model syntactic and semantic relationships between different tokens. The backbone of a program graph is the program’s abstract syntax tree (AST), consisting of syntax nodes (corresponding to nonterminals in the programming language’s grammar) and syntax tokens (corresponding to terminals). We label syntax nodes with the name of the nonterminal from the program’s grammar, whereas syntax tokens are labeled with the string that they represent. We use Child edges to connect nodes according to the AST. As this does not induce an order on children of a syntax node, we additionally add NextToken edges connecting each syntax token to its successor. An example of this is shown in Fig. 2a. ",
+        "bbox": [
+            173,
+            366,
+            825,
+            492
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "To capture the flow of control and data through a program, we add additional edges connecting different uses and updates of syntax tokens corresponding to variables. For such a token $v$ , let $\\mathcal { D } ^ { R } ( v )$ be the set of syntax tokens at which the variable could have been used last. This set may contain several nodes (for example, when using a variable after a conditional in which it was used in both branches), and even syntax tokens that follow in the program code (in the case of loops). Similarly, let $\\mathcal { D } ^ { W } ( v )$ be the set of syntax tokens at which the variable was last written to. Using these, we add LastRead (resp. LastWrite) edges connecting $v$ to all elements of $\\mathcal { D } ^ { R } ( v )$ (resp. $\\tilde { \\mathcal { D } } ^ { W } ( v ) )$ . Additionally, whenever we observe an assignment $v = e x p r$ , we connect $v$ to all variable tokens occurring in expr using ComputedFrom edges. An example of such semantic edges is shown in Fig. 2b. ",
+        "bbox": [
+            173,
+            498,
+            825,
+            637
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "We extend the graph to chain all uses of the same variable using LastLexicalUse edges (independent of data flow, i.e., in if (...) { ... v ...} else { ... v ...}, we link the two occurrences of $v$ ). We also connect return tokens to the method declaration using ReturnsTo edges (this creates a “shortcut” to its name and type). Inspired by Rice et al. (2017), we connect arguments in method calls to the formal parameters that they are matched to with FormalArgName edges, i.e., if we observe a call Foo(bar) and a method declaration Foo(InputStream stream), we connect the bar token to the stream token. Finally, we connect every token corresponding to a variable to enclosing guard expressions that use the variable with GuardedBy and GuardedByNegation edges. For example, in if ( $\\mathrm { ~ \\bf ~ \\cdot ~ x ~ } > \\mathrm { ~ \\bf ~ y ~ }$ ) { ... x ...} else $\\{ \\ \\begin{array} { r l } { \\mathrm { ~ \\texttt ~ { ~ . ~ . ~ } ~ } \\underline { { \\mathrm { ~ y ~ } } } \\mathrm { ~ . ~ . ~ . ~ } \\} } \\end{array}$ , we add a GuardedBy edge from $\\underline { { \\boldsymbol { \\mathrm { X } } } }$ (resp. a GuardedByNegation edge from y) to the AST node corresponding to $\\mathrm { ~  ~ { ~ x ~ } ~ } > \\mathrm { ~  ~ { ~ y ~ } ~ }$ . ",
+        "bbox": [
+            173,
+            643,
+            826,
+            797
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Finally, for all types of edges we introduce their respective backwards edges (transposing the adjacency matrix), doubling the number of edges and edge types. Backwards edges help with propagating information faster across the GGNN and make the model more expressive. ",
+        "bbox": [
+            176,
+            804,
+            823,
+            847
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Leveraging Variable Type Information We assume a statically typed language and that the source code can be compiled, and thus each variable has a (known) type $\\tau ( v )$ . To use it, we define a learnable embedding function $\\mathbf { r } ( \\tau )$ for known types and additionally define an “UNKTYPE” for all unknown/unrepresented types. We also leverage the rich type hierarchy that is available in many object-oriented languages. For this, we map a variable’s type $\\tau ( v )$ to the set of its supertypes, i.e. $\\tau ^ { * } \\bar { ( } v ) = \\{ \\tau : \\tau ( v ) \\quad$ implements type $\\tau \\} \\cup \\{ \\bar { \\tau } ( v ) \\}$ . We then compute the type representation $\\mathbf { r } ^ { * } ( v )$ of a variable $v$ as the element-wise maximum of $\\{ \\mathbf { r } ( \\tau ) : \\tau \\in \\tau ^ { * } ( v ) \\}$ . We chose the maximum here, as it is a natural pooling operation for representing partial ordering relations (such as type lattices). Using all types in $\\tau ^ { * } ( v )$ allows us to generalize to unseen types that implement common supertypes or interfaces. For example, List ${ \\tt < K > }$ has multiple concrete types (e.g. List<int>, List<string>). Nevertheless, these types implement a common interface (IList) and share common characteristics. During training, we randomly select a non-empty subset of $\\tau ^ { * } ( v )$ which ensures training of all known types in the lattice. This acts both like a dropout mechanism and allows us to learn a good representation for all types in the type lattice. ",
+        "bbox": [
+            174,
+            103,
+            825,
+            297
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Initial Node Representation To compute the initial node state, we combine information from the textual representation of the token and its type. Concretely, we split the name of a node representing a token into subtokens (e.g. classTypes will be split into two subtokens class and types) on camelCase and pascal_case. We then average the embeddings of all subtokens to retrieve an embedding for the node name. Finally, we concatenate the learned type representation $\\mathbf { r } ^ { * } ( v )$ , computed as discussed earlier, with the node name representation, and pass it through a linear layer to obtain the initial representations for each node in the graph. ",
+        "bbox": [
+            174,
+            314,
+            825,
+            411
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Programs Graphs for VARNAMING Given a program and an existing variable $v$ , we build a program graph as discussed above and then replace the variable name in all corresponding variable tokens by a special ${ < } S \\mathrm { L O T } >$ token. To predict a name, we use the initial node labels computed as the concatenation of learnable token embeddings and type embeddings as discussed above, run GGNN propagation for 8 time steps2 and then compute a variable usage representation by averaging the representations for all ${ < } S \\mathrm { L O T } >$ tokens. This representation is then used as the initial state of a one-layer GRU, which predicts the target name as a sequence of subtokens (e.g., the name inputStreamBuffer is treated as the sequence [input, stream, buffer]). We train this graph2seq architecture using a maximum likelihood objective. In section 5, we report the accuracy for predicting the exact name and the F1 score for predicting its subtokens. ",
+        "bbox": [
+            174,
+            426,
+            825,
+            565
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Program Graphs for VARMISUSE To model VARMISUSE with program graphs we need to modify the graph. First, to compute a context representation $\\mathbf { } c ( t )$ for a slot $t$ where we want to predict the used variable, we insert a new node $v _ { < S \\tt L O T > }$ at the position of $t$ , corresponding to a “hole” at this point, and connect it to the remaining graph using all applicable edges that do not depend on the chosen variable at the slot (i.e., everything but LastUse, LastWrite, LastLexicalUse, and GuardedBy edges). Then, to compute the usage representation $\\mathbf { u } ( t , v )$ of each candidate variable $v$ at the target slot, we insert a “candidate” node $v _ { t , v }$ for all $v$ in $\\mathbb { V } _ { t }$ , and connect it to the graph by inserting the LastUse, LastWrite and LastLexicalUse edges that would be used if the variable were to be used at this slot. Each of these candidate nodes represents the speculative placement of the variable within the scope. ",
+        "bbox": [
+            174,
+            582,
+            825,
+            720
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Using the initial node representations, concatenated with an extra bit that is set to one for the candidate nodes $v _ { t , v }$ , we run GGNN propagation for 8 time steps.2 The context and usage representation are then the final node states of the nodes, i.e., $\\pmb { c } ( t ) = \\pmb { h } ^ { ( v _ { < \\mathrm { S L O T } > } ) }$ and $\\mathbf { u } ( t , v ) = h ^ { ( v _ { t , v } ) }$ . Finally, the correct variable usage at the location is computed as arg $\\textstyle \\operatorname* { m a x } _ { v } W [ c ( t ) , \\mathbf { u } ( t , v ) ]$ where $W$ is a linear layer that uses the concatenation of $\\mathbf { } c ( t )$ and $\\mathbf { u } ( t , v )$ . We train using a max-margin objective. ",
+        "bbox": [
+            174,
+            728,
+            825,
+            800
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "4.1 IMPLEMENTATION ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            818,
+            341,
+            832
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Using GGNNs for sets of large, diverse graphs requires some engineering effort, as efficient batching is hard in the presence of diverse shapes. An important observation is that large graphs are normally very sparse, and thus a representation of edges as an adjacency list would usually be advantageous to reduce memory consumption. In our case, this can be easily implemented using a sparse tensor representation, allowing large batch sizes that exploit the parallelism of modern GPUs efficiently. A second key insight is to represent a batch of graphs as one large graph with many disconnected components. This just requires appropriate pre-processing to make node identities unique. As this makes batch construction somewhat CPU-intensive, we found it useful to prepare minibatches on a separate thread. Our TensorFlow (Abadi et al., 2016) implementation scales to 55 graphs per second during training and 219 graphs per second during test-time using a single NVidia GeForce GTX Titan X with graphs having on average 2,228 (median 936) nodes and 8,350 (median 3,274) edges and 8 GGNN unrolling iterations, all 20 edge types (forward and backward edges for 10 original edge types) and the size of the hidden layer set to 64. The number of types of edges in the GGNN contributes proportionally to the running time. For example, a GGNN run for our ablation study using only the two most common edge types (NextToken, Child) achieves 105 graphs/second during training and 419 graphs/second at test time with the same hyperparameters. Our (generic) implementation of GGNNs is available at https://github.com/Microsoft/ gated-graph-neural-network-samples, using a simpler demonstration task. ",
+        "bbox": [
+            176,
+            843,
+            825,
+            900
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            103,
+            825,
+            299
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "5 EVALUATION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            348,
+            313,
+            364
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Dataset We collected a dataset for the VARMISUSE task from open source $C ^ { \\# }$ projects on GitHub. To select projects, we picked the top-starred (non-fork) projects in GitHub. We then filtered out projects that we could not (easily) compile in full using Roslyn3, as we require a compilation to extract precise type information for the code (including those types present in external libraries). Our final dataset contains 29 projects from a diverse set of domains (compilers, databases, . . . ) with about 2.9 million non-empty lines of code. A full table is shown in Appendix D. ",
+        "bbox": [
+            174,
+            397,
+            825,
+            481
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "For the task of detecting variable misuses, we collect data from all projects by selecting all variable usage locations, filtering out variable declarations, where at least one other type-compatible replacement variable is in scope. The task is then to infer the correct variable that originally existed in that location. Thus, by construction there is at least one type-correct replacement variable, i.e. picking it would not raise an error during type checking. In our test datasets, at each slot there are on average 3.8 type-correct alternative variables (median 3, $\\sigma = 2 . 6$ ). ",
+        "bbox": [
+            174,
+            488,
+            825,
+            571
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "From our dataset, we selected two projects as our development set. From the rest of the projects, we selected three projects for UNSEENPROJTEST to allow testing on projects with completely unknown structure and types. We split the remaining 23 projects into train/validation/test sets in the proportion 60-10-30, splitting along files (i.e., all examples from one source file are in the same set). We call the test set obtained like this SEENPROJTEST. ",
+        "bbox": [
+            174,
+            579,
+            825,
+            648
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Baselines For VARMISUSE, we consider two bidirectional RNN-based baselines. The local model (LOC) is a simple two-layer bidirectional GRU run over the tokens before and after the target location. For this baseline, $\\mathbf { } c ( t )$ is set to the slot representation computed by the RNN, and the usage context of each variable $\\mathbf { u } ( t , v )$ is the embedding of the name and type of the variable, computed in the same way as the initial node labels in the GGNN. This baseline allows us to evaluate how important the usage context information is for this task. The flat dataflow model (AVGBIRNN) is an extension to LOC, where the usage representation $\\mathbf { u } ( t , v )$ is computed using another two-layer bidirectional RNN run over the tokens before/after each usage, and then averaging over the computed representations at the variable token $v$ . The local context, $\\mathbf { } c ( t )$ , is identical to LOC. AVGBIRNN is a significantly stronger baseline that already takes some structural information into account, as the averaging over all variables usages helps with long-range dependencies. Both models pick the variable that maximizes $\\boldsymbol { c } ( t ) ^ { T } \\mathbf { u } ( t , v )$ . ",
+        "bbox": [
+            173,
+            694,
+            825,
+            861
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "For VARNAMING, we replace LOC by AVGLBL, which uses a log-bilinear model for 4 left and 4 right context tokens of each variable usage, and then averages over these context representations (this corresponds to the model in Allamanis et al. (2015)). We also test AVGBIRNN on VARNAMING, which essentially replaces the log-bilinear context model by a bidirectional RNN. ",
+        "bbox": [
+            174,
+            867,
+            825,
+            924
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "table",
+        "img_path": "images/b50ee87c697642af7c15b71b6fc64db9212a957b4661dfb2395c47f5be19c8b6.jpg",
+        "table_caption": [
+            "Table 1: Evaluation of models. SEENPROJTEST refers to the test set containing projects that have files in the training set, UNSEENPROJTEST refers to projects that have no files in the training data. Results averaged over two runs. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td></td><td colspan=\"4\">SEENPROJTEST</td><td colspan=\"4\">UNSEENPROJTEST</td></tr><tr><td></td><td>Loc</td><td>AVGLBL</td><td>AVGBIRNN</td><td>GGNN</td><td>Loc</td><td>AVGLBL</td><td>AVGBIRNN</td><td>GGNN</td></tr><tr><td>VARMISUSE</td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td></tr><tr><td>Accuracy (%)</td><td>50.0</td><td>二</td><td>73.7</td><td>85.5</td><td>28.9</td><td></td><td>60.2</td><td>78.2</td></tr><tr><td>PR AUC</td><td>0.788</td><td></td><td>0.941</td><td>0.980</td><td>0.611</td><td></td><td>0.895</td><td>0.958</td></tr><tr><td>VARNAMING Accuracy (%)</td><td></td><td>36.1</td><td>42.9</td><td></td><td></td><td></td><td></td><td></td></tr><tr><td></td><td></td><td></td><td></td><td>53.6</td><td></td><td>22.7</td><td>23.4</td><td>44.0</td></tr><tr><td>F1 (%)</td><td></td><td>44.0</td><td>50.1</td><td>65.8</td><td></td><td>30.6</td><td>32.0</td><td>62.0</td></tr></table>",
+        "bbox": [
+            173,
+            143,
+            823,
+            252
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "table",
+        "img_path": "images/0af154e3d64763ffe10fe3cdcde26c9644db9e9a108844942ce96db280c1e44b.jpg",
+        "table_caption": [
+            "Table 2: Ablation study for the GGNN model on SEENPROJTEST for the two tasks. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Ablation Description</td><td colspan=\"2\">Accuracy (%) VARMISUSE</td></tr><tr><td></td><td></td><td>VARNAMING</td></tr><tr><td>Standard Model (reported in Table 1)</td><td>85.5</td><td>53.6</td></tr><tr><td>Only NextToken, Child, LastUse_LastWrite edges</td><td>80.6</td><td>31.2</td></tr><tr><td>Only semantic edges (all but NextToken, Child) Only syntax edges (NextToken, Child)</td><td>78.4 55.3</td><td>52.9 34.3</td></tr><tr><td>Node Labels: Tokens instead of subtokens</td><td></td><td></td></tr><tr><td>Node Labels:Disabled</td><td>85.6 84.3</td><td>34.5</td></tr><tr><td></td><td></td><td>31.8</td></tr></table>",
+        "bbox": [
+            241,
+            282,
+            756,
+            412
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "5.1 QUANTITATIVE EVALUATION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            438,
+            416,
+            453
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Table 1 shows the evaluation results of the models for both tasks.4 As LOC captures very little information, it performs relatively badly. AVGLBL and AVGBIRNN, which capture information from many variable usage sites, but do not explicitly encode the rich structure of the problem, still lag behind the GGNN by a wide margin. The performance difference is larger for VARMISUSE, since the structure and the semantics of code are far more important within this setting. ",
+        "bbox": [
+            174,
+            464,
+            825,
+            535
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Generalization to new projects Generalizing across a diverse set of source code projects with different domains is an important challenge in machine learning. We repeat the evaluation using the UNSEENPROJTEST set stemming from projects that have no files in the training set. The right side of Table 1 shows that our models still achieve good performance, although it is slightly lower compared to SEENPROJTEST. This is expected since the type lattice is mostly unknown in UNSEENPROJTEST. ",
+        "bbox": [
+            174,
+            551,
+            825,
+            621
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "We believe that the dominant problem in applying a trained model to an unknown project (i.e., domain) is the fact that its type hierarchy is unknown and the used vocabulary (e.g. in variables, method and class names, etc.) can differ substantially. ",
+        "bbox": [
+            176,
+            627,
+            823,
+            670
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Ablation Study To study the effect of some of the design choices for our models, we have run some additional experiments and show their results in Table 2. First, we varied the edges used in the program graph. We find that restricting the model to syntactic information has a large impact on performance on both tasks, whereas restricting it to semantic edges seems to mostly impact performance on VARMISUSE. Similarly, the ComputedFrom, FormalArgName and ReturnsTo edges give a small boost on VARMISUSE, but greatly improve performance on VARNAMING. As evidenced by the experiments with the node label representation, syntax node and token names seem to matter little for VARMISUSE, but naturally have a great impact on VARNAMING. ",
+        "bbox": [
+            174,
+            685,
+            825,
+            797
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "5.2 QUALITATIVE EVALUATION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            815,
+            405,
+            830
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Figure 3 illustrates the predictions that GGNN makes on a sample test snippet. The snippet recursively searches for the global directives file by gradually descending into the root folder. Reasoning about the correct variable usages is hard, even for humans, but the GGNN correctly predicts the variable usages at all locations except two (slot 1 and 8). As a software engineer is writing the code, it is imaginable that she may make a mistake misusing one variable in the place of another. Since all variables are string variables, no type errors will be raised. As the probabilities in Fig. 3 suggest most potential variable misuses can be flagged by the model yielding valuable warnings to software engineers. Additional samples with comments can be found in Appendix B. ",
+        "bbox": [
+            176,
+            842,
+            823,
+            885
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/cd8c9c73a863608276a7923a4347ae44724d33325aed2f76dd26669048968bd2.jpg",
+        "image_caption": [
+            "Figure 3: VARMISUSE predictions on slots within a snippet of the SEENPROJTEST set for the ServiceStack project. Additional visualizations are available in Appendix B. The underlined tokens are the correct tokens. The model has to select among a number of string variables at each slot, where all of them represent some kind of path. The GGNN accurately predicts the correct variable usage in 11 out of the 13 slots reasoning about the complex ways the variables interact among them. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            169,
+            106,
+            828,
+            392
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "image",
+        "img_path": "images/1a46d813f5e2a8d4ca1585320818302c03d99347f9237a6ad178e6da4a0a1573.jpg",
+        "image_caption": [
+            "Figure 4: A bug found (yellow) in RavenDB open-source project. The code unnecessarily ensures that the buffer is of size length rather than size (which our model predicts as the correct variable here). "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            169,
+            497,
+            818,
+            560
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            637,
+            825,
+            708
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Furthermore, Appendix C shows samples of pairs of code snippets that share similar representations as computed by the cosine similarity of the usage representation $\\mathbf { u } ( t , v )$ of GGNN. The reader can notice that the network learns to group variable usages that share semantic similarities together. For example, checking for null before the use of a variable yields similar distributed representations across code segments (Sample 1 in Appendix C). ",
+        "bbox": [
+            174,
+            715,
+            825,
+            785
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "5.3 DISCOVERED VARIABLE MISUSE BUGS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            804,
+            486,
+            819
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "We have used our VARMISUSE model to identify likely locations of bugs in RavenDB (a document database) and Roslyn (Microsoft’s $C ^ { \\# }$ compiler framework). For this, we manually reviewed a sample of the top 500 locations in both projects where our model was most confident about a choosing a variable differing from the ground truth, and found three bugs in each of the projects. ",
+        "bbox": [
+            174,
+            830,
+            825,
+            888
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Figs. 1,4,5 show the issues discovered in RavenDB. The bug in Fig. 1 was possibly caused by copy-pasting, and cannot be easily caught by traditional methods. A compiler will not warn about unused variables (since first is used) and virtually nobody would write a test testing another test. Fig. 4 shows an issue that, although not critical, can lead to increased memory consumption. Fig. 5 shows another issue arising from a non-informative error message. We privately reported three additional bugs to the Roslyn developers, who have fixed the issues in the meantime (cf. https://github.com/dotnet/roslyn/pull/23437). One of the reported bugs could cause a crash in Visual Studio when using certain Roslyn features. ",
+        "bbox": [
+            174,
+            895,
+            823,
+            924
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "image",
+        "img_path": "images/336e106c897c8cfa8eb64fc3ca64fbd06fdd03a060af8c210b6cbadf7e1fcc42.jpg",
+        "image_caption": [
+            "Figure 5: A bug found (yellow) in the RavenDB open-source project. Although backupFilename is found to be invalid by IsValidBackup, the user is notified that backupLocation is invalid instead. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            171,
+            102,
+            826,
+            170
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            242,
+            826,
+            327
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Finding these issues in widely released and tested code suggests that our model can be useful during the software development process, complementing classic program analysis tools. For example, one usage scenario would be to guide the code reviewing process to locations a VARMISUSE model has identified as unusual, or use it as a prior to focus testing or expensive code analysis efforts. ",
+        "bbox": [
+            174,
+            334,
+            825,
+            390
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "6 DISCUSSION & CONCLUSIONS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            409,
+            459,
+            425
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Although source code is well understood and studied within other disciplines such as programming language research, it is a relatively new domain for deep learning. It presents novel opportunities compared to textual or perceptual data, as its (local) semantics are well-defined and rich additional information can be extracted using well-known, efficient program analyses. On the other hand, integrating this wealth of structured information poses an interesting challenge. Our VARMISUSE task exposes these opportunities, going beyond simpler tasks such as code completion. We consider it as a first proxy for the core challenge of learning the meaning of source code, as it requires to probabilistically refine standard information included in type systems. ",
+        "bbox": [
+            174,
+            440,
+            825,
+            553
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "REFERENCES ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            574,
+            285,
+            588
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Martín Abadi, Ashish Agarwal, Paul Barham, Eugene Brevdo, Zhifeng Chen, Craig Citro, Greg S Corrado, Andy Davis, Jeffrey Dean, Matthieu Devin, et al. Tensorflow: Large-scale machine learning on heterogeneous distributed systems. arXiv preprint arXiv:1603.04467, 2016.   \nMiltiadis Allamanis, Earl T Barr, Christian Bird, and Charles Sutton. Learning natural coding conventions. In Foundations of Software Engineering (FSE), 2014.   \nMiltiadis Allamanis, Earl T Barr, Christian Bird, and Charles Sutton. Suggesting accurate method and class names. In Foundations of Software Engineering (FSE), 2015.   \nMiltiadis Allamanis, Hao Peng, and Charles Sutton. A convolutional attention network for extreme summarization of source code. In International Conference on Machine Learning (ICML), pp. 2091–2100, 2016.   \nMiltiadis Allamanis, Earl T Barr, Premkumar Devanbu, and Charles Sutton. A survey of machine learning for big code and naturalness. arXiv preprint arXiv:1709.06182, 2017.   \nEarl T Barr, Mark Harman, Yue Jia, Alexandru Marginean, and Justyna Petke. Automated software transplantation. In International Symposium on Software Testing and Analysis (ISSTA), 2015.   \nAl Bessey, Ken Block, Ben Chelf, Andy Chou, Bryan Fulton, Seth Hallem, Charles Henri-Gros, Asya Kamsky, Scott McPeak, and Dawson Engler. A few billion lines of code later: using static analysis to find bugs in the real world. Communications of the ACM, 53(2):66–75, 2010.   \nAvishkar Bhoopchand, Tim Rocktäschel, Earl Barr, and Sebastian Riedel. Learning Python code suggestion with a sparse pointer network. arXiv preprint arXiv:1611.08307, 2016. ",
+        "bbox": [
+            171,
+            594,
+            826,
+            926
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Benjamin Bichsel, Veselin Raychev, Petar Tsankov, and Martin Vechev. Statistical deobfuscation of android applications. In Conference on Computer and Communications Security (CCS), 2016. ",
+        "bbox": [
+            171,
+            103,
+            825,
+            132
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Pavol Bielik, Veselin Raychev, and Martin Vechev. PHOG: probabilistic model for code. In International Conference on Machine Learning (ICML), 2016. ",
+        "bbox": [
+            173,
+            140,
+            823,
+            170
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Kyunghyun Cho, Bart van Merriënboer, Dzmitry Bahdanau, and Yoshua Bengio. On the properties of neural machine translation: Encoder–decoder approaches. Syntax, Semantics and Structure in Statistical Translation, 2014. ",
+        "bbox": [
+            174,
+            176,
+            823,
+            219
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Michaël Defferrard, Xavier Bresson, and Pierre Vandergheynst. Convolutional neural networks on graphs with fast localized spectral filtering. In Neural Information Processing Systems (NIPS), pp. 3844–3852, 2016. ",
+        "bbox": [
+            174,
+            227,
+            823,
+            270
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Justin Gilmer, Samuel S. Schoenholz, Patrick F. Riley, Oriol Vinyals, and George E. Dahl. Neural message passing for quantum chemistry. arXiv preprint arXiv:1704.01212, 2017. ",
+        "bbox": [
+            171,
+            276,
+            823,
+            308
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Marco Gori, Gabriele Monfardini, and Franco Scarselli. A new model for learning in graph domains. In IEEE International Joint Conference Neural Networks (IJCNN). IEEE, 2005. ",
+        "bbox": [
+            171,
+            314,
+            823,
+            344
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Aditya Grover and Jure Leskovec. node2vec: Scalable feature learning for networks. In International Conference on Knowledge Discovery and Data Mining (SIGKDD), pp. 855–864. ACM, 2016. ",
+        "bbox": [
+            174,
+            351,
+            825,
+            381
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Abram Hindle, Earl T Barr, Zhendong Su, Mark Gabel, and Premkumar Devanbu. On the naturalness of software. In International Conference on Software Engineering (ICSE), 2012. ",
+        "bbox": [
+            174,
+            387,
+            823,
+            417
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Thomas N Kipf and Max Welling. Semi-supervised classification with graph convolutional networks. arXiv preprint arXiv:1609.02907, 2016. ",
+        "bbox": [
+            174,
+            424,
+            825,
+            454
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Yujia Li, Daniel Tarlow, Marc Brockschmidt, and Richard Zemel. Gated graph sequence neural networks. In International Conference on Learning Representations (ICLR), 2015. ",
+        "bbox": [
+            174,
+            460,
+            823,
+            491
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Chris J Maddison and Daniel Tarlow. Structured generative models of natural source code. In International Conference on Machine Learning (ICML), 2014. ",
+        "bbox": [
+            176,
+            497,
+            823,
+            526
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Diego Marcheggiani and Ivan Titov. Encoding sentences with graph convolutional networks for semantic role labeling. In ACL, 2017. ",
+        "bbox": [
+            174,
+            534,
+            823,
+            564
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Tomas Mikolov, Ilya Sutskever, Kai Chen, Greg S Corrado, and Jeff Dean. Distributed representations of words and phrases and their compositionality. In Neural Information Processing Systems (NIPS), 2013. ",
+        "bbox": [
+            173,
+            570,
+            823,
+            613
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Jeffrey Pennington, Richard Socher, and Christopher D Manning. GloVe: Global vectors for word representation. In EMNLP, 2014. ",
+        "bbox": [
+            173,
+            621,
+            823,
+            651
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Veselin Raychev, Martin Vechev, and Eran Yahav. Code completion with statistical language models. In Programming Languages Design and Implementation (PLDI), pp. 419–428, 2014. ",
+        "bbox": [
+            173,
+            657,
+            825,
+            688
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Veselin Raychev, Martin Vechev, and Andreas Krause. Predicting program properties from Big Code. In Principles of Programming Languages (POPL), 2015. ",
+        "bbox": [
+            173,
+            694,
+            823,
+            724
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Veselin Raychev, Pavol Bielik, and Martin Vechev. Probabilistic model for code with decision trees. In Object-Oriented Programming, Systems, Languages, and Applications (OOPSLA), 2016. ",
+        "bbox": [
+            173,
+            731,
+            823,
+            761
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Andrew Rice, Edward Aftandilian, Ciera Jaspan, Emily Johnston, Michael Pradel, and Yulissa Arroyo-Paredes. Detecting argument selection defects. Proceedings of the ACM on Programming Languages, 1(OOPSLA):104, 2017. ",
+        "bbox": [
+            174,
+            767,
+            823,
+            811
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Michael Schlichtkrull, Thomas N. Kipf, Peter Bloem, Rianne van den Berg, Ivan Titov, and Max Welling. Modeling relational data with graph convolutional network. arXiv preprint arXiv:1703.06103, 2017. ",
+        "bbox": [
+            173,
+            819,
+            821,
+            862
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Armando Solar-Lezama. Program synthesis by sketching. University of California, Berkeley, 2008. ",
+        "bbox": [
+            171,
+            869,
+            823,
+            886
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Mingzhe Wang, Yihe Tang, Jian Wang, and Jia Deng. Premise selection for theorem proving by deep graph embedding. In Advances in Neural Information Processing Systems, pp. 2783–2793, 2017. ",
+        "bbox": [
+            171,
+            892,
+            823,
+            921
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "image",
+        "img_path": "images/8d4734049cdf665102b0203edbfe7d102c214d1ca0e59c1e940ccf68db6434c3.jpg",
+        "image_caption": [
+            "Figure 6: Precision-Recall and ROC curves for the GGNN model on VARMISUSE. Note that the $y$ axis starts from $50 \\%$ . "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            171,
+            99,
+            823,
+            270
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "table",
+        "img_path": "images/dd6c7d57e2baa84336760f0c78a1b6a4a7c222370ffeb1c9b7940bd6dc5e4789.jpg",
+        "table_caption": [
+            "Table 3: Performance of GGNN model on VARMISUSE per number of type-correct, in-scope candidate variables. Here we compute the performance of the full GGNN model that uses subtokens. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td># of candidates</td><td>2</td><td>3</td><td>4</td><td></td><td>6or7</td><td>8+</td></tr><tr><td>Accuracy On SEENPROJTEST (%)</td><td>91.6</td><td>84.5</td><td>81.8</td><td>78.6</td><td>75.1</td><td>77.5</td></tr><tr><td>Accuracy On UNSEENPROJTEST (%)</td><td>85.7</td><td>77.1</td><td>75.7</td><td>69.0</td><td>71.5</td><td>62.4</td></tr></table>",
+        "bbox": [
+            218,
+            366,
+            779,
+            425
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "A PERFORMANCE CURVES ",
+        "text_level": 1,
+        "bbox": [
+            178,
+            450,
+            413,
+            467
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Figure 6 shows the ROC and precision-recall curves for the GGNN model. As the reader may observe, setting a false positive rate to $10 \\%$ we get a true positive rate5 of $73 \\%$ for the SEENPROJTEST and $69 \\%$ for the unseen test. This suggests that this model can be practically used at a high precision setting with acceptable performance. ",
+        "bbox": [
+            173,
+            483,
+            826,
+            540
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "B VARMISUSE PREDICTION SAMPLES",
+        "text_level": 1,
+        "bbox": [
+            174,
+            563,
+            506,
+            579
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Below we list a set of samples from our SEENPROJTEST projects with comments about the model performance. Code comments and formatting may have been altered for typesetting reasons. The ground truth choice is underlined. ",
+        "bbox": [
+            173,
+            595,
+            826,
+            638
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Sample 1 ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            643,
+            240,
+            659
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "image",
+        "img_path": "images/abfe6409dabc3b628a3cb9baa2fdc14d3f39bb8b79f6efc499c55f175cb161d8.jpg",
+        "image_caption": [],
+        "image_footnote": [],
+        "bbox": [
+            171,
+            664,
+            831,
+            858
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": ". The model correctly predicts all variables in the loop. ",
+        "bbox": [
+            173,
+            868,
+            537,
+            883
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Sample 2 ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            99,
+            241,
+            114
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "image",
+        "img_path": "images/67d1357095f3d80bff9433916647f24a7195c8a63c4dcc5ead0f08be17f5bdaf.jpg",
+        "image_caption": [],
+        "image_footnote": [],
+        "bbox": [
+            171,
+            121,
+            830,
+            174
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "#1 name: $86 \\%$ , DIR_PATH: $14 \\%$ #2 path: $90 \\%$ , name: $8 \\%$ , DIR_PATH: $2 \\%$ #3 path: $76 \\%$ , name: $16 \\%$ , DIR_PATH: $8 \\%$ ",
+        "bbox": [
+            174,
+            183,
+            513,
+            234
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "$\\triangleright$ String variables are not confused their semantic role is inferred correctly. ",
+        "bbox": [
+            173,
+            246,
+            663,
+            261
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Sample 3 ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            266,
+            240,
+            280
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "[global::System.Diagnostics.DebuggerNonUserCodeAttribute]   \npublic void MergeFrom(pb::CodedInputStream input) { uint tag; while ((tag $=$ input.ReadTag()) $\\ ! = ~ 0$ ) { switch(tag) { default: input.SkipLastField(); break; case 10: { #1 .AddEntriesFrom(input, _repeated_payload_codec); break; } }   \n} ",
+        "bbox": [
+            171,
+            289,
+            707,
+            484
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "#1 Payload: $66 \\%$ , payload_: $44 \\%$ ",
+        "bbox": [
+            186,
+            493,
+            464,
+            511
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "$\\triangleright$ The model is commonly confused by aliases, i.e. variables that point to the same location in memory.   \nIn this sample, either choice would have yielded identical behavior. ",
+        "bbox": [
+            173,
+            522,
+            825,
+            551
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Sample 4 ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            556,
+            241,
+            571
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "image",
+        "img_path": "images/a45880cd7de37c697125e92c3c541033a38ec7e20081fe1d6ce9b55998761b1c.jpg",
+        "image_caption": [],
+        "image_footnote": [],
+        "bbox": [
+            169,
+            578,
+            828,
+            715
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "#1 gate: $9 9 \\%$ , _observers: $1 \\%$ #2 _isDisposed: $90 \\%$ , _isStopped: $8 \\%$ , HasObservers: $2 \\%$ ",
+        "bbox": [
+            173,
+            726,
+            671,
+            758
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": ". The ReturnsTo edge can help predict variables that otherwise would have been impossible. ",
+        "bbox": [
+            166,
+            770,
+            785,
+            786
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Sample 5 ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            99,
+            240,
+            114
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "image",
+        "img_path": "images/382d0a5b3bd9d9fd228858bebcaa0e6dfce97d4d8f24faa63d9010e590be558b.jpg",
+        "image_caption": [],
+        "image_footnote": [],
+        "bbox": [
+            166,
+            121,
+            828,
+            534
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "#1 error: $93 \\%$ , _exception: $7 \\%$   \n#2 error: $98 \\%$ , _exception: $2 \\%$   \n#3 _gate: $100 \\%$ , _observers: $0 \\%$   \n#4 isStopped: $86 \\%$ , _isDisposed: $13 \\%$ , HasObservers: $1 \\%$   \n#5 isStopped: $91 \\%$ , _isDisposed: $9 \\%$ , HasObservers: $0 \\%$   \n#6 _exception: $100 \\%$ , error: $0 \\%$   \n#7 error: $98 \\%$ , _exception: $2 \\%$   \n#8 _exception: $9 9 \\%$ , error: $1 \\%$ ",
+        "bbox": [
+            174,
+            545,
+            679,
+            684
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "$\\triangleright$ The model predicts the correct variables from all slots apart from the last. Reasoning about the last one, requires interprocedural understanding of the code across the class file. ",
+        "bbox": [
+            171,
+            695,
+            825,
+            724
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Sample 6 ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            99,
+            241,
+            114
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "private bool BecomingCommand(object message) if (ReceiveCommand #1 return true; if #2 .ToString() $= =$ #3 #4 .Tell #5 else return false; return true;   \n} ",
+        "bbox": [
+            169,
+            122,
+            633,
+            219
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "#1 message: $100 \\%$ , Response: $0 \\%$ , Message: $0 \\%$ #2 message: $100 \\%$ , Response: $0 \\%$ , Message: $0 \\%$ #3 Response: $91 \\%$ , Message: $9 \\%$ #4 Probe: $98 \\%$ , AskedForDelete: $2 \\%$ #5 Response: $98 \\%$ , Message: $2 \\%$ ",
+        "bbox": [
+            174,
+            229,
+            571,
+            318
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": ". The model predicts correctly all usages except from the one in slot #3. Reasoning about this snippet requires additional semantic information about the intent of the code. ",
+        "bbox": [
+            168,
+            329,
+            825,
+            357
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "Sample 7 ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            362,
+            240,
+            377
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "var response $=$ ResultsFilter(typeof(TResponse), #1 #2 , request); ",
+        "bbox": [
+            166,
+            385,
+            815,
+            404
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "#1 httpMethod: $9 9 \\%$ , absoluteUrl: $1 \\%$ , UserName: $0 \\%$ , UserAgent: $0 \\%$ #2 absoluteUrl: $9 9 \\%$ , httpMethod: $1 \\%$ , UserName: $0 \\%$ , UserAgent: $0 \\%$ ",
+        "bbox": [
+            194,
+            415,
+            758,
+            449
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "$\\triangleright$ The model knows about selecting the correct string parameters because it matches them to the formal parameter names. ",
+        "bbox": [
+            173,
+            460,
+            825,
+            489
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "Sample 8 ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            496,
+            241,
+            510
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "if #1 $> =$ #2 ) throw new InvalidOperationException(Strings_Core.FAILED_CLOCK_MONITORING) ",
+        "bbox": [
+            187,
+            517,
+            843,
+            547
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "#1 n: $100 \\%$ , MAXERROR: $0 \\%$ , SYNC_MAXRETRIES: $0 \\%$ #2 MAXERROR: $62 \\%$ , SYNC_MAXRETRIES: $22 \\%$ , n: $16 \\%$ ",
+        "bbox": [
+            174,
+            559,
+            596,
+            593
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "$\\triangleright$ It is hard for the model to reason about conditionals, especially with rare constants as in slot #2. ",
+        "bbox": [
+            163,
+            604,
+            812,
+            621
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "C NEAREST NEIGHBOR OF GGNN USAGE REPRESENTATIONS ",
+        "text_level": 1,
+        "bbox": [
+            171,
+            101,
+            705,
+            118
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "Here we show pairs of nearest neighbors based on the cosine similarity of the learned representations $\\mathbf { u } ( t , v )$ . Each slot $t$ is marked in dark blue and all usages of $v$ are marked in yellow (i.e. variableName ). This is a set of hand-picked examples showing good and bad examples. A brief description follows after each pair. ",
+        "bbox": [
+            173,
+            217,
+            828,
+            276
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "Sample 1 ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            281,
+            240,
+            296
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "image",
+        "img_path": "images/3af9a60fadeb14347e4f874e0c1dc803122c0a76e9fdc856fd08d2c98658db62.jpg",
+        "image_caption": [],
+        "image_footnote": [],
+        "bbox": [
+            165,
+            299,
+            831,
+            590
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "$\\triangleright$ Slots that are checked for null-ness have similar representations. ",
+        "bbox": [
+            171,
+            595,
+            606,
+            611
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "Sample 2 ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            616,
+            240,
+            631
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "image",
+        "img_path": "images/d1ada4fdbb0e1a6e130ce0b48d0b02926d9a7f74e9bd9bde7dc55ae52c59ef8f.jpg",
+        "image_caption": [],
+        "image_footnote": [],
+        "bbox": [
+            166,
+            635,
+            833,
+            895
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "$\\triangleright$ Slots that follow similar API protocols have similar representations. Note that the function HasAddress is a local function, seen only in the testset. ",
+        "bbox": [
+            171,
+            898,
+            826,
+            928
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "Sample 3 ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            99,
+            240,
+            114
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "image",
+        "img_path": "images/2138340e86ff73ed6c4633db684eb824cdcf8b0c1f5f5434c9e65b177116c2f6.jpg",
+        "image_caption": [],
+        "image_footnote": [],
+        "bbox": [
+            169,
+            117,
+            831,
+            296
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "text",
+        "text": "$\\triangleright$ Adding elements to a collection-like object yields similar representations. ",
+        "bbox": [
+            173,
+            301,
+            668,
+            316
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "text",
+        "text": "D DATASET ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            351,
+            287,
+            367
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "text",
+        "text": "The collected dataset and its characteristics are listed in Table 4. The full dataset as a set of projects and its parsed JSON will become available online. ",
+        "bbox": [
+            173,
+            388,
+            825,
+            417
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "table",
+        "img_path": "images/cbc14fa71ce2f75da12cf724042a0e7a75e4183c82fc6295ea8172f5e72f36df.jpg",
+        "table_caption": [
+            "Table 4: Projects in our dataset. Ordered alphabetically. kLOC measures the number of non-empty lines of C# code. Projects marked with Devwere used as a development set. Projects marked with †were in the test-only dataset. The rest of the projects were split into train-validation-test. The dataset contains in total about 2.9MLOC. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Name</td><td>Git SHA</td><td>kLOCs</td><td>Slots</td><td>Vars</td><td>Description</td></tr><tr><td>Akka.NET</td><td>719335a1</td><td>240</td><td>51.3k</td><td>51.2k</td><td>Actor-based Concurrent &amp;Distributed Framework</td></tr><tr><td>AutoMapper</td><td>2ca7c2b5</td><td>46</td><td>3.7k</td><td>10.7k</td><td>Object-to-Object Mapping Library</td></tr><tr><td>BenchmarkDotNet</td><td>1670ca34</td><td>28</td><td>5.1k</td><td>6.1k</td><td>Benchmarking Library</td></tr><tr><td>BotBuilder</td><td>190117c3</td><td>44</td><td>6.4k</td><td>8.7k</td><td>SDK for Building Bots</td></tr><tr><td>choco</td><td>93985688</td><td>36</td><td>3.8k</td><td>5.2k</td><td>Windows Package Manager</td></tr><tr><td>commandline†</td><td>09677b16</td><td>11</td><td>1.1k</td><td>2.3k</td><td>Command Line Parser</td></tr><tr><td>CommonMark.NETDev</td><td>f3d54530</td><td>14</td><td>2.6k</td><td>1.4k</td><td>Markdown Parser</td></tr><tr><td>Dapper</td><td>931c700d</td><td>18</td><td>3.3k</td><td>4.7k</td><td>Object Mapper Library</td></tr><tr><td>EntityFramework</td><td>fa0b7ec8</td><td>263</td><td>33.4k</td><td>39.3k</td><td>Object-Relational Mapper</td></tr><tr><td>Hangfire</td><td>ffc4912f</td><td>33</td><td>3.6k</td><td>6.1k</td><td>Background Job Processing Library</td></tr><tr><td>Humanizert</td><td>cclla77e</td><td>27</td><td>2.4k</td><td>4.4k</td><td>String Manipulation and Formatting</td></tr><tr><td>Lean†</td><td>f574bfd7</td><td>190</td><td>26.4k</td><td>28.3k</td><td>Algorithmic Trading Engine</td></tr><tr><td>Nancy</td><td>72elf614</td><td>70</td><td>7.5k</td><td>15.7</td><td>HTTP Service Framework</td></tr><tr><td>Newtonsoft.Json</td><td>6057d9b8</td><td>123</td><td>14.9k</td><td>16.1k</td><td> JSON Library</td></tr><tr><td>Ninject</td><td>7006297f</td><td>13</td><td>0.7k</td><td>2.1k</td><td>Code Injection Library</td></tr><tr><td>NLog</td><td>643e326a</td><td>75</td><td>8.3k</td><td>11.0k</td><td>Logging Library</td></tr><tr><td>Opserver</td><td>51b032e7</td><td>24</td><td>3.7k</td><td>4.5k</td><td>Monitoring System</td></tr><tr><td>OptiKey</td><td>7d35c718</td><td>34</td><td>6.1k</td><td>3.9k</td><td>Assistive On-Screen Keyboard</td></tr><tr><td>orleans Polly</td><td>e0d6a150 0afdbc32</td><td>300 32</td><td>30.7k 3.8k</td><td>35.6k 9.1k</td><td>Distributed Virtual Actor Model</td></tr><tr><td></td><td></td><td></td><td></td><td></td><td>Resilience &amp; Transient Fault Handling Library</td></tr><tr><td>quartznet</td><td>b33e6f86</td><td>49</td><td>9.6k</td><td>9.8k</td><td>Scheduler</td></tr><tr><td>ravendbDev</td><td>55230922</td><td>647</td><td>78.0k</td><td>82.7k</td><td>Document Database</td></tr><tr><td>RestSharp</td><td>70de357b</td><td>20</td><td>4.0k</td><td>4.5k</td><td>REST and HTTP API Client Library</td></tr><tr><td>Rx.NET</td><td>2d146fe5</td><td>180</td><td>14.0k</td><td>21.9k</td><td>Reactive Language Extensions</td></tr><tr><td>scriptcs</td><td>f3cc8bcb</td><td>18</td><td>2.7k</td><td>4.3k</td><td>C# Text Editor</td></tr><tr><td>ServiceStack</td><td>6d59da75</td><td>231</td><td>38.0k</td><td>46.2k</td><td>Web Framework</td></tr><tr><td>ShareX</td><td>718dd711</td><td>125</td><td>22.3k</td><td>18.1k</td><td>Sharing Application</td></tr><tr><td>SignalR</td><td>fa88089e</td><td>53</td><td>6.5k</td><td>10.5k</td><td>Push Notification Framework</td></tr><tr><td>Wox</td><td>cdaf6272</td><td>13</td><td>2.0k</td><td>2.1k</td><td>Application Launcher</td></tr></table>",
+        "bbox": [
+            178,
+            507,
+            820,
+            921
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "table",
+        "img_path": "images/72b636af8dc21676160a77f576e621c898d29fb40316b34c6acb8fc9ae0dc020.jpg",
+        "table_caption": [
+            "For this work, we released a large portion of the data, with the exception of projects with a GPL license. The data can be found at https://aka.ms/iclr18-prog-graphs-dataset. Since we are excluding some projects from the data, below we report the results, averaged over three runs, on the published dataset: "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td></td><td>Accuracy (%)</td><td>PR AUC</td></tr><tr><td>SEENPROJTEST</td><td>84.0</td><td>0.976</td></tr><tr><td>UNSEENPROJTEST</td><td>74.1</td><td>0.934</td></tr></table>",
+        "bbox": [
+            173,
+            166,
+            514,
+            224
+        ],
+        "page_idx": 16
+    }
+]

parse/train/H1ersoRqtm/H1ersoRqtm.md

@@ -0,0 +1,350 @@
+# STRUCTURED NEURAL SUMMARIZATION
+
+Patrick Fernandes, Miltiadis Allamanis & Marc Brockschmidt
+
+Microsoft Research   
+Cambridge, United Kingdom   
+{t-pafern,miallama,mabrocks}@microsoft.com
+
+# ABSTRACT
+
+Summarization of long sequences into a concise statement is a core problem in natural language processing, requiring non-trivial understanding of the input. Based on the promising results of graph neural networks on highly structured data, we develop a framework to extend existing sequence encoders with a graph component that can reason about long-distance relationships in weakly structured data such as text. In an extensive evaluation, we show that the resulting hybrid sequence-graph models outperform both pure sequence models as well as pure graph models on a range of summarization tasks.
+
+# 1 INTRODUCTION
+
+Summarization, the task of condensing a large and complex input into a smaller representation that retains the core semantics of the input, is a classical task for natural language processing systems. Automatic summarization requires a machine learning component to identify important entities and relationships between them, while ignoring redundancies and common concepts.
+
+Current approaches to summarization are based on the sequence-to-sequence paradigm over the words of some text, with a sequence encoder — typically a recurrent neural network, but sometimes a 1D-CNN (Narayan et al., 2018) or using self-attention (McCann et al., 2018) — processing the input and a sequence decoder generating the output. Recent successful implementations of this paradigm have substantially improved performance by focusing on the decoder, extending it with an attention mechanism over the input sequence and copying facilities (See et al., 2017; McCann et al., 2018). However, while standard encoders (e.g. bidirectional LSTMs) theoretically have the ability to handle arbitrary long-distance relationships, in practice they often fail to correctly handle long texts and are easily distracted by simple noise (Jia & Liang, 2017).
+
+In this work, we focus on an improvement of sequence encoders that is compatible with a wide range of decoder choices. To mitigate the long-distance relationship problem, we draw inspiration from recent work on highly-structured objects (Li et al., 2015; Kipf & Welling, 2017; Gilmer et al., 2017; Allamanis et al., 2018; Cvitkovic et al., 2018). In this line of work, highly-structured data such as entity relationships, molecules and programs is modelled using graphs. Graph neural networks are then successfully applied to directly learn from these graph representations. Here, we propose to extend this idea to weakly-structured data such as natural language. Using existing tools, we can annotate (accepting some noise) such data with additional relationships (e.g. co-references) to obtain a graph. However, the sequential aspect of the input data is still rich in meaning, and thus we propose a hybrid model in which a standard sequence encoder generates rich input for a graph neural network. In our experiments, the resulting combination outperforms baselines that use pure sequence or pure graph-based representations.
+
+Briefly, the contributions of our work are: 1. A framework that extends standard sequence encoder models with a graph component that leverages additional structure in sequence data. 2. Application of this extension to a range of existing sequence models and an extensive evaluation on three summarization tasks from the literature. 3. We release all used code and data at https://github.com/CoderPat/structured-neural-summarization.
+
+public void Add(string name, object value $=$ null, DbType? dbType $=$ null, ParameterDirection? direction $=$ null, int? size $=$ null, byte? precision $=$ null, byte? scale $=$ null) { parameters[Clean(name) $] =$ new ParamInfo{ Name $=$ name, Value $=$ value, ParameterDirection $=$ direction ?? ParameterDirection.Input, DbType $=$ dbType, Size $=$ size, Precision $=$ precision, Scale $=$ scale };}
+
+Ground truth: BILSTM LSTM: $\mathbf { B I L S T M + G N N } \to \mathbf { L S T M } .$ : $\mathbf { B I L S T M + G N N } \to \mathbf { L S T M + P O I N T E R }$ :
+
+add a parameter to this dynamic parameter list adds a new parameter to the specified parameter creates a new instance of the dynamic type specified add a parameter to a list of parameters
+
+Figure 1: An example from the dataset for the METHODDOC source code summarization task along with the outputs of a baseline and our models. In the METHODNAMING dataset, this method appears as a sample requiring to predict the name Add as a subtoken sequence of length 1.
+
+# 2 STRUCTURED SUMMARIZATION TASKS
+
+In this work, we consider three summarization tasks with different properties. All tasks follow the common pattern of translating a long (structured) sequence into a shorter sequence while trying to preserve as much meaning as possible. The first two tasks are related to the summarization of source code (Figure 1), which is highly structured and thus can profit most from models that can take advantage of this structure; the final task is a classical natural language task illustrating that hybrid sequence-graph models are applicable for less structured inputs as well.
+
+METHODNAMING The aim of this task is to infer the name of a function (or method in objectoriented languages, such as Java, Python and C#) given its source code (Allamanis et al., 2016). Although method names are a single token, they are usually composed of one or more subtokens (split using snake case or camelCase) and thus, the method naming task can be cast as predicting a sequence of subtokens. Consequently, method names represent an “extreme” summary of the functionality of a given function (on average, the names in the Java dataset have only 2.9 subtokens). Notably, the vocabulary of tokens used in names is very large (due to abbreviations and domainspecific jargon), but this is mitigated by the fact that $33 \%$ of subtokens in names can be copied directly from subtokens in the method’s source code. Finally, source code is highly structured input data with known semantics, which can be exploited to support name prediction.
+
+METHODDOC Similar to the first task, the aim of this task is to predict a succinct description of the functionality of a method given its source code (Barone & Sennrich, 2017). Such descriptions usually appear as documentation of methods (e.g. “docstrings” in Python or “JavaDocs” in Java). While the task shares many characteristics with the METHODNAMING task, the target sequence is substantially longer (on average 19.1 tokens in our C# dataset) and only $1 9 . 4 \%$ of tokens in the documentation can be copied from the code. While method documentation is nearer to standard natural language than method names, it mixes project-specific jargon, code segments and often describes non-functional aspects of the code, such as performance characteristics and design considerations.
+
+NLSUMMARIZATION Finally, we consider the classic summarization of natural language as widely studied in NLP research. Specifically, we are interested in abstractive summarization, where given some text input (e.g. a news article) a machine learning model produces a novel natural language summary. Traditionally, NLP summarization methods treat text as a sequence of sentences and each one of them as a sequence of words (tokens). The input data has less explicitly defined structure than our first two tasks. However, we recast the task as a structured summarization problem by considering additional linguistic structure, including named entities and entity coreferences as inferred by existing NLP tools.
+
+# 3 MODEL
+
+As discussed above, standard neural approaches to summarization follow the sequence-to-sequence framework. In this setting, most decoders only require a representation $^ { h }$ of the complete input sequence (e.g. the final state of an RNN) and per-token representations $h _ { t _ { i } }$ for each input token $t _ { i }$ These token representations are then used as the “memories” of an attention mechanism (Bahdanau et al., 2014; Luong et al., 2015) or a pointer network (Vinyals et al., 2015a).
+
+In this work, we propose an extension of sequence encoders that allows us to leverage known (or inferred) relationships among elements in the input data. To achieve that, we combine sequence encoders with graph neural networks (GNNs) (Li et al., 2015; Gilmer et al., 2017; Kipf & Welling, 2017). For this, we first use a standard sequential encoder (e.g. bidirectional RNNs) to obtain a pertoken representation $h _ { t _ { i } }$ , which we then feed into a GNN as the initial node representations. The resulting per-node (i.e. per-token) representations $\boldsymbol { h } _ { t _ { i } } ^ { \prime }$ can then be used by an unmodified decoder. Experimentally, we found this to surpass models that use either only the sequential structure or only the graph structure (see Sect. 4). We now discuss the different parts of our model in detail.
+
+Gated Graph Neural Networks To process graphs, we follow Li et al. (2015) and briefly summarize the core concepts of GGNNs here. A graph $\mathcal { G } = ( \nu , \pmb { \varepsilon } , \pmb { X } )$ is composed of a set of nodes $\nu$ , node features $\boldsymbol { X }$ , and a list of directed edge sets ${ \pmb { \mathcal { E } } } = ( { \mathcal { E } } _ { 1 } , \dots , { \mathcal { E } } _ { K } )$ where $K$ is the number of edge types. Each $v \in \nu$ is associated with a real-valued vector $\scriptstyle { \mathbf { { \mathit { x } } } } _ { \mathit { v } }$ representing the features of the node (e.g., the embedding of a string label of that node), which is used for the initial state ${ h } _ { v } ^ { ( 0 ) }$ of a node.
+
+Information is propagated through the graph using neural message passing (Gilmer et al., 2017). For this, every node $v$ sends messages to its neighbors by transforming its current representation $\boldsymbol { h } _ { v } ^ { ( i ) }$ using an edge-type dependent function $f _ { k }$ . Here, $f _ { k }$ can be an arbitrary function; we use a simple linear layer. By computing all messages at the same time, all states can be updated simultaneously. In particular, a new state for a node $v$ is computed by aggregating all incoming messages as $m _ { v } ^ { ( i ) } = \bar { g } ( \{ f _ { k } ( h _ { u } ^ { ( i ) } ) \} )$ there is an edge of type $k$ from $u$ to $v \}$ ). $g$ is an aggregation function; we use elementwise summation for $g$ . Given the aggregated message $\mathbf { \it { m } } _ { v } ^ { ( i ) }$ and the current state vector $\boldsymbol { h } _ { v } ^ { ( i ) }$ of node $v$ , we can compute the new state 1) = GRU(m(i)v , h(i)v ), where GRU is the recurrent cell function of a gated recurrent unit. These dynamics are rolled out for a fixed number of timesteps $T$ , and the state vectors resulting from the final step are used as output node representations, i.e., $\mathrm { G N N } ( ( \mathcal { V } , \pmb { \mathcal { E } } , X ) ) = \{ \pmb { h } _ { v } ^ { ( T ) } \} _ { v \in \mathcal { V } }$ .
+
+Sequence GNNs We now explain our novel combination of GGNNs and standard sequence encoders. As input, we take a sequence $\boldsymbol { S } = \left[ s _ { 1 } \ldots s _ { N } \right]$ and $K$ binary relationships $R _ { 1 } \ldots R _ { K } \in S \times S$ between elements of the sequence. For example, $R _ { = }$ could be the equality relationship $\left\{ \left( s _ { i } , s _ { j } \right) \right. \mid$ $s _ { i } = s _ { j } \}$ . The choice and construction of relationships is dataset-dependent, and will be discussed in detail in Sect. 4. Given any sequence encoder $\mathcal { S E }$ that maps $S$ to per-element representations $\left[ \mathbf { e } _ { 1 } \ldots \mathbf { e } _ { N } \right]$ and a sequence representation e (e.g. a bidirectional RNN), we can construct the sequence GNN $\mathcal { S } \mathcal { E } _ { G N N }$ by simply computing $\mathbf { \bar { e } } _ { 1 } ^ { \prime } \cdot \cdot \cdot \mathbf { e } _ { N } ^ { \prime } ] = \mathbf { G N N } ( ( S , [ R _ { 1 } \dots R _ { K } ] , [ \mathbf { e } _ { 1 } \dots \mathbf { e } _ { N } ] ) )$ . To obtain a graph-level representation, we use the weighted averaging mechanism from Gilmer et al. (2017). Concretely, for each node $v$ in the graph, we compute a weight $\sigma ( w ( \pmb { h } _ { v } ^ { ( T ) } ) ) \in [ 0 , 1 ]$ using a learnable function $w$ and the logistic sigmoid $\sigma$ and compute a graph-level representation as $\begin{array} { r } { \hat { \mathbf { e } } \equiv \sum _ { 1 \leq i \leq N } \sigma ( w ( \mathbf { e } _ { i } ^ { \prime } ) ) \cdot \mathbb { N } ( \mathbf { e } _ { i } ^ { \prime } ) } \end{array}$ , where $\aleph$ is another learnable projection function. We found that best results were achieved by computing the final $\mathbf { e ^ { \prime } }$ as $W \cdot ( \mathbf { e } \hat { \mathbf { e } } )$ for some learnable matrix $W$ .
+
+This method can easily be extended to support additional nodes not present in the original sequence $S$ after running $\mathcal { S E }$ (e.g., to accommodate meta-nodes representing sentences, or non-terminal nodes from a syntax tree). The initial node representation for these additional nodes can come from other sources, such as a simple embedding of their label.
+
+Implementation Details. Processing large graphs of different shapes efficiently requires to overcome some engineering challenges. For example, the CNN/DM corpus has (on average) about 900 nodes per graph. To allow efficient computation, we use the trick of Allamanis et al. (2018) where all graphs in a minibatch are “flattened” into a single graph with multiple disconnected components. The varying graph sizes also represent a problem for the attention and copying mechanisms in the decoder, as they require to compute a softmax over a variable-sized list of memories. To handle this efficiently without padding, we associate each node in the (flattened) “batch” graph with the index of the sample in the minibatch from which the node originated. Then, using TensorFlow’s unsorted segment $\mathbf { \nabla } _ { \cdot } \star$ operations, we can perform an efficient and numerically stable softmax over the variable number of representations of the nodes of each graph.
+
+# 4 EVALUATION
+
+# 4.1 QUANTITATIVE EVALUATION
+
+We evaluate Sequence GNNs on our three tasks by comparing them to models that use only sequence or graph information, as well as by comparing them to task-specific baselines. We discuss the three tasks, their respective baselines and how we present the data to the models (including the relationships considered in the graph component) next before analyzing the results.
+
+# 4.1.1 SETUP FOR METHODNAMING
+
+Datasets, Metrics, and Models. We consider two datasets for the METHODNAMING task. First, we consider the “Java (small)” dataset of Alon et al. (2018a), re-using the train-validation-test splits they have picked. We additionally generated a new dataset from 23 open-source C# projects mined from GitHub (see below for the reasons for this second dataset), removing any duplicates. More information about these datasets can be found in Appendix C. We follow earlier work on METHODNAMING (Allamanis et al., 2016; Alon et al., 2018a) and measure performance using the F1 score over the generated subtokens. However, since the task can be viewed as a form of (extreme) summarization, we also report ROUGE-2 and ROUGE-L scores (Lin, 2004), which we believe to be additional useful indicators for the quality of results. ROUGE-1 is omitted since it is equivalent to F1 score. We note that there is no widely accepted metric for this task and further work identifying the most appropriate metric is required.
+
+We compare to the current state of the art (Alon et al., 2018a), as well as a sequence-to-sequence implementation from the OpenNMT project (Klein et al.). Concretely, we combine two encoders (a bidirectional LSTM encoder with 1 layer and 256 hidden units, and its sequence GNN extension with 128 hidden units unrolled over 8 timesteps) with two decoders (an LSTM decoder with 1 layer and 256 hidden units with attention over the input sequence, and an extension using a pointer network-style copying mechanism (Vinyals et al., 2015a)). Additionally, we consider self-attention as an alternative to RNN-based sequence encoding architectures. For this, we use the Transformer (Vaswani et al., 2017) implementation in OpenNMT (i.e., using self-attention both for the decoder and the encoder) as a baseline and compare it to a version whose encoder is extended with a GNN component.
+
+Data Representation Following the work of Allamanis et al. (2016); Alon et al. (2018a), we break up all identifier tokens (i.e. variables, methods, classes, etc.) in the source code into subtokens by splitting them according to camelCase and pascal case heuristics. This allows the models to extract information from the information-rich subtoken structure, and ensures that a copying mechanism in the decoder can directly copy relevant subtokens, something that we found to be very effective for this task. All models are provided with all (sub)tokens belonging to the source code of a method, including its declaration, with the actual method name replaced by a placeholder symbol.
+
+To construct a graph from the (sub)tokens, we implement a simplified form of the work of Allamanis et al. (2018). First, we introduce additional nodes for each (full) identifier token, and connect the constituent subtokens appearing in the input sequence using a INTOKEN edge; we additionally connect these nodes using a NEXTTOKEN edge. We also add nodes for the parse tree and use edges to indicate that one node is a CHILD of another. Finally, we add LASTLEXICALUSE edges to connect identifiers to their most (lexically) recent use in the source code.
+
+# 4.1.2 SETUP FOR METHODDOC
+
+Datasets, Metrics, and Models. We tried to evaluate on the Python dataset of Barone & Sennrich (2017) that contains pairs of method declarations and their documentation (“docstring”). However, following the work of Lopes et al. (2017), we found extensive duplication between different folds of the dataset and were only able to reach comparable results by substantially overfitting to the training data that overlapped with the test set. We have documented details in subsection C.3 and in Allamanis (2018), and decided to instead evaluate on our new dataset of 23 open-source C# projects from above, again removing duplicates and methods without documentation. Following Barone & Sennrich (2017), we measure the BLEU score for all models. However, we also report F1, ROUGE-2 and ROUGE-L scores, which should better reflect the summarization aspect of the task. We consider the same models as for the METHODNAMING task, using the same configuration, and use the same data representation.
+
+![](images/0f24ece1ecd933d082df2284a4d3190ac4a48d4c10138fc5c01fc0d240b7a43f.jpg)  
+Figure 2: (Partial) graph of an example input from the CNN/DM corpus.
+
+# 4.1.3 SETUP FOR NLSUMMARIZATION
+
+Datasets, Metrics, and Models. We use the CNN/DM dataset (Hermann et al., 2015) using the exact data and split provided by See et al. (2017). The data is constructed from CNN and Daily Mail news articles along with a few sentences that summarize each article. To measure performance, we use the standard ROUGE metrics. We compare our model with the near-to-state-of-the-art work of See et al. (2017), who use a sequence-to-sequence model with attention and copying as basis, but have additionally substantially improved the decoder component. As our contribution is entirely on the encoder side and our model uses a standard sequence decoder, we are not expecting to outperform more recent models that introduce substantial novelty in the structure or training objective of the decoder (Chen & Bansal, 2018; Narayan et al., 2018). Again, we evaluate our contribution using an OpenNMT-based encoder/decoder combination. Concretely, we use a bidirectional LSTM encoder with 1 layer and 256 hidden units, and its sequence GNN extension with 128 hidden units unrolled over 8 timesteps. As decoder, we use an LSTM with 1 layer and 256 hidden units with attention over the input sequence, and an extension using a pointer network-style copying mechanism.
+
+Data Representation We use Stanford CoreNLP (Manning et al., 2014) (version 3.9.1) to tokenize the text and provide the resulting tokens to the encoder. For the graph construction (Figure 2), we extract the named entities and run coreference resolution using CoreNLP. We connect tokens using a NEXT edge and introduce additional super-nodes for each sentence, connecting each token to the corresponding sentence-node using a IN edge. We also connect subsequent sentence-nodes using a NEXT edge. Then, for each multi-token named entity we create a new node, labeling it with the type of the entity and connecting it with all tokens referring to that entity using an IN edge. Finally, coreferences of entities are connected with a special REF edge. Figure 2 shows a partial graph for an article in the CNN/DM dataset. The goal of this graph construction process is to explicitly annotate important relationships that can be useful for summarization. We note that (a) in early efforts we experimented with adding dependency parse edges, but found that they do not provide significant benefits and (b) that since we retrieve the annotations from CoreNLP, they can contain errors and thus, the performance of the our method is influenced by the accuracy of the upstream annotators of named entities and coreferences.
+
+Table 1: Evaluation results for all models and tasks.   
+
+<table><tr><td>METHODNAMING</td><td>F1</td><td>ROUGE-2</td><td>ROUGE-L</td></tr><tr><td>Java</td><td></td><td></td><td></td></tr><tr><td>Alon et al. (2018a)</td><td>43.0</td><td>一</td><td>1</td></tr><tr><td>SELFATT →SELFATT</td><td>24.9</td><td>8.3</td><td>27.4</td></tr><tr><td>SELFATT+GNN →SELFATT</td><td>44.5</td><td>20.9</td><td>43.4</td></tr><tr><td>BILSTM →LSTM</td><td>35.8</td><td>17.9</td><td>39.7</td></tr><tr><td>BILSTM+GNN →LSTM</td><td>44.7</td><td>21.1</td><td>43.1</td></tr><tr><td>BILSTM →LSTM+POINTER</td><td>42.5</td><td>22.4</td><td>45.6</td></tr><tr><td>GNN →LSTM+POINTER</td><td>50.5</td><td>24.8</td><td>48.9</td></tr><tr><td>BILSTM+GNN→LSTM+POINTER</td><td>51.4</td><td>25.0</td><td>50.0</td></tr><tr><td>C#</td><td></td><td></td><td></td></tr><tr><td>SELFATT →SELFATT</td><td>41.3</td><td>25.2</td><td>43.2</td></tr><tr><td>SELFATT+GNN→→SELFATT</td><td>62.1</td><td>31.0</td><td>61.1</td></tr><tr><td>BILSTM →LSTM</td><td>48.8</td><td>32.8</td><td>51.8</td></tr><tr><td>BILSTM+GNN →LSTM</td><td>62.6</td><td>31.0</td><td>61.3</td></tr><tr><td>BILSTM →LSTM+POINTER</td><td>57.2</td><td>29.7</td><td>60.4</td></tr><tr><td>GNN→LSTM+POINTER</td><td>63.0</td><td>31.5</td><td>61.3</td></tr><tr><td>BILSTM+GNN→LSTM+POINTER</td><td>63.4</td><td>31.9</td><td>62.4</td></tr><tr><td>METHODDOC</td><td>F1</td><td>ROUGE-2</td><td>ROUGE-L</td><td>BLEU</td></tr><tr><td>C#</td><td></td><td></td><td></td><td></td></tr><tr><td>SELFATT →SELFATT</td><td>40.0</td><td>27.8</td><td>41.1</td><td>13.9</td></tr><tr><td>SELFATT+GNN→SELFATT</td><td>37.6</td><td>25.6</td><td>37.9</td><td>21.4</td></tr><tr><td>BILSTM →LSTM</td><td>35.2</td><td>15.3</td><td>30.8</td><td>10.0</td></tr><tr><td>BILSTM+GNN →LSTM</td><td>41.1</td><td>28.9</td><td>41.0</td><td>22.5</td></tr><tr><td>BILSTM →LSTM+POINTER</td><td>35.2</td><td>20.8</td><td>36.7</td><td>14.7</td></tr><tr><td>GNN →LSTM+POINTER</td><td>38.9</td><td>25.6</td><td>37.1</td><td>17.7</td></tr><tr><td>BILSTM+GNN →→LSTM+POINTER (average pooling)</td><td>43.2</td><td>29.0</td><td>41.0</td><td>21.3</td></tr><tr><td>BILSTM+GNN→LSTM+POINTER</td><td>45.4</td><td>28.3</td><td>41.1</td><td>22.2</td></tr><tr><td>NLSUMMARIZATION</td><td>ROUGE-1</td><td>ROUGE-2</td><td>ROUGE-L</td><td></td></tr><tr><td>CNN/DM</td><td></td><td></td><td></td><td></td></tr><tr><td>BILSTM →LSTM</td><td>33.6</td><td>11.4</td><td>27.9</td><td></td></tr><tr><td>BILSTM+GNN→LSTM</td><td>33.0</td><td>13.3</td><td>28.3</td><td></td></tr><tr><td>See et al. (2017) (+ Pointer)</td><td>36.4</td><td>15.7</td><td>33.4</td><td></td></tr><tr><td>BILSTM →LSTM+POINTER</td><td>35.9</td><td>13.9</td><td>30.3</td><td></td></tr><tr><td>BILSTM+GNN →LSTM+POINTER</td><td>38.1</td><td>16.1</td><td>33.2</td><td></td></tr><tr><td>See et al. (2017) (+ Pointer + Coverage)</td><td>39.5</td><td>17.3</td><td>36.4</td><td></td></tr><tr><td></td><td></td><td></td><td></td><td></td></tr></table>
+
+# 4.1.4 RESULTS & ANALYSIS
+
+We show all results in Tab. 1. Results for models from the literature are taken from the respective papers and repeated here. Across all tasks, the results show the advantage of our hybrid sequence GNN encoders over pure sequence encoders.
+
+On METHODNAMING, we can see that all GNN-augmented models are able to outperform the current specialized state of the art, requiring only simple graph structure that can easily be obtained using existing parsers for a programming language. The results in performance between the different encoder and decoder configurations nicely show that their effects are largely orthogonal.
+
+On METHODDOC, the unmodified SELFATT $ s$ ELFATT model already performs quite well, and the augmentation with graph data only improves the BLEU score and worsens the results on ROUGE. Inspection of the results shows that this is due to the length of predictions. Whereas the ground truth data has on average 19 tokens in each result, SELFATT $ s$ ELFATT predicts on average 11 tokens, and SELFATT+GNN SELFATT 16 tokens. Additionally, we experimented with an ablation in which a model is only using graph information, e.g., a setting comparable to a simplification of the architecture of Allamanis et al. (2018). For this, we configured the GNN to use 128-dimensional representations and unrolled it for 10 timesteps, keeping the decoder configuration as for the other models. The results indicate that this configuration performs less well than a pure sequenced model. We speculate that this is mainly due to the fact that 10 timesteps are insufficient to propagate inforpublic static bool TryFormat(float value, Span<byte> destination, out int bytesWritten, StandardFormat format $=$ default) { return TryFormatFloatingPoint<float>(value, destination, out bytesWritten, format); }
+
+Table 2: Ablations on CNN/DM Corpus   
+
+<table><tr><td>NLSUMMARIZATION (CNN/DM)</td><td>ROUGE-1</td><td>ROUGE-2</td><td>ROUGE-L</td></tr><tr><td>See et al.(2017) (base)</td><td>31.3</td><td>11.8</td><td>28.8</td></tr><tr><td>See et al. (2017) (+ Pointer)</td><td>36.4</td><td>15.7</td><td>33.4</td></tr><tr><td>See et al.(2017) (+ Pointer + Coverage)</td><td>39.5</td><td>17.3</td><td>36.4</td></tr><tr><td>BILSTM →LSTM</td><td>33.6</td><td>11.4</td><td>27.9</td></tr><tr><td>BILSTM →LSTM+POINTER</td><td>35.9</td><td>13.9</td><td>30.3</td></tr><tr><td>BILSTM →LSTM+PoINTER (+ coref/entity annotations)</td><td>36.2</td><td>14.2</td><td>30.5</td></tr><tr><td>BILSTM+GNN →LSTM</td><td>33.0</td><td>13.3</td><td>28.3</td></tr><tr><td>BILSTM+GNN→LSTM+POINTER (only sentence nodes)</td><td>36.0</td><td>15.2</td><td>29.6</td></tr><tr><td>BILSTM+GNN →LSTM+POINTER (sentence nodes + eq edges)</td><td>36.1</td><td>15.4</td><td>30.3</td></tr><tr><td>BILSTM+GNN→LSTM+POINTER</td><td>38.1</td><td>16.1</td><td>33.2</td></tr></table>
+
+Ground truth BILSTM LSTM BILST $\mathbf { M } \mathbf { + } \mathbf { G N N } \to \mathbf { L S T M }$ B $\mathbf { \mathbf { \mathbf { I L S T M + G N N } } } \mathbf { \mathbf { \Phi } } \to \mathbf { \mathbf { \mathbf { L S T M + P O I N T E R } } }$ formats a single as a utf8 string formats a number of bytes in a utf8 string formats a timespan as a utf8 string formats a float as a utf8 string
+
+Figure 3: An example from the dataset for the METHODDOC source code summarization task along with the outputs of a baseline and our models.
+
+mation across the whole graph, especially in combination with summation as aggregation function for messages in graph information propagation.
+
+Finally, on NLSUMMARIZATION, our experiments show that the same model suitable for tasks on highly structured code is competitive with specialized models for natural language tasks. While there is still a gap to the best configuration of See et al. (2017) (and an even larger one to more recent work in the area), we believe that this is entirely due to our simplistic decoder and training objective, and that our contribution can be combined with these advances.
+
+In Table 2 we show some ablations for NLSUMMARIZATION. As we use the same hyperparameters across all datasets and tasks, we additionally perform an experiment with the model of See et al. (2017) (as implemented in OpenNMT) but using our settings. The results achieved by these baselines trend to be a bit worse than the results reported in the original paper, which we believe is due to a lack of hyperparameter optimization for this task. We then evaluated how much the additional linguistic structure provided by CoreNLP helps. First, we add the coreference and entity annotations to the baseline $\mathrm { B I L S T M } \to \mathrm { L S T M } + \mathrm { P O I N T E R }$ model (by extending the embedding of tokens with an embedding of the entity information, and inserting fresh $\mathrm {  ~ \omega ~ } _ { \mathrm { i R E F 1 } } \mathrm {  ~ \omega ~ }$ ”, . . . tokens at the sources/targets of co-references) and observe only minimal improvements. This suggests that our graph-based encoder is better-suited to exploit additional structured information compared to a biLSTM encoder. We then drop all linguistic structure information from our model, keeping only the sentence edges/nodes. This still improves on the baseline $\mathrm { B I L S T M } \to \mathrm { L S T M } + \mathrm { P O I I }$ NTER model (in the ROUGE-2 score), suggesting that the GNN still yields improvements in the absence of linguistic structure. Finally, we add long-range dependency edges by connecting tokens with equivalent string representations of their stems and observe further minor improvements, indicating that even using only purely syntactical information, without a semantic parse, can already provide gains.
+
+# 4.2 QUALITATIVE EVALUATION
+
+We look at a few sample suggestions in our dataset across the tasks. Here we highlight some observations we make that point out interesting aspects and failure cases of our model.
+
+Figure 4: Sample natural language translations from the CNN-DM dataset.   
+
+<table><tr><td rowspan=1 colspan=1>Input: Arsenal,Newcastle United and Southampton have checked on Caen midfelder N&#x27;golo Kante .Paris-born Kante is a defensive minded player who has impressed for Caen this season and they are wiling to sellfor around f 5milion.Marseille have been in constant contact with Caen over signing the 24-year-old who has similarities with Lassna Diarra and Claude Makelele in terms of stature and style .N&#x27;Golo Kante is attractinginterest froma host of PremierLeague clubs including Arsenal.Caen would be wiling to sellKante for aroundf5million.</td></tr><tr><td rowspan=1 colspan=1>Reference:n&#x27;golo kante is wanted by arsenal,newcastle and southampton.marseille are also keen on thef5mrated midfielder.kante has been compared to lassana diarra and claude makelele.click here for the latestpremier league news .</td></tr><tr><td rowspan=1 colspan=1>See et al.(2O17) (+ Pointer): arsenal,newcastle united and southampton have checked on caen midfieldern&#x27;golo kante .paris-born kante is attracting interest from a host of premier league clubs including arsenal .paris-born kante is attracting interest from a host of premier league clubs including arsenal</td></tr><tr><td rowspan=1 colspan=1>See et al. (2O17)(+ Pointer + Coverage): arsenal, newcastle united and southampton have checked on caenmidfielder n&#x27;golo kante.paris-born kante is a defensive minded player who has impressed for caen this season.marseille have been in constant contact with caen over signing the 24-year-old .</td></tr><tr><td rowspan=1 colspan=1>BILSTM+GNN →LSTM: marseille have been linked with caen midfielder %UNK% %UNK% . marseillehave been interested from a host of premier league clubs including arsenal .caen have been interested from ahost of premier league clubs including arsenal .</td></tr><tr><td rowspan=1 colspan=1>BILSTM+GNN →LSTM+PoINTER n&#x27;golo kante is attracting interest from a host of premier league clubs .marseilehave been in constant contact with caen over signing the24-year-old.the 24-year-old has similaritieswith lassana diarra and claude makelele in terms of stature .</td></tr></table>
+
+METHODDOC Figures 1 and 3 illustrate typical results of baselines and our model on the METHODDOC task (see Appendix A for more examples). The hardness of the task stems from the large number of distractors and the need to identify the most relevant parts of the input. In Figure 1, the token “parameter” and variations appears many times, and identifying the correct relationship is non-trivial, but is evidently eased by graph edges explicitly denoting these relationships. Similarly, in Figure 3, many variables are passed around, and the semantics of the method require understanding how information flows between them.
+
+NLSUMMARIZATION Figure 4 shows one sample summarization. More samples for this task can be found in Appendix B. First, we notice that the model produces natural-looking summaries with no noticeable negative impact on the fluency of the language over existing methods. Furthermore, the GNN-based model seems to capture the central named entity in the article and creates a summary centered around that entity. We hypothesize that the GNN component that links long-distance relationships helps capture and maintain a better “global” view of the article, allowing for better identification of central entities. Our model still suffers from repetition of information (see Appendix B), and so we believe that our model would also profit from advances such as taking coverage into account (See et al., 2017) or optimizing for ROUGE-L scores directly via reinforcement learning (Chen & Bansal, 2018; Narayan et al., 2018).
+
+# 5 RELATED WORK
+
+Natural language processing research has studied summarization for a long time. Most related is work on abstractive summarization, in which the core content of a given text (usually a news article) is summarized in a novel and concise sentence. Chopra et al. (2016) and Nallapati et al. (2016) use deep learning models with attention on the input text to guide a decoder that generates a summary. See et al. (2017) and McCann et al. (2018) extend this idea with pointer networks (Vinyals et al., 2015a) to allow for copying tokens from the input text to the output summary. These approaches treat text as a simple token sequences, not explicitly exposing additional structure. In principle, deep sequence networks are known to be able to learn the inherent structure of natural language (e.g. in parsing (Vinyals et al., 2015b) and entity recognition (Lample et al., 2016)), but our experiments indicate that explicitly exposing this structure by separating concerns improves performance.
+
+Recent work in summarization has proposed improved training objectives for summarization, such as tracking coverage of the input document (See et al., 2017) or using reinforcement learning to directly identify actions in the decoder that improve target measures such as ROUGE-L (Chen & Bansal, 2018; Narayan et al., 2018). These objectives are orthogonal to the graph-augmented encoder discussed in this work, and we are interested in combining these efforts in future work.
+
+Exposing more language structure explicitly has been studied over the last years, with a focus on tree-based models (Tai et al., 2015). Very recently, first uses of graphs in natural language processing have been explored. Marcheggiani & Titov (2017) use graph convolutional networks to encode single sentences and assist machine translation. De Cao et al. (2018) create a graph over named entities over a set of documents to assist question answering. Closer to our work is the work of Liu et al. (2018), who use abstract meaning representation (AMR), in which the source document is first parsed into AMR graphs, before a summary graph is created, which is finally rendered in natural language. In contrast to that work we do not use AMRs but directly encode relatively simple relationships directly on the tokenized text, and do not treat summarization as a graph rewrite problem. Combining our encoder with AMRs to use richer graph structures may be a promising future direction.
+
+Finally, summarization in source code has also been studied in the forms of method naming, comment and documentation prediction. Method naming has been tackled with a series of models. For example, Allamanis et al. (2015) use a log-bilinear network to predict method names from features, and later extend this idea to use a convolutional attention network over the tokens of a method to predict the subtokens of names (Allamanis et al., 2016). Raychev et al. (2015) and Bichsel et al. (2016) use CRFs for a range of tasks on source code, including the inference of names for variables and methods. Recently, Alon et al. (2018b;a) extract and encode paths from the syntax tree of a program, setting the state of the art in accuracy on method naming.
+
+Linking text to code can have useful applications, such as code search (Gu et al., 2018), traceability (Guo et al., 2017), and detection of redundant method comments (Louis et al., 2018). Most approaches on source code either treat it as natural language (i.e., a token sequence), or use a language parser to explicitly expose its tree structure. For example, Barone & Sennrich (2017) use a simple sequenceto-sequence baseline, whereas Hu et al. (2017) summarize source code by linearizing the abstract syntax tree of the code and using a sequence-to-sequence model. Wan et al. (2018) instead directly operate on the tree structure using tree recurrent neural networks (Tai et al., 2015). The use of additional structure on related tasks on source code has been studied recently, for example in models that are conditioned on learned traversals of the syntax tree (Bielik et al., 2016) and in graph-based approaches (Allamanis et al., 2018; Cvitkovic et al., 2018). However, as noted by Liao et al. (2018), GNN-based approaches suffer from a tension between the ability to propagate information across large distances in a graph and the computational expense of the propagation function, which is linear in the number of graph edges per propagation step.
+
+# 6 DISCUSSION & CONCLUSIONS
+
+We presented a framework for extending sequence encoders with a graph component that can leverage rich additional structure. In an evaluation on three different summarization tasks, we have shown that this augmentation improves the performance of a range of different sequence models across all tasks. We are excited about this initial progress and look forward to deeper integration of mixed sequence-graph modeling in a wide range of tasks across both formal and natural languages. The key insight, which we believe to be widely applicable, is that inductive biases induced by explicit relationship modeling are a simple way to boost the practical performance of existing deep learning systems.
+
+# REFERENCES
+
+Miltiadis Allamanis. The adverse effects of code duplication in machine learning models of code. arXiv preprint arXiv:1812.06469, 2018.
+
+Miltiadis Allamanis, Earl T Barr, Christian Bird, and Charles Sutton. Suggesting accurate method and class names. In Proceedings of the 2015 10th Joint Meeting on Foundations of Software Engineering, pp. 38–49. ACM, 2015.
+
+Miltiadis Allamanis, Hao Peng, and Charles Sutton. A convolutional attention network for extreme summarization of source code. In International Conference on Machine Learning, pp. 2091–2100, 2016.
+
+Miltiadis Allamanis, Marc Brockschmidt, and Mahmoud Khademi. Learning to represent programs with graphs. In International Conference on Learning Representations, 2018.
+
+Uri Alon, Omer Levy, and Eran Yahav. code2seq: Generating sequences from structured representations of code. arXiv preprint arXiv:1808.01400, 2018a.
+
+Uri Alon, Meital Zilberstein, Omer Levy, and Eran Yahav. A general path-based representation for predicting program properties. In Proceedings of the 39th ACM SIGPLAN Conference on Programming Language Design and Implementation, pp. 404–419. ACM, 2018b.
+
+Dzmitry Bahdanau, Kyunghyun Cho, and Yoshua Bengio. Neural machine translation by jointly learning to align and translate. arXiv preprint arXiv:1409.0473, 2014.
+
+Antonio Valerio Miceli Barone and Rico Sennrich. A parallel corpus of Python functions and documentation strings for automated code documentation and code generation. In Proceedings of the Eighth International Joint Conference on Natural Language Processing (Volume 2: Short Papers), volume 2, pp. 314–319, 2017.
+
+Benjamin Bichsel, Veselin Raychev, Petar Tsankov, and Martin Vechev. Statistical deobfuscation of android applications. In Proceedings of the 2016 ACM SIGSAC Conference on Computer and Communications Security, pp. 343–355. ACM, 2016.
+
+Pavol Bielik, Veselin Raychev, and Martin Vechev. PHOG: probabilistic model for code. In International Conference on Machine Learning (ICML), 2016.
+
+Yen-Chun Chen and Mohit Bansal. Fast abstractive summarization with reinforce-selected sentence rewriting. arXiv preprint arXiv:1805.11080, 2018.
+
+Sumit Chopra, Michael Auli, and Alexander M Rush. Abstractive sentence summarization with attentive recurrent neural networks. In Proceedings of the 2016 Conference of the North American Chapter of the Association for Computational Linguistics: Human Language Technologies, pp. 93–98, 2016.
+
+Milan Cvitkovic, Badal Singh, and Anima Anandkumar. Deep learning on code with an unbounded vocabulary. In Machine Learning 4 Programming, 2018.
+
+Nicola De Cao, Wilker Aziz, and Ivan Titov. Question answering by reasoning across documents with graph convolutional networks. arXiv preprint arXiv:1808.09920, 2018.
+
+Justin Gilmer, Samuel S Schoenholz, Patrick F Riley, Oriol Vinyals, and George E Dahl. Neural message passing for quantum chemistry. In International Conference on Machine Learning, pp. 1263–1272, 2017.
+
+Xiaodong Gu, Hongyu Zhang, and Sunghun Kim. Deep code search. In Proceedings of the 40th International Conference on Software Engineering, pp. 933–944. ACM, 2018.
+
+Jin Guo, Jinghui Cheng, and Jane Cleland-Huang. Semantically enhanced software traceability using deep learning techniques. In Software Engineering (ICSE), 2017 IEEE/ACM 39th International Conference on, pp. 3–14. IEEE, 2017.
+
+Karl Moritz Hermann, Tomas Kocisky, Edward Grefenstette, Lasse Espeholt, Will Kay, Mustafa Suleyman, and Phil Blunsom. Teaching machines to read and comprehend. In Advances in Neural Information Processing Systems, pp. 1693–1701, 2015.
+
+Xing Hu, Yuhan Wei, Ge Li, and Zhi Jin. Codesum: Translate program language to natural language. arXiv preprint arXiv:1708.01837, 2017.
+
+Robin Jia and Percy Liang. Adversarial examples for evaluating reading comprehension systems. In Empirical Methods in Natural Language Processing (EMNLP), 2017.
+
+Thomas N. Kipf and Max Welling. Semi-supervised classification with graph convolutional networks. In International Conference on Learning Representations, 2017.
+
+G. Klein, Y. Kim, Y. Deng, J. Senellart, and A. M. Rush. OpenNMT: Open-Source Toolkit for Neural Machine Translation. ArXiv e-prints.
+
+Guillaume Lample, Miguel Ballesteros, Sandeep Subramanian, Kazuya Kawakami, and Chris Dyer. Neural architectures for named entity recognition. In Proceedings the North American Chapter of the Association for Computational Linguistics: Human Language Technologies, 2016.
+
+Yujia Li, Daniel Tarlow, Marc Brockschmidt, and Richard Zemel. Gated graph sequence neural networks. arXiv preprint arXiv:1511.05493, 2015.
+
+Renjie Liao, Marc Brockschmidt, Daniel Tarlow, Alexander Gaunt, Raquel Urtasun, and Richard S. Zemel. Graph partition neural networks for semi-supervised classification. In International Conference on Learning Representations (ICLR) [Workshop Track], 2018.
+
+Chin-Yew Lin. ROUGE: A package for automatic evaluation of summaries. Text Summarization Branches Out, 2004.
+
+Fei Liu, Jeffrey Flanigan, Sam Thomson, Norman Sadeh, and Noah A Smith. Toward abstractive summarization using semantic representations. arXiv preprint arXiv:1805.10399, 2018.
+
+Cristina V Lopes, Petr Maj, Pedro Martins, Vaibhav Saini, Di Yang, Jakub Zitny, Hitesh Sajnani, and Jan Vitek. Dej´ avu: a map of code duplicates on github. \` Proceedings of the ACM on Programming Languages, 1(OOPSLA):84, 2017.
+
+Annie Louis, Santanu Kumar Dash, Earl T Barr, and Charles Sutton. Deep learning to detect redundant method comments. arXiv preprint arXiv:1806.04616, 2018.
+
+Minh-Thang Luong, Hieu Pham, and Christopher D Manning. Effective approaches to attentionbased neural machine translation. arXiv preprint arXiv:1508.04025, 2015.
+
+Christopher Manning, Mihai Surdeanu, John Bauer, Jenny Finkel, Steven Bethard, and David McClosky. The stanford corenlp natural language processing toolkit. In Proceedings of 52nd annual meeting of the association for computational linguistics: system demonstrations, pp. 55–60, 2014.
+
+Diego Marcheggiani and Ivan Titov. Encoding sentences with graph convolutional networks for semantic role labeling. In Proceedings of the 2017 Conference on Empirical Methods in Natural Language Processing, pp. 1506–1515, 2017.
+
+Bryan McCann, Nitish Shirish Keskar, Caiming Xiong, and Richard Socher. The natural language decathlon: Multitask learning as question answering. arXiv preprint arXiv:1806.08730, 2018.
+
+Ramesh Nallapati, Bowen Zhou, Cicero dos Santos, Caglar Gulcehre, and Bing Xiang. Abstractive text summarization using sequence-to-sequence rnns and beyond. In Proceedings of The 20th SIGNLL Conference on Computational Natural Language Learning, pp. 280–290, 2016.
+
+Shashi Narayan, Shay B Cohen, and Mirella Lapata. Ranking sentences for extractive summarization with reinforcement learning. arXiv preprint arXiv:1802.08636, 2018.
+
+Veselin Raychev, Martin Vechev, and Andreas Krause. Predicting program properties from Big Code. In Principles of Programming Languages (POPL), 2015.
+
+Abigail See, Peter J Liu, and Christopher D Manning. Get to the point: Summarization with pointergenerator networks. In Proceedings of the 55th Annual Meeting of the Association for Computational Linguistics (Volume 1: Long Papers), volume 1, pp. 1073–1083, 2017.
+
+Kai Sheng Tai, Richard Socher, and Christopher D Manning. Improved semantic representations from tree-structured long short-term memory networks. 2015.
+
+Ashish Vaswani, Noam Shazeer, Niki Parmar, Jakob Uszkoreit, Llion Jones, Aidan N Gomez, Łukasz Kaiser, and Illia Polosukhin. Attention is all you need. In Advances in Neural Information Processing Systems, pp. 5998–6008, 2017.
+
+Oriol Vinyals, Meire Fortunato, and Navdeep Jaitly. Pointer networks. In Advances in Neural Information Processing Systems, pp. 2692–2700, 2015a.
+
+Oriol Vinyals, Lukasz Kaiser, Terry Koo, Slav Petrov, Ilya Sutskever, and Geoffrey Hinton. Grammar as a foreign language. In Advances in Neural Information Processing Systems, 2015b.
+
+Yao Wan, Zhou Zhao, Min Yang, Guandong Xu, Haochao Ying, Jian Wu, and Philip S Yu. Improving automatic source code summarization via deep reinforcement learning. In Proceedings of the 33rd ACM/IEEE International Conference on Automated Software Engineering, pp. 397–407. ACM, 2018.
+
+# A CODE SUMMARIZATION SAMPLES
+
+A.1 METHODDOC
+
+# C# Sample 1
+
+public static bool TryConvertTo(object valueToConvert, Type resultType, IFormatProvider formatProvider, out object result){ result $=$ null; try{ result $=$ ConvertTo(valueToConvert, resultType, formatProvider); catch (InvalidCastException){ return false; catch (ArgumentException){ return false; } return true;   
+}
+
+# Ground truth
+
+sets result to valuetoconvert converted to resulttype considering formatprovider for custom conversions calling the parse method and calling convert . changetype .   
+converts the specified type to a primitive type .   
+sets result to resulttype   
+sets result to valuetoconvert converted to resulttype.
+
+BILSTM LSTM BILSTM+GNN $\mathbf { J } \to \mathbf { L S T N }$ M BILSTM+G $\mathbf { \ V N } \to \mathbf { L S T M } + \mathbf { \beta }$ POINTER
+
+# C# Sample 2
+
+public virtual Task Init(string name, IProviderRuntime providerRuntime, IProviderConfiguration config){ Log $=$ providerRuntime.GetLogger(this.GetType().FullName); this.serializerSettings $=$ OrleansJsonSerializer.GetDefaultSerializerSettings(); return TaskDone.Done;   
+}
+
+Ground truth BILSTM $\bf \Pi \to L S T N$ I BILSTM+G $\mathbf { \partial } _ { \mathbf { i } } \mathbf { N N } \to \mathbf { L S T M }$ BILSTM+GN $\mathbf { N } \to \mathbf { L S T }$ M+POINTER
+
+initializes the storage provider   
+creates a grain object   
+initializes the provider provider   
+initialization function to initialize the specified provider.
+
+# C# Sample 3
+
+public void NullParameter(){ TaskParameter t $=$ new TaskParameter(null); Assert.Null(t.WrappedParameter); Assert.Equal( TaskParameterType.Null , t.ParameterType ); ((INodePacketTranslatable) t).Translate( TranslationHelpers.GetWriteTranslator()); TaskParameter $\begin{array} { r l } { \pm 2 } & { { } = } \end{array}$ TaskParameter.FactoryForDeserialization( TranslationHelpers.GetReadTranslator()); Assert.Null(t2.WrappedParameter); Assert.Equal(TaskParameterType.Null, t2.ParameterType);   
+}
+
+Ground truth BILSTM LSTM BILSTM+G $\mathbf { N N } \to \mathbf { L S T M }$ BILSTM+GNN LSTM+POINTER verifies that construction and serialization with a null parameter is ok tests that the value is a value that is a value to the specified type verifies that construction with an parameter parameter verifies that construction and serialization with a parameter that is null
+
+# C# Sample 4
+
+public override DbGeometryWellKnownValue CreateWellKnownValue(DbGeometry geometryValue){ geometryValue.CheckNull("geometryValue"); var spatialValue $=$ geometryValue.AsSpatialValue(); DbGeometryWellKnownValue result $=$ CreateWellKnownValue(spatialValue,
+
+() $= >$ SpatialExceptions.CouldNotCreateWellKnownGeometryValueNoSrid("geometryValue"), () $= >$ SpatialExceptions.CouldNotCreateWellKnownGeometryValueNoWkbOrWkt("geometryValue"), (srid, wkb, wkt) $= >$ new DbGeometryWellKnownValue() { CoordinateSystemId $=$ srid, WellKnownBinary $=$ wkb, WellKnownText $=$ wkt }); return result; }
+
+Ground truth BILSTM LSTM B $\mathbf { I L S T M + G N N } \to \mathbf { L S T M }$ BILSTM+GN $\Gamma \to \mathbf { L } \mathbf { S }$ TM+POINTER
+
+creates an instance of t:system.data.spatial.dbgeometry value using one or both of the standard well known spatial formats.   
+creates a t:system.data.spatial.dbgeography value based on the specified well known binary value .   
+creates a new t:system.data.spatial.dbgeography instance using the specified well known spatial formats .   
+creates a new instance of the t:system.data.spatial.dbgeometry value based on the provided geometry value and returns the resulting well as known spatial formats .
+
+# A.2 METHODNAMING
+
+# C# Sample 1
+
+public bool _(D d) { return d ! $=$ null && d.Val == Val ;   
+}
+
+Ground truth equals BILSTM LSTM foo BILSTM+GNN LSTM equals BILSTM+ $\mathbf { G N N } \to \mathbf { L S T M } \mathbf { + P O I }$ NTER equals
+
+# C# Sample 2
+
+internal void _(string switchName, Hashtable bag, string parameterName) { object obj $=$ bag[parameterName]; if(obj ! $=$ null){ int value $=$ (int) obj; AppendSwitchIfNotNull(switchName, value.ToString(CultureInfo.InvariantCulture));   
+}
+
+Ground truth append switch with integer BILSTM LSTM set string BILSTM+GN $\ J \to \mathbf { L S T N }$ M append switch BILSTM $\mathbf { + G N N \to L S T M + P O }$ INTER append switch if not null
+
+# C# Sample 3
+
+internal static string _(){ var currentPlatformString $=$ string.Empty; if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows)){ currentPlatformString $=$ "WINDOWS"; } else if (RuntimeInformation.IsOSPlatform(OSPlatform.Linux)){ currentPlatformString $=$ "LINUX"; } else if ( RuntimeInformation.IsOSPlatform(OSPlatform.OSX)) { currentPlatformString $=$ "OSX"; } else { Assert.True(false, "unrecognized current platform"); } return currentPlatformString ;
+
+Ground truth BILSTM LSTM BILSTM+GNN LSTM BILSTM+ $\mathbf { G N N } \to \mathbf { L S T M + P O I N T }$ ER
+
+get os platform as string get name   
+get platform   
+get current platform string
+
+# C# Sample 4
+
+public override DbGeometryWellKnownValue CreateWellKnownValue(DbGeometry geometryValue){ geometryValue.CheckNull("geometryValue"); var spatialValue $=$ geometryValue.AsSpatialValue(); DbGeometryWellKnownValue result $=$ CreateWellKnownValue(spatialValue, () $= >$ SpatialExceptions.CouldNotCreateWellKnownGeometryValueNoSrid("geometryValue"), () $= >$ SpatialExceptions.CouldNotCreateWellKnownGeometryValueNoWkbOrWkt("geometryValue"), (srid, wkb, wkt) $= >$ new DbGeometryWellKnownValue () { CoordinateSystemId $=$ srid , WellKnownBinary $=$ wkb , WellKnownText $=$ wkt }); return result;   
+}
+
+Ground truth BILSTM LSTM BILSTM+GN $\ J \to \mathbf { L S T N }$ BILSTM+G $\mathbf { N N } \to \mathbf { L S T M } +$ POINTER create well known value spatial geometry from xml geometry point get well known value
+
+# Java Sample 1
+
+public static void _(String name, int expected, MetricsRecordBuilder rb) { Assert.assertEquals("Bad value for metric " $^ +$ name, expected, getIntCounter(name, rb));   
+}
+
+Ground truth assert counter BILSTM LSTM assert email value BILSTM+GNN $\ J \to \mathbf { L S T N }$ M assert header BILSTM+GNN LSTM+POINTER assert int counter
+
+B NATURAL LANGUAGE SUMMARIZATION SAMPLES  
+
+<table><tr><td rowspan=1 colspan=1>Input: -LRB- CNN -RRB- Gunshots were fired at rapper Lil Wayne &#x27;s tour bus early Sunday inAtlanta .No one was injured in the shooting ,and no arrests have been made,Atlanta Police spokeswoman Elizabeth Espy said .Police are stillooking for suspects . Ofcers were called to aparking lot in Atlanta &#x27;s Buckhead neighborhood,Espy said .They arrived at 3:25 a.m. and locatedtwo tour buses that had been shot multiple times .The drivers of the buses said the incident occurredon Interstate 285 near Interstate 75,Espy said .Witnesses provided a limited description of the twovehicles suspected to be involved : a“ Corvette style vehicle ”and an SUV .Lil Wayne was in Atlantafor a performance at Compound nightclub Saturday night . CNN &#x27;s Carma Hassan contributed to thisreport .</td></tr><tr><td rowspan=1 colspan=1>Reference: rapper lil wayne not injured after shots fired at his tour bus on an atlanta interstate ,police say . no one has been arrested in the shooting</td></tr><tr><td rowspan=1 colspan=1>See et al. (2017) (+ Pointer): police are stillooking for suspects . the incident occurred on interstate285 near interstate 75 ,police say . witnesses provided a limited description of the two vehicles suspected to be involved : a“ corvette style vehicle ” and an suv .</td></tr><tr><td rowspan=1 colspan=1>See et al. (2017) (+ Pointer + Coverage): lil wayne &#x27;s tour bus was shot multiple times , police say: police are stillooking for suspects .they arrived at 3:25 a.m. and located two tour buses that hadbeen shot .</td></tr><tr><td rowspan=1 colspan=1>BILSTM+GNN → LSTM: the incident occurred on interstate %UNK% near interstate 75 . no onewas injured in the shooting ,and no arrests have been made ,atlanta police spokeswoman says .</td></tr><tr><td rowspan=1 colspan=1>BILSTM+GNN →LSTM+PoINTER gunshots fired at rapper lil wayne &#x27;s tour bus early sundayin atlanta ,police say . no one was injured in the shooting ,and no arrests have been made , policesay.</td></tr></table>
+
+<table><tr><td rowspan=1 colspan=1>Input: Tottenham have held further discussions with Marseille over a potential deal for midfielderFlorian Thauvin .The 22-year-old has been left out of the squad for this weekend &#x27;s game withMetz as Marseille push for a f 15m sale .The winger,who can also play behind the striker, wasthe subject of enquiries from Spurs earlier in the year and has also been watched by Chelsea andValencia .Tottenham have held further talks with Ligue 1 side Marseille over a possible deal forFlorian Thauvin .Marseille are already resigned to losing Andre Ayew and Andre-Pierre Gignacwith English sides keen on both .Everton,Newcastle and Swansea,have allshown an interest inAyew,who is a free agent in the summer .</td></tr><tr><td rowspan=1 colspan=1>Reference: florian thauvin has been left out of marseille &#x27;s squad with metz . marseille are pushingfor a f 15m sale and tottenham are interested .the winger has also been watched by chelsea and laliga side valencia .</td></tr><tr><td rowspan=1 colspan=1>See et al. (2O17)(+ Pointer): tottenham have held further discussions with marseille over a potentialdeal for midfelder florian thauvin .the 22-year-old has been left out of the squad for this weekend &#x27;s game with metz as marseille push for a 15m sale .</td></tr><tr><td rowspan=1 colspan=1>See et al. (2017) (+ Pointer + Coverage): florian thauvin has been left out of the squad for thisweekend &#x27;s game with metz as marseille push for a 15m sale .the 22-year-old was the subject ofenquiries from spurs earlier in the year .</td></tr><tr><td rowspan=1 colspan=1>BILSTM+GNN →LSTM: the 22-year-old has been left out of the squad for this weekend &#x27;s gamewith metz .the 22-year-old has been left out of the squad for this weekend &#x27;s game with metz .thewinger has been left out of the squad for this weekend &#x27;s game with metz .</td></tr><tr><td rowspan=1 colspan=1>BILSTM+GNN → LSTM+PoINTER tottenham have held further discussions with marseille overa potential deal .the winger has been left out of the squad for this weekend &#x27;s game .tottenham haveheld further talks with marseille over a potential deal .</td></tr></table>
+
+# C CODE DATASETS INFORMATION
+
+# C.1 C# DATASET
+
+We extract the C# dataset from open-source projects on GitHub. Overall, our dataset contains 460,905 methods, 55,635 of which have a documentation comment. The dataset is split $8 5 - 5 - 1 0 \%$ . The projects and exact state of the repositories used is listed in Table 3
+
+Table 3: Projects in our C# dataset. Ordered alphabetically.   
+
+<table><tr><td>Name</td><td>Git SHA</td><td>Description</td></tr><tr><td>Akka.NET</td><td>6f32f6a7</td><td>Actor-based Concurrent &amp; Distributed Framework</td></tr><tr><td>AutoMapper</td><td>19d6f7fc</td><td>Object-to-Object Mapping Library</td></tr><tr><td>BenchmarkDotNet</td><td>57005f05</td><td>Benchmarking Library</td></tr><tr><td>CommonMark.NET</td><td>f3d54530</td><td>Markdown Parser</td></tr><tr><td>CoreCLR</td><td>cc5dcbe6</td><td>.NET Core Runtime</td></tr><tr><td>CoreFx</td><td>ec1671fd</td><td>.NETFoundationalLibraries</td></tr><tr><td>Dapper</td><td>3c7cde28</td><td>Object Mapper Library</td></tr><tr><td>EntityFramework</td><td>c4d9a269</td><td>Object-Relational Mapper</td></tr><tr><td>Humanizer</td><td>2b1c94c4</td><td>String Manipulation and Formatting</td></tr><tr><td>Lean</td><td>90ee6aae</td><td>Algorithmic Trading Engine</td></tr><tr><td>Mono</td><td>9b9e4f4b</td><td>.NET Implementation</td></tr><tr><td>MsBuild</td><td>7f95dc15</td><td>Build Engine</td></tr><tr><td>Nancy</td><td>de458a9b</td><td>HTTP Service Framework</td></tr><tr><td>NLog</td><td>49fdd08e</td><td>Logging Library</td></tr><tr><td>Opserver</td><td>9e4d3a40</td><td>Monitoring System</td></tr><tr><td>orleans</td><td>f89c5866</td><td>Distributed Virtual Actor Model</td></tr><tr><td>Polly</td><td>f3d2973d</td><td>Resilience &amp; Transient Fault Handling Library</td></tr><tr><td>Powershell</td><td>9ac701db</td><td>Command-line Shell</td></tr><tr><td>ravendb</td><td>6437de30</td><td>Document Database</td></tr><tr><td>roslyn</td><td>8ca0a542</td><td>Compiler &amp; Code Analysis &amp; Compilation</td></tr><tr><td>ServiceStack</td><td>17f081b9</td><td>Real-time web library</td></tr><tr><td>SignalR</td><td>9b05bcb0</td><td>Push Notification Framework</td></tr><tr><td>Wox</td><td>13e6c5ee</td><td>Application Launcher</td></tr></table>
+
+# C.2 JAVA METHOD NAMING DATASETS
+
+We use the datasets and splits of Alon et al. (2018a) provided by their website. Upon scanning all methods in the dataset, the size of the corpora can be seen in Table 4. More information can be found at Alon et al. (2018a).
+
+# C.3 PYTHON METHOD DOCUMENTATION DATASET
+
+We use the dataset as split of Barone & Sennrich (2017) provided by their GitHub repository. Upon parsing the dataset, we get 106,065 training samples, 1,943 validation samples and 1,937 test samples. We note that $1 6 . 9 \%$ of the documentation samples in the validation set and $1 5 . 3 \%$ of the samples in test set have a sample with the identical natural language documentation on the training set. This eludes to a potential issue, described by Lopes et al. (2017). See Allamanis (2018) for a lengthier discussion of this issue.
+
+Table 4: The statistics of the extracted graphs from the Java method naming dataset of Alon et al. (2018a).   
+
+<table><tr><td>Dataset</td><td>Train Size</td><td>Valid Size</td><td>Test Size</td></tr><tr><td>Java - Small</td><td>691,505</td><td>23,837</td><td>56,952</td></tr></table>
+
+# C.4 GRAPH DATA STATISTICS
+
+Below we present the data characteristics of the graphs we use across the datasets.
+
+Table 5: Graph Statistics For Datasets.   
+
+<table><tr><td>Dataset</td><td>Avg Num Nodes</td><td>Avg Num Edges</td></tr><tr><td>CNN/DM</td><td>903.2</td><td>2532.9</td></tr><tr><td>C# Method Names</td><td>125.2</td><td>239.3</td></tr><tr><td>C# Documentation</td><td>133.5</td><td>265.9</td></tr><tr><td>Java-SmallMethod Names</td><td>144.4</td><td>251.6</td></tr></table>

parse/train/H1ersoRqtm/H1ersoRqtm_content_list.json

@@ -0,0 +1,1902 @@
+[
+    {
+        "type": "text",
+        "text": "STRUCTURED NEURAL SUMMARIZATION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            98,
+            666,
+            121
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Patrick Fernandes, Miltiadis Allamanis & Marc Brockschmidt ",
+        "bbox": [
+            183,
+            143,
+            620,
+            159
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Microsoft Research   \nCambridge, United Kingdom   \n{t-pafern,miallama,mabrocks}@microsoft.com ",
+        "bbox": [
+            184,
+            161,
+            598,
+            202
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "ABSTRACT ",
+        "text_level": 1,
+        "bbox": [
+            454,
+            237,
+            544,
+            252
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Summarization of long sequences into a concise statement is a core problem in natural language processing, requiring non-trivial understanding of the input. Based on the promising results of graph neural networks on highly structured data, we develop a framework to extend existing sequence encoders with a graph component that can reason about long-distance relationships in weakly structured data such as text. In an extensive evaluation, we show that the resulting hybrid sequence-graph models outperform both pure sequence models as well as pure graph models on a range of summarization tasks. ",
+        "bbox": [
+            233,
+            280,
+            766,
+            391
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 INTRODUCTION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            444,
+            336,
+            460
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Summarization, the task of condensing a large and complex input into a smaller representation that retains the core semantics of the input, is a classical task for natural language processing systems. Automatic summarization requires a machine learning component to identify important entities and relationships between them, while ignoring redundancies and common concepts. ",
+        "bbox": [
+            174,
+            484,
+            825,
+            540
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Current approaches to summarization are based on the sequence-to-sequence paradigm over the words of some text, with a sequence encoder — typically a recurrent neural network, but sometimes a 1D-CNN (Narayan et al., 2018) or using self-attention (McCann et al., 2018) — processing the input and a sequence decoder generating the output. Recent successful implementations of this paradigm have substantially improved performance by focusing on the decoder, extending it with an attention mechanism over the input sequence and copying facilities (See et al., 2017; McCann et al., 2018). However, while standard encoders (e.g. bidirectional LSTMs) theoretically have the ability to handle arbitrary long-distance relationships, in practice they often fail to correctly handle long texts and are easily distracted by simple noise (Jia & Liang, 2017). ",
+        "bbox": [
+            174,
+            547,
+            825,
+            674
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "In this work, we focus on an improvement of sequence encoders that is compatible with a wide range of decoder choices. To mitigate the long-distance relationship problem, we draw inspiration from recent work on highly-structured objects (Li et al., 2015; Kipf & Welling, 2017; Gilmer et al., 2017; Allamanis et al., 2018; Cvitkovic et al., 2018). In this line of work, highly-structured data such as entity relationships, molecules and programs is modelled using graphs. Graph neural networks are then successfully applied to directly learn from these graph representations. Here, we propose to extend this idea to weakly-structured data such as natural language. Using existing tools, we can annotate (accepting some noise) such data with additional relationships (e.g. co-references) to obtain a graph. However, the sequential aspect of the input data is still rich in meaning, and thus we propose a hybrid model in which a standard sequence encoder generates rich input for a graph neural network. In our experiments, the resulting combination outperforms baselines that use pure sequence or pure graph-based representations. ",
+        "bbox": [
+            174,
+            680,
+            825,
+            847
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Briefly, the contributions of our work are: 1. A framework that extends standard sequence encoder models with a graph component that leverages additional structure in sequence data. 2. Application of this extension to a range of existing sequence models and an extensive evaluation on three summarization tasks from the literature. 3. We release all used code and data at https://github.com/CoderPat/structured-neural-summarization. ",
+        "bbox": [
+            174,
+            854,
+            825,
+            922
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "public void Add(string name, object value $=$ null, DbType? dbType $=$ null, ParameterDirection? direction $=$ null, int? size $=$ null, byte? precision $=$ null, byte? scale $=$ null) { parameters[Clean(name) $] =$ new ParamInfo{ Name $=$ name, Value $=$ value, ParameterDirection $=$ direction ?? ParameterDirection.Input, DbType $=$ dbType, Size $=$ size, Precision $=$ precision, Scale $=$ scale };} ",
+        "bbox": [
+            173,
+            108,
+            808,
+            210
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Ground truth: BILSTM LSTM: $\\mathbf { B I L S T M + G N N } \\to \\mathbf { L S T M } .$ : $\\mathbf { B I L S T M + G N N } \\to \\mathbf { L S T M + P O I N T E R }$ : ",
+        "bbox": [
+            183,
+            224,
+            426,
+            275
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "add a parameter to this dynamic parameter list adds a new parameter to the specified parameter creates a new instance of the dynamic type specified add a parameter to a list of parameters ",
+        "bbox": [
+            442,
+            224,
+            753,
+            275
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Figure 1: An example from the dataset for the METHODDOC source code summarization task along with the outputs of a baseline and our models. In the METHODNAMING dataset, this method appears as a sample requiring to predict the name Add as a subtoken sequence of length 1. ",
+        "bbox": [
+            174,
+            281,
+            821,
+            324
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2 STRUCTURED SUMMARIZATION TASKS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            359,
+            531,
+            376
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "In this work, we consider three summarization tasks with different properties. All tasks follow the common pattern of translating a long (structured) sequence into a shorter sequence while trying to preserve as much meaning as possible. The first two tasks are related to the summarization of source code (Figure 1), which is highly structured and thus can profit most from models that can take advantage of this structure; the final task is a classical natural language task illustrating that hybrid sequence-graph models are applicable for less structured inputs as well. ",
+        "bbox": [
+            174,
+            397,
+            825,
+            481
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "METHODNAMING The aim of this task is to infer the name of a function (or method in objectoriented languages, such as Java, Python and C#) given its source code (Allamanis et al., 2016). Although method names are a single token, they are usually composed of one or more subtokens (split using snake case or camelCase) and thus, the method naming task can be cast as predicting a sequence of subtokens. Consequently, method names represent an “extreme” summary of the functionality of a given function (on average, the names in the Java dataset have only 2.9 subtokens). Notably, the vocabulary of tokens used in names is very large (due to abbreviations and domainspecific jargon), but this is mitigated by the fact that $33 \\%$ of subtokens in names can be copied directly from subtokens in the method’s source code. Finally, source code is highly structured input data with known semantics, which can be exploited to support name prediction. ",
+        "bbox": [
+            174,
+            507,
+            826,
+            647
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "METHODDOC Similar to the first task, the aim of this task is to predict a succinct description of the functionality of a method given its source code (Barone & Sennrich, 2017). Such descriptions usually appear as documentation of methods (e.g. “docstrings” in Python or “JavaDocs” in Java). While the task shares many characteristics with the METHODNAMING task, the target sequence is substantially longer (on average 19.1 tokens in our C# dataset) and only $1 9 . 4 \\%$ of tokens in the documentation can be copied from the code. While method documentation is nearer to standard natural language than method names, it mixes project-specific jargon, code segments and often describes non-functional aspects of the code, such as performance characteristics and design considerations. ",
+        "bbox": [
+            174,
+            674,
+            825,
+            785
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "NLSUMMARIZATION Finally, we consider the classic summarization of natural language as widely studied in NLP research. Specifically, we are interested in abstractive summarization, where given some text input (e.g. a news article) a machine learning model produces a novel natural language summary. Traditionally, NLP summarization methods treat text as a sequence of sentences and each one of them as a sequence of words (tokens). The input data has less explicitly defined structure than our first two tasks. However, we recast the task as a structured summarization problem by considering additional linguistic structure, including named entities and entity coreferences as inferred by existing NLP tools. ",
+        "bbox": [
+            174,
+            811,
+            825,
+            924
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "3 MODEL ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            102,
+            267,
+            117
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "As discussed above, standard neural approaches to summarization follow the sequence-to-sequence framework. In this setting, most decoders only require a representation $^ { h }$ of the complete input sequence (e.g. the final state of an RNN) and per-token representations $h _ { t _ { i } }$ for each input token $t _ { i }$ These token representations are then used as the “memories” of an attention mechanism (Bahdanau et al., 2014; Luong et al., 2015) or a pointer network (Vinyals et al., 2015a). ",
+        "bbox": [
+            174,
+            133,
+            825,
+            204
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "In this work, we propose an extension of sequence encoders that allows us to leverage known (or inferred) relationships among elements in the input data. To achieve that, we combine sequence encoders with graph neural networks (GNNs) (Li et al., 2015; Gilmer et al., 2017; Kipf & Welling, 2017). For this, we first use a standard sequential encoder (e.g. bidirectional RNNs) to obtain a pertoken representation $h _ { t _ { i } }$ , which we then feed into a GNN as the initial node representations. The resulting per-node (i.e. per-token) representations $\\boldsymbol { h } _ { t _ { i } } ^ { \\prime }$ can then be used by an unmodified decoder. Experimentally, we found this to surpass models that use either only the sequential structure or only the graph structure (see Sect. 4). We now discuss the different parts of our model in detail. ",
+        "bbox": [
+            173,
+            210,
+            826,
+            321
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Gated Graph Neural Networks To process graphs, we follow Li et al. (2015) and briefly summarize the core concepts of GGNNs here. A graph $\\mathcal { G } = ( \\nu , \\pmb { \\varepsilon } , \\pmb { X } )$ is composed of a set of nodes $\\nu$ , node features $\\boldsymbol { X }$ , and a list of directed edge sets ${ \\pmb { \\mathcal { E } } } = ( { \\mathcal { E } } _ { 1 } , \\dots , { \\mathcal { E } } _ { K } )$ where $K$ is the number of edge types. Each $v \\in \\nu$ is associated with a real-valued vector $\\scriptstyle { \\mathbf { { \\mathit { x } } } } _ { \\mathit { v } }$ representing the features of the node (e.g., the embedding of a string label of that node), which is used for the initial state ${ h } _ { v } ^ { ( 0 ) }$ of a node. ",
+        "bbox": [
+            174,
+            338,
+            825,
+            411
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Information is propagated through the graph using neural message passing (Gilmer et al., 2017). For this, every node $v$ sends messages to its neighbors by transforming its current representation $\\boldsymbol { h } _ { v } ^ { ( i ) }$ using an edge-type dependent function $f _ { k }$ . Here, $f _ { k }$ can be an arbitrary function; we use a simple linear layer. By computing all messages at the same time, all states can be updated simultaneously. In particular, a new state for a node $v$ is computed by aggregating all incoming messages as $m _ { v } ^ { ( i ) } = \\bar { g } ( \\{ f _ { k } ( h _ { u } ^ { ( i ) } ) \\} )$ there is an edge of type $k$ from $u$ to $v \\}$ ). $g$ is an aggregation function; we use elementwise summation for $g$ . Given the aggregated message $\\mathbf { \\it { m } } _ { v } ^ { ( i ) }$ and the current state vector $\\boldsymbol { h } _ { v } ^ { ( i ) }$ of node $v$ , we can compute the new state 1) = GRU(m(i)v , h(i)v ), where GRU is the recurrent cell function of a gated recurrent unit. These dynamics are rolled out for a fixed number of timesteps $T$ , and the state vectors resulting from the final step are used as output node representations, i.e., $\\mathrm { G N N } ( ( \\mathcal { V } , \\pmb { \\mathcal { E } } , X ) ) = \\{ \\pmb { h } _ { v } ^ { ( T ) } \\} _ { v \\in \\mathcal { V } }$ . ",
+        "bbox": [
+            173,
+            417,
+            826,
+            588
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Sequence GNNs We now explain our novel combination of GGNNs and standard sequence encoders. As input, we take a sequence $\\boldsymbol { S } = \\left[ s _ { 1 } \\ldots s _ { N } \\right]$ and $K$ binary relationships $R _ { 1 } \\ldots R _ { K } \\in S \\times S$ between elements of the sequence. For example, $R _ { = }$ could be the equality relationship $\\left\\{ \\left( s _ { i } , s _ { j } \\right) \\right. \\mid$ $s _ { i } = s _ { j } \\}$ . The choice and construction of relationships is dataset-dependent, and will be discussed in detail in Sect. 4. Given any sequence encoder $\\mathcal { S E }$ that maps $S$ to per-element representations $\\left[ \\mathbf { e } _ { 1 } \\ldots \\mathbf { e } _ { N } \\right]$ and a sequence representation e (e.g. a bidirectional RNN), we can construct the sequence GNN $\\mathcal { S } \\mathcal { E } _ { G N N }$ by simply computing $\\mathbf { \\bar { e } } _ { 1 } ^ { \\prime } \\cdot \\cdot \\cdot \\mathbf { e } _ { N } ^ { \\prime } ] = \\mathbf { G N N } ( ( S , [ R _ { 1 } \\dots R _ { K } ] , [ \\mathbf { e } _ { 1 } \\dots \\mathbf { e } _ { N } ] ) )$ . To obtain a graph-level representation, we use the weighted averaging mechanism from Gilmer et al. (2017). Concretely, for each node $v$ in the graph, we compute a weight $\\sigma ( w ( \\pmb { h } _ { v } ^ { ( T ) } ) ) \\in [ 0 , 1 ]$ using a learnable function $w$ and the logistic sigmoid $\\sigma$ and compute a graph-level representation as $\\begin{array} { r } { \\hat { \\mathbf { e } } \\equiv \\sum _ { 1 \\leq i \\leq N } \\sigma ( w ( \\mathbf { e } _ { i } ^ { \\prime } ) ) \\cdot \\mathbb { N } ( \\mathbf { e } _ { i } ^ { \\prime } ) } \\end{array}$ , where $\\aleph$ is another learnable projection function. We found that best results were achieved by computing the final $\\mathbf { e ^ { \\prime } }$ as $W \\cdot ( \\mathbf { e } \\hat { \\mathbf { e } } )$ for some learnable matrix $W$ . ",
+        "bbox": [
+            173,
+            603,
+            826,
+            775
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "This method can easily be extended to support additional nodes not present in the original sequence $S$ after running $\\mathcal { S E }$ (e.g., to accommodate meta-nodes representing sentences, or non-terminal nodes from a syntax tree). The initial node representation for these additional nodes can come from other sources, such as a simple embedding of their label. ",
+        "bbox": [
+            174,
+            781,
+            825,
+            837
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Implementation Details. Processing large graphs of different shapes efficiently requires to overcome some engineering challenges. For example, the CNN/DM corpus has (on average) about 900 nodes per graph. To allow efficient computation, we use the trick of Allamanis et al. (2018) where all graphs in a minibatch are “flattened” into a single graph with multiple disconnected components. The varying graph sizes also represent a problem for the attention and copying mechanisms in the decoder, as they require to compute a softmax over a variable-sized list of memories. To handle this efficiently without padding, we associate each node in the (flattened) “batch” graph with the index of the sample in the minibatch from which the node originated. Then, using TensorFlow’s unsorted segment $\\mathbf { \\nabla } _ { \\cdot } \\star$ operations, we can perform an efficient and numerically stable softmax over the variable number of representations of the nodes of each graph. ",
+        "bbox": [
+            174,
+            853,
+            825,
+            924
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            103,
+            825,
+            174
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "4 EVALUATION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            195,
+            315,
+            212
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "4.1 QUANTITATIVE EVALUATION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            227,
+            415,
+            242
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "We evaluate Sequence GNNs on our three tasks by comparing them to models that use only sequence or graph information, as well as by comparing them to task-specific baselines. We discuss the three tasks, their respective baselines and how we present the data to the models (including the relationships considered in the graph component) next before analyzing the results. ",
+        "bbox": [
+            174,
+            253,
+            825,
+            309
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "4.1.1 SETUP FOR METHODNAMING ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            327,
+            433,
+            340
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Datasets, Metrics, and Models. We consider two datasets for the METHODNAMING task. First, we consider the “Java (small)” dataset of Alon et al. (2018a), re-using the train-validation-test splits they have picked. We additionally generated a new dataset from 23 open-source C# projects mined from GitHub (see below for the reasons for this second dataset), removing any duplicates. More information about these datasets can be found in Appendix C. We follow earlier work on METHODNAMING (Allamanis et al., 2016; Alon et al., 2018a) and measure performance using the F1 score over the generated subtokens. However, since the task can be viewed as a form of (extreme) summarization, we also report ROUGE-2 and ROUGE-L scores (Lin, 2004), which we believe to be additional useful indicators for the quality of results. ROUGE-1 is omitted since it is equivalent to F1 score. We note that there is no widely accepted metric for this task and further work identifying the most appropriate metric is required. ",
+        "bbox": [
+            174,
+            351,
+            826,
+            503
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "We compare to the current state of the art (Alon et al., 2018a), as well as a sequence-to-sequence implementation from the OpenNMT project (Klein et al.). Concretely, we combine two encoders (a bidirectional LSTM encoder with 1 layer and 256 hidden units, and its sequence GNN extension with 128 hidden units unrolled over 8 timesteps) with two decoders (an LSTM decoder with 1 layer and 256 hidden units with attention over the input sequence, and an extension using a pointer network-style copying mechanism (Vinyals et al., 2015a)). Additionally, we consider self-attention as an alternative to RNN-based sequence encoding architectures. For this, we use the Transformer (Vaswani et al., 2017) implementation in OpenNMT (i.e., using self-attention both for the decoder and the encoder) as a baseline and compare it to a version whose encoder is extended with a GNN component. ",
+        "bbox": [
+            174,
+            511,
+            825,
+            636
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Data Representation Following the work of Allamanis et al. (2016); Alon et al. (2018a), we break up all identifier tokens (i.e. variables, methods, classes, etc.) in the source code into subtokens by splitting them according to camelCase and pascal case heuristics. This allows the models to extract information from the information-rich subtoken structure, and ensures that a copying mechanism in the decoder can directly copy relevant subtokens, something that we found to be very effective for this task. All models are provided with all (sub)tokens belonging to the source code of a method, including its declaration, with the actual method name replaced by a placeholder symbol. ",
+        "bbox": [
+            174,
+            651,
+            825,
+            750
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "To construct a graph from the (sub)tokens, we implement a simplified form of the work of Allamanis et al. (2018). First, we introduce additional nodes for each (full) identifier token, and connect the constituent subtokens appearing in the input sequence using a INTOKEN edge; we additionally connect these nodes using a NEXTTOKEN edge. We also add nodes for the parse tree and use edges to indicate that one node is a CHILD of another. Finally, we add LASTLEXICALUSE edges to connect identifiers to their most (lexically) recent use in the source code. ",
+        "bbox": [
+            174,
+            757,
+            825,
+            840
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "4.1.2 SETUP FOR METHODDOC ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            856,
+            405,
+            871
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Datasets, Metrics, and Models. We tried to evaluate on the Python dataset of Barone & Sennrich (2017) that contains pairs of method declarations and their documentation (“docstring”). However, following the work of Lopes et al. (2017), we found extensive duplication between different folds of the dataset and were only able to reach comparable results by substantially overfitting to the training data that overlapped with the test set. We have documented details in subsection C.3 and in Allamanis (2018), and decided to instead evaluate on our new dataset of 23 open-source C# projects from above, again removing duplicates and methods without documentation. Following Barone & Sennrich (2017), we measure the BLEU score for all models. However, we also report F1, ROUGE-2 and ROUGE-L scores, which should better reflect the summarization aspect of the task. We consider the same models as for the METHODNAMING task, using the same configuration, and use the same data representation. ",
+        "bbox": [
+            176,
+            882,
+            825,
+            924
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "image",
+        "img_path": "images/0f24ece1ecd933d082df2284a4d3190ac4a48d4c10138fc5c01fc0d240b7a43f.jpg",
+        "image_caption": [
+            "Figure 2: (Partial) graph of an example input from the CNN/DM corpus. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            173,
+            99,
+            826,
+            266
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            333,
+            825,
+            445
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "4.1.3 SETUP FOR NLSUMMARIZATION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            481,
+            452,
+            494
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Datasets, Metrics, and Models. We use the CNN/DM dataset (Hermann et al., 2015) using the exact data and split provided by See et al. (2017). The data is constructed from CNN and Daily Mail news articles along with a few sentences that summarize each article. To measure performance, we use the standard ROUGE metrics. We compare our model with the near-to-state-of-the-art work of See et al. (2017), who use a sequence-to-sequence model with attention and copying as basis, but have additionally substantially improved the decoder component. As our contribution is entirely on the encoder side and our model uses a standard sequence decoder, we are not expecting to outperform more recent models that introduce substantial novelty in the structure or training objective of the decoder (Chen & Bansal, 2018; Narayan et al., 2018). Again, we evaluate our contribution using an OpenNMT-based encoder/decoder combination. Concretely, we use a bidirectional LSTM encoder with 1 layer and 256 hidden units, and its sequence GNN extension with 128 hidden units unrolled over 8 timesteps. As decoder, we use an LSTM with 1 layer and 256 hidden units with attention over the input sequence, and an extension using a pointer network-style copying mechanism. ",
+        "bbox": [
+            173,
+            512,
+            825,
+            694
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Data Representation We use Stanford CoreNLP (Manning et al., 2014) (version 3.9.1) to tokenize the text and provide the resulting tokens to the encoder. For the graph construction (Figure 2), we extract the named entities and run coreference resolution using CoreNLP. We connect tokens using a NEXT edge and introduce additional super-nodes for each sentence, connecting each token to the corresponding sentence-node using a IN edge. We also connect subsequent sentence-nodes using a NEXT edge. Then, for each multi-token named entity we create a new node, labeling it with the type of the entity and connecting it with all tokens referring to that entity using an IN edge. Finally, coreferences of entities are connected with a special REF edge. Figure 2 shows a partial graph for an article in the CNN/DM dataset. The goal of this graph construction process is to explicitly annotate important relationships that can be useful for summarization. We note that (a) in early efforts we experimented with adding dependency parse edges, but found that they do not provide significant benefits and (b) that since we retrieve the annotations from CoreNLP, they can contain errors and thus, the performance of the our method is influenced by the accuracy of the upstream annotators of named entities and coreferences. ",
+        "bbox": [
+            174,
+            729,
+            825,
+            922
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "table",
+        "img_path": "images/9736507d854d7ae3d25c3d066f5e08fa8e12e5b33e3fbe97e7e9b348dd2f9e0d.jpg",
+        "table_caption": [
+            "Table 1: Evaluation results for all models and tasks. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>METHODNAMING</td><td>F1</td><td>ROUGE-2</td><td>ROUGE-L</td></tr><tr><td>Java</td><td></td><td></td><td></td></tr><tr><td>Alon et al. (2018a)</td><td>43.0</td><td>一</td><td>1</td></tr><tr><td>SELFATT →SELFATT</td><td>24.9</td><td>8.3</td><td>27.4</td></tr><tr><td>SELFATT+GNN →SELFATT</td><td>44.5</td><td>20.9</td><td>43.4</td></tr><tr><td>BILSTM →LSTM</td><td>35.8</td><td>17.9</td><td>39.7</td></tr><tr><td>BILSTM+GNN →LSTM</td><td>44.7</td><td>21.1</td><td>43.1</td></tr><tr><td>BILSTM →LSTM+POINTER</td><td>42.5</td><td>22.4</td><td>45.6</td></tr><tr><td>GNN →LSTM+POINTER</td><td>50.5</td><td>24.8</td><td>48.9</td></tr><tr><td>BILSTM+GNN→LSTM+POINTER</td><td>51.4</td><td>25.0</td><td>50.0</td></tr><tr><td>C#</td><td></td><td></td><td></td></tr><tr><td>SELFATT →SELFATT</td><td>41.3</td><td>25.2</td><td>43.2</td></tr><tr><td>SELFATT+GNN→→SELFATT</td><td>62.1</td><td>31.0</td><td>61.1</td></tr><tr><td>BILSTM →LSTM</td><td>48.8</td><td>32.8</td><td>51.8</td></tr><tr><td>BILSTM+GNN →LSTM</td><td>62.6</td><td>31.0</td><td>61.3</td></tr><tr><td>BILSTM →LSTM+POINTER</td><td>57.2</td><td>29.7</td><td>60.4</td></tr><tr><td>GNN→LSTM+POINTER</td><td>63.0</td><td>31.5</td><td>61.3</td></tr><tr><td>BILSTM+GNN→LSTM+POINTER</td><td>63.4</td><td>31.9</td><td>62.4</td></tr><tr><td>METHODDOC</td><td>F1</td><td>ROUGE-2</td><td>ROUGE-L</td><td>BLEU</td></tr><tr><td>C#</td><td></td><td></td><td></td><td></td></tr><tr><td>SELFATT →SELFATT</td><td>40.0</td><td>27.8</td><td>41.1</td><td>13.9</td></tr><tr><td>SELFATT+GNN→SELFATT</td><td>37.6</td><td>25.6</td><td>37.9</td><td>21.4</td></tr><tr><td>BILSTM →LSTM</td><td>35.2</td><td>15.3</td><td>30.8</td><td>10.0</td></tr><tr><td>BILSTM+GNN →LSTM</td><td>41.1</td><td>28.9</td><td>41.0</td><td>22.5</td></tr><tr><td>BILSTM →LSTM+POINTER</td><td>35.2</td><td>20.8</td><td>36.7</td><td>14.7</td></tr><tr><td>GNN →LSTM+POINTER</td><td>38.9</td><td>25.6</td><td>37.1</td><td>17.7</td></tr><tr><td>BILSTM+GNN →→LSTM+POINTER (average pooling)</td><td>43.2</td><td>29.0</td><td>41.0</td><td>21.3</td></tr><tr><td>BILSTM+GNN→LSTM+POINTER</td><td>45.4</td><td>28.3</td><td>41.1</td><td>22.2</td></tr><tr><td>NLSUMMARIZATION</td><td>ROUGE-1</td><td>ROUGE-2</td><td>ROUGE-L</td><td></td></tr><tr><td>CNN/DM</td><td></td><td></td><td></td><td></td></tr><tr><td>BILSTM →LSTM</td><td>33.6</td><td>11.4</td><td>27.9</td><td></td></tr><tr><td>BILSTM+GNN→LSTM</td><td>33.0</td><td>13.3</td><td>28.3</td><td></td></tr><tr><td>See et al. (2017) (+ Pointer)</td><td>36.4</td><td>15.7</td><td>33.4</td><td></td></tr><tr><td>BILSTM →LSTM+POINTER</td><td>35.9</td><td>13.9</td><td>30.3</td><td></td></tr><tr><td>BILSTM+GNN →LSTM+POINTER</td><td>38.1</td><td>16.1</td><td>33.2</td><td></td></tr><tr><td>See et al. (2017) (+ Pointer + Coverage)</td><td>39.5</td><td>17.3</td><td>36.4</td><td></td></tr><tr><td></td><td></td><td></td><td></td><td></td></tr></table>",
+        "bbox": [
+            171,
+            119,
+            834,
+            617
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "4.1.4 RESULTS & ANALYSIS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            645,
+            385,
+            660
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "We show all results in Tab. 1. Results for models from the literature are taken from the respective papers and repeated here. Across all tasks, the results show the advantage of our hybrid sequence GNN encoders over pure sequence encoders. ",
+        "bbox": [
+            174,
+            672,
+            825,
+            714
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "On METHODNAMING, we can see that all GNN-augmented models are able to outperform the current specialized state of the art, requiring only simple graph structure that can easily be obtained using existing parsers for a programming language. The results in performance between the different encoder and decoder configurations nicely show that their effects are largely orthogonal. ",
+        "bbox": [
+            174,
+            722,
+            825,
+            777
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "On METHODDOC, the unmodified SELFATT $ s$ ELFATT model already performs quite well, and the augmentation with graph data only improves the BLEU score and worsens the results on ROUGE. Inspection of the results shows that this is due to the length of predictions. Whereas the ground truth data has on average 19 tokens in each result, SELFATT $ s$ ELFATT predicts on average 11 tokens, and SELFATT+GNN SELFATT 16 tokens. Additionally, we experimented with an ablation in which a model is only using graph information, e.g., a setting comparable to a simplification of the architecture of Allamanis et al. (2018). For this, we configured the GNN to use 128-dimensional representations and unrolled it for 10 timesteps, keeping the decoder configuration as for the other models. The results indicate that this configuration performs less well than a pure sequenced model. We speculate that this is mainly due to the fact that 10 timesteps are insufficient to propagate inforpublic static bool TryFormat(float value, Span<byte> destination, out int bytesWritten, StandardFormat format $=$ default) { return TryFormatFloatingPoint<float>(value, destination, out bytesWritten, format); } ",
+        "bbox": [
+            174,
+            785,
+            825,
+            924
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "table",
+        "img_path": "images/8265df601c5ba5ef05dfa6c6e0c8c05477fe004786c78230eb7168e068ff09b8.jpg",
+        "table_caption": [
+            "Table 2: Ablations on CNN/DM Corpus "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>NLSUMMARIZATION (CNN/DM)</td><td>ROUGE-1</td><td>ROUGE-2</td><td>ROUGE-L</td></tr><tr><td>See et al.(2017) (base)</td><td>31.3</td><td>11.8</td><td>28.8</td></tr><tr><td>See et al. (2017) (+ Pointer)</td><td>36.4</td><td>15.7</td><td>33.4</td></tr><tr><td>See et al.(2017) (+ Pointer + Coverage)</td><td>39.5</td><td>17.3</td><td>36.4</td></tr><tr><td>BILSTM →LSTM</td><td>33.6</td><td>11.4</td><td>27.9</td></tr><tr><td>BILSTM →LSTM+POINTER</td><td>35.9</td><td>13.9</td><td>30.3</td></tr><tr><td>BILSTM →LSTM+PoINTER (+ coref/entity annotations)</td><td>36.2</td><td>14.2</td><td>30.5</td></tr><tr><td>BILSTM+GNN →LSTM</td><td>33.0</td><td>13.3</td><td>28.3</td></tr><tr><td>BILSTM+GNN→LSTM+POINTER (only sentence nodes)</td><td>36.0</td><td>15.2</td><td>29.6</td></tr><tr><td>BILSTM+GNN →LSTM+POINTER (sentence nodes + eq edges)</td><td>36.1</td><td>15.4</td><td>30.3</td></tr><tr><td>BILSTM+GNN→LSTM+POINTER</td><td>38.1</td><td>16.1</td><td>33.2</td></tr></table>",
+        "bbox": [
+            173,
+            121,
+            821,
+            282
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            176,
+            309,
+            767,
+            361
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Ground truth BILSTM LSTM BILST $\\mathbf { M } \\mathbf { + } \\mathbf { G N N } \\to \\mathbf { L S T M }$ B $\\mathbf { \\mathbf { \\mathbf { I L S T M + G N N } } } \\mathbf { \\mathbf { \\Phi } } \\to \\mathbf { \\mathbf { \\mathbf { L S T M + P O I N T E R } } }$ formats a single as a utf8 string formats a number of bytes in a utf8 string formats a timespan as a utf8 string formats a float as a utf8 string ",
+        "bbox": [
+            183,
+            376,
+            423,
+            425
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            441,
+            375,
+            686,
+            426
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Figure 3: An example from the dataset for the METHODDOC source code summarization task along with the outputs of a baseline and our models. ",
+        "bbox": [
+            173,
+            433,
+            821,
+            462
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "mation across the whole graph, especially in combination with summation as aggregation function for messages in graph information propagation. ",
+        "bbox": [
+            174,
+            501,
+            823,
+            529
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Finally, on NLSUMMARIZATION, our experiments show that the same model suitable for tasks on highly structured code is competitive with specialized models for natural language tasks. While there is still a gap to the best configuration of See et al. (2017) (and an even larger one to more recent work in the area), we believe that this is entirely due to our simplistic decoder and training objective, and that our contribution can be combined with these advances. ",
+        "bbox": [
+            174,
+            535,
+            825,
+            604
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "In Table 2 we show some ablations for NLSUMMARIZATION. As we use the same hyperparameters across all datasets and tasks, we additionally perform an experiment with the model of See et al. (2017) (as implemented in OpenNMT) but using our settings. The results achieved by these baselines trend to be a bit worse than the results reported in the original paper, which we believe is due to a lack of hyperparameter optimization for this task. We then evaluated how much the additional linguistic structure provided by CoreNLP helps. First, we add the coreference and entity annotations to the baseline $\\mathrm { B I L S T M } \\to \\mathrm { L S T M } + \\mathrm { P O I N T E R }$ model (by extending the embedding of tokens with an embedding of the entity information, and inserting fresh $\\mathrm {  ~ \\omega ~ } _ { \\mathrm { i R E F 1 } } \\mathrm {  ~ \\omega ~ }$ ”, . . . tokens at the sources/targets of co-references) and observe only minimal improvements. This suggests that our graph-based encoder is better-suited to exploit additional structured information compared to a biLSTM encoder. We then drop all linguistic structure information from our model, keeping only the sentence edges/nodes. This still improves on the baseline $\\mathrm { B I L S T M } \\to \\mathrm { L S T M } + \\mathrm { P O I I }$ NTER model (in the ROUGE-2 score), suggesting that the GNN still yields improvements in the absence of linguistic structure. Finally, we add long-range dependency edges by connecting tokens with equivalent string representations of their stems and observe further minor improvements, indicating that even using only purely syntactical information, without a semantic parse, can already provide gains. ",
+        "bbox": [
+            174,
+            612,
+            825,
+            834
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "4.2 QUALITATIVE EVALUATION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            864,
+            405,
+            878
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "We look at a few sample suggestions in our dataset across the tasks. Here we highlight some observations we make that point out interesting aspects and failure cases of our model. ",
+        "bbox": [
+            176,
+            895,
+            823,
+            924
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "table",
+        "img_path": "images/879ad0593963ca3e074145df80c378944913e18c84b695b9649622deeb04970e.jpg",
+        "table_caption": [
+            "Figure 4: Sample natural language translations from the CNN-DM dataset. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=1 colspan=1>Input: Arsenal,Newcastle United and Southampton have checked on Caen midfelder N&#x27;golo Kante .Paris-born Kante is a defensive minded player who has impressed for Caen this season and they are wiling to sellfor around f 5milion.Marseille have been in constant contact with Caen over signing the 24-year-old who has similarities with Lassna Diarra and Claude Makelele in terms of stature and style .N&#x27;Golo Kante is attractinginterest froma host of PremierLeague clubs including Arsenal.Caen would be wiling to sellKante for aroundf5million.</td></tr><tr><td rowspan=1 colspan=1>Reference:n&#x27;golo kante is wanted by arsenal,newcastle and southampton.marseille are also keen on thef5mrated midfielder.kante has been compared to lassana diarra and claude makelele.click here for the latestpremier league news .</td></tr><tr><td rowspan=1 colspan=1>See et al.(2O17) (+ Pointer): arsenal,newcastle united and southampton have checked on caen midfieldern&#x27;golo kante .paris-born kante is attracting interest from a host of premier league clubs including arsenal .paris-born kante is attracting interest from a host of premier league clubs including arsenal</td></tr><tr><td rowspan=1 colspan=1>See et al. (2O17)(+ Pointer + Coverage): arsenal, newcastle united and southampton have checked on caenmidfielder n&#x27;golo kante.paris-born kante is a defensive minded player who has impressed for caen this season.marseille have been in constant contact with caen over signing the 24-year-old .</td></tr><tr><td rowspan=1 colspan=1>BILSTM+GNN →LSTM: marseille have been linked with caen midfielder %UNK% %UNK% . marseillehave been interested from a host of premier league clubs including arsenal .caen have been interested from ahost of premier league clubs including arsenal .</td></tr><tr><td rowspan=1 colspan=1>BILSTM+GNN →LSTM+PoINTER n&#x27;golo kante is attracting interest from a host of premier league clubs .marseilehave been in constant contact with caen over signing the24-year-old.the 24-year-old has similaritieswith lassana diarra and claude makelele in terms of stature .</td></tr></table>",
+        "bbox": [
+            173,
+            102,
+            841,
+            406
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "METHODDOC Figures 1 and 3 illustrate typical results of baselines and our model on the METHODDOC task (see Appendix A for more examples). The hardness of the task stems from the large number of distractors and the need to identify the most relevant parts of the input. In Figure 1, the token “parameter” and variations appears many times, and identifying the correct relationship is non-trivial, but is evidently eased by graph edges explicitly denoting these relationships. Similarly, in Figure 3, many variables are passed around, and the semantics of the method require understanding how information flows between them. ",
+        "bbox": [
+            174,
+            464,
+            825,
+            561
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "NLSUMMARIZATION Figure 4 shows one sample summarization. More samples for this task can be found in Appendix B. First, we notice that the model produces natural-looking summaries with no noticeable negative impact on the fluency of the language over existing methods. Furthermore, the GNN-based model seems to capture the central named entity in the article and creates a summary centered around that entity. We hypothesize that the GNN component that links long-distance relationships helps capture and maintain a better “global” view of the article, allowing for better identification of central entities. Our model still suffers from repetition of information (see Appendix B), and so we believe that our model would also profit from advances such as taking coverage into account (See et al., 2017) or optimizing for ROUGE-L scores directly via reinforcement learning (Chen & Bansal, 2018; Narayan et al., 2018). ",
+        "bbox": [
+            174,
+            583,
+            826,
+            723
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "5 RELATED WORK ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            750,
+            344,
+            765
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Natural language processing research has studied summarization for a long time. Most related is work on abstractive summarization, in which the core content of a given text (usually a news article) is summarized in a novel and concise sentence. Chopra et al. (2016) and Nallapati et al. (2016) use deep learning models with attention on the input text to guide a decoder that generates a summary. See et al. (2017) and McCann et al. (2018) extend this idea with pointer networks (Vinyals et al., 2015a) to allow for copying tokens from the input text to the output summary. These approaches treat text as a simple token sequences, not explicitly exposing additional structure. In principle, deep sequence networks are known to be able to learn the inherent structure of natural language (e.g. in parsing (Vinyals et al., 2015b) and entity recognition (Lample et al., 2016)), but our experiments indicate that explicitly exposing this structure by separating concerns improves performance. ",
+        "bbox": [
+            174,
+            785,
+            825,
+            924
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Recent work in summarization has proposed improved training objectives for summarization, such as tracking coverage of the input document (See et al., 2017) or using reinforcement learning to directly identify actions in the decoder that improve target measures such as ROUGE-L (Chen & Bansal, 2018; Narayan et al., 2018). These objectives are orthogonal to the graph-augmented encoder discussed in this work, and we are interested in combining these efforts in future work. ",
+        "bbox": [
+            174,
+            103,
+            825,
+            172
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Exposing more language structure explicitly has been studied over the last years, with a focus on tree-based models (Tai et al., 2015). Very recently, first uses of graphs in natural language processing have been explored. Marcheggiani & Titov (2017) use graph convolutional networks to encode single sentences and assist machine translation. De Cao et al. (2018) create a graph over named entities over a set of documents to assist question answering. Closer to our work is the work of Liu et al. (2018), who use abstract meaning representation (AMR), in which the source document is first parsed into AMR graphs, before a summary graph is created, which is finally rendered in natural language. In contrast to that work we do not use AMRs but directly encode relatively simple relationships directly on the tokenized text, and do not treat summarization as a graph rewrite problem. Combining our encoder with AMRs to use richer graph structures may be a promising future direction. ",
+        "bbox": [
+            174,
+            180,
+            825,
+            319
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Finally, summarization in source code has also been studied in the forms of method naming, comment and documentation prediction. Method naming has been tackled with a series of models. For example, Allamanis et al. (2015) use a log-bilinear network to predict method names from features, and later extend this idea to use a convolutional attention network over the tokens of a method to predict the subtokens of names (Allamanis et al., 2016). Raychev et al. (2015) and Bichsel et al. (2016) use CRFs for a range of tasks on source code, including the inference of names for variables and methods. Recently, Alon et al. (2018b;a) extract and encode paths from the syntax tree of a program, setting the state of the art in accuracy on method naming. ",
+        "bbox": [
+            174,
+            325,
+            825,
+            438
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Linking text to code can have useful applications, such as code search (Gu et al., 2018), traceability (Guo et al., 2017), and detection of redundant method comments (Louis et al., 2018). Most approaches on source code either treat it as natural language (i.e., a token sequence), or use a language parser to explicitly expose its tree structure. For example, Barone & Sennrich (2017) use a simple sequenceto-sequence baseline, whereas Hu et al. (2017) summarize source code by linearizing the abstract syntax tree of the code and using a sequence-to-sequence model. Wan et al. (2018) instead directly operate on the tree structure using tree recurrent neural networks (Tai et al., 2015). The use of additional structure on related tasks on source code has been studied recently, for example in models that are conditioned on learned traversals of the syntax tree (Bielik et al., 2016) and in graph-based approaches (Allamanis et al., 2018; Cvitkovic et al., 2018). However, as noted by Liao et al. (2018), GNN-based approaches suffer from a tension between the ability to propagate information across large distances in a graph and the computational expense of the propagation function, which is linear in the number of graph edges per propagation step. ",
+        "bbox": [
+            174,
+            444,
+            825,
+            625
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "6 DISCUSSION & CONCLUSIONS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            645,
+            459,
+            661
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "We presented a framework for extending sequence encoders with a graph component that can leverage rich additional structure. In an evaluation on three different summarization tasks, we have shown that this augmentation improves the performance of a range of different sequence models across all tasks. We are excited about this initial progress and look forward to deeper integration of mixed sequence-graph modeling in a wide range of tasks across both formal and natural languages. The key insight, which we believe to be widely applicable, is that inductive biases induced by explicit relationship modeling are a simple way to boost the practical performance of existing deep learning systems. ",
+        "bbox": [
+            174,
+            676,
+            825,
+            787
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "REFERENCES ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            102,
+            287,
+            118
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Miltiadis Allamanis. The adverse effects of code duplication in machine learning models of code. arXiv preprint arXiv:1812.06469, 2018. ",
+        "bbox": [
+            171,
+            126,
+            825,
+            155
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Miltiadis Allamanis, Earl T Barr, Christian Bird, and Charles Sutton. Suggesting accurate method and class names. In Proceedings of the 2015 10th Joint Meeting on Foundations of Software Engineering, pp. 38–49. ACM, 2015. ",
+        "bbox": [
+            173,
+            165,
+            823,
+            208
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Miltiadis Allamanis, Hao Peng, and Charles Sutton. A convolutional attention network for extreme summarization of source code. In International Conference on Machine Learning, pp. 2091–2100, 2016. ",
+        "bbox": [
+            173,
+            218,
+            826,
+            261
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Miltiadis Allamanis, Marc Brockschmidt, and Mahmoud Khademi. Learning to represent programs with graphs. In International Conference on Learning Representations, 2018. ",
+        "bbox": [
+            173,
+            271,
+            823,
+            301
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Uri Alon, Omer Levy, and Eran Yahav. code2seq: Generating sequences from structured representations of code. arXiv preprint arXiv:1808.01400, 2018a. ",
+        "bbox": [
+            173,
+            311,
+            825,
+            340
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Uri Alon, Meital Zilberstein, Omer Levy, and Eran Yahav. A general path-based representation for predicting program properties. In Proceedings of the 39th ACM SIGPLAN Conference on Programming Language Design and Implementation, pp. 404–419. ACM, 2018b. ",
+        "bbox": [
+            176,
+            351,
+            823,
+            395
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Dzmitry Bahdanau, Kyunghyun Cho, and Yoshua Bengio. Neural machine translation by jointly learning to align and translate. arXiv preprint arXiv:1409.0473, 2014. ",
+        "bbox": [
+            169,
+            404,
+            823,
+            433
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Antonio Valerio Miceli Barone and Rico Sennrich. A parallel corpus of Python functions and documentation strings for automated code documentation and code generation. In Proceedings of the Eighth International Joint Conference on Natural Language Processing (Volume 2: Short Papers), volume 2, pp. 314–319, 2017. ",
+        "bbox": [
+            174,
+            443,
+            826,
+            501
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Benjamin Bichsel, Veselin Raychev, Petar Tsankov, and Martin Vechev. Statistical deobfuscation of android applications. In Proceedings of the 2016 ACM SIGSAC Conference on Computer and Communications Security, pp. 343–355. ACM, 2016. ",
+        "bbox": [
+            173,
+            510,
+            826,
+            554
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Pavol Bielik, Veselin Raychev, and Martin Vechev. PHOG: probabilistic model for code. In International Conference on Machine Learning (ICML), 2016. ",
+        "bbox": [
+            168,
+            563,
+            825,
+            593
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Yen-Chun Chen and Mohit Bansal. Fast abstractive summarization with reinforce-selected sentence rewriting. arXiv preprint arXiv:1805.11080, 2018. ",
+        "bbox": [
+            171,
+            603,
+            823,
+            632
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Sumit Chopra, Michael Auli, and Alexander M Rush. Abstractive sentence summarization with attentive recurrent neural networks. In Proceedings of the 2016 Conference of the North American Chapter of the Association for Computational Linguistics: Human Language Technologies, pp. 93–98, 2016. ",
+        "bbox": [
+            173,
+            642,
+            826,
+            699
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Milan Cvitkovic, Badal Singh, and Anima Anandkumar. Deep learning on code with an unbounded vocabulary. In Machine Learning 4 Programming, 2018. ",
+        "bbox": [
+            173,
+            709,
+            823,
+            739
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Nicola De Cao, Wilker Aziz, and Ivan Titov. Question answering by reasoning across documents with graph convolutional networks. arXiv preprint arXiv:1808.09920, 2018. ",
+        "bbox": [
+            171,
+            748,
+            823,
+            779
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Justin Gilmer, Samuel S Schoenholz, Patrick F Riley, Oriol Vinyals, and George E Dahl. Neural message passing for quantum chemistry. In International Conference on Machine Learning, pp. 1263–1272, 2017. ",
+        "bbox": [
+            171,
+            787,
+            825,
+            832
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Xiaodong Gu, Hongyu Zhang, and Sunghun Kim. Deep code search. In Proceedings of the 40th International Conference on Software Engineering, pp. 933–944. ACM, 2018. ",
+        "bbox": [
+            169,
+            842,
+            825,
+            871
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Jin Guo, Jinghui Cheng, and Jane Cleland-Huang. Semantically enhanced software traceability using deep learning techniques. In Software Engineering (ICSE), 2017 IEEE/ACM 39th International Conference on, pp. 3–14. IEEE, 2017. ",
+        "bbox": [
+            174,
+            881,
+            825,
+            924
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Karl Moritz Hermann, Tomas Kocisky, Edward Grefenstette, Lasse Espeholt, Will Kay, Mustafa Suleyman, and Phil Blunsom. Teaching machines to read and comprehend. In Advances in Neural Information Processing Systems, pp. 1693–1701, 2015. ",
+        "bbox": [
+            176,
+            103,
+            823,
+            147
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Xing Hu, Yuhan Wei, Ge Li, and Zhi Jin. Codesum: Translate program language to natural language. arXiv preprint arXiv:1708.01837, 2017. ",
+        "bbox": [
+            173,
+            155,
+            825,
+            184
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Robin Jia and Percy Liang. Adversarial examples for evaluating reading comprehension systems. In Empirical Methods in Natural Language Processing (EMNLP), 2017. ",
+        "bbox": [
+            173,
+            194,
+            823,
+            223
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Thomas N. Kipf and Max Welling. Semi-supervised classification with graph convolutional networks. In International Conference on Learning Representations, 2017. ",
+        "bbox": [
+            174,
+            232,
+            823,
+            262
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "G. Klein, Y. Kim, Y. Deng, J. Senellart, and A. M. Rush. OpenNMT: Open-Source Toolkit for Neural Machine Translation. ArXiv e-prints. ",
+        "bbox": [
+            174,
+            270,
+            823,
+            301
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Guillaume Lample, Miguel Ballesteros, Sandeep Subramanian, Kazuya Kawakami, and Chris Dyer. Neural architectures for named entity recognition. In Proceedings the North American Chapter of the Association for Computational Linguistics: Human Language Technologies, 2016. ",
+        "bbox": [
+            176,
+            309,
+            826,
+            353
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Yujia Li, Daniel Tarlow, Marc Brockschmidt, and Richard Zemel. Gated graph sequence neural networks. arXiv preprint arXiv:1511.05493, 2015. ",
+        "bbox": [
+            176,
+            362,
+            823,
+            392
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Renjie Liao, Marc Brockschmidt, Daniel Tarlow, Alexander Gaunt, Raquel Urtasun, and Richard S. Zemel. Graph partition neural networks for semi-supervised classification. In International Conference on Learning Representations (ICLR) [Workshop Track], 2018. ",
+        "bbox": [
+            178,
+            400,
+            823,
+            444
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Chin-Yew Lin. ROUGE: A package for automatic evaluation of summaries. Text Summarization Branches Out, 2004. ",
+        "bbox": [
+            171,
+            453,
+            825,
+            483
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Fei Liu, Jeffrey Flanigan, Sam Thomson, Norman Sadeh, and Noah A Smith. Toward abstractive summarization using semantic representations. arXiv preprint arXiv:1805.10399, 2018. ",
+        "bbox": [
+            171,
+            492,
+            825,
+            521
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Cristina V Lopes, Petr Maj, Pedro Martins, Vaibhav Saini, Di Yang, Jakub Zitny, Hitesh Sajnani, and Jan Vitek. Dej´ avu: a map of code duplicates on github. \\` Proceedings of the ACM on Programming Languages, 1(OOPSLA):84, 2017. ",
+        "bbox": [
+            176,
+            530,
+            823,
+            574
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Annie Louis, Santanu Kumar Dash, Earl T Barr, and Charles Sutton. Deep learning to detect redundant method comments. arXiv preprint arXiv:1806.04616, 2018. ",
+        "bbox": [
+            173,
+            583,
+            823,
+            613
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Minh-Thang Luong, Hieu Pham, and Christopher D Manning. Effective approaches to attentionbased neural machine translation. arXiv preprint arXiv:1508.04025, 2015. ",
+        "bbox": [
+            173,
+            621,
+            825,
+            651
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Christopher Manning, Mihai Surdeanu, John Bauer, Jenny Finkel, Steven Bethard, and David McClosky. The stanford corenlp natural language processing toolkit. In Proceedings of 52nd annual meeting of the association for computational linguistics: system demonstrations, pp. 55–60, 2014. ",
+        "bbox": [
+            176,
+            660,
+            826,
+            704
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Diego Marcheggiani and Ivan Titov. Encoding sentences with graph convolutional networks for semantic role labeling. In Proceedings of the 2017 Conference on Empirical Methods in Natural Language Processing, pp. 1506–1515, 2017. ",
+        "bbox": [
+            176,
+            713,
+            825,
+            756
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Bryan McCann, Nitish Shirish Keskar, Caiming Xiong, and Richard Socher. The natural language decathlon: Multitask learning as question answering. arXiv preprint arXiv:1806.08730, 2018. ",
+        "bbox": [
+            171,
+            765,
+            823,
+            795
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Ramesh Nallapati, Bowen Zhou, Cicero dos Santos, Caglar Gulcehre, and Bing Xiang. Abstractive text summarization using sequence-to-sequence rnns and beyond. In Proceedings of The 20th SIGNLL Conference on Computational Natural Language Learning, pp. 280–290, 2016. ",
+        "bbox": [
+            176,
+            804,
+            823,
+            848
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Shashi Narayan, Shay B Cohen, and Mirella Lapata. Ranking sentences for extractive summarization with reinforcement learning. arXiv preprint arXiv:1802.08636, 2018. ",
+        "bbox": [
+            171,
+            856,
+            823,
+            886
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Veselin Raychev, Martin Vechev, and Andreas Krause. Predicting program properties from Big Code. In Principles of Programming Languages (POPL), 2015. ",
+        "bbox": [
+            174,
+            895,
+            823,
+            924
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Abigail See, Peter J Liu, and Christopher D Manning. Get to the point: Summarization with pointergenerator networks. In Proceedings of the 55th Annual Meeting of the Association for Computational Linguistics (Volume 1: Long Papers), volume 1, pp. 1073–1083, 2017. ",
+        "bbox": [
+            176,
+            103,
+            823,
+            146
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Kai Sheng Tai, Richard Socher, and Christopher D Manning. Improved semantic representations from tree-structured long short-term memory networks. 2015. ",
+        "bbox": [
+            173,
+            155,
+            823,
+            184
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Ashish Vaswani, Noam Shazeer, Niki Parmar, Jakob Uszkoreit, Llion Jones, Aidan N Gomez, Łukasz Kaiser, and Illia Polosukhin. Attention is all you need. In Advances in Neural Information Processing Systems, pp. 5998–6008, 2017. ",
+        "bbox": [
+            176,
+            193,
+            823,
+            234
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Oriol Vinyals, Meire Fortunato, and Navdeep Jaitly. Pointer networks. In Advances in Neural Information Processing Systems, pp. 2692–2700, 2015a. ",
+        "bbox": [
+            173,
+            244,
+            823,
+            273
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Oriol Vinyals, Lukasz Kaiser, Terry Koo, Slav Petrov, Ilya Sutskever, and Geoffrey Hinton. Grammar as a foreign language. In Advances in Neural Information Processing Systems, 2015b. ",
+        "bbox": [
+            174,
+            281,
+            823,
+            310
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Yao Wan, Zhou Zhao, Min Yang, Guandong Xu, Haochao Ying, Jian Wu, and Philip S Yu. Improving automatic source code summarization via deep reinforcement learning. In Proceedings of the 33rd ACM/IEEE International Conference on Automated Software Engineering, pp. 397–407. ACM, 2018. ",
+        "bbox": [
+            174,
+            319,
+            826,
+            376
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "A CODE SUMMARIZATION SAMPLES",
+        "text_level": 1,
+        "bbox": [
+            176,
+            102,
+            493,
+            118
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "A.1 METHODDOC ",
+        "bbox": [
+            176,
+            133,
+            315,
+            147
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "C# Sample 1 ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            159,
+            263,
+            174
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "public static bool TryConvertTo(object valueToConvert, Type resultType, IFormatProvider formatProvider, out object result){ result $=$ null; try{ result $=$ ConvertTo(valueToConvert, resultType, formatProvider); catch (InvalidCastException){ return false; catch (ArgumentException){ return false; } return true;   \n} ",
+        "bbox": [
+            173,
+            184,
+            836,
+            333
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Ground truth ",
+        "text_level": 1,
+        "bbox": [
+            184,
+            349,
+            271,
+            362
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "sets result to valuetoconvert converted to resulttype considering formatprovider for custom conversions calling the parse method and calling convert . changetype .   \nconverts the specified type to a primitive type .   \nsets result to resulttype   \nsets result to valuetoconvert converted to resulttype. ",
+        "bbox": [
+            441,
+            349,
+            818,
+            425
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "BILSTM LSTM BILSTM+GNN $\\mathbf { J } \\to \\mathbf { L S T N }$ M BILSTM+G $\\mathbf { \\ V N } \\to \\mathbf { L S T M } + \\mathbf { \\beta }$ POINTER ",
+        "bbox": [
+            183,
+            386,
+            423,
+            424
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "C# Sample 2 ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            438,
+            264,
+            452
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "public virtual Task Init(string name, IProviderRuntime providerRuntime, IProviderConfiguration config){ Log $=$ providerRuntime.GetLogger(this.GetType().FullName); this.serializerSettings $=$ OrleansJsonSerializer.GetDefaultSerializerSettings(); return TaskDone.Done;   \n} ",
+        "bbox": [
+            174,
+            460,
+            895,
+            535
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Ground truth BILSTM $\\bf \\Pi \\to L S T N$ I BILSTM+G $\\mathbf { \\partial } _ { \\mathbf { i } } \\mathbf { N N } \\to \\mathbf { L S T M }$ BILSTM+GN $\\mathbf { N } \\to \\mathbf { L S T }$ M+POINTER ",
+        "bbox": [
+            181,
+            551,
+            423,
+            602
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "initializes the storage provider   \ncreates a grain object   \ninitializes the provider provider   \ninitialization function to initialize the specified provider. ",
+        "bbox": [
+            439,
+            551,
+            772,
+            603
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "C# Sample 3 ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            609,
+            264,
+            625
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "public void NullParameter(){ TaskParameter t $=$ new TaskParameter(null); Assert.Null(t.WrappedParameter); Assert.Equal( TaskParameterType.Null , t.ParameterType ); ((INodePacketTranslatable) t).Translate( TranslationHelpers.GetWriteTranslator()); TaskParameter $\\begin{array} { r l } { \\pm 2 } & { { } = } \\end{array}$ TaskParameter.FactoryForDeserialization( TranslationHelpers.GetReadTranslator()); Assert.Null(t2.WrappedParameter); Assert.Equal(TaskParameterType.Null, t2.ParameterType);   \n} ",
+        "bbox": [
+            174,
+            633,
+            746,
+            770
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Ground truth BILSTM LSTM BILSTM+G $\\mathbf { N N } \\to \\mathbf { L S T M }$ BILSTM+GNN LSTM+POINTER verifies that construction and serialization with a null parameter is ok tests that the value is a value that is a value to the specified type verifies that construction with an parameter parameter verifies that construction and serialization with a parameter that is null ",
+        "bbox": [
+            183,
+            786,
+            423,
+            838
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            439,
+            786,
+            852,
+            838
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "C# Sample 4 ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            849,
+            264,
+            864
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "public override DbGeometryWellKnownValue CreateWellKnownValue(DbGeometry geometryValue){ geometryValue.CheckNull(\"geometryValue\"); var spatialValue $=$ geometryValue.AsSpatialValue(); DbGeometryWellKnownValue result $=$ CreateWellKnownValue(spatialValue, ",
+        "bbox": [
+            176,
+            873,
+            949,
+            924
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "() $= >$ SpatialExceptions.CouldNotCreateWellKnownGeometryValueNoSrid(\"geometryValue\"), () $= >$ SpatialExceptions.CouldNotCreateWellKnownGeometryValueNoWkbOrWkt(\"geometryValue\"), (srid, wkb, wkt) $= >$ new DbGeometryWellKnownValue() { CoordinateSystemId $=$ srid, WellKnownBinary $=$ wkb, WellKnownText $=$ wkt }); return result; } ",
+        "bbox": [
+            174,
+            104,
+            957,
+            194
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "Ground truth BILSTM LSTM B $\\mathbf { I L S T M + G N N } \\to \\mathbf { L S T M }$ BILSTM+GN $\\Gamma \\to \\mathbf { L } \\mathbf { S }$ TM+POINTER ",
+        "bbox": [
+            181,
+            207,
+            424,
+            297
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "creates an instance of t:system.data.spatial.dbgeometry value using one or both of the standard well known spatial formats.   \ncreates a t:system.data.spatial.dbgeography value based on the specified well known binary value .   \ncreates a new t:system.data.spatial.dbgeography instance using the specified well known spatial formats .   \ncreates a new instance of the t:system.data.spatial.dbgeometry value based on the provided geometry value and returns the resulting well as known spatial formats . ",
+        "bbox": [
+            441,
+            208,
+            841,
+            321
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "A.2 METHODNAMING ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            343,
+            343,
+            358
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "C# Sample 1 ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            369,
+            263,
+            385
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "public bool _(D d) { return d ! $=$ null && d.Val == Val ;   \n} ",
+        "bbox": [
+            174,
+            392,
+            500,
+            430
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "Ground truth equals BILSTM LSTM foo BILSTM+GNN LSTM equals BILSTM+ $\\mathbf { G N N } \\to \\mathbf { L S T M } \\mathbf { + P O I }$ NTER equals ",
+        "bbox": [
+            181,
+            445,
+            496,
+            496
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "C# Sample 2 ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            502,
+            264,
+            517
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "internal void _(string switchName, Hashtable bag, string parameterName) { object obj $=$ bag[parameterName]; if(obj ! $=$ null){ int value $=$ (int) obj; AppendSwitchIfNotNull(switchName, value.ToString(CultureInfo.InvariantCulture));   \n} ",
+        "bbox": [
+            173,
+            526,
+            818,
+            626
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "Ground truth append switch with integer BILSTM LSTM set string BILSTM+GN $\\ J \\to \\mathbf { L S T N }$ M append switch BILSTM $\\mathbf { + G N N \\to L S T M + P O }$ INTER append switch if not null ",
+        "bbox": [
+            181,
+            641,
+            673,
+            693
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "C# Sample 3 ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            699,
+            264,
+            713
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "internal static string _(){ var currentPlatformString $=$ string.Empty; if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows)){ currentPlatformString $=$ \"WINDOWS\"; } else if (RuntimeInformation.IsOSPlatform(OSPlatform.Linux)){ currentPlatformString $=$ \"LINUX\"; } else if ( RuntimeInformation.IsOSPlatform(OSPlatform.OSX)) { currentPlatformString $=$ \"OSX\"; } else { Assert.True(false, \"unrecognized current platform\"); } return currentPlatformString ; ",
+        "bbox": [
+            200,
+            723,
+            758,
+            914
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "Ground truth BILSTM LSTM BILSTM+GNN LSTM BILSTM+ $\\mathbf { G N N } \\to \\mathbf { L S T M + P O I N T }$ ER ",
+        "bbox": [
+            183,
+            102,
+            423,
+            151
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "get os platform as string get name   \nget platform   \nget current platform string ",
+        "bbox": [
+            439,
+            102,
+            681,
+            152
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "C# Sample 4 ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            159,
+            264,
+            174
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "public override DbGeometryWellKnownValue CreateWellKnownValue(DbGeometry geometryValue){ geometryValue.CheckNull(\"geometryValue\"); var spatialValue $=$ geometryValue.AsSpatialValue(); DbGeometryWellKnownValue result $=$ CreateWellKnownValue(spatialValue, () $= >$ SpatialExceptions.CouldNotCreateWellKnownGeometryValueNoSrid(\"geometryValue\"), () $= >$ SpatialExceptions.CouldNotCreateWellKnownGeometryValueNoWkbOrWkt(\"geometryValue\"), (srid, wkb, wkt) $= >$ new DbGeometryWellKnownValue () { CoordinateSystemId $=$ srid , WellKnownBinary $=$ wkb , WellKnownText $=$ wkt }); return result;   \n} ",
+        "bbox": [
+            174,
+            184,
+            955,
+            321
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "Ground truth BILSTM LSTM BILSTM+GN $\\ J \\to \\mathbf { L S T N }$ BILSTM+G $\\mathbf { N N } \\to \\mathbf { L S T M } +$ POINTER create well known value spatial geometry from xml geometry point get well known value ",
+        "bbox": [
+            181,
+            338,
+            423,
+            388
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            439,
+            338,
+            661,
+            388
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "Java Sample 1 ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            396,
+            276,
+            411
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "public static void _(String name, int expected, MetricsRecordBuilder rb) { Assert.assertEquals(\"Bad value for metric \" $^ +$ name, expected, getIntCounter(name, rb));   \n} ",
+        "bbox": [
+            173,
+            420,
+            825,
+            479
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            472,
+            184,
+            483
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "Ground truth assert counter BILSTM LSTM assert email value BILSTM+GNN $\\ J \\to \\mathbf { L S T N }$ M assert header BILSTM+GNN LSTM+POINTER assert int counter ",
+        "bbox": [
+            183,
+            498,
+            602,
+            550
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "table",
+        "img_path": "images/17c8bb677ca1727c64543deca803078e74c9931cdd483d303dc153dacdc4aa06.jpg",
+        "table_caption": [
+            "B NATURAL LANGUAGE SUMMARIZATION SAMPLES"
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=1 colspan=1>Input: -LRB- CNN -RRB- Gunshots were fired at rapper Lil Wayne &#x27;s tour bus early Sunday inAtlanta .No one was injured in the shooting ,and no arrests have been made,Atlanta Police spokeswoman Elizabeth Espy said .Police are stillooking for suspects . Ofcers were called to aparking lot in Atlanta &#x27;s Buckhead neighborhood,Espy said .They arrived at 3:25 a.m. and locatedtwo tour buses that had been shot multiple times .The drivers of the buses said the incident occurredon Interstate 285 near Interstate 75,Espy said .Witnesses provided a limited description of the twovehicles suspected to be involved : a“ Corvette style vehicle ”and an SUV .Lil Wayne was in Atlantafor a performance at Compound nightclub Saturday night . CNN &#x27;s Carma Hassan contributed to thisreport .</td></tr><tr><td rowspan=1 colspan=1>Reference: rapper lil wayne not injured after shots fired at his tour bus on an atlanta interstate ,police say . no one has been arrested in the shooting</td></tr><tr><td rowspan=1 colspan=1>See et al. (2017) (+ Pointer): police are stillooking for suspects . the incident occurred on interstate285 near interstate 75 ,police say . witnesses provided a limited description of the two vehicles suspected to be involved : a“ corvette style vehicle ” and an suv .</td></tr><tr><td rowspan=1 colspan=1>See et al. (2017) (+ Pointer + Coverage): lil wayne &#x27;s tour bus was shot multiple times , police say: police are stillooking for suspects .they arrived at 3:25 a.m. and located two tour buses that hadbeen shot .</td></tr><tr><td rowspan=1 colspan=1>BILSTM+GNN → LSTM: the incident occurred on interstate %UNK% near interstate 75 . no onewas injured in the shooting ,and no arrests have been made ,atlanta police spokeswoman says .</td></tr><tr><td rowspan=1 colspan=1>BILSTM+GNN →LSTM+PoINTER gunshots fired at rapper lil wayne &#x27;s tour bus early sundayin atlanta ,police say . no one was injured in the shooting ,and no arrests have been made , policesay.</td></tr></table>",
+        "bbox": [
+            174,
+            131,
+            839,
+            477
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "table",
+        "img_path": "images/2582be1a64ce7532a8da18bfc0c3cf0f0d35e813ef43615062ab39e18a886462.jpg",
+        "table_caption": [],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=1 colspan=1>Input: Tottenham have held further discussions with Marseille over a potential deal for midfielderFlorian Thauvin .The 22-year-old has been left out of the squad for this weekend &#x27;s game withMetz as Marseille push for a f 15m sale .The winger,who can also play behind the striker, wasthe subject of enquiries from Spurs earlier in the year and has also been watched by Chelsea andValencia .Tottenham have held further talks with Ligue 1 side Marseille over a possible deal forFlorian Thauvin .Marseille are already resigned to losing Andre Ayew and Andre-Pierre Gignacwith English sides keen on both .Everton,Newcastle and Swansea,have allshown an interest inAyew,who is a free agent in the summer .</td></tr><tr><td rowspan=1 colspan=1>Reference: florian thauvin has been left out of marseille &#x27;s squad with metz . marseille are pushingfor a f 15m sale and tottenham are interested .the winger has also been watched by chelsea and laliga side valencia .</td></tr><tr><td rowspan=1 colspan=1>See et al. (2O17)(+ Pointer): tottenham have held further discussions with marseille over a potentialdeal for midfelder florian thauvin .the 22-year-old has been left out of the squad for this weekend &#x27;s game with metz as marseille push for a 15m sale .</td></tr><tr><td rowspan=1 colspan=1>See et al. (2017) (+ Pointer + Coverage): florian thauvin has been left out of the squad for thisweekend &#x27;s game with metz as marseille push for a 15m sale .the 22-year-old was the subject ofenquiries from spurs earlier in the year .</td></tr><tr><td rowspan=1 colspan=1>BILSTM+GNN →LSTM: the 22-year-old has been left out of the squad for this weekend &#x27;s gamewith metz .the 22-year-old has been left out of the squad for this weekend &#x27;s game with metz .thewinger has been left out of the squad for this weekend &#x27;s game with metz .</td></tr><tr><td rowspan=1 colspan=1>BILSTM+GNN → LSTM+PoINTER tottenham have held further discussions with marseille overa potential deal .the winger has been left out of the squad for this weekend &#x27;s game .tottenham haveheld further talks with marseille over a potential deal .</td></tr></table>",
+        "bbox": [
+            174,
+            510,
+            839,
+            868
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "text",
+        "text": "C CODE DATASETS INFORMATION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            102,
+            473,
+            118
+        ],
+        "page_idx": 16
+    },
+    {
+        "type": "text",
+        "text": "C.1 C# DATASET ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            133,
+            307,
+            148
+        ],
+        "page_idx": 16
+    },
+    {
+        "type": "text",
+        "text": "We extract the C# dataset from open-source projects on GitHub. Overall, our dataset contains 460,905 methods, 55,635 of which have a documentation comment. The dataset is split $8 5 - 5 - 1 0 \\%$ . The projects and exact state of the repositories used is listed in Table 3 ",
+        "bbox": [
+            174,
+            160,
+            825,
+            203
+        ],
+        "page_idx": 16
+    },
+    {
+        "type": "table",
+        "img_path": "images/8f3e3b14cf0c4e66fb1d5598a0c36f7ae9096fd31a267c2ba5b215c552d07249.jpg",
+        "table_caption": [
+            "Table 3: Projects in our C# dataset. Ordered alphabetically. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Name</td><td>Git SHA</td><td>Description</td></tr><tr><td>Akka.NET</td><td>6f32f6a7</td><td>Actor-based Concurrent &amp; Distributed Framework</td></tr><tr><td>AutoMapper</td><td>19d6f7fc</td><td>Object-to-Object Mapping Library</td></tr><tr><td>BenchmarkDotNet</td><td>57005f05</td><td>Benchmarking Library</td></tr><tr><td>CommonMark.NET</td><td>f3d54530</td><td>Markdown Parser</td></tr><tr><td>CoreCLR</td><td>cc5dcbe6</td><td>.NET Core Runtime</td></tr><tr><td>CoreFx</td><td>ec1671fd</td><td>.NETFoundationalLibraries</td></tr><tr><td>Dapper</td><td>3c7cde28</td><td>Object Mapper Library</td></tr><tr><td>EntityFramework</td><td>c4d9a269</td><td>Object-Relational Mapper</td></tr><tr><td>Humanizer</td><td>2b1c94c4</td><td>String Manipulation and Formatting</td></tr><tr><td>Lean</td><td>90ee6aae</td><td>Algorithmic Trading Engine</td></tr><tr><td>Mono</td><td>9b9e4f4b</td><td>.NET Implementation</td></tr><tr><td>MsBuild</td><td>7f95dc15</td><td>Build Engine</td></tr><tr><td>Nancy</td><td>de458a9b</td><td>HTTP Service Framework</td></tr><tr><td>NLog</td><td>49fdd08e</td><td>Logging Library</td></tr><tr><td>Opserver</td><td>9e4d3a40</td><td>Monitoring System</td></tr><tr><td>orleans</td><td>f89c5866</td><td>Distributed Virtual Actor Model</td></tr><tr><td>Polly</td><td>f3d2973d</td><td>Resilience &amp; Transient Fault Handling Library</td></tr><tr><td>Powershell</td><td>9ac701db</td><td>Command-line Shell</td></tr><tr><td>ravendb</td><td>6437de30</td><td>Document Database</td></tr><tr><td>roslyn</td><td>8ca0a542</td><td>Compiler &amp; Code Analysis &amp; Compilation</td></tr><tr><td>ServiceStack</td><td>17f081b9</td><td>Real-time web library</td></tr><tr><td>SignalR</td><td>9b05bcb0</td><td>Push Notification Framework</td></tr><tr><td>Wox</td><td>13e6c5ee</td><td>Application Launcher</td></tr></table>",
+        "bbox": [
+            174,
+            243,
+            820,
+            617
+        ],
+        "page_idx": 16
+    },
+    {
+        "type": "text",
+        "text": "C.2 JAVA METHOD NAMING DATASETS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            643,
+            459,
+            659
+        ],
+        "page_idx": 16
+    },
+    {
+        "type": "text",
+        "text": "We use the datasets and splits of Alon et al. (2018a) provided by their website. Upon scanning all methods in the dataset, the size of the corpora can be seen in Table 4. More information can be found at Alon et al. (2018a). ",
+        "bbox": [
+            174,
+            670,
+            825,
+            713
+        ],
+        "page_idx": 16
+    },
+    {
+        "type": "text",
+        "text": "C.3 PYTHON METHOD DOCUMENTATION DATASET ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            731,
+            542,
+            746
+        ],
+        "page_idx": 16
+    },
+    {
+        "type": "text",
+        "text": "We use the dataset as split of Barone & Sennrich (2017) provided by their GitHub repository. Upon parsing the dataset, we get 106,065 training samples, 1,943 validation samples and 1,937 test samples. We note that $1 6 . 9 \\%$ of the documentation samples in the validation set and $1 5 . 3 \\%$ of the samples in test set have a sample with the identical natural language documentation on the training set. This eludes to a potential issue, described by Lopes et al. (2017). See Allamanis (2018) for a lengthier discussion of this issue. ",
+        "bbox": [
+            173,
+            757,
+            826,
+            813
+        ],
+        "page_idx": 16
+    },
+    {
+        "type": "table",
+        "img_path": "images/f7c6b5866c07b5ce850ebf6cf50afa0b805a47d8f43b2da9868cff4166d9f0f8.jpg",
+        "table_caption": [
+            "Table 4: The statistics of the extracted graphs from the Java method naming dataset of Alon et al. (2018a). "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Dataset</td><td>Train Size</td><td>Valid Size</td><td>Test Size</td></tr><tr><td>Java - Small</td><td>691,505</td><td>23,837</td><td>56,952</td></tr></table>",
+        "bbox": [
+            320,
+            877,
+            678,
+            921
+        ],
+        "page_idx": 16
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            103,
+            823,
+            132
+        ],
+        "page_idx": 17
+    },
+    {
+        "type": "text",
+        "text": "C.4 GRAPH DATA STATISTICS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            148,
+            395,
+            164
+        ],
+        "page_idx": 17
+    },
+    {
+        "type": "text",
+        "text": "Below we present the data characteristics of the graphs we use across the datasets. ",
+        "bbox": [
+            173,
+            174,
+            710,
+            190
+        ],
+        "page_idx": 17
+    },
+    {
+        "type": "table",
+        "img_path": "images/07b4d3250602bafe5f8460cf8adff0266382ea181ed4a4ad40d4fe86dc094a52.jpg",
+        "table_caption": [
+            "Table 5: Graph Statistics For Datasets. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Dataset</td><td>Avg Num Nodes</td><td>Avg Num Edges</td></tr><tr><td>CNN/DM</td><td>903.2</td><td>2532.9</td></tr><tr><td>C# Method Names</td><td>125.2</td><td>239.3</td></tr><tr><td>C# Documentation</td><td>133.5</td><td>265.9</td></tr><tr><td>Java-SmallMethod Names</td><td>144.4</td><td>251.6</td></tr></table>",
+        "bbox": [
+            271,
+            228,
+            725,
+            314
+        ],
+        "page_idx": 17
+    }
+]