eLinda: Explorer for Linked Data

07/24/2017
by   Oren Mishali, et al.
0

To realize the premise of the Semantic Web towards knowledgeable machines, one might often integrate an application with emerging RDF graphs. Nevertheless, capturing the content of a rich and open RDF graph by existing tools requires both time and expertise. We demonstrate eLinda - an explorer for Linked Data. The challenge addressed by eLinda is that of understanding the rich content of a given RDF graph. The core functionality is an exploration path, where each step produces a bar chart (histogram) that visualizes the distribution of classes in a set of nodes (URIs). In turn, each bar represents a set of nodes that can be further expanded through the bar chart in the path. We allow three types of explorations: subclass distribution, property distribution, and object distribution for a property of choice.

READ FULL TEXT VIEW PDF
POST COMMENT

Comments

There are no comments yet.

Authors

page 3

10/25/2021

PREC: semantic translation of property graphs

Converting property graphs to RDF graphs allows to enhance the interoper...
06/19/2019

The Linked Open Data cloud is more abstract, flatter and less linked than you may think!

This paper presents an empirical study aiming at understanding the model...
02/23/2020

Path Outlines: Browsing Path-Based Summaries of Linked Open Datasets

Linked Data (LD) are structured sources of information, such as DBpedia ...
06/19/2019

Observing LOD using Equivalent Set Graphs: it is mostly flat and sparsely linked

This paper presents an empirical study aiming at understanding the model...
06/19/2019

Observing the LOD Cloud using Equivalent Set Graphs: the LOD Cloud is mostly flat and sparsely linked

This paper presents an empirical study aiming at understanding the model...
03/05/2016

A Linked Data Scalability Challenge: Concept Reuse Leads to Semantic Decay

The increasing amount of available Linked Data resources is laying the f...
06/24/2016

Enriching Linked Datasets with New Object Properties

Although several RDF knowledge bases are available through the LOD initi...
This week in AI

Get the week's most popular data science and artificial intelligence research sent straight to your inbox every Saturday.

1 Introduction

The growing interest in representing information as RDF Linked Data is due to the appealing potential of having machines reading and integrating data from a large and diverse community of resources. Examples include government efforts such as Data.gov111U.S. Government’s open data, https://www.data.gov/ and public initiatives like DBpedia.222http://wiki.dbpedia.org/ An important challenge for the research community is to make the data more accessible for consumption by potential end users [3]. In achieving that goal, tools for effective visualization and exploration of the data play a central role [3, 2].

The basic principle for effective visual representation of data is well stated by Shneiderman [7]: “Overview first, zoom and filter, then details-on-demand.” To that end, a Linked Dataset (or RDF graph) typically has an associated ontology that describes its semantics in terms of class hierarchies and properties, and can potentially provide a comprehensive overview of the underlying data.

The demonstrated tool presented in this paper, eLinda, supports the exploration and visualization of an RDF graph based on the classes and properties. Exploration of a dataset is carried over through several paths, both vertical—down the class hierarchy, and horizontal—via properties. The visualization is based on bar charts (histograms) that summarize information about (possibly large) node collections. The visualization and exploration of eLinda realize a novel formal framework that we present in Section 2.

We drive inspiration from ontology visualization tools, such as VOWL [6], FlexViz [4] and GLOW [5], that visualize an ontology independently of the underlying data. Yet, eLinda connects between ontology elements and their actual occurrence in the dataset. Consequently, during exploration eLinda is able to present the user with ontology elements in a sorted manner, by decreasing significance (i.e., support in the dataset). This feature is crucial for a user who attempts to make sense of the data as demonstrated in open and rich datasets. For illustration, in DBpedia the ontology333http://mappings.dbpedia.org/server/ontology/classes/ reports on 49 nine top-level classes, yet almost half of the classes (22) do not have instances at all.

The ability to dive into the details is a vital requirement for data visualization tools. A family of tools known as

