Deep Neural Networks for Matching Entities in Semi-Structured Data

Abstract

To provide a system, a method, and a non-transitory machine readable media for matching entity in semi-structured data.SOLUTION: A system 100 utilizes a deep neural network in order to determine a confidence score that reflects how confident the deep neural network is for matching between candidate pairs of entities and corresponding matching. The deep neural network finds these matching with no need for domain knowledge that would be needed when a feature relative to a machine learning model is hand-crafted, which is a drawback of a prior-art machine learning model used to match entities in multiple tables. Thus, the deep neural network improves functionality of the prior art machine learning model designed to perform the same task.SELECTED DRAWING: Figure 1

Description

[Technical Field]

[0001] This document relates generally to machine learning and, more particularly, to deep neural networks for matching entities in semi-structured data. [Background technology]

[0002] Databases typically store data in tables, with each row representing a different entity. An entity can be any element in a dataset, including, for example, a user, a document, an organization, a location, etc., but in many types of data storage, each row in a table corresponds to a different entity. If the table is, for example, a table of documents, each row represents a different document. One problem that can arise in data storage is the inability to align entities across multiple tables. For example, the data stored in each table may not be normalized, and therefore it may be difficult to determine whether an entity in one table is the same entity listed in another table because different tables may store information about the same entity in two different ways. For example, a product catalog targeted to customers may contain information about products stored in a different format than the same information in a product catalog targeted to component suppliers. In some cases, it may be beneficial to identify alignments between entities in different tables to reconcile the two different formats of information. In other cases, this alignment can be used to deduplicate entities that are not intended to be listed twice to reduce storage size. [Prior art documents] [Non-patent literature]

[0003] [Non-Patent Document 1] BERKHAHN, FELIX, et al., "Entity Embeddings of Categorical Variables", arXiv:1604.06737v1 [cs.LG], (22 Apr 2016), 1-9 [Non-patent document 2] PARIKH, ANKUR, et al., "A Decomposable Attention Model for Natural Language Inference", arXiv:1606.01933v2 [cs.CL], (25 Sep 2016), 7 pgs Summary of the Invention [Means for solving the problem]

[0004] The present disclosure is illustrated by way of example, and not by way of limitation, in the figures of the accompanying drawings in which like reference numerals indicate similar elements. [Brief explanation of the drawings]

[0005] [Figure 1] FIG. 1 is a block diagram illustrating a system for using machine learning to match entities in a table, according to one example embodiment. [Figure 2] FIG. 1 illustrates an example of a sequence processing operation according to one exemplary embodiment. [Figure 3] 1 is a flow diagram illustrating a method for matching entities in a table using a machine learning model, according to one example embodiment. [Figure 4] FIG. 1 is a block diagram illustrating a software architecture that may be installed on any one or more of the devices described above. [Figure 5] 1 is a diagrammatic representation of a machine in the form of a computer system upon which a set of instructions may be executed to cause the machine to perform any one or more of the methodologies discussed herein, according to one exemplary embodiment. DETAILED DESCRIPTION OF THE INVENTION

[0006] The following description discusses exemplary systems, methods, techniques, instruction sequences, and computer program products. In the following description, for purposes of explanation, numerous details are set forth in order to provide an understanding of various exemplary embodiments of the present subject matter. However, it will be apparent to those skilled in the art that various exemplary embodiments of the present subject matter may be practiced without these specific details.

[0007] In one exemplary embodiment, a deep neural network can be utilized to determine matches between candidate pairs of entities and a confidence score that reflects how confident the deep neural network is about the corresponding matches. Deep neural networks are also able to find these matches without requiring domain knowledge, a drawback of prior art machine learning models used to match entities in multiple tables, which would be required if features for the machine learning model were handcrafted. Indeed, in some cases, it may be impossible for a user to define the entire set of engineering features (such as when the semantics and precise usage of technical terms may differ across countries and organizations), making the prior art unusable. Thus, deep neural networks improve the capabilities of prior art machine learning models designed to perform the same task. Specifically, deep neural networks learn the relationships between tabular fields and patterns that define matches solely from historical data, making the approach comprehensive and applicable regardless of the context.

[0008] The table itself can be considered semi-structured. Some fields in the table may contain structured data (i.e., these fields have clear types such as date / numeric values, such as amount, volume, and quantity, or categorical values ​​such as country codes or currency codes). Other fields in the table are unstructured text-type fields, such as item description, reference number, bank statement memo notice, company name, etc. While there may be formatting conventions for some of these text fields, the data in the fields is generally entered by the user, and therefore the content can vary considerably. For example, a bank transfer payment memo field may or may not contain an invoice number, a reference number may or may not have leading zeros, a company name may or may not contain the city where the company is located, etc. These unstructured fields often carry most of the information needed to find matching entities.

[0009] One solution is to use a basic form of automation to reconcile entities from different tables, such as "if the amounts match between the entities and the invoice number is contained in the bank payment memo field, then they match." Such rule-based automation is inflexible in that it must be programmed with knowledge of the data types in each of those fields and their corresponding meanings. A higher degree of automation can be achieved using machine learning techniques that can deal with "fuzzy" data and adapt to patterns from historical data.

[0010] The machine learning approach defines the task as a machine learning problem by using pairwise matching scoring. Specifically, the machine learning model f calculates the probability score that an item is a match.

[0011]

number

[0012] (or more generally, to output a multi-class probability score (e.g., "no match," "one-to-one match," "partial match"))

[0013]

number

[0014] (where,

[0015]

number

[0016] represents the tabular data for each of the two entities), and the class label

[0017]

number

[0018] (e.g., trained against "match" or "no match"):

[0019]

number

[0020] The training data is a labeled pair.

[0021]

number

[0022] where:

[0023]

number

[0024] is an indicator vector encoding the label, and C is the number of output classes. At test time, entity pairs (a, b) are received and the goal is to predict the correct label y. Note that although training data is specifically mentioned in this section, this data is used to jointly train the entire neural network.

[0025] Training data is obtained from historical data that specifies which entities are considered to be matches, and training data is then constructed from generated pairs of these positive examples (pairs that constitute a "one-to-one match," or a "partial match") and negative examples of the class (no matches).

[0026] Given Entity

[0027]

number

[0028] To find a match for

[0029]

number

[0030] are scored, the results are aggregated, and the best match (or combination of partial matches) is selected as output, along with a confidence score that reflects how reliably the model is based on that result.

[0031] Prior art machine learning approaches to this problem relied on engineering features or other types of pre-assigned relationships between table fields. However, as noted above, this approach does not work in areas where domain knowledge is not available. This often occurs, for example, when the model creator is different from the model's users. A software organization, for example, may create a model, but the model may be used by an industry that the software organization does not know or is not very familiar with (e.g., the healthcare industry, or a sprinkler component manufacturer).

