Resource Description Framework Graph Research Articles

Linguistic summarisation of multiple entities in RDF graphs

<abstract><p>Methods for producing summaries from structured data have gained interest due to the huge volume of available data in the Web. Simultaneously, there have been advances in natural language generation from Resource Description Framework (RDF) data. However, no efforts have been made to generate natural language summaries for groups of multiple RDF entities. This paper describes the first algorithm for summarising the information of a set of RDF entities in the form of human-readable text. The paper also proposes an experimental design for the evaluation of the summaries in a human task context. Experiments were carried out comparing machine-made summaries and summaries written by humans, with and without the help of machine-made summaries. We develop criteria for evaluating the content and text quality of summaries of both types, as well as a function measuring the agreement between machine-made and human-written summaries. The experiments indicated that machine-made natural language summaries can substantially help humans in writing their own textual descriptions of entity sets within a limited time.</p></abstract>

Optimizing Keyword Search Over Federated RDF Systems

The issue of keyword search in federated resource description framework(RDF) systems is revisited in this paper. Numerous independent SPARQL endpoints that solely offer SPARQL query interfaces make up a federated RDF system. Others find it challenging to remotely build up the global inverted indices over the full RDF network by downloading the dataset at various SPARQL endpoints. This poses a challenge for existing keyword search approaches. In this paper, we propose a keyword search approach for federated RDF systems without building up global inverted indices on the entire RDF graph. We build an offline schema graph for the federated RDF system. During query evaluation, the full-text search interfaces provided by existing SPARQL endpoints were used to map keywords to vertices in the schema graph. Subsequently, the schema graph was explored to construct SPARQL queries from the keywords. The constructed queries were evaluated over the underlying federated RDF systems. Some cost models were proposed to measure keyword mapping and query construction. On the other hand, to further improve the efficiency, a multiple query optimization strategy was designed to rewrite the queries and share the common computation during evaluation. Extensive experiments on real RDF datasets show that the proposed techniques are effective.

Aggregation Path Search using Multiple Large RDF Datasets with Equivalence Relations

In the Semantic Web, items are represented by uniform resource identifiers (URIs) on the Web in order to describe relationships between things in resource description framework (RDF) graphs. Large scale open RDF data (linked data) describing information about various things are available. Hence, relational discovery research has been conducted using RDF data to explore relationships between things. The SPARQL protocol and RDF query language (SPARQL) is usually employed to process RDF data; however, SPARQL is not suitable for relational discovery using linked data because it is difficult to describe unknown vocabularies and relationships in SPARQL queries. In this paper, we propose an aggregation path search for RDF graphs as an extension of shortest path keyword search. The aggregation path search is devised to find RDF paths by merging multiple resource URIs into commonly reachable nodes in an RDF graph. This search method can discover new relationships between items that are connected by a common node. We present a method for treating equivalent resource URIs as a single resource URI; these equivalent URIs essentially represent the same thing based on equivalence relations in different RDF datasets. In our experiments, we show in the integration of multiple large scale RDF datasets that the integration of equivalent resources enables richer retrieval of aggregated paths.

Fuzzy RDF Knowledge Graph Embeddings Through Vector Space Model

Resource description framework (RDF) is a World Wide Web consortium recommendation and has been widely accepted for semantic data models (e.g., knowledge graphs). As such, a large amount of RDF data is readily available. Information in the real world is often uncertain, and uncertain RDF data models have been proposed and received increasing attention. Knowledge graph embedding is an effective way to perform vector projection of structured knowledge, after which we can infer a large-scale knowledge graph. Nowadays, knowledge graph embedding models are widely proposed, but most of them can only handle crisp information. In this article, we concentrate on modeling fuzzy RDF graphs in the vector space. We propose a fuzzy RDF knowledge graph embedding model (FRKGE), which can project the fuzzy entities and fuzzy relations with membership degree to the vector space. Our proposed model preserves the structure of the fuzzy RDF knowledge graph and the explicit expression of membership degree in the vector space, which provides a natural expression of fuzzy RDF tuples. Our experimental results demonstrate that the FRKGE model is competent for the task of representation learning for fuzzy RDF knowledge graphs.

