Semantic Web Machine Reading with FRED

2.1. From Discourse Representation Structures to RDF/OWL n-ary relations

The core of FRED takes as input Discourse Representation Structures (DRSs), based on Hans Kamp’s Discourse Representation Theory (DRT) [25]. DRSs, informally called “boxes” (due to their graphical representation), represent natural language sentences, and include two parts: a set of discourse referents, and a set of conditions providing the interpretation of the discourse referents. The DRS language is within first order logic, and its discourse referents are arbitrary entities, including events modeled according to a neo-Davidsonian semantics [25].

OPEN IN VIEWER

Fig. 3.

Boxer versus FRED result (in two varieties labelling with either VerbNet and FrameNet frames and roles) for the sentence “People love movies”, which exemplifies the case of a box that does not add any semantics to its content, which in turn maps to a specific frame.

The DRSs taken by FRED as input are produced by Boxer [5], which performs deep parsing out of Combinatory Categorial Grammar (CCG) parse trees [47]. It also makes use of both VerbNet [27] and FrameNet [4] for frame labelling and semantic role labelling, i.e. representing event types and the relations (thematic roles) between events and their participating individuals. Figure 3(a) exemplifies a box for the sentence “People love movies” as it is returned by Boxer: the box is divided into two sections, the top section contains the discourse referents, in this case x0, x1, x2; the bottom section contains the predicates that constrain their interpretation: x2 is an event described by the predicate love having two arguments, an agent x0, of type people and a patient x1, of type movie. For more details about Boxer and the syntax of its output, the reader can refer to [5].

Although the example in Fig. 3(a) is very simple, DRSs can be very complex, depending on the input text. Therefore, the problem of transforming DRSs to RDF/OWL models requires non-trivial design decisions on how to represent discourse referents and their interpreting predicates. In the case of Fig. 3(a), there is one box, which encapsulates a single event controlling all discourse referents. Therefore, the box content can be represented as an RDF/OWL n-ary relation modelling the identified event (frame), with its arguments modelled as typed individuals, and thematic roles modelled as object properties: the corresponding FRED output is shown in Figs 3(b), 3(c). Events are modelled as subtypes of the class dul:Event. The reader may notice that FRED also performs skolemization of first-order predicate variables, e.g. x 0 becomes fred:people_1, as well as alignment of predicates to existing semantic web ontologies, e.g. with owl:equivalentClass triples. The skolemization of the event occurrence, its event type, and the labels for its semantic roles are currently given in two varieties following either VerbNet or FrameNet. In the first case, the event type fred:Love is aligned to vn.data:Love_31020100, and therefore roles are labeled as vn.role:Experiencer and vn.role:Theme respectively.

In the second case, the event type fred:Love is aligned to ff:Experiencer_focus, and therefore roles are labeled as fe:Experiencer:experiencer_focus and fe:Content:experiencer_focus respectively.

Natural language text on the web is rarely such simple as “People love movies”, hence the possible configurations of boxes and their contents have a wide range of complexity. In this example, the box itself does not add any special semantics to its content, but this is not always the case. One of the design issues addressed by FRED is to assess whether a box has its own semantics or not.

OPEN IN VIEWER

Fig. 4.

Boxer versus FRED results for examples of sentences expressing states of affairs (mostly) by means of the copula.

There are two main basic types of boxes that FRED needs to distinguish: (1) boxes only having a syntactic role in Boxer’s result, meaning that FRED only needs to focus on representing their content, and linking them to the rest; (2) boxes providing a unified relation to a complex state of affairs (usually expressed in the text by a copula), meaning that they have their own semantics to be represented. Figure 3 is an example of (1), where the content of the box is represented as an n-ary relation expressing an event love_1 that keeps together the entities participating in the event. Hence, the box does not add any significant information: the love frame is the main informative and unifying element. Other examples of (1) are the sentences “Valentina is a researcher” and “Valentina is happy”. In these cases, the output of Boxer has always the same structure, as depicted in Fig. 4, which includes three boxes, one predicate ( researcher ) applied to a discourse referent (a named entity in the examples). The boxes here would indicate special states of affairs, e.g. the typing of an entity, and the relation of an entity to its quality, respectively. The boxes here are redundant as all discourse referents are controlled by the same and single predicate characterising their content. FRED detects such special situations and maps them to specific semantic relations after getting rid of the boxes: as for the examples in Fig. 4 these are rdf:type in the first case (Fig. 4(c)), and dul:hasQuality in the second case (Fig. 4(d)). The reader may notice that Boxer tries to assign a type to the named entities that it detects, in the case of Fig. 4(a) “Valentina” is assigned with the type loc, which stands for “Location”. These assignments have a typically low accuracy in a sample-based validation, hence FRED bypasses them, and handles named entity typing by exploiting external semantic web resources when possible, or by simply leaving the individual untyped otherwise.

