JP6777903B2 - Search device, search method and search program - Google Patents

Description

The present invention relates to a search device, a search method, and a search program.

The problem of finding a specific subgraph, or subgraph, given as a query in a graph structure is called subgraph matching. Conventionally, in subgraph matching, a search algorithm called backtracking has been used for searching (see Non-Patent Documents 1 and 2). In backtracking, the query graph Q and the data graph G are input, and the embedding of all the query graph Q included in the data graph G is reported. At that time, the candidate vertices of the data graph G that can be the allocation destination of the vertices of the query graph Q are extracted, and the allocation destination of the vertices of the query graph Q is selected from the candidate vertices while being selected to search for embedding. Embeddings are listed.

Huahai He, Ambuj K. Singh, “Graphs-at-a-time: Query Language and Access Methods for Graph Databases”, Proceedings of the 2008 ACM SIGMOD International Conference on Management of Data, SIG-MOD '08, 2008, pp .405-418 Jinsoo Lee, Wook-Shin Han, Romans Kasperovics, Jeong-Hoon Lee, “An In-depth Comparison of Subgraph Isomorphism Algorithms in Graph Databases”, Proceedings of the 39th international conference on Very Large Data Bases, 2012, pp.133- 144

However, according to the conventional backtracking, a long processing time is required to comprehensively search even a portion of the data graph G to be searched where there is no embedding. Therefore, for example, it may be difficult to perform interactive work using a query described as subgraph matching for a graph database, which is a database designed for graph data, or to provide a service that depends on the graph database. Further, when subgraph matching is used for a graph, for example, data mining using the number of appearances of a specific subgraph as a feature amount of the graph is performed, it may not be completed in a realistic time.

The present invention has been made in view of the above, and an object of the present invention is to speed up a subgraph matching process for searching a part of a data graph having the same type as a query graph.

In order to solve the above-mentioned problems and achieve the object, the search device according to the present invention is a search target among graphs composed of labeled vertices and edges connecting adjacent vertices. When searching for a part of the data graph that is a graph of data that is similar to the query graph that is the graph of the query used for the search, the top of the query graph and the top of the query graph are based on the search failure that occurs in the process of the search. A pattern extraction unit that extracts a set of combinations with the vertices of the data graph as a failure pattern representing the cause of the search failure, and a search state that matches the failure pattern extracted by the pattern extraction unit are pruned. , A search unit for searching a portion having the same type as the query graph from the data graph.

According to the present invention, it is possible to speed up the subgraph matching process for searching a part of the data graph having the same type as the query graph.

FIG. 1 is a diagram showing a definition regarding subgraph matching. FIG. 2 is a flowchart showing a processing procedure of the recursive function. FIG. 3 is an explanatory diagram for explaining the subgraph matching process. FIG. 4 is an explanatory diagram for explaining the subgraph matching process. FIG. 5 is an explanatory diagram for explaining a processing outline of the search device of the present embodiment. FIG. 6 is an explanatory diagram for explaining a processing outline of the search device of the present embodiment. FIG. 7 is a schematic diagram showing a schematic configuration of the search device of the present embodiment. FIG. 8 is a diagram showing a definition and a theorem regarding the search process by the search device of the present embodiment. FIG. 9 is a diagram showing a theorem regarding the search process by the search device of the present embodiment. FIG. 10 is a diagram showing a theorem regarding a search process by the search device of the present embodiment. FIG. 11 is a diagram showing a theorem regarding the search process by the search device of the present embodiment. FIG. 12 is a flowchart showing the search processing procedure of the present embodiment. FIG. 13 is an explanatory diagram for explaining the search process of another embodiment. FIG. 14 is a diagram illustrating a computer that executes a search program.

Hereinafter, an embodiment of the present invention will be described in detail with reference to the drawings. The present invention is not limited to this embodiment. Further, in the description of the drawings, the same parts are indicated by the same reference numerals.

[Conventional subgraph matching process]
First, the conventional subgraph matching process will be described. In the following description, undirected graph G ₌ the vertex has a label _{(V G, E G, Σ} , l) is the target of processing. Hereinafter, G is referred to as a data graph. Here, V _G represents a set of vertices, a set of E _G ⊆V _G × V _G edge, sigma is a set of labels, l is a function for associating the vertex and labels. Similarly, the query graph Q = (V _Q , _EQ , Σ, l) is the target of processing. It is assumed that the vertices of the query graph are numbered such as u ₁ , u ₂ , ..., U _{| VQ |} .

