TAPAS

概述

TAPAS 模型在 TAPAS: Weakly Supervised Table Parsing via Pre-training 中被提出，作者是 Jonathan Herzig、Paweł Krzysztof Nowak、Thomas Müller、Francesco Piccinno 和 Julian Martin Eisenschlos。它是一个基于 BERT 的模型，专门设计（并经过预训练）用于回答有关表格数据的问题。与 BERT 相比，TAPAS 使用相对位置嵌入，并有 7 种标记类型来编码表格结构。TAPAS 在掩码语言建模 (MLM) 目标上进行了预训练，数据集包含来自英语维基百科的数百万个表格和相应的文本。

对于问答，TAPAS 在顶部有 2 个头：一个单元格选择头和一个聚合头，用于（可选地）在选定的单元格之间执行聚合（例如计数或求和）。TAPAS 已经在几个数据集上进行了微调

SQA（微软的顺序问题回答）
WTQ（斯坦福大学的 Wiki 表格问题）
WikiSQL（Salesforce 出品）。

它在 SQA 和 WTQ 上都取得了最先进的成果，同时在 WikiSQL 上具有与 SOTA 相当的性能，并且架构更简单。

论文的摘要如下

回答表格上的自然语言问题通常被视为语义解析任务。为了减轻完整逻辑形式的收集成本，一种流行的方法侧重于弱监督，包括外延而不是逻辑形式。然而，从弱监督中训练语义解析器会带来困难，此外，生成的逻辑形式仅用作检索外延之前的中间步骤。在本文中，我们提出了 TAPAS，一种无需生成逻辑形式的表格问答方法。TAPAS 从弱监督中进行训练，并通过选择表格单元格并可选地将相应的聚合运算符应用于此类选择来预测外延。TAPAS 扩展了 BERT 的架构以将表格编码为输入，从维基百科抓取的文本段和表格的有效联合预训练中初始化，并进行端到端训练。我们使用三个不同的语义解析数据集进行了实验，发现 TAPAS 通过将 SQA 的最先进准确率从 55.1 提高到 67.2，并在 WIKISQL 和 WIKITQ 上与最先进水平相当，但模型架构更简单，从而优于或匹敌语义解析模型。我们还发现，从 WIKISQL 到 WIKITQ 的迁移学习（在我们的设置中这很简单）产生了 48.7 的准确率，比最先进水平高出 4.2 个百分点。

此外，作者还进一步预训练了 TAPAS 以识别表格蕴含，方法是创建一个平衡的数据集，其中包含数百万个自动创建的训练示例，这些示例在微调之前的中间步骤中学习。TAPAS 的作者将这种进一步的预训练称为中间预训练（因为 TAPAS 首先在 MLM 上进行预训练，然后在另一个数据集上进行预训练）。他们发现，中间预训练进一步提高了 SQA 的性能，在 TabFact（一个包含 1.6 万个维基百科表格的大规模数据集，用于表格蕴含（二元分类任务））上取得了新的最先进水平以及最先进水平。有关更多详细信息，请参阅他们的后续论文：Julian Martin Eisenschlos、Syrine Krichene 和 Thomas Müller 的通过中间预训练理解表格。

TAPAS 架构。摘自原始博客文章。

此模型由 nielsr 贡献。此模型的 Tensorflow 版本由 kamalkraj 贡献。原始代码可以在此处找到。

使用技巧

