An Adaptive Framework for RDF Stream Reasoning

Qiong Li, Xiaowang Zhang, Zhiyong Feng, Guohui XiaoISWC (Posters, Demos & Industry Tracks) 2017 · OpenReview

In the evolving landscape of the Semantic Web, data is increasingly generated as continuous streams from sources such as IoT sensors and environmental monitors. Processing this "firehose" of information in real-time is challenging, particularly when logical reasoning is required to uncover implicit knowledge. Researchers from Tianjin University and the Free University of Bozen-Bolzano have addressed this by proposing PRSPR, an adaptive, plug-in framework designed for efficient RDF stream reasoning.

The Challenge of Stream Reasoning

RDF streams model real-time information, but traditional reasoning tools are primarily optimized for static datasets. Reasoning—the process of inferring new facts from existing data based on ontologies—is often computationally expensive. Existing systems that handle streams frequently perform reasoning as a post-processing step, which introduces latency unsuitable for real-time applications. The PRSPR framework aims to bridge this gap by providing a modular architecture that supports distributed reasoning and flexible query engine integration.

The PRSPR Framework

PRSPR (an extension of the previous PRSP work) utilizes a "plug-and-play" architecture to decouple reasoning from query execution. This modularity allows developers to integrate various SPARQL query engines and RDFS/OWL inference engines.

Architecture of the PRSPR framework showing the data flow from RDF streams to query results.

The framework consists of four primary components:

  1. Query Preparation: Continuous SPARQL queries are decomposed into a standard SPARQL query and a "Window Selector" that defines temporal or data-driven boundaries.
  2. Data Transformer: This module partitions the incoming RDF stream into discrete graphs based on the specified window and step sizes.
  3. RDFS Reasoner: Serving as the core logic engine, it employs rule-based ontologies on Apache Spark to compute the deductive closure, revealing hidden facts within each data window.
  4. Query Execution: A unified interface allows for the swapping of different SPARQL engines (e.g., RDF-3X, gStore) to suit specific performance requirements.

By implementing a "locally optimal executable strategy" on Spark, PRSPR optimizes rule application to prevent reasoning from becoming a system bottleneck.

Experimental Evaluation

The framework was evaluated using the YABench benchmark and the Lehigh University Benchmark (LUBM). Testing spanned various scales, from LUBM200 (approx. 28 million triples) to LUBM1000 (over 130 million triples), comparing centralized engines (RDF-3X, gStore) against distributed ones (gStoreD, TriAD, S2RDF).

Performance metrics including loading time, response time, and engine execution time, alongside a table of reasoning times for various LUBM scales.

Key Findings

  • Essential Reasoning: For specific queries, standard engines returned zero results without an active reasoner, demonstrating that reasoning is critical for data completeness.
  • Scalability and Performance: As the data volume increased from LUBM200 to LUBM1000, reasoning time grew from 3,155 seconds to 9,688 seconds. Distributed engines like TriAD and S2RDF significantly outperformed centralized alternatives under high loads.
  • System Limits: At the LUBM1000 scale, some engines (e.g., gStoreD, S2RDF) experienced data loss or incomplete results, highlighting the extreme computational demands of high-velocity stream reasoning.

Conclusion

PRSPR provides a flexible and scalable solution for RDF stream reasoning by leveraging distributed computing and a modular design. While it handles massive data volumes effectively, extreme scales still pose challenges for data integrity and latency. Future work will focus on further optimizing reasoning strategies and extending support for more complex OWL entailment rules to enhance the framework's robustness in high-velocity environments.

Summary updated

BibTeX
@inproceedings{li2017adaptive,
  author = {Qiong Li and Xiaowang Zhang and Zhiyong Feng and Guohui Xiao},
  title = {{An Adaptive Framework for RDF Stream Reasoning}},
  booktitle = {ISWC (Posters, Demos \& Industry Tracks)},
  year = {2017},
  url = {https://openreview.net/forum?id=ppGQLyMnRkm},
}
Figure