We study a new problem setting of information extraction (IE), referred to as text-to-table. In text-to-table, given a text, one creates a table or several tables expressing the main content of the text, while the model is learned from text-table pair data. The problem setting differs from those of the existing methods for IE. First, the extraction can be carried out from long texts to large tables with complex structures. Second, the extraction is entirely data-driven, and there is no need to explicitly define the schemas. As far as we know, there has been no previous work that studies the problem. In this work, we formalize text-to-table as a sequence-to-sequence (seq2seq) problem. We first employ a seq2seq model fine-tuned from a pre-trained language model to perform the task. We also develop a new method within the seq2seq approach, exploiting two additional techniques in table generation: table constraint and table relation embeddings. We consider text-to-table as an inverse problem of the well-studied table-to-text, and make use of four existing table-to-text datasets in our experiments on text-to-table. Experimental results show that the vanilla seq2seq model can outperform the baseline methods of using relation extraction and named entity extraction. The results also show that our method can further boost the performances of the vanilla seq2seq model. We further discuss the main challenges of the proposed task. The code and data are available at https://github. com/shirley-wu/text_to_table . 1 1 Introduction Information extraction (IE) is a task that aims to extract information of interest from text data and represent the extracted information in a structured form. Traditional IE tasks include named entity recognition which recognizes entities and their 1 The work was done when Xueqing Wu was an intern at ByteDance AI Lab. types (Huang et al., 2015; Ma and Hovy, 2016; Lample et al., 2016; Devlin et al., 2019), relation extraction which identifies the relationships between entities (Zheng et al., 2017; Zeng et al., 2018; Luan et al., 2019; Zhong and Chen, 2021), etc. Since the results of IE are structured, they can be easily used by computer systems in different applications such as text mining. In this work, we study IE in a new setting, referred to as text-to-table. First, the system receives a training dataset containing text-table pairs. Each text-table pair contains a text and a table (or tables) representing information needed for the target application extracted from the text. The system learns a model for information extraction. Next, the system employs the learned model to conduct information extraction from a new text and outputs the result in a table (or tables). Figure 1 gives an example of text-to-table, where the input (above) is a report of a basketball game, and the output (below) is two tables summarizing the scores of the 2518 teams and players from the input. Text-to-table is unique compared to the traditional IE approaches. First, text-to-data can be performed at both sentence-level and document-level. While the distinction between sentence and document level is vague, document-level extraction can produce a more complex output. As in the example in Figure 1, extraction of information is performed from the entire document. The extracted information contains multiple types of scores of teams and players in a basketball game structured in table format. Second, the schemas for extraction are implicitly included in the training data such as header names. There is no need to explicitly define the schemas, which reduces the need for manual efforts for schema design and annotations. Our work is inspired by research on the so-called table-to-text (or data-to-text) problem, which is the task of generating a description for a given table. Table-to-text is useful in applications where the content of a table needs to be described in natural language. Thus, text-to-table can be regarded as an inverse problem of table-to-text. However, there are also differences. Most notably, their applications are different. Text-to-table systems can automatically produce tables for text summarization and text mining. For example, the score tables of sports games and infoboxes of Wikipedia articles can serve as summaries of original documents. The score tables can be utilized to evaluate the ath-letes' performances, and the infoboxes can be used to construct a knowledge graph. In this work, we formalize text-to-table as a sequence-to-sequence (seq2seq) task. More specifically, we translate the text into a sequence representation of a table (or tables), where the schema of the table is implicitly contained in the representation. We build the seq2seq model on top of a pre-trained language model, which is the state-of-the-art approach for seq2seq tasks (Lewis et al., 2020; Raffel et al., 2020). Although the approach is a natural application of existing technologies, as far as we know, there has been no previous study to investigate to what extent the approach works. We also develop a new method for text-to-table within the seq2seq approach with two additional techniques, table constraint, and table relation embeddings. Table constraint controls the creation of rows in a table and table relation embeddings affect the alignments between cells and their row headers and column headers. Both are to make the generated table well-formulated. The approach to IE based on seq2seq has already been proposed. Methods for conducting individual tasks of relation extraction (Zeng et al., 2018; Nayak and Ng, 2020; Huang et al., 2021), named entity recognition (Chen and Moschitti, 2018; Yan et al., 2021), event extraction (Li et al., 2021; Lu et al., 2021) and role-filler entity extraction (Du et al., 2021; Huang et al., 2021) have been developed. Methods for jointly performing multiple tasks of named entity recognition, relation extraction, and event extraction have also been devised (Paolini et al., 2021). Most of the methods exploit suitable pre-trained models such as BERT. However, all the existing methods rely on predefined schemas for extraction. Moreover, their models are designed to extract information from short texts, rather than long texts, and extract information with simple structures (such as an entity and its type), rather than information with complicated structures (such as a table). We conduct extensive experiments on the four datasets. Results show that the vanilla seq2seq model fine-tuned from BART (Lewis et al., 2020) can outperform the state-of-the-art IE models fine-tuned from BERT (Devlin et al., 2019; Zhong and Chen, 2021). Furthermore, results show that our proposed approach to text-to-table with the two techniques can further improve the extraction accuracies. We also summarize the challenging issues with the seq2seq approach to text-to-table for future research. Our contributions are summarized as follows: 1. We propose the new task of text-to-table for IE. We derive four new datasets for the task from existing datasets. 2. We formalize the task as a seq2seq problem and propose a new method within the seq2seq approach using the techniques of table constraint and table relation embeddings. 3. We conduct extensive experiments to verify the effectiveness of the proposed approach. Information Extraction (IE) is the task of extracting information (structured data) from a text (un-structured data). For example, named entity recognition (NER) recognizes entities appearing in a text. Relation extraction (RE) identifies the relationships between entities. Event extraction (EE) discovers events occurring in a text. Role-filler entity extrac-2519 tion (REE) fills entities into event templates and is similar to EE. Traditionally, researchers formalize the task as a language understanding problem. The state-of-the-art methods for NER perform the task on the basis of the pre-trained language model BERT (De-vlin et al., 2019). The pipeline approach to RE divides the problem into NER and relation classification, and conducts the two sub-tasks in a sequential manner (Zhong and Chen, 2021), while the end-to-end approach jointly carries out the two sub-tasks (Zheng et al., 2017; Zeng et al., 2018; Luan et al., 2019). The state-of-the-art methods for EE also employ BERT and usually jointly train the models with other tasks such as NER and RE (Wad-den et al., 2019; Zhang et al., 2019; Lin et al., 2020). All the methods assume the use of pre-defined schemas (e.g., entity types for NER, entity and relation types for RE, and event templates for EE). Besides, most methods are designed for extraction from short texts. Therefore, existing methods for IE cannot be directly applied to text-to-table. Another series of related work is open information extraction (OpenIE), which aims to extract information from texts without relying on explicitly defined schemas (Banko et al., 2007; Wu and Weld, 2010; Mausam et al., 2012; Stanovsky et al., 2018; Zhan and Zhao, 2020). However, OpenIE aims to extract information with simple structures (i.e., relation tuples) from short texts, and the methods in OpenIE cannot be directly applied to text-to-table. IE is also conducted at document level, referred to as doc-level IE. For example, some NER methods directly perform NER on a long document (Strubell et al., 2017; Luo et al., 2018), and others encode each sentence in a document, use attention to fuse document-level information, and perform NER on each sentence (Hu et al., 2020; Xu et al., 2018). There are also RE methods that predict the relationships between entities in a document (Yao et al., 2019; Nan et al., 2020). However, existing doc-level IE approaches usually do not consider the extraction of complex relations between many items. Sequence-to-sequence (seq2seq) is the general problem of transforming one text into another text (Sutskever et al., 2014; Bahdanau et al., 2015), which includes machine translation, text summarization, etc. The use of the pre-trained language models of BART (Lewis et al., 2020) and T5 (Raf-fel et al., 2020) can significantly boost the performances of seq2seq, such as machine translation (Lewis et al., 2020; Raffel et al., 2020; Liu et al., 2020) and text summarization (Lewis et al., 2020; Raffel et al., 2020; Huang et al., 2020). Recently, some researchers also formalize the IE problems as seq2seq, that is, transforming the input text into an internal representation. One advantage is that one can employ a single model to extract multiple types of information. Results show that this approach works better than or equally well as the traditional approach of language understanding, in RE (Zeng et al., 2018; Nayak and Ng, 2020), NER (Chen and Moschitti, 2018; Yan et al., 2021), EE (Li et al., 2021; Lu et al., 2021) and REE (Du et al., 2021; Huang et al., 2021). Methods that jointly perform multiple tasks including NER, RE, and EE have also been devised (Paolini et al., 2021). Data-to-text aims to generate natural language descriptions from the input structured data such as sports commentaries (Wiseman et al., 2017). The structured data is usually represented as tables (Wiseman et al., 2017; Thomson et al., 2020; Chen et al., 2020), sets of table cells (Parikh et al., 2020; Bao et al., 2018), semantic representations (Novikova et al., 2017), or sets of relation triples (Gardent et al., 2017; Nan et al., 2021). The task requires the model to select the salient information from the data, organize it in a logical order, and generate an accurate and fluent natural language description (Wiseman et al., 2017). Data-to-text models usually adopt the encoder-decoder architecture. The encoders are specifically designed to model the input data, such as multi-layer percep-tron (Puduppully et al., 2019a,b), recurrent neural network (Juraska et al., 2018; Liu et al., 2018; Shen et al., 2020), graph neural network (Marcheggiani and Perez-Beltrachini, 2018; Koncel-Kedziorski et al., 2019), or Transformer (Gong et al., 2019). As shown in Figure 1, text-to-table takes a text as input and produces a table or several tables to summarize the content of the text. Formally, the input is a text denoted as x = x 1 ,    , x | x | . The output is one table or multiple tables. For simplicity suppose that there is only one table denoted as T . Further, suppose that T has n r rows and n c columns. Thus, T contains n r  n c cells, where the cell of row i and column j is a sequence of words t i,j = t i,j, 1 , ..., t i,j, | t i,j | . There are three types of table: one that has both column headers and row headers, one that only has column headers, and one that only has row headers. For example, the player table in Figure 1 has both column headers (Assists, Points, etc) and row headers (Al Horford, Isaiah Thomas, etc). We let t 1 ,j , j = 2 ,    , n c denote the column headers, let t i, 1 , i = 2 ,    , n r denote the row headers, and let t i,j , i = 2 ,    , n r , j = 2 ,    , n c denote the non-header cells of the table. For example, in the player table in Figure 1, t 1 , 2 = Assists, t 2 , 1 = Al Horford, and t 2 , 2 = 5. The information extracted via text-to-table can be leveraged in many different applications such as document summarization and text mining. For example, in Figure 1, one can quickly obtain the key information of the text by simply looking at the tables summarized from the text. There are differences between text-to-table and traditional IE settings. As can be seen from the example in Figure 1, extraction of information is performed from the entire document. The extracted information (structured data) is in a complex form, specifically multiple types of scores of teams and players in a basketball game. Furthermore, the data-driven approach is taken, and the schemas of the tables do not need to be explicitly defined. The task of text-to-table also has challenges. First, parallel data containing texts and tables is difficult to obtain. Manual construction of such data is usually expensive. Second, structured information may not be easily represented as tables. For example, a knowledge graph may not be easily converted into tables. Third, evaluation of table extraction may not be easy, which includes multiple factors, such as header, content, and structure. We develop a method for text-to-table using the seq2seq approach and the two techniques of table constraint and table relation embeddings. We formalize text-to-table as a sequence-to-sequence (seq2seq) problem (Sutskever et al., 2014; Bahdanau et al., 2015). Specifically, given an input text, we generate a sequence representing the output table (or tables). We introduce two special tokens, a separation token denoted as   s   and a new-line token denoted as   n  . For a table t , we represent each row t i with a sequence of cells Figure 2: The sequence representation of the player table in Figure t =  s  , t 1 , 1 ,  s  ,    ,  s  , t 1 ,n c ,  s  ,  n  , (2)  s  , t 2 , 1 ,  s  ,    ,  s  , t 2 ,n c ,  s  ,  n  ,        s  , t n r , 1 ,  s  ,    ,  s  , t n r ,n c ,  s Figure 2 shows the sequence of the player table in Figure 1. When there are multiple tables, we create a sequence of tables using the captions of the tables as delimiters. Let x = x 1 ,    , x | x | and y = y 1 ,    , y | y | denote the input and output sequences respectively. In inference, the model generates the output sequence based on the input sequence. The model conducts generation in an auto-regressive way, which generates one token at each step based on the tokens it has generated so far. In training, we learn the model based on the text-table pairs { ( x 1 , y 1 ) , ( x 2 , y 2 ) ,    , ( x n , y n ) } . The objective of learning is to minimize the cross-entropy loss. We refer to the method described above as vanilla seq2seq. There is no guarantee, however, that the output sequence of vanilla seq2seq represents a well-formulated table. We add a postprocessing step to ensure that the output sequence is a table. The post-processing method takes the first row generated as well-defined, deletes extra cells at the end of the other rows, and inserts empty cells at the end of the other rows. We develop two techniques to improve table generation, called table constraint and table relation embeddings. We use our method to denote the seq2seq approach with these two techniques. 2 2 Our methods is able to generate the output containing multiple tables. Our method exploits a constraint in the decoding process to ensure that the output sequence represents a well-formulated table. Specifically, our method calculates the number of cells in the first row it generates, and then forces the following rows to contain the same number of cells. Our method also incorporates table relation embeddings including row relation embeddings and column relation embeddings into the self-attention of the Transformer decoder. Given a token in a non-header cell, the row relation embeddings  Kr and  Vr indicate which row header the token is aligned to, and the column relation embeddings  Kc and  Vc indicate which column header the token is aligned to. Let us consider the self-attention function in one block of Transformer decoder: at each position, self-attention only attends to the previous positions. For simplicity, let us only consider one head in the self-attention. At the t -th position, the input of self-attention is the sequence of representations z = ( z 1 ,    , z t ) and the output is the sequence of representations h = ( h 1 ,    , h t ) , where z i  R d and h i  R d are the representations at the i -th position ( i = 1 ,    , t ) . In a conventional Transformer decoder, self-attention is defined as follows, h i =   i (cid:88) j =1  ij ( z j WV )   WO , (3)  ij = e e ij (cid:80) ij =1 e e ij , e ij = ( z i WQ )( z j WK ) T  d k , (4) i = 1 ,    , t, j = 1 ,    , i where WQ , WK , WV  R d  d k are the query, key, and value weight matrices respectively, and WO  R d k  d is the output weight matrix. where r Kij and r Vij are relation vectors representing the relationship between the i -th position and the j -th position. The relation vectors r Kij and r Vij are defined as follows. For the token at the i -th position, if the token at the j -th position is a part of its row header, then r Kij and r Vij are set to the row relation embeddings  Kr and  Vr . Similarly, for the token at the i -th position, if the token at the j -th position is a part of its column header, then r K ij and r V ij are set to the column relation embeddings  Kc and  Vc . Otherwise, r Kij and r Vij are set to 0 . In inference, to identify the row header or the column header of a token, we parse the sequence generated so far to create a partial table using the new-line tokens and separation tokens in the sequence. Figure 3 illustrates how relation vectors are constructed. We make use of four existing datasets which are traditionally utilized for data-to-text: Rotowire (Wise-man et al., 2017), E2E (Novikova et al., 2017), WikiTableText (Bao et al., 2018), and WikiBio (Le-bret et al., 2016). In each dataset, we filter out the content in the tables that does not appear in the texts. We plan to make the processed datasets publicly available for future research. Table 2 gives the statistics of the Rotowire dataset and Table 1 gives the statistics of the other three datasets. Rotowire is from the sports domain. Each instance is composed of a text and two tables, where the text is a report of a basketball game and the two tables represent the scores of teams and players respectively (cf., Figure 1). Each table has column headers describing the types of scores, and row headers describing the names of teams or players. The texts are long and may contain irrelevant information such as the performance of players in other games. Therefore, this is a challenging dataset. stance is a pair of short text and an automatically constructed table, where the text is a description of a restaurant, and the table has two columns with row headers summarizing the characteristics of the restaurant. The tables are automatically constructed, where the texts in the tables are from a limited set and thus lack diversity. WikiTableText is an open-domain dataset. Each instance includes a text and a table, where the text is a description and the table has a row and two columns with row headers collected from Wikipedia. The texts are short and contain information similar to that in the tables. WikiBio is extracted from the Wikipedia biography pages. Each instance consists of a text and a table, where the text is the introduction of Wikipedia page 3 and the table is from the infobox of a Wikipedia page and has two columns with row headers. The input texts are usually long and contain more information than the tables. We know of no existing method that can be directly employed in text-to-table. For each dataset, we first define the schemas based on the training data, then use an existing method of relation extraction (RE) or named entity extraction (NER) to extract information, and finally create tables based on the schemas and extracted information. We take 3 The original dataset only uses the first sentence of the introduction. We use the entire introduction. it as the baseline for the dataset. No baseline can be applied to all four datasets. For RE, we use PURE, a state-of-the-art method (Zhong and Chen, 2021). For NER, we use BERT (Devlin et al., 2019). Training: For vanilla seq2seq and our method, we adopt Transformer (Vaswani et al., 2017) as the model and fine-tune the models from BART-base. We also experiment with BART-large. For RE and NER, we fine-tune the models from BERT-base-uncased. All models are trained with Adam optimizer until convergence. Hyper-parameters are shown in Appendix A. For the small datasets of Rotowire and WikiTableText, we run experiments five times with different random seeds and take the average of results to reduce variance. Evaluation: We evaluate the performance of a method based on (1) the number of correct headers and (2) the number of correct non-header cells. We adopt the F1 score as the evaluation measure. For each table, we compare the set of predicted results y against the set of ground-truth y  . Precision is defined as the percentage of the correctly predicted results among the predicted results, i.e., P = 1 | y | (cid:80) y  y max y   y  O ( y, y  ) . Recall is defined as the percentage of the correctly predicted results among the ground-truth, i.e., R = 1 | y  | (cid:80) y   y  max y  y O ( y, y  ) . Finally, F 1 = 2 / (1 /P + 1 /R ) . Here, O (  ) denotes a way of similarity calculation. We consider three ways: exact match, chrf (Popovic, 2015) and rescaled BERTScore (Zhang et al., 2020). Exact match conducts an exact match between two texts. Chrf calculates character-level n-gram similarity between two texts. BERTScore calculates the similarity of BERT embeddings between two texts. For non-header cells, we use not only the content but also the header(s) to ensure that the cell is on the right row (and column), and calculate the similarity O (  ) as the product of header similarity and cell content similarity. 4 We evaluate the measures of a 4 As shown in Figure 1, the tables in the dataset contain empty cells. The empty cells do not contain information. Therefore, we ignore the empty cells and only use the nonempty cells in the evaluation. generated table and then take the average on all tables. This evaluation assumes that the order of rows and columns is not important. We find that this assumption is applicable to the four datasets and many real-world scenarios. We also evaluate the percentage of output sequences that cannot represent well-formulated tables, referred to as error rate. Table 3 shows the results on the Rotowire dataset. One can see that our method performs the best followed by vanilla seq2seq in terms of most of the measures, especially the F1 score on non-header cells. Both outperform the baselines of doc-level RE and sent-level RE. The RE baselines perform quite well, but they heavily rely on rules and cannot beat the seq2seq approach. Among them, the doc-level RE performs better than sent-level RE, because some information in Rotowire can only be extracted when the cross-sentence context is provided. We implement two baselines of RE, namely doc-level RE and sent-level RE. We take team names, player names, and numbers of scores as entities and take types of scores as relations. Sent-level RE predicts the relations between entities within each sentence. Doc-level RE predicts the relations between entities within a window (the window size is 12 entities) and uses the approximation model proposed by Zhong and Chen (2021) to speed up inference. Table 4 shows the results of our method, vanilla seq2seq, and the baseline of NER on E2E, WikiTableText, and WikiBio. Again, the seq2seq approach outperforms the baseline. Our method and vanilla seq2seq are comparable, because the table structures in the three datasets are very simple (there are only two columns in the tables), and the use of the two techniques does not further improve the performances. The NER baseline has high precision but low recall, mainly because NER can only make the right decision when it is clear. We implement the baseline of NER in the following way. We view the non-head cells in the tables as entities and their row headers as entity types. In training, we match the non-head cells into the texts 2524 Pre TC TRE Rotowire/Team Rotowire/Player E2E WikiTableText WikiBio    28.05 7.75 94.45 46.37 67.51    30.61 10.67 95.53 47.13 67.43    82.97 81.96 97.87 59.26 68.98    83.09  82.24  97.88 59.29  68.98    83.30  82.50  97.87 59.12 69.02    83.36  82.53  97.88 59.14 69.02 Table 5: Results of ablation study on our method by excluding pre-trained language model (Pre), table constraint (TC) and table relation embeddings (TRE). Method Rotowire/Team Rotowire/Player E2E WikiTableText WikiBio Vanilla seq2seq (BART base) 82.97 81.96 97.87 59.26 68.98 Our method (BART base) 83.36 82.53 97.88 59.14 69.02 Vanilla seq2seq (BART large) 86.31 86.59 97.94 62.71 69.66 Our method (BART large) 86.31 86.83 97.90 62.41 69.71 Table 6: Results of our method and vanilla seq2seq with base and large BART models on all four datasets. and take them as entities in the texts. Only a proportion of the non-header cells can be matched into the texts ( 85% for E2E, 74% for WikiTableText, and 69% for WikiBio). We carry out an ablation study on our method. Specifically, we exclude pre-trained language model, table constraint (TC), and table relation embeddings (TRE) from our method. Note that our method without TC and TRE is equivalent to vanilla seq2seq. Table 5 gives the results on the four datasets. It can be seen that the use of both TC and TRE can significantly improve the performance on Rotowire, which indicates that our method is particularly effective when the tables are large with many rows and columns. There are no significant improvements on E2E, WikiTableText, and WikiTableText, apparently because the formulation of tables is easy for the three datasets. Therefore, we conclude that the two techniques of TC and TRE are helpful when the task is difficult. Rotowire and WikiTableText. This indicates that pre-trained language model is particularly helpful when the task is difficult and the size of training data is small. We observe that vanilla seq2seq makes more formatting errors than our method, especially on player tables in Rotowire that have a large number of columns. It indicates that for vanilla seq2seq, it is difficult to keep track of the columns in each row and make alignments with the column headers. In contrast, the two techniques of our method can help effectively cope with the problem. Figure 4 shows a bad case of vanilla seq2seq, where the model correctly infers the column of assists but fails to infer the columns of personal fouls, points, and total rebounds for the row of Rajon Rondo. In contrast, our method can successfully handle the case, because TC can eliminate the incorrectly formatted output, and TRE can make correct alignments with the column headers. We also investigate the effect of the scale of pre-trained language model BART. We use both BART-base and BART-large and conduct fine-tuning on top of them for vanilla seq2seq and our method. Table 6 gives the results on the four datasets. The 2525 results show that the use of BART-large can further boost the performances on all four datasets, indicating that it is better to use larger pre-trained models when computation cost is not an issue. We analyze the experimental results on the four datasets and identify five challenging issues. (1) Text Diversity: Extraction of the same content from different expressions is one challenge. For example, the use of synonyms is very common in Rotowire. The team of Knicks is often referred to as New York, its home city. Identification of the same entities from different expressions is needed in the task. (2) Text Redundancy: There are cases such as those in WikiBio, in which the texts contain much redundant information. This poses a challenge to the text-to-table model to have a strong ability in summarization. It seems that the seq2seq approach works well to some extent but further improvement is undoubtedly necessary. (3) Large Table: The tables in Rotowire have large numbers of columns, and the extraction from them is challenging even for our method of using TC and TRE. (4) Background Knowledge: WikiTableText and WikiBio are from open domain. Thus, performing text-to-table on such kind of datasets require the use of much background knowledge. A possible way to address this challenge is to use more powerful pre-trained language models or external knowledge bases. (5) Reasoning: Sometimes the information is not explicitly presented in the text, and reasoning is required to conduct correct extraction. For example, an article in Rotowire reports a game between the two teams Nets and Wizards. From the sentence: The Nets seized control of this game from the very start, opening up a 31 14 lead after the first quarter, humans can infer that the point of Wizards is 14 , which is still difficult for machines. We propose employing text-to-table as a new way of information extraction (IE), which extracts information of interest from the input text and summarizes the extracted information in tables. The advantage of the approach is that one can easily conduct information extraction from either short texts or long texts to create simple tables or complex tables without explicitly defining the schemas. Text-to-table can be viewed as an inverse problem of table-to-text. We formalize text-to-table as a sequence-to-sequence problem on top of a pre-trained model. We further propose an improved method using a seq2seq model and table constraint and table relation embeddings techniques. We conduct experiments on four datasets derived from existing table-to-text datasets. The results demonstrate that our proposed approach outperforms existing methods using conventional IE techniques. We further analyze the challenges of text-to-table for future study. The issues include diversity of text, redundancy of text, large table, background knowledge, and reasoning.
objective abstain abstain abstain abstain method objective objective objective method abstain result objective other abstain abstain abstain abstain abstain objective abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain method abstain abstain abstain abstain abstain abstain abstain objective abstain method objective objective abstain abstain abstain other abstain abstain abstain abstain method abstain objective objective objective objective objective objective objective other other other other other other other other other other other other other other other other other other other other other other other other other other other other other abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain method method method method method other abstain method abstain abstain abstain abstain abstain abstain abstain method abstain method method method method abstain abstain abstain method method abstain other abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain result abstain abstain result abstain abstain abstain abstain abstain abstain abstain abstain abstain result abstain abstain abstain abstain result abstain abstain result abstain abstain abstain abstain abstain abstain abstain result abstain result abstain abstain abstain result result abstain abstain abstain abstain abstain abstain result abstain abstain abstain abstain result abstain abstain abstain abstain abstain abstain abstain abstain result abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain objective abstain abstain objective objective method objective method abstain