S3QLRDF: distributed SPARQL query processing using Apache Spark—a comparative performance study

The proliferation of semantic data in the form of Resource Description Framework (RDF) triples demands an efficient, scalable, and distributed storage along with a highly available and fault-tolerant parallel processing strategy. There are three open issues with distributed RDF data management systems that are not well addressed altogether in existing work. First is the querying efficiency, second is that solutions are optimized for certain types of query patterns and don’t necessarily work well for all types, and third is concerned with reducing pre-processing cost. More precisely, the rapid growth of RDF data raises the need for an efficient partitioning strategy over distributed data management systems to improve SPARQL (SPARQL Protocol and RDF Query Language) query performance regardless of its pattern shape with minimized pre-processing time. In distributed RDF systems, both the data and the query processing are highly distributed. On the other hand, SPARQL workloads are dynamic and structurally diverse that can have different degrees of complexity. A complex SPARQL query over a large RDF graph in distributed systems requires combining a lot of distributed pieces of data through join operations. Therefore, designing an efficient data-partitioning schema and join strategy to minimize data transfer is the fundamental challenge in distributed RDF data management systems. In this context, we propose a new relational partitioning schema called Property Table Partitioning (PTP) for RDF data, that further partitions existing Property Table into multiple tables based on distinct properties (comprising of all subjects with non-null values for those distinct properties) in order to minimize input size and number of join operations of a query. This paper proposed a distributed RDF data management system called S3QLRDF, which is built on top of Spark and utilizes SQL to execute SPARQL queries over PTP schema. The experimental analysis with respect to preprocessing costs and query performance, using synthetic and real datasets shows that S3QLRDF outperforms state-of-the-art distributed RDF management systems.

Fixing the inconsistencies of continuous changing operations in fuzzy spatiotemporal RDF graph

Fuzzy spatiotemporal data models have been used to support spatial and temporal knowledge representation and reasoning in the presence of fuzziness. In the meantime, Resource Description Framework (RDF), the most relevant data representation and exchange standard on Semantic Web, has become a trend for representing fuzzy spatiotemporal data. However, due to the dynamic changes of fuzzy spatiotemporal data, fuzzy spatiotemporal RDF graphs are more likely to violate predefined spatial and temporal constraints than the general RDF graph, which causes data inconsistencies. At present, consistency problems in RDF graphs have been widely studied, but their studies consider only discrete changing operations of fuzzy spatiotemporal data, while researches on consistencies of continuous changing operations are still open issues. In this paper, we study the types of inconsistency caused by continuous changing operations and propose the corresponding fixing rules to the problems of inconsistencies. Then, we propose the corresponding fixing approaches to checking and fixing fuzzy spatiotemporal RDF graphs according to the inconsistent states. Finally, the experimental results show that our proposed algorithms can significantly fix inconsistencies of continuous changing operations in fuzzy spatiotemporal RDF graphs.

Fuzzy Spatiotemporal Data Modeling and Operations in RDF

With the emergence of a large number of fuzzy spatiotemporal data on the Web, how to represent and operate fuzzy spatiotemporal data has become an important research issue. Meanwhile, the Resource Description Framework (RDF) is a standard data and knowledge description language of the Semantic Web and has been applied in many application areas, such as geographic information systems and meteorological systems. In this paper, a model for representing fuzzy spatiotemporal data is proposed and a set of algebraic operations for the model are investigated. First, a representation method of fuzzy spatiotemporal RDF data and a fuzzy spatiotemporal RDF graph model are proposed. In addition, a formal fuzzy spatiotemporal RDF algebra is proposed and a set of algebraic operations for manipulating fuzzy spatiotemporal RDF data are developed. The algebraic operations include: set operation, selection operation, projection operation, join operation, and construction operation. Finally, the existing SPARQL query language is extended and an example that shows how to apply the proposed algebraic operations to capture the queries expressed by the extended SPARQL query language is given.

