RU2839037C1 - Method and system for obtaining vector presentations of data in table taking into account structure of table and its content - Google Patents

Abstract

FIELD: data processing.

SUBSTANCE: group of inventions relates to data processing and can be used to obtain vector representations of data in a table based on the structure of the table and its content. Method comprises the following steps: obtaining data, which includes: text, table structure; table is defined as a set from a list of table header cells and a list of table body cells; each cell of the table body is marked with tags characterizing: a table identifier, a list of atomic columns to which the cell belongs, a list of atomic rows to which the cell belongs; data of each cell of table body is supplemented with information from corresponding cells of headers; performing the text in the table tokenisation; performing position coding at table rows level; forming vector representations of tokens for each token in table by aggregation of vector representations of tokens and positional vector representations; attention matrix is generated, using cell belonging to column or row of table; storing coordinates of boundaries of table cells in sequence of table tokens; the base model receives at the input prepared text and position vector representations of tokens and an attention matrix and processes them to obtain contextualized vector representations of tokens; using stored coordinates of boundaries of table cells, pooling is used to obtain a vector representation of a table cell.

EFFECT: faster process of training a language model when working with spreadsheet documents.

6 cl, 5 dwg

Description

[1] This technical solution generally relates to methods for modifying, training and using language models aimed at working with tables, namely to a method and system for obtaining vector representations of data in a table, taking into account the structure of the table and its contents.

LEVEL OF TECHNOLOGY

[2] A language model is a probability distribution over sequences of words. Language models generate probabilities by training on a corpus of texts in one or more languages. Given that languages can be used to express a vast number of valid sentences (the so-called digital infinity), language modeling faces the challenge of assigning non-zero probabilities to linguistically valid sequences that may never appear in the training data. Several modeling approaches have been developed to overcome this problem, such as the use of Markov chains or the use of neural architectures such as recurrent neural networks or transformers.

[3] Language models are useful for a variety of computational linguistics problems; from initial applications in speech recognition to avoid generating meaningless (i.e. unlikely) word sequences, to more widespread use in machine translation (e.g. evaluating candidate translations), natural language generation (generating text that sounds more like human language), part-of-speech tagging, syntactic analysis, optical character recognition, handwriting recognition, grammar inference, information retrieval, and other applications.

[4] There are a large number of architectures aimed at working with documents, working on visual, textual information and information about the location of text (layout) on the page, such as:

1. TableNet is an end-to-end deep learning model designed for table discovery and structure recognition.

2. Donut - encoder-decoder architecture based on transformer, working without OCR, the encoder takes an image as input, the decoder takes text as input and the encoder output to generate text.

3. DiT - a transform architecture for pre-training on document images.

4. UDoP - The model combines text, image and layout using a single transformer-based model into a common space.

5. DocLLM - a lightweight extension for traditional LLM, for working with documents, combining text query and layout, without using a visual encoder.

[5] However, they are not specialized to perform the task of selecting named entities in a table, and therefore require a larger amount of data and computing power to obtain a comparable result for a specific task.