TAPAS 是一个默认使用相对位置嵌入的模型（在表格的每个单元格处重新启动位置嵌入）。请注意，这是在原始 TAPAS 论文发表后添加的内容。根据作者的说法，这通常会带来稍好的性能，并允许您编码更长的序列而不会耗尽嵌入。这反映在 TapasConfig 的 reset_position_index_per_cell 参数中，该参数默认设置为 True。在 hub 上可用的模型的默认版本都使用相对位置嵌入。您仍然可以通过在调用 from_pretrained() 方法时传入额外的参数 revision="no_reset" 来使用具有绝对位置嵌入的版本。请注意，通常建议在右侧而不是左侧填充输入。
TAPAS 基于 BERT，因此例如 TAPAS-base 对应于 BERT-base 架构。当然，TAPAS-large 将产生最佳性能（论文中报告的结果来自 TAPAS-large）。各种尺寸模型的結果显示在原始 GitHub 存储库上。
TAPAS 具有在 SQA 上微调的检查点，这些检查点能够回答与会话设置中的表格相关的问题。这意味着您可以提出后续问题，例如与上一个问题相关的“他的年龄是多少？”。请注意，在会话设置中，TAPAS 的前向传递略有不同：在这种情况下，您必须将每个表格-问题对逐个馈送到模型，以便 prev_labels 标记类型 ID 可以被模型对上一个问题的预测 labels 覆盖。有关更多信息，请参阅“用法”部分。
TAPAS 与 BERT 类似，因此依赖于掩码语言建模 (MLM) 目标。因此，它在预测掩码标记和一般 NLU 方面很有效，但对于文本生成来说不是最佳选择。使用因果语言建模 (CLM) 目标训练的模型在这方面更好。请注意，TAPAS 可以用作 EncoderDecoderModel 框架中的编码器，以将其与诸如 GPT-2 之类的自回归文本解码器结合使用。

用法：微调

在这里，我们解释如何在你自己的数据集上微调 TapasForQuestionAnswering。

步骤 1：选择您可以使用 TAPAS 的 3 种方式之一 - 或进行实验

基本上，有 3 种不同的方式可以微调 TapasForQuestionAnswering，对应于 Tapas 进行微调的不同数据集

SQA：如果您有兴趣在会话设置中提出与表格相关的后续问题。例如，如果您首先问“第一个演员的名字是什么？”，那么您可以问一个后续问题，例如“他多大了？”。在这里，问题不涉及任何聚合（所有问题都是单元格选择问题）。
WTQ：如果您对在会话设置中提问不感兴趣，而只是对提出与表格相关的问题感兴趣，这些问题可能涉及聚合，例如计算行数、对单元格值求和或平均单元格值。然后，您可以例如问“克里斯蒂亚诺·罗纳尔多在他的职业生涯中进了多少个球？”。这种情况也称为弱监督，因为模型本身必须学习适当的聚合运算符（SUM/COUNT/AVERAGE/NONE），仅以问题的答案作为监督。
WikiSQL-supervised：此数据集基于 WikiSQL，模型在训练期间被赋予了真实聚合运算符。这也称为强监督。在这里，学习适当的聚合运算符要容易得多。

总结一下

任务	示例数据集	描述
会话式	SQA	会话式，仅单元格选择问题
聚合的弱监督	WTQ	问题可能涉及聚合，并且模型必须仅根据答案作为监督来学习这一点
聚合的强监督	WikiSQL-supervised	问题可能涉及聚合，并且模型必须根据黄金聚合运算符来学习这一点

Pytorch

隐藏 Pytorch 内容

从 hub 初始化具有预训练基础和随机初始化的分类头的模型可以如下所示完成。

>>> from transformers import TapasConfig, TapasForQuestionAnswering

>>> # for example, the base sized model with default SQA configuration
>>> model = TapasForQuestionAnswering.from_pretrained("google/tapas-base")

>>> # or, the base sized model with WTQ configuration
>>> config = TapasConfig.from_pretrained("google/tapas-base-finetuned-wtq")
>>> model = TapasForQuestionAnswering.from_pretrained("google/tapas-base", config=config)

>>> # or, the base sized model with WikiSQL configuration
>>> config = TapasConfig("google-base-finetuned-wikisql-supervised")
>>> model = TapasForQuestionAnswering.from_pretrained("google/tapas-base", config=config)

当然，您不一定必须遵循 TAPAS 进行微调的这三种方式之一。您还可以通过在初始化 TapasConfig 时定义您想要的任何超参数来进行实验，然后基于该配置创建 TapasForQuestionAnswering。例如，如果您的数据集既有会话式问题，又有可能涉及聚合的问题，那么您可以这样做。这是一个例子

