Triple Patterns Research Articles

SPARQL Optimization Using Re-ordering Joining Patterns with Surrogate Key Concept and Subset Patterns

Semantic web data resides on the web in the form of knowledge graphs known as RDF graphs and searching around the web has been always a crucial task. For the data retrieval of RDF data of the semantic web, SPARQL query language has been used which in turn is based on triple patterns and joins. Optimization of SPARQL query has been a problematic concern for decades due to the large amount of triple patterns associated with RDF data. Although several researchers have put a lot of effort into the optimization of SPARQL query, it is difficult to understand the concept from scratch due to its diversified nature. This paper analyses various optimization techniques for the SPARQL query used with the semantic web to process knowledge graphs. These techniques include join-based, heuristic-based, rule-based, and indexing-based approaches for optimization. This paper will help researchers in this domain to easily get into the core concept of SPARQL execution along with various optimization approaches used for query processing, which can help in various other domains like linked open data and information retrieval. In this paper, an optimization algorithm HSOA (hybrid SPARQL optimization algorithm) has been proposed, which comprises the features of index-based, cost-based, and triple reordering-based optimization approaches. The proposed hybrid algorithm has been designed specifically for n-triple RDF data, which comprises subset patterns, and surrogate key concepts. The results produced by the proposed algorithm are encouraging and have also been tested and compared with the benchmark dataset and SPARQL queries like LUBM, BSBM, and SP2Bench.

Semantic relatedness in DBpedia: A comparative and experimental assessment

The evaluation of semantic relatedness between web resources is still an open challenge. This paper focuses on knowledge-based methods that provide an alternative to corpus-based approaches and generally rely on the availability of knowledge graphs. In particular, we selected 10 methods from the existing literature, organized by adjacent resources, triple patterns, and triple weights-based methods. They were implemented and evaluated using DBpedia as a reference RDF knowledge graph. Since DBpedia is under constant development, the experimental results of these proposals are not comparable in the literature. For this reason, in this work, these methods were experimented with the same DBpedia release and 14 well-known golden datasets at once. Based on this experimentation, the weighting of RDF triples combined with the evaluation of all the directed paths linking the compared resources is the best strategy for computing semantic relatedness in DBpedia.

Approach for Efficient Triple Pattern Extraction Information Retrieval in Ontology

E-learning is an effective tool for education than what is currently provided by any of the available computer aided tutoring, or learning management systems. Semantic Web is a collection of information that is linked to each other and process by machine in global scale. It can be seen as globally connected database. Here we proposed a combined methodology for better information retrieval by using similarity measurement and visiting frequency and triplet pattern extraction. The primary intention of this paper is to improve the learning capability. triple patterns extraction is essential to convert the incoming learners query to Ontology browsing query (SPARQL).After extracting the triple patterns from the input query is used to build the query for receiving exact information in the ontology content.

Space/time-efficient RDF stores based on circular suffix sorting

The resource description framework (RDF) has gained popularity as a format for the standardized publication and exchange of information in the Web of Data. In this paper, we introduce RDFCSA, a compressed representation of RDF datasets that in addition supports efficient querying. RDFCSA regards the triples of the RDF store as short circular strings and applies suffix sorting on those strings, so that triple-pattern queries reduce to prefix searching on the string set. The RDF store is then represented compactly using a compressed suffix array (CSA), a proved technology in text indexing that efficiently supports prefix searches. Our experiments show that RDFCSA is competitive with state-of-the-art alternatives. It compresses the raw data to 60% of its size, close to the most compact alternatives. While most alternatives perform better in some kinds of triple-patterns than in others, RDFCSA features fast and consistent query times, a few microseconds per result in all cases. This enables efficiently supporting join queries by using either merge- or chaining-join strategies over the triple patterns coupled with some specific optimizations such as variable filling. Our experiments on binary joins show that RDFCSA is faster than the alternatives in most cases.

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%.

MuSe: a multi-level storage scheme for big RDF data using MapReduce

Resource Description Framework (RDF) model owing to its flexible structure is increasingly being used to represent Linked data. The rise in amount of Linked data and Knowledge graphs has resulted in an increase in the volume of RDF data. RDF is used to model metadata especially for social media domains where the data is linked. With the plethora of RDF data sources available on the Web, scalable RDF data management becomes a tedious task. In this paper, we present MuSe—an efficient distributed RDF storage scheme for storing and querying RDF data with Hadoop MapReduce. In MuSe, the Big RDF data is stored at two levels for answering the common triple patterns in SPARQL queries. MuSe considers the type of frequently occuring triple patterns and optimizes RDF storage to answer such triple patterns in minimum time. It accesses only the tables that are sufficient for answering a triple pattern instead of scanning the whole RDF dataset. The extensive experiments on two synthetic RDF datasets i.e. LUBM and WatDiv, show that MuSe outperforms the compared state-of-the art frameworks in terms of query execution time and scalability.

