Vector embedded model for relational table having null value or similar value

Abstract

To provide a method of, a program for, and a storage medium for complimenting data from other record having non-null value with the same attribute with respect to a null value token in a database record.SOLUTION: The present invention is directed to a computing environment 100 which is exemplary for generation of vector embedding. A computer 102 has a processor 104, a program 106, a database 108, a training database 110, and an embedding database 112. A vector embedding method provides processing of structured and semi-structured database and file with using natural language processing technique. In some cases, the method includes a step of properly giving a null value token with a tag to thereby reduce or eliminate unjust influence on generation of a semantic vector using a neural network.SELECTED DRAWING: Figure 1

Description

[Technical Field]

[0001] The present invention relates generally to databases, and more particularly to semantic-based queries using embedded vector representations. [Background technology]

[0002] A computer database is a set of data stored in a structured or semi-structured format on a computer. The database model of data storage organizes large amounts of data so that it can be efficiently accessed, managed, and updated.

[0003] One type of computer database is a relational database, which enforces specific relationships between data to improve speed and efficiency over conventional databases. Relational databases are typically structured as one or more tables with rows and columns. Rows, defined as tuples, track entities of interest, and columns are defined as attributes of those entities. For example, a row or tuple may correspond to an employee, patient, physical asset, location, or other entity. Each column or attribute defines an aspect of an 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 a relational database (e.g., via sorting, updating, comparing, and other operations). One 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 of a structured or semi-structured database.

[0006] According to one embodiment of the present invention, the method complements a null value of a first token of a first database record with a non-null value of a second token of a second database record.

[0007] According to a related embodiment, the method replaces a null value of the first token with a non-null value of the second token.

[0008] According to a related embodiment, the complementing occurs in response to determining that the second record is similar to the first record.

[0009] According to a related embodiment, the method determines that a second record is similar to a first record based on comparing semantic vectors of tokens of the first database record with semantic vectors of tokens of the second database record.

[0010] According to a related embodiment, semantic vectors for the first and second database records are generated using a vector embedding model.

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

[0012] According to a related embodiment, the training data comprises database records that have been augmented to include row identification tags or null value tags, or both.

[0013] According to a related embodiment, a null value for a token is: Null value, Missing values, placeholder values, a predetermined value, or default value, , where a null value denotes the absence of specific attribute information for a given token.

[0014] According to a related embodiment, the method generates a semantic vector for the first token based on determining that the first token has a null value, and queries the embedded database to find one or more records similar to the first record. A second token of a second database record is selected from the one or more similar records.

[0015] According to one embodiment of the present invention, a computer system for processing records of a structured or semi-structured database comprises one or more processors and one or more tangible storage media storing one or more program instructions for performing a method when executed by the one or more processors.

[0016] According to one embodiment of the present invention, a computer program product for processing records of a structured or semi-structured database comprises one or more tangible storage media storing program instructions for performing a method when executed by one or more processors, the program instructions including instructions for performing the method.

[0017] According to one embodiment of the present invention, a method for reducing or eliminating the influence of null value tokens in records of a structured or semi-structured database includes tagging one or more null value tokens in the records of the structured or semi-structured database with a tag representing a null value, and generating a semantic vector for the non-null value using only nearby tokens of non-null values.

[0018] According to a related embodiment, the method finds similar records based on querying the generated semantic vectors for a given record.

[0019] According to a related embodiment, a null value for a token is: Null value, Missing values, placeholder values, a predetermined value, or default value, , with a null value signifying the absence of specific attribute information for a given token.

[0020] According to still other embodiments 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-described methods. [Brief explanation of the drawings]

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

[0022] [Figure 1] FIG. 1 is a functional block diagram of an exemplary computing environment 100 for generating vector embeddings, according to one embodiment of the present invention. [Figure 2] 2 is an illustration of an entry in database 108 of FIG. 1 according to one embodiment of the present invention. [Figure 3] 2 is an illustration of the training database 110 of FIG. 1 according to one embodiment of the present invention. [Figure 4] 2 is an illustration of the embedded database 112 of FIG. 1 according to one embodiment of the present invention. [Figure 5] 5 is an illustration of a query 502 using the embedded database 112 of FIG. 1 according to one embodiment of the present invention. [Figure 6] 6 is an exemplary method 600 for generating records for training database 110 of FIG. 1 using records for database 108, according to one embodiment of the present invention. [Figure 7] 7 is an exemplary flowchart of a method 700 for generating records for the embedded database 112 of FIG. 1 using records for the training database 110, according to one embodiment of the present invention. [Figure 8]8 is an exemplary flowchart of a method 800 for querying records of the database of FIG. 1 with records of the embedded database 112, according to one embodiment of the present invention. [Figure 9] 9 illustrates an exemplary flowchart of a method 900 for imputing data for null value tokens in a database 108, according to one embodiment of the present invention. [Figure 10] 10 is an exemplary flowchart of a method 1000 for reducing or eliminating the undue influence of null values on semantic vectors, according to one embodiment of the present invention. [Figure 11] FIG. 2 is a block diagram of an exemplary cloud computing node, according to one embodiment of the present invention. [Figure 12] FIG. 12 is a block diagram of a cloud computing environment including the cloud computing node of FIG. 11 according to one embodiment of the present invention. [Figure 13] FIG. 13 is a block diagram of functional layers of the cloud computing environment of FIG. 12, in accordance with one embodiment of the present invention. DETAILED DESCRIPTION OF THE INVENTION

