Semantic Role Labeling for Knowledge Graph Extraction from Text

This paper introduces TakeFive, a new semantic role labeling method that transforms a text into a frame-oriented knowledge graph. It performs dependency parsing, identifies the words that evoke lexical frames, locates the roles and fillers for each frame, runs coercion techniques, and formalises the results as a knowledge graph. This formal representation complies with the frame semantics used in Framester, a factual-linguistic linked data resource. The obtained precision, recall and F1 values indicate that TakeFive is competitive with other existing methods such as SEMAFOR, Pikes, PathLSTM and FRED. We finally discuss how to combine TakeFive and FRED, obtaining higher values of precision, recall and F1.


Introduction
Most knowledge in linked data and knowledge graphs is of a relational nature: people participating in events, products having prices, artifacts with parts, works of art produced by artists, beers sold at a bar, etc. For that reason, a good part of integration and interoperability ends up consisting in aligning relations among heterogeneous schemas and data.
Email addresses: mehwish.alam@istc.cnr.it (Mehwish Alam), aldo.gangemi@istc.cnr.it (Aldo Gangemi), valentina.presutti@istc.cnr.it (Valentina Presutti), diego.reforgiato@unica.it (Diego Reforgiato Recupero) Less known is the fact that the relations holding between entities are usually part of a larger context or situation: beers can be found at a bar because there is a selling/purchase situation; artists produce works because there is a creative process involved; artifacts are assembled through craftmanship or industrial procedures, products are assigned prices in the market, people are assigned roles in events, etc.
Regardless of the representation language used and its serialization, existing knowledge graphs share a common limit: they express facts that typically lack contextual and situational information. This limit makes interoperability difficult. When two different datasets need to be integrated, implicit situations need to be reconstructed: This happens quite smoothly in humans, but not in knowledge-based systems.
A method to contextualise knowledge graphs is to express the facts that they capture as projections of frames. Frames are cognitive structures that are used by humans for organising their knowledge, as well as for interpreting, processing or anticipating information (cf. [1] for a discussion encompassing both linguistic and knowledge-based approaches to frames). In linguistics, a reference model for frames is Fillmore's Frame Semantics [2], where a frame is introduced intuitively as "a kind of outline figure with not necessarily all of the details filled in". More precisely, a frame is a structure that reifies an n-ary relation with multi-varied arguments, denotes a situation, event, state, or configuration, and is supposed to bear representational similarity to the knowledge encoded in cognitive systems. Any binary projection of a frame is called a semantic role. For example, in the sentence I bought a pair of shoes, the word "bought" identifies an occurrence of a commercial event, where "I" and "pair of shoes" are objects that play the roles of "buyer" and "'goods" respectively in the Commerce buy frame. Fillmore's Frame Semantics has been substantiated by FrameNet [3]: a long-standing, manually developed resource of (English) frames represented in a structured format by a group of linguists in Berkeley.
Recently, two resources have been introduced which support semantic interoperability by using frames: FrameBase [4] and Framester [5]. The idea is simple in principle: since situations are frame occurrences, let's align any schema to a set of frames from a stable ontology, and make data interoperate along that path (if a schema fragment 1 and a schema fragment 2 align to a same frame, the respective data can be jointly queried modulo ontologybased data access, where the ontology of frames is uniform across resources). This is apparently good news, but while an initial ontology of frames can be found in FrameNet, the methods by which we can actually align any existing schema to frames is much less obvious. And the main reason is that the relations defined in schemas, ontologies, and knowledge graphs cannot be trivially aligned to semantic roles.
For example, we need to assign the relation foaf:knows to a semantic role within frames such as framenet:Personal relationship or framenet:Familiarity. However, there is no semantic role corresponding to foaf:knows. The alignment would work only as a result of a path internal to the frame, e.g. an OWL property chain on roles, such as: isP artnerIn o hasP artner.
Current approaches are still struggling with this problem: FrameBase manually aligns relations to semantic roles, leading to scalability issues, while Framester provides an extensive amount of linguistic mappings that help a semi-automated alignment, but a previous linguistic parsing of the relations and their context is required, which is still non-standard, specially considering that only a few ontologies explicitly encode the competency questions that led to the form of their relations.
In practice, the integration of a knowledge extraction approach from competency questions or other textual material, its alignment to Framester, and the usage of dereferencing methods as proposed by FrameBase, collectively seem a viable automated integration solution in the future. In order to foster the research, in this paper we propose a knowledge-graph-based algorithm for labeling semantic roles from an arbitrary text, thus accommodating for the linguistic parsing needed to perform frame alignment prior to interoperability. Our algorithm, called TakeFive, is evaluated, and compared to alternative approaches, with respect to metrics widely applied in two NLP tasks: frame detection and semantic role labeling. The first refers to the ability to automatically detect occurrences of frames in natural language text. The second refers to identifying the fragments of text denoting the entities that play specific roles in a frame occurrence. In this paper, we extend our preliminary work [6], and use Framester [5], a frame-based knowledge graph, to address frame detection and SRL with TakeFive 1 . TakeFive uses NLP resources and software components, but integrates them in a semantic web pipeline that produces knowledge graphs ready to be used for interoperability across data and schemas. We intend to verify if a knowledge-based hybrid method is comparable to purely statistical methods, while retaining the ability to extract a properly linked knowledge graph from a sentence.
As an example of the output of SRL, let us consider the following sentence Despite recent declines in yields, investors continue to pour cash into money funds.
By performing frame detection, we recognize that to pour evokes the frame Pour.v from Framester, subsumed by the frame Cause motion from FrameNet, meaning that the sentence expresses an occurrence of this frame. By performing SRL, TakeFive then labels the investors and cash respectively with the Agent.cause motion role, and the Theme.cause motion role, as both involved in the Cause motion situation occurrence (cf. Figure 1). The annotations use entities from reference ontologies for frames and semantic roles. The remainder of the paper is organized as follows: Section 2 describes related work for SRL and SRL-based knowledge extraction, Section 3 briefly introduces the data, resources and components used by TakeFive. Section 4 presents the TakeFive algorithm. Section 5 describes the evaluation setting, the performance measures, and the results, with a comparison to other tools and a discussio.