Further, subgraph matching is defined as a problem of enumerating embedded Ms in parts having the same subgraph type when a data graph G and a query graph Q are given.

Here, subgraph matching will be described with reference to FIG. FIG. 1 is a diagram showing a definition regarding subgraph matching. In the following description, embedding is represented as a set, as shown in Definition 1 of FIG. The sub graph matching, the vertices of the query graph (hereinafter, referred to as query vertex.), The vertex of the data graph (hereinafter, referred to as data apex.) Searches the embedded M∈V _Q × V _G to.

Further, in the process of search, it is necessary to consider the partial embedding shown in the definition 2 of FIG. 1, that is, the embedding in which the data vertices are assigned only to some query vertices. In the present embodiment, there is a case where domain is referred to as implantable complete embedded as a whole V _Q.

Also, embedding meet three constraints shown in equation (1) ~ (3) M : when you can define V _Q → V _{G, Q} are those which are subgraph isomorphism against G.

The mainstream of conventional subgraph matching processing is a search algorithm based on backtracking. As mentioned above, backtracking mainly involves two processes: extraction of candidate vertices and enumeration of embeddings.

First, in the extraction of candidate vertices, the set of data vertex can be the candidate vertex or each query vertex is assigned C [u _i] ⊆V _G are extracted. u _i whether assignable to data vertex v, for example, be determined using the following equation (4) to (6) (see Non-Patent Document 1). That is, if they meet all of the following formulas (4) ~ (6), u it is determined to be assigned to v.

In the above formula (4), first, label matching is confirmed. Therefore, data vertexes included in the C _{[u i]} satisfies a label constraints. Further, the degree is compared by the above formula (5), and the number of adjacent vertices is compared for each label of the adjacent vertex by the above formula (6). In these conditions, if there is no adjacent vertices in the number of more than u _i to v, can not be assigned to adjacent vertices of u _i to the adjacent vertex of v is used. In this way, the combination of unassignable query vertices and data vertices is excluded under the condition that it is easy to confirm, and the subsequent search is speeded up.

Next, the embedding enumeration will be described with reference to FIG. In the embedded enumeration, the recursive function Search is called and executed. FIG. 2 is a flowchart showing a processing procedure of the recursive function. In the flowchart shown in FIG. 2, First, Search (φ) is called. However, φ represents an empty set. The recursive function Search (P) receives the partially embedded P as an argument, and first, it is confirmed whether or not P is completely embedded (step S100). That is, it is confirmed whether or not k = | V _Q | with k = | P |. If P is a complete embedding (step S100, Yes), then P is reported as an embedding (step S180) and the process returns to the caller of the function.

On the other hand, when P is not completely embedded (steps S100 and No), the process proceeds to step S110. In the process of step S110, the query vertex uk _{+ 1} is assigned to the data vertex v. At that time, v so that the label constraint is satisfied by the selected from C [u _i]. At the same time, v must satisfy the edge constraints for the query vertices already contained in P and the data vertices. Specifically, V∈C satisfying edge constraints shown in equation (7) [u _i] is selected.

Next, a partially embedded P ⁺ with the assignment of (uk _{+ 1} , v) added to P is created, and the injective constraint is confirmed for P ⁺ (step S120). If P ⁺ is injective (step S120, Yes), the recursive function Search (P ⁺ ) is recursively called with P ⁺ as an argument (step S140). On the other hand, if P ⁺ is not injective (step S120, No), the recursive function Search (P ⁺ ) is not recursively called and returns to the caller (step S150).

Next, the conventional subgraph matching process will be specifically described with reference to FIGS. 3 and 4. 3 and 4 are explanatory views for explaining the subgraph matching process. In the conventional subgraph matching process, first, a set of candidate vertices is extracted using the above equations (4) to (6). In the example shown in FIG. 3, C [u ₁ ] = {v ₁ }, C [u ₂ ] = {v ₂ , ..., v ₅ }, C [u ₃ ] = {v ₆ , ..., v ₉ }, C [u ₄ ] = {v ₁ , v ₁₀ } is extracted.