[0023] Although some embodiments of the present invention are described with reference to relational databases, it should be noted that the inventive concepts disclosed herein are applicable 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 multi-modal databases (e.g., images and text), to name a few.

[0024] An example of a relational database is a table that stores information about individuals. Each table tuple, or row, corresponds to an individual, and each table column can correspond to an attribute (e.g., the individual's name, contact information, demographic information, and other information).

[0025] In accordance with one embodiment of the present invention, a task of interest in managing a relational database is data imputation to build, complete, or correct records stored within the database, including records with null values. Data imputation can be performed by identifying, for a given record under consideration (having one or more null values), one or more similar records (e.g., within the same database) whose attributes can be imputed to the null values of the given record; i.e., the process of inferring and filling in the null values based on the attributes of other records deemed similar to the given record. The task of imputing data is a technical and significant computing challenge.

[0026] Yet another task of interest in managing a relational database, according to one embodiment of the present invention, is determining the similarity between different records (rows or tuples) in a relational database, or between different records in two relational databases. Properly finding similar records enables proper data complementation. In the above example, the task of interest is, for a given record (e.g., a person's record) listed in the relational database, to find the other records that are most similar to it. The task of determining the most similar records is a technical and non-trivial computing challenge.

[0027] Yet another task of interest in managing a relational database, according to one embodiment of the present invention, is identifying and removing or merging duplicate records. For example, two records may exist in a relational database for the same individual (e.g., these records may have been created by joining two different databases), but these records may not contain identical information. The task of determining which records are duplicates is a technical and significant computing challenge.

[0028] The following discussion presents these significant technical computing challenges, explains why prior art techniques are limited in addressing them, and highlights the advantages of implementing embodiments of the present invention in addressing these challenges.

[0029] According to embodiments of the present invention, structured or semi-structured databases can be processed in a number of ways.

[0030] In one example, the processing includes generating a set of token sequences for at least a portion of the database, where each token in the sequence represents a respective database entity in the database; assigning, for each token in the set of token sequences, at least one corresponding vector from a set of vectors of the same dimension, where 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.

[0031] In another example, the processing is performed on a relational database containing multiple data types. Non-text tokens in the relational database are converted to textual form. The text is generated based on the relationships of the tokens in the relational database. A set of pre-trained word vectors for the text is retrieved from an external database. The set of pre-trained word vectors is initialized for tokens common to both the relational database and the external database. The set of pre-trained vectors is used to create cognitive intelligence queries expressed as Structured Query Language (SQL) queries. The contents of the relational database are used for training purposes to initialize the set of pre-trained word vectors for tokens common to both the relational database and the external database. The first set of word vectors may be immutable or may be mutable with updates controlled via parameters.

[0032] In yet another example, the processing is performed on a relational database containing image data types. At least one image identifier in the relational database is converted into a token format. Text is generated based on the relationships of 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 intelligence queries, expressed as Structured Query Language (SQL) queries, to the relational database. The image identifier can be converted into a token format by converting the image into a tag, using a neural network classification model to replace the image identifier with a corresponding cluster identifier, binary comparison, or using a user-specified similarity function. The image identifier can be converted into multiple text formats using more than one conversion method.

[0033] In yet another example, the processing is performed on a relational database including a numeric data type. At least one numeric token in the relational database is converted to a text format. The text is generated based on relationships between the tokens in the relational database. A set of word vectors is generated based on the text. A cognitive intelligence query expressed as a Structured Query Language (SQL) query can be applied to the relational database using the set of word vectors. At least one numeric token in the relational database can be converted to a string type including a numeric value and a column heading in which the token appears in the relational database. Converting the at least one numeric token in the relational database can include clustering tokens in a column of the relational database using a clustering algorithm and replacing each token in the column with a cluster identifier.

[0034] In yet another example, the processing includes receiving, by a processor system, a set of information. The set of information includes private information and non-private information. The processing further includes generating a plurality of vectors to represent the private information and the non-private information. The plurality of vectors corresponds to coded representations of the private information and the non-private information. The processing further includes publishing at least a portion of the set of information and the corresponding vector.

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

[0036] According to one definition, vector embedding is a technique for mapping words or phrases in a vocabulary to vectors of real numbers. The advantage of using vector embedding is that it defines the semantic and / or syntactic meaning of tokens (words or phrases) in a way that can be systematically processed by natural language processing systems. In this technique, the vector representation of a word or phrase is influenced by the token's context, i.e., its neighboring words or phrases. The range of neighboring words is a configurable parameter. A neural network (also called a training model) can be trained using training data to generate semantic vectors using strings as inputs and to generate vector representations for each token in the string. The strings can be, for example, sentences. The set of models used to generate vector embeddings using this technique is called word2Vec.

[0037] Another definition of distributed language embedding is assigning a vector to each word, phrase, concept, or more general item of data, where the vector indicates various aspects of related words, including semantic "closeness." The embodiments described herein can perform various operations on text entities within a structured or semi-structured database. The term "text entity" refers to some recognizable item (data) that appears in a database (or some external source), such as a word, a number, or a meaningful short sentence like "Theory of Relativity." A "word vector" is a vector representation of a word in a language. Methods for obtaining these vector representations range from "brute force" learning with various types of neural networks to log-linear classifiers and various matrix formulations, such as matrix factorization techniques. For example, word2vec generates vectors that capture not only the syntactic properties of words but also their semantic properties. Word2vec scans a corpus (text) to generate a vector representation for each word in a sentence. Word vectors are typically low-dimensional (around 100-300) and represent words. They can be used to calculate semantic and / or grammatical closeness of words, as well as to test analogies such as "A king to a man is a queen to what?" (answer: queen) using vector algebra.

[0038] According to yet another definition, database entities, such as words, numbers, fields (columns) of a row, entire rows in a table (i.e., tuples), or even entire relationships, are each related to a vector that captures the interrelationship between that database entity and all other such entities. The proximity of such entities can be determined through simple vector operations. Furthermore, vectors can be learned (or trained) through machine learning (ML) techniques on entity sequences derived from the database itself. This provides two types of databases: a typical relational database and a text database. The textual representation of a database can be analyzed, and a low-dimensional vector representation, for example, 200, can be assigned to each token. Using some techniques, tokens that frequently co-occur can be assigned vectors with relatively large cosine distances. This vector can also be used to check for similarities using simple vector operations. A token can be defined as a sequence of characters without intervening spaces. Each token represents a text entity, and these entities are related to each other. This relationship can be expressed numerically, for example, if cos(e1, e2) > 0.5. where cos is the cosine distance between the two vectors. Relationships can also be expressed in terms of a scale, e.g., very_strong, strong, moderate, weak, very_weak, e.g., strong(e1,e2), which allows for numerical values to be defined separately, e.g., very_strong=0.95. For example, understanding the relationship between two text entities "John" and "New York" involves deriving tokens for the text entities, e.g., V_John and V_New_York, and performing algebraic operations, e.g., cosine distance, on the two vectors.If the cosine distance between V_John and V_New_York is large (i.e., close to 1), the two text entities are closely related; if the cosine distance is small (i.e., close to -1), the two text entities are not closely related.

[0039] According to yet another definition, in vector embedding, a d-dimensional vector space is fixed. Each word in a text corpus (e.g., a collection of documents) is associated with a vector of real dimension d. The assignment of words to vectors should be such that the vector encodes the meaning of the word. Ideally, if two words are closely related (i.e., have similar meanings), their vectors should point in the same direction. In other words, the cosine distance between their vectors should be relatively large. Closely related words refer to words that often appear together in a text corpus. Appearing together implies proximity. Conversely, if words are unrelated, the cosine distance between their vectors should be relatively small. Some refinements to the proximity calculation weight proximity or take grammatical rules into account, or both.

[0040] Vectors can be generated by learning about the database itself or by using external text or vector sources. In the context of a relational database, one way to generate vectors is to apply vector embedding methods to token sequences generated from the database, where each row corresponds to a sentence and a relation corresponds to a document. Vectors thus enable a dual view of the data: relationships and (meaningful) text. Therefore, vector embedding can extract latent semantic information, such as word associations and co-occurrences, and encode it into word vectors. Thus, vectors first capture inter- and intra-attribute relationships within a row (sentence) and then aggregate these relationships across documents to compute aggregate semantic relationships. The encoded semantic information can then be used when querying the database.

[0041] A common problem with the above functions and processes is that database records often contain null values. For purposes of the claimed embodiments of the present invention, it will be apparent to those skilled in the art that the terms empty, null, missing, placeholder, or other predetermined or default values that refer to the absence of particular attribute information for a given entity or record are considered without departing from the spirit and scope of the claimed invention. The common functional definition of these terms is that, in the context of the embodiments of the present invention, these values do not refer to actual attributes of the entity corresponding to a given record in a database. Instead, these values refer to the attribute information not being readily available.

[0042] The above functions can be performed better if null values are replaced with actual values using data imputation. Furthermore, it would be desirable to minimize the undue influence of null values when performing data imputation or other data processing tasks.

[0043] More specifically, in the context of structured or semi-structured databases, semantic vectors are more useful when generated using actual attributes of records rather than null values. When actual attributes are unavailable in a given record (i.e., the value is null), they can be filled in with other similar records by implementing embodiments of the claimed invention. Furthermore, semantic vectors can be made more useful by minimizing the undue influence of null values that cannot be filled in from other records.

[0044] In brief summary, the challenges presented by null values arise in vector embedding processes applied to relational databases, where each row is treated as a sentence and potentially provided as input to the process (e.g., input to a neural network). A vector can be generated for a word or phrase in a row. However, that row may have many null values. A word's vector will be influenced by nearby null values and may be mistaken for similar to other tokens that have nearby null values.

[0045] Therefore, there are at least two challenges in performing the above target task: data imputation for a given null value in a given record (i.e., if an attribute value is null, which is the most similar record to which the attribute record should be copied) and generation of semantic vectors based on records with one or more null values. Addressing one or both of these challenges is an objective of at least one embodiment of the present invention.

[0046] Regarding the first issue, for a given null value in a given record, it is not immediately obvious which other records are sufficiently similar to the given record and therefore suitable as sources of data completion for the given null value. This is because, in the prior art, null values do not have corresponding semantic vectors created for them, and other null values inappropriately influence the semantic vectors for both the given null value and null values in other records. The more null values a record has, the more similar it appears to other records with null values. However, this similarity is meaningless because two records are similar only insofar as they both contain null values and do not otherwise convey information (e.g., attributes) about the same entity.

[0047] Regarding the second issue, the inappropriate influence of null values in relational databases on the vector output of neural network training models arises because of an assumption underlying this process: that words used in the same way and / or in the same context appear to have similar meanings. While this assumption is believed to yield reliable assessments of semantic similarity in many use cases, it often breaks down in relational databases with null values, as many attributes are identified as similar simply because they are all surrounded by the same null value.

[0048] Therefore, there exists a need for creative methods, systems, and computer program products that reliably impute data for null values in database records and generate vector paddings that are not improperly or unduely affected by the null values. Accordingly, it is an object of at least some embodiments of the disclosed invention to provide one or more of these capabilities.

[0049] It will be apparent to those skilled in the art that the disclosed invention has applicability to many databases, not just relational databases, and may be extended to data imputation and vector filling processes for data stored in any structure, some of which may contain null values that can be imputed with other records.

[0050] Embodiments of the present invention will now be described in detail with reference to the various drawings.

[0051] Figure 1 is a functional block diagram of an exemplary computing environment 100 for generating vector embeddings, according to one embodiment of the present invention. Referring now to Figure 1, computing environment 100 includes a computer 102, whose general structure and components may be as described below in connection with Figure 9.

[0052] The computer 102 includes a processor 104 , a program 106 , a database 108 , a training database 110 , and an embedded database 112 .

[0053] Processor 104 generally processes program instructions of program 106 to perform one or more methods. Program 106 processes data stored (or to be stored) in database 108, training database 110, and embedded database 112, each of which stores one or more records, each corresponding to an entity, and each record having one or more attributes. Program 106 and the databases are stored on tangible storage media of computer 102. While FIG. 1 shows one computer, one processor, and one program (and several databases), it will be apparent to those skilled in the art that these components may be distributed among more than one computing device and provided via cloud computing or other distributed computing models without departing from the spirit and scope of the claimed invention.

[0054] More specifically, program 106 performs, among other things, vector embedding functions (as described in connection with FIGS. 2-4) and query functions (as described in connection with FIG. 5).

[0055] Database 108 generally contains the data upon which various tasks of interest are performed, as described above. For example, database 108 is a table whose rows represent individuals and whose columns represent attributes of those individuals. Some of those attributes may be missing (or may be tagged as null, empty, or other values) in some rows. An example of an entry in database 108 is provided below in FIG. 2.

[0056] Training database 110 generally includes data generated by program 106 for generating vector embeddings such as in embedding database 112 according to an embodiment of the present invention.

[0057] The records stored in the embedded database 112 are generally data that the program 106 generates by processing the records in the training database 110 (in other words, the program 106 processes the training data to generate semantic vectors).

[0058] 2 is an illustrative example of an entry 200 in database 108 of FIG. 1 , according to one embodiment of the present invention. In the illustrated example, database 108 is a comma-separated value (CSV) relational database, and its entry 200 includes a header row (not shown in FIG. 2 ) corresponding to an individual's attributes and one or more additional rows (shown in FIG. 2 ) corresponding to records storing the individual's actual attributes. Records in database 108 may contain incomplete, inaccurate, or inconsistent attribute information that adversely affects queries and other operations on the database, including vector filling processes performed on database 108. This is problematic.

[0059] In fact, the entities 200 in the illustrated example are for the same fictitious individual, "JOSEPH ROBERTS," but the records are not identical because they may contain incomplete, inaccurate, or contradictory information.

[0060] In this example, the attributes for 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 the other records.

[0061] For example, note that the first entry (with record ID 99310) has values "M" and "JOSEPH" for the attributes SEX and FNAME, but the second, third, and fourth entries (with record IDs 99311, 99312, and 99313, respectively) have null values for these two attributes.

[0062] In line with the above target task, it is desirable to perform data imputation to find suitable values to replace these null values by finding the most similar records that may have actual values for one or more of these attributes.

[0063] As described more generally above, generating vector embeddings of data in database 108 without processing in accordance with the claimed embodiments of the present invention is of limited usefulness because they do not fill data voids and semantic vectors for non-null data may be unduly influenced by null values.

[0064] It is therefore desirable to process the data in database 108 to fill data gaps (data imputation) and reduce or eliminate the inappropriate influence of null values on the semantic vectors for the data in database 108. At least some methods showing how to perform these functions are provided in Figures 6-9. An example of training data generated and / or used by these methods is described in Figure 3.

[0065] Figure 3 is an illustrative example of training database 110 of Figure 1, according to one embodiment of the present invention. Entries 300 of training database 110 are generated by applying the method of Figure 6 (by way of example) to entries 200 of database 108 (Figure 2). Details of this process are described in conjunction with Figure 6. Here, it can be seen that the values of entry 300 are tagged with their attributes: RECORID (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 state), HZIP (home zip code), DLSTATE (driver's license state).

[0066] Note that for the second entry in the set of entries 300, the FNAME field is empty (in entry 200 of Figure 2, this entry is "...M.,ROBERTS..." with no value between "M" and "ROBERTS").

[0067] Additionally, note that throughout the various entries 300, "EMPTY" tags appear where information is missing. This is an example of a null void in the data that can be filled using data imputation, and an example of a null value that, if not filled, can unduly affect the semantic vector. If a multidimensional vector is generated based on shared nearby tokens, entry 300 will likely result in a false positive (of clear similarity) due to the EMPTY tag. This is a problem.

[0068] Figure 4 is an illustrative example of the embedded database 112 of Figure 1, in accordance with one embodiment of the present invention. Figure 4 shows an example vector 400 generated using the entries 300 of Figure 3. The semantic vector 400 is generated using an embodiment of the present invention to fill data gaps and to reduce or eliminate the undue influence of null values.

[0069] Figure 5 is an illustrative example of a query 502 using the embedded database 112 of Figure 1, according to one embodiment of the present invention. In the example shown, the query 502 seeks the vector in the embedded database 112 that is most similar to the vector with RecordID 99728. In the example shown, the result 504 indicates that the record with RecordID 99727 is most similar to RecordID 99728.

[0070] By implementing embodiments of the present invention, the most similar records are correctly identified and serve as sources for data imputation. Additionally, the effect of null values is reduced or eliminated.

[0071] Figure 6 is an exemplary method 600 for generating training database 110 using entries from database 108 of Figures 1 and 2, according to one embodiment of the present invention. Referring now to Figures 1, 2, and 6, program instructions of program 106 are executed by processor 104 to perform steps of method 600. Method 600 may generally operate to create a training data set (stored in training database 110) using database 108 with null values.

[0072] The program 106 identifies column attributes in the database 108 (step 602).

[0073] The program 106 adds / tags null (missing, empty, default, placeholder, etc.) values in the database 108 with a special tag, for example, "_EMPTY" (step 604).

[0074] Program 106 optionally or alternatively appends a row identifier to the attribute string (step 604a). This allows embodiments of the present invention to distinguish particular entries or cell values in a table from other null-valued cells in a column by appending or assigning a row identifier to the null value; otherwise, all null values in a particular column may appear indistinguishable when performing certain processing steps. For example, for a given record under analysis (whose null values will be replaced using data imputation), once similar rows have been identified, other techniques such as value-based voting (simply using the most common value from the candidate set) or the mean or median of the candidate values may be used.

[0075] The program 106 stores the corrected data in the training database 110 (step 606). This training data can then be used to perform data imputation.

[0076] FIG. 7 is an exemplary method 700 for generating records for the embedded database 112 of FIG. 1 using records for the training database 110 based on the output of the method 600 of FIG. 6, according to one embodiment of the present invention.

[0077] 1, 2, 3, 6, and 7, program instructions of program 106 are executed by processor 104 to perform steps of method 700. Method 700 may generally operate to construct semantic vectors, i.e., data imputation, for training data in training database 110 that has a tag of "_EMPTY" (or an equivalent tag).

[0078] The program 106 determines that the token for which a semantic vector is being generated contains a null value (step 702). The token is part of a "sentence" (e.g., a record or row in the training database 110). The method 700 preferably generates a semantic vector for the token as an output.

[0079] For example, program 106 determines (step 702) that the SEX_EMPTY and FNAME_EMPTY tokens in certain entries 300 of training database 110 contain the "_EMPTY" tag (i.e., the second, third, and fourth entries). The determination (step 702) can be made on a token-by-token basis, i.e., as there are tokens to be processed (to generate a semantic vector), for each such token, program 106 determines (step 702) whether the token has the "_EMPTY" tag.

[0080] The program 106 generates a semantic vector (step 704) for each token with the "_EMPTY" tag determined above (step 702). Generating the semantic vector can be done using a neural network.

[0081] The program 106 stores the generated (step 704) semantic vectors in the embedded database 112 (step 706).

[0082] FIG. 8 is an exemplary flowchart of a method 800 for querying records of the database 108 of FIG. 1 with records of the embedded database 112, according to one embodiment of the present invention.

[0083] 1, 2, 3, 5, and 8, program instructions of program 106 are executed by processor 104 to perform steps of method 800. Method 800 may generally operate to query, for a given record in database 108, the most similar other records in database 108 (or other databases). One purpose of performing method 800 is to perform the tasks of interest described above. For example, method 800 may be performed to, for a given record in database 108 that has a null value, find the most similar other record whose non-null data can be used to fill in the null data of the given record.

[0084] Thus, program 106 identifies records (or tokens in records) in the database that have null values (step 802). For example, program 106 identifies the second entry in entries 200 (FIG. 2) as having null values for the SEX and FNAME attributes. Alternatively, program 106 can perform the identification (step 802) using entry 300 (FIG. 3) of training database 110.

[0085] Based on the identified records, program 106 queries embedded database 112 (step 804) using the record information of the records identified above (step 802). For example, program 106 queries embedded database 112 (step 804) using SQL query 502 (FIG. 5).

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

[0087] FIG. 9 is an exemplary flowchart of a method 900 for imputing data for null value tokens in the database 108 according to one embodiment of the present invention.

[0088] 1, 8 and 9, program instructions of program 106 are executed by processor 104 to perform steps of method 900. Method 900 may generally operate to impute data for null values in records of database 108 by querying semantic vectors of embedded database 112 (method 800).

[0089] Therefore, the program 106 identifies (902) attributes that have null values in the records of the database 108. This identification (step 902) can be done by looking for null values in the records of the database 108 or for the "_EMPTY" tag in the training database 110.

[0090] For a given token identified (902) as having a null value, the program 106 identifies (step 904) the most similar records in the database 108 (e.g., the top K records whose scores are closest to the identified record) that may contain a non-null attribute value(s) for the identified (902) token. For example, the program 106 may perform the identification of the most similar records (step 904) by performing the method 800.

[0091] Based on identifying tokens with null values (step 904), the program 106 imputes (step 906) non-null values of the tokens identified above (step 904) to the tokens with null values identified as requiring data imputation.

[0092] FIG. 10 is an exemplary flowchart of a method 1000 for reducing or eliminating the undue influence of null values on semantic vectors, according to one embodiment of the present invention.

[0093] 1, 3, and 10, program instructions of program 106 are executed by processor 104 to perform steps of method 1000. Method 1000 may generally operate to reduce or eliminate the undue influence of null valued tokens in generating semantic vectors.

[0094] Thus, program 106 receives a record or token for processing (to generate a semantic vector) (step 1002). The program determines (1004) that the record or token contains a null value (e.g., has an "_EMPTY" tag).

[0095] Based on this observation, program 106 suppresses the use of the “_EMPTY” tag when constructing semantic vectors for entities or tokens in the neighborhood of the “_EMPTY” token (step 1006). For example, with respect to rows 2, 3, and 4 of entry 300 (FIG. 3), generating a vector representation for “LNAME_ROBERTS” would not use “SEX_EMPTY” or “FNAME_EMPTY,” even if these values appear in the context or neighborhood of “LNAME_ROBERTS.” Suppressing the undue influence of empty tags can be achieved in various ways, including, for example, filtering out null-valued tokens or adjusting the scope of the context to exclude null-valued tokens. Stated another way (and listing practical steps to be taken), program 106 provides, for a given token, only neighboring tokens not tagged with null values as input to the neural network (step 1006).

[0096] The program 106 uses a neural network to generate a semantic vector for the token (step 1008). The generated semantic vector (step 1008) is not (or is less likely to be) unduly affected by null values and is therefore more useful for other tasks of interest.

[0097] 11 is a block diagram of an exemplary cloud computing node according to one embodiment of the present invention. Cloud computing node 10 is merely one example of a suitable computing node and is not intended to suggest any limitation on the scope of use or functionality of the embodiments described herein. Nevertheless, cloud computing node 10 may implement and / or perform any of the functions described above.

[0098] In cloud computing node 10, computer system / server 12 is operable in numerous other general-purpose or special-purpose computing system environments or configurations. Examples of well-known computing systems, environments, or configurations, or combinations thereof, that may be suitable for use with 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 devices, network PCs, minicomputer systems, mainframe computer systems, and distributed cloud computing environments that include any of the above systems or devices.

[0099] The computer system / server 12 may be described in the general context of computer system-executable instructions, such as program modules, being executed by a computer system. Generally, program modules may include routines, programs, objects, components, logic, data structures, etc. that perform particular tasks or implement particular abstract data types. The computer system / server 12 may be practiced in a distributed cloud computing environment where tasks are performed by remote processing devices linked through a communications network. In a distributed cloud computing environment, program modules may be located in both local and remote computer system storage media, including memory storage devices.

[0100] 11, computer system / server 12 in cloud computing node 10 is shown in the form of a general-purpose computing device. Components of 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 coupling various system components, including system memory 28, to processor 16.

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

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

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

[0104] By way of example and not limitation, memory 28 may store a program / utility 40 having a set (at least one) of program modules 42, as well as an operating system, one or more application programs, other program modules, and program data. Each of the operating system, one or more application programs, other program modules, and program data, or any combination thereof, may include an implementation of a networking environment. Program modules 42 generally perform the functions and / or methods of embodiments of the present invention described herein.

[0105] The computer system / server 12 may also communicate with one or more external devices 14, such as a keyboard, pointing device, display 24, etc., one or more devices that allow a user to interact with the computer system / server 12, or any device that allows the computer system / server 12 to communicate with one or more other computing devices (e.g., a network card, modem, etc.), or combinations thereof. Such communication may occur via an input / output (I / O) interface 22. Furthermore, the computer system / server 12 may also communicate with one or more networks, such as a local area network (LAN), a general wide area network (WAN), or a public network (e.g., the Internet), or combinations thereof, via a network adapter 20. As shown, the network adapter 20 communicates with other components of the computer system / server 12 via a bus 18. Although not shown, it is understood that other hardware and / or software components may be used with the 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 archive storage systems.

[0106] FIG. 12 is a block diagram of a cloud computing environment including the cloud computing node of FIG. 11 , according to one embodiment of the present invention. Referring now to FIG. 12 , an exemplary cloud computing environment 50 is shown. As shown, the cloud computing environment 50 includes one or more cloud computing nodes 10 that can communicate with local computing devices used by cloud consumers, such as, for example, a personal digital assistant (PDA) or mobile phone 54A, a desktop computer 54B, a laptop computer 54C, or a computer system 54N, or a combination thereof. The nodes 10 can communicate with each other. These nodes can be physically or virtually grouped in one or more networks (not shown), such as a private cloud, a community cloud, a public cloud, or a hybrid cloud, or a combination thereof. This enables the cloud computing environment 50 to provide infrastructure as a service, platform as a service, or software as a service, or a combination thereof, without requiring the cloud consumer to maintain resources on a local computing device. It should be understood that the types of computing devices 54A-N shown in FIG. 12 are intended to be exemplary only, and that the computing node 10 and cloud computing environment 50 can communicate with any type of computerized device over any type of network or over a network-addressable connection (e.g., using a web browser), or both.

[0107] Figure 13 is a block diagram of functional layers of the cloud computing environment of Figure 12, in accordance with one embodiment of the present invention. Referring now to Figure 13, a set of functional abstraction layers provided by cloud computing environment 50 is shown. It should be understood in advance that the components, layers, and functions shown in Figure 14 are intended to be merely exemplary, and embodiments of the present invention are not limited thereto. As shown, the following layers and corresponding functions are provided:

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

[0109] The virtualization layer 70 provides an abstraction layer through which the following examples of virtual entities can be provided: virtual servers 71, virtual storage 72, virtual networks including virtual private networks 73, virtual applications and operating systems 74, and virtual clients 75.

[0110] In one example, the management layer 80 can provide the following functions: Resource provisioning 81 provides dynamic procurement of computing and other resources utilized 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 billing or invoicing for the consumption of these resources. In one example, these resources can include application software licenses. Security provides identity verification for cloud consumers and tasks and 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 allocation and management of cloud computing resources to ensure required service levels are met. Service level agreement (SLA) planning and fulfillment 85 provides pre-provisioning and procurement of cloud computing resources to anticipate future requirements according to SLAs.

[0111] The workload tier 90 provides examples of functionality that can utilize a cloud computing environment. Examples of workloads and functionality that can be provided from this tier include mapping and navigation 91, software development and lifecycle management 92, virtual classroom instruction delivery 93, data analytics processing 94, transaction processing 95, and database management 96, including those described in connection with Figures 1-10 above.

[0112] A computer-readable storage medium may be any tangible device capable of holding and storing instructions for use by an instruction execution device. A computer-readable storage medium may be, for example, but not limited to, an electronic storage device, a magnetic storage device, an optical storage device, an electromagnetic storage device, a semiconductor storage device, or any suitable combination of the above. A non-exhaustive list of more specific examples of computer-readable storage media includes the following: portable computer diskettes, 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 versatile disk (DVD), memory stick, floppy disk, a mechanically encoded device having instructions recorded thereon, and any suitable combination of the above. As used herein, computer-readable storage media is not to be construed as transitory signals per se, such as radio waves or other freely propagating electromagnetic waves, electromagnetic waves propagating through a waveguide or other transmission medium (e.g., light pulses through fiber optic cable), or electrical signals sent through wires.

[0113] The computer-readable program instructions described herein can be downloaded from a computer-readable storage medium to each computing / processing device or to an external computer or storage device over a network, such as the Internet, a local area network, a wide area network, or a wireless network, or a combination thereof. The network can include copper cables, optical fibers, wireless networks, routers, firewalls, switches, gateway computers, or edge servers, or a combination thereof. A network adapter card or network interface in each computing / processing device receives the computer-readable program instructions from the network and transfers the computer-readable program instructions for storage in a computer-readable storage medium within the respective computing / processing device.

[0114] The computer-readable program instructions for carrying out the operations of the present disclosure may be assembler instructions, instruction set architecture (ISA) instructions, machine instructions, machine-dependent instructions, microprocessors, firmware instructions, state-setting data, or source or object cores written in any combination of one or more programming languages, including object-oriented programming languages such as Smalltalk, C++, and traditional procedural programming languages such as the "C" programming language or similar programming languages. The computer-readable program instructions may execute entirely on the user's computer, partially on the user's computer as a stand-alone software package, partially on the user's computer and partially on a remote computer, or entirely on a remote computer or server. In the latter scenario, the remote computer may be connected to the user's computer through 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, a programmable logic circuit, a field programmable gate array (FPGA), or a programmable logic array (PLA) can execute computer readable program instructions to individualize the electronic circuitry by utilizing state information of the computer readable program instructions to implement aspects of the present disclosure.

[0115] Aspects of the present disclosure will be described with reference to flowchart illustrations and / or block diagrams of methods, apparatus (systems) and computer program products according to embodiments of the present disclosure. It will 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.

[0116] These computer-readable program instructions can be provided to a processor of a general-purpose computer, special-purpose computer, or other programmable data processing apparatus to produce a machine, whereby the instructions, executed by the processor of the computer or other programmable data processing apparatus, create means for performing the functions / acts specified in one or more blocks of the flowcharts and / or block diagrams. These computer program instructions can also be stored in a computer-readable medium that can direct a computer, other programmable data processing apparatus, or other device, or combination thereof, to function in a particular manner, whereby the instructions stored in the computer-readable medium include an article of manufacture containing instructions that implement aspects of the functions / acts specified in one or more blocks of the flowcharts and / or block diagrams.

[0117] The computer program instructions may 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 data processing apparatus, or other device to generate a computer-implemented process, whereby the instructions running on the computer, other programmable apparatus, or other device perform the functions / operations specified in one or more blocks of the flowcharts and / or block diagrams.

[0118] 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 disclosure. In this regard, each block in a flowchart or block diagram may represent a module, segment, tensorlet, block, or portion of instructions, which includes one or more executable instructions for implementing the specified logical function(s). In some alternative implementations, the functions shown in the blocks may occur in a different order than that shown in the figures. For example, two blocks shown in succession may in fact be executed substantially simultaneously, or the blocks may sometimes be executed in the reverse order, depending on the functionality involved. It should also be noted that each block in the block diagrams and / or flowchart diagrams, and combinations of blocks in the block diagrams and / or flowchart diagrams, may be implemented by a dedicated hardware-based system that performs the specified functions or operations, or a combination of dedicated hardware and computer instructions.

Claims

1. 1. A method for processing records of a structured or semi-structured database by computer information processing, comprising: generating a semantic vector for a token that is at least a portion of the database record, the generating of the semantic vector comprising: determining whether the token contains a null value; tagging said tokens containing said null value with a special tag; suppressing the use of tokens containing non-null values when generating semantic vectors for nearby tokens containing the null values; said generating comprising: Complementing a null value of a first token associated with said token in a first database record with a non-null value of a second token associated with said token in a second database record, said comple ting comprising: determining whether the second database record is similar to the first database record by comparing the semantic vectors of the tokens associated with the first database record with the semantic vectors of the tokens associated with the second database record; replacing the null value of the first token with the non-null value of the second token based on the second database record being determined to be similar to the first database record; said complementing including Contains method.

2. The method of claim 1 , wherein the semantic vectors of the first and second database records are generated using a vector embedding model that maps words or phrases in a vocabulary to vectors of real numbers.

3. The method of claim 2 , wherein the vector embedding model comprises a neural network trained with training data.

4. The method of claim 3 , wherein the training data comprises database records with row identifier tags or null value tags, or both, appended to the null values.

5. The null value of the token is Null value, Missing values, placeholder values, a predetermined value, or Default value Including, The null value indicates the absence of specific attribute information for a given token. The method of claim 1.

6. querying an embedded database containing the semantic vectors of the database records generated using a vector embedding model that maps words or phrases in a vocabulary to vectors of real numbers, to find one or more records similar to the first database record; further comprising the second token of the second database record is selected from the one or more similar records according to a similarity resulting from the query; The method of claim 1.

7. 1. A computer system for processing records of a structured or semi-structured database, comprising: one or more processors; one or more tangible storage media storing one or more program instructions for performing a method when executed by the one or more processors; Equipped with The program instructions include: instructions for generating a semantic vector for a token that is at least a portion of the database record, the generating the semantic vector comprising: determining whether the token contains a null value; tagging said tokens containing said null value with a special tag; suppressing the use of tokens containing non-null values when generating semantic vectors for nearby tokens containing the null values; the instructions for generating, instructions for complementing a null value of a first token associated with said token in a first database record with a non-null value of a second token associated with said token in a second database record, said complementing comprising: determining whether the second database record is similar to the first database record by comparing the semantic vectors of the tokens associated with the first database record with the semantic vectors of the tokens associated with the second database record; replacing the null value of the first token with the non-null value of the second token based on the second database record being determined to be similar to the first database record; and Contains Computer systems.

8. 8. The computer system of claim 7, wherein the semantic vectors of the first and second database records are generated using a vector embedding model that maps words or phrases in a vocabulary to vectors of real numbers.

9. 10. The computer system of claim 8, wherein the vector embedding model comprises a neural network trained with training data.

10. 10. The computer system of claim 9, wherein the training data comprises database records with row identifier tags or null value tags, or both, appended to the null values.

11. The null value of the token is Null value, Missing values, placeholder values, a predetermined value, or Default value Including, The null value indicates the absence of specific attribute information for a given token.

8. The computer system of claim 7.

12. querying an embedded database containing the semantic vectors of the database records generated using a vector embedding model that maps words or phrases in a vocabulary to vectors of real numbers, to find one or more records similar to the first database record; further comprising the second token of the second database record is selected from the one or more similar records according to a similarity resulting from the query; 8. The computer system of claim 7.

13. and program instructions for causing a computer to carry out the method of any one of claims 1 to 6. Computer program.

14. 14. A computer readable storage medium having stored thereon the computer program of claim 13.

Images