R2D2: A Dbpedia Chatbot Using Triple-Pattern Like Queries

Chatbots, also known as conversation agents, are programs that are able to simulate and reproduce an intelligent conversation with humans. Although this type of program is not new, the explosion of the available information and the rapid increase of the users seeking this information have renewed the interest in their development. In this paper, we present R2D2, an intelligent chatbot relying on semantic web technologies and offering an intelligent controlled natural language interface for accessing the information available in DBpedia. The chatbot accepts structured input, allowing users to enter triple-pattern like queries, which are answered by the underlying engine. While typing, an auto-complete service guides users on creating the triple patterns, suggesting resources available in the DBpedia. Based on user input (in the form of triple-pattern like queries), the corresponding SPARQL queries are automatically formulated. The queries are submitted to the corresponding DBpedia SPARQL endpoint, and then the result is received by R2D2 and augmented with maps and visuals and eventually presented to the user. The usability evaluation performed shows the advantages of our solution and its usefulness.

IHDT++: improving HDT for SPARQL triple pattern resolution

RDF self-indexes compress the RDF collection and provide efficient access to the data without a previous decompression (via the so-called SPARQL triple patterns). HDT is one of the reference solutions in this scenario, with several applications to lower the barrier of both publication and consumption of Big Semantic Data. However, the simple design of HDT takes a compromise position between compression effectiveness and retrieval speed. In particular, it supports scan and subject-based queries, but it requires additional indexes to resolve predicate and object-based SPARQL triple patterns. A recent variant, HDT++, improves HDT compression ratios, but it does not retain the original HDT retrieval capabilities. In this article, we extend HDT++ with additional indexes to support full SPARQL triple pattern resolution with a lower memory footprint than the original indexed HDT (called HDT-FoQ). Our evaluation shows that the resultant structure, iHDT++ , requires 70 - 85% of the original HDT-FoQ space (and up to 48 - 72% for an HDT Community variant). In addition, iHDT++ shows significant performance improvements (up to one level of magnitude) for most triple pattern queries, being competitive with state-of-the-art RDF self-indexes.

RDFFrames

Knowledge graphs represented in RDF are becoming increasingly popular and are essential to many machine learning applications. A rich ecosystem of RDF data management systems and tools has evolved over the years, most notably RDF database management systems that support the SPARQL query language. Surprisingly, machine learning tools for knowledge graphs typically do not use SPARQL despite the obvious advantages of using a database system. This is due to the mismatch between SPARQL and machine learning tools in terms of expected data model and interface style. Machine learning tools work on data in tabular format and process it using imperative relational API calls, while SPARQL matches graph patterns to RDF triples. To access knowledge graphs for machine learning, we observe that it is more natural to use a navigational paradigm based on graph traversal rather than the SPARQL paradigm based on triple patterns. We demonstrate RDFFrames, a framework that bridges the gap between machine learning tools and RDF database systems by offering the usability and flexibility of machine learning tools together with the performance of a database system. RDFFrames enables the user to make a sequence of Python calls to define the data to be extracted from a knowledge graph stored in an RDF database system, and it translates these calls into a compact SPARQL query, executes it on the database system, and returns the results in a standard tabular format.

A data distribution model for RDF

The ever-increasing amount of RDF data made available requires data to be partitioned across multiple servers. We have witnessed some research progress made towards scaling RDF query processing based on suitable data distribution methods. In general, they work well for queries matching simple triple patterns, but they are not efficient for queries involving more complex patterns. In this paper, we present an RDF data distribution method which overcomes the shortcomings of the current approaches in order to scale RDF storage both on the volume of data and query processing. We apply a method that identifies frequent patterns accessed by queries in order to keep related data in the same partition. We deploy our reasoning on a summarized view of data in order to avoid exhaustive analysis on large datasets. As result, partitioning templates are obtained from data items in an RDF structure. In addition, we provide an approach for dynamic data insertions even if new data do not conform to the original RDF structure. Apart from the repartitioning approaches, we use an overflow repository to store data which may not follow the original schema. Our study shows that our method scales well and is effective to improve the overall performance by decreasing the amount of message passing among servers, compared to alternative data distribution approaches for RDF.

Study of Aesthetic Elements of Karo Traditional House in terms of Dualism and Triple Patterns

Study of Aesthetic Elements of Karo Traditional House in terms of Dualism and Triple Patterns

