JP6190324B2 - SEARCH DEVICE, SEARCH METHOD, AND SEARCH PROGRAM - Google Patents

Description

  The present invention relates to a search device and the like.

  In recent years, as web services such as Flickr (registered trademark) have been developed, image search is becoming popular. In the midst of this, research on image retrieval techniques has been actively conducted. The purpose of the image search is to find an image having the same meaning as the inquiry image.

  Therefore, in image search, how to rank images based on the user's intention is an important issue. The initial image retrieval technique proposed in the 1970s is based on keywords. The keyword-based image search method is still used in many web services. However, there is a problem that there is a semantic gap between text and images.

  In order to overcome this semantic gap, a search method for searching for an image most visually similar to the query image was proposed in the 1990s. In this search method, images stored in a database are ranked based on similarity using low-dimensional feature quantities such as shape and color, and images with higher similarity are used as search results. This search method has an advantage that the feature amount of the image can be automatically extracted as compared with the search method based on the keyword. However, this search technique does not sufficiently reflect the user's intentions with low-dimensional feature values, and there is a gap between the image feature values and the user's intentions, and appropriate search results cannot always be obtained. There is a problem.

  As a technique for solving this gap problem, it has been proposed to use Manifold Ranking for image retrieval. Manifold Ranking is a technique for calculating a ranking of data points based on a cluster (typically called Manifold) composed of data points. Also, a method for solving the above gap problem in image search has been proposed on the premise that data points belonging to the same cluster have the same meaning.

J.He, M.Li, H.Zhang, H.Tong, and C.Zhang, “Manifold-Ranking Based Image Retrieval”, In ACM Multimedia, 2004. D.Zhou, J.Weston, A.Gretton, O.Bousquet, and B.Schoelkopf, “Ranking on Data Manifolds”, In NIPS, 2003.

However, the image search method using Manifold Ranking has a problem of high calculation amount. Theoretically, the ranking score in the Manifold Ranking is defined as the one that minimizes the cost function described later. An optimal solution that minimizes the cost function can be obtained by calculating an inverse matrix of a matrix having a size of n × n, where n is the number of data points. Since the calculation amount for obtaining the inverse matrix of the n × n matrix is O (n ³ ), the calculation amount in the Manifold Ranking is O (n ³ ). Furthermore, the image retrieval method using the Manifold Ranking holds an inverse matrix, and therefore requires an O (n ² ) memory amount. Such a problem applies not only to image search but also to general data search.

  An example of an embodiment disclosed in the present application has been made in view of the above, and an object thereof is to perform data search at high speed and with high accuracy.

An example of an embodiment disclosed in the present application is a matrix to a matrix product including a sparse matrix with respect to a matrix for calculating a score of each node based on an adjacency matrix of an input graph including a plurality of nodes and edges connecting the nodes. Decompose. An example of the embodiment is to select a solution node having a score with respect to the query node obtained from the matrix subjected to matrix decomposition within the number of searches from a plurality of nodes according to the input of the query node and the number of searches. In addition, the control unit divides the input graph into a plurality of clusters, and for each cluster, estimates an upper limit value of the score for all nodes in the cluster, and obtains a query node having a score corresponding to the number of searches from the top for the query node. Is selected from multiple nodes, the upper limit of the score estimated for each cluster is the minimum score corresponding to the elements already included in the set of solution nodes (provided that the set of solution nodes is an empty set) Are excluded from the target cluster from which the solution node is selected .

  According to an example of an embodiment disclosed in the present application, for example, data search can be performed at high speed and with high accuracy.

FIG. 1 is a diagram showing Lemma 1. FIG. 2 is a diagram illustrating Theorem 1. FIG. 3 is a diagram showing Lemma 2. FIG. 4 is a diagram showing Lemma 3. FIG. 5 is a diagram showing the lemma 4. FIG. 6 is a diagram showing Definition 1. FIG. 7 is a diagram showing the lemma 5. FIG. 8 is a diagram showing definition 2. FIG. 9 is a diagram showing the lemma 6. FIG. 10 is a diagram showing the lemma 7. FIG. 11 is a diagram showing Theorem 2. FIG. 12 is a diagram showing Theorem 3. FIG. 13 is a block diagram illustrating an example of a configuration of the search device. FIG. 14 is a block diagram illustrating an example of the configuration of the pre-calculation unit. FIG. 15 is a block diagram illustrating an example of the configuration of the search unit. FIG. 16 is a diagram illustrating an example of a flowchart illustrating the pre-calculation process. FIG. 17 is a diagram illustrating an example of a flowchart illustrating search processing. FIG. 18 is a diagram illustrating an example of an algorithm for optimization processing by rearranging nodes. FIG. 19 is a diagram illustrating an example of a top-k search processing algorithm. FIG. 20 is a diagram illustrating an example of a computer that executes a search program.

  Prior to the description of the embodiments, the definitions of main symbols used in the following description, the mathematical background of the conventional method, and the mathematical background of the embodiment will be described. Thereafter, an embodiment will be described.

