RORS: Enhanced Rule-Based OWL Reasoning on Spark

@article{Liu2016RORSER,
  title={RORS: Enhanced Rule-Based OWL Reasoning on Spark},
  author={Zhihui Liu and Zhiyong Feng and Xiaowang Zhang and Xin Wang and Guozheng Rao},
  journal={ArXiv},
  year={2016},
  volume={abs/1605.02824}
}
The rule-based OWL reasoning is to compute the deductive closure of an ontology by applying RDF/RDFS and OWL entailment rules. The performance of the rule-based OWL reasoning is often sensitive to the rule execution order. In this paper, we present an approach to enhancing the performance of the rule-based OWL reasoning on Spark based on a locally optimal executable strategy. Firstly, we divide all rules (27 in total) into four main classes, namely, SPO rules (5 rules), type rules (7 rules… Expand
Enhancing Rule-based OWL Reasoning on Spark
TLDR
The experimental results show that the approach to enhancing the performance of the rule-based OWL reasoning on Spark based on a locally optimal executable strategy achieves better performance as compared to Kim & Park’s algorithm. Expand
SPOWL: Spark-based OWL 2 Reasoning Materialisation
  • Yu Liu, P. McBrien
  • Computer Science
  • BeyondMR@SIGMOD
  • 2017
TLDR
SPOWL acts as a compiler, which maps axioms in the T-Box of an ontology to Spark programmes, which will be executed iteratively to compute and materialise a closure of reasoning results entailed by the ontology. Expand
PRSPR: An Adaptive Framework for Massive RDF Stream Reasoning
TLDR
To efficiently support real-time reasoning on massive RDF stream, this paper develops a multi-threaded batch processing approach to manage resources and an adaptive reasoning plan for dynamically managing inference rules in the stream reasoning. Expand
ComR: a combined OWL reasoner for ontology classification
TLDR
This paper proposes a task decomposition strategy for identifying the minimal non-EL subontology that contains only necessary axioms to ensure completeness and shows that this approach offers a substantial speedup in ontology classification. Expand
Towards Better SWRL Rules Dependency Extraction
TLDR
This paper describes a rules dependency extraction approach for Semantic Web Rule Language (SWRL) rules that insures the automatic extraction of a rule dependency graph based on the semantics of their components. Expand
Distributed Reasoning of RDF Data
TLDR
This chapter covers five main categories of distributed RDF reasoning systems: Peer-to-Peer R DF reasoning systems, NoSQL-based RDF Reasoning systems, Hadoop- based RDF thinking systems, Spark-basedRDF reasoning Systems, and shared memory RDFreasoning systems. Expand
An Adaptive Framework for RDF Stream Reasoning
TLDR
Within this framework, not only can PRSPR apply all kinds of SPARQL query engines to process RDF streams, but also simultaneously support various inference engines for RDFS/OWL for stream reasoning. Expand
Multi-source knowledge fusion: a survey
TLDR
This paper comprehensively introduces the latest research progress of open-source knowledge fusion, multi-knowledge graphs fusion, information fusion within KGs,multi-modal knowledge fusion and multi- source knowledge collaborative reasoning. Expand
Linked Data

References

SHOWING 1-10 OF 23 REFERENCES
Scalable OWL-Horst ontology reasoning using SPARK
TLDR
An approach to perform reasoning for scalable OWL ontologies in a Hadoop-based distributed computing cluster that loads triples to memory in computer nodes that are connected by SPARK - a memory-based cluster computing platform - and executes ontology reasoning. Expand
Rule-based Reasoning on Massively Parallel Hardware
TLDR
This paper proposes a rule-based reasoning algorithm which explores the highly parallel hardware of modern processors and works with rules that can be defined depending on the application scenario and thus is able to apply different semantics. Expand
Cichlid: Efficient Large Scale RDFS/OWL Reasoning with Spark
TLDR
This paper proposes Cichlid, an efficient distributed reasoning engine for the widely-used RDFS and OWL Horst rule sets and optimized the inner Spark execution mechanism by proposing an off-heap memory storage mechanism for RDD. Expand
OWL Reasoning with WebPIE: Calculating the Closure of 100 Billion Triples
TLDR
This paper proposes solutions to allow distributed computation of the closure of an RDF graph under the OWL Horst semantics, and demonstrates the WebPIE inference engine, built on top of the Hadoop platform and deployed on a compute cluster of 64 machines. Expand
Rule-Based OWL Reasoning for Specific Embedded Devices
TLDR
This paper developed an OWL reasoner for embedded devices that can be implemented using rule-based reasoning engines, and presents the used embedded hardware, the implemented reasoning component, and results regarding performance and memory consumption. Expand
A distributed rule execution mechanism based on MapReduce in sematic web reasoning
TLDR
A kind of semantic web rule execution mechanism using MapReduce programming model, which not only can handle RDFS and OWL ter Horst semantic rules, but also can be used in SWRL reasoning. Expand
Pellet: A practical OWL-DL reasoner
TLDR
Pellet is the first sound and complete OWL-DL reasoner with extensive support for reasoning with individuals, user-defined datatypes, and debugging support for ontologies. Expand
QueryPIE: Backward Reasoning for OWL Horst over Very Large Knowledge Bases
TLDR
This work presents an hybrid algorithm to perform efficient backward-chaining reasoning on very large datasets expressed in the OWL Horst (pD*) fragment, and implements a prototype called QueryPIE (Query Parallel Inference Engine), which is the first reported backward- chaining reasoner for OWLHorst that efficiently scales to a billion triples. Expand
Large Scale Fuzzy pD * Reasoning Using MapReduce
TLDR
This is the first work to investigate how MapReduce can help to solve the scalability issue of fuzzy OWL reasoning and implements a prototype system for the evaluation purpose. Expand
Parallel Materialization of the Finite RDFS Closure for Hundreds of Millions of Triples
TLDR
This work is the first to provide RDFS inferencing on such large data sets in such low times and shows that the time to produce inferences scales linearly with the number of processes, evaluating this behavior on up to hundreds of millions of triples. Expand
...
1
2
3
...