Datalog has grown in popularity with its integration into various commercial and open-source systems. One significant application of Datalog is in stream reasoning scenarios, particularly in the context of Internet of Things and Edge Computing, where it supports the derivation of implicit consequences from incomplete streaming data. The dynamic nature of edge infrastructure, with constantly changing data and deduction rules, poses additional challenges for incremental reasoning. This paper introduces Zodiac, a method for reasoning under rule amendments, and ZodiacEdge, a system implementing this method. Zodiac is based on Datalog stratification and semi-naive evaluation but includes a novel data structure that supports incremental maintenance of deductions for fast rule amendments, even in the presence of negation and aggregation. ZodiacEdge is designed to work with RDF data, accepting Datalog programs with predicates of a maximum arity of two.

Abstract Data streams which are now massively and constantly arriving from Internet of Things devices, sensors and social media, require efficient processing, querying and reasoning within a given timeframe. With this in mind, the RDF data model, the cornerstone of the Web of Data, supports a feature-rich stream processing ecosystem that takes into account the temporal dimension associated with events. These timestamped streams support advanced temporal analysis ranging from time-based queries, temporal anomaly detection to temporal reasoning. This survey is the first to provide a comprehensive overview of the field of RDF stream processing, focusing on (query) languages, systems, and benchmarks. For each of these areas, we present salient dimensions, propose a taxonomy of existing work, detail the concepts at the core of each approach and describe their main technical aspects and implementation. We hope that the survey will help readers understand this scientifically rich field and identify the most relevant method for various usage scenarios.

Graphs are fundamental data structures used in a wide range of fields, from social networks to bioinformatics. Their flexibility and ability to model complex data make them an indispensable tool for solving a wide range of problems. However, the use of graphs poses challenges, in particular the management of large amounts of data, which complicates and increases the analysis load in terms of computational power, memory and storage. This paper addresses the computation of a connected components, which are often used to understand the connectivity structure of a graph. This paper proposes a novel parallel approach to perform this computation. It takes advantage of a cluster computing engine and a graph processing library running locally on each node of the cluster. We also present an incremental approach to computing these components. We demonstrate the efficiency of our approach in a real biological use case, where our approach can be up to 4x faster than the label propagation algorithm implemented on a state-of-the-art cluster computing engine. This performance gain is mainly due to a reduction in the amount of data shuffling.

The emergence of increasingly powerful and inexpensive single-board computers has motivated a great deal of work in the field of edge computing. We believe that knowledge graphs will contribute to intelligent edge computing. This requires the ability to efficiently answer queries requiring inferences performed with minimal knowledge accessible on a device at the edge of the network. In this work, we determine the minimum size of the knowledge graph that an edge device needs based on the analysis of its query workload. In the context of a succinct data structures-based store, we also present an incremental update of this knowledge graph when new queries are introduced into the environment. We demonstrate the effectiveness of our solution on real use cases encountered by our industrial partner.

In this paper, we study the following problem: given a knowledge graph (KG) and a set of input vertices (representing concepts or entities) and edge labels, we aim to find the smallest connected subgraphs containing all of the inputs. This problem plays a key role in KG-based search engines and natural language question answering systems, and it is a natural extension of the Steiner tree problem, which is known to be NP-hard. We present RECON, a system for finding approximate answers. RECON aims at achieving high accuracy with instantaneous response (i.e., sub-second/millisecond delay) over KGs with hundreds of millions edges without resorting to expensive computational resources. Furthermore, when no answer exists due to disconnection between concepts and entities, RECON refines the input to a semantically similar one based on the ontology, and attempts to find answers with respect to the refined input. We conduct a comprehensive experimental evaluation of RECON. In particular we compare it with five existing approaches for finding approximate Steiner trees. Our experiments on four large real and synthetic KGs show that RECON significantly outperforms its competitors and incurs a much smaller memory footprint.

International audience

As the usage of RDF-based Knowledge Graphs is going mainstream, it becomes necessary for organizations and companies to consider the privacy preservation of the data they are managing and possibly sharing. This is generally performed by anonymization techniques such as triple suppression and generalization. Nevertheless, these techniques have the drawback of reducing the utility of the released datasets. This paper presents semantic anatomization, a novel anonymization technique, that retains all quasi-identifier and sensitive values in the RDF graph. Due to an aggregating mechanism and the exploitation of the semantics contained in ontologies, this technique preserves data correlation and supports high quality analysis from anonymized graphs. We demonstrate the potential of semantic anatomization on large graphs generated from our own extension of the well-established Lehigh university benchmark.

