Numeric embeddings for entity-matching

Pairwise entity matching systems and methods are disclosed herein. A deep learning model may be used to match entities from separate data tables. Entities may be preprocessed to fuse textual and numeric data early in the neural network architecture. Numeric data may be represented as a vector of a geometrically progressing function. By fusing textual and numeric data, including dates, early in the neural network architecture the neural network may better learn the relationships between the numeric and textual data. Once preprocessed, the paired entities may be scored and matched using a neural network.

TECHNICAL FIELD

Embodiments generally relate to matching multi-modal entities from separate data tables. More specifically, embodiments relate to matching paired entities using a deep learning model that fuses textual and numeric data early in the neural network architecture to automate the matching process.

Typically, determining whether two entities (e.g., rows or columns in a data table) constitute a match requires a person to view and analyze the two entities to make the determination. Often, table data contains a mixture of structured and unstructured data. Structured data is data which has a clear type; for example, a Date field will often have structured data in the form of a date. Unstructured data is data which does not have a clear type or formatting convention. Different users or automated systems may input unstructured data in various formats. For example, a Reference Number field may not have a structured type, especially if the reference number contains leading zeroes. Some users who are entering in data may lead off the leading zeroes while other users may not. This variance in the structure of data may make it difficult for an automated processes to match entities. Consequently, two entities that constitute a match and contain differently formatted data or contain other inconsistencies may cause the entities to be incorrectly classified by typical machine learning algorithms, such as natural language processing models. Further, these models and other automated systems often fail to match numeric data consistently and properly and may make errors when comparing numbers that are textually similar but are orders of magnitude different. For example, a natural language processing model may make an incorrect determination that numbers that vary by orders of magnitude constitute a match due to their textual similarity based on a similar pattern of digits. Furthermore, these and other similar models may fail to correctly match dates that are represented by text. As such, matching paired entities is often done manually which is typically a labor-intensive and time-consuming endeavor.

Accordingly, a need exists for a machine learning method that can determine if paired entities are a match to automate the matching process. Additionally, the method should be able to handle various structured and unstructured data, including numeric and date data types.

SUMMARY

Disclosed embodiments address the above-mentioned problems by providing a method for preprocessing paired entities to fuse numeric and textual data types early in the neural network architecture. A first embodiment is directed to one or more non-transitory computer-readable media storing computer-executable instructions that, when executed by a processor, perform a method of matching data table entities, the method comprising ingesting a set of data comprising a plurality of entities, wherein each entity of the plurality of entities comprises textual data and numeric data, pairing entities from the plurality of entities to form an entity pair, for the textual data in each entity of the entity pair: tokenizing the textual data into a set of textual tokens, and contextualizing each textual token in the set of textual tokens by passing each textual token through at least one neural network, for the numeric data in each entity in the entity pair: converting each numeric value in the numeric data to an integer, and mapping each integer to a vector, concatenating the textual data with the numeric data to form a sequence for each entity in the entity pair, and analyzing the sequences using a deep learning model to classify the entity pair.

A second embodiment is directed to a method of matching data table entities, the method comprising ingesting a set of data comprising a plurality of entities, wherein each entity in the plurality of entities comprises textual data and numeric data, pairing entities form the set of data to form an entity pair, contextualizing, for each entity of the entity pair, the textual data using at least one neural network, mapping, for each entity in the entity pair, each numeric value of the numeric data to a vector, concatenating, for each entity of the entity pair, the textual data with the numeric data to form a sequence, and analyzing the sequences using a deep learning model to classify the entity pair.

A third embodiment is directed to a system for matching data table entities, the system comprising a data store storing a plurality of entities, and one or more non-transitory computer-readable media storing computer-executable instructions that, when executed by a processor, perform a method of matching data table entities, the method comprising pairing entities from the plurality of entities, wherein each entity comprises textual data and numeric data, for the textual data in each entity of the paired entities: tokenizing the textual data into a set of textual tokens, and contextualizing the textual data using at least one neural network, for the numeric data in each entity of the paired entities: converting each numeric value in the numeric data to an integer, and mapping each integer to a vector of a geometrically progressing frequency, concatenating the textual data with the numeric data to form a sequence for each entity of the paired entities, and analyzing the sequence using a deep learning model.