>>> from transformers import TapasConfig, TapasForQuestionAnswering

>>> # you can initialize the classification heads any way you want (see docs of TapasConfig)
>>> config = TapasConfig(num_aggregation_labels=3, average_logits_per_cell=True)
>>> # initializing the pre-trained base sized model with our custom classification heads
>>> model = TapasForQuestionAnswering.from_pretrained("google/tapas-base", config=config)

TensorFlow

隐藏 TensorFlow 内容

从 hub 初始化具有预训练基础和随机初始化的分类头的模型可以如下所示完成。请确保已安装 tensorflow_probability 依赖项

>>> from transformers import TapasConfig, TFTapasForQuestionAnswering

>>> # for example, the base sized model with default SQA configuration
>>> model = TFTapasForQuestionAnswering.from_pretrained("google/tapas-base")

>>> # or, the base sized model with WTQ configuration
>>> config = TapasConfig.from_pretrained("google/tapas-base-finetuned-wtq")
>>> model = TFTapasForQuestionAnswering.from_pretrained("google/tapas-base", config=config)

>>> # or, the base sized model with WikiSQL configuration
>>> config = TapasConfig("google-base-finetuned-wikisql-supervised")
>>> model = TFTapasForQuestionAnswering.from_pretrained("google/tapas-base", config=config)

当然，您不一定必须遵循 TAPAS 进行微调的这三种方式之一。您还可以通过在初始化 TapasConfig 时定义您想要的任何超参数来进行实验，然后基于该配置创建 TFTapasForQuestionAnswering。例如，如果您的数据集既有会话式问题，又有可能涉及聚合的问题，那么您可以这样做。这是一个例子

>>> from transformers import TapasConfig, TFTapasForQuestionAnswering

>>> # you can initialize the classification heads any way you want (see docs of TapasConfig)
>>> config = TapasConfig(num_aggregation_labels=3, average_logits_per_cell=True)
>>> # initializing the pre-trained base sized model with our custom classification heads
>>> model = TFTapasForQuestionAnswering.from_pretrained("google/tapas-base", config=config)

您还可以从已微调的检查点开始。这里需要注意的是，由于 L2 损失有点脆弱，因此在 WTQ 上已经微调的检查点存在一些问题。有关更多信息，请参见此处。

有关 HuggingFace 的 hub 上可用的所有预训练和微调 TAPAS 检查点的列表，请参见此处。

步骤 2：以 SQA 格式准备数据

其次，无论您选择上述哪种方式，都应该以 SQA 格式准备数据集。此格式是一个 TSV/CSV 文件，包含以下列

id：可选，表格-问题对的 ID，用于簿记目的。
annotator：可选，注释表格-问题对的人员的 ID，用于簿记目的。
position：整数，指示问题是与表格相关的第一个、第二个、第三个……。仅在会话设置 (SQA) 中是必需的。如果您要使用 WTQ/WikiSQL-supervised，则不需要此列。
question：字符串
table_file：字符串，包含表格数据的 csv 文件的名称
answer_coordinates：一个或多个元组的列表（每个元组是一个单元格坐标，即答案的一部分的行、列对）
answer_text：一个或多个字符串的列表（每个字符串是答案一部分的单元格值）
aggregation_label：聚合运算符的索引。仅在聚合的强监督（WikiSQL-supervised 情况）中是必需的
float_answer：问题的浮点数答案（如果存在，则为 np.nan，如果不存在）。仅在聚合的弱监督（例如 WTQ 和 WikiSQL）中是必需的

表格本身应存在于文件夹中，每个表格都是一个单独的 csv 文件。请注意，TAPAS 算法的作者使用了转换脚本，其中包含一些自动化逻辑，用于将其他数据集 (WTQ, WikiSQL) 转换为 SQA 格式。作者在此处对此进行了解释。可以在此处找到此脚本的与 HuggingFace 的实现一起使用的转换。有趣的是，这些转换脚本并不完美（answer_coordinates 和 float_answer 字段是根据 answer_text 填充的），这意味着 WTQ 和 WikiSQL 结果实际上可以得到改进。