In this case, according to the backtracking search tree shown in FIG. 4, since C [u ₁ ] = {v ₁ }, u ₁ is _first assigned to v ₁ . Further, here, for u _{2 and} later, a case of searching in ascending order of vertex numbers will be considered. That is, v ₂ is selected from C [u ₂ ], v ₆ is selected from C [u ₃ ], and v ₁₀ is selected from C [u ₄ ]. In this case, all query vertices are assigned to the data vertices, so {(u ₁ , v ₁ ), (u ₂ , v ₂ ), (u ₃ , v ₆ ), (u ₄ , v ₁₀ )} Reported as an embedding.

In addition, other embeddings are searched. Returning to its assigned selection u _2, assigned to _{u 2} is _{v 3, u 3} is assigned to _{v 7.} In this case, the candidate vertices v ₁ of u ₄ adjacent to v _7, already assigned u _1, to become a violation of injection constraints, can not be assigned to u ₄ to v _1. The adjacent vertex of v _7, since the other there is no candidate vertices of u _4, the search fails.

for the remaining candidate vertices _v 8, _{v 9} of u _3, likewise, can not be assigned to _{u 4} to _{v 1,} the search fails. Further, return to its assigned selection u _2, if u ₂ is assigned to v _4, and even when u ₂ is assigned to v _5, similarly, the search fails. By the above processing, the search has been performed for all the candidate vertices, and the search ends.

In this way, the conventional subgraph matching process is executed based on backtracking in which recursive calls are repeated while changing the allocation destination of query vertices.

[Outline of search device processing]
Next, a processing outline of the search device according to the present embodiment will be described with reference to FIGS. 5 and 6. In the example shown in FIG. 3, the search device of the present embodiment first, in the same manner as the above-mentioned conventional subgraph matching process, first, {(u ₁ , v ₁ ), (u ₂ , v ₂ ), (u ₃ , Report v ₆ ), (u ₄ , v ₁₀ )} as embedding.

Next, the search device assigns u ₂ to v ₃ by backtracking and assigns u ₃ to v ₇ , and when the search fails, records it as a failure pattern. That is, "if u ₁ is assigned to v ₁ and u ₃ is assigned to v ₇ at the same time, the search fails" is extracted and recorded as a failure pattern. Similarly, when u ₃ is assigned to v ₈ or v ₉ and the search fails, "assigning u ₁ to v ₁ and assigning u ₃ to v ₈ (or v ₉ ) are performed at the same time. And, "the search fails" is extracted and recorded as a failure pattern.

Further, when the search device changes the allocation destination of u ₂ to v ₄ , the partial embedding in which u ₃ is assigned to the adjacent vertices v ₇ , v ₈ , and v ₉ all match the recorded failure pattern. .. Therefore, without creating an embedded portion assigned to u ₃ in candidate vertices, it is understood to be a search failure. Similarly, it can be seen that the search fails when the allocation destination of u ₂ is changed to v ₅ .

As described above, according to the search device of the present embodiment, the search space is reduced as compared with the conventional subgraph matching search tree shown in FIG. 4, as in the search tree shown in FIG. That is, conventionally, as shown in FIG. 4, although there is no embedding that assigns u ₂ to any of v ₃ , v ₄ , and v ₅ , u ₃ is assigned to v ₇ , v ₈ , and so on, respectively. v had been searching assigned to the _9. That is, conventionally, for a certain partially embedded P, a search by backtracking is performed even when there is no completely embedded M such as P⊂M. The search device of the present embodiment prunes the search that does not lead to the discovery of such an embedding. Therefore, according to the search device of the present embodiment, high-speed subgraph matching is possible.

Further, as shown in the flowchart of FIG. 6, the process of enumerating the embedding by the search device of the present embodiment includes the processing procedure of the recursive function in the conventional subgraph matching process shown in FIG. 2, and steps S130 and S160 to S170. different. That is, as shown in FIG. 6, in the search device of the present embodiment, the failure pattern is extracted and recorded (steps S160 to S170). Specifically, when no embedding is reported in the recursive call of the recursive function Search (P ⁺ ) (step S160, Yes), the failure pattern is extracted from P and recorded (step S170). If the embedding is reported (step S160, No), the process returns to the caller of the function.