DETAILED DESCRIPTION

In some embodiments, a machine learning method for determining if paired entities constitute a match by preprocessing entity data to fuse numeric and textual data early in a neural network architecture is provided. Paired entities are fed into a scoring function to determine whether the pair constitutes a match. The scoring function is determined and optimized via machine learning methods. A neural network may be trained on historical data to learn when entities from data tables match. In some embodiments, an entity comprises a row or a column in a data table. The preprocessed entity data may be sent to a decomposable attention model and thereafter fed into the scoring function to determine if the paired entities are a match. In some embodiments, the pairs may be categorized as Match, No Match, or Partial Match. Numeric inputs, including dates, may be mapped to integers and encoded as vectors of geometrically progressing frequencies during the preprocessing phase. Dates may be represented as a number of days since a reference day (e.g., Jan. 1, 2000). By fusing the numeric and textual information early in the neural network architecture, the neural network may learn better relationships from the various data modalities than by analyzing all data types as textual data. Further, improvements in the preprocessing state allows for the scoring function to be better trained to determine if the paired entities constitute a match.

The subject matter of the present disclosure is described in detail below to meet statutory requirements; however, the description itself is not intended to limit the scope of claims. Rather, the claimed subject matter might be embodied in other ways to include different steps or combinations of steps similar to the ones described in this document, in conjunction with other present or future technologies. Minor variations from the description below will be understood by one skilled in the art and are intended to be captured within the scope of the present claims. Terms should not be interpreted as implying any particular ordering of various steps described unless the order of individual steps is explicitly described.

The following detailed description of embodiments references the accompanying drawings that illustrate specific embodiments in which the present teachings can be practiced. The described embodiments are intended to illustrate aspects of the disclosed invention in sufficient detail to enable those skilled in the art to practice the invention. Other embodiments can be utilized, and changes can be made without departing from the claimed scope of the invention. The following detailed description is, therefore, not to be taken in a limiting sense. The scope of embodiments is defined only by the appended claims, along with the full scope of equivalents to which such claims are entitled.

FIG.1depicts two data tables from which entities may be paired. The data tables may represent financial information, such as incoming payments and outgoing invoices. Other use cases may include, but are not limited to, matching product catalogs, deduplicating a database, inter-company reconciliation, or returnable packaging management. Broadly, the matching of entities from any data table comprising multiple data types may be compared and matched using embodiments described herein. As illustrated, incoming payments table102comprises a plurality of incoming entities104a,104b, and104c, where each incoming entity104a-cis a row in incoming payments table102. In some embodiments, the columns of the data tables may be the paired entities. Likewise, outgoing invoices table106comprises a plurality of outgoing entities108a-d. As illustrated inFIG.1, the size (i.e., the number of rows and columns) of incoming payments table102and outgoing invoices table106may vary. Incoming payments table102and outgoing invoices table106may have column and/or row headers denoting various categories or fields that each data value belongs to. In some embodiments, incoming payments table102and outgoing invoices table106are multimodal data tables comprising numeric, textual, date, and categorical data. For example, the ‘Company Code’ field represents categorical data which has a predetermined definition for the particular text string while the ‘Amount’ field represents a numerical data field.

Incoming payments table102and outgoing invoices table106illustrate various instances in which conventional automated entity matching models may fail to correctly match entities. For example, conventional methods may match 100 shown in the ‘Amount’ column of incoming entity104bto 10,000 in the ‘Amount’ column of outgoing entity108ddespite the two values being orders of magnitude apart. However, because of the two numbers' textual similarity, conventional matching methods may assume the two numbers constitute a match or a near-match. Another potential issue is also illustrated in incoming entity104b, where a single incoming payment is split into two entities (outgoing entities108band108c) in outgoing invoices table106. Small discrepancies between tables may also be accounted for using embodiments described herein. Such discrepancies may be due to exchange rates, for example. If discrepancies are present throughout a data set, the neural network may be trained to classify data that is within a certain error range as a match or a near-match to account for discrepancies. For example, the neural network may be trained to classifying dollar amounts that are within a 10-dollar difference as matches.