linked-data browsers [3] are able to provide informative insights into the details of a dataset, by supporting the exploration of resources via properties and relations with other elements in the RDF graph. Example tools include Marbles444http://mes.github.io/marbles/, Sig.ma [8], and DBPedia Mobile [1]. The browsers are focused on exploring specific RDF resources and thus present limited, if any, overview of the data [3]. In addition, they often require the user to have prior knowledge of the dataset (i.e., a starting point), but it is common that users are interested in finding something useful without previously knowing what they are looking for [2]. eLinda supports this mode of exploration, as well as looking into detailed RDF data with automatic generation of SPARQL queries.

The demonstration will showcase data exploration with eLinda on several datasets, and using a variety of scenarios and information needs.

Figure 1: Initial chart in the exploration pane over DBPedia

2 Formal Model

In this section we give the formal definition of the data and interaction model underlying eLinda.

RDF graphs.   We adopt a standard model of RDF data. Specifically, we assume (infinite) collections of Unique Resource Identifiers (URIs), and of literals. An RDF triple, is an element of . An RDF graph is a finite collection of RDF triples. We denote by and the set of URIs and literals, respectively, that occur in . In the remainder of this section we assume a fixed RDF graph . A URI is said to be of class if .

Bar charts.   eLinda enables the visual exploration of by means of bar charts, as in Figure 1 that are constructed interactively. Formally, a bar is a triple where is a set of URIs, is the label of , and is the type of that can be either ( represents URIs that are associated with some type) or ( represents URIs that are associated with some property). A bar chart (or just chart) is associated with a finite set of labels, denoted , and it maps each label to a bar with the label (i.e., a bar of the form for some set ); we denote this bar by .

Bar expansion.   A bar expansion is a function that transforms a given bar into a chart . eLinda supports three specific bar expansions , each constructing a chart from a given bar .

  • Subclass expansion:   This expansion is enabled when . Then, consists of all such that contains , and where consists of all of class .

  • Property expansion:   This expansion is enabled when . Then, consists of all where contains for some and , and where is the set of all the with the property (that is, for some ).

  • Object expansion:   This expansion is enabled when . Then, consists of all such that contains for and objects of class . The set is where consists of all the of class with for some .

In addition, we allow for a filter operation that is associated with a condition on URIs, and removes from each bar the URIs that violates the condition.

The property and object expansions are defined above for outgoing properties, that is, the URIs of play the roles of the subjects. We similarly define the incoming versions, where the URIs of play the roles of the objects.

Exploration.   Finally, eLinda enables the exploration of by enabling the user to construct a list of charts in sequence, each exploring a bar of the previous chart. The exploration begins with a predefined initial chart that we denote by . In our implementation this bar has the form where is the subclass expansion and is the bar with being a predefined type and consisting of all with . A sensible choice of is a general type such as owl:Thing.

More formally, by exploration we refer to a sequence of the form where each is obtained by selecting a bar from , namely the one with the label , and applying the expansion to that bar. (Recall that is the predefined initial chart.) In notation we have the following for all : (a) ; (b) is applicable to ; and (c) . As a feature, eLinda enables the user to generate SPARQL code to extract each of the bars along the exploration.

3 User Interface

Figure 2: Three exploration panes over DBpedia: the Person class, the Philosopher class, and persons influencing philosophers. The colored breadcrumb trails indicate the exploration path.

In this section we explain how the interaction model of the previous section is materialized in eLinda’s user interface. We start with basic concepts regarding the operation of the tool.

3.1 Operational context

eLinda is implemented as a single-page web application within a web browser. The interface provides a setting form that allows a user to point the tool to an online SPARQL endpoint such as DBpedia, YAGO, or LinkedGeoData.555The current implementation assumes Virtuoso endpoints. During its operation, user requests are translated into numerous SPARQL queries that are sent to the server in real time, asking for data to visualize. The very first queries present the user with general statistics about the dataset such as the total number of RDF triples, and the number of classes the dataset has. The exploration however is totally visual, and does not require knowledge of the SPARQL query language.

