Transformers 文档

TAPAS

Transformers

加入 Hugging Face 社区

并访问增强的文档体验

在模型、数据集和 Spaces 上协作

通过加速推理获得更快的示例

在文档主题之间切换

开始使用

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（斯坦福大学的维基表格问题）
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 上也达到了最先进水平，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 标记类型可以被模型对上一个问题的预测 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)

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

有关 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），那么您应该首先将每个表格的 queries、answer_coordinates 和 answer_text 分组在一起（按其 position 索引的顺序），并批量编码每个表格及其问题。这将确保 prev_labels 标记类型（请参阅 TapasTokenizer 的文档）设置正确。有关更多信息，请参阅此笔记本。有关使用 TensorFlow 模型的更多信息，请参阅此笔记本。

**步骤 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 覆盖。同样，更多信息可以在此笔记本（对于 PyTorch）和此笔记本（对于 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

class 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