Data published on the Web is growing every year. However, most of this data does not have semantic representation. Web tables are an example of structured data on the Web that has no clear semantics. While there is an emerging research effort in lifting tabular data into semantic web formats, most of the work is focused around entity recognition in tables with simple structure. In this work we explore how capture the semantics of complex tables and transform them to knowledge graph. These complex tables include contextual information about statements, such as time or provenance. Hence, we need to use contextualized knowledge graphs to represent the information of the tables. We explore how this contextual information is represented in tables, and relate it to previous classifications of web tables, and how to encode it in RDF using different approaches. Finally, we present a prototype tool that converts web tables from Wikipedia into RDF, trying to cover all existing approaches.
Data is being published in the web at an ever-increasing speed. However, most of this data lacks semantics. This makes difficult to use it to generate value. Knowledge-graphs are a well-known representation to encode data semantics. The Semantic Web provides standards to represent inter-operable knowledge graphs were each resource can be unequivocally referenced. Tools to generate semantic data from structured web data (specially tables) in gaining traction in the recent years. Most approaches focus on entity recognition and disambiguation, in order to automatically extract the information and transform it to RDF. However, to the best of our knowledge, existing approaches tackle only simple tables with no additional information about the statements that can be extracted. More complex tables exists that provide statements in different contexts (e.g., according to different sources, or valid at different time periods). In order to encode this contextual information (or statement metadata), we need to identify those Copyright c 2018 for this paper by its authors. Copying permitted for private and academic purposes. contexts and represent the information accordingly using contextualized knowledge graphs. In this work we focus on transforming tables into RDF, where contexts are represented by means of reifying the statements using the main existing approaches.
The rest of the paper is organized as it follows: in section 2 is discussed some background information; section 3 presents an overview of how data is usually represented in web tables, challenges to represent this data in RDF, and how recent research is dealing with them; section 4 discusses the proposed approach to transform data from web tables to RDF; finally, section 5 draw some conclusions and possible lines of future work. 2
2.1
RDF In this section we introduce the necessary background information about RDF, existing reification approaches, and tools to convert automatically structured data to RDF. RDF is the data model used in the Semantic Web. It represents statements as triples <Subject, Predicate, Object>. The subject identifies the resource being described, the predicate is the property applied to it, and the object is the concrete value for this property. Triples can share subject and/or object, hence creating a interconnected graph of (possibly heterogeneous) statements. Formal definitions of RDF triple and RDF graph can be seen in Definitions 1 and 2.
Definition 1 (RDF triple). Assume infinite, mutually disjoint sets I (IRI references), B (Blank nodes), and L (Literals) . An RDF triple is a tuple (s;p;o) 2 (I [B) I (I [B[L), where \s" is the subject, \p" is the predicate and \o" is the object.
Definition 2 (RDF graph). An RDF graph G is a set of RDF triples f(s;p;o)g. p It can be represented as a directed labeled graph s ! o. 2.2
As seen in previous section, RDF statements represent binary relations between to resources (the subject and the object). This model is not well suited to represent additional contextual information about the statement themselves (such as data of validity, provenance, or confidence). Current approaches to represent this kind of information reify the statement into a new resource, that can be then used as subject or object of new statements that represent the context. Down below we describe the five main existing approaches. In the Figure 1, we illustrate each of them.
In RDF Reification [6, Sec. 4], a resource can be used as a statement, and additional information can be added as follows: a quad of the form (s;p;o;i), i is a quad identifier, can be described by the triples (i;r:subject;s), (i;r:predicate;p) and (i;r:object;o): (a) Standart
Reification (b) Named
Graphs (c) n-ary
Relations (d) Singleton
Properties
(e) NdFluents
Named Graphs [
In N-ary Relations [
Singleton Properties [
NdFluents [
In order to transform a data source into RDF, a common approach is to use a
mapping language to represent how the data from one source has to be transformed
into triples . Several tools exist to transform heterogeneous data formats into RDF,
most of them tackling a single data model or format. In this section we focus on the
two most prominent mapping languages: RML [
RML [
SPARQL-Generate [
The first two clauses (source - and its binding functions - and iterator) allow
SPARQLGenerate to support various data formats and navigate through them.
3
According to Crestan et al. [
Mun~oz et al. [
While solutions for transforming data in tables to RDF have been proposed, most
of them focus on challenges such as identifying the subject column, interpret the
implicit structure of table, entity recognition and disambiguation, and mapping values
in the table with classes and properties in a knowledge base [
The transformation from tables to Knowledge Graphs needs to consider the different typologies of tables presented in the previous section. For tables without contextual metadata about the statements the process is relatively simple: each cell in the subject column is mapped to a subject in a triple and each cell of the same row to an object, using a property that depends on the column of the object. However, for tables that contain contextual information it is necessary to capture the context of the triples. RDF, as mentioned in Section 2.1, only supports binary relations. In order to capture the context of the triples it will be necessary to resort to a reification approach (see Section 2.2). Take as an example table 17. We want to extract information not only about the population estimates, but also about the corresponding year and the agency responsible for that estimation. This table is an example of a matrix table, where contexts are indicated by the headers of rows and columns. Listing 1.1 exemplifies an expected output for the value for the cell of row 1 and column 2, including all the contextual metadata.
In addition, the approach needs to read the webpage and extract the information. However, the HTML structure of the table can be arbitrary, and this is one of the challenges to face in this approach. Hence, it is necessary to include a preliminary step to pre-process the table. For this prototype, we decide to get some of the necessary information from the user. The preprocessing step produces as output a modified version of the table with additional information: indexes for column and row, the datatype for the value in each cell, category of the table and groups of columns. This information is then used by a conversion module RDF. Note that this approach could be extended to include other kinds of knowledge graphs, such as property graphs, by adding a new conversion module. A schema of this process is shown in Figure 2. 5 See https://en.wikipedia.org/wiki/List_of_sovereign_states_and_dependent_ territories_by_mortality_rate, where the same data is given twice but with different sources 6 See Table 1 7 Taken from https://en.wikipedia.org/wiki/World_population_estimates 1 wp : year1950 a time : DateTimeDescription , time : I n t e r v a l ; 2 time : year " 1950 " ^^ xsd : gYear . 3 4 wp : Maddison a ex : Provenance ; 5 prov : wasGeneratedBy [ 6 a event : Event , prov : A c t i v i t y ; 7 event : time [ 8 a time : I n t e r v a l ; 9 time : hasDateTimeDescription [ 10 a time : DateTimeDescription ; 11 time : year " 2008 " ^^ xsd : gYear ] ] ] . 12 13 <http : / / p u r l . org / az / worldpop#e a r t h : year1950 : Maddison> 14 r d f : o b j e c t 2544000000 ; 15 r d f : p r e d i c a t e dbo : p o p u l a t i o n T o t a l ; 16 r d f : s u b j e c t dbr : Earth ; 17 time : i n t e r v a l D u r i n g wp : year1950 ; 18 prov : agent wp : Maddison .
Listing 1.1: Expected output example
The input taken by the preprocessing module is written in RDF using RML [
The RDF conversion module makes use of SPARQL-Generate [
The prototype tool is publicly available8 under Apache-2.0 license. 8 https://github.com/felipequecole/table2rdf Transforming web tables into knowledge graphs while capturing their semantics and contextual information is a challenging task for various reasons: On the side of the knowledge graph representation, it can be necessary to use reification techniques in order to encode the context. On the side of the table, the HTML structure can be arbitrary, and the contents of the table can be difficult to identify. We propose a two-step process. The first step takes additional information and pre-processes the table, generating a enriched version of the table with the information needed by the second step, such as the category of the table or how to extract the contextual metadata about the statements. The second step reads the output of the preprocessor and transforms the data in a knowledge graph. We have implemented a tool that gets part of the necessary information from the user (falling back to default values in case some information is not given) in the first step, and a RDF conversion module as second step. Note that other approaches focusing on different challenges, such as entity disambiguation or subject column identification, could be incorporated in the preprocessing step. Conversely, new modules can be added to substitute the RDF transformation to another kind of knowledge graph, such as property graphs.