Related Methods
Semantic technologies usually leverage syntactic resources to improve their accuracy. Stanford CoreNLP 2 [7], which we use in TakeFive, is one of the most used full-fledged NLP tools, and has been used in the Semantic Web context. However, it has not been extensively employed for SRL (an exception is [8]).
After the development of PropBank [9], where semantic information has been added to the Penn English Treebank data set, and the CoNLL shared tasks on semantic role labeling [10,11], there has been a lot of research in this domain, typically using PropBank as the reference ontology for roles. Prop-Bank is a data set consisting of the phrase-structure syntactic trees from the WSJ section of the Penn Treebank. Its annotations include predicateargument structures for verbs and defines a small number of roles: core roles are ARG0 through ARG5, which can be interpreted differently for different predicates. Further modifier roles ARGM* include e.g. ARGM-TMP (temporal) and ARGM-DIR (directional).
The semantics of the core roles ARG0-ARG5 is not straightforwardly clear. The study described in [12] shows that the roles ARG2-ARG5 serve many different purposes for different verbs, and points out that they are inconsistent and highly overloaded. In order to improve the performance for the SRL task, the arguments were mapped to VerbNet thematic roles. Others, e.g. [13] revised the syntactic subcategorization patterns for FrameNet lexical units, using VerbNet. While PropBank labels the roles of verbs with a limited number of tags, frame-semantic parsing labels frame arguments with framespecific roles, making it clearer what those arguments may mean. Therefore, for frame-semantic parsing, sentences may contain multiple frames that need to be detected along with their arguments. SemEval 2007 task 19 [14] addressed this problem. The task leveraged FrameNet 1.3 and released a small corpus containing more than 2000 sentences with full text annotations.
The work described in [15] projects predicate-argument structures from seed examples to unlabeled sentences using linear program formulation to find the best alignment related to the projection. The projected information and the seeds are both used to train statistical models for SRL. In addition, the authors introduce a method for finding examples for unseen verbs using a graph alignment tool, which was used to project annotations from seed examples to unlabeled sentences.
In [16,17] the authors use an unsupervised approach for SRL that aims at inducing semantic roles automatically from unannotated data. Although this can be useful to discover new semantic frames and roles, in this paper we focus on the concrete representation provided in FrameNet and VerbNet, without expanding their inventory of semantic types.
Authors in [18] introduce a semantic parser that uses a broad knowl-edge base created by interconnecting FrameNet, VerbNet and PropBank. SEMAFOR [19] 3 is a well known system for frame-semantic parsing, based on the combination of knowledge from FrameNet, two probabilistic models trained on full text annotations released along the FrameNet lexicon, and expedient heuristics. At SemEval 2007 it outperformed existing approaches. FRED 4 [20,21] is the state-of-the-art tool for producing framed knowledge graphs for the Semantic Web. It consists of a complex pipeline of NLP and Semantic Web components for parsing text, representing it to a neo-Davidsonian logical form, extracting entities, disambiguating predicates, linking them to public resources, and creating a well-connected, formal and queryable knowledge graph out of that. FRED uses a "greedy" approach for SRL, i.e. it labels roles with reference labels (from either VerbNet or FrameNet) when the confidence of its categorial parser is high, otherwise it uses other heuristics to provide meaningful local labels that make sense in that textual context. PIKES [22] 5 is a tool that automatically extracts things of interest and facts about them from text. PIKES applies a number of NLP tools to annotate a text, and applies a linked-data-oriented approach to generate RDF graphs.
PathLSTM is a SRL system introduced in [23], which builds on top of the mate-tools semantic role labeler 6 . It leverages neural sequence modeling techniques: the authors model semantic relationships between a predicate and its arguments by analyzing the dependency path between a predicate word, and each argument head word. Lexicalised paths are considered, which are decomposed into sequences of individual items, namely the words and dependency relations on a path. Long-short term memory networks are then applied to find a recurrent composition function that can reconstruct an appropriate representation of the full path from its individual parts.