In addition, it is collated with the extracted failure pattern (step S130). Specifically, when the created partially embedded P ⁺ does not match any of the recorded failure patterns (step S130, Yes), the recursive function Search (P ⁺ ) is recursively called (step S140). .. If P ⁺ matches any of the failure patterns (steps S130, No), the process proceeds to step S150. Since the other processes are the same as the conventional subgraph matching process shown in FIG. 2, the description thereof will be omitted.

[Search device configuration]
Next, a schematic configuration of the search device according to the present embodiment will be described with reference to FIG. 7. As shown in FIG. 7, the search device 1 according to the present embodiment is realized by a general-purpose computer such as a workstation or a personal computer, and includes an input unit 11, an output unit 12, a control unit 13, and a storage unit 14. The search device 1 executes a search process described later, and performs a subgraph matching process while pruning a failure pattern.

The input unit 11 is realized by using an input device such as a keyboard or a mouse, and inputs various instruction information to the control unit 13 in response to an input operation by the operator. Further, in the present embodiment, the input unit 11 receives the graph data including the data graph G and the query graph Q, which are the targets of the search process described later, and inputs the graph data to the control unit 13.

The output unit 12 is realized by a display device such as a liquid crystal display, a printing device such as a printer, an information communication device, and the like, and outputs, for example, a subgraph matching result which is a processing result of a search process described later to an operator.

Further, the search device 1 includes a communication control unit (not shown). The communication control unit is realized by a NIC (Network Interface Card) or the like, and controls communication between an external device such as a server via a telecommunication line such as a LAN (Local Area Network) or the Internet and the control unit 13. For example, the above graph data may be received from an external device via the communication control unit. Further, the subgraph matching result may be output to an external device via the communication control unit.

The storage unit 14 is realized by a semiconductor memory element such as a RAM (Random Access Memory) or a flash memory (Flash Memory), or a storage device such as a hard disk or an optical disk. The processing program that operates the search device 1, data used during execution of the processing program, and the like are stored in advance in the storage unit, or are temporarily stored each time the processing is performed. For example, in the search process described later, the extracted failure pattern is recorded. The storage unit 14 may be configured to communicate with the control unit 13 via the communication control unit.

As illustrated in FIG. 3, the control unit 13 executes a processing program stored in a memory by an arithmetic processing unit such as a CPU (Central Processing Unit), thereby performing a vertex extraction unit 13a, a pattern extraction unit 13b, and a search. It functions as a unit 13c. The control unit 13 may be configured in a functional unit different from these functional units as long as the search process described later is realized.

Further, in the present embodiment, the control unit 13 may be realized by a plurality of CPU cores. As a result, it is possible to perform processing corresponding to each branch of backtracking and processing related to the vertices of each data graph in the search processing described later by parallel processing by a plurality of CPUs.

Specifically, the control unit 13 is used for searching from a data graph which is a graph of data to be searched among graphs composed of labeled vertices and edges connecting adjacent vertices. The following search process is executed when searching for a part that matches the query graph, which is the graph of the query to be performed.

That is, the vertex extraction unit 13a selects the vertices of the query graph among the vertices adjacent to the vertices of the data graph that can match the vertices of the query graph based on the combination of the labels of each vertex of the data graph and the adjacent vertices. The vertices of the data graph that can match the adjacent vertices are extracted as candidate vertices corresponding to each vertex of the data graph. Specifically, the vertex extraction unit 13a extracts candidate vertices satisfying the above equations (4) to (6) as in the conventional backtracking process.

Further, the pattern extraction unit 13b extracts a set of combinations of the vertices of the query graph and the vertices of the data graph as a failure pattern representing the cause of the search failure, based on the search failure that occurs in the search process. Specifically, the pattern extraction unit 13b extracts a failure pattern using the extracted candidate vertices as described below.

Further, the search unit 13c prunes the search state that matches the failure pattern extracted by the pattern extraction unit 13b, and searches the data graph for a portion having the same type as the query graph.

Here, FIG. 8 is a diagram showing a definition and a theorem regarding the search process by the search device of the present embodiment. The definitions and theorems shown in FIG. 8 are applied in the search process described below. That is, as shown in Definition 3 of FIG. 8, a failure pattern is defined. Further, as shown in Definition 4 of FIG. 8, pattern matching is defined. Further, as shown in Theorem 1 of FIG. 8, the determination of the failure pattern is defined.