FHIR-Ontop-OMOP: Building clinical knowledge graphs in FHIR RDF with the OMOP Common data Model

BackgroundKnowledge graphs (KGs) play a key role to enable explainable artificial intelligence (AI) applications in healthcare. Constructing clinical knowledge graphs (CKGs) against heterogeneous electronic health records (EHRs) has been desired by the research and healthcare AI communities. From the standardization perspective, community-based standards such as the Fast Healthcare Interoperability Resources (FHIR) and the Observational Medical Outcomes Partnership (OMOP) Common Data Model (CDM) are increasingly used to represent and standardize EHR data for clinical data analytics, however, the potential of such a standard on building CKG has not been well investigated. ObjectiveTo develop and evaluate methods and tools that expose the OMOP CDM-based clinical data repositories into virtual clinical KGs that are compliant with FHIR Resource Description Framework (RDF) specification. MethodsWe developed a system called FHIR-Ontop-OMOP to generate virtual clinical KGs from the OMOP relational databases. We leveraged an OMOP CDM-based Medical Information Mart for Intensive Care (MIMIC-III) data repository to evaluate the FHIR-Ontop-OMOP system in terms of the faithfulness of data transformation and the conformance of the generated CKGs to the FHIR RDF specification. ResultsA beta version of the system has been released. A total of more than 100 data element mappings from 11 OMOP CDM clinical data, health system and vocabulary tables were implemented in the system, covering 11 FHIR resources. The generated virtual CKG from MIMIC-III contains 46,520 instances of FHIR Patient, 716,595 instances of Condition, 1,063,525 instances of Procedure, 24,934,751 instances of MedicationStatement, 365,181,104 instances of Observations, and 4,779,672 instances of CodeableConcept. Patient counts identified by five pairs of SQL (over the MIMIC database) and SPARQL (over the virtual CKG) queries were identical, ensuring the faithfulness of the data transformation. Generated CKG in RDF triples for 100 patients were fully conformant with the FHIR RDF specification. ConclusionThe FHIR-Ontop-OMOP system can expose OMOP database as a FHIR-compliant RDF graph. It provides a meaningful use case demonstrating the potentials that can be enabled by the interoperability between FHIR and OMOP CDM. Generated clinical KGs in FHIR RDF provide a semantic foundation to enable explainable AI applications in healthcare.

Distributed subgraph query for RDF graph data based on MapReduce

Nowadays, Resource Description Framework (RDF) query has been widely used in social networks, biomedicine and other fields. With the explosion of RDF data due to the Internet of Things and Semantic Web, people's demand for intelligent computing and intelligent search is increasing, effectively querying RDF has become a major challenge. The current query methods often introduce a large number of join operations, and repeatedly traverse in some subgraphs during the query process, which makes the query efficiency and query performance poor. To address the above problems, this paper proposes a subgraph query algorithm for RDF graph data in a distributed environment. The graph structure is used to decompose the stars of the RDF graph, and the optimal query sequence of the stars is calculated. Fewer intermediate results can be produced based on the query sequence to reduce repeated calculations. Besides, adjacency lists are used to store RDF graphs, which are distributed across multiple tables. Multiple table operations can reduce the scope of subject node traversal, and further improve the query efficiency of RDF subgraph by matching one star per iteration. Experimental results show that our work can improve the query efficiency of RDF subgraphs.

Learning to transfer knowledge from RDF Graphs with gated recurrent units