Lexical resources used by TakeFive
In this section we describe the lexical resources that we leverage in order to design TakeFive.

VerbNet
VerbNet [24] is a broad coverage verb lexicon in English, with links to other data sources such as WordNet [25] and FrameNet [3]. It contains semantic roles and verb classes corresponding to Levin's classes [26], and including multiple verb senses. Verb classes can therefore be considered akin to word synsets. They generalise the verbs based on their shared syntactic behavior. These verb classes feature a simple two-layer hierarchy. For example, the verb conquer is a member of the class subjugate-42.3, and hence a sense Conquer 42030000 is created (the sense of conquer in that class).
VerbNet further contains semantic roles, which correspond to the relations between a verb sense and its arguments. Each class has multiple frames (either syntactic-or semantic-oriented), which define a list of predicates associated with their arguments. There is a (partial) morphism between syntactic and semantic frames, so that semantic roles ("arguments") are also associated with patterns that characterize the syntactic behavior of a verb in that class. For example, the roles defined for the class subjugate-42.3 are Agent, Patient and Instrument meaning that an agent subjugates a patient with some instrument. Here Agent and Patient are necessary roles, and Instrument is an optional role. Verb senses help in determining if a particular verb instance conforms to the underlying semantics of the class. For the case of the verb conquer its only sense is included in the class subjugate-42.3. VerbNet maps verbs to FrameNet frames, e.g. the verb sense Conquer 42030000 is mapped to the frame Conquering. The version of VerbNet used in TakeFive evaluation is 3.1, and the data come from the RDF porting of VerbNet 3.1 that is included in Framester 7 [5].

FrameNet
FrameNet [3] contains frames, which describe a situation, state or action. Each frame has semantic roles ("frame elements") that are much more semantically detailed than VerbNet ones. FrameNet also defines a subsumption relation between either frames or roles. The subsumption relation can be used to create a hierarchy of classes, as shown in [27]. Each frame can be evoked by lexical Units (LUs) belonging to different parts of speech. In version 1.5, FrameNet covers about 10,000 lexical units and 1024 frames. Let us consider the following sentence: In the above example, The Spaniards is the argument (we will also refer to it as filler) of the role Conqueror and the Incas is the argument (or filler) of the role Theme and conquered is the lexical unit evoking the frame.

Framester
Framester [5] is a large RDF 8 knowledge graph (currently including about 50 million triples), acting as a hub between several predicate oriented linguistic resources such as FrameNet, WordNet, VerbNet [24], BabelNet [28], Predicate Matrix [29], as well as many other linguistic, factual, and foundational knowledge graphs. It leverages this wealth of links to create an interoperable and homogeneous predicate space represented in a formal rendering of frame semantics [2] and semiotics [30]. Framester uses a novel mapping between WordNet, BabelNet, VerbNet and FrameNet at its core, expands it to other linguistic resources transitively, and represents all of this formally. It further links these resources to other important ontological and linked data resources Framester is accessible through its SPARQL endpoint 9 . Framester also features a subsumption hierarchy of semantic roles (i.e. frame elements) and adds generic roles on top of frame-specific roles.
Framester also offers a Word Frame Disambiguation (WFD) service based on the mappings defined within the resource. It is available as a frame detection API which is implemented using UKB and Babelfy as the Word Sense Disambiguation algorithms as a first step and then the second step uses the mappings between WordNet/BabelNet synsets and FrameNet frames. The associated REST API is available online 10 .

