# TAPAS ## 概述 TAPAS 模型由 Jonathan Herzig、Paweł Krzysztof Nowak、Thomas Müller、Francesco Piccinno 和 Julian Martin Eisenschlos 在 [TAPAS: Weakly Supervised Table Parsing via Pre-training](https://huggingface.co/papers/2004.02349) 中提出。它是一个基于 BERT 的模型，专为回答关于表格数据的问题而设计（并经过预训练）。与 BERT 相比，TAPAS 使用相对位置嵌入，并拥有 7 种标记类型来编码表格结构。TAPAS 在包含数百万个来自英文维基百科的表格及相应文本的大型数据集上，通过掩码语言建模（MLM）目标进行预训练。 在问答任务中，TAPAS 顶部有两个头：一个单元格选择头和一个聚合头，用于（可选地）对选定的单元格执行聚合操作（例如计数或求和）。TAPAS 已在多个数据集上进行了微调： - [SQA](https://www.microsoft.com/en-us/download/details.aspx?id=54253)（微软的 Sequential Question Answering） - [WTQ](https://github.com/ppasupat/WikiTableQuestions)（斯坦福大学提出的 Wiki Table Questions） - [WikiSQL](https://github.com/salesforce/WikiSQL)（由 Salesforce 提供）。 它在 SQA 和 WTQ 上均达到了最先进的水平，同时在 WikiSQL 上的性能与 SOTA 相当，且架构要简单得多。 该论文的摘要如下： *在表格上回答自然语言问题通常被视为一个语义解析任务。为了减轻完整逻辑形式的收集成本，一种流行的方法专注于由指称（denotations）而非逻辑形式组成的弱监督。然而，从弱监督中训练语义解析器存在困难，此外，生成的逻辑形式仅作为检索指称之前的中间步骤使用。在本文中，我们提出了 TAPAS，一种无需生成逻辑形式即可在表格上进行问答的方法。TAPAS 从弱监督中进行训练，并通过选择表格单元格以及可选地对这种选择应用相应的聚合运算符来预测指称。TAPAS 扩展了 BERT 的架构以将表格编码为输入，从从维基百科爬取的文本片段和表格的有效联合预训练中初始化，并进行端到端训练。我们在三个不同的语义解析数据集上进行了实验，发现 TAPAS 通过将在 SQA 上的最先进准确率从 55.1 提升至 67.2，以及在 WIKISQL 和 WIKITQ 上达到与最先进水平相当的表现，从而优于或匹敌语义解析模型，但其模型架构更为简单。我们额外发现，在我们的设置中轻而易举的从 WIKISQL 到 WIKITQ 的迁移学习，取得了 48.7 的准确率，比最先进水平高出 4.2 个百分点。* 此外，作者还进一步对 TAPAS 进行了预训练，使其能够识别 **表格蕴含**。他们构建了一个包含数百万个自动生成的训练样本的平衡数据集，并在微调之前的中间步骤中学习这些数据。TAPAS 的作者将这种进一步的预训练称为中间预训练（因为 TAPAS 首先在 MLM 上进行预训练，然后在另一个数据集上进行预训练）。他们发现，中间预训练进一步提升了在 SQA 上的性能，取得了新的最先进水平，并在 [TabFact](https://github.com/wenhuchen/Table-Fact-Checking) 上也达到了最先进水平。TabFact 是一个包含 16k 个维基百科表格的大规模数据集，用于表格蕴含（一种二分类任务）。更多详情请参阅他们的后续论文：Julian Martin Eisenschlos、Syrine Krichene 和 Thomas Müller 撰写的 [Understanding tables with intermediate pre-training](https://www.aclweb.org/anthology/2020.findings-emnlp.27/)。 drawing TAPAS 架构。摘自原始博客文章。 该模型由 [nielsr](https://huggingface.co/nielsr) 贡献。原始代码可在[此处](https://github.com/google-research/tapas)找到。 ## 使用技巧 - TAPAS 是一个默认使用相对位置嵌入的模型（在表格的每个单元格处重置位置嵌入）。请注意，这是在原始 TAPAS 论文发表之后添加的功能。根据作者的说法，这通常能带来略好的性能，并且允许您编码更长的序列而不会耗尽嵌入。这一点体现在 [TapasConfig](/docs/transformers/main/zh/model_doc/tapas#transformers.TapasConfig) 的 `reset_position_index_per_cell` 参数中，该参数默认设置为 `True`。[hub](https://huggingface.co/models?search=tapas) 上可用的默认模型版本均使用相对位置嵌入。您仍然可以通过在调用 `from_pretrained()` 方法时传入额外参数 `revision="no_reset"` 来使用带有绝对位置嵌入的模型。请注意，通常建议在右侧而非左侧填充输入。 - TAPAS 基于 BERT，因此例如 `TAPAS-base` 对应于 `BERT-base` 架构。当然，`TAPAS-large` 将带来最佳性能（论文中报告的结果来自 `TAPAS-large`）。各种规模模型的结果展示在 [原始 GitHub 仓库](https://github.com/google-research/tapas) 中。 - TAPAS 提供了在 SQA 上微调的检查点，能够在对话场景中回答与表格相关的问题。这意味着你可以提出诸如“他多大了？”之类的后续问题，这些问题与之前的问题相关联。请注意，在对话场景下，TAPAS 的前向传播过程略有不同：在这种情况下，你需要将每个表格-问题对逐一输入模型，以便用模型对前一个问题的预测 `labels` 来覆盖 `prev_labels` 的 token 类型 ID。更多信息请参阅“用法”部分。 - TAPAS 与 BERT 类似，因此依赖于掩码语言建模（MLM）目标。因此，它在预测掩码 token 以及通用 NLU 方面效率较高，但在文本生成方面并非最优。使用因果语言建模（CLM）目标训练的模型在这方面表现更好。请注意，TAPAS 可以作为 EncoderDecoderModel 框架中的编码器，与 GPT-2 等自回归文本解码器结合使用。 ## 用法：微调 在此，我们将介绍如何在您自己的数据集上对 [TapasForQuestionAnswering](/docs/transformers/main/zh/model_doc/tapas#transformers.TapasForQuestionAnswering) 进行微调。 **第 1 步：选择使用 TAPAS 的三种方式之一——或自行尝试** 基本上，微调 [TapasForQuestionAnswering](/docs/transformers/main/zh/model_doc/tapas#transformers.TapasForQuestionAnswering) 有 3 种不同的方式，分别对应 Tapas 所微调的不同数据集： 1. SQA：如果您希望在对话场景中提出与表格相关的后续问题，则适用此任务。例如，如果您先问“第一位演员的名字是什么？”，随后可以提出诸如“他多大了？”这样的后续问题。在此任务中，问题不涉及任何聚合操作（所有问题均为单元格选择问题）。 2. WTQ：如果您不希望在对话场景中提问，而是仅针对表格提出可能涉及聚合操作的问题，例如统计行数、对单元格值求和或求平均值。例如，您可以询问“克里斯蒂亚诺·罗纳尔多职业生涯中总共进了多少球？”。这种情况也被称为**弱监督**，因为模型仅以问题的答案作为监督信号，必须自行学习合适的聚合运算符（SUM/COUNT/AVERAGE/NONE）。 3. WikiSQL 监督：该数据集基于 WikiSQL，在训练过程中向模型提供真实的聚合算子。这也被称为**强监督**。在此情况下，学习合适的聚合算子要容易得多。 总结如下： | **任务** | **示例数据集** | **描述** | |-------------------------------------|---------------------|---------------------------------------------------------------------------------------------------------| | 对话式 | SQA | 对话式，仅涉及单元格选择的问题 | | 用于聚合的弱监督 | WTQ | 问题可能涉及聚合，模型必须仅以答案作为监督信号来学习这一点 | | 用于聚合的强监督 | WikiSQL 监督 | 问题可能涉及聚合，模型必须根据给定的标准聚合运算符来学习这一点 | 从 Hub 加载预训练基础模型并随机初始化分类头来初始化模型，方法如下所示。 ```python from transformers import TapasConfig, TapasForQuestionAnswering # for example, the base sized model with default SQA configuration model = TapasForQuestionAnswering.from_pretrained("google/tapas-base", device_map="auto") # 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, device_map="auto") # or, the base sized model with WikiSQL configuration config = TapasConfig("google-base-finetuned-wikisql-supervised") model = TapasForQuestionAnswering.from_pretrained("google/tapas-base", config=config, device_map="auto") ``` 当然，您不一定非要遵循 TAPAS 微调的这三种方式之一。您也可以自行定义任意超参数来初始化 [TapasConfig](/docs/transformers/main/zh/model_doc/tapas#transformers.TapasConfig)，然后基于该配置创建一个 [TapasForQuestionAnswering](/docs/transformers/main/zh/model_doc/tapas#transformers.TapasForQuestionAnswering)。例如，如果您的数据集同时包含对话式问题和可能涉及聚合的问题，就可以这样做。示例如下： ```python 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, device_map="auto") ``` 另一种做法是从一个已经微调好的检查点开始。需要注意的是，WTQ 上已有的微调检查点由于 L2 损失函数较为脆弱而存在一些已知问题。更多信息请参见 [此处](https://github.com/google-research/tapas/issues/91#issuecomment-735719340)。 有关 HuggingFace 模型库上所有可用的预训练和微调 TAPAS 检查点的列表，请参见[此处](https://huggingface.co/models?search=tapas)。 **步骤 2：以 SQA 格式准备数据** 其次，无论您在上一步中选择了什么，都应按照 [SQA](https://www.microsoft.com/en-us/download/details.aspx?id=54253) 格式准备数据集。该格式是一个 TSV/CSV 文件，包含以下列： - `id`：可选，表格-问题对的 id，用于记录管理。 - `annotator`：可选，标注该表格-问题对的人员 ID，用于记录管理。 - `position`：一个整数，表示该问题与表格相关，是第一个、第二个还是第三个。仅在对话式设置（SQA）中需要此列。如果您打算进行 WTQ/WikiSQL 监督，则不需要此列。 - `question`：字符串 - `table_file`：字符串，包含表格数据的 csv 文件的名称 - `answer_coordinates`：一个或多个元组的列表（每个元组为一个单元格坐标，即构成答案的行、列对） - `answer_text`：一个或多个字符串的列表（每个字符串都是答案的一部分，即某个单元格的值） - `aggregation_label`：聚合运算符的索引。仅在聚合的强监督情况下（即 WikiSQL 监督场景）需要指定。 - `float_answer`：问题的浮点数答案（如果存在的话；否则为 np.nan）。仅在聚合的弱监督情况下（例如 WTQ 和 WikiSQL）需要 表格本身应位于一个文件夹中，每个表格对应一个单独的 csv 文件。请注意，TAPAS 算法的作者使用了一些带有自动化逻辑的转换脚本，将其他数据集（WTQ、WikiSQL）转换为 SQA 格式。作者在[此处](https://github.com/google-research/tapas/issues/50#issuecomment-705465960)对此进行了说明。一个适用于 HuggingFace 实现的该脚本转换版本可以在[此处](https://github.com/NielsRogge/tapas_utils)找到。有趣的是，这些转换脚本并不完美（`answer_coordinates` 和 `float_answer` 字段是基于 `answer_text` 填充的），这意味着 WTQ 和 WikiSQL 的结果实际上可能还有提升空间。 **第 3 步：使用 TapasTokenizer 将数据转换为张量** 第三，既然您已按照此 TSV/CSV 格式（以及包含表格数据的相应 CSV 文件）准备好了数据，就可以使用 [TapasTokenizer](/docs/transformers/main/zh/model_doc/tapas#transformers.TapasTokenizer) 将表格-问题对转换为 `input_ids`、`attention_mask`、`token_type_ids` 等。同样，根据您在上文中选择的三种情况之一，[TapasForQuestionAnswering](/docs/transformers/main/zh/model_doc/tapas#transformers.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](/docs/transformers/main/zh/model_doc/tapas#transformers.TapasTokenizer) 会根据 TSV 文件中的 `answer_coordinates` 和 `answer_text` 列来创建 `labels`、`numeric_values` 和 `numeric_values_scale`。`float_answer` 和 `aggregation_labels` 已经存在于第 2 步的 TSV 文件中。示例如下： ```py 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](/docs/transformers/main/zh/model_doc/tapas#transformers.TapasTokenizer) 要求表格数据为**纯文本**。您可以对 dataframe 使用 `.astype(str)` 将其转换为纯文本数据。当然，这仅展示了如何编码单个训练样本。建议创建一个 dataloader 来遍历批次： ```python import pandas as pd import torch 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) ``` 请注意，在此处我们独立编码每个表格-问题对。只要您的数据集**不是对话式的**，这样做就没问题。如果您的数据集包含对话式问题（例如 SQA），则应先按表格将 `queries`、`answer_coordinates` 和 `answer_text` 分组（按 `position` 索引的顺序），然后对每个表格及其问题进行批量编码。这样可以确保 `prev_labels` 标记类型（参见 [TapasTokenizer](/docs/transformers/main/zh/model_doc/tapas#transformers.TapasTokenizer) 的文档）被正确设置。更多信息请参见[此笔记本](https://github.com/NielsRogge/Transformers-Tutorials/blob/master/TAPAS/Fine_tuning_TapasForQuestionAnswering_on_SQA.ipynb)。 **第 4 步：训练（微调）模型 然后，您可以按以下方式微调 [TapasForQuestionAnswering](/docs/transformers/main/zh/model_doc/tapas#transformers.TapasForQuestionAnswering)（此处以聚合任务的弱监督为例）： ```python from transformers import AdamW, TapasConfig, TapasForQuestionAnswering # 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, device_map="auto") 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() ``` ## 用法：推理 在此，我们将介绍如何使用 [TapasForQuestionAnswering](/docs/transformers/main/zh/model_doc/tapas#transformers.TapasForQuestionAnswering) 进行推理（即对新数据进行预测）。在推理过程中，只需向模型提供 `input_ids`、`attention_mask` 和 `token_type_ids`（可通过 [TapasTokenizer](/docs/transformers/main/zh/model_doc/tapas#transformers.TapasTokenizer) 获取）即可获得 logits。随后，您可以使用便捷的 `~models.tapas.tokenization_tapas.convert_logits_to_predictions` 方法，将这些 logits 转换为预测坐标以及可选的聚合索引。 但请注意，推理过程**有所不同**，具体取决于设置是否为对话式。在非对话式设置中，可以对批次中所有的表格-问题对并行执行推理。示例如下： ```py from transformers import TapasTokenizer, TapasForQuestionAnswering import pandas as pd model_name = "google/tapas-base-finetuned-wtq" model = TapasForQuestionAnswering.from_pretrained(model_name, device_map="auto") 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").to(model.device) 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 ``` 在对话式设置中，必须**按顺序**将每个表格-问题对提供给模型，以便`prev_labels` 标记类型可以被前一个表格-问题对的预测`labels`覆盖。有关更多信息，请参阅[此笔记本](https://github.com/NielsRogge/Transformers-Tutorials/blob/master/TAPAS/Fine_tuning_TapasForQuestionAnswering_on_SQA.ipynb)。 ## 资源 - [文本分类任务指南](../tasks/sequence_classification) - [掩码语言建模任务指南](../tasks/masked_language_modeling) ## TAPAS 特定输出[[transformers.models.tapas.modeling_tapas.TableQuestionAnsweringOutput]] #### transformers.models.tapas.modeling_tapas.TableQuestionAnsweringOutput[[transformers.models.tapas.modeling_tapas.TableQuestionAnsweringOutput]] ```python transformers.models.tapas.modeling_tapas.TableQuestionAnsweringOutput(loss: typing.Optional[torch.Tensor] = None, logits: typing.Optional[torch.Tensor] = None, logits_aggregation: typing.Optional[torch.Tensor] = None, hidden_states: tuple[torch.Tensor] | None = None, attentions: tuple[torch.Tensor] | None = None) ``` [来源](https://github.com/huggingface/transformers/blob/main/src/transformers/models/tapas/modeling_tapas.py#L49) **参数：** loss (`torch.Tensor`，形状为 `(1,)`，*可选*，当提供 `labels`（以及可能的 `answer`、`aggregation_labels`、`numeric_values` 和 `numeric_values_scale`）时返回）：总损失，为分层单元格选择对数似然损失与（可选的）半监督回归损失以及（可选的）聚合监督损失之和。 logits (`torch.Tensor`，形状为 `(batch_size, sequence_length)`)：每个 token 的单元格选择头预测分数。 logits_aggregation (`torch.Tensor`, *可选*, 形状为 `(batch_size, num_aggregation_labels)`) : 聚合头针对每个聚合算子的预测分数。 hidden_states (`tuple[torch.Tensor]`，*可选*，在传入 `output_hidden_states=True` 或 `config.output_hidden_states=True` 时返回)：一个 `torch.Tensor` 元组（如果模型具有嵌入层，则包含嵌入层输出的一个张量，以及每个层输出的一个张量），形状为 `(batch_size, sequence_length, hidden_size)`。模型在每层输出处的隐藏状态，以及可选的初始嵌入输出。 attentions (`tuple[torch.Tensor]`，*可选*，在传入 `output_attentions=True` 或 `config.output_attentions=True` 时返回)：一个 `torch.Tensor` 元组（每层一个），形状为 `(batch_size, num_heads, sequence_length, sequence_length)`。注意力 softmax 之后的注意力权重，用于在自注意力头中计算加权平均值。 [TapasForQuestionAnswering](/docs/transformers/main/zh/model_doc/tapas#transformers.TapasForQuestionAnswering) 的输出类型。 ## TapasConfig[[transformers.TapasConfig]] #### transformers.TapasConfig[[transformers.TapasConfig]] ```python transformers.TapasConfig(transformers_version: str | None = None, architectures: list[str] | None = None, output_hidden_states: bool | None = False, return_dict: bool | None = True, dtype: str | torch.dtype | None = None, chunk_size_feed_forward: int = 0, is_encoder_decoder: bool = False, id2label: dict[int, str] | dict[str, str] | None = None, label2id: dict[str, int] | dict[str, str] | None = None, problem_type: Literal['regression', 'single_label_classification', 'multi_label_classification'] | None = None, vocab_size: int = 30522, hidden_size: int = 768, num_hidden_layers: int = 12, num_attention_heads: int = 12, intermediate_size: int = 3072, hidden_act: str = 'gelu', hidden_dropout_prob: float | int = 0.1, attention_probs_dropout_prob: float | int = 0.1, max_position_embeddings: int = 1024, type_vocab_sizes: list[int] | tuple[int, ...] = (3, 256, 256, 2, 256, 256, 10), initializer_range: float = 0.02, layer_norm_eps: float = 1e-12, pad_token_id: int | None = 0, bos_token_id: int | None = None, eos_token_id: int | list[int] | None = None, positive_label_weight: float = 10.0, num_aggregation_labels: int = 0, aggregation_loss_weight: float = 1.0, use_answer_as_supervision: bool | None = None, answer_loss_importance: float = 1.0, use_normalized_answer_loss: bool = False, huber_loss_delta: float | None = None, temperature: float = 1.0, aggregation_temperature: float = 1.0, use_gumbel_for_cells: bool = False, use_gumbel_for_aggregation: bool = False, average_approximation_function: str = 'ratio', cell_selection_preference: float | None = None, answer_loss_cutoff: float | int | None = None, max_num_rows: int = 64, max_num_columns: int = 32, average_logits_per_cell: bool = False, select_one_column: bool = True, allow_empty_column_selection: bool = False, init_cell_selection_weights_to_zero: bool = False, reset_position_index_per_cell: bool = True, disable_per_token_loss: bool = False, aggregation_labels: dict | None = None, no_aggregation_label_index: int | None = None, is_decoder: bool = False, add_cross_attention: bool = False, tie_word_embeddings: bool = True) ``` [来源](https://github.com/huggingface/transformers/blob/main/src/transformers/models/tapas/configuration_tapas.py#L32) **参数：** vocab_size (`int`，*可选*，默认值为 `30522`)：模型的词汇表大小。定义了 `input_ids` 可以表示的不同 token 数量。 hidden_size (`int`，*可选*，默认为 `768`)：隐藏表示的维度。 num_hidden_layers (`int`，*可选*，默认为 `12`)：Transformer 解码器中的隐藏层数。 num_attention_heads (`int`，*可选*，默认为 `12`)：Transformer 解码器中每个注意力层的注意力头数量。 intermediate_size (`int`，*可选*，默认值为 `3072`)：MLP 表示的维度。 hidden_act (`str`，*可选*，默认为 `gelu`)：解码器中的非线性激活函数（函数或字符串）。例如，`"gelu"`、`"relu"`、`"silu"` 等。 hidden_dropout_prob (`Union[float, int]`，*可选*，默认值为 `0.1`)：嵌入层、编码器和池化器中所有全连接层的 dropout 概率。 attention_probs_dropout_prob (`Union[float, int]`，*可选*，默认值为 `0.1`)：注意力概率的 dropout 比率。 max_position_embeddings (`int`，*可选*，默认为 `1024`)：该模型可能使用的最大序列长度。 type_vocab_sizes (`list[int]`，*可选*，默认为 `[3, 256, 256, 2, 256, 256, 10]`)：调用 [TapasModel](/docs/transformers/main/zh/model_doc/tapas#transformers.TapasModel) 时传入的 `token_type_ids` 的词汇表大小。 initializer_range (`float`，*可选*，默认值为 `0.02`)：用于初始化所有权重矩阵的 truncated_normal_initializer 的标准差。 layer_norm_eps (`float`, *可选*，默认为 `1e-12`)：层归一化层所使用的 epsilon。 pad_token_id (`int`，*可选*，默认为 `0`)：词表中用于填充的 Token ID。 bos_token_id (`int`, *可选*) : 词表中用于表示流开始的 Token id。 eos_token_id (`Union[int, list[int]]`，*可选*)：词汇表中用于表示流结束（end-of-stream）的 Token ID。 positive_label_weight (`float`, *可选*, 默认值为 10.0) : 正样本标签的权重。 num_aggregation_labels (`int`，*可选*，默认为 0)：要预测的聚合算子数量。 aggregation_loss_weight (`float`, *可选*, 默认为 1.0) : 聚合损失的权重。 use_answer_as_supervision (`bool`, *可选*) : 是否将答案用作聚合示例的唯一监督信号。 answer_loss_importance (`float`, *可选*, 默认为 1.0) : 回归损失的重要性权重。 use_normalized_answer_loss (`bool`，*可选*，默认为 `False`)：是否将答案损失归一化为预测值和期望值的最大值。 huber_loss_delta (`float`, *可选*) : 用于计算回归损失的 Delta 参数。 temperature (`float`, *可选*，默认为 1.0)：用于控制（或更改）单元格 logits 概率偏斜度的值。 aggregation_temperature (`float`, *可选*，默认为 1.0)：缩放聚合 logits 以控制概率的偏度。 use_gumbel_for_cells (`bool`，*可选*，默认为 `False`)：是否对单元格选择应用 Gumbel-Softmax。 use_gumbel_for_aggregation (`bool`, *可选*, 默认为 `False`) : 是否对聚合选择应用 Gumbel-Softmax。 average_approximation_function (`string`，*可选*，默认为 `"ratio"`)：在弱监督情况下计算单元格期望平均值的方法。取值为 `"ratio"`、`"first_order"` 或 `"second_order"` 之一。 cell_selection_preference (`float`, *可选*) : 在模糊情况下选择单元格的偏好。仅适用于聚合的弱监督（WTQ、WikiSQL）。如果聚合概率的总质量（不包括“NONE”运算符）高于此超参数，则预测该示例为聚合。 answer_loss_cutoff (`float`, *可选*) : 忽略答案损失大于 cutoff 的示例。 max_num_rows (`int`，*可选*，默认为 64)：最大行数。 max_num_columns (`int`，*可选*，默认为 32)：最大列数。 average_logits_per_cell (`bool`，*可选*，默认为 `False`)：是否对每个单元格的 logits 取平均值。 select_one_column (`bool`，*可选*，默认为 `True`)：是否将模型限制为仅从单列中选择单元格。 allow_empty_column_selection (`bool`, *可选*，默认为 `False`) : 是否允许不选择任何列。 init_cell_selection_weights_to_zero (`bool`，*可选*，默认为 `False`)：是否将单元格选择权重初始化为 0，使初始概率为 50%。 reset_position_index_per_cell (`bool`，*可选*，默认为 `True`)：是否在每个单元格处重置位置索引（即使用相对位置嵌入）。 disable_per_token_loss (`bool`，*可选*，默认为 `False`)：是否禁用对单元格的任何（强或弱）监督。 aggregation_labels (`dict[int, label]`，*可选*)：用于聚合结果的聚合标签。例如，WTQ 模型具有以下聚合标签：`{0: "NONE", 1: "SUM", 2: "AVERAGE", 3: "COUNT"}` no_aggregation_label_index (`int`, *optional*) : 如果定义了聚合标签，且其中一个标签表示“无聚合”，则应将其索引设置为此值。例如，WTQ 模型的“NONE”聚合标签位于索引 0，因此对于这些模型，该值应设置为 0。 is_decoder (`bool`，*可选*，默认为 `False`)：模型是否用作解码器。如果为 `False`，则模型用作编码器。 add_cross_attention (`bool`，*可选*，默认为 `False`)：是否应在模型中添加交叉注意力层。 tie_word_embeddings (`bool`，*可选*，默认为 `True`)：是否根据模型的 `tied_weights_keys` 映射来绑定权重嵌入。 这是用于存储 TapasModel 配置的类。它根据指定的参数实例化 Tapas 模型，并定义模型架构。使用默认值实例化配置将生成与 [google/tapas-base-finetuned-sqa](https://huggingface.co/google/tapas-base-finetuned-sqa) 类似的配置。 配置对象继承自 [PreTrainedConfig](/docs/transformers/main/zh/main_classes/configuration#transformers.PreTrainedConfig)，可用于控制模型输出。有关更多信息，请参阅 [PreTrainedConfig](/docs/transformers/main/zh/main_classes/configuration#transformers.PreTrainedConfig) 的文档。 示例： ```python >>> from transformers import TapasModel, TapasConfig >>> # Initializing a default (SQA) Tapas configuration >>> configuration = TapasConfig() >>> # Initializing a model from the configuration >>> model = TapasModel(configuration) >>> # Accessing the model configuration >>> configuration = model.config ``` ## TapasTokenizer[[transformers.TapasTokenizer]] #### transformers.TapasTokenizer[[transformers.TapasTokenizer]] ```python transformers.TapasTokenizer(vocab_file, do_lower_case = True, do_basic_tokenize = True, never_split = None, unk_token = '[UNK]', sep_token = '[SEP]', pad_token = '[PAD]', cls_token = '[CLS]', mask_token = '[MASK]', empty_token = '[EMPTY]', tokenize_chinese_chars = True, strip_accents = None, cell_trim_length: int = -1, max_column_id: int | None = None, max_row_id: int | None = None, strip_column_names: bool = False, update_answer_coordinates: bool = False, min_question_length = None, max_question_length = None, model_max_length: int = 512, additional_special_tokens: list[str] | None = None, clean_up_tokenization_spaces = True, **kwargs) ``` [来源](https://github.com/huggingface/transformers/blob/main/src/transformers/models/tapas/tokenization_tapas.py#L149) **参数：** vocab_file (`str`) : 包含词汇表的文件。 do_lower_case (`bool`，*可选*，默认为 `True`)：分词时是否将输入转换为小写。 do_basic_tokenize (`bool`，*可选*，默认为 `True`)：是否在执行 WordPiece 之前进行基础分词。 never_split (`Iterable`，*可选*)：在分词过程中永远不会被拆分的 token 集合。仅在 `do_basic_tokenize=True` 时生效 unk_token (`str`，*可选*，默认为 `"[UNK]"`)：未知标记。不在词汇表中的标记无法转换为 ID，因此会被设置为该标记。 sep_token (`str`，*可选*，默认为 `"[SEP]"`)：分隔符 token，用于从多个序列构建序列时，例如用于序列分类的两个序列，或用于问答的文本和问题。它也用作使用特殊 token 构建的序列的最后一个 token。 pad_token (`str`，*可选*，默认为 `"[PAD]"`)：用于填充的标记，例如在对长度不同的序列进行批处理时。 cls_token (`str`，*可选*，默认为 `"[CLS]"`)：用于序列分类（对整个序列进行分类，而非逐 token 分类）的分类器 token。当使用特殊 token 构建序列时，它是序列的第一个 token。 mask_token (`str`，*可选*，默认为 `"[MASK]"`)：用于掩码值的标记。这是在通过掩码语言建模训练该模型时所使用的标记，也是模型将尝试预测的标记。 empty_token (`str`，*可选*，默认为 `"[EMPTY]"`)：表格中空单元格值所使用的标记。空单元格值包括 ""、"n/a"、"nan" 和 "?"。 tokenize_chinese_chars (`bool`，*可选*，默认为 `True`)：是否对汉字进行分词。对于日语，建议关闭此功能（参见此 [issue](https://github.com/huggingface/transformers/issues/328)）。 strip_accents (`bool`, *可选*) : 是否去除所有重音符号。如果未指定此选项，则将根据 `lowercase` 的值来确定（与原始 BERT 相同）。 cell_trim_length (`int`，*可选*，默认值为 -1)：如果 > 0：将单元格截断，使其长度 <= 该值。同时会禁用进一步的单元格截断，因此应与 `truncation` 设置为 `True` 一起使用。 max_column_id (`int`, *可选*) : 要提取的最大列 ID。 max_row_id (`int`, *可选*) : 要提取的最大行 ID。 strip_column_names (`bool`，*可选*，默认为 `False`)：是否添加空字符串而不是列名。 update_answer_coordinates (`bool`，*可选*，默认为 `False`)：是否根据答案文本重新计算答案坐标。 min_question_length (`int`, *可选*) : 每个问题的最小长度（以 token 为单位，否则将被跳过）。 max_question_length (`int`, *可选*) : 每个问题的最大长度（以 token 为单位，否则将被跳过）。 clean_up_tokenization_spaces (`bool`, *可选*, 默认为 `True`) : 是否在解码后清理空格，清理操作包括移除多余空格等潜在伪影。 构建 TAPAS 分词器。基于 WordPiece。将表格和一个或多个相关句子展平，供 TAPAS 模型使用。 该分词器继承自 [PreTrainedTokenizer](/docs/transformers/main/zh/main_classes/tokenizer#transformers.PythonBackend)，后者包含了大部分主要方法。用户应参考该父类以获取有关这些方法的更多信息。[TapasTokenizer](/docs/transformers/main/zh/model_doc/tapas#transformers.TapasTokenizer) 会创建多个 token type id 来编码表格结构。更准确地说，它按以下顺序添加了 7 个 token type id：`segment_ids`、`column_ids`、`row_ids`、`prev_labels`、`column_ranks`、`inv_column_ranks` 和 `numeric_relations`： - segment_ids: 指示标记属于问题（0）还是表格（1）。特殊标记和填充标记为 0。 - column_ids: 指示标记属于表格中的哪一列（从 1 开始）。对于所有问题标记、特殊标记和填充，其值均为 0。 - row_ids：指示标记属于表格中的哪一行（从 1 开始）。所有问题标记、特殊标记和填充标记均为 0。列标题的标记也为 0。 - prev_labels：指示某个 token 是否为（属于）上一个问题的答案（1）或不是（0）。在对话场景（例如 SQA）中非常有用。 - column_ranks: 指示表格标记相对于某一列的排名（如适用）。例如，如果有一列“电影数量”，其值为 87、53 和 69，则这些标记的列排名分别为 3、1 和 2。所有问题标记、特殊标记和填充标记的值均为 0。 - inv_column_ranks: 指示表格标记相对于某一列的逆排名（如果适用）。例如，如果有一列“电影数量”，其值为 87、53 和 69，则这些标记的逆列排名分别为 1、3 和 2。对于所有问题标记、特殊标记和填充，该值为 0。 - numeric_relations: 指示问题与表格标记之间的数值关系。对于所有问题标记、特殊标记和填充，值为 0。 [TapasTokenizer](/docs/transformers/main/zh/model_doc/tapas#transformers.TapasTokenizer) 对表格及其关联句子执行端到端的分词：标点拆分和 wordpiece。 #### __调用__[[transformers.TapasTokenizer.__call__]] ```python __call__(table: typing.Union[ForwardRef('pd.DataFrame'), str, list[str], NoneType], queries: str | list[str] | list[int] | list[list[str]] | list[list[int]] | None = None, answer_coordinates: list[tuple] | list[list[tuple]] | None = None, answer_text: list[str] | list[list[str]] | None = None, add_special_tokens: bool = True, padding: bool | str | transformers.utils.generic.PaddingStrategy = False, truncation: bool | str | transformers.models.tapas.tokenization_tapas.TapasTruncationStrategy = False, max_length: int | None = None, pad_to_multiple_of: int | None = None, padding_side: str | None = None, return_tensors: str | transformers.utils.generic.TensorType | None = None, return_token_type_ids: bool | None = None, return_attention_mask: bool | None = None, return_overflowing_tokens: bool = False, return_special_tokens_mask: bool = False, return_offsets_mapping: bool = False, return_length: bool = False, verbose: bool = True, **kwargs) ``` [来源](https://github.com/huggingface/transformers/blob/main/src/transformers/models/tapas/tokenization_tapas.py#L518) **参数：** table (`pd.DataFrame` 或 `str` 或 `list[str]`) : 包含表格数据的表。请注意，所有单元格的值必须为文本。请使用 *.astype(str)* 将 Pandas 数据框转换为字符串。当传入字符串或字符串列表时，它们将被解释为带有空表的查询（以支持通用分词器测试）。 queries (`str` 或 `list[str]`) : 与待编码表格相关的问题或问题批次。请注意，如果是批次，所有问题必须指向**同一个**表格。 answer_coordinates (`list[Tuple]` 或 `list[list[Tuple]]`，*可选*)：批处理中每个表格-问题对的回答坐标。如果仅提供单个表格-问题对，则 answer_coordinates 必须是一个包含一个或多个元组的列表。每个元组必须是一个 (row_index, column_index) 对。第一个数据行（非列标题行）的索引为 0。第一列的索引为 0。如果提供了一组表格-问题对，则 answer_coordinates 必须是一个元组列表的列表（每个列表对应一个表格-问题对）。 answer_text (`list[str]` 或 `list[list[str]]`，*可选*) : 批处理中每个表格-问题对的回答文本。如果仅提供单个表格-问题对，则 answer_text 必须是一个包含一个或多个字符串的列表。每个字符串必须是对应回答坐标的回答文本。如果提供了一组表格-问题对，则 answer_coordinates 必须是字符串列表的列表（每个列表对应单个表格-问题对）。 add_special_tokens (`bool`，*可选*，默认为 `True`)：是否使用相对于其模型的特殊标记对序列进行编码。 padding (`bool`、`str` 或 [PaddingStrategy](/docs/transformers/main/zh/internal/file_utils#transformers.utils.PaddingStrategy)，*可选*，默认为 `False`)：启用并控制填充。接受以下值： - `True` 或 `'longest'`：填充至批次中最长的序列（如果仅提供单个序列，则不进行填充）。 - `'max_length'`：填充至由参数 `max_length` 指定的最大长度，或者如果未提供该参数，则填充至模型可接受的最大输入长度。 - `False` 或 `'do_not_pad'`（默认值）：不进行填充（即可以输出包含不同长度序列的批次）。 truncation (`bool`、`str` 或 `TapasTruncationStrategy`，*可选*，默认为 `False`)：启用并控制截断。接受以下值： - `True` 或 `'drop_rows_to_fit'`：截断至由参数 `max_length` 指定的最大长度，或者如果未提供该参数，则截断至模型可接受的最大输入长度。这将逐行进行截断，从表格中移除行。 - `False` 或 `'do_not_truncate'`（默认）：不截断（即，可以输出序列长度超过模型最大可接受输入大小的批次）。 max_length (`int`, *可选*) : 控制截断/填充参数之一所使用的最大长度。如果未设置或设置为 `None`，当截断/填充参数需要最大长度时，将使用预定义的最大模型长度。如果模型没有特定的最大输入长度（例如 XLNet），则禁用截断/填充至最大长度的功能。 is_split_into_words (`bool`，*可选*，默认为 `False`)：输入是否已经预先分词（例如，已拆分为单词）。如果设置为 `True`，分词器将假设输入已经拆分为单词（例如，通过按空白字符拆分），然后对其进行分词。这对于 NER 或 token 分类很有用。 pad_to_multiple_of (`int`，*可选*)：如果设置，则将序列填充为所提供值的倍数。这对于在计算能力 `>= 7.5`（Volta）的 NVIDIA 硬件上启用 Tensor Cores 的使用特别有用。 return_tensors (`str` 或 [TensorType](/docs/transformers/main/zh/internal/file_utils#transformers.TensorType)，*可选*)：如果设置，将返回张量而不是 Python 整数列表。可接受的值为： - `'pt'`：返回 PyTorch `torch.Tensor` 对象。 - `'np'`：返回 Numpy `np.ndarray` 对象。 用于对与表格相关的一个或多个序列进行分词并准备输入模型的主要方法。 #### convert_logits_to_predictions[[transformers.TapasTokenizer.convert_logits_to_predictions]] ```python convert_logits_to_predictions(data, logits, logits_agg = None, cell_classification_threshold = 0.5) ``` [来源](https://github.com/huggingface/transformers/blob/main/src/transformers/models/tapas/tokenization_tapas.py#L1885) **参数：** data (`dict`) : 将特征映射到实际值的字典。应使用 [TapasTokenizer](/docs/transformers/main/zh/model_doc/tapas#transformers.TapasTokenizer) 创建。 logits (`torch.Tensor`，形状为 `(batch_size, sequence_length)`)：包含 token 级别 logits 的张量。 logits_agg (`torch.Tensor`，形状为 `(batch_size, num_aggregation_labels)`，*可选*) : 包含聚合 logits 的张量。 cell_classification_threshold (`float`, *可选*，默认为 0.5)：用于单元格选择的阈值。所有概率大于该阈值的表格单元格都将被选中。 **返回：** `tuple`，包含根据输入而定的各种元素 - predicted_answer_coordinates (`list[list[[tuple]]`，长度为 `batch_size`)：预测的答案坐标，表示为元组列表的列表。列表中的每个元素包含批次中单个示例的预测答案坐标，表示为元组列表。每个元组代表一个单元格，即（行索引，列索引）。 - predicted_aggregation_indices (`list[int]`，长度为 `batch_size`，*可选*，在提供 `logits_aggregation` 时返回)：聚合头预测的聚合算子索引。 将 [TapasForQuestionAnswering](/docs/transformers/main/zh/model_doc/tapas#transformers.TapasForQuestionAnswering) 的 logits 转换为实际的预测答案坐标以及可选的聚合索引。 该函数所基于的原始实现可在[此处](https://github.com/google-research/tapas/blob/4908213eb4df7aa988573350278b44c4dbe3f71b/tapas/experiments/prediction_utils.py#L288)找到。 #### save_vocabulary[[transformers.TapasTokenizer.save_vocabulary]] ```python save_vocabulary(save_directory: str, filename_prefix: str | None = None) ``` [来源](https://github.com/huggingface/transformers/blob/main/src/transformers/models/tapas/tokenization_tapas.py#L386) ## TapasModel[[transformers.TapasModel]] #### transformers.TapasModel[[transformers.TapasModel]] ```python transformers.TapasModel(config: TapasConfig, add_pooling_layer = True) ``` [来源](https://github.com/huggingface/transformers/blob/main/src/transformers/models/tapas/modeling_tapas.py#L510) **参数：** config ([TapasConfig](/docs/transformers/main/zh/model_doc/tapas#transformers.TapasConfig))：模型配置类，包含模型的所有参数。通过配置文件进行初始化并不会加载与模型关联的权重，仅加载配置。请查看 [from_pretrained()](/docs/transformers/main/zh/main_classes/model#transformers.PreTrainedModel.from_pretrained) 方法以加载模型权重。 add_pooling_layer (`bool`，*可选*，默认为 `True`)：是否添加池化层 未添加任何特定头部的裸 Tapas 模型，直接输出原始隐藏状态。 该模型继承自 [PreTrainedModel](/docs/transformers/main/zh/main_classes/model#transformers.PreTrainedModel)。请查阅父类文档，了解该库为所有模型实现的通用方法（例如下载或保存、调整输入嵌入大小、剪枝头等）。 该模型也是 PyTorch [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) 的子类。请将其作为常规的 PyTorch Module 使用，有关通用用法和行为的所有事项，请参阅 PyTorch 文档。 #### forward[[transformers.TapasModel.forward]] ```python forward(input_ids: typing.Optional[torch.LongTensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, token_type_ids: typing.Optional[torch.LongTensor] = None, position_ids: typing.Optional[torch.LongTensor] = None, inputs_embeds: typing.Optional[torch.Tensor] = None, encoder_hidden_states: typing.Optional[torch.Tensor] = None, encoder_attention_mask: typing.Optional[torch.Tensor] = None, output_attentions: bool | None = None, output_hidden_states: bool | None = None, return_dict: bool | None = None, **kwargs) ``` [来源](https://github.com/huggingface/transformers/blob/main/src/transformers/models/tapas/modeling_tapas.py#L543) **参数：** input_ids (`torch.LongTensor`，形状为 `(batch_size, sequence_length)`，*可选*)：输入序列中 token 在词汇表中的索引。默认情况下，填充（padding）将被忽略。可以使用 [AutoTokenizer](/docs/transformers/main/zh/model_doc/auto#transformers.AutoTokenizer) 获取索引。有关详细信息，请参阅 [PreTrainedTokenizer.encode()](/docs/transformers/main/zh/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) 和 [PreTrainedTokenizer.__call__()](/docs/transformers/main/zh/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__)。[什么是输入 ID？](../glossary#input-ids) attention_mask (`torch.Tensor`，形状为 `(batch_size, sequence_length)`，*可选*)：用于避免对填充（padding）标记索引执行注意力机制的掩码。掩码值取自 `[0, 1]`： - 1 表示**未掩码**的标记， - 0 表示**已掩码**的标记。 [什么是注意力掩码？](../glossary#attention-mask) token_type_ids (`torch.LongTensor`，形状为 `(batch_size, sequence_length, 7)`，*可选*)：编码表格结构的 Token 索引。可以使用 [AutoTokenizer](/docs/transformers/main/zh/model_doc/auto#transformers.AutoTokenizer) 获取这些索引。有关更多信息，请参阅此类。 [什么是 token type IDs？](../glossary#token-type-ids) position_ids (`torch.LongTensor`，形状为 `(batch_size, sequence_length)`，*可选*)：输入序列中每个 token 在位置嵌入中的位置索引。如果 [TapasConfig](/docs/transformers/main/zh/model_doc/tapas#transformers.TapasConfig) 的 `reset_position_index_per_cell` 设置为 `True`，则会使用相对位置嵌入。取值范围为 `[0, config.max_position_embeddings - 1]`。[什么是位置 ID？](../glossary#position-ids) inputs_embeds (`torch.Tensor`，形状为 `(batch_size, sequence_length, hidden_size)`，*可选*)：可选地，你可以选择直接传入嵌入表示，而不是传入 `input_ids`。如果你希望比模型内部的嵌入查找矩阵更精细地控制如何将 `input_ids` 索引转换为对应的向量，这将非常有用。 encoder_hidden_states (`torch.Tensor`，形状为 `(batch_size, sequence_length, hidden_size)`，*可选*)：编码器最后一层输出的隐藏状态序列。如果模型被配置为解码器，则用于交叉注意力。 encoder_attention_mask (`torch.Tensor`，形状为 `(batch_size, sequence_length)`，*可选*)：用于避免对编码器输入中填充标记索引执行注意力机制的掩码。如果模型被配置为解码器，此掩码将用于交叉注意力。在 `[0, 1]` 中选择的掩码值： - 对于**未掩码**的标记，值为 1； - 对于**已掩码**的标记，值为 0。 output_attentions (`bool`, *可选*) : 是否返回所有注意力层的注意力张量。有关更多详细信息，请参阅返回张量中的 `attentions`。 output_hidden_states (`bool`, *可选*) : 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回张量中的 `hidden_states`。 return_dict (`bool`, *可选*) : 是否返回 [ModelOutput](/docs/transformers/main/zh/main_classes/output#transformers.utils.ModelOutput) 而不是普通元组。 **返回：** [BaseModelOutputWithPooling](/docs/transformers/main/zh/main_classes/output#transformers.modeling_outputs.BaseModelOutputWithPooling) 或 `tuple(torch.Tensor)` 一个 [BaseModelOutputWithPooling](/docs/transformers/main/zh/main_classes/output#transformers.modeling_outputs.BaseModelOutputWithPooling) 或 `torch.Tensor` 元组（如果传入了 `return_dict=False` 或 `config.return_dict=False`），其包含的元素取决于配置（[TapasConfig](/docs/transformers/main/zh/model_doc/tapas#transformers.TapasConfig)）和输入。 [TapasModel](/docs/transformers/main/zh/model_doc/tapas#transformers.TapasModel) 的 forward 方法重写了 `__call__` 特殊方法。 尽管前向传播的实现需要在此函数中定义，但之后应调用 `Module` 实例，而不是直接调用此函数，因为前者会负责执行预处理和后处理步骤，而后者会静默地忽略这些步骤。 - **last_hidden_state**（形状为 `(batch_size, sequence_length, hidden_size)` 的 `torch.Tensor`）-- 模型最后一层输出的隐藏状态序列。 - **pooler_output**（形状为 `(batch_size, hidden_size)` 的 `torch.Tensor`）-- 序列中第一个 token（分类 token）的最后一层隐藏状态，经过用于辅助预训练任务的层进一步处理后的结果。例如，对于 BERT 系列模型，这返回的是分类 token 经过线性层和 tanh 激活函数处理后的结果。线性层的权重是在预训练期间通过下一句预测（分类）目标训练得到的。 - **hidden_states** (`tuple(torch.Tensor)`，*可选*，在传入 `output_hidden_states=True` 或 `config.output_hidden_states=True` 时返回) -- 一个 `torch.Tensor` 元组（如果模型具有嵌入层，则包含嵌入层的输出，以及每一层的输出），形状为 `(batch_size, sequence_length, hidden_size)`。 模型在每一层输出处的隐藏状态，以及可选的初始嵌入输出。 - **attentions** (`tuple(torch.Tensor)`，*可选*，当传入 `output_attentions=True` 或 `config.output_attentions=True` 时返回) -- 一个 `torch.Tensor` 元组（每层一个），形状为 `(batch_size, num_heads, sequence_length, sequence_length)`。 经过注意力 softmax 后的注意力权重，用于在自注意力头中计算加权平均值。 示例： ```python >>> from transformers import AutoTokenizer, TapasModel >>> import pandas as pd >>> tokenizer = AutoTokenizer.from_pretrained("google/tapas-base") >>> model = TapasModel.from_pretrained("google/tapas-base") >>> data = { ... "Actors": ["Brad Pitt", "Leonardo Di Caprio", "George Clooney"], ... "Age": ["56", "45", "59"], ... "Number of movies": ["87", "53", "69"], ... } >>> table = pd.DataFrame.from_dict(data) >>> queries = ["How many movies has George Clooney played in?", "How old is Brad Pitt?"] >>> inputs = tokenizer(table=table, queries=queries, padding="max_length", return_tensors="pt") >>> outputs = model(**inputs) >>> last_hidden_states = outputs.last_hidden_state ``` ## TapasForMaskedLM[[transformers.TapasForMaskedLM]] #### transformers.TapasForMaskedLM[[transformers.TapasForMaskedLM]] ```python transformers.TapasForMaskedLM(config: TapasConfig) ``` [来源](https://github.com/huggingface/transformers/blob/main/src/transformers/models/tapas/modeling_tapas.py#L660) **参数：** config ([TapasConfig](/docs/transformers/main/zh/model_doc/tapas#transformers.TapasConfig))：模型配置类，包含模型的所有参数。通过配置文件进行初始化并不会加载与模型关联的权重，仅加载配置。请查看 [from_pretrained()](/docs/transformers/main/zh/main_classes/model#transformers.PreTrainedModel.from_pretrained) 方法以加载模型权重。 顶部带有`language modeling`头的 Tapas 模型。 该模型继承自 [PreTrainedModel](/docs/transformers/main/zh/main_classes/model#transformers.PreTrainedModel)。请查阅父类文档，了解该库为所有模型实现的通用方法（例如下载或保存、调整输入嵌入大小、剪枝头等）。 该模型也是 PyTorch [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) 的子类。请将其作为常规的 PyTorch Module 使用，有关通用用法和行为的所有事项，请参阅 PyTorch 文档。 #### forward[[transformers.TapasForMaskedLM.forward]] ```python forward(input_ids: typing.Optional[torch.LongTensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, token_type_ids: typing.Optional[torch.LongTensor] = None, position_ids: typing.Optional[torch.LongTensor] = None, inputs_embeds: typing.Optional[torch.Tensor] = None, encoder_hidden_states: typing.Optional[torch.Tensor] = None, encoder_attention_mask: typing.Optional[torch.Tensor] = None, labels: typing.Optional[torch.LongTensor] = None, output_attentions: bool | None = None, output_hidden_states: bool | None = None, return_dict: bool | None = None, **kwargs) ``` [来源](https://github.com/huggingface/transformers/blob/main/src/transformers/models/tapas/modeling_tapas.py#L684) **参数：** input_ids (`torch.LongTensor`，形状为 `(batch_size, sequence_length)`，*可选*)：输入序列中 token 在词汇表中的索引。默认情况下，填充（padding）将被忽略。可以使用 [AutoTokenizer](/docs/transformers/main/zh/model_doc/auto#transformers.AutoTokenizer) 获取索引。有关详细信息，请参阅 [PreTrainedTokenizer.encode()](/docs/transformers/main/zh/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) 和 [PreTrainedTokenizer.__call__()](/docs/transformers/main/zh/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__)。[什么是输入 ID？](../glossary#input-ids) attention_mask (`torch.Tensor`，形状为 `(batch_size, sequence_length)`，*可选*)：用于避免对填充（padding）标记索引执行注意力机制的掩码。掩码值取自 `[0, 1]`： - 1 表示**未掩码**的标记， - 0 表示**已掩码**的标记。 [什么是注意力掩码？](../glossary#attention-mask) token_type_ids (`torch.LongTensor`，形状为 `(batch_size, sequence_length, 7)`，*可选*)：编码表格结构的 Token 索引。可以使用 [AutoTokenizer](/docs/transformers/main/zh/model_doc/auto#transformers.AutoTokenizer) 获取这些索引。有关更多信息，请参阅此类。 [什么是 token type IDs？](../glossary#token-type-ids) position_ids (`torch.LongTensor`，形状为 `(batch_size, sequence_length)`，*可选*)：输入序列中每个 token 在位置嵌入中的位置索引。如果 [TapasConfig](/docs/transformers/main/zh/model_doc/tapas#transformers.TapasConfig) 的 `reset_position_index_per_cell` 设置为 `True`，则会使用相对位置嵌入。取值范围为 `[0, config.max_position_embeddings - 1]`。[什么是位置 ID？](../glossary#position-ids) inputs_embeds (`torch.Tensor`，形状为 `(batch_size, sequence_length, hidden_size)`，*可选*)：可选地，你可以选择直接传入嵌入表示，而不是传入 `input_ids`。如果你希望比模型内部的嵌入查找矩阵更精细地控制如何将 `input_ids` 索引转换为对应的向量，这将非常有用。 encoder_hidden_states (`torch.Tensor`，形状为 `(batch_size, sequence_length, hidden_size)`，*可选*)：编码器最后一层输出的隐藏状态序列。如果模型被配置为解码器，则用于交叉注意力。 encoder_attention_mask (`torch.Tensor`，形状为 `(batch_size, sequence_length)`，*可选*)：用于避免对编码器输入中填充标记索引执行注意力机制的掩码。如果模型被配置为解码器，此掩码将用于交叉注意力。在 `[0, 1]` 中选择的掩码值： - 对于**未掩码**的标记，值为 1； - 对于**已掩码**的标记，值为 0。 labels (`torch.LongTensor`，形状为 `(batch_size, sequence_length)`，*可选*)：用于计算掩码语言建模损失的标签。索引应在 `[-100, 0, ..., config.vocab_size]` 范围内（参见 `input_ids` 的文档字符串）。索引设置为 `-100` 的令牌将被忽略（掩码），损失仅针对标签在 `[0, ..., config.vocab_size]` 范围内的令牌进行计算。 output_attentions (`bool`, *可选*) : 是否返回所有注意力层的注意力张量。有关更多详细信息，请参阅返回张量中的 `attentions`。 output_hidden_states (`bool`, *可选*) : 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回张量中的 `hidden_states`。 return_dict (`bool`, *可选*) : 是否返回 [ModelOutput](/docs/transformers/main/zh/main_classes/output#transformers.utils.ModelOutput) 而不是普通元组。 **返回：** [MaskedLMOutput](/docs/transformers/main/zh/main_classes/output#transformers.modeling_outputs.MaskedLMOutput) 或 `tuple(torch.Tensor)` 一个 [MaskedLMOutput](/docs/transformers/main/zh/main_classes/output#transformers.modeling_outputs.MaskedLMOutput) 或 `torch.Tensor` 元组（如果传入了 `return_dict=False` 或 `config.return_dict=False`），其包含的元素取决于配置（[TapasConfig](/docs/transformers/main/zh/model_doc/tapas#transformers.TapasConfig)）和输入。 [TapasForMaskedLM](/docs/transformers/main/zh/model_doc/tapas#transformers.TapasForMaskedLM) 的 forward 方法重写了 `__call__` 特殊方法。 尽管前向传播的实现需要在此函数中定义，但之后应调用 `Module` 实例，而不是直接调用此函数，因为前者会负责执行预处理和后处理步骤，而后者会静默地忽略这些步骤。 - **loss** (`torch.Tensor`，形状为 `(1,)`，*可选*，当提供 `labels` 时返回) -- 掩码语言建模（MLM）损失。 - **logits**（形状为 `(batch_size, sequence_length, config.vocab_size)` 的 `torch.Tensor`）-- 语言建模头的预测分数（SoftMax 之前每个词汇表 token 的分数）。 - **hidden_states** (`tuple(torch.Tensor)`，*可选*，在传入 `output_hidden_states=True` 或 `config.output_hidden_states=True` 时返回) -- 一个 `torch.Tensor` 元组（如果模型具有嵌入层，则包含嵌入层的输出，以及每一层的输出），形状为 `(batch_size, sequence_length, hidden_size)`。 模型在每一层输出处的隐藏状态，以及可选的初始嵌入输出。 - **attentions** (`tuple(torch.Tensor)`，*可选*，当传入 `output_attentions=True` 或 `config.output_attentions=True` 时返回) -- 一个 `torch.Tensor` 元组（每层一个），形状为 `(batch_size, num_heads, sequence_length, sequence_length)`。 经过注意力 softmax 后的注意力权重，用于在自注意力头中计算加权平均值。 示例： ```python >>> from transformers import AutoTokenizer, TapasForMaskedLM >>> import pandas as pd >>> tokenizer = AutoTokenizer.from_pretrained("google/tapas-base") >>> model = TapasForMaskedLM.from_pretrained("google/tapas-base") >>> data = { ... "Actors": ["Brad Pitt", "Leonardo Di Caprio", "George Clooney"], ... "Age": ["56", "45", "59"], ... "Number of movies": ["87", "53", "69"], ... } >>> table = pd.DataFrame.from_dict(data) >>> inputs = tokenizer( ... table=table, queries="How many [MASK] has George [MASK] played in?", return_tensors="pt" ... ) >>> labels = tokenizer( ... table=table, queries="How many movies has George Clooney played in?", return_tensors="pt" ... )["input_ids"] >>> outputs = model(**inputs, labels=labels) >>> logits = outputs.logits ``` ## TapasForSequenceClassification[[transformers.TapasForSequenceClassification]] #### transformers.TapasForSequenceClassification[[transformers.TapasForSequenceClassification]] ```python transformers.TapasForSequenceClassification(config: TapasConfig) ``` [来源](https://github.com/huggingface/transformers/blob/main/src/transformers/models/tapas/modeling_tapas.py#L1119) **参数：** config ([TapasConfig](/docs/transformers/main/zh/model_doc/tapas#transformers.TapasConfig))：模型配置类，包含模型的所有参数。通过配置文件进行初始化并不会加载与模型关联的权重，仅加载配置。请查看 [from_pretrained()](/docs/transformers/main/zh/main_classes/model#transformers.PreTrainedModel.from_pretrained) 方法以加载模型权重。 在顶部添加序列分类头（即在池化输出之上添加一个线性层）的 Tapas 模型，例如用于表格蕴含任务，如 TabFact（Chen et al., 2020）。 该模型继承自 [PreTrainedModel](/docs/transformers/main/zh/main_classes/model#transformers.PreTrainedModel)。请查阅父类文档，了解该库为所有模型实现的通用方法（例如下载或保存、调整输入嵌入大小、剪枝头等）。 该模型也是 PyTorch [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) 的子类。请将其作为常规的 PyTorch Module 使用，有关通用用法和行为的所有事项，请参阅 PyTorch 文档。 #### forward[[transformers.TapasForSequenceClassification.forward]] ```python forward(input_ids: typing.Optional[torch.LongTensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, token_type_ids: typing.Optional[torch.LongTensor] = None, position_ids: typing.Optional[torch.LongTensor] = None, inputs_embeds: typing.Optional[torch.Tensor] = None, labels: typing.Optional[torch.LongTensor] = None, output_attentions: bool | None = None, output_hidden_states: bool | None = None, return_dict: bool | None = None, **kwargs) ``` [来源](https://github.com/huggingface/transformers/blob/main/src/transformers/models/tapas/modeling_tapas.py#L1131) **参数：** input_ids (`torch.LongTensor`，形状为 `(batch_size, sequence_length)`，*可选*)：输入序列中 token 在词汇表中的索引。默认情况下，填充（padding）将被忽略。可以使用 [AutoTokenizer](/docs/transformers/main/zh/model_doc/auto#transformers.AutoTokenizer) 获取索引。有关详细信息，请参阅 [PreTrainedTokenizer.encode()](/docs/transformers/main/zh/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) 和 [PreTrainedTokenizer.__call__()](/docs/transformers/main/zh/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__)。[什么是输入 ID？](../glossary#input-ids) attention_mask (`torch.Tensor`，形状为 `(batch_size, sequence_length)`，*可选*)：用于避免对填充（padding）标记索引执行注意力机制的掩码。掩码值取自 `[0, 1]`： - 1 表示**未掩码**的标记， - 0 表示**已掩码**的标记。 [什么是注意力掩码？](../glossary#attention-mask) token_type_ids (`torch.LongTensor`，形状为 `(batch_size, sequence_length, 7)`，*可选*)：编码表格结构的 Token 索引。可以使用 [AutoTokenizer](/docs/transformers/main/zh/model_doc/auto#transformers.AutoTokenizer) 获取这些索引。有关更多信息，请参阅此类。 [什么是 token type IDs？](../glossary#token-type-ids) position_ids (`torch.LongTensor`，形状为 `(batch_size, sequence_length)`，*可选*)：输入序列中每个 token 在位置嵌入中的位置索引。如果 [TapasConfig](/docs/transformers/main/zh/model_doc/tapas#transformers.TapasConfig) 的 `reset_position_index_per_cell` 设置为 `True`，则会使用相对位置嵌入。取值范围为 `[0, config.max_position_embeddings - 1]`。[什么是位置 ID？](../glossary#position-ids) inputs_embeds (`torch.Tensor`，形状为 `(batch_size, sequence_length, hidden_size)`，*可选*)：可选地，你可以选择直接传入嵌入表示，而不是传入 `input_ids`。如果你希望比模型内部的嵌入查找矩阵更精细地控制如何将 `input_ids` 索引转换为对应的向量，这将非常有用。 labels (`torch.LongTensor`，形状为 `(batch_size,)`，*可选*) : 用于计算序列分类/回归损失的标签。索引应在 `[0, ..., config.num_labels - 1]` 范围内。如果 `config.num_labels == 1`，则计算回归损失（均方损失）；如果 `config.num_labels > 1`，则计算分类损失（交叉熵）。注意：在原始实现中，这被称为 "classification_class_index"。 output_attentions (`bool`, *可选*) : 是否返回所有注意力层的注意力张量。有关更多详细信息，请参阅返回张量中的 `attentions`。 output_hidden_states (`bool`, *可选*) : 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回张量中的 `hidden_states`。 return_dict (`bool`, *可选*) : 是否返回 [ModelOutput](/docs/transformers/main/zh/main_classes/output#transformers.utils.ModelOutput) 而不是普通元组。 **返回：** [SequenceClassifierOutput](/docs/transformers/main/zh/main_classes/output#transformers.modeling_outputs.SequenceClassifierOutput) 或 `tuple(torch.Tensor)` 一个 [SequenceClassifierOutput](/docs/transformers/main/zh/main_classes/output#transformers.modeling_outputs.SequenceClassifierOutput) 或 `torch.Tensor` 元组（如果传入了 `return_dict=False` 或 `config.return_dict=False`），其包含的元素取决于配置（[TapasConfig](/docs/transformers/main/zh/model_doc/tapas#transformers.TapasConfig)）和输入。 [TapasForSequenceClassification](/docs/transformers/main/zh/model_doc/tapas#transformers.TapasForSequenceClassification) 的 forward 方法重写了 `__call__` 特殊方法。 尽管前向传播的实现需要在此函数中定义，但之后应调用 `Module` 实例，而不是直接调用此函数，因为前者会负责执行预处理和后处理步骤，而后者会静默地忽略这些步骤。 - **loss** (`torch.Tensor`，形状为 `(1,)`，*可选*，当提供 `labels` 时返回) -- 分类损失（如果 config.num_labels==1，则为回归损失）。 - **logits**（形状为 `(batch_size, config.num_labels)` 的 `torch.Tensor`）-- 分类（或当 config.num_labels==1 时为回归）得分（SoftMax 之前）。 - **hidden_states** (`tuple(torch.Tensor)`，*可选*，在传入 `output_hidden_states=True` 或 `config.output_hidden_states=True` 时返回) -- 一个 `torch.Tensor` 元组（如果模型具有嵌入层，则包含嵌入层的输出，以及每一层的输出），形状为 `(batch_size, sequence_length, hidden_size)`。 模型在每一层输出处的隐藏状态，以及可选的初始嵌入输出。 - **attentions** (`tuple(torch.Tensor)`，*可选*，当传入 `output_attentions=True` 或 `config.output_attentions=True` 时返回) -- 一个 `torch.Tensor` 元组（每层一个），形状为 `(batch_size, num_heads, sequence_length, sequence_length)`。 经过注意力 softmax 后的注意力权重，用于在自注意力头中计算加权平均值。 示例： ```python >>> from transformers import AutoTokenizer, TapasForSequenceClassification >>> import torch >>> import pandas as pd >>> tokenizer = AutoTokenizer.from_pretrained("google/tapas-base-finetuned-tabfact") >>> model = TapasForSequenceClassification.from_pretrained("google/tapas-base-finetuned-tabfact") >>> data = { ... "Actors": ["Brad Pitt", "Leonardo Di Caprio", "George Clooney"], ... "Age": ["56", "45", "59"], ... "Number of movies": ["87", "53", "69"], ... } >>> table = pd.DataFrame.from_dict(data) >>> queries = [ ... "There is only one actor who is 45 years old", ... "There are 3 actors which played in more than 60 movies", ... ] >>> inputs = tokenizer(table=table, queries=queries, padding="max_length", return_tensors="pt") >>> labels = torch.tensor([1, 0]) # 1 means entailed, 0 means refuted >>> outputs = model(**inputs, labels=labels) >>> loss = outputs.loss >>> logits = outputs.logits ``` ## TapasForQuestionAnswering[[transformers.TapasForQuestionAnswering]] #### transformers.TapasForQuestionAnswering[[transformers.TapasForQuestionAnswering]] ```python transformers.TapasForQuestionAnswering(config: TapasConfig) ``` [来源](https://github.com/huggingface/transformers/blob/main/src/transformers/models/tapas/modeling_tapas.py#L781) **参数：** config ([TapasConfig](/docs/transformers/main/zh/model_doc/tapas#transformers.TapasConfig))：模型配置类，包含模型的所有参数。通过配置文件进行初始化并不会加载与模型关联的权重，仅加载配置。请查看 [from_pretrained()](/docs/transformers/main/zh/main_classes/model#transformers.PreTrainedModel.from_pretrained) 方法以加载模型权重。 Tapas 模型，顶部带有单元格选择头以及可选的聚合头，用于表格上的问答任务（在隐藏状态输出之上添加线性层以计算 `logits` 和可选的 `logits_aggregation`），例如用于 SQA、WTQ 或 WikiSQL 监督任务。 该模型继承自 [PreTrainedModel](/docs/transformers/main/zh/main_classes/model#transformers.PreTrainedModel)。请查阅父类文档，了解该库为所有模型实现的通用方法（例如下载或保存、调整输入嵌入大小、剪枝头等）。 该模型也是 PyTorch [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) 的子类。请将其作为常规的 PyTorch Module 使用，有关通用用法和行为的所有事项，请参阅 PyTorch 文档。 #### forward[[transformers.TapasForQuestionAnswering.forward]] ```python forward(input_ids: typing.Optional[torch.LongTensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, token_type_ids: typing.Optional[torch.LongTensor] = None, position_ids: typing.Optional[torch.LongTensor] = None, inputs_embeds: typing.Optional[torch.Tensor] = None, table_mask: typing.Optional[torch.LongTensor] = None, labels: typing.Optional[torch.LongTensor] = None, aggregation_labels: typing.Optional[torch.LongTensor] = None, float_answer: typing.Optional[torch.Tensor] = None, numeric_values: typing.Optional[torch.Tensor] = None, numeric_values_scale: typing.Optional[torch.Tensor] = None, output_attentions: bool | None = None, output_hidden_states: bool | None = None, return_dict: bool | None = None, **kwargs) ``` [来源](https://github.com/huggingface/transformers/blob/main/src/transformers/models/tapas/modeling_tapas.py#L804) **参数：** input_ids (`torch.LongTensor`，形状为 `(batch_size, sequence_length)`，*可选*)：输入序列中 token 在词汇表中的索引。默认情况下，填充（padding）将被忽略。可以使用 [AutoTokenizer](/docs/transformers/main/zh/model_doc/auto#transformers.AutoTokenizer) 获取索引。有关详细信息，请参阅 [PreTrainedTokenizer.encode()](/docs/transformers/main/zh/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) 和 [PreTrainedTokenizer.__call__()](/docs/transformers/main/zh/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__)。[什么是输入 ID？](../glossary#input-ids) attention_mask (`torch.Tensor`，形状为 `(batch_size, sequence_length)`，*可选*)：用于避免对填充（padding）标记索引执行注意力机制的掩码。掩码值取自 `[0, 1]`： - 1 表示**未掩码**的标记， - 0 表示**已掩码**的标记。 [什么是注意力掩码？](../glossary#attention-mask) token_type_ids (`torch.LongTensor`，形状为 `(batch_size, sequence_length, 7)`，*可选*)：编码表格结构的 Token 索引。可以使用 [AutoTokenizer](/docs/transformers/main/zh/model_doc/auto#transformers.AutoTokenizer) 获取这些索引。有关更多信息，请参阅此类。 [什么是 token type IDs？](../glossary#token-type-ids) position_ids (`torch.LongTensor`，形状为 `(batch_size, sequence_length)`，*可选*)：输入序列中每个 token 在位置嵌入中的位置索引。如果 [TapasConfig](/docs/transformers/main/zh/model_doc/tapas#transformers.TapasConfig) 的 `reset_position_index_per_cell` 设置为 `True`，则会使用相对位置嵌入。取值范围为 `[0, config.max_position_embeddings - 1]`。[什么是位置 ID？](../glossary#position-ids) inputs_embeds (`torch.Tensor`，形状为 `(batch_size, sequence_length, hidden_size)`，*可选*)：可选地，你可以选择直接传入嵌入表示，而不是传入 `input_ids`。如果你希望比模型内部的嵌入查找矩阵更精细地控制如何将 `input_ids` 索引转换为对应的向量，这将非常有用。 table_mask (`torch.LongTensor`，形状为 `(batch_size, seq_length)`，*可选*) : 表格的掩码。指示哪些 token 属于表格（1）。问题 token、表头和填充均为 0。 labels (`torch.LongTensor`，形状为 `(batch_size, seq_length)`，*可选*)：用于计算分层单元格选择损失的每个 token 的标签。它编码了答案在表格中出现的位置。可以使用 [AutoTokenizer](/docs/transformers/main/zh/model_doc/auto#transformers.AutoTokenizer) 获取。 - 对于**属于答案**的 token 为 -1，对于**不属于答案**的 token 为 -0。 aggregation_labels (`torch.LongTensor`，形状为 `(batch_size, )`，*可选*)：用于计算聚合损失的批处理中每个样本的聚合函数索引。索引应在 `[0, ..., config.num_aggregation_labels - 1]` 范围内。仅在聚合的强监督（WikiSQL 监督）情况下需要。 float_answer (`torch.Tensor`，形状为 `(batch_size, )`，*可选*)：批次中每个示例的浮点数答案。对于单元格选择问题，请设置为 *float('nan')*。仅在弱监督（WTQ）情况下需要，用于计算聚合掩码和回归损失。 numeric_values (`torch.Tensor`，形状为 `(batch_size, seq_length)`，*可选*)：每个 token 的数值，非数值 token 为 NaN。可通过 [AutoTokenizer](/docs/transformers/main/zh/model_doc/auto#transformers.AutoTokenizer) 获取。仅在弱监督聚合（WTQ）场景下需要，用于计算回归损失。 numeric_values_scale (`torch.Tensor`，形状为 `(batch_size, seq_length)`，*可选*)：每个 token 的数值缩放比例。可通过 [AutoTokenizer](/docs/transformers/main/zh/model_doc/auto#transformers.AutoTokenizer) 获取。仅在聚合的弱监督（WTQ）情况下需要，用于计算回归损失。 output_attentions (`bool`, *可选*) : 是否返回所有注意力层的注意力张量。有关更多详细信息，请参阅返回张量中的 `attentions`。 output_hidden_states (`bool`, *可选*) : 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回张量中的 `hidden_states`。 return_dict (`bool`, *可选*) : 是否返回 [ModelOutput](/docs/transformers/main/zh/main_classes/output#transformers.utils.ModelOutput) 而不是普通元组。 **返回：** [TableQuestionAnsweringOutput](/docs/transformers/main/zh/model_doc/tapas#transformers.models.tapas.modeling_tapas.TableQuestionAnsweringOutput) 或 `tuple(torch.Tensor)` 一个 [TableQuestionAnsweringOutput](/docs/transformers/main/zh/model_doc/tapas#transformers.models.tapas.modeling_tapas.TableQuestionAnsweringOutput) 或 `torch.Tensor` 元组（如果传入了 `return_dict=False` 或 `config.return_dict=False`），其包含的元素取决于配置（[TapasConfig](/docs/transformers/main/zh/model_doc/tapas#transformers.TapasConfig)）和输入。 [TapasForQuestionAnswering](/docs/transformers/main/zh/model_doc/tapas#transformers.TapasForQuestionAnswering) 的 forward 方法重写了 `__call__` 特殊方法。 尽管前向传播的实现需要在此函数中定义，但之后应调用 `Module` 实例，而不是直接调用此函数，因为前者会负责执行预处理和后处理步骤，而后者会静默地忽略这些步骤。 - **loss** (`torch.Tensor`，形状为 `(1,)`，*可选*，当提供 `labels`（以及可能的 `answer`、`aggregation_labels`、`numeric_values` 和 `numeric_values_scale`）时返回） -- 总损失，为分层单元格选择对数似然损失与（可选的）半监督回归损失以及（可选的）聚合监督损失之和。 - **logits**（形状为 `(batch_size, sequence_length)` 的 `torch.Tensor`）-- 单元格选择头针对每个 token 的预测分数。 - **logits_aggregation** (`torch.Tensor`，*可选*，形状为 `(batch_size, num_aggregation_labels)`) -- 聚合头针对每个聚合算子的预测分数。 - **hidden_states** (`tuple[torch.Tensor]`，*可选*，在传入 `output_hidden_states=True` 或 `config.output_hidden_states=True` 时返回) -- 一个 `torch.Tensor` 元组（如果模型具有嵌入层，则包含嵌入层输出的一个张量，以及每个层输出的一个张量），形状为 `(batch_size, sequence_length, hidden_size)`。 模型在每一层输出处的隐藏状态，以及可选的初始嵌入输出。 - **attentions** (`tuple[torch.Tensor]`，*可选*，当传入 `output_attentions=True` 或 `config.output_attentions=True` 时返回) -- 一个 `torch.Tensor` 元组（每层一个），形状为 `(batch_size, num_heads, sequence_length, sequence_length)`。 经过注意力 softmax 后的注意力权重，用于在自注意力头中计算加权平均值。 示例： ```python >>> from transformers import AutoTokenizer, TapasForQuestionAnswering >>> import pandas as pd >>> tokenizer = AutoTokenizer.from_pretrained("google/tapas-base-finetuned-wtq") >>> model = TapasForQuestionAnswering.from_pretrained("google/tapas-base-finetuned-wtq") >>> data = { ... "Actors": ["Brad Pitt", "Leonardo Di Caprio", "George Clooney"], ... "Age": ["56", "45", "59"], ... "Number of movies": ["87", "53", "69"], ... } >>> table = pd.DataFrame.from_dict(data) >>> queries = ["How many movies has George Clooney played in?", "How old is Brad Pitt?"] >>> inputs = tokenizer(table=table, queries=queries, padding="max_length", return_tensors="pt") >>> outputs = model(**inputs) >>> logits = outputs.logits >>> logits_aggregation = outputs.logits_aggregation ```