The Internet is a vital part of today’s ecosystem. The speedy evolution of the Internet has brought up practical issues such as the problem of information retrieval. Several methods have been proposed to solve this issue. Such approaches retrieve the information by using SPARQL queries over the Resource Description Framework (RDF) content which requires a precise match concerning the query structure and the RDF content. In this work, we propose a transfer learning-based neural learning method that helps to search RDF graphs to provide probabilistic reasoning between the queries and their results. The problem is formulated as a classification task where RDF graphs are preprocessed to abstract the N-Triples, then encode the abstracted N-triples into a transitional state that is suitable for neural transfer learning. Next, we fine-tune the neural learner to learn the semantic relationships between the N-triples. To validate the proposed approach, we employ ten-fold cross-validation. The results have shown that the anticipated approach is accurate by acquiring the average accuracy, recall, precision, and f-measure. The achieved scores are 97.52%, 96.31%, 98.45%, and 97.37%, respectively, and outperforms the baseline approaches.

Efficient semantic summary graphs for querying large knowledge graphs

Knowledge Graphs (KGs) integrate heterogeneous data, but one challenge is the development of efficient tools for allowing end users to extract useful insights from these sources of knowledge. In such a context, reducing the size of a Resource Description Framework (RDF) graph while preserving all information can speed up query engines by limiting data shuffle, especially in a distributed setting. This paper presents two algorithms for RDF graph summarization: Grouping Based Summarization (GBS) and Query Based Summarization (QBS). The latter is an optimized and lossless approach for the former method. We empirically study the effectiveness of the proposed lossless RDF graph summarization to retrieve complete data, by rewriting an RDF Query Language called SPARQL query with fewer triple patterns using a semantic similarity. We conduct our experimental study in instances of four datasets with different sizes. Compared with the state-of-the-art query engine Sparklify executed over the original RDF graphs as a baseline, QBS query execution time is reduced by up to 80% and the summarized RDF graph is decreased by up to 99%.

GRDF: An Efficient Compressor with Reduced Structural Regularities That Utilizes gRePair.

The explosive volume of semantic data published in the Resource Description Framework (RDF) data model demands efficient management and compression with better compression ratio and runtime. Although extensive work has been carried out for compressing the RDF datasets, they do not perform well in all dimensions. However, these compressors rarely exploit the graph patterns and structural regularities of real-world datasets. Moreover, there are a variety of existing approaches that reduce the size of a graph by using a grammar-based graph compression algorithm. In this study, we introduce a novel approach named gRDF (graph repair for RDF) that uses gRePair, one of the most efficient grammar-based graph compression schemes, to compress the RDF dataset. In addition to that, we have improved the performance of HDT (header-dictionary-triple), an efficient approach for compressing the RDF datasets based on structural properties, by introducing modified HDT (M-HDT). It can detect the frequent graph pattern by employing the data-structure-oriented approach in a single pass from the dataset. In our proposed system, we use M-HDT for indexing the nodes and edge labels. Then, we employ gRePair algorithm for identifying the grammar from the RDF graph. Afterward, the system improves the performance of -trees by introducing a more efficient algorithm to create the trees and serialize the RDF datasets. Our experiments affirm that the proposed gRDF scheme can substantially achieve at approximately 26.12%, 13.68%, 6.81%, 2.38%, and 12.76% better compression ratio when compared with the most prominent state-of-the-art schemes such as HDT, HDT++, -trees, RDF-TR, and gRePair in the case of real-world datasets. Moreover, the processing efficiency of our proposed scheme also outperforms others.

Schema-Based Mapping Approach for Data Transformation to Enrich Semantic Web