Incoming payments table102and outgoing invoices table106may comprise training data used to train the neural network to learn matches between entities. The neural network model may ingest a set of training data that comprises matching, non-matching, and/or partial-matching data. In some embodiments, when training the neural network, a set of ground truth data may be introduced. In some embodiments, the neural network is fed the correct outputs to help the neural network correctly and quickly adjust the weights. In some embodiments, the neural network is fed entities that do not match to learn patterns present in the non-matching data. In some embodiments, a trainable function may be constructed from the scoring data. The trainable function may be represented by a neural network which may be parameterized by a set of N floating point weights, where N represents the size of the neural network and the capacity of the neural network to learn matching patterns. Broadly, for training the neural network, a larger value for N is preferable; however, N may be limited by the amount of training data available. Once trained, the trainable function may be able to accurately determine whether two paired entities constitute a Match, No Match, or another classification, such as a Partial Match.

In deep learning models, the weights are used to determine the significance an input has on a predicted output. Smaller weights will have less impact on the predicted output of the neural network while larger weights will have a more significant impact on the predicted output. The training process involves feeding the deep learning model inputs and adjusting the weights based on the predicted output. Often, the actual output is supplied to the deep learning model to help in adjusting the weights to the final, optimal value.

During the training process, an optimization algorithm may be used to determine how the weights are used and to minimize the loss function. In some embodiments, gradient descent or stochastic gradient descent (SGD) may be used as the optimization algorithm. In some embodiments, extensions and variants of SGD may be used including, but not limited to, implicit updates SGD, the momentum method, averaging SGD, the adaptive gradient algorithm, Root Mean Square Propagation, Adaptive Moment Estimation (Adam), AMSGrad, backtracking line search, and the like.

To make the determination if the paired entities constitute a match or a no-match, a binary classification may be used. In some embodiments, the paired entities may be classified as a partial match. In some embodiments, cross-entropy loss (also referred to as log loss) may be used to make the binary classification or multi-class classification. In some embodiments, a generic neural network, such as a multilayer perceptron neural network, may be used to classify the paired entities into various categories.

FIG.2illustrates a high-level schematic of decomposable attention neural network200. As depicted, decomposable attention neural network200comprises two preprocessing steps, preprocessing entity A202and preprocessing entity B204. Preprocessing entity A202and preprocessing entity B204may be done in parallel or subsequent to one another. The two preprocessing steps may be necessary to allow decomposable attention neural network200to accurately compare and match the paired entities. Both preprocessing entity A202and preprocessing entity B204may comprise substantially the same preprocessing steps before being fed into decomposable attention module206. The preprocessing steps will be discussed in more detail below with respect toFIG.3. As depicted, the output of preprocessing entity A202and preprocessing entity B204may be two distinct sequences, Sequence A and Sequence B, wherein each sequence has the same dimensions. In some embodiments, the sequences may have unequal dimensions. Subsequently, the two sequences are fed into decomposable attention module206.

Decomposable attention module206analyzes one sequence (i.e., Sequence A), and for each token of the sequence, decomposable attention module206may determine a soft, weighted average of the tokens of the other sequence to create one token. This may be done using soft-alignment. In a soft-alignment attention neural network, a soft alignment is performed during the training process. The soft alignment may allow for the gradient of the cost function of the neural network to be backpropagated throughout the neural network architecture. This soft-alignment process is then repeated for the other sequence (i.e., Sequence B). Thereafter, decomposable attention module206outputs two separate sequences. One sequence comprising original tokens from Sequence A aligned with the matched tokens of Sequence B, and the second sequence comprises original tokens from Sequence B aligned with the matched tokens of Sequence A. Next, the two sequences are compared and optionally pooled to decrease the dimension of the model. The comparison may be performed by feeding the aligned sequences into a feed-forward network. In some embodiments the pooling comprises average pooling or maximum pooling. In some embodiments, the pooling sums up all of the compared tokens. Lastly, the two sequences are concatenated together and sent to a classifier to determine if the two sequences constitute a match. In some embodiments, the classifier is the trained scoring function described above. In some embodiments, the classifier is a multilayer perceptron neural network. Generally, any neural network classifier may be used to classify the paired entities after the preprocessing steps are complete and the resultant sequences have been passed through decomposable attention module206.