Requirements from the dataset.   A Linked Dataset is usually associated with an ontology that defines a class type hierarchy and properties. eLinda offers an ontology-based exploration experience, while trying to make minimal assumptions on the structure of the target dataset. For example, even datasets with no class hierarchy at all may be browsed with eLinda however in a limited fashion. Yet the full power of the tool is exploited for datasets that define a class type hierarchy using the standard properties owl:Class (or rdfs:Class) and rdfs:subClassOf. Such datasets will be better “explorable” since the user will be able to navigate down the class hierarchy while searching for data of interest. With regard to properties, eLinda does not assume their declaration with rdf:Property or alike, since they are totally inferred from the actual data triples as explained in Section 3.3. eLinda makes extensive use of standard rdfs:label properties, that if exist provide the user with short and meaningful textual labels that are attached to visualized elements.

3.2 Navigating with the subclass expansion

Exploration with eLinda is effectively performed by constructing a sequence of tabbed panes. An example pane for the DBpedia dataset is presented in Figure 1. Each pane visualizes data related to a set of subjects (instances) from several different perspectives. All subjects in are of the same type .666Note that does not necessarily include all instances of as we will explain later on. When pointing eLinda to a new dataset an initial pane is shown, and during the exploration the user may open additional panes one beneath the other. The initial pane in Figure 1 refers to all DBpedia subjects of type owl:Thing (the root class).777We also handle the case of datasets with not root class, as found in LinkedGeoData. The upper left corner of a pane shows basic statistics: the total number of instances (i.e., ), and the number of direct and indirect subclasses that class type has.

Subclass chart.   By default, a pane is opened with a bar chart showing the distribution of instances in among the subclasses of (the result of a subclass expansion). Each bar represents instances of a specific subclass, and the height of the bar is proportional to the number of instances. The bars are sorted by decreasing height. Hovering a bar reveals a pop-up box with basic information, as shown in the figure for Agent, the second largest DBpedia class, with more than 2 million instances, 5 direct subclasses, and 277 subclasses in total. To facilitate the visualization of a large number of bars, only a subset of the bars is initially shown. A widget located at the top of the chart allows to control visible part of the chart.

Class navigation.   A user interested in exploring a particular instance set, or in getting an overview of the dataset, can navigate down the class hierarchy by clicking a bar, what causes a new pane to be opened below, with a new chart showing its direct subclasses. For example, a user wishes to explore instances of type Philosopher should open three additional panes through the path owl:Thing Agent Person Philosopher. Often, locating the position of a desired class type using top-down navigation may be challenging. For example, it may be difficult for a user to infer that class Philosopher is located under Agent Person. For such circumstances, eLinda provides an autocomplete search box for locating class types, based on a list that is populated by collecting all subjects in the dataset of type owl:Class or rdfs:Class. Selecting a class that way, immediately opens the associated pane without the need to drill down.

3.3 Applying the property expansion

Within a pane, switching to the Property Data tab shows a second chart with a comprehensive overview about properties featured by instances in (the result of a property expansion). To calculate this property data, eLinda does not refer to ontology elements such as rdf:Property that may not be available in the dataset or incomplete. Instead, it aggregates all properties found within instances in . The bar chart here shows how the instances are distributed among the properties found. A specific bar corresponds to those instances in that share a property . The height of a bar is proportional to the property’s coverage—the percentage of instances that feature the property in . (Again, bars are sorted by decreasing height.)

The number of possible properties for a given set may be very large and thus difficult for the user to consume. For example, in DBpedia there are nearly 40,000 instances of type Politician, that feature 1,482 different properties altogether. We enable the user to restrict to significant properties by filtering out properties with a coverage lower than a threshold. In the Politician example, only 38 properties that cross the default coverage threshold of 20% are shown. The user may adjust the threshold and reveal more properties if needed.

Browse instance data.   The aforementioned property chart provides an overview, yet in some cases it may be desirable to view actual instance data. This is facilitated by another UI element, a data table, that presents data in a tabular format. Each bar in the property chart that is selected by the user is added as a new column in the table. The column is then filled-in with actual values that are fetched from the dataset. For example, by selecting the property bars birthPlace and influencedBy for instances of type Philosopher, we can see in the table where each philosopher was born, and by whom he or she was influenced. In addition, the table exposes the SPARQL query it was generated from, allowing a user to retrieve the corresponding data.