As shown in FIG. 6, the pattern extraction unit 13b extracts a failure pattern from the partial embedding when the search fails (step S170). It is desirable for the pattern extraction unit 13b to extract a more generalized failure pattern in order to match more partial embeddings and perform search pruning more effectively. That is, it is desirable that the number of combinations of query vertices and data vertices | D | included in the failure pattern D is small. Therefore, the pattern extraction unit 13b creates a failure pattern D by extracting a part of the combination of the query vertex and the data vertex from the partially embedded P found to be the search failure. Therefore, the created failure pattern D becomes a subset when the partial embedding of the extraction source is P, and therefore satisfies the following equation (8).

The failure pattern is created based on the cause of the search failure. As shown in FIG. 6, the cause of the search failure is that there is no candidate vertex that satisfies the edge constraint (step S110), and that P ⁺ created by adding a new allocation to P is a failure (step S120). It is roughly divided into two (~ S140).

First, a method of extracting a failure pattern when there is no candidate vertex that satisfies the edge constraint will be described. Process is the object above formula in step S110 in FIG. 6 a set of candidate vertices v satisfying (7) When _C P _{[u i],} the following equation (9) holds.

Here, FIG. 9 is a diagram showing a theorem regarding the search process by the search device of the present embodiment. The absence candidate vertices corresponding to the query vertex u ₁ is represented by C _{P [u i]} such that empty set. Also, if there are no candidate vertices for query vertices to which data vertices have not been assigned, the search will fail. In other words, as shown in Theorem 2 of FIG. 9, equation (10) holds.

_Furthermore, C P _{[u i]} is for the case where an empty set, the theorem 3 shown in FIG. 9 is established.

That is, when there are no more candidate vertices by the edge constraint, C P _{[u i]} exists u _i as the empty set. For that case i, there are _{D i} as a _{D i} ⊆P and Dead _{(D i),} satisfies the equation (8). Therefore, the pattern extracting unit _13b, C P _{[u i]} registers as a failure pattern any _{D i} such that empty set.

Next, a method of extracting a failure pattern when both P ⁺ are failures will be described. Here, FIG. 10 is a diagram showing a theorem regarding the search process by the search device of the present embodiment. When both P ⁺ are unsuccessful, Theorem 4 and Theorem 5 shown in FIG. 10 hold. That is, since the equation (13) of Theorem 4 holds in the case where all P ⁺ are failures, the set of failure patterns shown in the equation (15) can be defined. For the failure pattern in this case, the equation (16) of Theorem 5 holds. Therefore, the pattern extraction unit 13b registers the failure pattern created by using the equation (16).

Next, a method of extracting D ⁺ from P ⁺ will be described in order to obtain a set of failure patterns shown in the equation (15) of Theorem 4. The reasons why P ⁺ fails are that P ⁺ is not injective (step S120), P ⁺ matches one of the failure patterns (step S130), and recursive recursion is called, as shown in FIG. There are three cases where the function fails to search (step S140). Of these, when P ⁺ matches any of the failure patterns, the failure pattern has already been extracted and recorded. If the recursive function called recursively fails in the search, the failure pattern is extracted and recorded in the recursive function. Therefore, the pattern extraction unit 13b newly extracts the failure pattern only when P ⁺ is not injective.

Failure due to the partial embedding P ⁺ not being injective, that is, the assignment of multiple query vertices to the same data vertices, is represented by Theorem 6 and Theorem 7 shown in FIG. That is, the equation (18) of Theorem 6 holds when P ⁺ is not injective. Further, _Di ⁺ of the equation (19) itself is a failure pattern as shown in the equation (20) of Theorem 7.

In this search algorithm, a partial embedding confirmed to be injective is passed to the recursive function Search (step S120). Therefore, the fact that P ⁺ is not injective is due to the fact that the last added _uk and another query vertex are assigned to the same data vertex. Therefore, if P ⁺ is not injective, then | D _k ⁺ | = 2. In this case, the pattern extraction unit 13b sets D _k ⁺ as a failure pattern extracted from P ⁺ .