As edge computing is becoming a new platform for rich applications and services, it becomes more and more important to design adapted data management systems for this environment. In this paper, we present a prototype corresponding to a compact, in-memory RDF store that can answer SPARQL queries requiring reasoning services without necessitating any decompression. This demonstration highlights a design based on succinct data structures, shows some implementation details and provides encouraging performance measures over a set of real-world and synthetic data and query sets.

Topic evolution networks are widely used to represent the evolution of research topics in scientific document archives. These networks might contain thousands of topics and alignment edges which are computed by comparing millions of topic pairs with some similarity function. In this work, we are addressing the problem of computing a very large number cosine-based topic alignments on top of Apache Spark. We present the native map-reduce implementation proposed by Spark and a more efficient implementation which is tuned for alignment computation. Both implementations are evaluated on three real-world datasets.

Stream processing is becoming an omnipresent component in feature-rich computerized applications. The RDF data model is now frequently used to represent streams due to its data integration capabilities and support for reasoning services. In such situations, continuous extensions of the SPARQL query language are used to retrieve information from input streams. To efficiently process such queries, we claim that a representation aware of the regularity of incoming stream patterns is needed. In this paper, we present such a data format together with a dedicated query language which is equipped with inference features. Moreover, we highlight that queries in this language can be generated from machine learning-based processing of data streams. We emphasize the efficiency of our solution through an evaluation of real-world and synthetic datasets.

Shifting from Big Data to Big Knowledge requires systems that are able to cope with the large volume and high-velocity dimensions in a scalable and inference-enabled manner. In this work, we are focusing on stream processing and reasoning using the graph-based RDF data model. We are aiming to explore the ability of modern distributed computing frameworks to process highly expressive knowledge inference queries over Big Data streams. To do so, we consider queries expressed as a positive fragment of a temporal logic framework based on Answer Set Programming and propose solutions to process such queries, based on the two main execution models adopted by major parallel and distributed execution frameworks: Bulk Synchronous Parallel (BSP) and Recordat-A-Time (RAT). We implement our solution named BigSR and conduct a series of experiments with 15 queries from 4 different datasets. Our experiments show that BigSR achieves high throughput beyond million-triples per second using a rather small cluster of machines.

International audience

Reasoning over semantically annotated data is an emerging trend in stream processing aiming to produce sound and complete answers to a set of continuous queries. It usually comes at the cost of finding a trade-off between data throughput and the cost of expressive inferences. StriderRproposes such a trade-off and combines a scalable RDF stream processing engine with an efficient reasoning system. The main reasoning tasks are based on a query rewriting approach for SPARQL that benefits from an intelligent encoding of an extension of the RDFS (i.e., RDFS with owl:sameAs) ontology elements. StriderRruns in production at a major international water management company to detect anomalies from sensor streams. The system is evaluated along different dimensions and over multiple datasets to emphasize its performance.

Real-time processing of data streams emanating from sensors is becoming a common task in industrial scenarios. An increasing number of processing jobs executed over such platforms are requiring reasoning mechanisms. The key implementation goal is thus to efficiently handle massive incoming data streams and support reasoning, data analytic services. Moreover, in an on-going industrial project on anomaly detection in large potable water networks, we are facing the effect of dynamically changing data and work characteristics in stream processing. The Strider system addresses these research and implementation challenges by considering scalability, fault-tolerance, high throughput and acceptable latency properties. We will demonstrate the benefits of Strider on an Internet of Things-based real world and industrial setting.

The number of linked data sources and the size of the linked open data graph keep growing every day. As a consequence, semantic RDF services are more and more confronted with various "big data" problems. Query processing in the presence of inferences is one them. For instance, to complete the answer set of SPARQL queries, RDF database systems evaluate semantic RDFS relationships (subPropertyOf, subClassOf) through time-consuming query rewriting algorithms or space-consuming data materialization solutions. To reduce the memory footprint and ease the exchange of large datasets, these systems generally apply a dictionary approach for compressing triple data sizes by replacing resource identifiers (IRIs), blank nodes and literals with integer values. In this article, we present a structured resource identification scheme using a clever encoding of concepts and property hierarchies for efficiently evaluating the main common RDFS entailment rules while minimizing triple materialization and query rewriting. We will show how this encoding can be computed by a scalable parallel algorithm and directly be implemented over the Apache Spark framework. The efficiency of our encoding scheme is emphasized by an evaluation conducted over both synthetic and real world datasets.