Guozheng Rao

Context-Free Path Queries on RDF Graphs

Navigational graph queries are an important class of queries that can extract implicit binary relations over the nodes of input graphs. Most of the navigational query languages used in the RDF community, e.g. property paths in W3C SPARQL 1.1 and nested regular expressions in nSPARQL, are based on the regular expressions. It is known that regular expressions have limited expressivity; for instance, some natural queries, like same generation-queries, are not expressible with regular expressions. To overcome this limitation, in this paper, we present cfSPARQL, an extension of SPARQL query language equipped with context-free grammars. The cfSPARQL language is strictly more expressive than property paths and nested expressions. The additional expressivity can be used for modelling graph similarities, graph summarization and ontology alignment. Despite the increasing expressivity, we show that cfSPARQL still enjoys a low computational complexity and can be evaluated efficiently.

On the statistical analysis of practical SPARQL queries

In this paper, we analyze some basic features of SPARQL queries from practical world in a statistical way. In particular, we focus on three statistic features including the occurrence frequency of triple patterns, fragments, and well-designed patterns and four semantic features including monotonicity, non-monotonicity, weak monotonicity and satisfiability. All the features contribute to characterize SPARQL queries in different dimensions. We hope that this statistical analysis would provide some useful observations for researchers and engineers who are interested in what real-word SPARQL queries look like, so that they could develop some practical heuristics for processing SPARQL queries, as well as build SPARQL query processing engines and benchmarks. In addition, our research facilitates to reduce scope of the problems by avoiding some cases that may not occur in practice.

RORS: Enhanced Rule-Based OWL Reasoning on Spark

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), sameAs rules (7 rules), and schema rules (8 rules) since, as we investigated, those triples corresponding to the first three classes of rules are overwhelming (e.g., over 99% in the LUBM dataset) in our practical world. Secondly, based on the interdependence among those entailment rules in each class, we pick out an optimal rule executable order of each class and then combine them into a new rule execution order of all rules. Finally, we implement the new rule execution order on Spark in a prototype called RORS. The experimental results show that the running time of RORS is improved by about 30% as compared to Kim & Parks algorithm (2015) using the LUBM200 (27.6 million triples).

PROSE: A Plugin-Based Paraconsistent OWL Reasoner

The study of paraconsistent reasoning with ontologies is especially important for the Semantic Web since knowledge is not always perfect within it. Quasi-classical semantics is proven to rationally draw more meaningful conclusions even from an inconsistent ontology with the stronger inference power of paraconsistent reasoning. In our previous work, we have conceived a quasi-classical framework called prose to provide rich paraconsistent reasoning services for OWL ontologies, whose architecture contains three parts: a classical OWL reasoner, a quasi-classical transformer, and OWL API connecting with them. This paper finally implements prose where quasi-classical transformer is bulit as a plugin for paraconsistent reasoning on classical reasoners. Additionally, we select three popular classical OWL reasoners (i.e., Pellet, HermiT, and FaCT++) and two typical kinds of reasoning services (i.e., QC-consistency checking and QC-classification) for users. As we excepted, prose does exactly enable current classical OWL reasoners to tolerate inconsistency in a simple and convenient way. Furthermore, we evaluate the three reasoners in three dimensions (class, property, individual) and, as a result, those results can amend the analysis of the three reasoners on inconsistent ontologies.

Efficient Approximation of Well-Designed SPARQL Queries

Query response time often influences user experience in the real world. However, the time of answering a SPARQL query with its all exact solutions in large scale RDF dataset possibly exceeds users’ tolerable waiting time, especially when it contains the OPT operations since the OPT operation is the least conventional operator in SPARQL. So it becomes essential to make a trade-off between the query response time and the accuracy of their solutions. That is, partial answers can be provided for users to reduce the response query time within their tolerable waiting time. In this paper, based on the depth of the OPT operation occurring in a query, we propose an approach to obtain its all approximate queries with less depth of the OPT operation. Although queries are approximated in this method, it remains the “non-optional” query patterns from users. This paper mainly discusses those queries with well-designed patterns since the OPT operation in a well-designed pattern is really “optional”. We remove “optional” triple patterns with less depth of the OPT operation and then obtain approximate queries with different depths of the OPT operation. Furthermore, we evaluate the approximate query efficiency and solutions precision with the degree of approximation. It shows that users can keep the balance between query efficiency and solutions precision by changing the degree of approximation.