[Search processing]
Next, the search process of the search device 1 will be described with reference to FIG. FIG. 12 is a flowchart showing the search processing procedure of the present embodiment. The flowchart of FIG. 12 is obtained by adding a process for extracting a failure pattern to the flowchart shown in FIG. However, it is assumed that the set of failure patterns is a global variable defined outside the scope of the function Search and is initialized with an empty set.

In this search process, the pattern extraction unit 13b creates a failure pattern D based on the above theorems 3, 5 and 7, and adds the created D to the failure pattern set. Further, the pattern extraction unit 13b returns the failure pattern extracted from P as the return value of the function Search. However, the pattern extraction unit 13b returns an empty set when an embedding including the argument P is found.

First, similarly to the conventional subgraph matching process shown in FIG. 2, the search unit 13c confirms whether or not P is completely embedded (step S100). In the case of complete embedding (step S100, Yes), the search unit 13c reports P as embedding (step S180). Further, since P is not a failure, the search unit 13c sets the failure pattern D extracted from P as an empty set (step S161).

If it is not completely embedded (step S100, No), the search unit 13c confirms whether P is a failure based on Theorem 2 shown in FIG. 9 (step S163). In the case of failure (step S163, Yes), the pattern extraction unit 13b extracts a failure pattern based on Theorem 3 shown in FIG. 9 (step S164). If it is not a failure (step S163, No), the search unit 13c proceeds with processing for P ⁺ in which a new allocation is added to P.

That is, the search unit 13c first initializes the set of failure patterns D ⁺ extracted from each of P ⁺ with an empty set (step S165). Then, the search section 13c, the apex meeting the edge constraints _{v∈C P [u k + 1]} , it executes the loop (step S110). That is, the search unit 13c creates P ⁺ (step S121) and confirms whether or not it is injective (step S122). Here, since P is injective, it can be confirmed that P ⁺ is not injective by whether or not v ∈ val (P).

When it is not injective (step S122, Yes), the pattern extraction unit 13b adds the failure pattern to the set of failure patterns based on Theorem 7 shown in FIG. 11 (step S131). In the case of injective function (step S122, No), the search unit 13c confirms whether or not P ⁺ matches the failure pattern recorded in the set of failure patterns (step S132).

If a matching failure pattern D ⁺ exists (step S132, Yes), since this D ⁺ is a failure pattern extracted from P, the pattern extraction unit 13b adds this D ⁺ to the set of failure patterns. (Step S133). If there is no matching failure pattern (step S132, No), the search unit 13c recursively calls Search (P ⁺ ) and substitutes the return value into D ⁺ (step S141). Further, the search unit 13c adds the return value D ⁺ to the set of failure patterns (step S142).

The above process, if executed for all the _{v∈C P [u k + 1]} , the search unit 13c confirms whether or not there are those successfully in the P ^+. Since the function Search returns an empty set when the search is successful, the empty set is added in the process of step S142 if there is a successful one. Therefore, the search unit 13c confirms whether or not the set of failure patterns includes an empty set (step S166).

When the set of failure patterns includes an empty set (step S166, Yes), it means that there is a complete embedding including P, so the search unit 13c sets the failure pattern D as an empty set (step S167). .. If the set of failure patterns does not include the empty set (steps S166, No), P is a search failure, so the pattern extraction unit 13b D extracts the failure patterns extracted based on Theorem 5 shown in FIG. Substitute in (step S168).

After the above processing, when D is not an empty set, that is, when P is a failure (step S169, Yes), the pattern extraction unit 13b adds D to the set of failure patterns (step S170). As a result, or when D is an empty set (step S169, No), the function Search returns D and returns to the caller.

As described above, the search device 1 of the present embodiment is a graph of data to be searched among graphs composed of labeled vertices and edges connecting adjacent vertices. From the graph, search for a part that is similar to the query graph, which is the graph of the query used for the search. At that time, the pattern extraction unit 13b extracts a set of combinations of the vertices of the query graph and the vertices of the data graph as a failure pattern representing the cause of the search failure, based on the search failure that occurs in the search process. To do. Further, the search unit 13c prunes the search state that matches the failure pattern extracted by the pattern extraction unit 13b, and searches the data graph for a portion having the same type as the query graph.