Ingoing properties.   The default property chart relates to outgoing properties that “leave” instances of . Similarly, a user may explore properties that “enter” those instances by switching to an ingoing property chart. For type Philosopher, 9 ingoing properties that cross the 20% coverage threshold are shown, such as author that connects between different works to philosophers who authored them.

Data filters.   A data filter may be attached to each table column, and by that to restrict the set of instances that appear in the data table to those that have certain property values. For example, by applying a filter on the birthPlace property, the user may view only those philosophers who were born in Vienna. Note that by applying data filters, the set that is captured by the pane is left unchanged. If we want to change our focus of exploration we may ask eLinda to open a new pane that is associated with —the set after applying the filters (filter expansion). The set may be explored in a similar manner, using all available expansions that will now operate on a narrowed set.

3.4 Exploring connections with objects

A third kind of bar chart is available within the Connections tab and allows to explore connections between to other sets of instances (now operate as objects) via selected properties. This chart materializes the object expansion. The chart provides more insights on and also the opportunity to switch an instance set, from to (objects connected to via property ). As an example, consider the property influencedBy that appears within instances of Philosopher. Selecting that property and switching to the Connections tab opens a bar chart with objects that are connected to via the property influencedBy. The objects are distributed by their type, where each bar represents a set of objects of a given type. One of the bars shown is Scientist, denoting the set of scientists who have influenced philosophers. Also here, the user may continue with the exploration on the new set by clicking a bar. A new pane is opened now focusing on the aforementioned set of scientists. Note that from now on the different expansions will operate on this narrowed set and not on all instances of type Scientist.

HTTP responseSPARQLSQLeLindaWeb browserReverse proxyHTTP requestKey-ValueCacheVirtuosoSPARQLVirtuosoSQL
Figure 3: Basic system architecture

4 System Architecture

The architecture design of eLinda is driven primarily by the requirement of responsiveness, which means that expansions should happen instantly, preferably in tens to hundreds of milliseconds. Each exploration step in eLinda is realized by sending one or more SPARQL queries to the endpoint. Achieving responsiveness is challenging, since some of the queries that are submitted repeatedly are heavy, with runtime up to several minutes. Naturally, we can take advantage of the fact that the queries generated by eLinda are of a restricted form. Next, we describe three techniques that eLinda implements to boost responsiveness.

Incremental evaluation.   eLinda builds the chart of an expansion by computing it on the first triples in the RDF graph. It then continues to compute the query on the next triples and aggregates the results in the frontend. It continues for steps, or until the full chart is computed. In the current implementation, the parameters and are determined by an administrator’s configuration. This method provides eLinda with effective latency for user interaction. Moreover, it works well on remote servers in the compatibility mode, as we explain later in this section.

eLinda HVS.   eLinda detects heavy queries and saves their results in a key-value store called heavy query store (HVS) on the eLinda endpoint. For each query to the eLinda enpoint, the system first checks if the HVS encountered it before and determined it to be heavy. If so, use the result from the HVS, otherwise route it to the Virtuoso888https://virtuoso.openlinksw.com/ endpoint. eLinda backend measures the run time of the routed queries. Queries with runtime bigger than one second are considered heavy and saved in the HVS. The HVS is cleared on any updated to the eLinda knowledge bases.

eLinda decomposer.   To offer swift accurate results in case the result is not in the HVS, we provide a specialized eLinda endpoint. Our eLinda endpoint contains mirrors of the common knowledge bases, such as DBpedia and YAGO, in a Virtuoso SPARQL database. Our system contains specialized indexes to accelerate heavy queries. eLinda detects heavy queries are sent to the eLinda backend and map the SPARQL queries to a decomposition of SQL queries that utilizes the indexes and prevents heavy and redundant SPARQL computations. Unlike the eLinda HVS, the eLinda decomposer can be used for all property expansion queries. As an example, on DBPedia the query for the outgoing property expansion is the following.