[6] Existing language models aimed at working with tables, such as: TaBERT (Yin et al., 2020), TURL (Deng et al. 2020), TAPAS (Herzig et al., 2020), TabNER (Koleva et al., 2022) - require modifications to the standard transformer architecture (Vaswani et al., 2017 - https://arxiv.org/pdf/1706.03762.pdf) and pre-training on a large amount of data to solve the problem of obtaining vector representations of data in a table, taking into account the table structure and its contents.

[7] TaBERT adds a vertical attention mechanism for contextualizing column embedding, which requires pre-training (in known examples, pre-training occurred on web pages with data parsing from html). The structure of the text passed to the encoder does not correspond to the standard structure fed to the transformer: the [SEP] token has a different meaning than in the basic transformer, acting as a separator between table rows rather than a separator between texts whose connection needs to be established.

[8] In TURL, token embedding in the table part is obtained by adding the word vector w, the token type (title or content) t, and the positional embedding p: x ^∧ t=w+t+p. This does not correspond to the standard transformer scheme and requires additional pre-training on a large amount of tabular data. It is designed to work only with a flat table due to the attention (visibility) mechanism based on columns and rows.

[9] In TAPAS, token embedding in the table part is obtained by adding the word vector w, positional embedding p, segment embedding s, column embedding c, table row embedding r, and rank embedding rg: x ^∧ t=w+p+c+s+r+rg. This does not correspond to the standard transformer scheme and requires additional retraining on a large amount of tabular data.

[10] In TabNER, token embedding in the tabular part is obtained by adding the word vector w, positional embedding pos, segment embedding seg: x ^∧ t=w+seg+pos, where the segment embedding indicates whether the text belongs to the heading or the content of the table, and does not indicate the relation to the semantic part, as in the standard transformer, which leads to a distribution bias and the inability to use open models. It also assumes the use of model output embeddings to extract named entities at the token level, which increases the probability of distinguishing the extracted entities.

DISCLOSURE OF INVENTION

[11] This technical solution is aimed at eliminating the shortcomings inherent in existing solutions known from the prior art.

[12] The technical problem solved in this technical solution is that the model architectures used for working with documents do not use the structural elements of tables in the document when constructing data representations (embeddings) and solving the target problem (classification, NER, question-answering systems, etc.), as a rule, replacing the use of the table structure with a large amount of data used at the stages of pre-training and training specific to a particular area, depriving the ability to use open-to-use models in the selected language, or force the use of a large amount of data and computing power to generalize the knowledge contained in the tables. SOTA model architectures that take into account the table structure during training, as a rule, make changes to the architecture of standard models, which makes it impossible to use open models without additional pre-training, which requires a large amount of resources and data, as well as the need to pre-process them and select data corresponding to the required structure, depriving the ability to use training on large unstructured datasets.

[13] The main technical result that emerges from solving the above problem is the acceleration of the process of training a language model when working with tabular documents by providing the ability to use any pre-trained transformer to obtain cell-level representations for a table, which allows the use of both open models trained on a large amount of data and specialized models pre-trained on unstructured data specific to the document domain, without preliminary preparation and cleaning of the corpus.

[14] An additional technical result that appears when solving the above-mentioned problem is an increase in the accuracy of solving language model problems when working with tabular documents due to the use of the structured nature of tabular data and the ability to work with tables with a complex structure.

[15] The specified technical results are achieved by implementing a method for obtaining vector representations of data in a table taking into account the structure of the table and its contents, implemented using a processor and a data storage device, including the following steps:

• receive data including: text, table structure;

• a table is defined as a set of a list of table header cells and a list of table body cells;

• each cell of the table body is marked with tags that characterize: the table identifier, the list of atomic columns to which the cell belongs, the list of atomic rows to which the cell belongs.

• the data of each table body cell is supplemented with information from the corresponding header cells;

• tokenize the text in the table;

• perform positional coding at the table row level;

• form token vector representations for each token in the table by aggregating token vector representations and positional vector representations;

• form an attention matrix using the cell’s belonging to a column or row of the table;

• store the coordinates of the table cell boundaries in the sequence of table tokens;

• the base model receives prepared text and positional vector representations of tokens and an attention matrix as input and processes them, obtaining contextualized vector representations of tokens;

• using the stored coordinates of the table cell boundaries, use pooling to obtain a vector representation of the table cell.

[16] In one of the specific examples of the method’s implementation, the base model is further trained to perform a specific task.

[17] In another particular example of the implementation of the method, the base model is pre-trained on unstructured text for the domain, without the need for information about tables.

[18] In addition, the stated technical result is achieved through the operation of a system for obtaining vector representations of data in a table, taking into account the structure of the table and its content, containing:

at least one data processing device;

at least one data storage device;

at least one program, where one or more programs are stored on one or more data storage devices and executed on one or more data processing devices, wherein the one or more programs ensure the execution of the following steps:

• receive data including: text, table structure;

• a table is defined as a set of a list of table header cells and a list of table body cells;

• each cell of the table body is marked with tags that characterize: the table identifier, the list of atomic columns to which the cell belongs, the list of atomic rows to which the cell belongs.

• the data of each table body cell is supplemented with information from the corresponding header cells;

• tokenize the text in the table;

• perform positional coding at the table row level;

• form token vector representations for each token in the table by aggregating token vector representations and positional vector representations;

• form an attention matrix using the cell’s belonging to a column or row of the table;

• store the coordinates of the table cell boundaries in the sequence of table tokens;

• the base model receives prepared text and positional vector representations of tokens and an attention matrix as input and processes them, obtaining contextualized vector representations of tokens;

• using the stored coordinates of the table cell boundaries, use pooling to obtain a vector representation of the table cell.

[19] In one of the specific examples of the system’s implementation, the basic model is further trained to perform a specific task.

[20] In another particular example of the system implementation, the base model is pre-trained on unstructured text for the domain, without the need for information about tables.

BRIEF DESCRIPTION OF DRAWINGS

[21] The features and advantages of the present technical solution will become apparent from the following detailed description and the accompanying drawings, in which:

[22] Fig. 1 illustrates a block diagram of the implementation of the claimed method.

[23] Fig. 2 illustrates the general scheme of operation of the method.

[24] Fig. 3 illustrates an example of the method operation.

[25] Fig. 4 illustrates the attention matrix.

[26] Fig. 5 illustrates a system for implementing the claimed method.

IMPLEMENTATION OF THE INVENTION

[27] Below we will describe the terms and concepts necessary for the implementation of this technical solution.

[28] Transformer is a deep neural network architecture introduced in 2017 by researchers at Google Brain. Similar to recurrent neural networks (RNNs), transformers are designed to process sequences such as natural language text and solve problems such as machine translation and automatic summarization. Unlike RNNs, transformers do not require processing sequences in order. For example, if the input is text, a transformer does not need to process the end of the text after processing its beginning. Due to this, transformers are easier to parallelize than RNNs and can be trained faster. The transformer architecture consists of an encoder and a decoder. The encoder receives a vectorized sequence with positional information as input. The decoder receives a portion of this sequence and the output of the encoder. The encoder and decoder are composed of layers. The encoder layers sequentially pass the result to the next layer as its input. The decoder layers sequentially pass the output to the next layer, along with the encoder output as its input. Each encoder consists of a self-attention mechanism (input from the previous layer) and a feedforward neural network (input from the self-attention mechanism). Each decoder consists of a self-attention mechanism (input from the previous layer), an attention mechanism to the encoding results (input from the self-attention mechanism and the encoder), and a feedforward neural network (input from the attention mechanism).

[29] An embedding is a vector represented as an array of numbers that results from transforming data, such as text. The combination of these numbers that make up the vector acts as a multidimensional map for measuring similarity.

Using vector representations (embeddings) allows:

• reduce the dimensionality of data - using embeddings, you can represent text queries as numerical vectors, which allows you to reduce the dimensionality of data and speed up its processing;

• improve search quality - embeddings allow you to evaluate the similarity between text queries based on the distance between the corresponding vectors. This improves search quality and the relevance of results;

• provide versatility - embeddings can be used for various natural language processing tasks, such as Retrieval Augmented Generation (RAG), text classification, clustering and others.

[30] Pooling is an operation in image and other data processing that is used to reduce the dimensionality of data and extract the most significant features. There are several types of pooling, including max pooling and average pooling.

[31] The claimed technical solution may be implemented, for example, by a system, a machine-readable medium, a server, etc. In this technical solution, a system means, among other things, a computer system, a computer (electronic computer), a CNC (computer numerical control), a programmable logic controller (PLC), computerized control systems, and any other devices capable of performing a given, clearly defined sequence of operations (actions, instructions).

[32] A command processing unit is an electronic unit or integrated circuit (microprocessor) that executes machine instructions (programs).

[33] The command processing unit reads and executes machine instructions (programs) from one or more data storage devices, such as random access memory (RAM) and/or read-only memory (ROM). ROM may include, but is not limited to, hard disk drives (HDD), flash memory, solid-state drives (SSD), optical storage media (CD, DVD, BD, MD, etc.), etc.

[34] A program is a sequence of instructions intended for execution by a computer control device or a command processing device.

[35] The term "instructions" as used in this application may refer generally to software instructions or software commands that are written in a given programming language to perform a specific function, such as, for example, receiving and processing data, forming a user profile, receiving and transmitting signals, analyzing received data, identifying a user, etc. The instructions may be implemented in a variety of ways, including, for example, object-oriented methods. For example, the instructions may be implemented using the C++ programming language, Java, Python, various libraries (e.g., Microsoft Foundation Classes), etc. The instructions that perform the processes described in this solution may be transmitted via both wired and wireless data transmission channels, such as Wi-Fi, Bluetooth, USB, WLAN, LAN, etc.

[36] The presented method for obtaining vector representations of data in a table taking into account the structure of the table and its contents (Fig. 1 shows a block diagram of the method) solves the problems of accelerating the process of training a language model when working with tabular documents and increasing the accuracy of solving problems of a language model when working with tabular documents by sequentially performing the following steps:

• receive data including: text, table structure;

• a table is defined as a set of a list of table header cells and a list of table body cells;

• each cell of the table body is marked with tags that characterize: the table identifier, the list of atomic columns to which the cell belongs, the list of atomic rows to which the cell belongs.

• the data of each table body cell is supplemented with information from the corresponding header cells;

• tokenize the text in the table;

• perform positional coding at the table row level;

• form token vector representations for each token in the table by aggregating token vector representations and positional vector representations;

• form an attention matrix using the cell’s belonging to a column or row of the table;

• store the coordinates of the table cell boundaries in the sequence of table tokens;

• the base model receives prepared text and positional vector representations of tokens and an attention matrix as input and processes them, obtaining contextualized vector representations of tokens;

• using the stored coordinates of the table cell boundaries, use pooling to obtain a vector representation of the table cell.

[37] The proposed method (Fig. 2 shows the general scheme of the method's operation) makes changes to the structure of the standard models without changing the distribution of input embeddings (it does not add a new type of positional, rank or other embeddings and does not redefine the use of standard types of embeddings and tokens), therefore it does not require additional pre-training on a large amount of data, and allows the use of open models in a selected language or pre-training for fitting to a domain (construction documentation, financial reports, legal documents, etc.) without the need for specific pre-processing or data selection. It also allows the use of models using not only text data as a base model, but also models using information from a picture and layout, such as UDOP and LayoutLMv3.

[38] Thus, the presented technical solution has the following advantages:

1) there is no need for additional pre-training to fit the architecture of the base embedder:

1. open models can be used;

2. it is possible to pre-train models for a domain on unstructured text;

3. the ability to use almost any model based on the transformer architecture as a base model, therefore, it is possible to also use information about the image and 2-D coordinates;

2) uses the structure of tabular data;