As a result, it is possible to speed up the subgraph matching process for searching the data graph including the query graph. Therefore, for example, it is possible to easily provide an interactive work using a query described as subgraph matching for a graph database, which is a database designed for graph data, and a service that depends on the graph database. Further, when subgraph matching is used for a graph, for example, data mining using the number of appearances of a specific subgraph as a feature amount of the graph is performed, it can be completed in a realistic time.

It can also be applied when a label is attached to an edge. That is, the search device 1 is a query used for a search from a data graph which is a graph of data to be searched among graphs composed of vertices and edges with labels connecting adjacent vertices. You may search for a part having the same type as the query graph which is the graph of. In this case, the pattern extraction unit 13b extracts a set of combinations of the vertices of the query graph and the vertices of the data graph as a failure pattern representing the cause of the search failure, based on the search failure that occurs in the search process. To do. As a result, the range to which the search process can be applied is expanded.

[Other Embodiments]
In the above embodiment, the search device 1 searches for a failure pattern that matches the partial embedding from the set of failure patterns (step S132 in FIG. 12), but is not limited to this. FIG. 13 is an explanatory diagram for explaining the search process of another embodiment. The work of searching for an element satisfying a specific condition from a set requires a processing time proportional to the number of elements in the method of confirming each element, and the processing time increases. In addition, since the number of failure patterns added to the set can be enormous, there is a possibility that all the information cannot be recorded in the storage device.

Therefore, as shown in FIG. 13, the failure pattern may be held by the hash table. In this case, the search device 1 allocates added to the last portion embedded P and _{(u k, P [u k} ]), it is held in the storage unit 14 in association with the failure pattern extracted from P.

As a result, the failure patterns confirmed in the process of step S132 in FIG. 12 become one, so that the process time is shortened. Further, in the process of step S170, the value of the hash table is overwritten and the old value is not retained, so that the number of failed patterns recorded is reduced. The maximum number of combinations of query vertices and data vertices that can exist is | V _Q | | V _G |. Since the number of failed patterns to be retained is less than this, it is overwhelmingly smaller than the case where all of the extracted failure patterns are retained. Therefore, it is possible to execute the search process even if a limited storage device is used.

[program]
It is also possible to create a program in which the processing executed by the search device 1 according to the above embodiment is described in a language that can be executed by a computer. As one embodiment, the search device 1 can be implemented by installing a search program that executes the above search process as package software or online software on a desired computer. For example, by causing the information processing device to execute the above search program, the information processing device can function as the search device 1. The information processing device referred to here includes a desktop type or notebook type personal computer. In addition, the information processing device includes smartphones, mobile communication terminals such as mobile phones and PHS (Personal Handyphone System), and slate terminals such as PDAs (Personal Digital Assistants). Further, the terminal device used by the user may be used as a client, and the terminal device may be implemented as a server device that provides the service related to the search process to the client. For example, the search device 1 is implemented as a server device that provides a search processing service that inputs graph data and outputs a subgraph matching result. In this case, the search device 1 may be implemented as a Web server, or may be implemented as a cloud that provides the service related to the search process by outsourcing. An example of a computer that executes a search program that realizes the same functions as the search device 1 will be described below.

FIG. 14 is a diagram showing an example of a computer that executes a search program. The computer 1000 has, for example, a memory 1010, a CPU 1020, a hard disk drive interface 1030, a disk drive interface 1040, a serial port interface 1050, a video adapter 1060, and a network interface 1070. Each of these parts is connected by a bus 1080.

The memory 1010 includes a ROM (Read Only Memory) 1011 and a RAM 1012. The ROM 1011 stores, for example, a boot program such as a BIOS (Basic Input Output System). The hard disk drive interface 1030 is connected to the hard disk drive 1031. The disk drive interface 1040 is connected to the disk drive 1041. A removable storage medium such as a magnetic disk or an optical disk is inserted into the disk drive 1041. For example, a mouse 1051 and a keyboard 1052 are connected to the serial port interface 1050. For example, a display 1061 is connected to the video adapter 1060.

Here, the hard disk drive 1031 stores, for example, the OS 1091, the application program 1092, the program module 1093, and the program data 1094. Each table described in the above embodiment is stored in, for example, the hard disk drive 1031 or the memory 1010.

