CN114661956A - A Pregel-based Temporal T-SPARQL Query and Reasoning Method - Google Patents

Abstract

The invention discloses a temporal T-SPARQL query and inference method based on Pregel, which is used for performing query processing and optimization on temporal RDF graph data in a graph parallel computing mode. The problem of the study can be formally defined as: given a temporal RDF query graph G and a temporal query graph Q, all matches of the query graph Q in the data graph G are found. And converting the T-SPARQL query into a function executed on a vertex, performing communication on the edge in a message transfer mode, storing an intermediate result set in the vertex attribute, performing message aggregation on the next iteration based on the received message, and continuing matching until the iteration is finished. The proposed T-SPGX algorithm generates a corresponding query plan according to a given T-SPARQL query, the query plan comprises two aspects of predicate label matching and time information filtering, and different time filtering methods are adopted for a single temporal triplet mode and a plurality of temporal triplet mode connection queries. The query efficiency is improved from the aspect of query result optimization, the semantic hierarchy of the temporal RDFS is used for reasoning the temporal RDF data, the implicit result is deduced in the existing explicit query result, and the query result set is expanded. A general and extensible solution is provided for the query method of the massive temporal RDF data.

Description

A Pregel-based Temporal T-SPARQL Query and Reasoning Method

technical field

The invention proposes a general and scalable solution for the query method of massive temporal RDF data. A temporal RDF query method based on Pregel is proposed, which can query, process and optimize temporal RDF graph data through graph parallel computing. The research problem can be formally defined as: given a temporal RDF query graph G and a temporal query graph Q, find all matches of the query graph Q in the data graph G. Convert the T-SPARQL query into a function executed on the vertex, communicate on the edge by means of message passing, store the intermediate result set in the vertex attribute, and the next iteration will aggregate the message based on the received message and continue to match until the end of the iteration. It belongs to the field of distributed knowledge semantic query.

Background technique

Information in reality naturally has temporal attributes. In order to better represent and manage temporal information, many researchers propose to use RDF for temporal data representation and management. With the explosive growth of temporal data and the development of semantic web and knowledge engineering , how to query and manage time data has become an important research topic. However, most previous research works use relational databases to store temporal RDF triples and rewrite temporal queries into T-SQL or SPARQL queries for evaluation. There are a large number of self-join operations and storage space data redundancy problems. Limits performance in large knowledge bases and complex queries. On the other hand, some graph-centric parallel platforms have been proposed and developed, which can effectively support iterative graph computation. These all promote the necessity of storing and querying temporal RDF graph data on a distributed platform.

Any object is constantly changing with the passage of time. Temporal attributes are an important attribute to describe the dynamic changes in the process of resource development. The representation and query of temporal information has always been the focus of various scientific researches. The development of generation and temporal query languages has effectively facilitated the management of temporal data. In order to facilitate the transmission and sharing of temporal data in the network, scholars have carried out temporal extensions to various data models. With the general acceptance and use of RDF as a semantic representation and metadata processing model, temporal RDF modeling has gradually attracted the attention of scholars, and the corresponding temporal extension methods have been widely studied.

Since the RDF model can use the RDF triple or RDF graph notation to describe the data set, and the representation of temporal information also has three ways of time point, time interval and time set, the time dimension is divided into transaction time and valid time , and different scholars add temporal information in different ways when they define temporal RDF models on the basis of classical RDF models. Therefore, the expression form of the temporal RDF model is not unique, and the temporal information carried by the temporal RDF model is not unique. At present, the main researches related to temporal RDF mainly include the following three aspects: research on temporal extension of RDF model, research on temporal RDF query language, and research on temporal RDF indexing scheme.

Due to the graphical nature of RDF data, the SPARQL query problem is essentially a subgraph matching problem. Each of its triples corresponds to a directed edge from the subject to the predicate in the directed graph, and these directed edges connect the RDF data entities together. A SPARQL query is a combination of a set of tuple patterns, and these tuple patterns are interrelated. Therefore, evaluating SPARQL queries in previous relational databases and data parallel systems will result in a large number of self-join operations and data redundancy in storage space. Query inefficiency problem. On the other hand, due to the rise of large real-world graph datasets, some graph-centric parallel platforms have been proposed and developed to efficiently support iterative graph computation. A popular approach to the design and implementation of parallel algorithms for graphs is vertex-centric computation, using edges between vertices to communicate. While vertex-centric programming is certainly not the only approach, this pattern is popular and It has been adopted by many research and open source projects. A method for translating SPARQL, the standard query language of the Semantic Web, into functions that execute on vertices, evaluating SPARQL queries with a graphical representation of RDF data.