Semantic Role Labeling Algorithm
TakeFive generates role oriented knowledge graphs given an input sentence. The algorithm begins by detecting the verb (lemma and VerbNet verb class), along with its arguments, and then it relates it to their corresponding 8 https://www.w3.org/TR/rdf11-primer/ 9 http://etna.istc.cnr.it/framester2/sparql 10 https://lipn.univ-paris13.fr/framester/en/wfd_html VerbNet roles. According to our running example 2, TakeFive detects the verb conquered and then extracts the VerbNet roles of this verb i.e., Conqueror and Theme. Finally, it assigns the role fillers i.e., The Spaniards as a filler of Conqueror and the Incas as the filler of the VerbNet role Theme. The backbone of TakeFive follows a step-wise approach: (i) preprocessing step for extracting dependencies and frame annotations using existing tools (i.e., CoreNLP and Word Frame Disambiguation respectively), (ii) detecting (CoreNLP-derived, mainly syntactic) interface roles, (iii) VerbNet specific roles (mainly semantic) for a certain frame, and then finally, (iv) checking the compatibility between interface and semantically specific roles. In other words, we aim at using background knowledge and formal reasoning in order to associate semantic roles with syntactic dependencies. In the rest of the paper, we use the following terminologies: -CoreNLP interface roles for the roles generalising CoreNLP dependencies as well as resource-specific semantic roles; -VerbNet specific roles for the VerbNet roles related to a certain verb sense; -VerbNet interface roles for the roles that subsume VerbNet specific roles in Framester, and are subsumed by an interface role.

Pre-processing step
Framester and CoreNLP. For a given input sentence, frame detection using Word Frame Disambiguation (WFD) is performed. It uses Babelfy as a WSD algorithm and then uses the mappings between BabelNet Synsets and FrameNet frames as given in Framester. The dependency tree is extracted associated to a given input sentence using CoreNLP. Listing 1 shows a dependency tree returned by CoreNLP for the running example.
Assigning Interface roles to CoreNLP dependencies. TakeFive is based on 23 simple heuristics for mapping CoreNLP dependency triples to interface roles. For the running example, we have a dependency nsubj, conquered-3, Spaniards-2 related to the verb conquered, and its argument Spaniards. Dependency types such as nsubj, dobj,... are generalized to CoreNLP interface roles through a set of heuristics e.g., by applying the rule nsubj → Agent i.e., the role Agent is assigned to the argument Spaniards. The set of interface roles include {Agent, Undergoer, Recipient, Eventuality, Oblique}.

TakeFive: A Semantic Role Labeling Algorithm
This section discusses the two algorithms proposed for labeling a given sentence with the VerbNet specific and VerbNet interface as well as a way to check the the compatibility between the CoreNLP interface roles (as assigned previously) and VerbNet interface roles. Algorithm 1 computes VerbNet interface and specific roles of extracted verbs from an input sentence.

