Vector embedding model of relation tables with invalid or equivalent values

Abstract

Natural language processing techniques are used to process structured and semi-structured databases and documents to fill invalid value tokens into database records from other records that have non-invalid values ​​for the same attribute. Vector embedding techniques are used, including appropriately labeling invalid value tokens in some cases to reduce or eliminate their undue influence on semantic vectors generated using neural networks.

Description

Background Technology

[0001] This invention relates generally to databases, and more specifically to semantic-based queries using embedded vector representations.

[0002] A computer database is a dataset stored on a computer in a structured or semi-structured format. Database models for data storage organize large amounts of data in a way that allows for efficient access, management, and updating.

[0003] One type of computer database is the relational database, which provides certain relationships between data to improve speed and efficiency compared to regular databases. Relational databases are typically structured as one or more tables with rows and columns. Rows are defined as tuples that track entities of interest, and columns are defined as attributes of those entities. For example, rows or tuples might correspond to employees, patients, physical assets, locations, or other entities. Each column or attribute defines an aspect of the entity represented in the relational database.

[0004] Query languages ​​can be used to manage data in relational databases. Managing data can include storing information in or retrieving information from a relational database, or otherwise manipulating the relational database (e.g., via classification, updating, comparison, and other operations). An example of a query language is Structured Query Language (SQL). Summary of the Invention

[0005] Embodiments of the present invention provide methods, computer program products, and systems for processing records in structured or semi-structured databases.

[0006] According to an embodiment of the present invention, the method imputes a non-invalid value of a second token in a second database record with an invalid value of a first token in a first database record.

[0007] According to relevant embodiments, the method replaces the invalid value of the first token with the non-invalid value of the second token.

[0008] According to relevant embodiments, in response to determining that the second record is similar to the first record, a filling operation is performed.

[0009] According to relevant embodiments, the method determines that the second record is similar to the first record based on comparing the semantic vector of the token in the first database record with the semantic vector of the token in the second database record.

[0010] According to relevant embodiments, a vector embedding model is used to generate semantic vectors for the first and second database records.

[0011] According to relevant embodiments, the vector embedding model includes a neural network trained using training data.

[0012] According to relevant embodiments, the training data includes database records that are appended with row identifier labels or invalid value labels or both.

[0013] According to relevant embodiments, invalid values ​​for a token include:

[0014] Null value;

[0015] Missing values;

[0016] Placeholder value;

[0017] Predefined value; or

[0018] default value,

[0019] An invalid value indicates that specific attribute information for a given token is missing.

[0020] According to relevant embodiments, the method generates a semantic vector for the first token based on determining that the first token has an invalid value and queries an embedding database to find one or more records similar to the first token. The second token in the second database record is selected from one or more similar records.

[0021] According to one embodiment of the present invention, a computer system for processing records of a structured or semi-structured database includes one or more processors; one or more tangible storage media storing one or more programming instructions for execution by the one or more processors to perform a method, the programming instructions including instructions for performing steps of the method described above.

[0022] According to one embodiment of the present invention, a computer program product for processing records in a structured or semi-structured database includes one or more tangible storage media storing programming instructions for execution by one or more processors to perform a method. The programming instructions include instructions for performing the described method.

[0023] According to one embodiment of the present invention, a method for reducing or eliminating the impact of invalid value tokens in records of a structured or semi-structured database includes labeling one or more invalid value tokens in records of a structured or semi-structured database with tags representing invalid values; and generating semantic vectors for non-invalid value tokens using only non-invalid value neighbor tokens.

[0024] According to relevant embodiments, this method finds similar records for a given record based on the semantic vector generated by the query.

[0025] According to relevant embodiments, invalid values ​​for a token include:

[0026] Null value;

[0027] Missing values;

[0028] Placeholder value;

[0029] Predefined value; or

[0030] default value,

[0031] An invalid value indicates that specific attribute information for a given token is missing.

[0032] According to yet another embodiment of the present invention, a computer system and a computer program product are provided for executing programming instructions to perform the steps of the above methods. Attached Figure Description

[0033] Embodiments of the invention will now be described by way of example only with reference to the accompanying drawings, in which:

[0034] Figure 1 This is a functional block diagram of an illustrative computing environment 100 for generating vector embeddings according to an embodiment of the present invention.

[0035] Figure 2 According to an embodiment of the present invention Figure 1 An illustrative example of 108 entries in the database.

[0036] Figure 3 This is an embodiment of the present invention. Figure 1 An illustrative example of the training database 110.

[0037] Figure 4 This is an embodiment of the present invention. Figure 1 An illustrative example of an embedded database 112.

[0038] Figure 5 This is a use according to an embodiment of the present invention. Figure 1 An illustrative example of query 502 in embedded database 112.

[0039] Figure 6 This is for generating using records from database 108 according to an embodiment of the present invention. Figure 1 The training database 110 records of the illustrative method 600.

[0040] Figure 7 This is according to an embodiment of the invention for generating using records from training database 110. Figure 1 An illustrative flowchart of the method 700 for embedding records in database 112.

[0041] Figure 8 This is an embodiment of the invention for querying records using embedded database 112. Figure 1An illustrative flowchart of the method for recording 108 records in the database 800.

[0042] Figure 9 This is an illustrative flowchart of a method 900 for inputting invalid value tokens into a database 108 according to an embodiment of the present invention.

[0043] Figure 10 This is an illustrative flowchart of a method 1000 for reducing or eliminating the inappropriate influence of invalid values ​​on semantic vectors according to an embodiment of the present invention.

[0044] Figure 11 This is a block diagram illustrating a cloud computing node according to an embodiment of the present invention.

[0045] Figure 12 It includes embodiments of the present invention. Figure 11 A block diagram of the cloud computing environment of the cloud computing nodes.

[0046] Figure 13 This is an embodiment of the present invention. Figure 12 A block diagram of the functional layers of a cloud computing environment. Detailed Implementation