The case (2) refers to those state of affairs that are expressed neither by means of events nor as typing/quality assertions. For example, let us consider the sentence: Valentina is Gianni’s fifth daughter, from his second marriage. Figure 5 shows the results of Boxer and FRED for this sentence. In this case, the box declaring the x5 discourse referent has a specific semantic role: it frames the state of affairs (situation) expressed by the sentence. In fact, this box conveys the semantics of a unifying relation between all discourse referents and predicates contained in the first box by defining a co-referencing statement for x0 and x2 (by using a redundant box), and the from predicate. Therefore, FRED represents this box in the graph as an individual fred:situation_1 from the class boxing:Situation, which models a unified relational context for the individuals and relations corresponding to boxed content.

These basic patterns for boxes and their contents can be composed by means of formal relations such as and, or, entails between boxes. Furthermore, boxes can be nested, negated, or can include more than one event, or no events. These combinations and variety of content give rise to complex configurations that may cause the emergence of additional patterns to be handled by appropriate heuristic rules.

OPEN IN VIEWER

Fig. 5.

Boxer versus FRED result for the sentence “Valentina is Gianni’s fifth daughter, from his second marriage”, which exemplifies the case of a box carrying the semantics of a state of affairs.

RDF vocabularies for DRSs The development of FRED involved also the creation of two OWL vocabularies: one, referred by the prefix boxer: for representing a taxonomy of types defined and used by Boxer as first class objects, such taxonomy includes types such as “person”, “organisation”, “location”, etc.; the other, referred by the prefix boxing:, for representing boxes (boxing:Situation), relations among boxes (i.e. boxing:entails, boxing:union), connecting boxes with their participating entities (e.g. boxing:involves), as well as other properties such as modality, negation, etc.

FRED also represents modality, tense and negation in its unified OWL/RDF graph, by identifying the corresponding patterns in Boxer output. Let us consider the example sentence “Rahm Emanuel says he won’t resign over police shooting.” and its corresponding FRED graph depicted in Fig. 6.

OPEN IN VIEWER

Fig. 6.

FRED graph for the sentence: Rahm Emanuel says he won’t resign over police shooting.

Tense representation is addressed by modelling a time interval (e.g. fred:now_1 in Fig. 6) that refers to what in the text is (possibly implicitly) expressed with the linguistic present tense: hence such “present” may not refer to the time at which the sentence was written or published, or the time of actual happening of the mentioned events. All events and situations expressed in the sentence are related to fred:now_1) by means of a relation from a set of object properties inspired by Allen’s interval algebra (before, after, included, etc.), depending on the tense of the verb that expresses them. For example, in Fig. 6, the event fred:say_1 is included in the fred:now_1 time interval as it is expressed with present tense, while fred:now_1 is “before” fred:resign_1, as the latter is expressed with future tense.

Modality and negation are represented with a lightweight, RDF-oriented semantics, because the underlying natural language semantics is unpredictable, and poses controversial problems from both linguistic and philosophical perspectives [8].

As far as negation is concerned, given two sentences with a similar syntactic structure, the negated scope is often ambiguous to interpret. For example, the sentence “John did not go to school by car” can be formally represented in different ways. For example (using a neo-Davidsonian first order logic style), it can be represented as: ¬ ∃ e ( go ( e , John , s , c ) ∧ Event ( e ) ∧ School ( s ) ∧ Car ( c ) ) meaning that “there is no event in which John went to school by car”. The negation in this case is applied to the event e, whose arguments are John, the school and the car. There is no assumption as to what argument, if any, has a special role in the negated situation. Another possible formal representation of the same sentence is the following: ∃ e ( go ( e , John , s , c ) ∧ Event ( e ) ∧ School ( s ) ∧ ¬ Car ( c ) ) meaning that “there is an event in which John went to school, but not by car”. In this case the negation is applied to one of the arguments, i.e. the car, and an explicit assessment that the event John went to school happened, is made.6

This is why FRED only annotates (using the property boxing:hasTruthValue) the referenced event with the information that its truth value is false, without making any assumption on the impact of negation over logical quantification and scope. The main limit of this approach is that the resulting representation does not trigger any automatic reasoning. The main benefit is that client applications have a hook to the negated event, and if needed, they can refactor the graph (e.g. with a SPARQL CONSTRUCT query) in order to express their desired interpretation, including rule-based or statistical approaches to decide what formal semantics to apply in each case.