SELECT ?p COUNT(?p) AS ?count SUM(?sp) AS ?sp
 FROM {SELECT ?s ?p count(*) AS ?sp
    FROM {?s a owl:Thing. ?s ?p ?o.}
    GROUP BY ?s ?p} GROUP BY ?p

The first subquery computes the subject, property and count of all the triples with owl:Thing subjects. This query includes a complex join with hundreds of millions of tuples as an intermediate result, which delays the response. eLinda decomposer detects that this subquery can utilize the specialized indexes and decompose the query accordingly. Clearly, the eLinda decomposer can be used for subclasses of owl:Thing.

Figure 4 shows the performance of the slowest and most commonly used queries by eLinda. These queries construct the bar charts of the outgoing and incoming property expansion in the first level. The runtime of these queries on the Virtuoso SPARQL endpoint is 454 and 124 seconds for the outgoing and incoming bar charts, respectively. On the eLinda endpoint that uses the eLinda decomposer, the queries take 1.5 and 1.2 seconds, respectively. In case the results are already in the eLinda HVS, the queries runtime is around 80 milliseconds.

Figure 4: Running times of level-zero property expansions over different store configurations

Remote Compatibility

Nowadays, data sources often offer online API endpoints that are constantly evolving [2]. In our architecture design we also set the goal of allowing the user to apply eLinda to the exploration of such sources, even if we have no access to the actual RDF graph and cannot execute any preprocessing. Hence, we also allow eLinda to work with a remote Virtuoso endpoint999We use AJAX communication with the Virtuoso server via its HTTP/JSON SPARQL interface. that can be configured in the setting form (described in Section 3) by merely specifying the endpoint URL. Naturally, in this mode responsiveness is lower than the above local mode. Yet, the aforementioned incremental evaluation is applicable (and applied) even in the remote mode, allowing for effective latency.

5 Demonstration Scenarios

During the demonstration, participants will explore several RDF datasets such as DBpedia and LinkedGeoData101010http://www.linkedgeodata.org/ with eLinda. Several kinds of explorations will be exercised. The first kind will tackle the task of understanding a large and unfamiliar dataset. Example scenarios are “examine the bar chart showing the first-level classes of the dataset,” and “analyze the twenty most significant properties of the largest class in the dataset.” Additional scenarios will look into sophisticated exploration paths such as “the types of people that influenced philosophers.” A second kind of exploration will demonstrate the performance issue elaborated in Section 4. The participants will be presented with explorations that entail heavy queries, and with the discussed solutions turned on and off. Finally, a third kind of explorations will illustrate how eLinda can be used to detect erroneous data such as “people who are indicated to be born in resources of type food.”

References

  • [1] C. Becker and C. Bizer. DBpedia mobile: A location-enabled linked data browser. In LDOW, volume 369, 2008.
  • [2] N. Bikakis and T. K. Sellis. Exploration and visualization in the web of big linked data: A survey of the state of the art. CoRR, abs/1601.08059, 2016.
  • [3] A.-S. Dadzie and M. Rowe. Approaches to visualising linked data: A survey. Semantic Web, 2(2):89–124, 2011.
  • [4] S. M. Falconer, C. Callendar, and M.-A. D. Storey. A visualization service for the semantic web. In EKAW, volume 6317 of LNCS, pages 554–564. Springer, 2010.
  • [5] W. Hop, S. de Ridder, F. Frasincar, and F. Hogenboom. Using hierarchical edge bundles to visualize complex ontologies in GLOW. In SAC, pages 304–311. ACM, 2012.
  • [6] S. Lohmann, S. Negru, F. Haag, and T. Ertl. Visualizing ontologies with VOWL. Semantic Web, 7(4):399–419, 2016.
  • [7] B. Shneiderman. The eyes have it: A task by data type taxonomy for information visualizations. In VL, pages 336–343, 1996.
  • [8] G. Tummarello, R. Cyganiak, M. Catasta, S. Danielczyk, R. Delbru, and S. Decker. Sig.ma: Live views on the web of data. J. Web Sem, 8(4):355–364, 2010.