3) Provides the ability to work with a table of complex structure.

[39] In a specific example of the implementation of the declared technical solution (an example of operation is shown in Fig. 3), almost any model based on the transformer architecture and classification layer (for example, ruBert-base: https://huggingface.co/ai-forever/ruBert-base) can serve as the basis for the basic token embedder (ENC).

Token vector representations for each token in the linearized table are formed by aggregating token embeddings and position embeddings.

[40] A table is defined as a tuple T=(C, H), where - is a set of table body cells for n rows and m columns. Each cell is a sequence of tokens of length t. Table header - is a set of corresponding column header cells, where is a sequence of header tokens of length q.

Use T[i,:] to access the i-th row (H=T[k,:]), where k is the row with the end of the table header (the table may have a complex structure) and - to access the j-th column of T.

Let's give an example where each tagged cell has a sequence of NER tags: where everyone

IO tags are used, so where, for example, ENT ∈ {NUM,RES,0RG,T0T}.

Positional encoding occurs at the table row level, where table header tokens h _j are taken into account in the order calculation, thus preserving the distribution in the input layer of the base model.

A table attention mask (visibility matrix) α _i,j is used, but at the token level rather than the cell level. This mask allows each token to access only tokens in the same row or column, α _i,j is a symmetric binary matrix defined as:

Here row (col) are functions that map linearized token indices back to row (column) indices in the table.

Classification occurs at the cell level (which does not cancel the possibility of classification at the token level, but it increases the probability of error and entity rupture within the cell, and therefore requires a large amount of data to obtain a comparable result), therefore, not only the coordinates of the original words in the token sequence are saved (bpe usually depends on the model), but also the coordinates of the table cell boundaries in the token sequence.

The output of the token encoder layer is a sequence of token representations:

Using the stored table cell (or word) boundaries, pooling (https://arxiv.org/abs/2009.07485 - max, weighted average, or other types of pooling) is performed to obtain a table cell representation. The preferred pooling method may depend on the architecture and pretraining method of the underlying embedder.

These representations are then fed into a classification layer with Softmax activation to assign a score to each class token.

[41] As a detailed example of implementation, a description of a particular embodiment of the method is presented:

Step 1: receive data including: text, table structure;

At the entrance comes:

1) Image in the form of a table, example below:

2) Results of full-text image recognition including text, its location and table structure using, for example, tools such as SberOCR, Tesseract, ABBYY FineReader or others).