As for modality, OWL lacks formal constructs to allow the required expressivity. The approach is then similar to the one for negation. Modality in FRED can be twofold: boxing:Necessary (corresponding to forms such as “will”, “must”, etc.) and boxing:Possible (for forms such as “may”, “might”, etc.). Both are individuals of the nominal class boxing:Modality. Note that the form “should” is represented with boxing:Necessary, by FRED. The English dictionary indicates two possible interpretations/uses of “should”, one for indicating “obligation”, the other for indicating something “probable”. However, it also indicates that “in modern English uses of should are dominated by the senses relating to obligation”. This is why FRED represents occurrences of should as expressions of “necessary” modality.

For the sentence of Fig. 6, the triples:

formalise the “will not resign” fragment, including modality and negation.

As the output of Boxer does not tag compound terms explicitly, FRED extracts them by recognising two main patterns in the input DRSs. Given a compound term “term1 term2” the two predicates forming it (“term1” and “term2”) can be represented by Boxer either as a dependency relation (i.e. term1(x0), term2(x1), nn(x0, x1)), or as two co-referent predicates (i.e. term1(x0), term2(x0)). FRED implements a compositional semantics on identified compound terms, exemplified in Fig. 6 for the expression police shooting.

FRED creates a class representing the compound term, e.g., fred:PoliceShooting, then it builds its corresponding taxonomy, e.g.,

based on the rationale that the modifier of the main concept (“police”) provides a distinguishing feature to the more specific class. This feature used to be called in ancient logic differentia specifica, and can be either a quality (typically expressed by an adjective or an adverb), or another concept (typically expressed by a noun). In the latter case, a new class is created for the concept, e.g. fred:Police, together with a triple associating such a class with the original class derived from the compound noun, e.g. fred:PoliceShooting. To this aim, the DOLCE property dul:associatedWith is used. The following triples (represented in Turtle notation) show this compositional FRED design pattern applied to the example sentence in Fig. 6:

The case of adjectives and adverbs expressing a differentia specifica is different from nouns. Adjectives in particular have an unpredictable and unstable semantics as nicely explained by Morzycki in [35]. FRED represents such modifiers (i.e. adjectives) as qualities of the modified term by means of the DOLCE property dul:hasQuality. But the quality can alternatively modify the individual denoted by the term, or the class expressed by that term. In a recent work, [19] reinterprets and augments Morzycki’s distinctions, and provides an ontology of adjectives with a set of associated knowledge representation patterns, based on two main aspects of adjectives: sectivity and framality. Sectivity impacts on the semantics of classes and individuals that are modified by adjectives, while framality is the ability of an adjective to activate a conceptual frame (in Fillmore’s sense [15]), and can be used for explaining sectivity phenomena. FRED implements an algorithm that leverages the theory and resources developed in [19] for applying the most appropriate representation pattern in presence of adjective occurrences. For example, FRED is able to distinguish the two main types of adjectives:

In the special case of Fig. 5, the fragment fifth daughter is part of a “periphrastic expression”, which leads to a special representation in FRED, as explained in the next section:

2.4. Generating periphrastic relations

There are many cases of relations that are expressed (and annotated by NLP tools) by means of prepositions, e.g. of, with, for, in, etc. Naming an object property in a semantic web graph with one of those terms, e.g. of, results meaningless and identical to many other relations that actually may mean a completely different concept. For example, of from “survivor of” has a different meaning (closer to among) from the of from “sister of”. In those cases FRED performs a paraphrasing task by identifying the noun to be associated with the preposition, and putting it before the preposition in order to form the label of the resulting relation. For example, the sentence “He was the only survivor of the expedition.” would be formalised by generating the following triples:

2.5. Named entity recognition, entity linking, and coreference resolution

Named Entity Recognition (NER) is used for identifying elements in a text that should have a corresponding OWL individual in the graph. FRED also integrates the results of Entity Linking (EL) performed on the input text for enriching its output graph with owl:sameAs axioms. For example, in Fig. 6, the reader may notice the following triple:

Co-reference resolution and role propagation output is used for merging nodes, for example in Fig. 6 the reader may notice that the individual fred:Rahm_emanuel is both the agent of the event say_1 and of the event resign_1, while in the text he was referred first by his name, and then by the pronoun “he”.

2.6. Word sense disambiguation for ontology alignment

FRED produces RDF/OWL ontologies having classes (and related taxonomies) depending on the lexicon used in the text. FRED exploits word sense disambiguation (WSD) in order to provide a public identity to these classes by identifying equivalent or more general concepts from WordNet and BabelNet [36], and by creating alignments, where appropriate. WSD also enables FRED to generate alignments to two top-level ontologies: WordNet “supersenses” and a subset of DOLCE+DnS Ultra Lite (DUL) classes. For example, the term programming language is formalised by the following alignment axioms:

Since Wikipedia is rich in “conceptual” entities, EL is also used for disambiguating the sense of words after a process of contextualisation and formal interpretation: if a text segment annotated by EL was originally annotated by FRED as an owl:Class, the resolved DBpedia entity is also given the semantics of an owl:Class. Therefore, if an individual in the graph is typed by the original FRED class, it will be typed by the DBpedia entity as well (FRED here applies an inheritance pattern). This ends up being a way of coercing the semantics of DBpedia entities, where applicable.

2.7. Other FRED’s capabilities

Multilinguality FRED takes as input a text in one of 48 different languages, it translates it in English and then processes it for producing its corresponding graph. Therefore, the resulting graph always has English labels. As for the translation, FRED currently relies on Bing Translation APIs.7

OPEN IN VIEWER

Fig. 7.

FRED pipeline.

Textual annotation grounding As part of its OWL/RDF output, FRED provides annotations that link text fragments to their corresponding graph elements. These annotations are expressed by means of the Earmark vocabulary [39] and the NLP Interchange Format (NIF) [23].

FRED takes as input a text in natural language (NL). It can be a short text (to be processed at once) or a corpus of NL documents; at the moment, the latter is available only by using the fredlib Python API. The input text is processed and transformed into DRSs. This processing includes also frame detection and semantic role labelling (based on VerbNet [27] and FrameNet [4]), identification of relations between frames, named entity recognition (NER) and coreference resolution (CRR). Boxer [5] is in charge of producing DRSs (see Section 2 for more details about Boxer) nevertheless, after observing a significant number of cases during FRED implementation and experience of usage, it emerged that Boxer’s pronoun CRR capability is limited. For this reason FRED also integrates CoreNLP9

Implementation This phase is implemented as a Python software component that uses system calls for getting Boxer, TAGME and CoreNLP outputs, integrate them in an internal representation and pass the result to the next component.

In this phase a first version of the graph is created. The component in charge of this task is implemented as a manager of ~100 heuristics that remove redundancies, associate a OWL/RDF representation to each identified pattern in the input DRSs (described in Section 2), and combines them. At this stage, FRED performs taxonomy induction, variable reification, role propagation, periphrastic relation extraction, frame and situation modelling, semantic role labelling, lightweight representation of negation and modality, tense modeling, and representation of both individual and intensional qualities. Figure 8 shows the result of this phase for the sentence “Rahm Emanuel says he won’t resign over police shooting.”. The reader may notice that the type assigned by Boxer is kept in this preliminary model and represented by means of a boxer:possibleType triple, which will be evaluated and possibly discarded in the next phase. Two events are modeled as n-ary relations based on the detected VerbNet frames “Say” and “Resign” and the result of semantic role labeling. Negation and modality are also represented for the event instance resign_1. Finally, a taxonomy is induced and added to the graph due to the recognition of the compound term “police shooting”.

Implementation This phase is realised by a set of Python modules that implement the heuristics described in Section 2. The resulting component is deployed as a REST service, meaning that it is possible to programmatically access the output of the heuristic-based triplification. Additional triples are generated in order to annotate the fragments from a text with the semantic entities that are extracted from the text, jointly with their syntactic part-of-speech annotations. The Earmark [39], NIF [23], and semiotics.owl10

The result of the previous phase is the input for the final phase, which has the goal to further enrich the graph with links to existing semantic web resources and textual annotations, as well as to enrich compositional associations (dul:associatedWith triples), and to perform validation and possible corrections on the RDF format. The results of TAGME are reused in order to produce owl:sameAs triples for recognised entities that have a correspondence in e.g. DBpedia. Word sense disambiguation (WSD) is used for producing alignments with classes from external ontologies (expressed by means of rdfs:subClassOf and owl:equivalentClass axioms). This task is addressed by integrating an external component: FRED currently reuses UKB [1]; an integration with Babelfy [34] is under development. The result of this phase is the final graph, which is provided in RDF; FRED supports most RDF serialisation formats.

Implementation The third phase is implemented as an independent Java software framework, named K~ore. K~ore is a modular set of Java components, each accessible via its own RESTful interface. All components are implemented as OSGi [38] bundles, components and services based on Apache Felix.11