When classifying entities in data tables, decomposable attention neural network200may pair each incoming entity104a-cwith each outgoing payment entity108a-dand score each pairing. Once scored, the results may be aggregated, and the best matches or results of matches may be chosen and presented to a user. In some embodiments, a confidence score may also be presented that represents the confidence of the scoring made by decomposable attention neural network200.

In some embodiments, various types of attention models may be used for pairwise matching. For example, a multi-head self-attention model or a scaled dot-product attention model may be used.

FIG.3illustrates a high-level neural network architecture for preprocessing an entity. Preprocessing architecture300may correspond to the preprocessing architecture used for preprocessing entity A202and preprocessing entity B204in decomposable attention neural network200. Preprocessing architecture300may allow for fusing textual and numeric data early on in the architecture of decomposable attention neural network200. As depicted, preprocessing architecture300receives an entity as an input, for example, incoming entity104afromFIG.1. Preprocessing for numerical and textual data may be split into two processes.

For textual data, the preprocessing may begin by tokenizing the text fields to create tokens302and then augmenting tokens302with an index304. Index304may represent the field (i.e., the column) from which tokens302originated from. For example, ‘Bank Statement ID’ from incoming entity104ais indexed with 0000 and each digit in the value 1000 is tokenized. As depicted, each token302may be associated with a single index304. In some embodiments, and as depicted inFIG.3, the tokenization occurs at a character level. In some embodiments, the tokenization occurs at a sub-word or whole word level. Numeric information, such as the monetary amount and the posting date, may also be tokenized and indexed as textual data as described above. In some embodiments, some or all of the numeric data in an entity may not be preprocessed as text. For example, preprocessing architecture300may be configured to preprocess the ‘Bank Statement ID’ field as text but may not preprocess the ‘Amount’ or ‘Posting Date’ fields as text.

Once the textual fields of incoming entity104ahave been tokenized and indexed, preprocessing architecture300moves to embedding block306where each index304may be embedded in the neural network architecture. The embeddings may allow for the model to learn relationships between fields in the table. The embeddings may be used to represent discrete variables as continuous vectors. By embedding the tokens, the overall dimensionality of decomposable attention neural network200may be reduced. In some embodiments, indexes304are embedded using a trainable embedding layer. Embedding may work to give meaning to the neural network for relationships between characters, words, sub-words, phrases, or the like. By using vectors, the distance between any two vectors may be calculated. In some embodiments, the distance is calculated using the scalar dot product. As such, the preprocessing architecture300may learn to associate two vectors that have a small distance between them in the vector space as potential matches while two vectors with a large distance between them are unlikely to be matches.

At contextualizing block308, tokens302may be embedded using a trainable embedding layer. Tokens302may be passed through a plurality of 1-dimenisonal convolutional neural network layers to contextualize the tokens and form a contextualized sequence. As such, the decomposable attention neural network200may learn to recognize patterns within the text and to associate characters and/or strings of Sequence A′s text with other similar characters and/or strings of Sequence B′s text. The contextualized sequence may be a sequence of floating vectors. In some embodiments, tokens302may be contextualized using recurrent neural networks such as Long Short Term Memory networks, fully recurrent neural networks, recursive neural networks, or any other type of recurrent neural network.

At fully embedded text block310, the outputs of contextualizing block308may be concatenated along the embedding dimension, thereby forming the contextualized sequence. Subsequently, the trainable embedding of the column of origin index from embedding block306may be attached to the contextualized sequence. In some embodiments the trainable embedding is attached by concatenation along the embedding dimension. In some embodiments, if the dimension of embedding block306matches the dimension of contextualizing block308, the trainable embedding may be attached by addition.