[0032] In one exemplary embodiment, a deep neural network is utilized as the machine learning model and is trained in such a way that no domain knowledge of the meaning of the fields in the table or the relationships between the fields in the table is required during training.

[0033] FIG. 1 is a block diagram illustrating a system 100 for using machine learning to match entities in tables, according to one exemplary embodiment. Here, an application server 102 executes a series of components to perform the matching. In some exemplary embodiments, the application server 102 may be cloud-based. An organization's data collection 104 may contain many different document tables (potentially thousands or millions) related to the organization. One or more of these tables may be passed to a machine learning component 106, which operates to identify matching entities between the tables. Prior to that occurrence, a deep neural network 108 within the machine learning component 106 may be trained using training data 110, which may be sample tables with entities that have indices for identifying a match (either a perfect, i.e., one-to-one match, or a partial match, such as a single payment corresponding to several different invoices, or vice versa). A field grouper 112 may operate to group fields within each table from the training data 110 into one of three different field types. The first field type is:

[0034]

number

[0035] a text-like field represented as

[0036]

number

[0037] a categorical field, denoted as

[0038]

number

[0039] The deep neural network 108 includes separate neural networks 120A, 120B, 120C for each of these field types.

[0040] Text-like fields are fields that contain unstructured text, such as names, invoice numbers, etc. Categorical fields are fields that contain category identification, such as country keys, currency codes, etc. Numeric features are fields that contain structured numbers and dates.

[0041] Although the image portion itself is not text, the portion may contain text. Therefore, optical character recognition can be performed on the image portion to identify the text within the image. Depending on the file format of the document file, optical character recognition may be performed on the text portion of the document (in some file formats, the text portion is already stored in a text-readable form and therefore does not require optical character recognition).

[0042] For categorical fields, neural network 120B includes a categorical embedding model that transforms the values ​​of each field into a vector in n-dimensional space (a vector in this context means a one-dimensional array of values ​​or associations in n-dimensional space). This transformation is performed using a trainable embedding-lookup. Specifically, in a function approximation problem, categorical variables are mapped into a Euclidean space that is an entity embedding of the categorical variables. This mapping is itself learned by the neural network. This embedding is then followed by a dense feed forward neural network.

[0043] For numeric fields, these fields may be normalized by converting the date or timestamp to a numeric scale, such as days / seconds since some fixed date and time.

[0044] In an optional exemplary embodiment, numeric and categorical fields may be treated as text fields, such as by attaching their text representations to text vectors (either by keeping them as numeric and categorical inputs or by using only their text representations).

[0045] The text-like field, which represents a series of text strings from different tabular fields, is tokenized. In one exemplary embodiment, each Unicode character is a token, although in other embodiments, a word-based or subword-based tokenizer may be used. Specifically, the series of operations may be performed by a sequence processor 122 within neural network 120A. Specifically, sequence processor 122 may extract the text fields of entities,

[0046]

number

[0047] are tokenized and concatenated to form a and l b The input sequence

[0048]

number

[0049] and

[0050]

number

[0051] These sequences are then trained via a trainable embedding lookup to form emb,text In an alternative implementation to the trainable embedding lookup, if the tokenization is word-based, a pre-trained word embedding lookup may be used.

[0052] A second sequence of tokens is generated to encode information about which tabular fields occurred in each original sequence of characters (or words or subwords). A second trainable embedding lookup then maps it to k emb,field length of the dimension vector l a is used to convert it into a sequence of

[0053] These two sequences are then stacked along the vector dimension, resulting in a k-dimensional vector of length l a A sequence of (k=k emb,text +k emb,field ) is formed.

[0054] The stacked sequences are then processed by an inter-sequence module 124, possibly by padding the stacked sequences with leading zeros to make them a fixed length. In one exemplary embodiment, a multi-layer 1D convolutional network is utilized, while in other exemplary embodiments, a recurrent neural network or a self-attention / transformer module is possible. The inter-sequence module 124 is implemented by the inventors as

[0055]

number

[0056] Let the length of the k'-dimensional vector be l'. a A similar process can be performed on the text field

[0057]

number

[0058] and the second pre-processed sequence

[0059]

number

[0060] Note that the inter-sequence module 124 obtains a trainable mapping function F A and F B It can be shown that

[0061]

number

[0062] Depending on the use case, some of the trainable parameters are A and F B If all parameters are shared, F A =F B This will result in the following:

[0063] Token-level embedded lookup can model the correspondence between individual tokens (e.g., "a" is similar to "A," "α," and "a'"). By extending token sequences with field-of-origin information, the model can learn relationships between tabular fields. For example, in a bank statement and invoice matching task, a common number sequence between the invoice number field and the payment advice may indicate a match, but a common number sequence between the invoice number and the payment amount or zip code may be coincidental and have no meaning.

[0064] Further processing in inter-sequence operations allows the algorithm to model the context of tokens (e.g., leading zeros may be less important) and learn correspondences of multi-token sequences (e.g., "Volkswagen" may correspond to "VW" and its corresponding language in a foreign alphabet (e.g., Japanese)).

[0065] Specifically, the decomposable attention and aggregation component 126 utilizes decomposable attention to perform sequence alignment and comparison.

[0066] 2 is a diagram illustrating an example of a sequence processing operation, according to one exemplary embodiment. The diagram shows how a text-like field 200 of an entity is tokenized and concatenated into a first sequence 202, and then a second sequence 204 is generated that indicates the field positions of the fields where the corresponding tokens reside. Both the first sequence 202 and the second sequence 204 are then mapped to embeddings 206 and 208, respectively. The embeddings 206 and 208, which may be stored as matrices, are then stacked together and aligned into a matrix 210. The inter-sequence module then outputs a k′-dimensional vector 212.

[0067] k'-dimensional vector

[0068]

number

[0069] (same as vector 212) is then passed to the decomposable attention and aggregation component 126, which operates as follows:

[0070] The core model has three components that are trained together:

[0071] Attention. First, we use a variant of neural attention to

[0072]

number

[0073] We soft-align the elements of and decompose the problem into a comparison of aligned subphrases.

[0074] Second, each aligned subphrase is compared separately to find the vector

[0075]

number

[0076] and the vector for b

[0077]

number

