Ranked Keyword Query on Semantic Web Data

Transcription

1 2010 Seventh International Conference on Fuzzy Systems and Knowledge Discovery (FSKD 2010) Ranked Keyword Query on Semantic Web Data Huiying Li School of Computer Science and Engineering Southeast University Nanjing, P.R.China Yanbing Wang School of Computer Science and Engineering Southeast University Nanjing, P.R.China Abstract The growth of the Semantic Web has seen a rapid increase in the amount of Semantic Web data. Meanwhile, the demand for access to Semantic Web data without detailed knowledge of RDF query languages is increasing. In this paper, an approach which can return ranked s to keyword query without the help of data schema is proposed. With the proposed approach, Semantic Web data is modeled as RDF sentence graph, and an to a query is modeled as an RDF sentence tree containing all query keywords. We present an algorithm for searching top-k s based on an indexing scheme, and employ IR-style scores in re-ranking s. The experimental results show our approach is feasible and effective. I. INTRODUCTION The amount of available Semantic Web data(or RDF data) has grown rapidly, and the need for ordinary users to query Semantic Web data has also dramatically increased. However, most semantic search systems only support formal queries such as SPARQL[11]. Users of these systems have to know the SPARQL query language and the schema of RDF data to ask suitable queries. Regarding a user querying papers written by Peter Haase and published in ISWC, he needs to construct a SPARQL query such as shown in Fig.1(b) (we use the local name to indicate the URIrefs in correspondence). A snippet of a real world RDF data to be queried, is depicted in Fig. 1(a). Obviously, it is too complicated for users to write even a relatively simple query without detailed knowledge of data schema and query language. The keyword query has become a popular information search method on the Web because the user does not need to know any query language or underlying structure of data. In the database communities, these are some researches on keyword query [2], [3], [5], [7], [10]. However, none of them can be directly applied to keyword query on RDF data because its underlying data model is a graph rather than relational or tree-shaped XML data. Recently, there are some research work dealing with keyword query to semantic search [9], [?], [16], [12]. However, these works mainly focus on translating keyword queries into formal queries (such as SPARQL). Besides, these search algorithms cannot deal with schemaless data. In this paper, we study ranked keyword query on RDF data. In a large RDF graph, many subgraphs may contain query keywords. We restrict s to those connected subgraphs that are minimal, and provide a scoring method that ranks s to help users focus on the most interesting s. The main contributions of this paper are as follows. s 6 paper-45 title A Model Driven Approach for Building OWL DL and OWL Full Ontologies s 1 s iswc 2 ispartof authorlist _:b1 _1 s 5 peter-haase haspart paper-13 SELECT?paper WHERE {?paper <ispartof> "iswc"?paper <authorlist>?blanknode?blanknode?x <peter-haase>} s 3 Can OWL and Logic Programming Live Together Happily title authorlist _1 ian-horrocks _:b2 _2 s 4 boris-motik Fig. 1. a) Example of RDF graph b) Example of SPARQL query 1. We propose a keyword query model on RDF data. We model RDF data as an undirected graph (called RDF sentence graph) and an to a query as an RDF sentence tree containing all query keywords. 2.We present a top-k searching algorithm based on an index structure. We precompute and store some shortest-path information to reduce the querying response time. 3. We devise IR-style scoring functions to re-rank top-k s. II. A KEYWORD QUERY MODEL ON RDF DATA Here we present the RDF sentence graph model of RDF data followed by the tree model that our searching algorithm will focus on. The RDF graph can be considered as a set of RDF triples (or RDF statements). As we known, a blank node simply indicates the existence of something, and is not assigned a global identification so it can only be used locally. Hence, the actual role that blank node play is to connect URIs, literals, and other blank nodes. RDF triples sharing a common blank node provide a joint context of the blank nodes. If such RDF triples are separated, the context is broken /10/$ IEEE 2285