步骤 3：使用 TapasTokenizer 将数据转换为张量

Pytorch

隐藏 Pytorch 内容

第三，假设您已以此 TSV/CSV 格式（以及包含表格数据的相应 CSV 文件）准备好数据，那么您可以使用 TapasTokenizer 将表格-问题对转换为 input_ids、attention_mask、token_type_ids 等。同样，根据您选择的上述三种情况中的哪一种，TapasForQuestionAnswering 需要不同的输入进行微调

任务	必需的输入
会话式	`input_ids`、`attention_mask`、`token_type_ids`、`labels`
聚合的弱监督	`input_ids`、`attention_mask`、`token_type_ids`、`labels`、`numeric_values`、`numeric_values_scale`、`float_answer`
聚合的强监督	`input ids`、`attention mask`、`token type ids`、`labels`、`aggregation_labels`

TapasTokenizer 基于 TSV 文件的 answer_coordinates 和 answer_text 列创建 labels、numeric_values 和 numeric_values_scale。float_answer 和 aggregation_labels 已经位于步骤 2 的 TSV 文件中。这是一个例子

>>> from transformers import TapasTokenizer
>>> import pandas as pd

>>> model_name = "google/tapas-base"
>>> tokenizer = TapasTokenizer.from_pretrained(model_name)