[0078] produces a set of v 1,i is a i and a are nonlinear combinations of their (softly) aligned subphrases in b (and v 2,j (similar to

[0079] Aggregation. Finally, the set from the previous step

[0080]

number

[0081] and use the results to

[0082]

number

[0083] Predict.

[0084] We first calculate the function F',

[0085]

number

[0086] The denormalized attention weights e are decomposed as follows: ij This decomposition is a xl b avoids the quadratic complexity that would be associated with applying F A / B l a +l b Only application is required. These attention weights are

[0087]

number

[0088] where β i teeth,

[0089]

number

[0090] Aligned (softly) to

[0091]

number

[0092] It is a subphrase in α j The same is true for .

[0093] Next, the aligned phrase

[0094]

number

[0095] are compared separately using a function G, which is again a feedforward network:

[0096]

number

[0097] where the square brackets [.,.] indicate concatenation. Note that in this case there are only a linear number of items, and there is no need to apply decomposition as was done in the previous step. Thus, G is

[0098]

number

[0099] and β i Both can be taken into consideration together.

[0100] At this time, the two sets of comparison vectors

[0101]

number

[0102] First, the system may aggregate for each set by some kind of pooling, such as average, max pooling, or summation:

[0103]

number

[0104] We feed the result through a final classifier H, which is a feedforward network followed by a linear layer:

[0105]

number

[0106] During the ceremony,

[0107]

number

[0108] represents the predicted (unnormalized) score for each class, and consequently, the predicted class is

[0109]

number

[0110] is given by

[0111] For training, a multi-class cross-entropy loss with dropout regularization can be used:

[0112]

number

[0113] where θ F , θ G , θ H are functions F A / B , G, and H, and the learnable parameters are shown. 1, the final classifier module 128 comprises a dense neural network with multi-class outputs. The final classifier module 128 receives the outputs of all previous modules and produces probabilities for the classes that its model was trained on.

[0114] The alignment utilization module 130 may then utilize the output of the final classifier module 128, as well as the confidence scores, to perform one or more actions related to matching (or partially matching, or not matching) the entities. For example, the matching entities may be presented to a user in a graphical user interface for reconciliation. Alternatively, the matching entities may be automatically reconciled, meaning that an action is performed on one of the entities based on its match to the other entities. As an example, an entity representing a deposit may be matched, either partially or fully, to an entity representing an invoice to which the payment should be applied. Reconciliation then entails applying the payment to the invoice and creating a record of the process so that relevant parties know that the payment has been applied to the invoice.

[0115] Alternatively, rather than using the output of the final classifier module 128 for adjustment, the match utilization module 130 may utilize its output for replication. Specifically, for example, if matching entities appear in redundant tables, or even in the same table, one of the entities may be removed and / or combined into the other entity because the other entity is deemed duplicate or redundant in some way.

[0116] 3 is a flow diagram illustrating a method 300 for matching entities in tables using a machine learning model, according to one exemplary embodiment. This method 300 is described with respect to comparing a first entity to a second entity to determine whether it is a match. In practice, to identify a match or partial match, in some exemplary embodiments, the method 300 may be repeated for various combinations of entities in the tables being examined. For example, if Table #1 has 10 entities and Table #2 has 8 entities, 80 different combinations of entities from Table #1 and Table #2 may be examined. In some exemplary embodiments, entities from the same table may be compared with each other, resulting in even more combinations being tested.

[0117] A loop is initiated for each of the two entities. At operation 302, a corresponding entity is obtained, which includes values ​​for multiple fields. At operation 304, the fields are divided into categories: one for text-based fields, one for categorical fields, and one for numeric / date fields. At operation 306, the values ​​for the text-based fields are tokenized. At operation 308, a set of coordinates in n-dimensional space is generated for the input, and each of the tokens is passed to an embedding machine learning model trained by a first machine learning algorithm to produce an embedding comprising the set of coordinates for each of the one or more tokens. At operation 310, the embeddings for each of the one or more tokens are concatenated into a first matrix.

[0118] At operation 312, an origin field sequence is constructed for the entity. The origin field sequence includes, for each of one or more tokens for each of the text-based fields, an identification of the text-based field corresponding to the value from which the token was generated. At operation 314, each value in the origin field sequence is passed through an embedding machine learning model to generate a set of coordinates for each value in the origin field sequence. At operation 316, the embeddings for each value in the origin field sequence are concatenated into a second matrix.

[0119] At operation 318, the first matrix and the second matrix are stacked to create a third matrix. At operation 320, the third matrix is ​​passed to a multi-layer 1D convolutional network, which outputs a sequence of k'-dimensional vectors. At operation 322, it is determined whether the entity was the first entity or the second entity. If it was the first entity, method 300 loops back to operation 302 for the second entity. If it was the second entity, at operation 324, the k'-dimensional vector is passed to a decomposable attention neural network to compare the first entity with the second entity based on the text-based field. At operation 326, a first feed-forward neural network is used to compare the first entity with the second entity based on the categorical field. At operation 328, the numeric / date field is normalized and used as input to a second feed-forward neural network to compare the first entity with the second entity based on the numeric / date field.

[0120] In operation 330, the classifier module then combines the outputs of operations 324, 326, and 328 and applies a class to the combination of the first entity and the second entity. This class may include an indication such as match, no match, or partial match. This classification may be based at least in part on the confidence values ​​output in operations 324, 326, and 328. The output of the neural network (classifying the pairs into match / partial match / no match classes) is then used as input to rule-based logic to construct the final proposed single or multiple matches (e.g., by applying a confidence threshold). [Example]

[0121] 1. A system comprising: at least one hardware processor; a non-transitory computer-readable medium having instructions stored thereon; wherein the instructions, when executed by the at least one hardware processor, cause the at least one hardware processor to: Retrieving a first entity in a first table, the first entity including values ​​for a plurality of fields; tokenizing values ​​in one or more fields of the plurality of fields into one or more tokens; passing each of the one or more tokens to an embedding machine learning model trained by a first machine learning algorithm to generate a set of coordinates in n-dimensional space for the input, thereby producing an embedding with coordinates for each of the one or more tokens; Concatenating embeddings for the one or more tokens and for each of the one or more fields of the plurality of fields in the first entity into a first matrix; constructing an origin field sequence for the first entity, the origin field sequence including, for each of one or more tokens for each of one or more fields of a plurality of fields in the first entity, an identification of a field corresponding to a value from which the token was generated; passing each value in the provenance field sequence to an embedding machine learning model to generate a set of coordinates for each value in the provenance field sequence; Concatenating the embeddings for each value in the origin field sequence into a second matrix; stacking the first matrix and the second matrix to create a third matrix; passing the third matrix to a decomposable attention neural network to compare the first entity with the second entity represented by its own matrix of embeddings; Execute an action that includes system. [Example]

[0122] The operation is Retrieving a second entity in a second table, the second entity including values ​​for a plurality of fields; tokenizing values ​​in each of the one or more fields of the plurality of fields in the second entity into one or more tokens; passing each of the one or more tokens to an embedding machine learning model to generate an embedding comprising a set of coordinates for each of the one or more tokens of the second entity; Concatenating the embeddings for each of the one or more tokens and for each of the one or more fields of the plurality of fields in the second entity into a fourth matrix; constructing an origin field sequence for the second entity, the origin field sequence including, for each of one or more tokens for each of one or more fields of the plurality of fields in the second entity, an identification of a field corresponding to a value from which the token was generated; passing each value in the provenance field sequence for the second entity to an embedding machine learning model to generate a set of coordinates for each value in the provenance field sequence for the second entity; concatenating the embeddings for each value in the provenance field sequence for the second entity into a fifth matrix; and stacking the fourth matrix and the fifth matrix to create a sixth matrix, the sixth matrix being compared to the third matrix by a decomposable attention neural network; and The system of Example 1, further comprising: [Example]

[0123] 3. The system of example 2, wherein the operations further include passing an output of the decomposable attention neural network to a classifier module, the classifier module comprising a dense neural network with multi-class outputs. [Example]

[0124] The system of Example 3, wherein the multi-class output includes separate classes for match, partial match, and no match. [Example]

[0125] 5. The system of any of Examples 1 to 4, wherein the operations further include dividing the plurality of fields in the first entity into three categories of fields: text-based fields, categorical fields, and numeric / date fields, wherein one or more fields of the plurality of fields are text-based fields. [Example]

[0126] 6. The system of example 5, wherein the operations further include passing the value of the categorical field to a second embedded machine learning model followed by a first feedforward neural network. [Example]

[0127] The system of example 5 or 6, wherein the operations further include normalizing values ​​in the numeric / date field and passing the normalized values ​​to a second feedforward neural network. [Example]

[0128] retrieving a first entity in a first table, the first entity including values ​​for a plurality of fields; tokenizing values ​​in one or more of the plurality of fields into one or more tokens; passing each of the one or more tokens to an embedding machine learning model trained by a first machine learning algorithm to generate a set of coordinates in n-dimensional space for the input, yielding an embedding with coordinates for each of the one or more tokens; Concatenating embeddings for one or more tokens and for each of one or more fields of the plurality of fields in the first entity into a first matrix; constructing an origin field sequence for the first entity, the origin field sequence including, for each of one or more tokens for each of one or more fields of a plurality of fields in the first entity, an identification of a field corresponding to a value from which the token was generated; passing each value in the provenance field sequence to an embedding machine learning model to generate a set of coordinates for each value in the provenance field sequence; Concatenating the embeddings for each value in the origin field sequence into a second matrix; stacking the first matrix and the second matrix to create a third matrix; passing the third matrix to a decomposable attention neural network to compare the first entity with a second entity represented by its own matrix of embeddings; A method comprising: [Example]

[0129] retrieving a second entity in a second table, the second entity including values ​​for a plurality of fields; tokenizing values ​​in each of the one or more fields of the plurality of fields in the second entity into one or more tokens; passing each of the one or more tokens to an embedding machine learning model to generate an embedding comprising a set of coordinates for each of the one or more tokens of the second entity; concatenating the embeddings for each of the one or more tokens and for each of the one or more fields of the plurality of fields in the second entity into a fourth matrix; constructing an origin field sequence for the second entity, the origin field sequence including, for each of one or more tokens for each of one or more fields of the plurality of fields in the second entity, an identification of a field corresponding to a value from which the token was generated; passing each value in the provenance field sequence for the second entity to an embedding machine learning model to generate a set of coordinates for each value in the provenance field sequence for the second entity; concatenating the embeddings for each value in the provenance field sequence for the second entity into a fifth matrix; stacking the fourth matrix and the fifth matrix to create a sixth matrix, the sixth matrix being compared against the third matrix by a decomposable attention neural network; The method of Example 8, further comprising: [Example]

[0130] 10. The method of example 9, further comprising passing an output of the decomposable attention neural network to a classifier module, the classifier module comprising a dense neural network with multi-class outputs. [Example]

[0131] 11. The method of example 10, wherein the multi-class output includes separate classes for match, partial match, and no match. [Example]

[0132] 12. The method of any of Examples 8 to 11, further comprising: dividing the plurality of fields in the first entity into three categories of fields: text-based fields, categorical fields, and numeric / date fields, wherein one or more fields of the plurality of fields are text-based fields. [Example]

[0133] 13. The method of example 12, further comprising passing the values ​​of the categorical field to a second embedded machine learning model followed by a first feedforward neural network. [Example]

[0134] 14. The method of example 12 or 13, further comprising normalizing values ​​in the numeric / date field and passing the normalized values ​​to a second feedforward neural network. [Example]

[0135] A non-transitory machine-readable medium having stored thereon instructions that, when executed by one or more processors, cause the one or more processors to: Retrieving a first entity in a first table, the first entity including values ​​for a plurality of fields; tokenizing values ​​in one or more fields of the plurality of fields into one or more tokens; passing each of the one or more tokens to an embedding machine learning model trained by a first machine learning algorithm to generate a set of coordinates in n-dimensional space for the input, thereby producing an embedding with coordinates for each of the one or more tokens; Concatenating embeddings for the one or more tokens and for each of the one or more fields of the plurality of fields in the first entity into a first matrix; constructing an origin field sequence for the first entity, the origin field sequence including, for each of one or more tokens for each of one or more fields of a plurality of fields in the first entity, an identification of a field corresponding to a value from which the token was generated; passing each value in the provenance field sequence to an embedding machine learning model to generate a set of coordinates for each value in the provenance field sequence; Concatenating the embeddings for each value in the origin field sequence into a second matrix; stacking the first matrix and the second matrix to create a third matrix; passing the third matrix to a decomposable attention neural network to compare the first entity with the second entity represented by its own matrix of embeddings; 10. A non-transitory machine-readable medium for causing operations to be performed, including: [Example]

[0136] Retrieving a second entity in a second table, the second entity including values ​​for a plurality of fields; tokenizing values ​​in each of the one or more fields of the plurality of fields in the second entity into one or more tokens; passing each of the one or more tokens to an embedding machine learning model to generate an embedding comprising a set of coordinates for each of the one or more tokens of the second entity; Concatenating the embeddings for each of the one or more tokens and for each of the one or more fields of the plurality of fields in the second entity into a fourth matrix; constructing an origin field sequence for the second entity, the origin field sequence including, for each of one or more tokens for each of one or more fields of the plurality of fields in the second entity, an identification of a field corresponding to a value from which the token was generated; passing each value in the provenance field sequence for the second entity to an embedding machine learning model to generate a set of coordinates for each value in the provenance field sequence for the second entity; concatenating the embeddings for each value in the provenance field sequence for the second entity into a fifth matrix; and stacking the fourth matrix and the fifth matrix to create a sixth matrix, the sixth matrix being compared to the third matrix by a decomposable attention neural network; and 16. The non-transitory machine-readable medium of Example 15, further comprising: [Example]

[0137] 17. The non-transitory machine-readable medium of example 16, wherein the operations further include passing an output of the decomposable attention neural network to a classifier module, the classifier module comprising a dense neural network having a multi-class output. [Example]

[0138] 18. The non-transitory machine-readable medium of example 17, wherein the multi-class output includes separate classes for matches, partial matches, and no matches. [Example]

[0139] 19. The non-transitory machine-readable medium of any of Examples 15-18, wherein the operations further include dividing the plurality of fields in the first entity into three categories of fields: text-based fields, categorical fields, and numeric / date fields, wherein one or more fields of the plurality of fields are text-based fields. [Example]

[0140] 20. The non-transitory machine-readable medium of example 19, wherein the operations further include passing the value of the categorical field to a second embedded machine learning model followed by a first feedforward neural network.

[0141] FIG. 4 is a block diagram 400 illustrating a software architecture 402 that may be installed on any one or more of the devices described above. It will be appreciated that FIG. 4 is merely a non-limiting example of a software architecture and that many other architectures may be implemented to facilitate the functionality described herein. In various embodiments, software architecture 402 is implemented by hardware, such as machine 500 of FIG. 5, which includes processor 510, memory 530, and input / output (I / O) components 550. In this exemplary architecture, software architecture 402 may be conceptualized as a stack of layers, with each layer providing specific functionality. For example, software architecture 402 includes layers such as operating system 404, library 406, framework 408, and application 410. Optionally, application 410 invokes API calls 412 through the software stack and receives messages 414 in response to API calls 412, according to some embodiments.

[0142] In various implementations, operating system 404 manages hardware resources and provides common services. Operating system 404 includes, for example, kernel 420, services 422, and drivers 424. Kernel 420, according to some embodiments, acts as an abstraction layer between the hardware and other software layers. For example, kernel 420 provides memory management, processor management (e.g., scheduling), component management, networking, and security configuration, among other functionality. Services 422 may provide other common services to other software layers. Drivers 424, according to some embodiments, are responsible for controlling or interacting with the underlying hardware. For example, drivers 424 may include a display driver, a camera driver, a BLUETOOTH® or BLUETOOTH® Low-Energy driver, a flash memory driver, a serial communications driver (e.g., a Universal Serial Bus (USB) driver), a Wi-Fi® driver, an audio driver, a power management driver, etc.

[0143] In some embodiments, libraries 406 provide a low-level common infrastructure utilized by applications 410. Libraries 406 may include system libraries 430 (e.g., the C standard library), which may provide functions such as memory allocation functions, string manipulation functions, mathematical functions, etc. Additionally, libraries 406 may include API libraries 432, such as media libraries (e.g., libraries for supporting the presentation and manipulation of various media formats, such as Moving Picture Expert Group 4 (MPEG4), Advanced Video Coding (H.264 or AVC), Moving Picture Expert Group Layer 3 (MP3), Advanced Audio Coding (AAC), Adaptive Multi-Rate (AMR) audio codec, Joint Photographic Expert Group (JPEG or JPG), or Portable Network Graphics (PNG)), graphics libraries (e.g., an OpenGL framework used for rendering in 2D and 3D within a graphics context on a display), database libraries (e.g., SQLite for providing various relational database functions), web libraries (e.g., WebKit for providing web browsing functionality), etc. The library 406 may include a wide variety of other libraries 434 for providing many other APIs to the application 410 .

[0144] Framework 408, according to some embodiments, provides a high-level common infrastructure that applications 410 can utilize. For example, framework 408 provides various graphical user interface (GUI) functionality, high-level resource management, high-level location services, etc. Framework 408 may provide a wide spectrum of other APIs that applications 410 can utilize, some of which may be specific to a particular operating system 404 or platform.

[0145] In one exemplary embodiment, applications 410 include a wide variety of other applications, such as a home application 450, a contacts application 452, a browser application 454, a book reader application 456, a location application 458, a media application 460, a messaging application 462, a game application 464, and third-party applications 466. According to some embodiments, applications 410 are programs that perform functions defined therein. Various programming languages ​​may be employed to create one or more of applications 410, structured in various ways, such as object-oriented programming languages ​​(e.g., Objective-C, Java, or C++) or procedural programming languages ​​(e.g., C or assembly language). In particular examples, third-party applications 466 (e.g., applications developed using the ANDROID® or IOS™ Software Development Kit (SDK) by entities other than the particular platform vendor) may be mobile software that runs on a mobile operating system, such as IOS™, ANDROID®, WINDOWS® Phone, or another mobile operating system. In this example, the third party application 466 can invoke API calls 412 provided by the operating system 404 to facilitate the functionality described herein.

[0146] FIG. 5 shows a diagrammatic representation of a machine 500 in the form of a computer system within which a set of instructions may be executed to cause the machine 500 to perform any one or more of the methodologies discussed herein, according to one exemplary embodiment. Specifically, FIG. 5 shows a diagrammatic representation of a machine 500 in the exemplary form of a computer system within which instructions 516 (e.g., software, programs, applications, applets, apps, or other executable code) may be executed to cause the machine 500 to perform any one or more of the methodologies discussed herein. For example, the instructions 516 may cause the machine 500 to perform the method of FIG. 4. Additionally, or alternatively, the instructions 516 may implement FIGS. 1-4, etc. The instructions 516 transform a general, non-programmable machine 500 into a specific machine 500 programmed to perform the described and illustrated functions in the described manner. In alternative embodiments, the machine 500 may operate as a standalone device or be coupled (e.g., networked) to other machines. In a networked deployment, machine 500 may operate in the capacity of a server machine or a client machine in a server-client network environment, or as a peer machine in a peer-to-peer (or distributed) network environment. Machine 500 may include, but is not limited to, a server computer, a client computer, a personal computer (PC), a tablet computer, a laptop computer, a netbook, a set-top box (STB), a personal digital assistant (PDA), an entertainment media system, a cellular phone, a smartphone, a mobile device, a wearable device (e.g., a smart watch), a smart home device (e.g., a smart appliance), other smart devices, a web appliance, a network router, a network switch, a network bridge, or any machine capable of executing, serially or otherwise, instructions 516 that specify activities performed by machine 500.Additionally, although only a single machine 500 is shown, the term "machine" should still be understood to include a collection of machines 500 that individually or together execute instructions 516 to perform any one or more of the methodologies discussed herein.

[0147] Machine 500 may include a processor 510, a memory 530, and I / O components 550, which may be configured to communicate with one another, such as via a bus 502. In one exemplary embodiment, processor 510 (e.g., a central processing unit (CPU), a reduced instruction set computer (RISC) processor, a complex instruction set computer (CISC) processor, a graphics processing unit (GPU), a digital signal processor (DSP), an application specific integrated circuit (ASIC), a radio frequency integrated circuit (RFIC), another processor, or any suitable combination thereof) may include, for example, processor 512 and processor 514, which may execute instructions 516. The term “processor” is intended to include multi-core processors, which may include two or more independent processors (sometimes referred to as “cores”) that may execute instructions 516 simultaneously. Although FIG. 5 shows multiple processors 510, the machine 500 may include a single processor 512 with a single core, a single processor 512 with multiple cores (e.g., a multi-core processor 512), multiple processors 512, 514 with a single core, multiple processors 512, 514 with multiple cores, or some combination thereof.

[0148] Memory 530 may include a main memory 532, a static memory 534, and a storage device 536, each accessible to processor 510, such as via bus 502. Main memory 532, static memory 534, and storage device 536 store instructions 516 that implement any one or more of the methodologies or functions described herein. The instructions 516 may reside, completely or partially, within main memory 532, within static memory 534, within storage device 536, within at least one of processors 510 (e.g., within a processor's cache memory), or within any suitable combination thereof during their execution by machine 500.

[0149] The I / O components 550 may include a wide variety of components for receiving input, providing output, generating output, transmitting information, exchanging information, capturing measurements, etc. The specific I / O components 550 included within a particular machine will depend on the type of machine. For example, a portable machine such as a mobile phone will likely include a touch input device or other such input mechanism, while a headless server machine will likely not include such a touch input device. It will be appreciated that the I / O components 550 may include many other components not shown in FIG. 5 . The I / O components 550 are grouped according to functionality solely to simplify the following discussion, and this grouping is in no way limiting. In various exemplary embodiments, the I / O components 550 may include output components 552 and input components 554. Output components 552 may include visual components (e.g., a plasma display panel (PDP), a light-emitting diode (LED) display, a liquid crystal display (LCD), a projector, or a cathode ray tube (CRT)), acoustic components (e.g., speakers), haptic components (e.g., vibration motors, resistive mechanisms), other signal generators, etc. Input components 554 may include alphanumeric input components (e.g., a keyboard, a touchscreen configured to receive alphanumeric input, a photo-optical keyboard, or other alphanumeric input component), point-based input components (e.g., a mouse, touchpad, trackball, joystick, motion sensor, or another pointing instrument), tactile input components (e.g., physical buttons, a touchscreen that provides the location and / or force of a contact or contact gesture, or other tactile input component), audio input components (e.g., a microphone), etc.

[0150] In further exemplary embodiments, I / O components 550 may include biometric components 556, motion components 558, environmental components 560, or position components 562, among other components. For example, biometric components 556 may include components for detecting expressions (e.g., hand expressions, facial expressions, voice expressions, body gestures, or eye movements), measuring biosignals (e.g., blood pressure, heart rate, body temperature, sweat, or brain waves), identifying people (e.g., voice identification, retinal identification, facial identification, fingerprint identification, or electroencephalogram-based identification), etc. Motion components 558 may include acceleration sensor components (e.g., accelerometers), gravity sensor components, rotation sensor components (e.g., gyroscopes), etc. The environmental components 560 may include, for example, a lighting sensor component (e.g., a photometer), a temperature sensor component (e.g., one or more thermometers that detect ambient temperature), a humidity sensor component, a pressure sensor component (e.g., a barometer), an acoustic sensor component (e.g., one or more microphones that detect background noise), a proximity sensor component (e.g., an infrared sensor that detects nearby objects), a gas sensor (e.g., a gas detection sensor for detecting concentrations of harmful gases for safety purposes or for measuring pollutants in the air), or other components that may provide indications, measurements, or signals corresponding to the surrounding physical environment. The position components 562 may include a location sensor component (e.g., a global positioning system (GPS) receiver component), an altitude sensor component (e.g., an altimeter or a barometer that detects air pressure, which may be a derivative of altitude), an orientation sensor component (e.g., a magnetometer), etc.

[0151] Communications may be implemented using a wide variety of technologies. I / O component 550 may include a communications component 564 operable to couple machine 500 to network 580 or device 570 via coupling 582 and coupling 572, respectively. For example, communications component 564 may include a network interface component or another suitable device for interfacing with network 580. In further examples, communications component 564 may include a wired communications component, a wireless communications component, a cellular communications component, a near-field communication (NFC) component, a Bluetooth® component (e.g., Bluetooth® Low Energy), a Wi-Fi® component, and other communications components for providing communications via other modalities. Device 570 may be another machine or any of a wide variety of peripheral devices (e.g., coupled via USB).

[0152] Moreover, the communication component 564 may detect an identifier or may include a component operable to detect an identifier. For example, the communication component 564 may include a radio frequency identification (RFID) tag reader component, an NFC smart tag detection component, an optical reader component (e.g., an optical sensor for detecting one-dimensional barcodes such as the Universal Product Code (UPC) barcode, multidimensional barcodes such as QR Code, Aztec Code, Data Matrix, Dataglyph, MaxiCode, PDF417, UltraCode, UCC RSS-2D barcode, and other optical codes), or an acoustic detection component (e.g., a microphone for identifying tagged audio signals). Additionally, various information may be derived via the communication component 564, such as location via Internet Protocol (IP) geolocation, location via Wi-Fi signal triangulation, location by detection of NFC beacon signals that may indicate a particular location, etc.

[0153] Various memories (i.e., 530, 532, 534, and / or memory of processor 510) and / or storage device 536 may store one or more sets of instructions 516 and data structures (e.g., software) that perform or are utilized by any one or more of the methodologies or functions described herein. These instructions (e.g., instructions 516), when executed by processor 510, cause various operations to implement the disclosed embodiments.

[0154] As used herein, the terms “mechanical storage medium,” “device storage medium,” and “computer storage medium” mean the same thing and may be used interchangeably. These terms refer to single or multiple storage devices and / or media (e.g., central or distributed databases, and / or associated caches and servers) that store executable instructions and / or data. These terms should therefore be understood to include optical and magnetic media, including, but not limited to, solid-state memory and memory internal or external to a processor. Specific examples of mechanical storage media, computer storage media, and / or device storage media include, by way of example, semiconductor memory devices, e.g., non-volatile memory including erasable programmable read-only memory (EPROM), electrically erasable programmable read-only memory (EEPROM), field programmable gate arrays (FPGA), and flash memory devices; magnetic disks, such as internal hard disks and removable disks; magneto-optical disks; and CD-ROM and DVD-ROM disks. The terms "machine storage medium," "computer storage medium," and "device storage medium" specifically exclude carrier waves, modulated data signals, and other such media, at least some of which fall under the scope of the term "signal media," discussed below.

[0155] In various exemplary embodiments, one or more portions of network 580 may be an ad-hoc network, an intranet, an extranet, a virtual private network (VPN), a local area network (LAN), a wireless LAN (WLAN), a wide area network (WAN), a wireless WAN (WWAN), a metropolitan area network (MAN), the Internet, a portion of the Internet, a portion of the public switched telephone network (PSTN), a plain old telephone service (POTS) network, a cellular telephone network, a wireless network, a Wi-Fi network, another type of network, or a combination of two or more such networks. For example, network 580 or a portion of network 580 may include a wireless or cellular network, and coupling 582 may be a code division multiple access (CDMA) connection, a global system for mobile communications (GSM) connection, or another type of cellular or wireless coupling. In this example, the coupling 582 may implement any of various types of data transfer technologies, such as single carrier radio transmission technology (1xRTT), Evolution Data Optimized (EVDO) technology, General Packet Radio Service (GPRS) technology, Enhanced Data Rates for GSM Evolution (EDGE) technology, Third Generation Partnership Project (3GPP) including 3G, Fourth Generation Wireless (4G) networks, Universal Mobile Telecommunications System (UMTS), High Speed ​​Data Packet Access (HSPA), Worldwide Interoperability for Microwave Access (WiMAX), Long Term Evolution (LTE) standards, other technologies defined by various standards-setting organizations, other long-range protocols, or other data transfer technologies.

[0156] The instructions 516 may be transmitted or received over the network 580 using a transmission medium via a network interface device (e.g., a network interface component included in the communications component 564) and utilizing any one of several well-known transfer protocols (e.g., Hypertext Transfer Protocol (HTTP)). Similarly, the instructions 516 may be transmitted or received using a transmission medium via a connection 572 (e.g., a peer-to-peer connection) to the device 570. The terms “transmission medium” and “signal medium” mean the same thing and may be used interchangeably in this disclosure. The terms “transmission medium” and “signal medium” should be understood to include any intangible medium capable of storing, encoding, or carrying instructions 516 for execution by the machine 500, including digital or analog communications signals or other intangible media for facilitating the communication of such software. Accordingly, the terms “transmission medium” and “signal medium” should be understood to include any form of modulated data signal, carrier wave, or the like. The term “modulated data signal” means a signal that has one or more of its characteristics set or changed in such a manner as to encode information in the signal.

[0157] The terms "machine-readable medium," "computer-readable medium," and "device-readable medium" mean the same thing and may be used interchangeably in this disclosure. These terms are defined to include both mechanical storage media and transmission media. Thus, these terms include both storage devices / media and carrier / modulated data signals. [Explanation of symbols]

[0158] 100 systems 102 Application Server 104 Organizational Data Collections 106 Machine Learning Components 108 Deep Neural Networks 110 training data 112 Field Grouper 120A Neural Network 120B Neural Network 120C Neural Network 122 Sequence Processor 124 Inter-sequence Modules 126 Decomposable Attention and Aggregation Components 128 Final Classifier Module 130 Integrated Use Module 200 text-like fields 202 First Sequence 204 Second Sequence 206 Embed 208 Embed 210 Queue 212 k'-dimensional vector, vector 300 ways 400 Block Diagram 402 Software Architecture 404 Operating System 406 Library 408 Framework 410 Application 412 API call 414 Message 420 kernel 422 Service 424 Driver 432 API Library 434 Other Libraries 450 Home Applications 452 Contact Application 454 Browser Application 456 Book Reader Application 458 Location Applications 460 Media Applications 462 messaging applications 464 Game Applications 466 Third Party Applications 500 machines, non-programmable machines 502 Bus 510 processor 512 processors 514 processor 516 Command 530 memory 532 Main memory, memory 534 Static Memory, Memory 536 Storage device 550 Input / Output (I / O) Components 552 Output Components 554 Input Component 556 Biometric Components 558 Movement Components 560 Environment Components 562 Position component 564 Communication Components 570 devices 572 Combine 580 Network 582 Combine

Claims

1. 1. A system comprising: at least one hardware processor; a non-transitory computer-readable medium storing instructions; wherein the instructions, when executed by the at least one hardware processor, cause the at least one hardware processor to: Retrieving a first entity in a first table, the first entity including values ​​for a plurality of fields; tokenizing the values ​​in one or more fields of the plurality of fields into one or more tokens; passing each of the one or more tokens to an embedding machine learning model trained by a first machine learning algorithm to generate a set of coordinates in n-dimensional space for the input, yielding an embedding with coordinates for each of the one or more tokens; concatenating the embeddings for the one or more tokens and for each of the one or more fields of the plurality of fields in the first entity into a first matrix; constructing an origin field sequence for the first entity, the origin field sequence including, for each of the one or more tokens for each of the one or more fields of the plurality of fields in the first entity, an identification of a field corresponding to the value from which the token was generated; passing each value in the sequence of origin fields to the embedded machine learning model to generate a set of coordinates for each value in the sequence of origin fields; concatenating the embeddings for each value in the source field sequence into a second matrix; stacking the first matrix and the second matrix to create a third matrix; passing the third matrix to a decomposable attention neural network to compare the first entity with a second entity represented by a matrix of its own embedding; Execute an operation including the operations further include dividing the plurality of fields in the first entity into three field categories: text-based fields, categorical fields, and numeric / date fields, wherein the one or more fields of the plurality of fields are the text-based fields; The system, wherein the operations further include passing the values ​​of the categorical field to a second embedded machine learning model followed by a first feedforward neural network.

2. The operation is Retrieving a second entity in a second table, the second entity including values ​​for a plurality of fields; tokenizing the value in each of one or more fields of the plurality of fields in the second entity into one or more tokens; passing each of the one or more tokens to the embedding machine learning model to generate an embedding comprising a set of coordinates for each of the one or more tokens of the second entity; concatenating the embeddings for each of the one or more tokens and for each of the one or more fields of the plurality of fields in the second entity into a fourth matrix; constructing an origin field sequence for the second entity, the origin field sequence including, for each of the one or more tokens for each of the one or more fields of the plurality of fields in the second entity, an identification of a field corresponding to the value from which the token was generated; passing each value in the sequence of provenance fields for the second entity to the embedded machine learning model to generate a set of coordinates for each value in the sequence of provenance fields for the second entity; concatenating the embeddings for each value in the origin field sequence for the second entity into a fifth matrix; stacking the fourth matrix and the fifth matrix to create a sixth matrix, wherein the sixth matrix is ​​compared to the third matrix by the decomposable attention neural network; and The system of claim 1 further comprising:

3. 3. The system of claim 2, wherein the operations further include passing an output of the decomposable attention neural network to a classifier module, the classifier module comprising a dense neural network with multi-class outputs.

4. The system of claim 3 , wherein the multi-class output includes separate classes for matches, partial matches, and mismatches.

5. 10. The system of claim 1, wherein the operations further comprise normalizing values ​​in the numeric / date field and passing the normalized values ​​to a second feedforward neural network.

6. A method executed by a system, comprising: retrieving a first entity in a first table, the first entity including values ​​for a plurality of fields; tokenizing the values ​​in one or more fields of the plurality of fields into one or more tokens; passing each of the one or more tokens to an embedding machine learning model trained by a first machine learning algorithm to generate a set of coordinates in n-dimensional space for the input, yielding an embedding with coordinates for each of the one or more tokens; concatenating the embeddings for the one or more tokens and for each of the one or more fields of the plurality of fields in the first entity into a first matrix; constructing an origin field sequence for the first entity, the origin field sequence including, for each of the one or more tokens for each of the one or more fields of the plurality of fields in the first entity, an identification of a field corresponding to the value from which the token was generated; passing each value in the sequence of origin fields to the embedded machine learning model to generate a set of coordinates for each value in the sequence of origin fields; concatenating the embeddings for each value in the source field sequence into a second matrix; stacking the first matrix and the second matrix to create a third matrix; passing the third matrix to a decomposable attention neural network to compare the first entity with a second entity represented by a matrix of unique embeddings; Including, The method is dividing the plurality of fields in the first entity into three field categories: text-based fields, categorical fields, and numeric / date fields, wherein the one or more fields of the plurality of fields are the text-based fields; and passing the values ​​of the categorical field to a second embedded machine learning model followed by a first feedforward neural network.

7. retrieving a second entity in a second table, the second entity including values ​​for a plurality of fields; tokenizing the value in each of one or more fields of the plurality of fields in the second entity into one or more tokens; passing each of the one or more tokens to the embedding machine learning model to generate an embedding comprising a set of coordinates for each of the one or more tokens of the second entity; concatenating the embeddings for each of the one or more tokens and for each of the one or more fields of the plurality of fields in the second entity into a fourth matrix; constructing an origin field sequence for the second entity, the origin field sequence including, for each of the one or more tokens for each of the one or more fields of the plurality of fields in the second entity, an identification of a field corresponding to the value from which the token was generated; passing each value in the sequence of provenance fields for the second entity to the embedded machine learning model to generate a set of coordinates for each value in the sequence of provenance fields for the second entity; concatenating the embeddings for each value in the sequence of origin fields for the second entity into a fifth matrix; stacking the fourth matrix and the fifth matrix to create a sixth matrix, wherein the sixth matrix is ​​compared to the third matrix by the decomposable attention neural network; and 7. The method of claim 6, further comprising:

8. 8. The method of claim 7, further comprising passing an output of the decomposable attention neural network to a classifier module, the classifier module comprising a dense neural network with multi-class outputs.

9. The method of claim 8 , wherein the multi-class output includes separate classes for matches, partial matches, and mismatches.

10. 7. The method of claim 6, further comprising normalizing values ​​in the numeric / date field and passing the normalized values ​​to a second feedforward neural network.

11. A non-transitory machine-readable medium having stored thereon instructions that, when executed by one or more processors, cause the one or more processors to: Retrieving a first entity in a first table, the first entity including values ​​for a plurality of fields; tokenizing the values ​​in one or more fields of the plurality of fields into one or more tokens; passing each of the one or more tokens to an embedding machine learning model trained by a first machine learning algorithm to generate a set of coordinates in n-dimensional space for the input, yielding an embedding with coordinates for each of the one or more tokens; concatenating the embeddings for the one or more tokens and for each of the one or more fields of the plurality of fields in the first entity into a first matrix; constructing an origin field sequence for the first entity, the origin field sequence including, for each of the one or more tokens for each of the one or more fields of the plurality of fields in the first entity, an identification of a field corresponding to the value from which the token was generated; passing each value in the sequence of origin fields to the embedded machine learning model to generate a set of coordinates for each value in the sequence of origin fields; concatenating the embeddings for each value in the source field sequence into a second matrix; stacking the first matrix and the second matrix to create a third matrix; passing the third matrix to a decomposable attention neural network to compare the first entity with a second entity represented by a matrix of its own embedding; Execute an operation including the operations further include dividing the plurality of fields in the first entity into three field categories: text-based fields, categorical fields, and numeric / date fields, wherein the one or more fields of the plurality of fields are the text-based fields; the operations further include passing the values ​​of the categorical field to a second embedded machine learning model followed by a first feedforward neural network.

12. The operation is Retrieving a second entity in a second table, the second entity including values ​​for a plurality of fields; tokenizing the value in each of one or more fields of the plurality of fields in the second entity into one or more tokens; passing each of the one or more tokens to the embedding machine learning model to generate an embedding comprising a set of coordinates for each of the one or more tokens of the second entity; concatenating the embeddings for each of the one or more tokens and for each of the one or more fields of the plurality of fields in the second entity into a fourth matrix; constructing an origin field sequence for the second entity, the origin field sequence including, for each of the one or more tokens for each of the one or more fields of the plurality of fields in the second entity, an identification of a field corresponding to the value from which the token was generated; passing each value in the sequence of provenance fields for the second entity to the embedded machine learning model to generate a set of coordinates for each value in the sequence of provenance fields for the second entity; concatenating the embeddings for each value in the origin field sequence for the second entity into a fifth matrix; stacking the fourth matrix and the fifth matrix to create a sixth matrix, wherein the sixth matrix is ​​compared to the third matrix by the decomposable attention neural network; and 12. The non-transitory machine-readable medium of claim 11, further comprising:

13. 13. The non-transitory machine-readable medium of claim 12, wherein the operations further comprise passing an output of the decomposable attention neural network to a classifier module, the classifier module comprising a dense neural network with multi-class outputs.

14. 14. The non-transitory machine-readable medium of claim 13, wherein the multi-class output includes separate classes for matches, partial matches, and mismatches.

Images