7,840 research outputs found
Context-Based Entity Matching for Big Data
In the Big Data era, where variety is the most dominant dimension, the RDF data model enables the creation and integration of actionable knowledge from heterogeneous data sources. However, the RDF data model allows for describing entities under various contexts, e.g., people can be described from its demographic context, but as well from their professional contexts. Context-aware description poses challenges during entity matching of RDF datasetsâthe match might not be valid in every context. To perform a contextually relevant entity matching, the specific context under which a data-driven task, e.g., data integration is performed, must be taken into account. However, existing approaches only consider inter-schema and properties mapping of different data sources and prevent users from selecting contexts and conditions during a data integration process. We devise COMET, an entity matching technique that relies on both the knowledge stated in RDF vocabularies and a context-based similarity metric to map contextually equivalent RDF graphs. COMET follows a two-fold approach to solve the problem of entity matching in RDF graphs in a context-aware manner. In the first step, COMET computes the similarity measures across RDF entities and resorts to the Formal Concept Analysis algorithm to map contextually equivalent RDF entities. Finally, COMET combines the results of the first step and executes a 1-1 perfect matching algorithm for matching RDF entities based on the combined scores. We empirically evaluate the performance of COMET on testbed from DBpedia. The experimental results suggest that COMET accurately matches equivalent RDF graphs in a context-dependent manner
Compacting Frequent Star Patterns in RDF Graphs
Knowledge graphs have become a popular formalism for representing entities
and their properties using a graph data model, e.g., the Resource Description
Framework (RDF). An RDF graph comprises entities of the same type connected to
objects or other entities using labeled edges annotated with properties. RDF
graphs usually contain entities that share the same objects in a certain group
of properties, i.e., they match star patterns composed of these properties and
objects. In case the number of these entities or properties in these star
patterns is large, the size of the RDF graph and query processing are
negatively impacted; we refer these star patterns as frequent star patterns. We
address the problem of identifying frequent star patterns in RDF graphs and
devise the concept of factorized RDF graphs, which denote compact
representations of RDF graphs where the number of frequent star patterns is
minimized. We also develop computational methods to identify frequent star
patterns and generate a factorized RDF graph, where compact RDF molecules
replace frequent star patterns. A compact RDF molecule of a frequent star
pattern denotes an RDF subgraph that instantiates the corresponding star
pattern. Instead of having all the entities matching the original frequent star
pattern, a surrogate entity is added and related to the properties of the
frequent star pattern; it is linked to the entities that originally match the
frequent star pattern. We evaluate the performance of our factorization
techniques on several RDF graph benchmarks and compare with a baseline built on
top of gSpan, a state-of-the-art algorithm to detect frequent patterns. The
outcomes evidence the efficiency of proposed approach and show that our
techniques are able to reduce execution time of the baseline approach in at
least three orders of magnitude reducing the RDF graph size by up to 66.56%
Data Model and Query Constructs for Versatile Web Query Languages
As the Semantic Web is gaining momentum, the need for
truly versatile query languages becomes increasingly apparent. A Web
query language is called versatile if it can access in the same query program
data in different formats (e.g. XML and RDF). Most query languages
are not versatile: they have not been specifically designed to cope
with both worlds, providing a uniform language and common constructs
to query and transform data in various formats. Moreover, most of them
do not provide a flexible data model that is powerful enough to naturally
convey both Semantic Web data formats (especially RDF and
Topic Maps) and XML. This article highlights challenges related to the
data model and language constructs for querying both standard Web
and Semantic Web data with an emphasis on facilitating sophisticated
reasoning. It is shown that Xcerptâs data model and querying constructs
are particularly well-suited for the Semantic Web, but that some adjustments
of the Xcerpt syntax allow for even more effective and natural
querying of RDF and Topic Maps
Compacting frequent star patterns in RDF graphs
Knowledge graphs have become a popular formalism for representing entities and their properties using a graph data model, e.g., the Resource Description Framework (RDF). An RDF graph comprises entities of the same type connected to objects or other entities using labeled edges annotated with properties. RDF graphs usually contain entities that share the same objects in a certain group of properties, i.e., they match star patterns composed of these properties and objects. In case the number of these entities or properties in these star patterns is large, the size of the RDF graph and query processing are negatively impacted; we refer these star patterns as frequent star patterns. We address the problem of identifying frequent star patterns in RDF graphs and devise the concept of factorized RDF graphs, which denote compact representations of RDF graphs where the number of frequent star patterns is minimized. We also develop computational methods to identify frequent star patterns and generate a factorized RDF graph, where compact RDF molecules replace frequent star patterns. A compact RDF molecule of a frequent star pattern denotes an RDF subgraph that instantiates the corresponding star pattern. Instead of having all the entities matching the original frequent star pattern, a surrogate entity is added and related to the properties of the frequent star pattern; it is linked to the entities that originally match the frequent star pattern. Since the edges between the entities and the objects in the frequent star pattern are replaced by edges between these entities and the surrogate entity of the compact RDF molecule, the size of the RDF graph is reduced. We evaluate the performance of our factorization techniques on several RDF graph benchmarks and compare with a baseline built on top gSpan, a state-of-the-art algorithm to detect frequent patterns. The outcomes evidence the efficiency of proposed approach and show that our techniques are able to reduce execution time of the baseline approach in at least three orders of magnitude. Additionally, RDF graph size can be reduced by up to 66.56% while data represented in the original RDF graph is preserved
An introduction to Graph Data Management
A graph database is a database where the data structures for the schema
and/or instances are modeled as a (labeled)(directed) graph or generalizations
of it, and where querying is expressed by graph-oriented operations and type
constructors. In this article we present the basic notions of graph databases,
give an historical overview of its main development, and study the main current
systems that implement them
Keyword Search on RDF Graphs - A Query Graph Assembly Approach
Keyword search provides ordinary users an easy-to-use interface for querying
RDF data. Given the input keywords, in this paper, we study how to assemble a
query graph that is to represent user's query intention accurately and
efficiently. Based on the input keywords, we first obtain the elementary query
graph building blocks, such as entity/class vertices and predicate edges. Then,
we formally define the query graph assembly (QGA) problem. Unfortunately, we
prove theoretically that QGA is a NP-complete problem. In order to solve that,
we design some heuristic lower bounds and propose a bipartite graph
matching-based best-first search algorithm. The algorithm's time complexity is
, where is the number of the keywords and is a
tunable parameter, i.e., the maximum number of candidate entity/class vertices
and predicate edges allowed to match each keyword. Although QGA is intractable,
both and are small in practice. Furthermore, the algorithm's time
complexity does not depend on the RDF graph size, which guarantees the good
scalability of our system in large RDF graphs. Experiments on DBpedia and
Freebase confirm the superiority of our system on both effectiveness and
efficiency
- âŠ