Additional implementation and deployment details FRED is also released as a Python API named fredlib, which relies on the K~ore REST services, and allows to query FRED with a user-specified corpus, also enabling the manipulation of the resulting graph. More specifically, a Python function hides details related to the communication with the FRED service, and returns the user a FRED graph object that is easily manageable. FRED graph objects expose methods for extracting qualified parts (motifs) from the graph. These methods include functions for extracting the set of individual and class nodes, equivalence axioms, typing axioms, categories of FRED nodes (i.e. events, situations, qualities, general concepts) and categories of edges (roles and non-roles). In addition, fredlib supports rdflib12

4.1. Rigorous evaluation

As far as (i) is concerned: [43] reports FRED performance on the frame detection task showing that it is one order of magnitude faster than Semafor [11] (see Fig. 9), i.e. the best state-of-art tool at the time. Table 3 summarises the accuracy performance of the two tools: FRED and Semafor have comparable precision values for frame detection, while the value of recall is lower for FRED. Nevertheless, it has to be noted that Semafor was trained on the FrameNet reference corpus, which put it in strong advantage with respect to FRED. As additional functionality compared to Semafor, FRED provides a formal representation of the identified frame occurrences.

OPEN IN VIEWER

Fig. 9.

Time to provide answers in function of the number of sentences per document as reported in [43].

A further study [16] reports a comparison between information extraction tools, including FRED. The author defines a number of basic semantic tasks by providing a correspondence between NLP tasks and semantic web terminology. Table 4 reports the list of tasks with a brief explanation of such correspondences: each NLP task is informally associated with a corresponding OWL-based semantics by indicating the type of triples that may be produced starting from its output.

As many of the analysed tools provide a non-RDF output, in order to allow their comparison, a manual conversion to RDF graphs was performed, based on a reference translation table. The study compares fifteen tools (including FRED) by assessing their coverage of, and performance on, the listed tasks against a gold standard of 524 triples produced from a news text. The result shows that FRED has the largest coverage of tasks and best accuracy performance for some of them. Table 5 summarises this evaluation analysis, the reader can refer to [16] for a detailed description of each tool (here we only provide an external reference for each of them), and to online updated data14

The table reports a value for each basic task indicating that a certain tool addresses that task (coverage) with a certain accuracy performance. Accuracy is computed as the sum of true (positive and negative) results over the sum of all (true and false) results. If a value is not present it means that it was either not computed or not computable (i.e. task not addressed), yet a “–” sign indicates “not addressed” while a “+” sign indicates “addressed”.

Besides rigorous evaluation, FRED’s quality is supported by evidence of its impact in the community (ii). A public forum in the software engineering community, stackoverflow.com, contains independent discussions about extending FRED’s usage to other platforms (Python, C#).15

More literature shows the impact of FRED beyond semantic technology circles: a 2014 study about dealing with big data for statistics made by the United Nations Economic Commission for Europe18

Since FRED is a semantic middleware (iii) its quality is primarily assessed by evaluating the performance of applications that depend on it. This is a hard task to address because a rigorous methodology would require to assess the performance of each such application both with and without using the middleware. Nevertheless, we argue that FRED’s impact as a middleware can be demonstrated by showing successful results of applications depending on it that address a broad range of tasks, hence reducing the possibility that their individual success is only due to other factors. In support to this claim, it has to be noted that all tools discussed in the next sections strongly depends on FRED’s output: the core of their logic relies on heuristics defined based on FRED’s graph design. In other words, these tools are specialisations of FRED for specific domains or tasks. The reminder of this section is dedicated to briefly describe three such tools addressing different tasks and their performance. Notably, FRED has been used also in [24] to automatically extract the meaning of citations in scientific research articles, and in [32] for supporting a semantic web approach to textual knowledge reconciliation.

4.4. Semantic sentiment analysis

Sentilo19

Figure 10 shows the pipeline of Sentilo. Its extension to FRED includes

an ontology for opinion sentences for enriching FRED graphs;

An evaluation conducted on a corpus of open-rating reviews about hotels, reported in the cited papers, shows high accuracy of the system for the different addressed tasks: holder detection ( F 1 = .95 ), topic detection ( F 1 = .66 ), subtopic detection ( F 1 = .80 ), and sentiment scoring (Pearson ρ = .81 , the correlation between Sentilo scores and open-rating review scores).

OPEN IN VIEWER

Fig. 10.

Pipeline of Sentilo (taken from [44]).

Legalo21

OPEN IN VIEWER

Fig. 11.

Pipeline of Legalo. Numbers indicate the order of execution of a component in the pipeline.

Figure 11 depicts the pipeline implemented by Legalo. The system also relies on external resources such as Watson22

Tipalo26

OPEN IN VIEWER

Fig. 12.

Pipeline of Tipalo. Numbers indicate the order of execution of a component in the pipeline.