Parallel or subsequent to the above-described contextualization steps, any numeric and/or date fields may undergo separate preprocessing steps. As shown, incoming entity104acomprises numeric values in the ‘Amount’ field and a date value in the ‘Posting Date’ field. Each of these values may be indexed with a single value and mapped to a single integer as shown at numeric embedding block312. It should be noted that the amount 9,999.05 has been converted from decimal form to an integer 999,905. Additionally, the date, May 20, 2021 has been converted to an integer7810which is the number of days since the reference date of Jan. 1, 2000.

Preprocessing may then move to numeric index embedding block314where the field of origin of each numeric value is embedded. Numeric index embedding block314may be substantially similar to embedding block306described above.

The numeric values may then be encoded at numeric embedding block316. To represent the numeric values, the integers may be encoded as vectors of cosines and/or sines of geometrically progressing frequencies as shown in Equation 1.

In Equation 1, x is the integer representing the numeric amount or date from the field. For example, inFIG.3, x would be 999,905 when preprocessing the ‘Amount; field and 7,810 when preprocessing the ‘Posting Date’ field. The integer may then be mapped to a d-dimensional numeric embedding by the function num_embedding(x). Amounts may be converted from a decimal amount to an integer by multiplying the amount by 10e, where e depends on the corresponding currency. For most currencies having monetary amounts with two decimal points, e is 2 to convert the decimal to an integer value.

Parameters b and d may vary depending on the data being processed by preprocessing architecture300. In some embodiments, the parameter d represents the dimension of the vector. Broadly, b and d should be selected so that the expected range of values of x can be captured. In some embodiments, d may be set to a fixed amount, such as 32 or 64, and b may be selected by requiring b1−d/2xmax=1, where xmaxis the maximum value of x expected to be encountered in the data set. In some embodiments, xmaxmay be determined from domain knowledge or from the training data set used to train the neural network. Capturing the entire expected range of values for x may allow for variances in numbers having different orders of magnitude to be properly represented such that decomposable attention neural network200can properly learn relationships between the paired entities. For example, xmaxmay be the largest value present in the training data set. As such, if incoming payments table102is being used to train decomposable attention neural network200, the value ‘10,000’ in incoming entity104cwould be set to be xmax. As another example, if it is known that incoming payments table102represents transactions having a maximum transaction limit of $50,000.00, xmaxmay be set to 50,000 even if no transaction in incoming payments table102equals 50,000.

In some embodiments, numeric values may be encoded as vectors using various equations other than Equation 1. Broadly, the encoding equation should function such that a floating-point number can be expanded into a vector so that the elements of the vector are sensitive to contributions of integers on various orders of magnitude. For example, the encoding equation should be sensitive such that an input of 100 causes a different classification than an input of 10,000.

After the numeric data fields have been encoded, a projection may be applied to the embedded numeric value to match the dimension of the embedded numeric value to the dimension of the encoded text sequence formed at fully embedded text block310. In some embodiments, the projection is a fully connected neural network layer that does not have an activation function. In some such embodiments, the projection comprises linear mapping. After applying the projection, another column of origin embedding may be added or concatenated to the embedded numeric value as described above. The resultant fully embedded numeric318values may then be attached to the fully embedded tokens, thus resulting in the final sequence having a dimension equal to the sum of the dimensions of the text fields and the numeric fields.

FIG.4illustrates an exemplary method400of preprocessing an entity for pairwise entity matching. Either entity in the paired entities may be preprocessed first. At step402, decomposable attention neural network200may ingest a set of data. The data may be in the form of two distinct tables such as incoming payments table102and outgoing invoices table106illustrated inFIG.1. As described above, the data may comprise any of textual, categorical, and/or numeric (including dates) data types. When training decomposable attention neural network200, the data may be training data selected to train decomposable attention neural network200on matching the entities. The training data may comprise entity pairs that do not constitute a match to aid decomposable attention neural network200in learning entity pairs that do not match.