[0047] It should be noted that although some embodiments of the invention have been described in conjunction with relational databases, the inventive concepts disclosed herein can be applied to other databases and other information types, such as Multidimensional Online Analytical Processing (MOLAP), JavaScript Object Notation (JSON), Extensible Markup Language (XML), Comma Separated Values ​​(CSV) files, spreadsheets, Resource Description Framework (RDF) documents, and multimodal databases (e.g., images and text), to name just a few.

[0048] An example of a relational database is a table that stores information about people. Each table tuple or row can correspond to a person, and each table column can correspond to an attribute (such as a person's name, contact information, demographic information, and other information).

[0049] According to embodiments of the present invention, an interesting task in managing relational databases is to perform data imputation to construct, complete, or correct records stored in the database, including records with invalid values. Data imputation can be performed by identifying one or more similar records (e.g., within the same database) whose attributes can be filled with invalid values ​​relative to a given record (having one or more invalid values); that is, the process of inferring and filling invalid values ​​based on attributes of other records considered similar to a given record. The task of data imputation is a technical and significant (non-trivial) computational challenge.

[0050] According to embodiments of the invention, another task of interest in managing relational databases is determining the similarity between different records (rows or tuples) in the relational database or between different records in two relational databases. Correctly finding similar records enables appropriate data imputation. In the example given above, the task of interest could be to find the other records most similar to a given record (e.g., a record of people) listed in the relational database. Determining the most similar record is a technical and significant computational challenge.

[0051] According to embodiments of the invention, another task of interest in managing relational databases is identifying, and removing, or merging duplicate records. For example, two records may exist in a relational database for the same person (e.g., records can be created by combining two different databases), but the records may not have the same information. Identifying duplicate records is a technical and significant computational challenge.

[0052] The following discussion illustrates these techniques and significant challenges, explains why existing techniques are limited in addressing them, and highlights the advantages of practicing embodiments of the present invention in addressing these challenges.

[0053] According to embodiments of the present invention, structured and semi-structured databases can be processed in a variety of ways.

[0054] In one example, the process includes: generating a set of token sequences for at least a portion of a database, wherein each token in the sequence represents a corresponding database entity of the database; assigning each token in the set of token sequences at least one corresponding vector from a set of vectors of the same dimension, wherein the at least one corresponding vector encodes a relationship between the database entity of the token and other database entities of other tokens in the set of token sequences; and extracting information from the database using a query language based at least in part on the relationships encoded by the assigned vectors.

[0055] In another example, the process is adapted to a relational database containing multiple data types. Non-text tokens in the relational database are converted into text form. The text is generated based on the relations of the tokens in the relational database. A set of pre-trained word vectors for this text is retrieved from an external database. This set of pre-trained word vectors is initialized for tokens common to both the relational and external databases. This set of pre-trained vectors is used to create a cognitive intelligent query represented as a Structured Query Language (SQL) query. The contents of the relational database are used for training, while simultaneously initializing this set of pre-trained word vectors for tokens common to both the relational and external databases. The first set of word vectors can be immutable or mutable, with updates controlled via parameters.

[0056] In another example, the process is adapted to a relational database containing image data types. At least one image identifier in the relational database is converted into token form. Text is generated based on the relationships between the tokens in the relational database. A set of word vectors is generated based on the text. Cognitive intelligent queries, expressed as Structured Query Language (SQL) queries, can apply the word vector set to the relational database. Image identifiers can be converted into token form by converting images into labels, by using a neural network classification model and replacing image identifiers with corresponding cluster identifiers, by binary comparison, or by using a user-specified similarity function. Image identifiers can be converted into multiple text forms using the above conversion methods.

[0057] In another example, the process is adapted to a relational database containing numeric data types. At least one numeric token in the relational database is converted into text form. The text is generated based on the relationships between the tokens in the relational database. A set of word vectors is generated based on the text. The set of word vectors can be used to apply cognitive intelligent queries, represented as Structured Query Language (SQL) queries, to the relational database. At least one numeric token in the relational database can be converted into a typed string including the header and numeric values ​​of the column in the relational database where the token appears. Converting at least one numeric token in the relational database may include: clustering the tokens in the column of the relational database using a clustering algorithm, and replacing each token in the column with a cluster identifier.

[0058] In yet another example, the process includes receiving a set of information by a processor system. The set of information includes private information and non-private information. The process also includes generating multiple vectors to represent the private and non-private information. These multiple vectors correspond to encoded representations of the private and non-private information. The process further includes publishing at least a portion of the set of information and the corresponding vectors.

[0059] As shown in the examples above, performing many tasks of interest or more generally managing or processing relational databases (and other data structures) involves vector embedding.

[0060] By definition, vector embedding is a technique for mapping words or phrases in a vocabulary to real-valued vectors. The benefit of using vector embedding is that it allows defining the semantic and / or syntactic meaning of tokens (words or phrases) in a way that can be systematically processed by a natural language processing system. In this technique, the vector representation of a word or phrase is influenced by the context of the token (i.e., its neighboring words or phrases). The span between neighboring words is a configurable parameter. A neural network (which can also be called a training model) can be trained using training data to generate semantic vectors by taking a string as its input and generating a vector representation of each token in that string. The string can be, for example, a sentence. One set of models used to generate vector embeddings using this technique is word2vec.

[0061] According to another definition, distributed language embeddings are vectors assigned to each word, term, concept, or more generally, data item, where these vectors indicate aspects of the associated word, including semantic “proximity.” The embodiments described herein can perform different operations on text entities in structured or semi-structured databases. The term “text entity” refers to some identifiable item (data) appearing in a database (or some external source), such as a word, number, or a meaningful short sequence such as “relativity.” A “word vector” is a vector representation of a word in a language. Methods used to obtain these vector representations range from “brute-force” learning using different types of neural networks to log-linear classifiers and various matrix formulas, such as matrix factorization techniques. For example, Word2vec generates vectors that capture the grammatical and semantic attributes of words. Word2vec scans a corpus (text) to generate a vector representation of each word in a document. Word vectors typically have low dimensionality (approximately 100-300) and represent the word. These vectors can be used to calculate the semantic and / or grammatical proximity of words, as well as for tests of analogy, such as calculating "What is the king to the man and the queen to the woman?" using vector algebra (answer: queen).

[0062] According to another definition, database entities (such as words, numbers, fields (columns), entire table rows (i.e., tuples), or even entire relations) are each associated with a vector that captures the relationships between the database entity and all other such entities. The proximity of such entities can be determined through simple vector operations. Furthermore, the learning (or training) of vectors can be achieved via machine learning (ML) techniques and can be performed on sequences of entities derived from the database itself. This provides two perceptions of the database: a typical relational perception and a textual perception. The textual perception of the database can be analyzed, and low-dimensional (e.g., 200) vector representations can be assigned to each token. According to some techniques, tokens that co-occur are often assigned vectors with relatively high cosine distances. Vectors can also be used to check analogies using simple vector operations. Tokens can be defined as sequences of “characters” without intermediate spaces. Each token represents a text entity, and entities are related to each other. This relationship can be represented numerically, for example, cos(e1, e2) > 0.5. Here, cos is the cosine distance between two vectors. This relationship can also be expressed linguistically on a scale, such as very strong, strong, moderate, weak, very weak, etc. The value of strong (e1, e2) allows for the definition of individual values; for example, very strong = 0.95. For instance, understanding the relationship between two text entities, "John" and "New York," involves deriving tokens for the text entities, such as v_John and v_New York, and performing algebraic operations on the two vectors, such as cosine distance. If the cosine distance between v_John and v_New York is high (i.e., closer to 1), the two text entities are closely related; if the cosine distance is low (i.e., closer to -1), the two entities are not closely related.

[0063] According to another definition, in vector embedding, the d-dimensional vector space is fixed. Each word in a text corpus (e.g., a collection of documents) is associated with a real vector of dimension d. Assigning words to vectors should such that the vectors encode the meaning of the word. Ideally, if two words are closely related (i.e., have similar meanings), then their vectors should point in similar directions. In other words, the cosine distance between their vectors should be relatively high. Closely related words are those that frequently appear together in the text corpus. By appearing together, we imply a very close range. Conversely, if words are unrelated, the cosine distance between their vectors should be relatively small. Some refinements to proximity calculations weight proximity and / or take into account grammatical rules.

[0064] Vectors can be generated by learning from the database itself or by using external text or vector sources. In the context of relational databases, one way to generate vectors is to apply vector embedding methods to a sequence of tokens generated from the database: each line corresponds to a sentence, and relations correspond to documents. Thus, vectors realize a dual view of the data: relations and (meaningful) text. Vector embedding can then extract latent semantic information in terms of word associations and co-occurrences, and encode this information in word vectors. Therefore, vectors capture first attribute-to-attribute and attribute-to-attribute relations within a line (sentence), and these relations are then aggregated across documents to compute set semantic relations. The encoded semantic information can then be used to query the database.

[0065] A common problem with the aforementioned functions and processes is that database records often contain invalid values. For the purposes of embodiments of the claimed invention, it will be apparent to those skilled in the art that, without departing from the spirit and scope of the claimed invention, the terms empty, invalid, missing, placeholder, or other predefined or default values ​​indicating a lack of specific attribute information for a given entity or record are envisioned. In the context of embodiments of the invention, the common functional definition of these terms is that, for a given record in the database, these values ​​do not represent the actual attributes of the entity corresponding to that record. Rather, these values ​​indicate the immediate unavailability of attribute information.

[0066] The above functionality can be performed better by using data imputation, which replaces invalid values ​​with actual values. Additionally, when performing data imputation or other data processing tasks, it may be desirable to minimize the inappropriate impact of invalid values.

[0067] More specifically, in the context of structured and semi-structured databases, semantic vectors are more useful when generated using the actual attributes of a record rather than invalid values. When actual attributes are unavailable in a given record (i.e., the values ​​are invalid), they can be filled in from other similar records by practicing embodiments of the claimed invention. Furthermore, semantic vectors can be made even more useful by minimizing the inappropriate effects of invalid values ​​(where these values ​​cannot be filled in from other records).

[0068] In short, the challenge arises from the presentation of invalid values ​​because in the vector embedding process applied to relational databases, each line can be treated as a sentence and can be provided as input to the process (e.g., to a neural network). Vectors can be generated for words or phrases in a line. However, the line can have many invalid values. The vector of a word is affected by invalid values ​​in its neighborhood and incorrectly looks similar to other tokens that have invalid values ​​in their neighborhood.

[0069] Therefore, there are at least two challenges in performing the tasks of interest discussed above: data imputation for a given invalid value in a given record (i.e., if an attribute value is invalid, which record is most similar to that attribute and from which to copy the attribute); and generating semantic vectors based on records with one or more invalid values. One object of at least one embodiment of the present invention is to address one or both of these challenges.

[0070] Regarding the first challenge: for a given invalid value in a given record, it is not easy to discern what other records are sufficiently similar to that given record and therefore suitable as a source for data imputation for that given invalid value. This is because, in the prior art, invalid values ​​do not have a corresponding semantic vector created for them, and because other invalid values ​​inappropriately affect the semantic vectors used for both the given invalid value and invalid values ​​in other records. The more invalid values ​​a record has, the more similar it appears to be to other records that have invalid values. However, this similarity is not meaningful, because two records are similar simply because they both have invalid values, not because they additionally convey information about the same entity (e.g., attributes).

[0071] Regarding the second challenge, the inappropriate impact of invalid values ​​in relational databases on the vector output of neural network training models occurs due to the fundamental assumption of this process; that is, words used in the same way and / or words with similar contexts may have similar meanings. This assumption is thought to produce a reliable assessment of semantic similarity in many use cases; however, it falls apart in many cases with relational databases containing invalid values, because many attributes are identified as similar simply because they are surrounded by the same invalid values.

[0072] Therefore, there is a need for inventive methods, systems, and computer program products that reliably fill in invalid values ​​in database records and generate vector embeddings free from the inappropriate or undue influence of invalid values. Thus, the aim of at least some embodiments of the disclosed invention is to provide one or more of these functionalities.

[0073] It will be clear to those skilled in the art that the disclosed invention is applicable not only to relational databases, but also to data imputation and vector embedding processes for data stored in any structure, where some data includes invalid values ​​that can be imputed from other records.

[0074] Embodiments of the invention will now be described in more detail with reference to the accompanying drawings.

[0075] Figure 1 This is a functional block diagram of an illustrative computing environment 100 for generating vector embeddings according to an embodiment of the present invention. See now. Figure 1The computing environment 100 includes a computer 102, and the general structure and components of the computer 102 may be a combination of the following. Figure 9 Those described.

[0076] Computer 102 includes processor 104, program 106, database 108, training database 110, and embedded database 112.

[0077] Processor 104 typically processes programming instructions of program 106 to execute one or more methods. Program 106 operates on data stored (or to be stored) in database 108, training database 110, and embedded database 112; each database stores one or more records, and each record corresponds to an entity, and each record has one or more attributes. Program 106 and the databases are stored on a tangible storage medium of computer 102. It will be apparent to those skilled in the art that, although in Figure 1 The invention describes a computer, a processor, a program (and some databases), but these components may be distributed across more than one computing device and may be provided via cloud computing or other distributed computing models without departing from the spirit or scope of the claimed invention.

[0078] More specifically, program 106 performs vector embedding functionality (such as combining...) Figure 2-4 (as described) and query functions (such as combining) Figure 5 (as described) etc.

[0079] Database 108 typically contains data on which various tasks of interest, as described above, are to be performed. For example, database 108 is a table whose rows represent people and whose columns represent attributes of those people. Some of these attributes may be missing in some rows (or may be marked as invalid values ​​(NULL), EMPTY, or other values). Instances of entries for database 108 are shown below. Figure 2 Provided by China.

[0080] Training database 110 typically includes data generated by program 106 to generate vector embeddings according to embodiments of the invention; such as those in embedding database 112.

[0081] The records stored in the embedded database 112 are typically data generated by the program 106 through processing the records in the training database 110 (in other words, the program 106 processes the training data to generate semantic vectors).

[0082] Figure 2 According to an embodiment of the present invention Figure 1An illustrative example of entries 200 in database 108. In the depicted example, database 108 is a comma-separated value (CSV) relational database, and its entries 200 include header rows corresponding to attributes of a person ( Figure 2 (not shown in the image) and one or more additional rows corresponding to the actual attributes of the record (not shown in the image) and the record corresponding to the actual attributes of the record holder. Figure 2 (As shown in the diagram). Records in database 108 may have incomplete, incorrect, or conflicting attribute information that inappropriately affects queries and other operations on the database, including the vector embedding process that will be performed on database 108. This is a problem.

[0083] In fact, entry 200 in the depicted example refers to the same fictional character, "JOSEPH ROBERTS". However, the records are not identical, as some records may contain incomplete, incorrect, or conflicting information.

[0084] In this example, the attributes of the first record are: unique ID information (e.g., “2e92d2e-761e-44ab-a3c3-4ef86a04300f, MDMPER, 60017,99310”), gender (e.g., “M” for male), date of birth (e.g., “28 / 8 / 1992”), Social Security number (e.g., “054-91-6381”), phone number (e.g., “929-914-1128”), address (e.g., “15 Charles ST, Port Washington, NY, 11050”), geographic coordinates (e.g., “11050, 40.754757-73.601772”), and other information. However, some of this information is missing from other records.

[0085] For example, note that the first entry (with record ID 99310) has the values ​​“M” and “JOSEPH” for the attributes gender and FNAME. However, the second, third, and fourth entries (record IDs 99311, 99312, and 99313, respectively) have null values ​​for both of these attributes.

[0086] Based on the above-mentioned task of interest, it is desirable to perform data imputation to find appropriate values ​​to replace these null values ​​by finding the most similar record that can have actual values ​​of one or more of these attributes.

[0087] As described more generally above, without processing according to embodiments of the claimed invention, the vector embeddings of data generated in database 108 have limited utility because they do not fill data gaps and because semantic vectors used for non-invalid data may be overly affected by invalid values.

[0088] Therefore, it is desirable to process the data in database 108 to fill data gaps (data imputation) and reduce or eliminate the inappropriate impact of invalid values ​​on the semantic vector of the data in database 108. Figure 6-9 The document provides at least some methods that demonstrate how to perform these functions. Figure 3 The document describes instances of training data generated and / or used by these methods.

[0089] Figure 3 According to an embodiment of the present invention Figure 1 An illustrative instance of the training database 110. By... Figure 6 Method 600 (as an example) is applied to entry 200 of database 108. Figure 2 This is used to generate 300 entries for the training database 110. Combined with... Figure 6 The process is described in detail. Here we can observe that the values ​​of entry 300 are labeled with their attributes: RECORDID (i.e., “Record ID”), SEX (or Gender), FNAME (First Name), LNAME (Last Name), DATE, SSN (Social Security Number), HPHONE (Home Phone Number), HSTREET (Home Street Address), HCITY (Home City), HSTATE (Home Status), HZIP (Home SIP Code), and DLSTATE (Driver's License Status).

[0090] It was observed that for the second entry in the set of 300 entries, the FNAME field was empty (in Figure 2 In entry 200, the entry is represented as “…M”, ROBERTS…, where there is no value between “M” and “ROBERTS”.

[0091] It was also observed that the “EMPTY” label appeared in each of the 300 entries with missing information. This is an example of invalid gaps in the data that can be filled using data imputation, and an example of invalid values ​​that could inappropriately affect the semantic vector if left unfilled. If a multidimensional vector is generated based on shared neighbor tokens, entry 300 will produce a high false positive rate (positive similarity) due to the EMPTY label. This is a problem.

[0092] Figure 4 According to an embodiment of the present invention Figure 1 An illustrative example of an embedded database 112. Figure 4 Depicting the use Figure 3 Example vector 400 is generated from entry 300. Semantic vector 400 is generated using embodiments of the present invention to fill data gaps and reduce or eliminate the inappropriate effects of invalid values.

[0093] Figure 5 This is a use according to an embodiment of the present invention. Figure 1 An illustrative example of query 502 in embedded database 112. In the depicted example, query 502 searches for the vector in embedded database 112 that is most similar to the vector with RECORDID 99728. In the depicted instance, result 504 shows that the record with RECORDID 99797 is most similar to RECORDID 99728.

[0094] By practicing embodiments of the present invention, the most similar record is correctly identified and serves as the source for data imputation. Furthermore, the impact of invalid values ​​is reduced or eliminated.

[0095] Figure 6 This is for use according to embodiments of the present invention. Figure 1 and 2 An illustrative method 600 for generating training database 110 from entries in database 108. See now. Figure 1 , 2 In step 6, the programming instructions of program 106 are executed by processor 104 to perform the steps of method 600. Method 600 can generally be used to create a training dataset (stored in training database 110) using database 108 with invalid values.

[0096] Program 106 identifies (step 602) the column attributes of database 108.

[0097] Procedure 106 uses a special label, such as “_EMPTY”, to add a / tag (step 604) invalid (missing, empty, default, placeholder, etc.) value in database 108.

[0098] Procedure 106 optionally or alternatively appends a row identifier (step 604a) to the attribute string. This allows embodiments of the invention to distinguish specific entries or cells in a table from other invalid value cells in a column by appending or assigning row identifiers to invalid values; otherwise, all invalid values ​​in a particular column might appear indistinguishable when performing certain processing steps. For example, for a given record being analyzed (whose invalid values ​​are to be replaced with data imputation), once similar rows are identified, we can use value-based voting (using only the most common values ​​from the candidate set) or other techniques (such as the average or median of the candidate values).

[0099] Procedure 106 stores the modified data (step 606) in the training database 110. This training data can then be used to perform data imputation.

[0100] Figure 7 It is based on an embodiment of the present invention for use in... Figure 6 The output of method 600 is generated using records from the training database 110. Figure 1The descriptive method 700 for the embedded database 112 records.

[0101] See now Figure 1 , 2 In steps 3, 6, and 7, the programming instructions of program 106 are executed by processor 104 to perform the steps of method 700. Method 700 can generally be used to construct semantic vectors of training data with “_EMPTY” (or equivalent labels) in training database 110; that is, data imputation.

[0102] Procedure 106 determines (step 702) that the token for which it is generating the semantic vector contains invalid values. The token is part of a "sentence" (e.g., a record or row in training database 110). Method 700 is expected to generate the semantic vector of the token as output.

[0103] For example, procedure 106 determines (step 702) that some entries 300 of the training database 110 contain the "_EMPTY" tag for the SEX_EMPTY and FNAME_EMPTY tokens (i.e., the second, third, and fourth entries). This determination (step 702) can be performed token-by-token; that is, when there are tokens to be processed (to generate semantic vectors), and for each such token, procedure 106 determines (step 702) whether the token has the "_EMPTY" tag.

[0104] Procedure 106 generates a semantic vector (step 704) for each token with the "_EMPTY" tag as determined above (step 702). A neural network can be used to perform the generation of the semantic vector.

[0105] Program 106 stores the generated semantic vector (step 704) in the embedded database 112 (step 706).

[0106] Figure 8 This is an embodiment of the invention for querying records using embedded database 112. Figure 1 An illustrative flowchart of the method for recording 108 records in the database 800.

[0107] See now Figure 1 , 2 In steps 3, 5, and 8, the programming instructions of program 106 are executed by processor 104 to perform the steps of method 800. Method 800 is generally operable to query for a given record in database 108 the most similar other record in database 108 (or another database). One purpose of executing method 800 is to perform the aforementioned task of interest. For example, method 800 can be executed to find the most similar other record in database 108 for a given record with an invalid value, whose non-invalid data can fill in the invalid data of the given record.

[0108] Therefore, program 106 identifies (step 802) records (or tokens within records) in database 108 that have invalid values. For example, program 106 will identify entry 200 ( Figure 2 The second entry in the dataset is identified as an invalid value with the attributes SEX and FNAME. Alternatively, program 106 can use entry 300 from training database 110. Figure 3 Perform the identification (step 802).

[0109] Based on the identified records, program 106 uses the record information of the identified records (step 802) to query (step 804) the embedded database 112. For example, program 106 uses SQL query 502 ( Figure 5 )Query (step 804) Embedded database 112.

[0110] Based on the query (step 804), program 106 receives (step 806) a list of records, which can be sorted according to their similarity to the records identified above (step 802). The sorted list can be, for example, result 504 ( Figure 5 ).

[0111] Figure 9 This is an illustrative flowchart of a method 900 for inputting invalid value tokens into a database 108 according to an embodiment of the present invention.

[0112] See now Figure 1 , 8 In step 9, the programming instructions of program 106 are executed by processor 104 to perform the steps of method 900. Method 900 can typically operate as estimating invalid data in records of database 108 by querying (method 800) the semantic vector embedded in database 112.

[0113] Therefore, procedure 106 can identify (step 902) attributes with invalid values ​​in the records of database 108. This identification can be performed by searching for null values ​​in the records of database 108 or by searching for the tag "_EMPTY" in training database 110 (step 902).

[0114] For a given token identified (step 902) as having an invalid value, program 106 identifies (step 904) the most similar record in database 108 that may contain the non-invalid attribute values ​​(e.g., the top K records with scores closest to the identified record) for the identified token (step 902). For example, program 106 may perform the identification of the most similar record (step 904) by executing method 800.

[0115] Based on the identification (step 904) of a token with a non-invalid value, program 106 fills the non-invalid value of the token identified above (step 904) into (step 906) a token with an invalid value that is identified (step 906) as needing data filling.

[0116] Figure 10 This is an illustrative flowchart of a method 1000 for reducing or eliminating the inappropriate influence of invalid values ​​on semantic vectors according to an embodiment of the present invention.

[0117] See now Figure 1 , 3 The programming instructions of program 106, and 10, are executed by processor 104 to perform the steps of method 1000. Method 1000 is generally operable to reduce or eliminate the inappropriate influence of invalid value tokens in the generation of semantic vectors.

[0118] Therefore, program 106 receives (step 1002) a record or token for processing (to generate a semantic vector). The program determines (step 1004) that the record or token contains an invalid value (e.g., it has the label "_EMPTY").

[0119] Based on this finding, procedure 106 prevents (step 1006) the use of the “_EMPTY” tag to build semantic vectors for entities or tokens in the neighborhood of the “_EMPTY” token. For example, relative to rows two, three, and four of entry 300 ( Figure 3 The vector representation of “LNAME_ROBERTS” will not use the values ​​“SEX_EMPTY” or “FNAME_EMPTY”, even if these values ​​appear in the context or neighborhood of “LNAME_ROBERTS”. Preventing the inappropriate influence of empty labels can be achieved in several ways, including, for example, by filtering invalid value tokens or adjusting the span of the context to exclude invalid value tokens. Another approach is described (along with the positive steps to be performed), in which procedure 106, for a given token, only feeds the neural network with neighboring tokens that are not labeled with invalid values ​​as input (step 1006).

[0120] Procedure 106 uses a neural network to generate (step 1008) a semantic vector for the token. The generated semantic vector (step 1008) is more useful when performing other tasks of interest because it is not overly affected (or less overly affected) by invalid values.

[0121] Figure 11 This is a block diagram illustrating a cloud computing node according to an embodiment of the present invention. Cloud computing node 10 is merely an example of a suitable cloud computing node and is not intended to impose any limitation on the use or scope of functionality of the embodiments of the invention described herein. In any case, cloud computing node 10 can be implemented and / or perform any of the functions set forth above.

[0122] Within cloud computing node 10, there exists a computer system / server 12 that can operate alongside many other general-purpose or special-purpose computing system environments or configurations. Examples of known computing systems, environments, and / or configurations that may be suitable for computer system / server 12 include, but are not limited to, personal computer systems, server computer systems, thin clients, thick clients, handheld or laptop devices, multiprocessor systems, microprocessor-based systems, set-top boxes, programmable consumer electronics, network PCs, minicomputer systems, mainframe computer systems, and distributed cloud computing environments that include any of the aforementioned systems or devices.

[0123] Computer system / server 12 can be described in the general context of computer system executable instructions (such as program modules) executed by the computer system. Generally, program modules may include routines, programs, objects, components, logic, data structures, etc., that perform specific tasks or implement specific abstract data types. Computer system / server 12 can be implemented in a distributed cloud computing environment, where tasks are performed by remote processing devices linked via a communication network. In a distributed cloud computing environment, program modules can reside in local and remote computer system storage media, including memory storage devices.

[0124] like Figure 11 As shown, the computer system / server 12 in cloud computing node 10 is illustrated in the form of a general-purpose computing device. The components of the computer system / server 12 may include, but are not limited to, one or more processors or processing units 16, system memory 28, and a bus 18 that couples the various system components, including the system memory 28, to the processor 16.

[0125] Bus 18 represents any one or more of several types of bus architectures, including memory buses or memory controllers, peripheral buses, accelerated graphics ports, and processor or local buses using any of the various bus architectures. By way of example and not limitation, such architectures include the Industry Standard Architecture (ISA) bus, the Micro Channel Architecture (MCA) bus, the Enhanced ISA (EISA) bus, the Video Electronics Standards Association (VESA) local bus, and the Peripheral Component Interconnect (PCI) bus.

[0126] Computer system / server 12 typically includes a variety of computer system readable media. Such media can be any available media that can be accessed by computer system / server 12, and includes volatile and non-volatile media, removable and non-removable media.

[0127] System memory 28 may include computer system readable media in the form of volatile memory, such as random access memory (RAM) 30 and / or cache memory 32. Computer system / server 12 may further include other removable / non-removable, volatile / non-volatile computer system storage media. By way of example only, storage system 34 may be provided for reading from and writing to non-removable, non-volatile magnetic media (not shown, and generally referred to as "hard disk drives"). Although not shown, disk drives for reading from or writing to removable non-volatile disks (e.g., "floppy disks") and optical disk drives for reading from or writing to removable non-volatile optical disks (e.g., CD-ROMs, DVD-ROMs, or other optical media) may be provided. In such cases, each may be connected to bus 18 via one or more data media interfaces. As will be further described and illustrated below, memory 28 may include at least one program product having a set (e.g., at least one) of program modules configured to perform embodiments of the invention.

[0128] A program / utility 40 having a set (at least one) of program modules 42, along with an operating system, one or more applications, other program modules, and program data, may be stored in memory 28 by way of example, not limitation. Each or some combination of the operating system, one or more applications, other program modules, and program data may include an implementation of a network environment. Program modules 42 typically perform functions and / or methods as described herein in embodiments of the invention.

[0129] Computer system / server 12 can also communicate with one or more external devices 14 (such as a keyboard, pointing device, display 24, etc.), and / or any device that enables computer system / server 12 to communicate with one or more other computing devices (e.g., network interface card, modem, etc.). This communication can be performed via input / output (I / O) interface 22. Furthermore, computer system / server 12 can communicate with one or more networks such as a local area network (LAN), a general wide area network (WAN), and / or a public network (e.g., the Internet) via network adapter 20. As shown, network adapter 20 communicates with other components of computer system / server 12 via bus 18. It should be understood that, although not shown, other hardware and / or software components can be used in conjunction with computer system / server 12. Examples include, but are not limited to: microcode, device drivers, redundant processing units, external disk drive arrays, RAID systems, tape drives, and data archiving storage systems.

[0130] Figure 12 It includes embodiments of the present invention. Figure 11A block diagram of the cloud computing environment for the cloud computing nodes. See now. Figure 4 The diagram illustrates an illustrative cloud computing environment 50. As shown, the cloud computing environment 50 includes one or more cloud computing nodes 10 to which local computing devices used by cloud consumers can communicate. These local computing devices include, for example, personal digital assistants (PDAs) or cellular phones 54A, desktop computers 54B, laptop computers 54C, and / or automotive computer systems 54N. The nodes 10 can communicate with each other. They can be physically or virtually grouped (not shown) in one or more networks, such as private clouds, community clouds, public clouds, or hybrid clouds, or combinations thereof, as described above. This allows the cloud computing environment 50 to provide infrastructure, platforms, and / or software as services that cloud consumers do not need to maintain on their local computing devices. It should be understood that... Figure 4 The types of computing devices 54A-N shown are intended to be illustrative only, and cloud computing node 10 and cloud computing environment 50 can communicate with any type of computerized device via any type of network and / or network-addressable connection (e.g., using a web browser).

[0131] Figure 13 This is an embodiment of the present invention. Figure 12 A block diagram of the functional layers of a cloud computing environment. See now. Figure 13 Figure 14 illustrates a set of functional abstraction layers provided by a cloud computing environment 50. It should be understood beforehand that the components, layers, and functions shown in Figure 14 are intended to be illustrative only, and embodiments of the invention are not limited thereto. As described, the following layers and corresponding functions are provided:

[0132] The hardware and software layer 60 includes hardware and software components. Examples of hardware components include: a mainframe 61; a RISC (Reduced Instruction Set Computer) based server 62; a server 63; a blade server 64; a storage device 65; and network and networking components 66. In some embodiments, software components include network application server software 67 and database software 68.

[0133] The virtualization layer 70 provides an abstraction layer from which the following examples of virtual entities can be provided: virtual server 71; virtual storage 72; virtual network 73, including virtual private network; virtual application and operating system 74; and virtual client 75.

[0134] In one example, management layer 80 may provide the following functionalities: Resource Provisioning 81 provides dynamic procurement of computing resources and other resources used to perform tasks within the cloud computing environment. Metering and Pricing 82 provides cost tracking as resources are utilized within the cloud computing environment and bills or invoices for the consumption of these resources. In one example, these resources may include application software licenses. Security provides authentication for cloud consumers and tasks, as well as protection for data and other resources. User Portal 83 provides access to the cloud computing environment for consumers and system administrators. Service Level Management 84 provides cloud resource allocation and management to ensure that required service levels are met. Service Level Agreement (SLA) Planning and Fulfillment 85 provides pre-scheduling and procurement of cloud resources based on anticipated future needs according to the SLA.

[0135] Workload layer 90 provides examples of functionalities that can leverage a cloud computing environment. Examples of workloads and functionalities that can be provided from this layer include: mapping and navigation 91; software development and lifecycle management 92; virtual classroom education delivery 93; data analytics and processing 94; transaction processing 95; and database management 96, including combinations thereof. Figure 1-10 Those described.

[0136] Computer-readable storage media can be tangible devices capable of retaining and storing instructions used by an instruction execution device. Computer-readable storage media can be, for example, but not limited to, electronic storage devices, magnetic storage devices, optical storage devices, electromagnetic storage devices, semiconductor storage devices, or any suitable combination of the foregoing. A non-exhaustive list of more specific examples of computer-readable storage media includes: portable computer disks, hard disks, random access memory (RAM), read-only memory (ROM), erasable programmable read-only memory (EPROM or flash memory), static random access memory (SRAM), portable compact disk read-only memory (CD-ROM), digital universal disk (DVD), memory sticks, floppy disks, mechanical encoding devices such as punch cards or protrusions in slots having instructions recorded thereon, and any suitable combination of the foregoing. As used herein, computer-readable storage media should not be construed as transient signals themselves, such as radio waves or other freely propagating electromagnetic waves, electromagnetic waves propagating through waveguides or other transmission media (e.g., light pulses passing through fiber optic cables), or electrical signals transmitted through wires.

[0137] The computer-readable program instructions described herein can be downloaded from a computer-readable storage medium to a corresponding computing / processing device or to an external computer or external storage device via a network (e.g., the Internet, a local area network, a wide area network, and / or a wireless network). The network may include copper transmission cables, optical transmission fibers, wireless transmissions, routers, firewalls, switches, gateway computers, and / or edge servers. A network adapter card or network interface in each computing / processing device receives the computer-readable program instructions from the network and forwards them to a computer-readable storage medium within the corresponding computing / processing device.

[0138] Computer-readable program instructions used to perform the operations of this invention may be assembly instructions, instruction set architecture (ISA) instructions, machine instructions, machine-dependent instructions, microcode, firmware instructions, state setting data, integrated circuit configuration data, or source code or object code written in any combination of one or more programming languages, including object-oriented programming languages ​​(such as Smalltalk, C++, etc.) and procedural programming languages ​​(such as the "C" programming language or similar programming languages). The computer-readable program instructions may be executed entirely on a user's computer, partially on a user's computer, as a standalone software package, partially on a user's computer and partially on a remote computer, or entirely on a remote computer or server. In the latter case, the remote computer may be connected to the user's computer via any type of network (including a local area network (LAN) or a wide area network (WAN)) or may be connected to an external computer (e.g., via the Internet using an Internet service provider). In some embodiments, electronic circuitry including, for example, programmable logic circuitry, field-programmable gate arrays (FPGAs), or programmable logic arrays (PLAs) may execute computer-readable program instructions by utilizing state information from the computer-readable program instructions to personalize the electronic circuitry in order to perform aspects of this invention.

[0139] This document describes aspects of the invention with reference to flowchart illustrations and / or block diagrams of methods, apparatus (systems), and computer program products according to embodiments of the invention. It should be understood that each block of the flowchart illustrations and / or block diagrams, and combinations of blocks in the flowchart illustrations and / or block diagrams, can be implemented by computer-readable program instructions.

[0140] These computer-readable program instructions may be provided to a processor of a general-purpose computer, a special-purpose computer, or other programmable data processing apparatus to produce a machine such that, when executed by the processor of the computer or other programmable data processing apparatus, the instructions create means for implementing the functions / actions specified in one or more blocks of a flowchart and / or block diagram. These computer-readable program instructions may also be stored in a computer-readable storage medium that causes a computer, programmable data processing apparatus, and / or other device to operate in a particular manner, wherein the computer-readable storage medium storing the instructions comprises an article of manufacture containing instructions that implement aspects of the functions / actions specified in one or more blocks of a flowchart and / or block diagram.

[0141] Computer-readable program instructions may also be loaded onto a computer, other programmable data processing apparatus, or other device to cause a series of operational steps to be performed on the computer, other programmable apparatus, or other device to produce a computer-implemented process, thereby causing the instructions to be executed on the computer, other programmable apparatus, or other device to perform the functions / actions specified in one or more blocks of a flowchart and / or block diagram.

[0142] The flowcharts and block diagrams in the figures illustrate the architecture, functionality, and operation of possible implementations of systems, methods, and computer program products according to various embodiments of the present invention. Each block in a flowchart or block diagram may represent a module, segment, or portion of instructions, including one or more executable instructions for implementing a specified logical function. In some alternative implementations, the functions marked in the blocks may occur in a different order than indicated in the figures. For example, depending on the functions involved, two consecutively shown blocks may actually be executed substantially simultaneously, or these blocks may sometimes be executed in reverse order. It should also be noted that each block in the block diagrams and / or flowcharts, and combinations of blocks in the block diagrams and / or flowcharts, can be implemented using a dedicated hardware-based system that performs the specified function or action or executes a combination of dedicated hardware and computer instructions.

Claims

1. A method for processing structured or semi-structured database records, comprising: Generate a semantic vector for a token associated with a database record, wherein generating the semantic vector includes: determining whether the token contains an invalid value; marking the token containing an invalid value; and preventing the use of the semantic vector of the token containing the invalid value when generating semantic vectors for tokens in a neighborhood containing non-invalid values; The non-invalid value of the second token in the second database record is filled with the invalid value of the first token in the first database record, wherein the filling includes: Based on a comparison of the semantic vector of the first token associated with the first database record and the semantic vector of the second token associated with the second database record, it is determined whether the second database record is similar to the first database record, wherein comparing the semantic vectors includes a semantic vector that prevents the use of tokens containing invalid values; and In response to determining that the second database record is similar to the first database record, the invalid value of the first token is replaced with the non-invalid value of the second token.

2. The method according to claim 1, wherein, The semantic vectors of the first database record and the second database record are generated using a vector embedding model.

3. The method according to claim 2, wherein, The vector embedding model includes a neural network trained using training data.

4. The method according to claim 3, wherein, The training data includes database records that have been appended with either row identifier labels or invalid value labels, or both.

5. The method according to claim 1, wherein, Invalid values ​​for tokens include: Null value; Missing values; Placeholder value; Predefined value; or default value, The invalid value indicates that specific attribute information of the given token is missing.

6. The method of claim 1, further comprising: Query the embedded database to find one or more records similar to the records in the first database. The second token in the second database record is selected from the one or more similar records.

7. A computer system for processing records in a structured or semi-structured database, comprising: One or more processors; One or more tangible storage media storing one or more programming instructions executed by the one or more processors to perform the method, the programming instructions including instructions for the following operations: Generate a semantic vector for a token associated with a database record, wherein generating the semantic vector includes: determining whether the token contains an invalid value; marking the token containing an invalid value; and preventing the use of the semantic vector of the token containing the invalid value when generating semantic vectors for tokens in a neighborhood containing non-invalid values; The non-invalid value of the second token in the second database record is filled with the invalid value of the first token in the first database record, wherein the filling includes: Based on a comparison of the semantic vector of the first token associated with the first database record and the semantic vector of the second token associated with the second database record, it is determined whether the second database record is similar to the first database record, wherein comparing the semantic vectors includes a semantic vector that prevents the use of tokens containing invalid values; and In response to determining that the second database record is similar to the first database record, the invalid value of the first token is replaced with the non-invalid value of the second token.

8. The computer system according to claim 7, wherein, The semantic vectors of the first database record and the second database record are generated using a vector embedding model.

9. The computer system according to claim 8, wherein, The vector embedding model includes a neural network trained using training data.

10. The computer system according to claim 9, wherein, The training data includes database records that have been appended with either row identifier labels or invalid value labels, or both.

11. The computer system according to claim 7, wherein, Invalid values ​​for tokens include: Null value; Missing values; Placeholder value; Predefined value; or default value, Invalid values ​​indicate that specific attribute information for a given token is missing.

12. The computer system according to claim 7, further comprising: Query the embedded database to find one or more records similar to the records in the first database. The second token in the second database record is selected from the one or more similar records.

13. A computer program product for processing records in a structured or semi-structured database, comprising: One or more tangible storage media storing program instructions executable by one or more processors to perform a method, the program instructions including instructions for the following operations: The one or more processors generate semantic vectors for tokens associated with database records, wherein generating semantic vectors includes: determining whether the token contains an invalid value; marking tokens containing invalid values; and preventing the use of semantic vectors containing invalid values ​​when generating semantic vectors for tokens in a neighborhood containing non-invalid values. The one or more processors fill in the non-invalid value of the second token in the second database record with the invalid value of the first token in the first database record, wherein the filling includes: Based on a comparison of the semantic vector of the first token associated with the first database record and the semantic vector of the second token associated with the second database record, it is determined whether the second database record is similar to the first database record, wherein comparing the semantic vectors includes a semantic vector that prevents the use of tokens containing invalid values; and In response to determining that the second database record is similar to the first database record, the invalid value of the first token is replaced with the non-invalid value of the second token.

14. The computer program product according to claim 13, wherein, The semantic vectors of the first database record and the second database record are generated using a vector embedding model.

15. The computer program product according to claim 14, wherein, The vector embedding model includes a neural network trained using training data.

16. The computer program product according to claim 15, wherein, The training data includes database records that have been appended with either row identifier labels or invalid value labels, or both.

17. The computer program product according to claim 13, wherein, Invalid values ​​for tokens include: Null value; Missing values; Placeholder value; Predefined value; or default value, The invalid value indicates that specific attribute information of the given token is missing.

18. The computer program product of claim 13, wherein the program instructions further include instructions for the following operations: Query the embedded database to find one or more records similar to the records in the first database. The second token in the second database record is selected from the one or more similar records.

Images