Knowledge graphs are popular representations of important entities and their relationships. Compact, interpretable knowledge can graphs facilitate human data analysis as well as empower memory-dependent knowledge-based applications. This makes them ideal for modeling the content of documents. Document-level information extraction which captures relations across distant sentences can be used to construct knowledge graphs of documents (Jia, Wong, and Poon 2019; Yao et al. 2019 ). These techniques focus on extracting all entities and relations from a document, which for long and dense documents such as scientific papers may be hundreds or thousands. This poses a new challenge: how do we determine the most important entities in a paper and the key relationships between them?
Automatic summarization (Liu and Lapata 2019; Yasunaga et al. 2019 ) addresses the problem of identifying salient information in a document, but introduces the additional challenge of discourse structuring (and in the abstractive case, text generation as well). Summarizing entities and relations directly as a first step could decouple the mixed burdens on models and help assure the factual correctness of a summary in line with recent trends in evaluation for summarization (Wang, Cho, and Lewis 2020; Durmus, He, and Diab 2020; Zhang et al. 2020) .
In this work, we introduce the task of extracting from a scientific document a compact knowledge graph that represents its most important information. Figure 1 illustrates the situation: a large knowledge graph can be extracted from the document, but only a portion of entities and relations characterize its main ideas (colored nodes and thick edges), while Figure 1: We introduce the task to extract a summary knowledge graph from a long document (e.g. a scientific paper). This is an example from our dataset, where the target summary graph should only contain entities and relations that are salient enough to be included in the abstract of the paper. The entities or relations (shown in light grey) not found in the abstract should be removed. We omit entity and relation types for simplicity. the rest play a more minor role. Our task emphasizes finding this salient subgraph. We support this task with a dataset of 200k scientific document/graph pairs that integrates automatic and human annotations from existing knowledge resources in the scientific domain. We outline an evaluation paradigm that balances accuracy against redundancy while admitting the variability of textual reference to an entity.
We develop and investigate two competitive baselines based on text summarization and graph learning models, and compare to two simple frequency-based methods. We provide an analysis of their tradeoffs, and of the general challenges posed in the proposed dataset. For example, we observe that missing entities and entity coreference errors in the predicted graphs have a large impact on relation accuracy. Our hope is that this task and data will facilitate research into future models that can better capture these challenging but important textual relations.
2 Background / Related Work
Most IE work focuses on extracting entities and their relational facts from a single sentence (Zhang et al. 2017; Stanovsky et al. 2018 ). More recent work addresses document-level IE which aims to capture relations across distant sentences (Jain et al. 2020; Jia, Wong, and Poon 2019; Yao et al. 2019) or to fill a pre-defined metadata table with entities (Hou et al. 2019) . Jia, Wong, and Poon (2019) , Yao et al. (2019) and Hou et al. (2019) formulate the task as classifying the relation type between each pair of groundtruth entities expressed in the document. We do not assume the existence of ground-truth entities and extract documentlevel relations directly from text.
Our work complements this trend of applying IE for long document understanding while addressing the need for focused, compact knowledge representations. The closest work to our is Jain et al. (2020) , who separately explore the idea of identifying salient entities related to experimental results using weak supervision provided by the Papers with Code dataset. 1 In contrast, we focus on identifying salient entities from the paper based on weak supervision from its abstract. This framing generalizes to a wider variety of documents and domains, and supports diverse tasks including multi-document summarization or building scientific knowledge bases. Besides entity salience, our task also requires models to identify the salience of relations, which we show to be challenging.
Document summarization models create summaries by identifying the most important sentences from documents (Nallapati, Zhai, and Zhou 2017; Narayan, Cohen, and Lapata 2018) or using a decoder to generate abstractive summaries (Rush, Chopra, and Weston 2015; Celikyilmaz et al. 2018) . Although text summarization tasks (Liu and Lapata 2019; Yasunaga et al. 2019) share our objective of distilling crucial information from documents, they mix this objective with the goal of producing fluent natural language text.
We argue that summarizing entities and relations directly as the first step could decouple the mixed burdens on models and help models to check the factual correctness of a summary. These advantages can benefit other text generation tasks that rely on long document understanding and representation, such as generation grounded on long text. An increasing number of recent works (Wang, Cho, and Lewis 2020; Durmus, He, and Diab 2020; Zhang et al. 2020) have proposed automatically evaluating summarization models by applying information extraction or question answering models to match entities or relations between generated and reference summaries. These newly proposed measures are found to have much higher correlation with human judgements than standard measures.
Recent applications of large pretrained language models such as Ribeiro et al. (2020) and Kale (2020) show the promise of generating fluent and accurate text from knowledge graphs, highlighting the need for identifying correct 1 Papers with Code: paperswithcode.com underlying knowledge representations. In addition, summarized knowledge graphs from multiple documents can be naturally merged by collapsing shared entity nodes to bring even richer information. And such summarized structures can be more easily leveraged to facilitate downstream tasks.
Another line of work that is closely related to ours is graph-based summarization, which leverages graph structures of documents to facilitate the summary generation (Erkan and Radev 2004; Tan, Wan, and Xiao 2017; Yasunaga et al. 2019; Huang, Wu, and Wang 2020; Xu et al. 2020) . These works try to leverage graphs that capture relations between sentences or discourse units. Wang et al. (2020a) incorporate graphs between entities extracted by sentence-level IE systems without considering entity or relation salience.
In general, graph summarization work can be categorized according to whether its goal is optimizing for memory or computational resources needed for processing, or improving analysis (Liu et al. 2018) . Knowledge graph summarization (Safavi et al. 2019) or node estimation (Park et al. 2019) are most relevant to our work, but they normally take a huge knowledge graph for pruning based on a given query, without any document context. Unlike these works, our task requires the model to handle different document contexts at inference, where each document can contain a completely different knowledge graph with unique entities. Our work is also similar to Falke and Gurevych (2017) , who collect a small corpus (30 data instances) of concept map annotations from OpenIE tuples for summarizing sets of documents. We choose a science-specific annotation scheme which provides more structure as our target.
Although our proposed idea of summarized knowledge graphs can be applied to documents in any domain, we focus on scientific papers in this work. Existing works toward understanding scientific documents include but are not limited to information extraction (Luan et al. 2018; Wadden et al. 2019) , summarization (Cohan et al. 2018; Collins, Augenstein, and Riedel 2017; Yasunaga et al. 2019) , fact verification (Wadden et al. 2020) , and citation generation (Luu et al. 2020; Xing, Fan, and Wan 2020) . Recently, attention to research in the scientific domain in the NLP community has grown even more (Wang et al. 2020b; Esteva et al. 2020) due to the urgent need for mitigating the COVID-19 global pandemic.
We introduce a text-to-graph task of extracting a succinct, structured knowledge graph which contains the most salient entities and relations from a document. More specifically, such a summarized knowledge graph should meet these conditions: 1) it contains only the most important entities from the document; 2) it includes relations between these entities only if they are crucial to understanding the main ideas of the text; and 3) each salient entity is only represented by a single node in the graph. These conditions are evaluated as entity salience, relation salience, and entity duplication rate, respectively (evaluation details in Section 5). In our dataset (see Section 4) where long documents are scientific papers, the most salient entities and relations are defined to be those that can be included in paper abstracts. Figure 1 shows an example of this task. Here, only entities and relations that appear in the abstract should be included in the summary knowledge graph. Those in grey should be removed even though they are mentioned in the paper, because they are not necessary enough to describe or understand the main idea of the paper.
Formally, we define the problem as: Given a document D, a pre-defined entity type set T v and a relation type set T R , predict a summarized knowledge graph
We note there can be multiple edges between v i and v j , but
.., m ni i } (from co-referent entity mentions).
We construct a text-to-graph dataset from a corpus of scientific papers. Our textual data consists of roughly 200k computer science research papers taken from S2orc, a corpus of 8 million full-text research papers and abstracts . We leverage abstracts to create summarized knowledge graphs for full papers. Abstracts effectively contain summarized information from full documents, and there are existing human annotation and information extraction (IE) systems that enable constructing relational graphs from abstracts.
Due to the expense and difficulty of annotation, we only have access to a small number of human-annotated summary graphs, which we use to judge system performance. We call this data the "human test set". For training and development, we take a weakly supervised approach using automatically extracted summary graphs. We use a scientific IE system to extract summary graphs from 196k abstracts and pair them with full papers from S2orc. Entity-relation graphs are also extracted for the full papers. We divide these graph/paper tuples into train, dev and automatic test sets. The dev set can be used for parameter tuning purposes, while the auto test set can be used to compare systems. Randomly sampling 115 examples, we observe that over 90% of extracted target entities for abstracts in the automatic test set are meaningful. Moreover, we will show in Section 7 that similar system performance trends are observed in the "human test set" and "automatic test set". Table 1 gives statistics about the number and size of the textual documents, as well as the summary graphs, for all data splits. The data collection and graph construction details are described in the sections that follow. The automatic test set is much larger than the human test set, which reduces the problems of noise in automatic annotation. 
We leverage the SciERC scientific IE dataset (Luan et al. 2018) for the human-labeled test data. SciERC consists of 500 expert-annotated paper abstracts, labeled with entities (6 types: Task, Method, Metric, Material, Other Scientific Term and Generic), co-reference, and relations (7 types: Compare, Part-of, Conjunction, Evaluate-for, Feature-of, Usedfor, Hyponym-of). We construct knowledge graphs from these annotations by collapsing coreferent mentions into a single node and linking all nodes via the annotated relations.
Of the 500 abstracts in SciERC, 300 have full texts available in S2orc. In order to guarantee information richness, We discard pairs where annotated graphs have fewer than 5 predicted relations. After such filtering, our "human test set" consists of the knowledge graphs and full text of 234 of these documents.
To facilitate model training and model development under a weakly supervised setting, we automatically create target knowledge graphs for the remaining papers from their abstracts. We leverage DyGIE++, a state-of-the-art scientific IE system that extracts entities, relations and co-references simultaneously (Wadden et al. 2019 ). We do not re-train Dy-GIE++, instead we use the pretrained model on SciERC for all processing and modeling steps in this work. We construct knowledge graphs from the IE output by again collapsing coreferences to create entities, which we associate with the list of coreferential text mentions. IE relations between mentions become edges between the corresponding entities in the graph. The same sample filtering is applied. 2
Our task is designed to build a summarized graph directly from a document, and in order to perform the task, models do not have to use specific information extraction tools to build a full graph first. However, we provide the full knowledge graphs that we constructed from documents as part of our dataset for reproducibility and to encourage future exploration on graph learning models for our task. We process each full document text with DyGIE++ in overlapping 300token windows (reduce computation memory) with each two consecutive chunks having one overlapped sentence to preserve cross-sentence co-references. 3 We collapse coreferen-tial mentions as previous steps, and then collapse coreference clusters from different windows with matching unique, non-generic mentions into a single graph node. A nongeneric entity mention is a string (excluding pronouns and determiners) with more than one token, or a unigram with an inverse document frequency (IDF) in the training data that is higher than an empirically chosen threshold, selected for high precision in identifying generic mentions. A generic entity mention is not clustered unless the model predicts it to be coreferent with some other entity mention.
The goal is to evaluate the correctness of the predicted summary knowledge graph compared with the ground truth summary graph. We first align entity nodes in the predicted graph to nodes in the target graph. After the entity alignment step, we measure 3 qualities of the predicted graphsentity salience, relation salience, and duplication rate -under a relaxed alignment condition, described next.
In the "human test set", we found 30% annotated entity mentions do not have exact string match in the main paper text. Further analysis showed that many such cases are due to minor paraphrasing, hyphenation differences or typos caused by OCR parsers that are 1commonly used to process papers in PDF format. For example, in-domain monolingual corpus in the abstract and in domain monolingual corpus in the paper are equivalent but do not have an exact match due to the hyphen difference. In addition, as we do not assume any specific information extraction tools being used, a similar issue for exact name matching may occur, potentially due to different entity mention names being extracted by different models. Therefore, exact string match does not yield a good alignment, and we instead use a relaxed alignment method that we found to be reasonably accurate for evaluation. Another issue in aligning entities between two graphs is that the same entity can be referred to with multiple strings, as each entity node represents a cluster of co-referent entity mentions. To align a predicted node with a target node where either can have a cluster of mention types, we find the maximum similarity over all possible pairs. The similarity score between a target entity v i = {m 1 i , m 2 i , ..., m ni i } and a predicted entityv j = {m 1 j ,m 2 j , ...,m nj j } is calculated as:
where we employ "gestalt pattern matching" (Ratcliff and Metzener 1988) to calculate string similarity based on common substrings. Each predicted node is aligned with the target node that gives the highest similarity score, subject to a minimum score λ. λ = 0.7 is selected such that, in a set of 200 relaxed (but not exact) alignments, 90% of them are manually inspected to be acceptable. • Alignments with Error (10%): We consider entities being aligned that have distinct meanings to be bad alignments. For example, two-dimensional analog of sorting versus one-dimensional notion of sorting.
In both human and auto test sets, applying the relaxed alignment from full graph nodes to target nodes increases the percentage of aligned target nodes from 60% (by exact matching) to 80%.
To calculate entity salience, we align each predicted node with up to one target graph node, collapsing multiple predicted nodes that map to the same target entity into a single node for calculating precision, recall and F1 scores. In other words, if multiple predicted entities are aligned to the same target entity, it is only counted once when calculating all scores. These metrics can be computed either with matching or ignoring entity types (typed vs. untyped evaluation). As each entity should only have one entity type, we adopt the dominating type among all mentions to be the entity type. Since this process does not penalize predicted graphs where multiple nodes are aligned to a single target node, we also calculate the duplication rate as the average number of predicted nodes which are aligned to each target node.
Based on entity alignment, a target relation edge (v i , v j ) can be aligned to a predicted relation for (v k ,v l ) if the corresponding nodes align (i.e., v i aligns tov k and v j aligns tov l ). We evaluate relation salience based on such relation alignments, allowing for multiple relation types between each pair of entities. We report precision, recall and F1 scores for relation prediction, with or without considering relation type and direction matching (typed vs. untyped evaluation). When evaluating without relation type and direction, we merge relations (if multiple) between an entity pair into a single edge.
We develop two baseline models for the graph summarization problem: one using a text summarization model that extracts summary sentences from which we extract entities and relations, and one that first builds a full-document graph and then applies a graph learning model to do graph pruning.
This model first produces a text summary of the full document text using the extractive summarizer BertSumExt (Liu and Lapata 2019) , and subsequently uses entities and relations from the text summary to form a summary knowledge graph. We re-train the original model on our dataset, by replacing the pre-trained BERT with SciBERT (Beltagy, Lo, and Cohan 2019) and increase the sequence length from 512 to 1024. DyGIE++-predicted entities and relations that appear within the text summary are used as the summarized graph.
This model predicts a summary subgraph from the full graph extracted by DyGIE++ (described in Section 4).
We formulate subgraph selection as a node classification problem: we encode the full graph with a GAT (Veličković et al. 2018 ) and use the resulting node representations to make a binary salience prediction.
In the original GAT, a node v i is embedded with a learnable feature vector and contextualized via multi-headed attention with its graph neighbors N (v i ) in each graph attention layer. At each graph attention layer, a vertex v i with neighborhood N (v i ) is contextualized as:
Herev i , v i ∈ R h denote contextualized and original vector representations of v i . W V , W K , W Q ∈ R h×h are model parameters, and α ij are attention weights computed from the vertex representations. The formulation above was extended using multi-head attention and layered with non-linearities to produce the Graph Attention Network.
Since the original GAT does not consider different relation types between neighboring vertices, to incorporate relation types into the model, we use separate heads for different relation types in T R ; that is, the head corresponding to relation type R ∈ T R is used to attend v i over those v j ∈ N R (v i ) where v i and v j are connected by an edge with label R, i.e. (v i , v j , R) ∈ E. As we have 7 different relation types in our dataset, we use 7 heads in our GAT. The representations from all heads are concatenated and transformed via non-linearity between model layers.
At the node embedding layer, we use four features to embed each entity node v i : the number of mentions in the document n i , the section id of the entity's first appearance in the document s i , the most frequent entity type among all mentions as predicted by DyGIE++ t i , and the pooled output representation from SciBERT (Beltagy, Lo, and Cohan 2019) of the longest mention string z i , to encode each node as follows:
where n ∈ R h is a learnable unit feature vector for n i , s i ∈ R ns and t i ∈ R nt are the one-hot vectors of s i and t i respectively, with n s and n t as the number of unique section ids and node (entity) types in the dataset. S (z i ) ∈ R he is the hidden representation at the first token ([CLS]) from the final layer of SciBERT. W s ∈ R h×ns , W t ∈ R h×nt , W e ∈ R h×he are trained model parameters.
Following the node embedding layer, we contextualize each node representation with 6 GAT layers and pass each node through a final binary classification layer to predict salience.
To supervise the training of this model, we apply the relaxed alignment method (in Section 5) to align full graph entities and target graph entities. All full graph entities that can be aligned are treated as positive examples, and all others as negative. Finally, we use a negative log likelihood loss function using all positive (labeled as salient) nodes and a negative sampling ratio of 3 for training.
We include all full graph relations between predicted entities in the output summary graph. We leave better relation prediction for future study.
We manually tune the hyperparameters of GAT based on dev set entity F1 performance curve versus training steps. We fix most of the model parameters (e.g. vector dimension h = 16; number of layers = 6; batch size = 10). The only parameters being tuned are learning rate, dropout rate and negative sampling ratio. But we only manually change each parameter value if we observe performance instability on the dev set for the first 1000 training steps. The average number of tuning trials for each parameter is fewer than 5 times. Finally we set negative sampling ratio = 3, dropout rate = 0.2 and learning rate = 5e-5 for all experiments with our G2G model. We use Adam optimizer. We do not finetune SciBERT (the base model) used in GAT. We run each experiment on a single TITAN RTX. We select the model checkpoint based on its typed relation F1 score performance on valid set.
We compare the TTG and G2G models in Section 6 with two frequency-based baselines: PageRank (PR): the top K most "authorized" entities in the full document graph with the highest PageRank scores (Page et al. 1999) , where each edge weight is initialized by the number of relation mentions between the entity pair; TopK-Freq (TKF): the top K most frequent entities. K is selected to be 18 for both of the models, which is the average number of full graph nodes aligned to target nodes in the training set. In both cases, relations from the full document graphs between the selected entities are added to generate the predicted summary graph. We also report performance of Gold Entity (GE), which provides the performance upper bound when relying on the entities and relations that can be extracted from the full text with DyGIE++. GE picks the full graph node with the highest similarity score for each target node (with a lower threshold of 0.7 for inclusion). Again, the predicted graph includes all relations found in the full graph between these entities. Table 2 shows Precision, Recall and F1 scores for both untyped and typed entity and relation prediction, as well as entity duplication rates for the automatic test set. We see similar evaluation trends with untyped and typed evaluation, with lower scores when type matching is required, as expected. Both G2G and TTG outperform other baselines in both entity and relation evaluations. In particular, G2G consistently performs the best in F1 scores, though TTG has higher precision. When evaluating entity duplication rate, TTG consistently performs the best. However, all systems' performances are still far from GE, which shows significant room for improvement on this task in the future. Table 3 gives the same results for the human test set. Most of the trends observed with the automatic test set hold for the human test set. The exception is that G2G shows better performance on entities, but is less effective on typed relations. Therefore, we argue that the automatic test set is reasonable to be used as an extra set to test systems during development.
We looked at a handful of abstracts in the human test set to analyze the scoring criteria proposed for this task. The target graphs were further hand-annotated to identify the most important entities (among all salient entities in the abstract), eliminating some "generic" nodes (e.g. "method"), non-essential "other scientific term" nodes, and occasional duplicated nodes. In some cases, we added entities that were not in the gold reference but were identified by one or more of the automatic algorithms and deemed appropriate. Entities identified by the automatic algorithms were handaligned to the reduced target set. For untyped entities, the recall is higher on the reduced set for G2G and Pagerank, suggesting that these algorithms may be better capturing the most salient entities. Errors in entity types often involved unclear cases. Trends in precision on the reduced graph were consistent with the automatic scoring. What we also noticed is that some of the aligned predicted nodes contain unrelated entities due to coreference errors from IE systems, which in part explains the low relation scores together with the impact of missing/inserted entities.
We investigate the causes of TKF performing poorly compared with G2G and TTG. In specific, we analyze why frequency may not be a good indicator of salient entities in some cases. We first calculate the average length of mention string names of predicted salient entities, and find out TKF has an average length of 2.1 while both TTG and G2G have 2.5 on average. Furthermore, we find out that some important entities tend to have long string names, especially when paper authors start introducing some specific tasks or models. These entities tend to be split into smaller segments in later parts of the paper for more detailed explanations. Such smaller segments tend to be mentioned more frequently and thus predicted by TKF, although sometimes they are not comprehensive enough to qualify as salient entities. For example, a key entity Bayesian semi-supervised Chinese word segmentation model can be detected as salient by both G2G and TTG while TKF only predicts Chinese words and word segmentation as the closest salient entities. Another exam-ple is that TKF predicts KL-One systems as a salient entity for a paper, while the gold entity is KL-One-like knowledge representation systems which is predicted by both G2G and TTG.
As noted in Table 1 , the sizes of target graphs and full papers are different in the human and automatic test sets. We observe that TTG produces graphs of similar size for papers in the two test sets: about 12 nodes and 7 edges. By contrast, G2G produces graphs of different sizes for different document lengths, averaging 14 nodes and 10 edges for human test set but 22 nodes and 17 edges for automatic test set, where documents are longer (and target graphs bigger).
We observe interesting trends regarding the sections where entities first appear. GE entities appear in the first section of the full paper only 55% of the time, for both auto and human test sets. About 25% and 20% of them have their first mention in middle 5 sections and final sections respectively. These numbers are also consistent with both test sets. This observation highlights the fact that extracting the main idea of the paper needs the understanding of the full paper. However, partly due to the sequence length limitation of BertSumExt, TTG is extremely biased towards entities in the first section (85%). G2G is less vulnerable to such bias (68%), but still often fails to include entities from later paper sections in its summaries. Table 4 shows the entity F1 score based on relaxed match for each different entity type. We calculate these scores by comparing subgraphs of the predicted and target graphs that contain entities of a certain type only. Entities of type "Metric" are the hardest to predict. This correlates with the fact that "Metric" entities are least likely to appear in the first section of a paper (36.7% vs 54.9% overall in human test set). Another possible reason for this is that "Metric" is the least frequent salient entity type. Only 5% and 6% of all target salient entities have the type "Metric", in auto and human test set respectively. Figure 2 : Sample output from G2G and TTG. Figure 2 shows an example where a target "Metric" entity first appearing in the second section of a paper is correctly predicted by G2G, but missed by TTG. The red (incorrect) relation edges show that only relying on full graph relations limits relation prediction performance. This is evidenced in Tables 3 and 2, where even GE gives low relation prediction scores due to the absence of gold target relations in the full document graphs.
We have described a new text-to-graph task for constructing summary knowledge graphs from full text documents, including a standard, preprocessed open-access dataset and evaluation techniques to facilitate further research. We have investigated graph classification and text summarization techniques for this task, and detailed some of their qualities in our analysis.
As we show that relation salience prediction is a rather challenging task in extracting summary knowledge graphs, it would be an important further investigation. Leveraging document-level IE and graph learning techniques would also be an interesting direction to explore. Models that can merge entity nodes better will lead to lower entity duplication rate and improved relation accuracy. One major shortcoming of our GAT model is that we do not consider the context of each entity mention in the document; incorporating contextual information for entity mentions would also be a promising research direction.