Modern web wants the data to be in Resource Description Framework (RDF) format, a machine-readable form that is easy to share and reuse data without human intervention. However, most of the information is still available in relational form. The existing conventional methods transform the data from RDB to RDF using instance-level mapping, which has not yielded the expected results because of poor mapping. Hence, in this paper, a novel schema-based RDB-RDF mapping method (relational database to Resource Description Framework) is proposed, which is an improvised version for transforming the relational database into the Resource Description Framework. It provides both data materialization and on-demand mapping. RDB-RDF reduces the data retrieval time for nonprimary key search by using schema-level mapping. The resultant mapped RDF graph presents the relational database in a conceptual schema and maintains the instance triples as data graph. This mechanism is known as data materialization, which suits well for the static dataset. To get the data in a dynamic environment, query translation (on-demand mapping) is best instead of whole data conversion. The proposed approach directly converts the SPARQL query into SQL query using the mapping descriptions available in the proposed system. The mapping description is the key component of this proposed system which is responsible for quick data retrieval and query translation. Join expression introduced in the proposed RDB-RDF mapping method efficiently handles all complex operations with primary and foreign keys. Experimental evaluation is done on the graphics designer database. It is observed from the result that the proposed schema-based RDB-RDF mapping method accomplishes more comprehensible mapping than conventional methods by dissolving structural and operational differences.

QRDF: An efficient RDF graph processing system for fast query

AbstractWith the rapid growth of RDF (resource description framework) data volume, it is challenging to answer queries over dynamic RDF graphs of which the data frequently changes (by insertion/deletion) over time. This article presents QRDF, an efficient RDF graph processing system that supports not only efficient storage but also fast query of dynamic RDF graphs. QRDF (i) adopts a red‐black (RB) tree for quick RDF data insertion/deletion and (ii) asynchronously moves data from the RB tree into a vector for efficient RDF query. QRDF performs early pruning on its index structure for various RDF query patterns. Experimental results show that the query performance of QRDF over RDF graphs is about 2x higher than that of the state‐of‐the‐art RDF processing systems.

Fixing the inconsistencies in fuzzy spatiotemporal RDF graph

Since an increasing number of applications have urgent requirements for the management of fuzzy spatiotemporal information, it is challenging to model fuzzy spatiotemporal data. On the other hand, because Resource Description Framework (RDF) benefits greatly from web data, linked data, and knowledge graph, it has been widely accepted and has rapidly become a new choice to model and represent data in many application domains. The advent of RDF seems to provide an opportunity for dealing with fuzzy spatiotemporal data. However, RDF data is subject to continuously changing operations so that they may violate the integrity constraints and cause inconsistencies. In order to solve these problems, we propose an extended RDF model that can represent fuzzy spatiotemporal data, and then present the structure of fuzzy spatiotemporal data in RDF graph. After studying the constraint conditions of fuzzy spatiotemporal data in RDF graph, we propose the corresponding fixing rules and algorithms to detect and repair the fuzzy spatiotemporal RDF graph. Finally, the experimental results demonstrate the effectiveness of our approach which can significantly solve the inconsistency problem of fuzzy spatiotemporal RDF graphs.

GoFast: Graph-based optimization for efficient and scalable query evaluation

The popularity of the Resource Description Framework (RDF) and SPARQL has thrust the development of high-performance systems to manage data represented with this model. Former approaches adapted the well-established relational model applying its storage, query processing, and optimization strategies. However, the borrowed techniques from the relational model are not universally applicable in the RDF context. First, the schema-free nature of RDF induces intensive joins overheads. Also, optimization strategies trying to find the optimal join order rely on error-prone statistics unable to capture all the correlations among triples. Graph-based approaches keep the graph structure of RDF representing the data directly as a graph. Their execution model leans on graph exploration operators to find subgraph matches to a query. Even if they have shown to outperform relational-based systems in complex queries, they are barely scalable and optimization techniques are completely system dependent. Recently, some systems such as RDF_QDAG have shown that by combining graph exploration and triples clustering one can achieve a good compromise between performance and scalability. In this paper, we propose optimization strategies for this kind of RDF management systems. First, we define novel statistics collected for clusters of triples to better capture the dependencies found in the original graph. Second, we redefine an execution plan based on these logical structures which allows to represent the RDF graph exploration process. Third, we introduce an algorithm for selecting the optimal execution plan based on a customized cost model. Finally, we propose a new approach to refine the chosen plan by pruning invalid clusters that do not participate in the construction of the final query results. All our proposals are validated experimentally using well-known RDF benchmarks.