Below is an example of the resulting full-text recognition (using SberOCR). General information:

Below is an example of the resulting full-text recognition (using SberOCR). A separate cell:

Step 2: A table is defined as a set of a list of table header cells and a list of table body cells.

Below is an example of a visual representation of a table as a header and a sequence of numbered cells and columns:

Step 3: Each cell of the table body is marked with tags that characterize: the table identifier, the list of atomic columns to which the cell belongs, the list of atomic rows to which the cell belongs.

The text is split into sequences. Each sequence contains information about the table (table_id), column (column_idxs) and table row (row_idxs). For non-table sequences, these values are None. An example of the sequences read is shown below:

Step 4: The data of each table body cell is supplemented with information from the corresponding header cells. Header cells are limited to the lower value of the row or are defined manually:

The data of each table body cell is supplemented with information from the corresponding header cells:

Step 5: Tokenize the text in the table.

The text is broken down into parts of the text (tokens) that are significant for the model and supplemented with service tokens necessary for the model to work - below is an example of tokens that are significant for the model and those obtained from the source text:

Step 6: Perform positional encoding at the table row level. Positional encoding occurs at the table row level, where table header tokens are taken into account in the order calculation, thus preserving the distribution in the input layer of the base model.

Step 7: generate token vector representations for each token in the table by aggregating token vector representations and positional vector representations - below is an example of the vector representations obtained from the first part of the transformer-encoder model:

Step 8: Form an attention matrix using the cell's belonging to a column or row of the table. The attention matrix is passed to the transformer model. The attention matrix consists of 0 and 1. Where the value 1 means that the tokens are conditioned on each other, i.e. dependent. The value 0 means that the tokens are independent for the model and are not required to perform calculations for these tokens. Each token in and outside the table is conditioned on all tokens outside the table. Inside the table, tokens are conditioned only on tokens in the same row or column. Fig. 4 shows the attention matrix, where white is 1, black is 0.

Step 9: Store the coordinates of the table cell boundaries in the table token sequence.

Sequence boundaries (rows outside tables and cells in tables) are stored as a list, where the first value points to the first token of the sequence (cell or row), the second value points to the last token of the sequence (cell or row), and will be used after obtaining vector representations of the tokens to obtain vector representations of the cells.

Below is an example of a list of sequence boundaries specified in tokens:

Step 10: The base model receives the prepared text and positional token embeddings and the attention matrix as input and processes them to obtain contextualized token embeddings.

The transformer model receives token indices, an attention matrix, and other information necessary for the operation of a specific model as input. At the output, we receive a list of vector representations of each token, enriched with contextual information important for this token. The number of output vectors is equal to the number of tokens.

The first step of the model is to obtain uncontextualized word vector representations from the dictionary. These are usually supplemented by a position vector representation.