Computing VN Interface and Specific Roles
Algorithm 1 takes the pre-processed information as an input i.e., (a) the sentence, (b) dependency tree obtained by CoreNLP and (c) the output of frame annotations obtained using WFD. It then returns the input sentence labeled with VerbNet specific as well as VerbNet Interface roles. If the verb is polysemic then it uses frame detection for extracting VerbNet roles (line 2-4, see Algorithm 2), otherwise it gets the verb sense using the SPARQL query in listing 3. If it returns more than one verb sense it selects the one which is most frequent (see query in listing 6) and extracts the VerbNet specific roles along with VN interface roles, if any (line 6-9, see listing 5). If the result is empty, it uses frame detection for obtaining the VerbNet roles described in Algorithm 2.
Algorithm 2 and 3 are used in case of polysemous verbs. The algorithm takes as an input a sentence and annotates it with frames (line 1). If there are no frame annotations it takes the most frequent verb sense using SPARQL query in listing 6 and then the VN specific and interface roles associated to the this verb sense through SPARQL query in listing 5 (line 2-5). If the Word Frame Disambiguation API returns multiple frames and there is a relation between these frames, the most specific frame is chosen (line 7-16) (see Algorithm 3). Then, given the verb and the chosen frame, VerbNet senses are extracted using listing 4 (line 17). If no verb senses are returned then the most frequent verb senses are extracted for getting the VerbNet specific roles (line [18][19][20]. However, if there are more than one verb senses then the most frequent verb sense is chosen. An intersection of both the queried and returned sets of verb senses is taken and the verb sense with highest ranking based on frequency of verb senses in WordNet is selected and the corresponding VN role is returned (line [22][23][24][25][26][27][28][29][30]. If both the above cases are false the VN role associated to the verb sense is selected (line 32).

Checking Compatibility of CoreNLP interface roles
The objective here is to return, all roles and fillers for each argument of verbs from the input sentence if the interface roles assigned using the two methods (i.e., heuristics and algorithm 1) are compatible. Let O = {Agent, Undergoer, Recipient, Eventuality}, C be the CoreNLP interface vnrole ← given verbSense extract VN roles using query 5 ; 5 end roles (assigned using heuristics such as nsubj → Agent), V be the VerbNet interface roles and R be the VerbNet specific roles; where V and R are returned by algorithm 1 for a given sentence. For v 1 ∈ V , c 1 ∈ C and r 1 ∈ R, if v 1 = ∅ and r 1 = ∅, then c 1 is assigned. However, if v 1 = ∅ and r 1 = ∅, then the following rules are defined: -The algorithm starts by choosing verb having at least one VN sense and takes c 1 and v 1 . If c 1 ∈ O and v 1 ∈ O then the pair (c 1 , v 1 ) is marked compatible and r 1 is returned such that r 1 ∈ R and v 1 associated to r 1 (returned by Algorithm 1).
-If c 1 and v 1 associated with verb are oblique check for a preposition along with CoreNLP dependencies triples having the modifier nmod and then return r 1 such that r 1 is compatible with the preposition according to VerbNet verb arguments. The association between the VerbNet arguments and the prepositions are already defined in VerbNet and now standardized in RDF in Framester linguistic linked data hub as shown in Listing 2 (we also make use of the Preposition Project dataset, which is another linked dataset in Framester).
-If c 1 = Agent or c 1 = Undergoer and c 1 = v 1 then select the top role of the subsumption hierarchy associated to VerbNet interface role (defined by the predicate fschema 11 :subsumedUnder). If the top role is Theme then select v 1 .
Algorithm 3: Obtaining VerbNet Roles using Frame Detection if frames are detected. 6 for f 1 ∈ f rames do

Evaluation
This section details the experimental setting, and the two evaluation procedures for measuring the performance of the TakeFive SRL algorithm. It also describes a comparison between TakeFive and other SRL tools.

Implementation details
The algorithm is developed in Python and uses REST-APIs for Framester and Stanford CoreNLP. It also employs Py4J 12 as a bridge between Python and Java. A Java class was developed which can directly be called from the main Python code through Py4J. It can be faster if a cache mechanism is used to store Framester results, and SPARQL queries to the Framester endpoint. The TakeFive SRL tool is available on-line 13 .

Evaluation setting
The performance evaluation was conducted for verifying if the chosen VerbNet roles associated with fillers are correct or not. We used the WSJ section of the Penn Treebank annotated with VerbNet and PropBank labels 14 . These annotations include the VerbNet and PropBank roles associated with each verb of each sentence of the dataset, and related to each filler. As an example, consider the following sentence contained in the WSJ annotated dataset: The Canadian pig herd totaled 10,674,500 at Oct. 1, down 3 from a year earlier, said Statistics Canada, a federal agency.
The two verbs totaled and said are indicated in the annotations together with their VerbNet verb classes, as well as their VerbNet and PropBank roles and fillers. In particular, Table 1 shows the annotations for sentence 3.
Performance evaluation was conducted by computing precision, recall and F1 score using the official CoNLL-2009 scorer 15 [31]. The CoNLL-2009 scorer evaluates the semantic frames by reducing them to semantic dependencies. A semantic dependency from every predicate to all its arguments is created. These dependencies are labeled according to their corresponding arguments. Additionally, a semantic dependency from each predicate to a virtual ROOT node is added. The latter dependencies are labeled with the predicate senses. This approach guarantees that the semantic dependency structure forms a single-rooted, connected (but not necessarily acyclic) graph. It can be seen that the scoring strategy gains some points even though a system assigns the incorrect predicate sense. For further details refer to [32,31].
In order to use the CoNLL scorer when comparing to other methods, we formatted the output of TakeFive as well as that of the other tools as required by the CoNLL-2009 scorer. Finally, for compliance purposes, we employed SemLink 16 to map VerbNet roles to PropBank roles.

Results
The results obtained by TakeFive have been compared to other state-ofthe-art methods, including SEMAFOR, Pikes, FRED, and PathLSTM (for details (see Section 2)). As FRED and TakeFive are two resources maintained by overlapping teams, we have also combined their results by including all the VerbNet roles extracted by FRED into the results of TakeFive; we named this new algorithm as TakeFive+FRED. First of all, the onf files (2454) of the WSJ corpus 17 were processed. Each file contains input sentences and their parse trees. The gold standard has 74977 rows. Each row corresponds to a verb in a given sentence and includes the VerbNet verb class, fillers and VerbNet and PropBank roles associated to that verb. Different rows might refer to the same sentence (as there might be several verbs within a given sentence). As already mentioned, when labeling each sentence using Take-Five, we extracted Framester and CoreNLP information (frames, dependency triples, POS tags, etc.). To speed up the experiments, we used a cache mechanism so that the information is downloaded only once (the cache mechanism is not currently available in the on-line version of TakeFive software). Table 2 shows the labeled and unlabeled precision, recall and F1-measure values of TakeFive, TakeFive+FRED, and the competitors, SEMAFOR, Pikes, PathLSTM and FRED. Labeled scores are related to the correct identification of labeled dependency whereas Unlabeled scores do not take into account labels. For example, for the correct proposition: verb.01: ARG0, ARG1, ARGM-TMP, the system that generates the following output for the same argument tokens verb.02: ARG0, ARG1, ARGM-LOC receives a labeled precision score of 2/4 because two out of four semantic dependencies are incorrect: the ROOT dependency is labeled "02" instead of "01" and the dependency to the "ARGM-TMP" is incorrectly labeled "ARGM-LOC". On the other hand, the same example would receive an unlabeled precision score of 4/4. SEMAFOR is the method with the highest accuracy. Our proposed approach is the second best, however the numbers are very close to that of SEMAFOR. We noticed that FRED has some internal issues with the offset extraction of words of the sentence and this affects the output representation. As far as Pikes is concerned we have observed that it misses some important roles for tokens. Its SRL engine is based on mate-tools 18 , further developed in [33]   The combined approach TakeFive+FRED is able to slightly outperform SEMAFOR. FRED captures complementary roles which TakeFive is unable to detect. Based on this intuition, we believe that future experiments on optimal combination of multiple SRL approaches might yield the best results.
A different strategy?. While the results with CoNLL indicate that TakeFive performs as good as state-of-the-art methods, and better in ensemble, in a semantic web context the evaluation strategy may be too lightweight. In order to test this, a different evaluation strategy has been conducted (not detailed here for space reasons, see [6]), which follows more closely the kind of SRL extraction that is supposed to be represented in a knowledge graph. The results with this second evaluation strategy show a lower accuracy (more than half than the one obtained with the CoNLL scorer) because i) in strategy 2 we defined the score so that a matching is verified only when the role filler contains all the exact words of the gold standard, ii) in strategy 2 we took into account VerbNet roles. The first evaluation method is based on CoNLL2009 score which takes into account the head words only, and PropBank roles. The latter are much lower in number with respect to their corresponding VerbNet elements. Moreover, matching the head word only for a certain filler probably oversimplifies the matches.
The main lesson learned is that NLP evaluation settings may be inadequate when measuring the absolute performance of a semantic task as complex as SRL. Since the contrastive results show that the differences in method performance are consistent, even if at different accuracy levels, the accuracy seems to entirely depend on the "resolution" or sensibility of the setting. We recommend to define knowledge-graph-oriented benchmarks and scorers, and, in the particular case of SRL, to revisit the way role ontologies are designed.

Conclusions and Future Work
In this paper we have addressed the problem of frame parsing jointly using Framester and Stanford CoreNLP in a novel implemented algorithm, TakeFive. In particular, we aimed at detecting verb frames and their labeled arguments (semantic roles and fillers). In order to assess the quality of our approach, we have carried out a comparative performance evaluation between TakeFive, and other SRL tools including SEMAFOR, FRED, Pikes, PathLSTM. TakeFive, the only one using a hybrid knowledge-based approach, is close to the best with the Wall Street Journal corpus from the Penn TreeBank. We have also observed that a simple ensemble of TakeFive, and the FRED machine reader, produces the best overall results.
We have noticed that natural texts (even in the reasonably controlled production of the Wall Street Journal) contain many more linguistic phenomena than expected in existing manually developed resources such as VerbNet (for this reason, FRED uses a greedy algorithm for SRL instead of one that is closed under one specific resource).