2 s 1 s 2 s3 Query Process searching keyword nodes trees keyword mapping re-ranking keywords top-k s s 5 s 6 s 4 In de x Process RDF data path index sentence RDF Sentence Graph inverted_list Fig. 2. An example of RDF sentence graph Fig. 3. A framework of keyword query on Semantic Web data A notion of the RDF sentence has been proposed in [15] and is well suited for our purpose. Two RDF triples are B-connected if they share common blank nodes. The B- connected relation is defined as transitive. In an RDF graph, an RDF sentence s is a set of RDF triples that satisfy the following conditions: (a) any two RDF triples in s are B- connected; (b) any RDF triple in s is not B-connected to any other RDF triple not in s. So an RDF sentence corresponds to a maximum set of B-connected RDF triples. Intuitively, an RDF sentence is a set of RDF triples which share common blank nodes. Based on the definition of RDF sentence, the RDF data can be convert to an RDF sentence graph taking the RDF sentences as nodes and the relationships between RDF sentences as edges. It is natural to define the relationships between RDF sentences based on common entity. If two RDF sentences share the common subject or one s subject is the same entity as the other s object, they are related. The formal definition of RDF sentence graph is as follows. Definition 1. An RDF sentence graph Gs = (S, E, l) is an undirected graph, where each node represents an RDF sentence. Given s i,s j S and s i s j, (s i,s j ) E iff s i and s j are related. l is a function from S to the power set of all words. For every s i S, l(s i ) is a set of words contained in the local name of its subject, predicate or object. As usual, l is called a labeling function. Figure 2 shows the RDF sentence graph of the RDF graph depicted in Figure 1. Compared to the RDF graph, RDF sentence graph is undirected, and all the text information is encapsulated in the sentence nodes. Generally, a keyword search query consists of m keywords {w 1,..., w m }. The first step is to locate sentence nodes matching query keywords. An RDF sentence node s i is relevant to a query keyword w i if it is in l(s i ). Such RDF sentence node is called keyword node. We formally define an to q = {w 1,..., w m } as follows: Definition 2. Given a query q={w 1,..., w m } and an RDF sentence graph Gs, an to q is an RDF sentence tree T (denoted by a nodes set T S = {s 1,s 2,..., s n } of Gs), which satisfies the following conditions: 1. For every keyword w i q, there exists a node s j T S relevant to it. 2. Each leaf node is relevant to at least one of the query keywords. Intuitively, an to a keyword query is an RDF sentence tree which contains all the keywords and all the leaf nodes are relevant to some keywords. Given a query, there may be many s to it. Usually, user prefers shorter s than longer ones. The length is the number of RDF sentences it contains. Note that to find a shortest tree is a Steiner tree problem in Graph Theory. III. KEYWORD QUERY APPROACH Given a set of query keywords, the approach returns top-k s with each containing all keywords. Enabling such keyword query requires (a) an index process which preprocesses RDF data by building inverted-list index and path index, and (b) a query process which produces the ranked list. Fig.3 shows the architecture. A. Index Process The first step is to load RDF data documents into an RDF sentence graph. Then, different preprocessing steps are performed on the sentence graph which produces appropriate indexes. For example, inverted list helps to map the keyword nodes, and path index contributes to searching s. Our storage layer uses the BerkeleyDB data storage system ( because of its flexibility with respect to accommodating nonrelational storage models and arbitrary data types. When parsing RDF data to RDF sentence graph Gs = (S, E, l), we collect the word set W : W ={w w l(s i ) and s i S} and setup the inverted-list index. For every word w W,there are entries leading to sentence s i where w l(s i ). Intuitively, for every word there is a list pointing to the RDF sentences which contain this word either in the local name of its subject, predicate, object. With the help of inverted-list index, we can locate the keyword nodes easily. To reduce the query response time, we precompute, for each RDF sentence node, the shortest distance from it to every node in the RDF sentence graph. This result is a collection 2286

3 distance, lastnode, node D(s 1 ) 1, s 1, s 2 1, s 1, s 5 1, s 1, s 6 D(s 2 )... 1, s 2, s 1 1, s 2, s 3 1, s 2, s 4 Fig. 4. 2, s 2, s 4 2, s 2, s 3 null 2, s 1, s 5 Example of path index 2, s 1, s 6 of node-node lists. For each node s n, D(s n ) denotes the list of nodes that it can reach, and these nodes are ordered by their shortest distances to s n. Each record in the list has three fields (distance, lastnode, node), where distance is the shortest distance between s n and node; lastnode is the last node (not current) on the shortest path from s n to the node which is useful in reconstructing the tree. In Fig.4, we show some parts of the node-node lists built for the graph in Fig.2 (assuming all edges have weight 1). For example, in the list for s 1, the first record is (1,s 1,s 2 ), which reflects the fact that node s 1 can reach s 2 with distance 1, the lastnode is s 1. This index is defined over the entire RDF sentence graph. It is easy to see that it contains as many as n n records at worst, where n is the number of nodes. So the connectivity of a sentence graph is the most important factor that affects the size of index. To compute the distances between nodes, we concurrently run n copies of Dijkstra s single source shortest path algorithm, one for each of the n nodes in sentence graph. This process is similar to [6], except that we are dealing with an undirected graph instead of an directed graph. For reduce the index time, we divide the sentence graph into connected components and compute the path index in each component. We omit the detailed algorithm here. B. Query Process The query process includes three steps: keyword mapping, searching, re ranking. Keyword mapping maps the keywords to the RDF sentences (called keyword nodes) with the help of inverted-list index. Here we briefly discuss the inverted-list index because it has been used widely. Given a set of keywords, we first need find nodes which are relevant to the keyword. Such nodes can be identified easily through an inverted-list index. Invertedlists have proven very effective for keyword searches in the information retrieval (IR) community. Answer searching extends the keyword nodes to trees with the help of path index.in this paper, we are concerned with finding the top-k s for a query. Because there may be many s for one query, each has to be assigned a relevance score and presented in decreasing order. A factor considered in scoring is length: the smaller the tree, the better the. Intuitively, the shorter shows compact information about the keywords. The computation of minimum Steiner tree is an NP-hard problem. To top-k keyword query, we are interested in not just null the shortest, but also in other s with acceptable length. We also wish to generate s incrementally to avoid generating very long s that the user may never look at. In this part, we consider only one factor ( length) for scoring. The other scoring factor will be discussed later. Based on the inverted-list index and path index we present an algorithm which offers a heuristic solution for incrementally computing s. Given a set of keywords, we first find, for each keyword w i (i =1,..., m), the set of nodes S i (i =1,..., m) relevant to the keyword by using the inverted-list index. Initially, S i starts out as the set of nodes that directly contain w i ; we call this initial set the cluster origin and its member nodes keyword nodes. In each search step, we choose an unvisited node as the next node which can reach one of the initial sets (say S n ), and add it to S n (S n is expanded). This process is continued until we have found a node which belongs to every S i (i =1,..., m). An is found, then it can be reconstructed using the path index. The key problem of this algorithm is in choosing the next node to be visited. It includes two steps: the first step is which S i (i =1,..., m) we should choose next to expand; when such set is found, the second step is to choose the node visited next. We discuss two heuristic strategies used in each step. In the first step, we use the cost balanced strategy which means that the node set to be expanded next is the set with the smallest cardinality. Intuitively, the algorithm attempts to balance the number of accessed nodes. When such set is found, we need to decide which node to visit next. For convenience, we define the distance from a node n to a set of nodes N as the shortest distance from n to any node in N. Weusetheequi distance strategy to decide which node to visit for expanding a set S i. Intuitively, the algorithm expands a set S i by visiting nodes in order of increasing distance from the cluster origin. Formally, the node nextnode will be visited next for set S i because it has the shortest distance (among all nodes not in S i )tos i.since the final purpose of our algorithm is not only to find s but also the first k best s (Here we consider only the length as scoring factor). This strategy helps us find short faster because it visit the node with the shortest distance first. How we know if we have found all top-k s is another problem. We could generate all trees and then sort them in ascending order of length, but this would increase computation costs and leads to a greatly increased time to generate all results. To avoid these overheads, we maintain a small list of generated trees. We keep adding trees to the list as they are generated. The size of the biggest tree is recorded as threshold. Whennumber (denotes the number of s we have found) is larger than k (assume k=10), and the mindistance of next node to be visited is larger than threshold, it means that the size of the new (if it exists) will be larger than k s in the list. Because the size of the new is the length sum of every path in the tree, if one of the path lengths is larger 2287

4 than threshold, the sum is also larger than threshold. Inthis situation, the algorithm is stopped, and the k s can be determined. The other situation is that although we found less than k s but there are also no s can be found, the algorithm is stopped too. The worst-case time of our searching algorithm is O(n 2 ), where n is the number of nodes in maximum connected component. Answer re ranking re-ranks the s.the algorithm proposed before considers only length as a ranking factor but the content is another ranking factor. We collect the text information contained in an and produce a virtual document for this, then assign an IR-style score to it. This score measures the relativity of the content to the given query. Following the most widely used ranking methods in IR [?], we show our content ranking formula below where D denotes the virtual document. Ran(q, D) = weight(w i,d) (1) weight(w i,d)= ntf ndl (2) ntf =1+ln(1+ln(tf)) (3) dl ndl =(1 s)+s (4) avgdl The weight of a keyword (term) in a virtual document is determined by two factors: Term Frequency(tf in Formula 3) and Document Length (dl in Formula 4). Term Frequency denotes the number of occurrences of a term in a virtual document. Intuitively, the more a term occurs, the higher the weight of the term should be. However, the same term may occur many times in a long virtual document, and the importance of a term should not be linearly dependent on the raw tf when tf is rather large. It has been accepted in IR that the raw tf should be dampened. Formula 3 applies the log function twice to normalize the raw tf to get ntf. Document Length denotes the length of a virtual document in bytes. Because longer documents contain more terms and higher term frequencies, longer documents tend to have higher value of Formula 1 for a given query. Formula 4 provides a normalization to reduce the term weights in long documents, where avgdl is the average document length in the set of top-k s and s is a constant and is usually set to 0.2. We do not consider the Document Frequency factor in IR because it is meaningless in our approach. In fact, all the virtual document comes from tree and they contains every query keywords inevitably. In our approach, we find the top-k s using the searching algorithm which considers only the length ranking factor. Then we use the formulas above to re-rank s and present a final ranking list of s. In fact, these formulas do much better when s contain large text information. TABLE I PROPERTIES OF THE DATASET Data set triple# RDF sentence# keyword# data.semanticweb.org 49,646 32,882 8,320 Q 1 Q 2 Q 3 Q 4 Q 5 Q 6 Q 7 Q 8 Q 9 Q 10 TABLE II QUERY EXAMPLES Queries ontology reasoning karlsruhe person rdf data query semantic web search data mining person Peter Haase ISWC www 2008 keynote semantic web tim finin ontology mapping southeast university semantic web search engine IV. EVALUATION In order to evaluate the effectiveness and the efficiency of our proposed approach, we have conducted experiments on a real world dataset. Here we present the results and discuss the factors affecting the performance of our method. A. Experimental Setup Implementation. We implemented our algorithm using Java 1.5, on a PC with a 2.13GHz Intel processor and 2G memory. Datasets. We have conducted experiments on a real world Semantic Web data ( It is an RDF data focused on Semantic Web conference, including the information of publications, authors, organizations and research institutes. It contains about 49,646 triples and 32,882 RDF sentences and 8,320 keywords. Performance Metrics. We evaluate the performance of the method by observing: 1) the query processing time. 2) the Reciprocal Rank. For a given query, the Reciprocal Rank(RR) is 1 divided by the rank at which the first correct is returned or 0 if no correct is returned. Query Examples. Table 3 lists 10 typical queries with query length ranging from 2 to 4. B. Experimental Results Effectiveness Evaluation The precision and recall are usually used to evaluate effectiveness, but they do not suit the effectiveness evaluation in top-k keyword query. To evaluate the effectiveness of our approach, we use the Reciprocal Rank metric. The Reciprocal Rank is 1 divided by the rank at which the first correct is returned or 0 if no correct is returned. For example, if the first correct is ranked at 5, then the Reciprocal Rank is 1/5. Table 4 shows the Reciprocal Rank for every query example. TABLE III RECIPROCAL RANK RESULTS Q 1 Q 2 Q 3 Q 4 Q 5 Q 6 Q 7 Q 8 Q 9 Q 10 RR 1 1 1/ /2 1 1/

5 query time (ms) Q1 Q2 Q3 Q4 Q5 Q6 Q7 Q8 Q9 Q10 Fig. 5. Query performance Efficiency Evaluation We run the algorithm 10 times for each query and Fig. 6 shows the average time it takes to find the top-10 s using our approach. To avoid a query taking too much time, we return whatever we have after 100 seconds. The experiments show that the algorithm is efficient with the support of index. V. CONCLUSION As the amount of information encoded in RDF data increases, so does the need for efficient and effective information query on Semantic Web data. Keyword query enables information discovery without requiring the user to know neither the schema of RDF data nor RDF query languages. We presented an approach that performs ranked keyword query on RDF data. We modeled RDF data as RDF sentence graph, and it takes the RDF sentences as nodes and the relationships between RDF sentences as edges. An to a keyword query is an RDF sentence tree which contains all the keywords, and all its leaf nodes are relevant to some keywords. Based on the keyword query model, we proposed a top-k searching algorithm which employs two search policies (cost-balanced and equi-distance), and employed IR-style scores in re-ranking s. Our experimental results show that our approach is feasible and effective. Currently, in the index process, we partition the large scale data into connected components and compute the path index for each components separately. It can reduce the index time and space to deal with entire data directly, but when a connected component is very large, it causes expensive index time and space. How to partition large scale RDF data into blocks with acceptable size and how to index between blocks is an interesting future work for us. in part by the NSFC under Grant REFERENCES [1] B. Aleman-Meza, F. Hakimpour, I. B. Arpinar, and A. P. Sheth, SwetoDblp Ontology of Computer Science Publications, Web Semantics: Science, Services and Agents on the World Wide Web, vol. 5, pp , 2007 [2] G. Bhalotia, C. Nakhe, A. Hulgeri, S. Chakrabarti, and S. Sudarshan, Keyword searching and browsing in databases using BANKS, Proc. International Conference on Data Engineering (ICDE 02), 2002, pp [3] S. Brin, and L. Page, The Anatomy of a Large-Scale Hypertextual Web Search Engine, Proc. International World Wide Web Conference (WWW 98), 1998, pp [4] J. Broekstra, A. Kampman, F. Harmelen, Sesame: A generic architecture for storing and querying rdf and rdf schema, Proc. International Semantic Web Conference (ISWC 2002), 2002, pp [5] L. Guo, F. Shao, C. Botev, and J. Shanmugasundaram, XRANK: ranked keyword search over XML documents, Proc. International Conference on Management of Data (SIGMOD 03), 2003, pp [6] H. He, H. Wang, J. Yang, and P. S. Yu, BLINKS:Ranked Keyword Searches on Graphs, Proc. International Conference on Management of Data (SIGMOD 07), 2007, pp [7] V. Hristidis, and Y. Papakonstantinou, Discover: Keyword search in relational databases, Proc. International Conference on Very Large Data Bases (VLDB 02), 2002, pp [8] O. Lassila, R. Swick, RDF Model and Syntax Specification. W3C Recommendation. [9] Y. Lei, V. S. Uren, E. Motta, Semsearch: A search engine for the semantic web, Proc. of International Conference on Knowledge Engineering and Knowledge Management (EKAW 06), 2006, pp [10] F. Liu, C. T. Yu, W. Meng, and A. Chowdhury, Effective keyword search in relational databases, Proc. International Conference on Management of Data (SIGMOD 06), 2006, pp [11] J. Perez, M. Arenas and C. Gutierrez, Semantics and complexity of SPARQL, Proc. International Semantic Web Conference (ISWC 06), 2006, pp [12] T. Tran, P. Cimiano, S. Rudolph, R. Studer, Ontology-based interpretation of keywords for semantic search, Proc. International Semantic Web Conference (ISWC 07), 2007, pp [13] G. Tummarello, C. Morbidoni, P. Puliti, F. Piazza, Signing Individual Fragments of an RDF Graph, Proc. International World Wide Web Conference (WWW 05), 2005, pp [14] X. Zhang, H. Li, Y. Qu, Finding Important Vocabulary within Ontology, Proc. Asian Semantic Web Conference (ASWC 06), 2006, pp [15] X. Zhang, G. Cheng, Y. Qu, Ontology Summarization Based on RDF Sentence Graph, Proc. International World Wide Web Conference (WWW 07), 2007, pp [16] Q. Zhou, C. Wang, M. Xiong, and Y. Yu, SPARK: Adapting Keyword Query to Semantic Search, Proc. of International Semantic Web Conference (ISWC 07), 2007, pp ACKNOWLEDGMENT The work is supported in part by the Natural Science Foundation of Jiangsu Province under Grant BK , and 2289