Towards Interactive Analytics over RDF Graphs

The continuous accumulation of multi-dimensional data and the development of Semantic Web and Linked Data published in the Resource Description Framework (RDF) bring new requirements for data analytics tools. Such tools should take into account the special features of RDF graphs, exploit the semantics of RDF and support flexible aggregate queries. In this paper, we present an approach for applying analytics to RDF data based on a high-level functional query language, called HIFUN. According to that language, each analytical query is considered to be a well-formed expression of a functional algebra and its definition is independent of the nature and structure of the data. In this paper, we investigate how HIFUN can be used for easing the formulation of analytic queries over RDF data. We detail the applicability of HIFUN over RDF, as well as the transformations of data that may be required, we introduce the translation rules of HIFUN queries to SPARQL and we describe a first implementation of the proposed model.

In-memory parallelization of join queries over large ontological hierarchies

The Resource Description Framework (RDF) data model enables the construction of knowledge graphs over various domains, using ontologies in order to encode information about the domain, and simple statements in the form of subject-predicate-object triples for data representation, facilitating the interlinking and exchange of Web data. However, this simplicity comes with the cost of having to execute a large number of joins in order to get the desirable query results, while at the same time large ontological hierarchies complicate the query answering process even more, for systems that provide complete answers with respect to such ontological axioms. In this work we present PARJ, an in-memory RDF store which takes into consideration ontological hierarchies during join processing with very low performance overhead, avoiding expensive preprocessing and materialization of implications, and is also amenable to straightforward parallelization. Specifically, we present a join implementation that allows to achieve any desired degree of parallelism on arbitrary join queries and RDF graphs stored in memory using compact vertical partitioning. We use an adaptive join processing approach, such that we take advantage of complete or even partial ordering of RDF data, which is compactly stored in order to increase spatial locality and keep memory consumption low, coupled with an ID-to-Position vector index used when ordering does not allow for efficient scanning of the input relation. Finally, we experimentally show the efficiency and scalability of our proposal.

RDF graph mining for cluster-based theme identification

PurposeThe purpose of this paper is to present a generic pipeline for Resource Description Framework (RDF) graph mining to provide a comprehensive review of each step in the knowledge discovery from data process. The authors also investigate different approaches and combinations to extract feature vectors from RDF graphs to apply the clustering and theme identification tasks.Design/methodology/approachThe proposed methodology comprises four steps. First, the authors generate several graph substructures (Walks, Set of Walks, Walks with backward and Set of Walks with backward). Second, the authors build neural language models to extract numerical vectors of the generated sequences by using word embedding techniques (Word2Vec and Doc2Vec) combined with term frequency-inverse document frequency (TF-IDF). Third, the authors use the well-known K-means algorithm to cluster the RDF graph. Finally, the authors extract the most relevant rdf:type from the grouped vertices to describe the semantics of each theme by generating the labels.FindingsThe experimental evaluation on the state of the art data sets (AIFB, BGS and Conference) shows that the combination of Set of Walks-with-backward with TF-IDF and Doc2vec techniques give excellent results. In fact, the clustering results reach more than 97% and 90% in terms of purity andF-measure, respectively. Concerning the theme identification, the results show that by using the same combination, the purity andF-measure criteria reach more than 90% for all the considered data sets.Originality/valueThe originality of this paper lies in two aspects: first, a new machine learning pipeline for RDF data is presented; second, an efficient process to identify and extract relevant graph substructures from an RDF graph is proposed. The proposed techniques were combined with different neural language models to improve the accuracy and relevance of the obtained feature vectors that will be fed to the clustering mechanism.

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.