At step404, data from each field of the entity may be tokenized. For example, each field in incoming entity104amay be tokenized as shown inFIG.3. In some embodiments, the data is tokenized on a character level, such that each Unicode character is tokenized. In some embodiments, the data may be tokenized on a sub-word level such that portions of a word or phrase are represented by a single token. For example, in the ‘Business Partner Name’ field of incoming entity104a, ‘ABCD’ may be represented by a single token and ‘CORP’ may be represented by a different token. In some embodiments, the data may be tokenized on a whole word level. Combinations of different levels of tokenization are also considered herein. For example, some data fields may be configured to be tokenized at a whole word level, while other fields may be configured to be tokenized at a character level. As described above, numeric data may also be represented textually and tokenized.

Once the fields have been tokenized, processing may move to step406or412. If the data type of the field is textual, processing moves to step406to continue preprocessing the textual data. If the data type of the field is numeric, processing moves to step412to continue preprocessing the numeric data. In some embodiments, as described above, numeric data may be preprocessed both as textual data and as numeric data.

At step406, the index of the textual data is embedded. By embedding the indexes, the neural network may learn relationships between the various fields. For example, referring back toFIG.1, a common string between the ‘Business Partner Name’ in incoming payments table102and the ‘Organization” field of outgoing invoices table106may indicate a match, but a common string between the ‘Note’ field in incoming payments table102and the ‘Amount’ field of outgoing invoices table106would be coincidental and have no significance on the two entities being a match. Thus, the model may learn field-level relationships and patterns. Each field of the entity may be represented by an index corresponding to each token of the field. As such, the number of indexes may represent the dimension of the resultant vector.

Next, at step408, tokens302for each field are contextualized. In some embodiments, tokens302may first be embedded using a trainable embedding layer. In a trainable embedding layer, the weights may be updated as tokens302are contextualized. Contextualization may be done by passing tokens302through numerous 1-dimensional convolutional neural network layers, recurrent neural network layers, or self-attention neural network layers. Broadly, any neural network architecture may be used to contextualize tokens302such that the neural network architecture may learn relationships between tokens302and the corresponding data table.

After contextualizing tokens302, processing may move to step410where concatenation occurs. In some embodiments, step410comprises two distinct concatenation steps. First, the output of the contextualization layers may be concatenated along the embedding dimension to form the contextualized sequence. Subsequently, a trainable embedding of the column of origin index may be concatenated to the contextualized sequence. In some embodiments, if the column of origin embedding matches the dimension of the contextualized tokens, the trainable embedding of the column of origin index may instead be added to the contextualized sequence. The contextualized sequence may then have a dimension equal to the number of distinct characters. In the example given inFIG.3, there are 43 distinct characters; as such, the contextualized sequence has a dimension of 43.

For fields where the data type is numeric, processing may instead proceed from step404to step412where each numeric value may be mapped to a single integer or a single distinct value. Dates may be mapped to an integer based off time elapsed from a reference date. In some embodiments, the integer value for dates may represent the number of epochs, seconds, days, weeks, months, or years, or any other reference value from a certain date.

Similar to step406, at step414, the index of origin for each numeric field in the entity will be embedded. As such, preprocessing architecture300may learn which field in the entity each numeric originated from. In some embodiments, step414may occur before step412such that the index of origin is embedded prior to the mapping of the numeric values to integers.

Next, at step416, the numeric value is encoded as a vector. The numeric values may then be encoded as vectors and mapped to cosines and sines of geometrically progressing frequencies as described above with respect to Equation 1. As such, the resultant numeric value may comprise a vector having values between −1 and 1.

After the numeric has been embedded as a vector as described above, a projection may be applied to the embedded numeric at step418. In some embodiments, this projection is done via linear mapping, whereby a fully connected neural network layer without an activation function is applied to match the dimension of the fully embedded numeric to the dimension of the encoded text sequence obtained at contextualizing block308.

At step420, the numeric data may be concatenated together. Step420may be substantially similar to step410where the textual tokens and the indexes are concatenated. At step420, the fully embedded numeric is concatenated to the index of the numeric created at step414. In some embodiments, the index of the numeric is added to the fully embedded numeric instead rather than concatenated. As described above, addition may be used when the dimensions of the fully embedded numeric and the index is the same.