ComQA: Question Answering Over Knowledge Base via Semantic Matching

Question answering over knowledge base (KBQA) is a powerful tool to extract answers from graph-like knowledge bases. Here, we present ComQA—a three-phase KBQA framework by which end-users can ask complex questions and get answers in a natural way. In ComQA, a complex question is decomposed into several triple patterns. Then, ComQA retrieves candidate subgraphs matching the triple patterns from the knowledge base and evaluates the semantic similarity between the subgraphs and the triple patterns to find the answer. It is a long-standing problem to evaluate the semantic similarity between the question and the heterogeneous subgraph containing the answer. To handle this problem, first, a semantic-based extension method is proposed to identify entities and relations in the question while considering the underlying knowledge base. The precision of identifying entities and relations determines the correctness of successive steps. Second, by exploiting the syntactic pattern in the question, ComQA constructs the query graphs for natural language questions so that it can filter out topology-mismatch subgraphs and narrow down the search space in knowledge bases. Finally, by incorporating the information from the underlying knowledge base, we fine-tune general word vectors, making them more specific to ranking possible answers in KBQA task. Extensive experiments over a series of QALD challenges confirm that the performance of ComQA is comparable to those state-of-the-art approaches with respect to precision, recall, and F1-score.

LargeRDFBench: A Billion Triples Benchmark for SPARQL Endpoint Federation

Gathering information from the distributed Web of Data is commonly carried out by using SPARQL query federation approaches. However, the fitness of current SPARQL query federation approaches for real applications is difficult to evaluate with current benchmarks as they are either synthetic, too small in size and complexity or do not provide means for a fine-grained evaluation. We propose LargeRDFBench, a billion-triple benchmark for SPARQL query federation which encompasses real data as well as real queries pertaining to real bio-medical use cases. We evaluate state-of-the-art SPARQL endpoint federation approaches on this benchmark with respect to their query runtime, triple pattern-wise source selection, number of endpoints requests, and result completeness and correctness. Our evaluation results suggest that the performance of current SPARQL query federation systems on simple queries (in terms of total triple patterns, query result set sizes, execution time, use of SPARQL features etc.) does not reflect the systems' performance on more complex queries. Moreover, current federation systems seem unable to deal with real queries that involve processing large intermediate result sets or lead to large result sets.

LargeRDFBench: A billion triples benchmark for SPARQL endpoint federation

Gathering information from the distributed Web of Data is commonly carried out by using SPARQL query federation approaches. However, the fitness of current SPARQL query federation approaches for real applications is difficult to evaluate with current benchmarks as they are either synthetic, too small in size and complexity or do not provide means for a fine-grained evaluation. We propose LargeRDFBench, a billion-triple benchmark for SPARQL query federation which encompasses real data as well as real queries pertaining to real bio-medical use cases. We evaluate state-of-the-art SPARQL endpoint federation approaches on this benchmark with respect to their query runtime, triple pattern-wise source selection, number of endpoints requests, and result completeness and correctness. Our evaluation results suggest that the performance of current SPARQL query federation systems on simple queries (in terms of total triple patterns, query result set sizes, execution time, use of SPARQL features etc.) does not reflect the systems’ performance on more complex queries. Moreover, current federation systems seem unable to deal with real queries that involve processing large intermediate result sets or lead to large result sets.

RDF approximate queries based on semantic similarity

In this paper, we propose a query relaxation approach to handle the problem of empty or too little answers returned from RDF query. We apply RDF entailment to triple patterns in the original query to get more general answers. We propose the notion of semantic similarity degree so that the returned answers are semantically close to the original query. We present how to compute the semantic similarity degree of a relaxed query with respect to the original query. With the semantic similarity degrees, we can choose the relaxed queries that are semantically close to the original query. On this basis, we give the query relaxation algorithm. We verify our approach by experiments. It is shown that our approach of RDF query relaxation based on the semantic similarity degree has some good performances and is feasible.

Linked Open Data Query Based on Natural Language

Linked open data (LOD) supports the SPARQL query strongly. A translation system from the natural language query to the SPARQL query based on the syntax rules is proposed. For a natural language query, a parsing method is proposed to represent the query intention and construct the corresponding query graph. The algorithms for obtaining and instantiating triple patterns are designed based on the rules. A mapping method for different types of graph nodes is lastly proposed to improve the recall. The experiments based on test data from QALD-4 are conducted. Compared with the other systems, our system is more easy and effective, and evaluation results are outstanding in the field of unsupervised learning.

Arabic Question Answering Using Ontology