HDStore: An SSD/HDD Hybrid Distributed Storage Scheme for Large-Scale Data

Traditional data storage schemes are primarily based upon Hard Disk Drives (HDD). However, with the appearance of large amount of data on the Web, the read/write performance based on HDD has reached a bottleneck. Thus the emerging of Solid State Drives (SSD) has provided an opportunity for the storage of the Web of data. In this paper, we propose an SSD/HDD hybrid distributed storage scheme, called HDStore, for large-scale data, in which the single fix-sized journal file using the append-only mode is stored on SSD to support efficient read and write, while several segment files focusing on read are stored on HDD. Through a series of operations build, split, move, and merge between the journal and segment files, we constructed HDStore storage scheme based on JS-model. The experimental results show that HDStore obtains an efficient optimization of data read/write, especially the write performance has increased by 15 % compared to the traditional HDD-based scheme.

Software process risk measurement model based on Bayesian network

The growing demand for higher reliability of software poses an unprecedented challenge to the software industry. Software Process control and Improvement is the important part for high quality software development processes. However, software process risk management is not concerned. To integrate efficient process risk management and CMMI is the goal of this paper. A software process risk measurement model based on Bayesian network is proposed to help improve software process risk management. Firstly, the relationship of process areas is analyzed. Then, risk analysis and measurement process is presented. At last, a real software case is then analyzed by this model framework. The results show that process risk management is effective to enhance reliability.

Proactive semantic web service system based on intelligent UDDI agent

Nowadays, there is an increasing focus on service oriented computing and semantic Web. Semantic Web service system based on intelligent UDDI Agent is presented to go beyond traditional passive service, which extends the service-oriented architecture (SOA). The integration of OWLS and WSDL enhances the veracity and efficiency of locating and finding service. The description framework of service context based on OWLS is designed, which helps the intelligent UDDI Agent to implement the ldquopushrdquo of service intelligently. And the intelligent UDDI agent can provide content for the requester or other service actively. Itpsilas easy for a requester to dynamically find and invoke the most appropriate Web service among a series of services with the same function.

A cognitive map-based decision support model for Web resource management

The Internet is a newly born media with versatile potentialities. With the explosion of data on networks, one of the important issues in network applications is how to efficiently manage Web resources (referring to data resources on the Web) to substantially enhance the utility of them so as to provide better service to users. Considering the complexity and inter-correlation of Web resources, the cognitive map is introduced as a powerful tool in this paper. We propose a cognitive map-based decision support model, by which we evaluate the utilization rate of Web resources and analyze the correlation of user accesses. Furthermore, we divide the users of the Website into different user groups based on cognitive maps. Consequently, we extract various information details to support decisions on Web resource management.

PRSPR: An Adaptive Framework for Massive RDF Stream Reasoning.

In this paper, we propose a plugin-based framework for massive RDF stream reasoning to support complicated tasks on RDF stream in an adaptive and flexible way. Within this framework, the problem of RDF stream reasoning can be equivalently reduced to the combination problem of SPARQL querying and rule-based reasoning. Take advantage of the plug-in method, we can apply various off-the-shelf SPARQL query engines and rule-based reasoners in a simple way. Moreover, to efficiently support real-time reasoning on massive RDF stream, we develop a multi-threaded batch processing approach to manage resources and an adaptive reasoning plan for dynamically managing inference rules in the stream reasoning. Finally, our experiments evaluate on dataset built on the benchmark LUBM and DBpedia. The experimental results show that our framework is effective and efficient.