Patent Application
20110258190
The present invention relates generally to the field of information processing, and more particularly relates to techniques for identifying relationships between data objects in an information processing system.
Entity resolution in the information processing field typically refers to determining whether multiple records, documents, web pages or other data objects represent the same real-world entity. The data objects may be from the same source or from different sources. Examples of entity resolution processes include record matching, record linkage or deduplication. The need for entity resolution often arises in information integration applications where data objects representing the same real-world entity are presented in different ways and there is a lack of a unique identifier for the real-world entity. As a more specific example, a telecommunications equipment supplier may be referred to as “Alcatel-Lucent,” “Alcatel Lucent” and “Lucent” in different records, web pages or other data objects even though these data objects all represent the same company.
A number of entity resolution approaches are known. One possible approach is to perform pairwise comparison of all data objects. However, this simple approach is inefficient, in that it requires O(n2) comparisons for a data set of n objects, and is therefore not scalable for use with very large data sets. Other approaches utilize a technique known as “blocking” in order to provide improved efficiency. Blocking eliminates the need for pairwise comparison of all data objects by assigning the data objects to blocks such that data objects from different blocks are not considered as possible matches, i.e., cannot refer to the same entity. Therefore, pairwise comparisons are only necessary for pairs of objects within the same block in order to identify whether or not they represent the same entity.
Examples of conventional blocking techniques include sorted neighborhood, bigram indexing and canopy clustering. Sorted neighborhood is one of the most efficient of the conventional blocking techniques, with a computational complexity of O(n log n). Unfortunately, it fails to capture the pairwise similarities between data objects if two similar strings start with different characters, e.g., “Alcatel-Lucent” and “Lucent-Alcatel.” On the other hand, bigram indexing and canopy clustering capture pairwise similarities better than sorted neighborhood, but they are less efficient because both have computational complexities of O(n2). Thus they do not scale well with large data sets.
Illustrative embodiments of the present invention provide improved entity resolution processes based on a technique referred to herein as spectral neighborhood blocking.
In accordance with one aspect of the invention, a processing device of an information processing system is operative to obtain a plurality of records, documents, web pages or other data objects, and to construct a binary tree using a bipartition procedure in which subsets of the data objects are associated with respective nodes of the tree. Evaluation of a designated modularity for a given one of the nodes of the tree is used as a stopping criterion to prevent further partitioning of that node and to indicate designation of that node as a leaf node of the tree. The designated modularity for the given node may comprise, for example, a Newman-Girvan modularity. The resulting leaf nodes of the tree provide a non-overlapping partitioning of the plurality of data objects. The processing device is further operative to perform a neighborhood search on the tree to identify pairs of the plurality of data objects that match the same entity, and to store an indication of the matching pairs of data objects.
In one or more of the illustrative embodiments, the bipartition procedure may comprise computing a designated singular vector of a matrix C as C=D−1/2B, where B denotes an n×m normalized record-qgram matrix having a corresponding record-record similarity matrix given by A=BBT, where D=diag(B(BT1)), and where diag(•) transforms a vector into a diagonal matrix, and further wherein the singular vector of C corresponds to a designated eigenvector of Laplacian matrix (A), such that the bipartition procedure is performed without requiring computation of the record-record similarity matrix A. The singular vector may more specifically comprise a second maximum singular vector of the matrix C that corresponds to a second smallest eigenvector of the Laplacian matrix
(A). The bipartition procedure may assign the records associated with the given one of the nodes to one of two subsets according to signs of corresponding entries in the singular vector.
The illustrative embodiments provide significant advantages over conventional approaches. For example, as indicated above, the spectral neighborhood blocking in one or more of these embodiments is implemented without requiring direct computation of a record-record similarity matrix. It exhibits an average computational complexity of O(n log n), such that it scales well with large data sets. It also overcomes the above-noted disadvantage of sorted neighborhood blocking in terms of the failure of that approach to capture pairwise similarities between data objects under certain conditions.
These and other features and advantages of the present invention will become more apparent from the accompanying drawings and the following detailed description.
The present invention will be illustrated herein in conjunction with exemplary information processing systems, processing devices and entity resolution techniques. It should be understood, however, that the invention is not limited to use with the particular types of systems, devices and techniques disclosed. For example, aspects of the present invention can be implemented in a wide variety of other information processing system configurations, using processing devices and process steps other than those described in conjunction with the illustrative embodiments.
The user device 102 may comprise at least a portion of a computer or any other type of processing device suitable for communicating over network 104. For example, the user device may comprise a portable or laptop computer, mobile telephone, personal digital assistant (PDA), wireless email device, television set-top box (STB), or other communication device.
The network 104 may comprise a wide area network such as the Internet, a metropolitan area network, a local area network, a cable network, a telephone network, a satellite network, as well as portions or combinations of these or other networks.
In other embodiments, the entity resolution module 110 may be implemented in one or more of the servers 106 or their associated databases 108, or in a separate centralized controller coupled to one or more of these elements. It is also possible to implement the entity resolution module in a distributed manner with portions of the module being arranged in respective ones of the devices 102, 106 or 108 or subsets thereof.
Referring now to
The processor 200 may be implemented as a microprocessor, a microcontroller, an application-specific integrated circuit (ASIC) or other type of processing device, as well as portions or combinations of such devices. The memory 202 may comprise an electronic random access memory (RAM), a read-only memory (ROM), a disk-based memory, or other type of storage device, as well as portions or combinations of such devices. The processor and memory may be used in storage and execution of one or more software programs for entity resolution based on spectral neighborhood blocking, as well as for performing related operations, such as those associated with storage and processing of retrieved records. The modules 210, 214 and 216 may therefore be implemented at least in part using such software programs. The memory 202 may be viewed as an example of what is more generally referred to herein as a computer program product or still more generally as a computer-readable storage medium that has executable program code embodied therein. Other examples of computer-readable storage media may include disks or other types of magnetic or optical media, in any combination.
The processor 200, memory 202 and interface circuitry 204 may comprise well-known conventional circuitry suitably modified to operate in the manner described herein. Also, the various modules shown in
It is to be appreciated that an information processing system and associated user device as disclosed herein may be implemented using components and modules other than those specifically shown in the exemplary arrangements of
The operation of the system 100 in illustrative embodiments will now be described with reference to
In step 300, n records are obtained. These records may be obtained from one or more of the servers 106 via the network 104, from internal records storage 205, or from other sources, in any combination.
In step 302, the tree generation portion of the process begins with a tree having a single node, and all n of the records are associated with that node. The tree is then grown by recursive splitting of nodes using steps 304 through 312.
In step 304, for a given node of the tree, its associated records are partitioned into two separate sets. Assume the single node referred to in step 302 includes a set S of records, where S⊂{1, . . . , n}. This set is partitioned in step 304 into two sets S1 and S2, and a Newman-Girvan modularity Q(S1, S2) is computed. The Newman-Girvan modularity computation will be described in greater detail below.
In step 306, a determination is made as to whether or not the computed Newman-Girvan modularity Q(S1, S2) is greater than zero. If Q(S1, S2)>0, the given node is split into two nodes having respective sets S1 and S2 of records, as indicated in step 308, and the process returns to step 304 to consider splitting additional nodes of the tree. Otherwise, the given node is not split and is instead identified as a final leaf node of the tree, as indicated in step 310. The flow then moves to step 312 to determine if there are more nodes to be considered for splitting. If there are no additional nodes to be considered, the tree is completed as indicated in step 314. Otherwise, the flow returns to step 304 to process additional nodes.
In step 316, a neighborhood search is performed on the completed tree in order to identify record pairs that match the same entity.
An example of the entity resolution process of
An example of a blocking approach that requires direct computation of the matrix A will now be described. In this approach, which is based in part on the normalized cut formulation in J. Shi and J. Malik, “Normalized cuts and image segmentation,” IEEE Transactions on Pattern Analysis and Machine Intelligence, 22(8):888-905, 2000, a set of n records may be partitioned into K clusters of similar records in the following manner. For S1, S2⊂{1, . . . , n}, let w(S1,S2)=ΣiεS
where S1 and S2 give a binary partition of the n records, i.e. S1∩S2 is empty and S1∪S2={1, . . . , n}. The quantity Ncut(S1, S2) measures a normalized similarity between records in S1 and S2 and thus minimization of the quantity defines a meaningful partition. This is performed as follows:
1. Rewrite Ncut(S1, S2) as a normalized quadratic form of an indicator vector assigning records to S1 and S2.
2. Replace the indicators with real values and solve an equivalent generalized eigenvector problem for the normalized graph Laplacian of A defined as follows:
(A)=D−1/2(D−A)D−1/2=I−D−1/2AD−1/2
where D=diag(A1) with 1 being a column vector of 1's. This blocking approach defines a binary partition of the records based on the sign of the entries in the eigenvector that corresponds to the second smallest eigenvalue of (A). We will use the term “second smallest eigenvector” to refer to this eigenvector elsewhere herein. When K>2, the above binary partition is implemented recursively to obtain K partitions.
As indicated previously, a problem with this blocking approach and others which require direct computation of the record-record similarity matrix A is that the complexity of the computation increases as the square of n.
The spectral neighborhood blocking technique in one or more of the illustrative embodiments avoids the need for direct computation of the record-record similarity matrix A, and thus exhibits substantially improved computational efficiency, as will now be described in greater detail.
In the present embodiment, we use a vector space model in which each record is represented by a vector of so-called “qgrams.” A qgram is a length q substring of the blocking attribute value. Note that each record in the
Given the record-qgram relation matrix B1, let B2 be an n×m matrix defined as follows, for 1≦i≦n,1≦j≦m:
B
2(i,j)=log(n/dj)B1(i,j)
where dj=Σk=1nB1(k, j) is the sum of frequencies for the jth qgram over all n records. Note that the matrix B2 is also referred to as a tf-idf weight matrix. See G. Salton et al., “A vector space model for automatic indexing,” Communications of the ACM, 18(11):613-620, 1975. The coefficient log(n/dj) downgrades the weight for the jth qgram if it appears very often in all records.
Now given the tf-idf weight matrix B2 for the records, we define the similarity matrix A for each pair of the records by the cosine similarity, that is, the similarity between the ith and jth records is:
Clearly, the larger A(i, j) is, the closer the two records are. This is just one example of a similarity metric, and other metrics may be used to define similarity between two records in other embodiments.
By defining B from B2 as
B(i,j)=ei−1B2(i,j),
where ei=√{square root over (Σk=1mB22(i,k))} is the Euclidean norm of the ith row of B2, we can rewrite A as:
A=BBT,
where the superscript T denotes matrix transpose. The matrix B is referred to herein as the normalized record-qgram matrix, and it can be computed with substantially less complexity than that required to compute the record-record similarity matrix A.
It should be noted that in alternative embodiments one can use words instead of qgrams for defining the record-record similarity. However, qgrams are beneficial in that qgrams typically capture more local information than words, which is important when words are noisy. Also, the total number of qgrams can be much smaller than that of words for large scale data sets when q is small and thus are more convenient to manipulate.
As described above, blocking based on the normalized cut formulation reduces to computing the second smallest eigenvector of the Laplacian matrix (A). The present embodiment avoids the need to compute A, in the following manner. Given an n×m normalized record-qgram matrix B, let A=BBT be its corresponding record-record similarity matrix and let D=diag(B(BT1)), where diag(•) transforms a vector into a diagonal matrix. Define a matrix C by C=D−1/2B. Then the second smallest eigenvector of
(A) is the second maximum left singular vector of C. This can be seen as follows. Let C=UΛVT be the singular value decomposition of C, where Λ is a diagonal matrix consisting of the singular values. Then we have
(A)=I−UΛ2U. Therefore, in the present embodiment, we only need to compute the second left singular vector of C, and C can be computed quickly given the typical sparsity of B. This is because the complexity for computing the second maximum left singular vector of a sparse matrix is typically proportional to the number of nonzero entries of the matrix depending on the relative distance between the second and third maximum singular values.
In practice, the singular values of the normalized record-qgram matrices typically decay quickly. Thus, bipartitioning based on the above-described similarity matrix A can be performed quickly as follows:
1. Compute the second maximum singular vector of C, and
2. Assign the n records to one of two subsets according to the signs of the corresponding entries in the singular vector.
This procedure is referred to herein as fast-bipartition for simplicity, and is applied in step 304 of the
The Newman-Girvan modularity applied as a stopping criterion in step 306 of the
where Okk=ΣiεS
pairs of records based on record degrees.
Therefore, the Newman-Girvan modularity has the following desirable physical interpretation: Q(S1, S2) measures the strength of within-clustering connectivity compared with random connections conditional on the record degrees. More specifically, the larger Q(S1, S2) is, the stronger the connections are between the records within each of the sets S1 and S2. The Newman-Girvan modularity also has desirable asymptotic properties such as statistical consistency.
It should be noted that the variable L in the Newman-Girvan modularity can be rewritten in terms of B as follows:
which can be computed quickly due to the sparsity of B. Similarly, the variables Okk and Lk in the Newman-Girvan modularity can also be computed quickly. Thus the Newman-Girvan modularity for a bipartition of n records can be computed directly based on B with complexity O(n). Furthermore, as mentioned previously, the fast-bipartition procedure takes time O(n). Then we can derive bipartitioning for nodes in each level with complexity O(n). Therefore, the average time complexity of the spectral neighborhood blocking is O(n log n), which is much faster than certain conventional blocking algorithms such as canopy clustering and bigram indexing.
Returning now to the example of (A) for the record-record similarity matrix A of
To build the first level of the tree, i.e., to bipartition all seven records at the root node, we compute matrix C from B. The signs of the entries in the second left singular vector of C lead to the bipartition (1, 2, 3, 6, 7) and (4, 5). The Newman-Girvan modularity is computed as 0.3, which is positive and thus the tree grows at this node.
Now it is necessary to check each of the two nodes resulting from split of the root node. To bipartition (1, 2, 3, 6, 7), compute C (5×72) based on the submatrix of B which consists of the rows of (1, 2, 3, 6, 7) and its second left singular vector. This gives a bipartition into (1, 2, 3) and (6, 7), and the corresponding Newman-Girvan modularity is computed to be 0.2654, rounded to 0.3 in the figure. As this number is positive, the node is split and the tree grows to level 3. However, a further bipartition of (4, 5) to (4) and (5) is invalid, since the Newman-Girvan modularity is computed to be −0.5, which is negative. The tree is therefore not further split at this node.
Similarly, the third level nodes of the tree, i.e., those associated with respective record sets (1, 2, 3) and (6, 7), are checked. Neither of these nodes can be further bipartitioned because the Newman-Girvan modularities for both of them are negative. So these nodes are not split, and the tree does not grow any further. The final bipartition tree and the complete bipartition process are depicted in
The neighborhood search of step 316 is not illustrated in the
It is a feature of the entity resolution process of
For example, we may regard two leaf nodes as neighbors if they are sufficiently close to each other in the tree, i.e. the path length in terms of the number of edges between them on the tree is small. As a more particular example, path length=4 may be used as the threshold to define the neighbors. For each record i, we examine every other record j in the same leaf or in the neighborhood of i, and determine whether i and j belong to the same block based on a pairwise similarity metric. It is important to point out that the total number of such pairwise examinations is O(n), as the size of a neighborhood is bounded. Therefore, to examine those pairs, one can utilize an even finer similarity metric than the tf-idf metric used in the above-described fast construction of the bipartition tree.
One possible implementation of the neighborhood search applied to the bipartition tree in step 316 is as follows. Let Tb, Tw (both in [0,1]) denote two pairwise-distance thresholds where the subscripts b and w stand for between-clusters and within-clusters, respectively. Then the candidate record pairs are generated by performing the following operations for each record Ri, 1≦i≦n:
1. Check every other record Rj that belongs to the same leaf as Ri, and if the distance is less than Tw, then Ri and Rj belong to the same block.
2. Check each record Rj that belongs to the neighborhood leaves of Ri, and if the distance is less than Tb, then Ri and Rj belong to the same block.
The performance of this particular neighborhood search is robust to the choices of Tb and that the best performance is achieved when Tb is close to 0 and Tw is close to 1, where the extreme case reduces to simply claiming records in the same leaf as neighbors. The intuition is that two records in the same leaf are either very similar or brought together through a third record, which is similar to both records. The latter case is called transitivity, a property preserved by the nature of spectral clustering.
As indicated above, the average time complexity of the spectral neighborhood blocking in the illustrative embodiments is O(n log n), which is much faster than both canopy clustering and bigram indexing, and in addition exhibits improved robustness to tuning parameters relative to these two conventional blocking approaches. Also, spectral neighborhood blocking overcomes the deficiencies of sorted neighborhood blocking, in that it captures the pairwise similarities between data objects if two similar strings start with different characters. Spectral neighborhood blocking also outperforms sorted neighborhood blocking when data have low or medium noise, which is often the case of real-world applications. The embodiments described above can therefore operate on labeled data, in which the real entities are known for records, as well as unlabelled data, for which the real entities are unknown.
It should also be noted that the spectral neighborhood blocking utilized in the
Alternative metrics may be used for determining similarity of records in the spectral neighborhood than the ones used in the illustrative embodiments above, and for ranking candidate pairs without training data. Also, alternative modularities may be used in place of the Newman-Girvan modularity applied in the illustrative embodiments.
As indicated previously, embodiments of the present invention may be implemented at least in part in the form of one or more software programs that are stored in a memory or other computer-readable medium of a processing device of an information processing system. System components such as the modules 210, 212 and 214 may be implemented at least in part using software programs. Of course, numerous alternative arrangements of hardware, software or firmware in any combination may be utilized in implementing these and other system elements in accordance with the invention. For example, embodiments of the present invention may be implemented in one or more field-programmable gate arrays (FPGAs), ASICs, digital signal processors or other types of integrated circuit devices, in any combination. Such integrated circuit devices, as well as portions or combinations thereof, are examples of “circuitry” as the latter term is used herein.
It should again be emphasized that the embodiments described above are for purposes of illustration only, and should not be interpreted as limiting in any way. Other embodiments may use different types and arrangements of system components depending on the needs of the particular entity resolution application. Alternative embodiments may therefore utilize the techniques described herein in other contexts in which it is desirable to implement accurate and efficient entity resolution for sets of records or other data objects. Also, it should also be noted that the particular assumptions made in the context of describing the illustrative embodiments should not be construed as requirements of the invention. The invention can be implemented in other embodiments in which these particular assumptions do not apply. These and numerous other alternative embodiments within the scope of the appended claims will be readily apparent to those skilled in the art.