>>> data = {"Actors": ["Brad Pitt", "Leonardo Di Caprio", "George Clooney"], "Number of movies": ["87", "53", "69"]}
>>> queries = [
...     "What is the name of the first actor?",
...     "How many movies has George Clooney played in?",
...     "What is the total number of movies?",
... ]
>>> answer_coordinates = [[(0, 0)], [(2, 1)], [(0, 1), (1, 1), (2, 1)]]
>>> answer_text = [["Brad Pitt"], ["69"], ["209"]]
>>> table = pd.DataFrame.from_dict(data)
>>> inputs = tokenizer(
...     table=table,
...     queries=queries,
...     answer_coordinates=answer_coordinates,
...     answer_text=answer_text,
...     padding="max_length",
...     return_tensors="pt",
... )
>>> inputs
{'input_ids': tensor([[ ... ]]), 'attention_mask': tensor([[...]]), 'token_type_ids': tensor([[[...]]]),
'numeric_values': tensor([[ ... ]]), 'numeric_values_scale: tensor([[ ... ]]), labels: tensor([[ ... ]])}

请注意，TapasTokenizer 期望表格的数据是纯文本。您可以在数据帧上使用 .astype(str) 将其转换为纯文本数据。当然，这仅显示了如何编码单个训练示例。建议创建一个数据加载器来迭代批次

>>> import torch
>>> import pandas as pd

>>> tsv_path = "your_path_to_the_tsv_file"
>>> table_csv_path = "your_path_to_a_directory_containing_all_csv_files"


>>> class TableDataset(torch.utils.data.Dataset):
...     def __init__(self, data, tokenizer):
...         self.data = data
...         self.tokenizer = tokenizer

...     def __getitem__(self, idx):
...         item = data.iloc[idx]
...         table = pd.read_csv(table_csv_path + item.table_file).astype(
...             str
...         )  # be sure to make your table data text only
...         encoding = self.tokenizer(
...             table=table,
...             queries=item.question,
...             answer_coordinates=item.answer_coordinates,
...             answer_text=item.answer_text,
...             truncation=True,
...             padding="max_length",
...             return_tensors="pt",
...         )
...         # remove the batch dimension which the tokenizer adds by default
...         encoding = {key: val.squeeze(0) for key, val in encoding.items()}
...         # add the float_answer which is also required (weak supervision for aggregation case)
...         encoding["float_answer"] = torch.tensor(item.float_answer)
...         return encoding

...     def __len__(self):
...         return len(self.data)


>>> data = pd.read_csv(tsv_path, sep="\t")
>>> train_dataset = TableDataset(data, tokenizer)
>>> train_dataloader = torch.utils.data.DataLoader(train_dataset, batch_size=32)

TensorFlow

隐藏 TensorFlow 内容

第三，假设您已以此 TSV/CSV 格式（以及包含表格数据的相应 CSV 文件）准备好数据，那么您可以使用 TapasTokenizer 将表格-问题对转换为 input_ids、attention_mask、token_type_ids 等。同样，根据您选择的上述三种情况中的哪一种，TFTapasForQuestionAnswering 需要不同的输入进行微调

任务	必需的输入
会话式	`input_ids`、`attention_mask`、`token_type_ids`、`labels`
聚合的弱监督	`input_ids`、`attention_mask`、`token_type_ids`、`labels`、`numeric_values`、`numeric_values_scale`、`float_answer`
聚合的强监督	`input ids`、`attention mask`、`token type ids`、`labels`、`aggregation_labels`

>>> from transformers import TapasTokenizer
>>> import pandas as pd

>>> model_name = "google/tapas-base"
>>> tokenizer = TapasTokenizer.from_pretrained(model_name)

>>> data = {"Actors": ["Brad Pitt", "Leonardo Di Caprio", "George Clooney"], "Number of movies": ["87", "53", "69"]}
>>> queries = [
...     "What is the name of the first actor?",
...     "How many movies has George Clooney played in?",
...     "What is the total number of movies?",
... ]
>>> answer_coordinates = [[(0, 0)], [(2, 1)], [(0, 1), (1, 1), (2, 1)]]
>>> answer_text = [["Brad Pitt"], ["69"], ["209"]]
>>> table = pd.DataFrame.from_dict(data)
>>> inputs = tokenizer(
...     table=table,
...     queries=queries,
...     answer_coordinates=answer_coordinates,
...     answer_text=answer_text,
...     padding="max_length",
...     return_tensors="tf",
... )
>>> inputs
{'input_ids': tensor([[ ... ]]), 'attention_mask': tensor([[...]]), 'token_type_ids': tensor([[[...]]]),
'numeric_values': tensor([[ ... ]]), 'numeric_values_scale: tensor([[ ... ]]), labels: tensor([[ ... ]])}

>>> import tensorflow as tf
>>> import pandas as pd

>>> tsv_path = "your_path_to_the_tsv_file"
>>> table_csv_path = "your_path_to_a_directory_containing_all_csv_files"


>>> class TableDataset:
...     def __init__(self, data, tokenizer):
...         self.data = data
...         self.tokenizer = tokenizer

...     def __iter__(self):
...         for idx in range(self.__len__()):
...             item = self.data.iloc[idx]
...             table = pd.read_csv(table_csv_path + item.table_file).astype(
...                 str
...             )  # be sure to make your table data text only
...             encoding = self.tokenizer(
...                 table=table,
...                 queries=item.question,
...                 answer_coordinates=item.answer_coordinates,
...                 answer_text=item.answer_text,
...                 truncation=True,
...                 padding="max_length",
...                 return_tensors="tf",
...             )
...             # remove the batch dimension which the tokenizer adds by default
...             encoding = {key: tf.squeeze(val, 0) for key, val in encoding.items()}
...             # add the float_answer which is also required (weak supervision for aggregation case)
...             encoding["float_answer"] = tf.convert_to_tensor(item.float_answer, dtype=tf.float32)
...             yield encoding["input_ids"], encoding["attention_mask"], encoding["numeric_values"], encoding[
...                 "numeric_values_scale"
...             ], encoding["token_type_ids"], encoding["labels"], encoding["float_answer"]

...     def __len__(self):
...         return len(self.data)


>>> data = pd.read_csv(tsv_path, sep="\t")
>>> train_dataset = TableDataset(data, tokenizer)
>>> output_signature = (
...     tf.TensorSpec(shape=(512,), dtype=tf.int32),
...     tf.TensorSpec(shape=(512,), dtype=tf.int32),
...     tf.TensorSpec(shape=(512,), dtype=tf.float32),
...     tf.TensorSpec(shape=(512,), dtype=tf.float32),
...     tf.TensorSpec(shape=(512, 7), dtype=tf.int32),
...     tf.TensorSpec(shape=(512,), dtype=tf.int32),
...     tf.TensorSpec(shape=(512,), dtype=tf.float32),
... )
>>> train_dataloader = tf.data.Dataset.from_generator(train_dataset, output_signature=output_signature).batch(32)

请注意，这里我们独立地编码每个表格-问题对。如果你的数据集不是会话式的，这没有问题。如果你的数据集涉及会话式问题（例如在 SQA 中），那么你应该首先按照 position 索引的顺序，将每个表格的 queries、answer_coordinates 和 answer_text 分组在一起，并批量编码每个表格及其问题。这将确保 prev_labels 令牌类型（请参阅 TapasTokenizer 的文档）被正确设置。有关更多信息，请参阅此 notebook。有关使用 TensorFlow 模型的更多信息，请参阅此 notebook。

**步骤 4：训练（微调）模型

Pytorch

隐藏 Pytorch 内容

然后，你可以如下微调 TapasForQuestionAnswering（此处显示的是用于聚合的弱监督情况）

>>> from transformers import TapasConfig, TapasForQuestionAnswering, AdamW

>>> # this is the default WTQ configuration
>>> config = TapasConfig(
...     num_aggregation_labels=4,
...     use_answer_as_supervision=True,
...     answer_loss_cutoff=0.664694,
...     cell_selection_preference=0.207951,
...     huber_loss_delta=0.121194,
...     init_cell_selection_weights_to_zero=True,
...     select_one_column=True,
...     allow_empty_column_selection=False,
...     temperature=0.0352513,
... )
>>> model = TapasForQuestionAnswering.from_pretrained("google/tapas-base", config=config)

>>> optimizer = AdamW(model.parameters(), lr=5e-5)

>>> model.train()
>>> for epoch in range(2):  # loop over the dataset multiple times
...     for batch in train_dataloader:
...         # get the inputs;
...         input_ids = batch["input_ids"]
...         attention_mask = batch["attention_mask"]
...         token_type_ids = batch["token_type_ids"]
...         labels = batch["labels"]
...         numeric_values = batch["numeric_values"]
...         numeric_values_scale = batch["numeric_values_scale"]
...         float_answer = batch["float_answer"]

...         # zero the parameter gradients
...         optimizer.zero_grad()

...         # forward + backward + optimize
...         outputs = model(
...             input_ids=input_ids,
...             attention_mask=attention_mask,
...             token_type_ids=token_type_ids,
...             labels=labels,
...             numeric_values=numeric_values,
...             numeric_values_scale=numeric_values_scale,
...             float_answer=float_answer,
...         )
...         loss = outputs.loss
...         loss.backward()
...         optimizer.step()

TensorFlow

隐藏 TensorFlow 内容

然后，你可以如下微调 TFTapasForQuestionAnswering（此处显示的是用于聚合的弱监督情况）

>>> import tensorflow as tf
>>> from transformers import TapasConfig, TFTapasForQuestionAnswering

>>> # this is the default WTQ configuration
>>> config = TapasConfig(
...     num_aggregation_labels=4,
...     use_answer_as_supervision=True,
...     answer_loss_cutoff=0.664694,
...     cell_selection_preference=0.207951,
...     huber_loss_delta=0.121194,
...     init_cell_selection_weights_to_zero=True,
...     select_one_column=True,
...     allow_empty_column_selection=False,
...     temperature=0.0352513,
... )
>>> model = TFTapasForQuestionAnswering.from_pretrained("google/tapas-base", config=config)

>>> optimizer = tf.keras.optimizers.Adam(learning_rate=5e-5)

>>> for epoch in range(2):  # loop over the dataset multiple times
...     for batch in train_dataloader:
...         # get the inputs;
...         input_ids = batch[0]
...         attention_mask = batch[1]
...         token_type_ids = batch[4]
...         labels = batch[-1]
...         numeric_values = batch[2]
...         numeric_values_scale = batch[3]
...         float_answer = batch[6]

...         # forward + backward + optimize
...         with tf.GradientTape() as tape:
...             outputs = model(
...                 input_ids=input_ids,
...                 attention_mask=attention_mask,
...                 token_type_ids=token_type_ids,
...                 labels=labels,
...                 numeric_values=numeric_values,
...                 numeric_values_scale=numeric_values_scale,
...                 float_answer=float_answer,
...             )
...         grads = tape.gradient(outputs.loss, model.trainable_weights)
...         optimizer.apply_gradients(zip(grads, model.trainable_weights))

用法：推理

Pytorch

隐藏 Pytorch 内容

这里我们解释如何使用 TapasForQuestionAnswering 或 TFTapasForQuestionAnswering 进行推理（即对新数据进行预测）。对于推理，只需要将 input_ids、attention_mask 和 token_type_ids（你可以使用 TapasTokenizer 获得）提供给模型以获得 logits。接下来，你可以使用方便的 ~models.tapas.tokenization_tapas.convert_logits_to_predictions 方法将这些 logits 转换为预测的坐标和可选的聚合索引。

但是，请注意，推理是否为会话式设置，有所不同。在非会话式设置中，可以并行处理批次中所有表格-问题对的推理。这是一个例子：

>>> from transformers import TapasTokenizer, TapasForQuestionAnswering
>>> import pandas as pd

>>> model_name = "google/tapas-base-finetuned-wtq"
>>> model = TapasForQuestionAnswering.from_pretrained(model_name)
>>> tokenizer = TapasTokenizer.from_pretrained(model_name)

>>> data = {"Actors": ["Brad Pitt", "Leonardo Di Caprio", "George Clooney"], "Number of movies": ["87", "53", "69"]}
>>> queries = [
...     "What is the name of the first actor?",
...     "How many movies has George Clooney played in?",
...     "What is the total number of movies?",
... ]
>>> table = pd.DataFrame.from_dict(data)
>>> inputs = tokenizer(table=table, queries=queries, padding="max_length", return_tensors="pt")
>>> outputs = model(**inputs)
>>> predicted_answer_coordinates, predicted_aggregation_indices = tokenizer.convert_logits_to_predictions(
...     inputs, outputs.logits.detach(), outputs.logits_aggregation.detach()
... )

>>> # let's print out the results:
>>> id2aggregation = {0: "NONE", 1: "SUM", 2: "AVERAGE", 3: "COUNT"}
>>> aggregation_predictions_string = [id2aggregation[x] for x in predicted_aggregation_indices]

>>> answers = []
>>> for coordinates in predicted_answer_coordinates:
...     if len(coordinates) == 1:
...         # only a single cell:
...         answers.append(table.iat[coordinates[0]])
...     else:
...         # multiple cells
...         cell_values = []
...         for coordinate in coordinates:
...             cell_values.append(table.iat[coordinate])
...         answers.append(", ".join(cell_values))

>>> display(table)
>>> print("")
>>> for query, answer, predicted_agg in zip(queries, answers, aggregation_predictions_string):
...     print(query)
...     if predicted_agg == "NONE":
...         print("Predicted answer: " + answer)
...     else:
...         print("Predicted answer: " + predicted_agg + " > " + answer)
What is the name of the first actor?
Predicted answer: Brad Pitt
How many movies has George Clooney played in?
Predicted answer: COUNT > 69
What is the total number of movies?
Predicted answer: SUM > 87, 53, 69

TensorFlow

隐藏 TensorFlow 内容

这里我们解释如何使用 TFTapasForQuestionAnswering 进行推理（即对新数据进行预测）。对于推理，只需要将 input_ids、attention_mask 和 token_type_ids（你可以使用 TapasTokenizer 获得）提供给模型以获得 logits。接下来，你可以使用方便的 ~models.tapas.tokenization_tapas.convert_logits_to_predictions 方法将这些 logits 转换为预测的坐标和可选的聚合索引。

但是，请注意，推理是否为会话式设置，有所不同。在非会话式设置中，可以并行处理批次中所有表格-问题对的推理。这是一个例子：

>>> from transformers import TapasTokenizer, TFTapasForQuestionAnswering
>>> import pandas as pd

>>> model_name = "google/tapas-base-finetuned-wtq"
>>> model = TFTapasForQuestionAnswering.from_pretrained(model_name)
>>> tokenizer = TapasTokenizer.from_pretrained(model_name)

>>> data = {"Actors": ["Brad Pitt", "Leonardo Di Caprio", "George Clooney"], "Number of movies": ["87", "53", "69"]}
>>> queries = [
...     "What is the name of the first actor?",
...     "How many movies has George Clooney played in?",
...     "What is the total number of movies?",
... ]
>>> table = pd.DataFrame.from_dict(data)
>>> inputs = tokenizer(table=table, queries=queries, padding="max_length", return_tensors="tf")
>>> outputs = model(**inputs)
>>> predicted_answer_coordinates, predicted_aggregation_indices = tokenizer.convert_logits_to_predictions(
...     inputs, outputs.logits, outputs.logits_aggregation
... )

>>> # let's print out the results:
>>> id2aggregation = {0: "NONE", 1: "SUM", 2: "AVERAGE", 3: "COUNT"}
>>> aggregation_predictions_string = [id2aggregation[x] for x in predicted_aggregation_indices]

>>> answers = []
>>> for coordinates in predicted_answer_coordinates:
...     if len(coordinates) == 1:
...         # only a single cell:
...         answers.append(table.iat[coordinates[0]])
...     else:
...         # multiple cells
...         cell_values = []
...         for coordinate in coordinates:
...             cell_values.append(table.iat[coordinate])
...         answers.append(", ".join(cell_values))

>>> display(table)
>>> print("")
>>> for query, answer, predicted_agg in zip(queries, answers, aggregation_predictions_string):
...     print(query)
...     if predicted_agg == "NONE":
...         print("Predicted answer: " + answer)
...     else:
...         print("Predicted answer: " + predicted_agg + " > " + answer)
What is the name of the first actor?
Predicted answer: Brad Pitt
How many movies has George Clooney played in?
Predicted answer: COUNT > 69
What is the total number of movies?
Predicted answer: SUM > 87, 53, 69

如果是会话式设置，则每个表格-问题对必须按顺序提供给模型，以便 prev_labels 令牌类型可以被前一个表格-问题对的预测 labels 覆盖。同样，更多信息可以在此 notebook （适用于 PyTorch）和此 notebook （适用于 TensorFlow）中找到。

Transformers

TAPAS

概述

使用技巧

用法：微调

用法：推理

资源

TAPAS 特定输出

class transformers.models.tapas.modeling_tapas.TableQuestionAnsweringOutput

TapasConfig

class transformers.TapasConfig

TapasTokenizer

class transformers.TapasTokenizer

__call__

convert_logits_to_predictions

save_vocabulary

TapasModel

class transformers.TapasModel

forward

TapasForMaskedLM

类 transformers.TapasForMaskedLM

forward

TapasForSequenceClassification

class transformers.TapasForSequenceClassification

forward

TapasForQuestionAnswering

class transformers.TapasForQuestionAnswering

forward

TFTapasModel

class transformers.TFTapasModel

call

TFTapasForMaskedLM

class transformers.TFTapasForMaskedLM

call

TFTapasForSequenceClassification

class transformers.TFTapasForSequenceClassification

call

TFTapasForQuestionAnswering

class transformers.TFTapasForQuestionAnswering

call

call