These vector representations are then fed to the input of the main part of the transformer model, which contextualizes the vector representations of words using the self-attention mechanism.

The BertModel model from the transformers library was used as the base model:

https://github.com/huggingface/transformers/blob/main/transformers/models/bert/modeling_bert.py#L956.

Below is an example of a list of vector representations of tokens output from a transformer model:

Step 11: using the saved coordinates of the table cell boundaries, use pooling to obtain a vector representation of the table cell. Pooling is performed using the saved coordinates of the cell boundary. After applying token pooling within the boundaries of the saved tokens, we obtain the number of vectors equal to the number of table cells + the number of extra-table sequences (rows) - below is an example of a list of vector representations of sequences (cells and rows):

[42] In general (see Fig. 5), the system for obtaining vector representations of data in a table taking into account the structure of the table and its contents (500) contains one or more processors (501), memory means such as RAM (502) and ROM (503), and input/output interfaces (504), united by a common information exchange bus.

[43] The processor (501) (or several processors, a multi-core processor, etc.) can be selected from a range of devices that are widely used at present, for example, from manufacturers such as: Intel™, AMD™, Apple™, Samsung Exynos™, MediaTEK™, Qualcomm Snapdragon™, etc. The processor or one of the processors used in the system (500) must also include a graphics processor, for example, an NVIDIA GPU with a software model compatible with CUDA, or Graphcore, the type of which is also suitable for the full or partial implementation of the method, and can also be used for training and applying machine learning models in various information systems.

[44] RAM (502) is a random access memory and is intended for storing machine-readable instructions executed by the processor (501) for performing the necessary operations for logical data processing. RAM (502), as a rule, contains executable instructions of the operating system and the corresponding software components (applications, software modules, etc.). In this case, the available memory capacity of the graphic card or graphic processor may act as RAM (502).

[45] ROM (503) represents one or more permanent storage devices, such as a hard disk drive (HDD), a solid-state drive (SSD), flash memory (EEPROM, NAND, etc.), optical storage media (CD-R/RW, DVD-R/RW, BlueRay Disc, MD), etc.

[46] To organize the operation of the device components (500) and to organize the operation of external connected devices, various types of I/O interfaces (504) are used. The choice of the corresponding interfaces depends on the specific design of the computing device, which may include, but are not limited to: PCI, AGP, PS/2, IrDa, Fire Wire, LPT, COM, SATA, IDE, Lightning, USB (2.0, 3.0, 3.1, micro, mini, type C), TRS/Audio jack (2.5, 3.5, 6.35), HDMI, DVI, VGA, Display Port, RJ45, RS232, etc.

[47] To ensure user interaction with the device (500), various means (505) of I/O information are used, for example, a keyboard, display (monitor), touch display, touchpad, joystick, mouse, light pen, stylus, touch panel, trackball, speakers, microphone, augmented reality means, optical sensors, tablet, light indicators, projector, camera, biometric identification means (retina scanner, fingerprint scanner, voice recognition module), etc.