Once both the numeric and the textual data for the ingested entity have been fully embedded, processing may proceed to step422where the preprocessed numeric and textual data may be concatenated together. This concatenation may increase the dimension of the sequence by the number of numeric and date fields present in the entity. For example, inFIG.3, two numeric/date fields are present and were embedded as described above with respect to steps412to420. As such, the size of the sequence increases from 43 to 45.

Processing then proceeds to step424where the preprocessed sequence is completed. Referring back now toFIG.2, this may represent Sequence A in decomposable attention neural network200. In some embodiments, Sequence B may be preprocessed before Sequence A.

At step426, the other entity in the entity pair (e.g., Entity B) is preprocessed following the steps outlined above for preprocessing Entity B, thus resulting in two fully preprocessed sequences, Sequence A and Sequence B. In some embodiments, the weights are shared between the preprocessing of each entity in the pair. Once the entity pair is fully preprocessed, the fully preprocessed pair may be passed through decomposable attention module200, and then sent to the scoring function for classification. The entity pair may be analyzed with the decomposable attention module206as described above with respect toFIG.2. The scoring function may be configured to score the paired entities between a value of 0 and 1. Pairs that receive a score close to 0 may be considered to not match while pairs that score close to 1 may be considered to be a match. In some embodiments, a Partial Match class is introduced by using a scoring function that produces one score for the two entities being a 1:1 Match, and another score for the two entities being a Partial Match, i.e., the entities are part of a larger group of entities that constitute a match. Broadly, any scoring metric may be used herein to determine matches. For example, a range from 0 to 100 could be used instead.

Turning now toFIG.5, in which an exemplary hardware platform for certain embodiments is depicted. Computer502can be a desktop computer, a laptop computer, a server computer, a mobile device such as a smartphone or tablet, or any other form factor of general- or special-purpose computing device containing at least one processor. Depicted with computer502are several components, for illustrative purposes. In some embodiments, certain components may be arranged differently or absent. Additional components may also be present. Included in computer502is system bus504, via which other components of computer502can communicate with each other. In certain embodiments, there may be multiple busses or components may communicate with each other directly. Connected to system bus504is central processing unit (CPU)506. Also attached to system bus504are one or more random-access memory (RAM) modules508. Also attached to system bus504is graphics card510. In some embodiments, graphics card510may not be a physically separate card, but rather may be integrated into the motherboard or the CPU506. In some embodiments, graphics card510has a separate graphics-processing unit (GPU)512, which can be used for graphics processing or for general purpose computing (GPGPU). Also, on graphics card510is GPU memory514. Connected (directly or indirectly) to graphics card510is display516for user interaction. In some embodiments no display is present, while in others it is integrated into computer502. Similarly, peripherals such as keyboard518and mouse520are connected to system bus504. Like display516, these peripherals may be integrated into computer502or absent. Also connected to system bus504is local storage522, which may be any form of computer-readable media, such as non-transitory computer readable media, and may be internally installed in computer502or externally and removably attached.

Finally, network interface card (NIC)524is also attached to system bus504and allows computer502to communicate over a network such as network526. NIC524can be any form of network interface known in the art, such as Ethernet, ATM, fiber, Bluetooth, or Wi-Fi (i.e., the Institute of Electrical and Electronics Engineers (IEEE) 802.11 family of standards). NIC524connects computer502to local network526, which may also include one or more other computers, such as computer528, and network storage, such as data store530. Generally, a data store such as data store530may be any repository from which information can be stored and retrieved as needed. Examples of data stores include relational or object-oriented databases, spreadsheets, file systems, flat files, directory services such as LDAP and Active Directory, or email storage systems. A data store may be accessible via a complex API (such as, for example, Structured Query Language), a simple API providing only read, write and seek operations, or any level of complexity in between. Some data stores may additionally provide management functions for data sets stored therein such as backup or versioning. Data stores can be local to a single computer such as computer528, accessible on a local network such as local network526, or remotely accessible over public Internet532. Local network526is in turn connected to public Internet532, which connects many networks such as local network526, remote network534or directly attached computers such as computer536. In some embodiments, computer502can itself be directly connected to public Internet532.