Currently, with the massive amount of data that is being posted on the web at a rapid pace, users regularly have inquiries and they expect to find out short and precise answers. Semantic web and ontology technologies are becoming the essential components to represent domain-specific data that can be utilized in Question Answering System (QAS). In this paper, we introduce an Arabic QAS based on the domain knowledge or ontology in order to answer natural language inquiries. Prior to the implementation, it was crucial to perform some Natural Language Processing (NLP) tasks that assisted in analyzing the questions such as normalization, tokenizing, removing the stop words, stemming and tagging. Furthermore, we present how to develop the ontology through the Protégé tool, how to translate the inquiries into triple patterns and build the SPARQL queries which are the mechanism to retrieve the answer from Resource Description Framework (RDF) data. As far as Arabic is concerned, Arabic Question Answering (QA) is still limited and did not reach the similar level of English QA because of challenges on the Arabic language, for example, complexity in morphology derivational and inflectional, and words suffer from the scare of vowels. In addition, Arabic language orthography does not use capital letters or the like, which affect on Named Entity Recognitions. Hence, it is an opportunity to focus on Arabic QA using ontology toward getting a clear concept of this semantic-based approach. The result of the experimental results demonstrates the feasibility of constructing a QAS based on ontology. The proposed model has achieved promising results with accuracy of 81%, which provides an important indication for further in-depth study and analysis.

Handling failing RDF queries: from diagnosis to relaxation

Recent years have witnessed the development of large knowledge bases (KBs). Due to the lack of information about the content and schema semantics of KBs, users are often not able to correctly formulate KB queries that return the intended result. In this paper, we consider the problem of failing RDF queries, i.e., queries that return an empty set of answers. Query relaxation is one cooperative technique proposed to solve this problem. In the context of RDF data, several works proposed query relaxation operators and ranking models for relaxed queries. But none of them tried to find the causes of an RDF query failure given by Minimal Failing Subqueries (MFSs) as well as successful queries that have a maximal number of triple patterns named Ma$$\underline{x}$$x?imal Succeeding Subqueries (XSSs). Inspired by previous work in the context of relational databases and recommender systems, we propose two complementary approaches to fill this gap. The lattice-based approach (LBA) leverages the theoretical properties of MFSs and XSSs to efficiently explore the subquery lattice of the failing query. The matrix-based approach computes a matrix that records alternative answers to the failing query with the triple patterns they satisfy. The skyline of this matrix directly gives the XSSs of the failing query. This matrix can also be used as an index to improve the performance of LBA. The practical interest of these two approaches are shown via a set of experiments conducted on the LUBM benchmark and a comparative study with baseline and related work algorithms.

An ant colony optimisation approach for optimising SPARQL queries by reordering triple patterns

Processing the excessive volumes of information on the Web is an important issue. The Semantic Web paradigm has been proposed as the solution. However, this approach generates several challenges, such as query processing and optimisation. This paper proposes a novel approach for optimising SPARQL queries with different graph shapes. This new method reorders the triple patterns using Ant Colony Optimisation (ACO) algorithms. Reordering the triple patterns is a way of decreasing the execution times of the SPARQL queries. The proposed approach is focused on in-memory models of RDF data, and it optimises the SPARQL queries by means of Ant System, Elitist Ant System and MAX–MIN Ant System algorithms. The approach is implemented in the Apache Jena ARQ query engine, which is used for the experimentation, and the new method is compared with Normal Execution, Jena Reorder Algorithms, and the Stocker et al. Algorithms. All of the experiments are performed using the LUBM dataset for various shapes of queries, such as chain, star, cyclic, and chain–star. The first contribution is the real-time optimisation of SPARQL query triple pattern orders using ACO algorithms, and the second contribution is the concrete implementation for the ARQ query engine, which is a component of the widely used Semantic Web framework Apache Jena. The experiments demonstrate that the proposed method reduces the execution time of the queries significantly.

Extended Query Pattern Graph and Heuristics - based SPARQL Query Planning

SPARQL query language plays a significant role in developing semantic web and web intelligence. In order to deal with large data query execution over RDF, SPARQL query optimizer is an essential component in the SPARQL query engine for improving query execution performance. This paper proposes an approach for performing query planning and optimization based on an extended query pattern graph and heuristics. First, this paper generalizes SPARQL query statement representation by taking other expressions into account, aiming at overcoming the limitations of only using basic query triple patterns. Second, this paper presents the heuristics for estimating the cost of executing query triple pattern. The proposed query planning methods are implemented within Corese query engine and are evaluated using BSBM benchmark. The results suggest that the proposed methods can optimize effectively the query execution time of SPARQL query engine.