[Definition of main symbols]
The main symbols used in the embodiment are shown in the table below. Hereinafter, the same symbols are used in the mathematical background of the conventional method, the mathematical background of the embodiment, and the description of the embodiment.

[Mathematical background of conventional methods]
The mathematical background of the conventional method will be described below. In Manifold Ranking, it is common to represent data using a k-NN graph. The nodes of the graph correspond to data points. If two data points are near k, the two data points are connected by an undirected graph. Ranking using a k-NN graph means that a set of nodes is U = {u ₁ , u ₂ ,..., u _n } ⊂R ^m (R ^m : m-th order real space), and an inquiry node is u _q When ∈U, the nodes included in U are ranked by the score for u _q .

When AεR ^{n × n} (R ^{n × n} : n × n matrix set) is an adjacent matrix in the k-NN graph, the matrix A is a symmetric matrix and the number of edges is O (n). The weight of the edge connecting the two nodes u _i and u _j is calculated as A _ij = exp {−d ² (u _i , u _j ) / 2σ ² }. Here, d (u _i , u _j ) is a distance function of the nodes u _i , u _j , and generally a Eugrid distance is used. Generally, the standard deviation of the function value of the distance function is used for σ. q is a vector magnitude of n × 1, the element q _q corresponding to the query node u _q is 1, the other elements are zero.

In Manifold Ranking, the score of each node is defined as an optimal solution that minimizes the cost function defined by the following equation (1). In addition, || * || ² in the following formula (1) is an L ² norm.

The first term on the right side of the cost function f (x) corresponds to the condition that adjacent nodes in the graph have similar scores, and the second term on the right side has a higher score for nodes closer to the query node u _q. It corresponds to the condition. The optimal ranking score x ^* minimizes the cost function f (x). From the following formula (3) where the derivative of the cost function shown in the following formula (2) is 0, the following formula ( It is obtained as in 4).

In the formula (4), (I-αC- ^{1 / 2} AC ^-1/2 ) ^-1 is an inverse matrix of (I-αC ^-1/2 AC ^-1/2 ). From equation (4), it can be seen that calculation of the inverse matrix is necessary to calculate the score in the Manifold Ranking. However, the calculation of the inverse matrix requires a calculation amount of O (n ³ ) in the case of an n × n matrix. Therefore, the amount of calculation at the time of search becomes a problem.

In addition, this conventional method has a problem that it is necessary to perform the calculations of equations (2) to (4) even for a node having a small score. In addition, this conventional method has a problem that an O (n ² ) storage area is required to hold an inverse matrix. As a result, when searching for large-scale data, a huge amount of calculation and a storage area are required.

[Mathematical background of the embodiment]
Next, the mathematical background of the embodiment will be described. In order to improve the search speed by Manifold Ranking, (i) calculate approximate score using sparse matrix obtained from incomplete Cholesky decomposition, and (ii) prune (exclude) unnecessary score calculation. Therefore, the upper limit of the score is calculated. In the methods (i) and (ii), since the number of non-zero elements in the sparse matrix obtained from the incomplete Cholesky decomposition is O (n), an inverse matrix requiring the calculation cost of O (n ³ ) is obtained. Searches can be made much faster than when using them.

  Note that a sparse matrix is a matrix in which most elements are zero, such as a triangular matrix or a diagonal matrix.

  Hereinafter, a method of approximately calculating the score for the inquiry node will be described. In an embodiment, the score is calculated using incomplete Cholesky decomposition. First, it shows that the definition of Manifold Ranking score can be rewritten using incomplete Cholesky decomposition.

In the embodiment, the nodes are rearranged in order to increase the accuracy of approximation. Let P be a matrix for rearranging nodes. A method for obtaining the matrix P will be described later. A matrix in which the nodes are rearranged is assumed to be A ′. The n × n adjacency matrix A in the k-NN graph is converted into a matrix A ′ using the matrix P as A = PA′P ^T. Note that the matrix ^PT is a transpose of the matrix P.

Similarly, the diagonal matrix C is transformed as C ′ = PCP ^T. Let u ′ _{i be} the i-th node after the nodes are rearranged. The n × n matrix P is an orthogonal matrix. Each row and each column of the matrix P has one non-zero element, and the other elements are zero. P _ij = 1 indicates that the j-th row can be replaced with the i-th row.

By using this matrix P, the calculation formula of the score defined by the above equation (4) is I = PIP ^T and P ^T = P ⁻¹ , so that the following equation (5) Can be rewritten.