[48] The network interaction means (506) provides data transmission via an internal or external computer network, such as an Intranet, the Internet, a LAN, etc. One or more means (506) may be, but are not limited to: an Ethernet card, a GSM modem, a GPRS modem, an LTE modem, a 5G modem, a satellite communication module, an NFC module, a Bluetooth and/or BLE module, a Wi-Fi module, etc.

[49] The specific choice of device elements (500) for implementing various software and hardware architectural solutions may vary while maintaining the required functionality. In particular, such an implementation may be performed using electronic components used to create digital integrated circuits. I am not limited to, but may use microcircuits whose operating logic is determined during manufacture, or programmable logic integrated circuits (FPGAs), whose operating logic is specified by programming. For programming, programmers and debugging environments are used that allow you to specify the desired structure of a digital device in the form of a basic electrical circuit or a program in special hardware description languages: Verilog, VHDL, AHDL, etc. An alternative to FPGAs are: programmable logic controllers (PLCs), basic matrix crystals (BMCs), which require a factory production process for programming; ASICs - specialized custom large-scale integrated circuits (LSI), which are significantly more expensive for small-scale and individual production. Thus, the implementation can be achieved by standard means based on classical principles of implementing the basics of computing technology.

[50] The submitted application materials disclose preferred examples of the implementation of the technical solution and should not be interpreted as limiting other, particular examples of its implementation that do not go beyond the scope of the requested legal protection, which are obvious to specialists in the relevant field of technology.

Claims (31)

1. A method for obtaining vector representations of data in a table taking into account the table structure and its contents, implemented using a processor and a data storage device, including the following steps: - receive data including: text, table structure; - a table is defined as a set of a list of table header cells and a list of table body cells; - each cell of the table body is marked with tags that characterize: the table identifier, the list of atomic columns to which the cell belongs, the list of atomic rows to which the cell belongs. - the data of each table body cell is supplemented with information from the corresponding header cells; - tokenize the text in the table; - perform positional coding at the table row level; - form vector representations of tokens for each token in the table by aggregating vector representations of tokens and positional vector representations; - form an attention matrix using the cell’s belonging to a column or row of the table; - save the coordinates of the table cell boundaries in the sequence of table tokens; - the basic model receives prepared text and positional vector representations of tokens and an attention matrix as input and processes them, obtaining contextualized vector representations of tokens; - using the stored coordinates of the table cell boundaries, use pooling to obtain a vector representation of the table cell. 2. The method according to paragraph 1, characterized in that the basic model is further trained to perform a specific task. 3. The method according to item 1, characterized in that the base model is pre-trained on unstructured text for the domain, without the need for information about tables. 4. A system for obtaining vector representations of data in a table, taking into account the structure of the table and its contents, used for machine learning, containing: at least one data processing device; at least one data storage device; at least one program, where one or more programs are stored on one or more data storage devices and executed on one or more data processing devices, wherein the one or more programs ensure the execution of the following steps: - receive data including: text, table structure; - a table is defined as a set of a list of table header cells and a list of table body cells; - each cell of the table body is marked with tags that characterize: the table identifier, the list of atomic columns to which the cell belongs, the list of atomic rows to which the cell belongs. - the data of each table body cell is supplemented with information from the corresponding header cells; - tokenize the text in the table; - perform positional coding at the table row level; - form vector representations of tokens for each token in the table by aggregating vector representations of tokens and positional vector representations; - form an attention matrix using the cell’s belonging to a column or row of the table; - save the coordinates of the table cell boundaries in the sequence of table tokens; - the basic model receives prepared text and positional vector representations of tokens and an attention matrix as input and processes them, obtaining contextualized vector representations of tokens; - using the stored coordinates of the table cell boundaries, use pooling to obtain a vector representation of the table cell. 5. The system according to paragraph 4, characterized in that the basic model is further trained to perform a specific task. 6. The system according to item 4, characterized in that the base model is pre-trained on unstructured text for the domain, without the need for information about tables.