Further, the search program is stored in the hard disk drive 1031 as, for example, a program module 1093 in which a command executed by the computer 1000 is described. Specifically, the program module 1093 in which each process executed by the search device 1 described in the above embodiment is described is stored in the hard disk drive 1031.

Further, the data used for information processing by the search program is stored as program data 1094 in, for example, the hard disk drive 1031. Then, the CPU 1020 reads the program module 1093 and the program data 1094 stored in the hard disk drive 1031 into the RAM 1012 as needed, and executes each of the above-described procedures.

The program module 1093 and program data 1094 related to the search program are not limited to the case where they are stored in the hard disk drive 1031. For example, they are stored in a removable storage medium and read by the CPU 1020 via the disk drive 1041 or the like. May be done. Alternatively, the program module 1093 and the program data 1094 related to the search program are stored in another computer connected via a network such as a LAN or WAN (Wide Area Network), and read by the CPU 1020 via the network interface 1070. You may.

Although the embodiment to which the invention made by the present inventor is applied has been described above, the present invention is not limited by the description and the drawings which form a part of the disclosure of the present invention according to the present embodiment. That is, all other embodiments, examples, operational techniques, and the like made by those skilled in the art based on the present embodiment are included in the scope of the present invention.

1 Search device 11 Input unit 12 Output unit 13 Control unit 13a Vertex extraction unit 13b Pattern extraction unit 13c Search unit 14 Storage unit

Claims (6)

Among the graphs composed of labeled vertices and edges connecting adjacent vertices, from the data graph which is the graph of the data to be searched to the query graph which is the graph of the query used for the search. When searching for the same type of part, a set of combinations of query graph vertices and data graph vertices is extracted as a failure pattern representing the cause of the search failure based on the search failure that occurs in the search process. Pattern extraction section and
A search unit that prunes the search state that matches the failure pattern extracted by the pattern extraction unit and searches the data graph for a portion having the same type as the query graph.
A search device characterized by comprising. Based on the combination of labels of each vertex of the data graph and adjacent vertices, among the vertices adjacent to the vertices of the data graph that can match the vertices of the query graph, the vertices adjacent to the vertices of the query graph A vertex extraction unit that extracts matching vertices of the data graph as candidate vertices corresponding to each vertex of the data graph is further provided.
The search device according to claim 1, wherein the pattern extraction unit extracts the failure pattern using the extracted candidate vertices. Among the graphs composed of vertices and edges with labels connecting adjacent vertices, from the data graph which is the graph of the data to be searched to the query graph which is the graph of the query used for the search. When searching for the same type of part, a set of combinations of query graph vertices and data graph vertices is extracted as a failure pattern representing the cause of the search failure based on the search failure that occurs in the search process. Pattern extraction section and
A search unit that prunes the search state that matches the failure pattern extracted by the pattern extraction unit and searches the data graph for a portion having the same type as the query graph.
A search device characterized by comprising. The pattern extraction unit records the failure pattern as a hash table in the storage unit, and records the failure pattern in the storage unit.
Claims 1 to 1, wherein the search unit prunes a search state that matches the failure pattern with reference to the storage unit, and searches the data graph for a portion having the same type as the query graph. The search device according to any one of 3. A search method executed by a search device,
Among the graphs composed of labeled vertices and edges connecting adjacent vertices, from the data graph which is the graph of the data to be searched to the query graph which is the graph of the query used for the search. When searching for the same type of part, a set of combinations of query graph vertices and data graph vertices is extracted as a failure pattern representing the cause of the search failure based on the search failure that occurs in the search process. Pattern extraction process and
A search step of pruning a search state that matches the failure pattern extracted in the pattern extraction step and searching for a portion having the same type as the query graph from the data graph.
A search method characterized by including. Among the graphs composed of labeled vertices and edges connecting adjacent vertices, from the data graph which is the graph of the data to be searched to the query graph which is the graph of the query used for the search. When searching for the same type of part, a set of combinations of query graph vertices and data graph vertices is extracted as a failure pattern representing the cause of the search failure based on the search failure that occurs in the search process. Pattern extraction steps to be performed and
A search step of pruning a search state that matches the failure pattern extracted in the pattern extraction step and searching for a portion having the same type as the query graph from the data graph.
A search program characterized by having a computer execute.

Images