Therefore, the present invention uses graph iteration to implement temporal RDF query, by transforming T-SPARQL query into a function that runs on vertices, matching the predicate label and temporal constraint relationship of the triplet, and storing it in the vertex attribute. The intermediate result set in the system expands the query results step by step, and finally realizes the query of temporal RDF in the distributed graph framework.

SUMMARY OF THE INVENTION

Purpose of the invention: Information in reality naturally has temporal attributes. In order to better represent and manage temporal information, many researchers propose to use RDF for temporal data representation and management. With the explosive growth of temporal data and semantic Web and knowledge With the development of engineering, how to query and manage time data has become an important research topic. However, most previous research works use relational databases to store temporal RDF triples and rewrite temporal queries into T-SQL or SPARQL queries for evaluation. There are a large number of self-join operations and storage space data redundancy problems. Limits performance in large knowledge bases and complex queries. On the other hand, some graph-centric parallel platforms have been proposed and developed, which can effectively support iterative graph computation. These all promote the necessity of storing and querying temporal RDF graph data on a distributed platform. Based on this background, the query method for massive temporal RDF data proposed by the present invention proposes a general and scalable solution.

Technical scheme: In order to realize the above-mentioned purpose, a kind of temporal T-SPARQL query and reasoning method based on Pregel of the present invention comprises the following steps: The specific research method is as follows:

(1) The constraint definition of binary relation of time interval is proposed, and the connection calculation of different types of time interval relation is realized.

(2) Perform subgraph matching queries on temporal RDF graph data based on the Pregel interface, convert T-SPARQL queries into functions executed on vertices, communicate on edges by means of message passing, and store intermediate result sets on vertices properties, the next iteration performs message aggregation based on received messages and continues matching until the end of the iteration. The proposed T-SPGX algorithm generates a corresponding query plan according to a given T-SPARQL query. The query plan includes predicate label matching and time information filtering. Group mode join queries take a different approach to time filtering.

(3) Improve query efficiency from query sequence optimization and query result optimization. The order of query statements is evaluated by using the temporal score histogram, and the optimized query order is obtained. Use the semantic level of temporal RDFS to reason about temporal RDF data, infer implicit results in the existing explicit query results, and expand the query result set. The proposed query method is implemented concretely, and the experimental results show that the algorithm has good query efficiency.

Beneficial effects: query processing and optimization of temporal RDF graph data through graph parallel computing. Based on the Pregel interface, the subgraph matching query is performed on the temporal RDF graph data, and the T-SPARQL query is converted into a function executed on the vertex. A general and scalable solution is proposed for the query method of massive temporal RDF data. , and with the help of RDFS semantic layer, the query efficiency is improved from the aspect of query result optimization, the implicit result is reasoned, and the query result set is expanded.

Description of drawings

Figure 1 is a general flow chart of the method of the present invention.

Figure 2 is a time interval binary relation table.

Figure 3 is a structural diagram of the BSP model.

Figure 4 is a schematic diagram of vertex computation and message passing.

Figure 5 is a temporal inference rule.

Detailed ways

The present invention will be further described below with reference to the accompanying drawings.

The overall flow of the present invention is shown in FIG. 1 . The sub-module processes included are shown in Fig. 2, Fig. 3, Fig. 4, and Fig. 5, respectively, and are described in detail below with reference to each figure. The specific implementation steps are as follows, and the overall flow is shown in FIG. 1 .

1 Temporal Interval Binary Relation Calculation

Figure 2 shows the temporal relationship defined by Allen and introduces interval unification, which can be used for comparison of temporal join computations.

2 BSP model

The Pregel model has the characteristics of parallel computing, batch message, and synchronization mechanism, which enables it to perform parallel processing on the graph with the vertex as the center. The Pregel computing framework is based on an overall synchronous parallel computing model, the BSP model, which decomposes the computation into iterations of a series of supersteps, in each superstep, a vertex program performs its local transformations and exchanges information with neighboring vertices. The BSP model requires the system to provide multiple parallel computing units. The model is divided into a Master role and a Worker role. The Master is responsible for the coordination of global information, and the Worker is responsible for computing. The processing process of the BSP model is shown in Figure 3.