Here, since the matrix I, the matrix C ′, and the matrix A ′ are all symmetric matrices, the matrix {I−α (C ′) ^{−1/2 A} ′ (C ′) ^−1/2 } is also symmetric. It is a matrix. Therefore, in the embodiment, the matrix {I−α (C ′) ^{−1/2 A} ′ (C ′) ^−1/2 } is ^subjected to incomplete Cholesky decomposition to obtain an approximate matrix. The incomplete Cholesky factorization is a method for approximating a symmetric matrix into a matrix product of a lower triangular matrix L, a diagonal matrix D, and an upper triangular matrix U (U = L ^T because L is a real symmetric matrix). is there.

By incomplete Cholesky decomposition, {I−α (C ′) ^{−1/2 A} ′ (C ′) ^−1/2 } = LDU + N≈LDU = LDL ^T From this equation, an approximate score can be calculated using forward substitution and backward substitution. Here, L ′ = LD and q ′ = (1-α) Pq. Further, the vector x is a vector based on the approximate score, and x ′ = Px. Then, from Expression (5), Ux ′ = y and L′ y = q ′. Since the matrix L ′ is a lower triangular matrix, an element of the vector y having a size of n × 1 is obtained by using forward substitution for L′ y = q ′ as shown in the following formula (6). Can do.

  Similarly, an element of a vector x ′ having a size of n × 1 can be obtained as shown in the following formula (7) using backward substitution for the matrix Ux ′ = y.

In forward substitution, first, the first element y ₁ is obtained, and the value of the previous element is obtained so that y ₂ is obtained using y ₁ . determine the value of each element to the last element y _n. The backward assignment, first, obtains the last element _x'n, to determine the _x'n-1 using the _x'n obtains the value after the elements, subjected to sequentially substituted into equation (7) By doing so, the value of each element up to the first element x ′ ₁ is obtained.