3 Pregel interface user-defined functions

The Pregel interface in GraphX is an improved Pregel mode with reference to GAS. The Pregel model with only vertex calculation functions is fine-grained and can support more parallel operations. It mainly includes three functions: vprog, mergeMsg and sendMsg. The function of Vprog is to update the message inside the vertex, the function of mergeMsg is to merge the two messages, and the function of sendMsg is to send its own message to its neighbor nodes.

Its core is three functions, and users can customize the implementation of these function bodies.

1) vprog function:

Common language: vertexProgram (vprog) will run on all vertices when it is initialized for the first time. After that, only the vertices that receive the message will run vertexProgram. Repeat this step until the iteration condition

The user can customize the implementation of the function body. In the first iteration, the function acts on each vertex of the graph, and in subsequent iterations, the function only acts on the vertex that receives the message. The input parameters of the function are the vertex attribute value and the message received by the vertex, and the original attribute value of the vertex is updated through the function body + message implemented by the user. The message received by the vertex should be the result of the sendMsg+mergeMsg function.

2) sendMsg function:

Common terms: the user can customize the implementation of the function body, the function acts on each edge of the graph, the input parameter of the function is the triplet of the edge, and the triplet of the function body + edge implemented by the user (source vertex and its attributes, The target vertex and its attributes, the attributes of the edge between the source vertex and the target vertex) pass the message to the vertex (the user can customize the message type).

3) mergeMsg function:

Common terms: The user can customize the implementation of the function body. The function acts on each vertex of the graph, and passes the message to each vertex according to the sendMsg function. The mergeMsg function mainly merges the two messages passed to the vertex. Assuming that the message type is A, the input parameters of this function are two messages of type A, and the function body implemented by the user + two messages are combined into a message of type A.

4 Temporal T-SPARQL Query Implementation

1) Iterative process

At each iteration, each data vertex explores a subquery; matching vertices send messages carrying their values to the corresponding neighbors. In subsequent iterations, only the vertices that received the message continue to explore. Instead of solving each subquery independently, the subquery is explored starting from the results of the previous subquery. Messages exchanged between vertices carry intermediate results; therefore, the message in the last iteration is the final answer to the query.

2) The program executed on the vertex:

Receive the message sent by the vertex in the previous super step, aggregate the message, update the attribute value of its own vertex, generate a new message, and send the new message and the matching new message to the next vertex

3) Matching of query statements:

When there is only one triple pattern, match the predicate label and match the time information, bind the vertices that match the predicate label and time filter information on the data graph, and send the matching intermediate result table from the source vertex to the destination vertex in the form of message passing. , the destination vertex updates its own attribute value to the result table.

When there are two triples patterns, it is necessary to formulate the order of the triples to be queried, and the connectivity before and after the triples must be maintained, that is, there must be common variables between the two triples before and after.

4) Temporal binary relation processing:

After the query order is formulated, due to the binary relationship between the time intervals, it is necessary to match and filter the time relationship when the two triple patterns are connected, that is, when the message of the previous triple pattern is sent to the destination vertex, the purpose The vertex matches the next query statement, and checks whether the start time and end time of the two edges satisfy the binary relationship of the time interval. If so, the destination vertex passes its own intermediate result set and the newly matched intermediate result to the next vertex. After the vertex receives the two matching tables, the message is aggregated and stored as its own vertex attribute value, that is, the final query result.

5) Message aggregation:

When a vertex receives messages from different source vertices, to aggregate the messages at the vertices, you can refer to the schematic diagram of vertex computation and message passing in Figure 4.

6) Candidate ranges for variables

If the variable in the triplet has been mapped to some vertices, the subsequent occurrence of this variable can only be limited to the binding value between them. If the variables in the triplet have not been mapped to any vertices, then the vertices on the data graph are all candidate vertices.

5 Query order optimization

An analytical cost model is proposed that uses statistics on a graph of time properties, combined with estimates of the time spent in different stages of a distributed execution plan, to estimate the execution time of different plans for a given query. Based on the number of active and matched vertices and edges, our cost model will estimate the runtime of each planned superstep. Graph Statistics We maintain statistics on temporal property graphs to help estimate vertices and edges that match specific query predicates.

6 Temporal relational reasoning