Determinant Px (= x'), since vector rearranged row vector x, the approximate score x _i nodes u _i, the element of the vector x', determined as in the following formula (8) .

Equation (8) indicates that the vector x ′ corresponds to an approximate score. That is, the element x ′ _j corresponds to the score of the node u ′ _j after the rearrangement.

If an incomplete Cholesky decomposition of the matrix {I−α (C ′) ^{−1/2 A} ′ (C ′) ^−1/2 } is performed, an approximate score can be calculated from the equations (6) to (8). I understand. An auxiliary theorem 1 indicating the calculation amount of the approximate score in the embodiment is shown in FIG. According to Lemma 1, a calculation amount of O (n) is required to calculate an approximate score.

In the embodiment, an approximate score is obtained by calculating {I−α (C ′) ^{−1/2 A} ′ (C ′) ^−1/2 } ≈LDU using incomplete Cholesky decomposition. In the following, a method for rearranging the nodes of the graph in order to improve the accuracy of approximation will be described. In the embodiment, the nodes are rearranged before applying the incomplete Cholesky decomposition. First, theorem 1 in FIG. 2 shows that the problem of improving the accuracy of approximation by rearranging nodes is equivalent to the NP complete problem.

Here, the reason why the incomplete Cholesky decomposition is “incomplete” will be described. Assuming that the matrix W is W = {I−α (C ′) ^{−1/2 A} ′ (C ′) ^−1/2 }, the matrix L (= U ^T ) and D are respectively expressed by the following formula (9): (10)

  Here, it can be seen from equation (9) that if the element in the matrix W is 0, the element in the corresponding matrix L is also 0. This “matrix L has the same sparse pattern as the matrix W” property is the reason for “incomplete”. “Sparse pattern” refers to an element arrangement pattern of a matrix in which most elements are zero, including a triangular matrix, a diagonal matrix, and the like.

  If there is no “matrix L has the same sparse pattern as the matrix W” property, it is impossible to calculate the score value accurately from the equations (9) and (10). Due to the property that “the matrix L has the same sparse pattern as the matrix W”, in the incomplete Cholesky decomposition, the smaller the number of elements whose values are forced to 0, the higher the accuracy of approximation can be expected. I understand.

  From equations (9) and (10), it can be seen that the matrix L and the matrix D are calculated from the elements on the left side. For this reason, it can be seen that as the left side element in the matrix W is sparser, the number of elements whose value is forcibly reduced to 0 decreases, and an improvement in approximation accuracy can be expected. That is, by rearranging the nodes, the element on the left side of the matrix can be made sparse, and the accuracy of approximation can be improved.

  Algorithm 1 that rearranges the nodes uses the property that the data of the k-NN graph forms a cluster, that is, clustering is possible. For example, “H.Shiokawa, Y.Fujiwara, and M.Onizuka,“ Fast Algorithm for Modularity-based Graph Clustering ”, AAAI, 2013.” can be used as a graph clustering method. There may be. The description of Algorithm 1 and the corresponding flowchart will be described later with reference to FIGS. 16 and 18.

  The method of rearranging the nodes has an advantage of pruning unnecessary node scores in addition to the approximation accuracy. As described above, the approximate score can be calculated by using forward substitution and backward substitution. However, it is difficult to calculate the score of only the selected node by the method using only forward substitution and backward substitution. This is because new scores are sequentially calculated by substituting previously calculated scores in forward substitution and backward substitution. The following describes an approach for pruning unnecessary node score calculations.

The inquiry node in after rearranged the node and _u'q, a cluster that contains the node _u'q when the _(C Q = _{C N} If the node _u'q is included in the cluster _{C N) C Q} In the embodiment, pruning is performed using the property of the matrix L shown in the lemma 2 of FIG.

  From the property of the matrix L shown in Lemma 2 of FIG. 3, the property shown in Lemma 3 of FIG. 4 holds for the vector y.

From Lemma 3 in FIG. 4, the non-zero elements in the vector y is found to be limited only to the elements corresponding to the cluster C _Q and cluster C _N. Using this property, the elements in the vector y can be calculated at high speed. Similarly, for this vector x ′ corresponding to the approximate score, the property shown in Lemma 4 of FIG. 5 holds. From Lemma 4 in FIG. 5, if there are elements of the vector x'corresponding to the cluster C _N, it can be seen that calculates a score for nodes selected arbitrarily.

In embodiments, using Lemma 2-4, the vector y, the element is first corresponding to the cluster C _Q and cluster C _N calculated, to calculate the element corresponding to the cluster C _N in the vector x'. By using the element corresponding to the cluster C _N, it is possible to calculate the score of the approximation in clusters arbitrarily selected.

  In the embodiment, in order to perform a high-speed search, a candidate node for a solution is obtained by estimating an upper limit value of the score. A search can be performed at high speed by calculating an approximate score only when it is determined that the upper limit of the score is a candidate for a solution. Hereinafter, a method for estimating the upper limit of the score will be described.

As mentioned above, embodiment, first, the cluster C _Q, to calculate the score of the approximation included in the cluster C _N, the node in the cluster other than clusters C _Q and cluster C _N, score Calculate an estimate of the upper limit of. The estimated value represented by (A) below for node u ′ _i is defined as definition 1 in FIG.

  Note that the two upper limit values defined by definition 1 in FIG. 6 represented by (B) below can be calculated in advance before performing a search. Here is a lemma to describe the properties of the estimates.

7 shows that the estimated value is the upper limit value of the approximate score. In the embodiment, in order to perform a search at high speed, the upper limit value of the score is not estimated for each node according to definition 1, but the upper limit value of the score is estimated for each cluster. The estimated value of the upper limit value of the score represented by the following formula (C) in the cluster C _i that is neither the cluster C _Q nor the cluster C _N is defined as definition 2 in FIG.

The estimated value of the upper limit value of the score in the cluster C _i represented by (C) has the property shown in the auxiliary theorem 6 in FIG. Then, using the auxiliary theorem 6 in FIG. 9, unnecessary nodes in the search are pruned. As a result, the calculation amount of the estimated value of the upper limit value of the score in the search is as shown in the lemma 7 of FIG.

  From the above mathematical considerations, theorem 2 of FIG. 11 and theorem 3 of FIG. 12 hold for the calculation amount and memory amount of the search in the embodiment. Although the embodiment uses a sparse matrix to prune unnecessary score calculations, theorem 2 in FIG. 11 can reduce the amount of calculation even when there is no need to prune unnecessary score calculations. You can see that the search can be speeded up.

  That is, in the embodiment, based on the NP complete problem, while obtaining a search result with higher accuracy than the conventional method, the calculation amount and the memory usage amount are O (n), which is significantly reduced from the conventional method. In addition, the embodiment is parameter-free that does not require the setting of internal parameters in advance, and the user can easily perform a search based on the Manifold Ranking.

[Embodiment]
Based on the above mathematical discussion, embodiments of a search device and the like disclosed in the present application will be described below with reference to the drawings. In the following embodiment, in an image search using an image as a node using Manifold Ranking, the k-NN graph, the inquiry node u _q , and the number k of solution nodes are input, and the k score is the top k node according to the Manifold Ranking. Is output. The following embodiments are merely examples, and do not limit the technology disclosed by the present application.

(Configuration of search device)
FIG. 13 is a block diagram illustrating an example of a configuration of the search device. The search device 100 according to the embodiment is a search device that calculates a score by Manifold Ranking and outputs k nodes as search results in descending order of score. As illustrated in FIG. 13, the search device 100 includes a pre-calculation unit 10 and a search unit 20. The pre-calculation unit 10 takes the graph data G = {V, E} (V is a node set, E is an edge set) as an external input, and outputs a triangular matrix. The search unit 20 uses the inquiry node u _q and the search number k as external inputs, the triangular matrix from the pre-calculation unit 10 as internal input, and outputs k nodes as search results.

(Configuration of pre-calculation unit)
FIG. 14 is a block diagram illustrating an example of the configuration of the pre-calculation unit. The prior calculation unit 10 includes a node rearrangement unit 11 and a matrix calculation unit 12. The node rearrangement unit 11 uses the graph data G = {V, E} as an external input, calculates a node rearrangement matrix P for rearranging the node set V, and is rearranged by the rearrangement matrix P and the rearrangement matrix P. Output node set V ′. The matrix calculation unit 12 uses the graph data G = {V ′, E} in which the nodes are rearranged as an internal input, and the lower triangular matrix L and the diagonal matrix D calculated based on the above equations (9) and (10). The upper triangular matrix U is output. However, it is L = ^{U T.}

(Configuration of search part)
FIG. 15 is a block diagram illustrating an example of the configuration of the search unit. The search unit 20 includes a score calculation unit 21, a score estimation unit 22, and a search result storage unit 23. The score calculation unit 21 uses the triangular matrix as an input from the pre-calculation unit 10 and the score of the node V calculated using the search target node V as the input from the search result storage unit 23. The score estimation unit 22 and the search result storage unit 23 Output to.

The score estimation unit 22 estimates the query node u _q and the search number k as external inputs, receives the score calculated by the score calculation unit 21 as input, and receives the search target node V from the search result storage unit 23 as input. The score of the node is output to the search result storage unit 23.

  The search result storage unit 23 uses the score estimated by the score estimation unit 22 as input, receives the score calculated by the score calculation unit 21 as input, determines a search target node, and determines the determined node as the score calculation unit 21 and It outputs to the score estimation part 22, and outputs a search result outside.

(Pre-calculation processing)
FIG. 16 is a diagram illustrating an example of a flowchart illustrating the pre-calculation process. The pre-calculation process is a process of outputting the rearrangement matrix P of the node V with the graph data G = {V, E} of k-NN as an input.

First, the pre-calculation unit 10 of the search device 100 accepts an input of the adjacency matrix A of the k-NN graph as an input from the outside (step S11). Next, the pre-calculation unit 10 initializes the rearrangement matrix P as P = 0 (step S12). Next, the pre-calculation unit 10 divides the graph G into N−1 clusters by a predetermined clustering method (step S13). Next, the pre-calculation unit 10 creates an _Nth empty cluster CN (step S14).

Next, the pre-calculation unit 10 executes a loop process of steps S15 to S18 for i = 1, 2,..., N−1. In step S16, the pre-calculation unit 10 deletes a node having an edge extending from another cluster to the i-th cluster. Next, in step S17, pre-calculation unit 10, a deleted node in step S16, adds to the N-th cluster _{C N.} When the loop process of steps S15 to S18 for i = 1, 2,..., N−1 is completed, the pre-calculation unit 10 moves the process to step S19.

  Next, the pre-calculation unit 10 initializes the row index k to k = 1 (step S19). Next, the pre-calculation unit 10 executes a loop process of steps S20 to S29 for i = 1, 2,..., N (N is the number of clusters). In step S21, the pre-calculation unit 10 initializes a node set V ′ obtained by rearranging the node set V of the graph data G = {V, E} to an empty set.

Next, the pre-calculation unit 10 executes a loop process of steps S22 to S27 for j = 1, 2,..., N _i (N _i is the number of nodes in the i-th cluster C _i ). In step S23, the pre-calculation unit 10 obtains the node u _{l of} C _i that minimizes the number of edges e (u) by u _l = arg min (e (u) | uεC _i \ V ′). Next, in step S24, the pre-calculation unit 10 sets the kl component P _kl of the rearrangement matrix P to P _kl = 1. However, l is _l corresponding to the node u _l obtained in step SS23.

Next, in step S25, the pre-calculation unit 10 adds the node u ₁ obtained in step S23 to the node set V ′. Next, in step S26, the pre-calculation unit 10 increments the row index k by 1 to k = k + 1.

Precalculation unit 10, j = 1,2, ···, the loop process of steps S22~S27 are finished for _{N i, i = 1,2, ···} , the loop of steps S20~S28 for N When the process ends, the process moves to a step S29. In step S29, the pre-calculation unit 10 outputs a node set V ′ in which the rearrangement matrix P obtained by the loop processing in steps S20 to S28 and the node set V of the graph data G = {V, E} are rearranged.

(Search process)
FIG. 17 is a diagram illustrating an example of a flowchart illustrating search processing. First, the search unit 20 receives an input of an inquiry node u _q (step S31). Next, the search unit 20 initializes the parameter θ and the top-k node set K to θ = 0 and K = φ, respectively (step S32). Next, the search unit 20 adds a dummy node to the top-k node set K (step S33).

Next, the search unit 20, from the query node _{u q,} obtains the node _u'q after the rearrangement (step S34). Next, the search unit 20 executes the loop process of steps S35 to S37 for all u ′ _i εC _Q ∪C _N. At step S36, the search unit 20, based on Lemma 3, to calculate the corresponding element y _'i to node _u'i. When the loop process of steps S35 to S37 for all u ′ _i εC _Q ∪C _N is completed, the search unit 20 moves the process to step S38.

Next, the search unit 20 executes the loop process of steps S38 to S44 for all u ′ _i εC _Q ∪C _N. In step S39, the search unit 20 calculates an element x ′ _i corresponding to the node u ′ _i based on the lemma 4. Next, in step S40, the search unit 20 determines whether or not the element x ′ _i calculated in step S39 is greater than or equal to the parameter θ. The search unit 20 moves the process to step S41 when the element x ′ _i is equal to or larger than the parameter θ, and moves the process to step S43 when the element x ′ _i is less than the parameter θ.

Next, in step S41, the search unit 20 calculates v ′ based on v ′ = arg min (x ′ _k | u ′ _k εK). Next, in step S42, the search unit 20 deletes v ′ from the top-k node set K, and adds u ′ _i to the top-k node set K. Next, in step S43, the search unit 20 updates θ according to a calculation formula θ = min (x ′ _k | x ′ _k εK). When the loop process of steps S38 to S44 for all u ′ _i εC _Q ∪C _N is completed, the search unit 20 moves the process to step S45.

Next, the search unit 20 executes the loop process of steps S45 to S55 for all C _i ≠ C _Q and C _N. In step S46, the search unit 20 calculates an estimated value of the upper limit value of the score represented by (C) described above, which is defined by definition 2 in FIG. Next, in step S47, the search unit 20 determines whether or not the estimated value of the upper limit value of the score represented by (C) described above is greater than or equal to the parameter θ. The search unit 20 moves the process to step S48 when the estimated value of the upper limit value of the score is greater than or equal to the parameter θ, and moves the process to step S53 when the estimated value of the upper limit value of the score is less than the parameter θ.

Next, the search unit 20 executes the loop process of steps S48 to S54 for all u _j εC _i . In step S49, the search unit 20 calculates an element x ′ _j corresponding to the node u ′ _j based on the lemma 4. Next, in step S50, the search unit 20, element _x'j calculated in step S49 is equal to or more parameters theta. Search unit 20, element _x'j is the process goes to step S51 if it is more than parameter theta, elements _x'j is the process moves to step S53 if less than parameter theta.

Next, in step S51, the search unit 20 calculates v ′ based on v ′ = arg min (x ′ _k | u ′ _k εK). Next, in step S <b> 52, the search unit 20 deletes v ′ from the top-k node set K and adds u ′ _i to the top-k node set K. Next, in step S _< b> 53, the search unit 20 updates θ using a calculation formula of θ = min (x ′ _k | x ′ _k εK). Searching unit 20, the loop process of steps S48~S54 for all _u'j ∈ C _i finished, all _{C i} ≠ _C Q, the loop process of steps S45~S55 for _{C N} is completed, step The process proceeds to S56.

Next, the search unit 20 executes the loop process of steps S56 to S58 for all u ′ _i εK. In step S57, the search unit 20 rearranges the nodes u ′ _i using the rearrangement matrix P calculated by the node rearrangement unit 11 of the pre-calculation unit 10. When the loop process of steps S56 to S58 for all u ′ _i εK is completed, the search unit 20 moves the process to step S59. In step S59, the search unit 20 outputs a top-k node set K.

(Optimization processing by rearranging nodes)
FIG. 18 is a diagram illustrating an example of an algorithm for optimization processing by rearranging nodes. Algorithm 1 shown in FIG. 18 corresponds to the flowchart showing the pre-calculation process shown in FIG. Algorithm 1 rearranges the nodes to sparse the left-side element of the matrix and improves the accuracy of approximation. Here, N is the number of clusters, N _i is the number of nodes in the i-th cluster C _i , and e (u) is the number of edges connected to the node u in the cluster C _i .

In Algorithm 1, first, the matrix P is set to a zero matrix (first row). Next, N-1 clusters in the graph are calculated by the graph clustering method (second row). In this clustering method, nodes having edges that extend between clusters are deleted, and the deleted nodes are added to the _Nth cluster CN (lines 3 to 7). As a result, nodes included in the cluster C _N becomes to have an edge across all clusters. That is, nodes included in cluster C _i where i = 1, 2,..., N−1 have only edges in the cluster. Finally, in each cluster, nodes are selected in the order of few edges, and the nodes are rearranged (lines 8 to 17).

(Top-k search process)
FIG. 19 is a diagram illustrating an example of a top-k search processing algorithm. Algorithm 2 shown in FIG. 19 corresponds to the flowchart showing the search process shown in FIG. In Algorithm 2, the parameter θ is the lowest approximate score in the top-k node set K, and K is the top-k node set. In Algorithm 2, first, θ is set to 0 (first line), and a dummy node having an approximate score of 0 is added to the top-k node set K (second to third lines). Next, determine the node _u'q from the query node _{u q} (4 line). In vector y, the cluster C _Q and, only elements corresponding to the nodes belonging to C _N is non-zero elements (Lemma 3), to calculate the non-zero elements in the vector y using forward substitution (5 7th line).

Nodes belonging to the cluster C _Q is expected to be the solution node, also for the cluster score approximation of nodes contained in C _N is necessary to calculate the score of the approximation of the selected node (auxiliary theorem 4), and the cluster _{C Q,} the score of the approximation to nodes belonging to the cluster _{C N} calculated, updates the set of solutions nodes (8-16 line). And the estimated value in each cluster is calculated (18th line).

  If the estimated value is smaller than θ, according to Lemma 6, the approximate scores of all the nodes included in the cluster are smaller than θ. Therefore, an approximate score is not calculated for the nodes included in the cluster. If the estimated value is greater than or equal to θ, the cluster may include a solution node, so an approximate score of the node included in the cluster is calculated (19th to 29th lines). Finally, the node number before sorting the solution nodes using the sorting matrix P is obtained (31st to 33rd rows).

(Variant)
The embodiment performs incomplete Cholesky decomposition on a matrix that calculates a score of each node based on an adjacency matrix of an input graph including a plurality of nodes and edges connecting the nodes. However, the matrix decomposition is not limited to incomplete Cholesky decomposition, and other decomposition methods for decomposing the matrix into matrix products including sparse matrices such as Cholesky decomposition, LDM decomposition, and LU decomposition may be used.

(Effect of embodiment)
The embodiment performs incomplete Cholesky decomposition on a matrix for calculating a score of each node based on an adjacency matrix of an input graph including a plurality of nodes and edges connecting the nodes. In the embodiment, in response to the input of the inquiry node and the number of searches, a solution node whose score for the query node obtained from the matrix subjected to matrix decomposition is within the number of searches from the top is selected and output from a plurality of nodes. .

  In the embodiment, the input graph is divided into a plurality of clusters, and the upper limit value of the score for all the nodes in the cluster is estimated for each cluster. In the embodiment, an element whose score upper limit value estimated for each cluster is already included in the set of solution nodes when selecting a solution node having a score corresponding to the number of searches from the top for a query node from a plurality of nodes. Clusters that are less than the minimum score corresponding to (however, when the set of solution nodes is an empty set, 0) are excluded from target clusters for selecting solution nodes.

  Also, the embodiment divides the input graph into a plurality of clusters, rearranges the nodes in the order in which the number of connected edges is small in each cluster, and calculates a score based on a matrix obtained according to the rearrangement of the nodes. Incomplete Cholesky decomposition is performed on the transformed matrix.

Therefore, the embodiment can reduce the calculation amount to the calculation amount of O (n) as compared with the conventional method that requires the calculation amount of O (n ³ ), so that the search process can be performed at high speed. In addition, since the embodiment outputs the search result based on the score based on the result of performing the incomplete Cholesky decomposition after rearranging the nodes, the problem of the trade-off between the reduction of the calculation amount and the calculation accuracy is overcome, The top k nodes can be output as search results with high accuracy. In addition, since the embodiment can perform the calculation with the memory amount of O (n), compared with the conventional method that requires the memory amount of O (n ² ), it is possible to save the calculation resources. In addition, since the embodiment does not require an internal parameter that needs to be set in advance, the user can easily perform a search based on the Manifold Ranking.

(System configuration of the embodiment)
Each component of the search device 100 illustrated in FIGS. 13 to 15 is functionally conceptual, and does not necessarily need to be physically configured as illustrated. That is, the specific form of distribution and integration of the functions of the search device 100 is not limited to the illustrated one, and all or a part thereof can be functionally or physically in arbitrary units according to various loads or usage conditions. Can be distributed or integrated.

  Each process performed in the search device 100 may be realized in whole or in part by a CPU (Central Processing Unit) and a program that is analyzed and executed by the CPU. Moreover, each process performed in the search device 100 may be realized as hardware based on wired logic.

  In addition, among the processes described in the embodiment, all or a part of the processes described as being automatically performed can be manually performed. Alternatively, all or part of the processing described as being performed manually can be automatically performed by a known method. In addition, the above-described and illustrated processing procedures, control procedures, specific names, and information including various data and parameters can be changed as appropriate unless otherwise specified.

(About the program)
Further, it is possible to create a program in which a process executed by a control device such as the CPU of the search device 100 described in the embodiment is described in a language that can be executed by a computer. For example, a search program in which processing executed by the control device is described in a language that can be executed by a computer can be created. In this case, the same effect as the embodiment can be obtained by the computer executing the search program. Furthermore, the processing similar to the embodiment can be realized by recording the search program on a computer-readable recording medium, and reading and executing the search program recorded on the recording medium. Hereinafter, an example of a computer that executes a program that realizes the same function as that of the search device 100 illustrated in FIGS.

  FIG. 20 is a diagram illustrating a computer that executes a search program. The computer 1000 includes a memory 1010 and a CPU 1020. The computer 1000 also includes 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. These are connected by a bus 1080.

  As illustrated in FIG. 20, the memory 1010 includes a ROM (Read Only Memory) 1011 and a RAM 1012. The ROM 1011 stores a boot program such as 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. The serial port interface 1050 is connected to a mouse 1051 and a keyboard 1052, for example. The video adapter 1060 is connected to the display 1061, for example.

  Here, as illustrated in FIG. 20, the hard disk drive 1031 stores, for example, an OS 1091, an application program 1092, a program module 1093, and program data 1094. That is, the search program is stored in, for example, the hard disk drive 1031 as a program module in which a command to be executed by the computer 1000 is described.

  The various data described in the embodiment is stored as program data, for example, in the memory 1010 or the hard disk drive 1031. The CPU 1020 reads the program module 1093 and the program data 1094 stored in the memory 1010 and the hard disk drive 1031 to the RAM 1012 as necessary. Then, the CPU 1020 executes each procedure of the search program.

  Note that the program module 1093 and the program data 1094 related to the search program are not limited to being stored in the hard disk drive 1031. That is, the program module 1093 and the program data 1094 may be stored in a removable storage medium and read by the CPU 1020 via a disk drive or the like.

  The program module 1093 and the program data 1094 related to the search program may be stored in another computer connected via a network (LAN (Local Area Network), WAN (Wide Area Network), etc.). The program module 1093 and the program data 1094 may be read and executed by the CPU 1020 via the network interface 1070.

  Further, the module division of the search program includes, for example, the pre-calculation unit 10, the node rearrangement unit 11, the matrix calculation unit 12, the search unit 20, the score calculation unit 21, the score estimation unit 22, and the search result storage unit illustrated in FIGS. 23 and other functional units that execute other processing may be performed in units of processing. However, the division and integration of modules are not limited to this, and may be appropriately performed in consideration of processing efficiency and maintainability.

  The above embodiments and modifications thereof are included in the invention disclosed in the claims and equivalents thereof as well as included in the technology disclosed in the present application.

10 Advance calculation part
11 Node rearrangement unit 12 Matrix calculation unit
20 Search part
21 Score calculator
22 Score estimation unit
23 Search Result Storage Unit 100 Search Device
1000 computers
1010 memory
1020 CPU

Claims (4)

A search device having a control unit for executing processing in cooperation with a storage unit,
The controller is
Perform matrix decomposition into a matrix product including a sparse matrix for a matrix for calculating a score of each node based on an adjacency matrix of an input graph including an edge connecting a plurality of nodes and the nodes,
In response to the input of the query node and the number of searches, the score for the query node obtained from the matrix subjected to the matrix decomposition is selected from the plurality of nodes and output the solution nodes within the number of searches from the top .
further,
The controller is
Dividing the input graph into a plurality of clusters;
For each cluster, estimate the upper limit of the score for all nodes in the cluster;
The upper limit value of the score estimated for each cluster is already included in the set of solution nodes when the solution node having the score for the inquiry node corresponding to the number of searches from the top is selected from the plurality of nodes. Retrieval characterized by excluding clusters that are less than the minimum value of the score corresponding to an element (however, when the set of solution nodes is an empty set, 0) from the target cluster for selecting the solution node apparatus. The retrieval apparatus according to claim 1 , wherein the matrix decomposition is incomplete Cholesky decomposition. A search method executed by a search device,
The search device is
Perform matrix decomposition into a matrix product including a sparse matrix for a matrix for calculating a score of each node based on an adjacency matrix of an input graph including an edge connecting a plurality of nodes and the nodes,
In response to the input of the query node and the number of searches, the score for the query node obtained from the matrix subjected to the matrix decomposition is selected from the plurality of nodes and output the solution nodes within the number of searches from the top .
further,
The search device is
Dividing the input graph into a plurality of clusters;
For each cluster, estimate the upper limit of the score for all nodes in the cluster;
The upper limit value of the score estimated for each cluster is already included in the set of solution nodes when the solution node having the score for the inquiry node corresponding to the number of searches from the top is selected from the plurality of nodes. Including a process of excluding clusters that are less than a minimum value of the score corresponding to an element (however, when the set of solution nodes is an empty set, 0) from the target clusters for selecting the solution nodes. Search method. Search program for causing a computer to function as a retrieval device according to claim 1 or 2.

Images