In the rules we use the following shorthand, sp for rdfs:sub Property of, type for rdf:type, property for rdf:Property, sc for rdfs:sub Class of, class for rdfs:Class, dom for rdfs:domain,rdfs :range. By extending the model-theoretic semantics of RDF graphs, the semantics of temporal knowledge graphs are given. Use the semantic level of temporal RDFS to reason about temporal RDF data, infer implicit results in the existing explicit query results, and expand the query result set.

Claims (5)

1. A tense T-SPARQL query and inference method based on Pregel is mainly characterized by comprising the following steps:

(1) and matching the query statement. And performing subgraph matching query on the temporal RDF graph data based on a Pregel interface, and converting the T-SPARQL query into a function executed on a vertex.

(2) And optimizing the query sequence. And evaluating the sequence of the query statements by utilizing the temporal histogram to obtain an optimized query sequence.

(3) Vertex computation and message aggregation. And performing communication on the edge by adopting a message transmission mode, storing the intermediate result set in the vertex attribute, performing message aggregation on the basis of the received message in the next iteration, and continuing matching until the iteration is finished.

(4) And (5) reasoning a query result. And the query efficiency is improved through the optimization of the query result, and the semantic hierarchy of the temporal RDFS is used for reasoning the temporal RDF data.

2. The method for temporal T-SPARQL query and inference based on Pregel of claim 1, wherein step (1) is query statement matching, and the method comprises:

(2-1) matching predicate labels:

and when only one triple mode exists, matching the predicate label and the time information, binding vertexes conforming to the predicate label and the time filtering information on the data graph, sending a matched intermediate result table from a source vertex to a target vertex in a message transmission mode, and updating the attribute value of the target vertex into the result table. When there are two triplet modes, the order of the query triplets needs to be formulated, connectivity needs to be maintained before and after the triplets, that is, there needs to be a common variable between the two triplets before and after the triplets.

(2-2) candidate ranges for variables:

if a variable in a triplet has been mapped to some vertex, then later reappearing of the variable can only be limited to the binding value between them. Vertices on the data graph are candidates if the variables in the triples have not yet been mapped to any vertex.

(2-3) temporal binary relation processing:

after a query sequence is formulated, due to the existence of a binary relation of a time interval, the time relation needs to be matched and filtered when two ternary group modes are connected, namely when a message of a previous ternary group mode is sent to a target vertex, the target vertex matches a next query statement, whether the start time and the end time of the two sides meet the binary relation of the time interval or not is checked, if the start time and the end time meet the binary relation of the time interval, the target vertex transmits an own intermediate result set and a newly matched intermediate result to the next vertex together, and the vertex aggregates the messages after receiving the two matching tables and stores the aggregated messages as own vertex attribute values, namely final query results.

3. The method for temporal T-SPARQL query and inference based on Pregel of claim 1, wherein step (2) is query order optimization, and the implementation method comprises:

an analytical cost model is presented that uses statistics on a graph of temporal attributes in conjunction with estimates on the time spent in different phases of a distributed execution plan to estimate the execution times of different plans for a given query. Based on the number of vertices and edges that are active and matched, our cost model will estimate the runtime of each super step of the plan. Graph statistics we maintain statistics about the temporal attribute graph to help estimate vertices and edges that match a particular query predicate.

4. The method for temporal T-SPARQL query and inference based on Pregel of claim 1, wherein step (3) is vertex computation and message aggregation, and the implementation method comprises:

(4-1) vertex calculation:

the proposed T-SPGX algorithm generates a corresponding query plan according to a given T-SPARQL query, the query plan comprises two aspects of predicate label matching and time information filtering, and different time filtering methods are adopted for a single temporal triplet mode and a plurality of temporal triplet mode connection queries. Receiving the message sent by the vertex in the previous super step, aggregating the messages, updating the attribute value of the vertex, generating a new message, and sending the new message and the matched new message to the next vertex

(4-2) message aggregation:

when a vertex receives messages from different source vertices, the vertex computation and message delivery diagram of fig. 4 may be referenced to aggregate the messages at the vertices.

5. The method for temporal T-SPARQL query and inference based on Pregel of claim 1, wherein step (4) is a query-to-result inference, the method comprises:

the semantic meaning of the time knowledge graph is given by expanding the model theory semantic meaning of the RDF graph. And reasoning the temporal RDF data by utilizing subclasses and sub-attributes in the semantic hierarchy of the temporal RDFS, reasoning implicit results in the existing explicit query results, and expanding a query result set.

Images