Hugging Face's logo

Transformers documentation

TAPAS

Hugging Face's logo
Join the Hugging Face community

and get access to the augmented documentation experience

to get started

该模型于 2020-04-05 在 HF papers 上发布，并于 2020-12-15 贡献至 Hugging Face Transformers。

TAPAS

概述

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

在问答任务中，TAPAS 顶部有两个头：一个单元格选择头和一个聚合头，用于（可选地）对选定的单元格执行聚合操作（例如计数或求和）。TAPAS 已在多个数据集上进行了微调：

  • SQA（微软的 Sequential Question Answering）
  • WTQ（斯坦福大学提出的 Wiki Table Questions）
  • WikiSQL（由 Salesforce 提供）。

它在 SQA 和 WTQ 上均达到了最先进的水平，同时在 WikiSQL 上的性能与 SOTA 相当，且架构要简单得多。

该论文的摘要如下：

在表格上回答自然语言问题通常被视为语义解析任务。为了减轻完整逻辑形式的收集成本，一种流行的方法专注于由指称（denotation）而非逻辑形式组成的弱监督。然而，从弱监督中训练语义解析器存在困难，此外，生成的逻辑形式仅作为检索指称之前的中间步骤使用。在本文中，我们提出了 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 是一个包含 16k 个维基百科表格的大规模数据集，用于表格蕴含（一种二分类任务）。更多详情请参阅他们的后续论文：Julian Martin Eisenschlos、Syrine Krichene 和 Thomas Müller 撰写的 Understanding tables with intermediate pre-training。

drawing TAPAS architecture. Taken from the original blog post.

该模型由 nielsr 贡献。原始代码可在此处找到。

使用技巧

  • 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 的前向传播过程略有不同：在这种情况下，你需要将每个表格-问题对逐一输入模型，以便用模型对前一个问题的预测 labels 来覆盖 prev_labels 的 token 类型 ID。更多信息请参阅“Usage”部分。
  • TAPAS 与 BERT 类似，因此依赖于掩码语言建模（MLM）目标。因此，它在预测掩码 token 以及通用 NLU 方面效率较高，但在文本生成方面并非最优。使用因果语言建模（CLM）目标训练的模型在这方面表现更好。请注意，TAPAS 可以作为 EncoderDecoderModel 框架中的编码器，与 GPT-2 等自回归文本解码器结合使用。

用法：微调

在此，我们将介绍如何在您自己的数据集上对 TapasForQuestionAnswering 进行微调。

第 1 步：选择使用 TAPAS 的三种方式之一——或自行尝试

基本上，微调 TapasForQuestionAnswering 有 3 种不同的方式，分别对应 Tapas 所微调的不同数据集：

  1. SQA：如果您希望在对话场景中提出与表格相关的后续问题，可以使用此功能。例如，如果您先问“第一位演员的名字是什么？”，然后可以提出后续问题，如“他多大了？”。在此，问题不涉及任何聚合（所有问题均为单元格选择问题）。
  2. WTQ：如果您不希望在对话场景中提问，而是希望针对表格提出可能涉及聚合操作的问题，例如统计行数、对单元格值求和或求平均值。例如，您可以提问“克里斯蒂亚诺·罗纳尔多职业生涯的总进球数是多少？”。这种情况也被称为弱监督，因为模型仅以问题的答案作为监督信号，必须自行学习合适的聚合算子（SUM/COUNT/AVERAGE/NONE）。
  3. WikiSQL 监督：该数据集基于 WikiSQL，在训练过程中向模型提供真实的聚合算子。这也被称为强监督。在此情况下，学习合适的聚合算子要容易得多。

总结如下：

任务示例数据集描述
对话式SQA对话式，仅涉及单元格选择的问题
用于聚合的弱监督WTQ问题可能涉及聚合，模型必须仅以答案作为监督信号来学习这一点
用于聚合的强监督WikiSQL 监督问题可能涉及聚合，模型必须根据给定的标准聚合运算符来学习这一点

从 Hub 加载预训练基础模型并随机初始化分类头来初始化模型，方法如下所示。

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 时定义任意超参数，然后基于该配置创建 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, device_map="auto")

另一种做法是从一个已经微调好的检查点开始。需要注意的是，WTQ 上已有的微调检查点由于 L2 损失函数较为脆弱而存在一些已知问题。更多信息请参见 此处。

如需查看 HuggingFace 模型库中所有可用的预训练和微调 TAPAS 检查点列表，请访问此处。

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

其次，无论您在上一步中选择了什么，都应按照 SQA 格式准备数据集。该格式是一个 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 格式。作者在此处对此进行了说明。一个适用于 HuggingFace 实现的该脚本转换版本可以在此处找到。有趣的是，这些转换脚本并不完美（answer_coordinates 和 float_answer 字段是基于 answer_text 填充的），这意味着 WTQ 和 WikiSQL 的结果实际上可能还有提升空间。

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

第三，既然您已按照此 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 要求表格数据为纯文本。您可以对 dataframe 使用 .astype(str) 将其转换为纯文本数据。 当然，这仅展示了如何编码单个训练样本。建议创建一个 dataloader 来遍历批次：

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 的文档）被正确设置。更多信息请参见此笔记本。

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

然后，您可以按以下方式微调 TapasForQuestionAnswering（此处以聚合任务的弱监督为例）：

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 进行推理（即对新数据进行预测）。在推理过程中，只需向模型提供 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, 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覆盖。有关更多信息，请参阅此笔记本。

资源

TAPAS 特定输出

class transformers.models.tapas.modeling_tapas.TableQuestionAnsweringOutput

< >

( loss: typing.Optional[torch.Tensor] = Nonelogits: typing.Optional[torch.Tensor] = Nonelogits_aggregation: typing.Optional[torch.Tensor] = Nonehidden_states: tuple[torch.Tensor] | None = Noneattentions: tuple[torch.Tensor] | None = None )

参数

  • 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 的输出类型。

TapasConfig

class transformers.TapasConfig

< >

( transformers_version: str | None = Nonearchitectures: list[str] | None = Noneoutput_hidden_states: bool | None = Falsereturn_dict: bool | None = Truedtype: str | torch.dtype | None = Nonechunk_size_feed_forward: int = 0is_encoder_decoder: bool = Falseid2label: dict[int, str] | dict[str, str] | None = Nonelabel2id: dict[str, int] | dict[str, str] | None = Noneproblem_type: Literal['regression', 'single_label_classification', 'multi_label_classification'] | None = Nonevocab_size: int = 30522hidden_size: int = 768num_hidden_layers: int = 12num_attention_heads: int = 12intermediate_size: int = 3072hidden_act: str = 'gelu'hidden_dropout_prob: float | int = 0.1attention_probs_dropout_prob: float | int = 0.1max_position_embeddings: int = 1024type_vocab_sizes: list[int] | tuple[int, ...] = (3, 256, 256, 2, 256, 256, 10)initializer_range: float = 0.02layer_norm_eps: float = 1e-12pad_token_id: int | None = 0bos_token_id: int | None = Noneeos_token_id: int | list[int] | None = Nonepositive_label_weight: float = 10.0num_aggregation_labels: int = 0aggregation_loss_weight: float = 1.0use_answer_as_supervision: bool | None = Noneanswer_loss_importance: float = 1.0use_normalized_answer_loss: bool = Falsehuber_loss_delta: float | None = Nonetemperature: float = 1.0aggregation_temperature: float = 1.0use_gumbel_for_cells: bool = Falseuse_gumbel_for_aggregation: bool = Falseaverage_approximation_function: str = 'ratio'cell_selection_preference: float | None = Noneanswer_loss_cutoff: float | int | None = Nonemax_num_rows: int = 64max_num_columns: int = 32average_logits_per_cell: bool = Falseselect_one_column: bool = Trueallow_empty_column_selection: bool = Falseinit_cell_selection_weights_to_zero: bool = Falsereset_position_index_per_cell: bool = Truedisable_per_token_loss: bool = Falseaggregation_labels: dict | None = Noneno_aggregation_label_index: int | None = Noneis_decoder: bool = Falseadd_cross_attention: bool = Falsetie_word_embeddings: bool = True )

参数

  • 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 时传入的 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，可选) — 忽略答案损失大于该阈值的样本。
  • 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) — 是否将 cell selection weights 初始化为 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, 可选) — 如果定义了聚合标签，且其中一个标签表示“无聚合”，则应将其设置为该标签的索引。例如，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 类似的配置。

配置对象继承自 PreTrainedConfig，可用于控制模型输出。有关更多信息，请参阅 PreTrainedConfig 的文档。

示例：

>>> 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

class transformers.TapasTokenizer

< >

( vocab_filedo_lower_case = Truedo_basic_tokenize = Truenever_split = Noneunk_token = '[UNK]'sep_token = '[SEP]'pad_token = '[PAD]'cls_token = '[CLS]'mask_token = '[MASK]'empty_token = '[EMPTY]'tokenize_chinese_chars = Truestrip_accents = Nonecell_trim_length: int = -1max_column_id: int | None = Nonemax_row_id: int | None = Nonestrip_column_names: bool = Falseupdate_answer_coordinates: bool = Falsemin_question_length = Nonemax_question_length = Nonemodel_max_length: int = 512additional_special_tokens: list[str] | None = Noneclean_up_tokenization_spaces = True**kwargs )

参数

  • 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]") — 用于序列分类的分类器标记（即对整个序列进行分类，而非逐标记分类）。当使用特殊标记构建序列时，它是序列的第一个标记。
  • mask_token (str, 可选，默认为 "[MASK]") — 用于掩码值的标记。这是在使用掩码语言建模训练该模型时所使用的标记，也是模型试图预测的目标标记。
  • empty_token (str，可选，默认为 "[EMPTY]") — 用于表格中空单元格值的标记。空单元格值包括 ""、"n/a"、"nan" 和 "?"。
  • tokenize_chinese_chars (bool，可选，默认为 True) — 是否对汉字进行分词。对于日语，建议关闭此功能（参见此 issue）。
  • 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，后者包含了大部分主要方法。有关这些方法的更多信息，请参阅该父类。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：指示 token 属于问题（0）还是表格（1）。特殊 token 和填充使用 0。
  • column_ids：指示 token 属于表格中的哪一列（从 1 开始）。对于所有问题 token、特殊 token 和填充，其值均为 0。
  • row_ids：指示 token 属于表格中的哪一行（从 1 开始）。所有问题 token、特殊 token 和填充 token 的值均为 0。列标题的 token 值也为 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：指示问题与表格 token 之间的数值关系。对于所有问题 token、特殊 token 和填充，其值均为 0。

TapasTokenizer 对表格及其关联句子执行端到端的分词：标点符号拆分和 wordpiece。

__call__

< >

( table: typing.Union[ForwardRef('pd.DataFrame'), str, list[str], NoneType]queries: str | list[str] | list[int] | list[list[str]] | list[list[int]] | None = Noneanswer_coordinates: list[tuple] | list[list[tuple]] | None = Noneanswer_text: list[str] | list[list[str]] | None = Noneadd_special_tokens: bool = Truepadding: bool | str | transformers.utils.generic.PaddingStrategy = Falsetruncation: bool | str | transformers.models.tapas.tokenization_tapas.TapasTruncationStrategy = Falsemax_length: int | None = Nonepad_to_multiple_of: int | None = Nonepadding_side: str | None = Nonereturn_tensors: str | transformers.utils.generic.TensorType | None = Nonereturn_token_type_ids: bool | None = Nonereturn_attention_mask: bool | None = Nonereturn_overflowing_tokens: bool = Falsereturn_special_tokens_mask: bool = Falsereturn_offsets_mapping: bool = Falsereturn_length: bool = Falseverbose: bool = True**kwargs )

参数

  • 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, 可选, 默认值为 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），则禁用截断/填充到最大长度的功能。

    如果未设置或设置为 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, 可选) — 如果设置，将返回张量而不是 Python 整数列表。可接受的值为：
    • 'pt'：返回 PyTorch torch.Tensor 对象。
    • 'np'：返回 Numpy np.ndarray 对象。

用于对与表格相关的一个或多个序列进行分词并准备输入模型的主要方法。

convert_logits_to_predictions

< >

( datalogitslogits_agg = Nonecell_classification_threshold = 0.5 ) → tuple comprising various elements depending on the inputs

参数

  • data (dict) — 将特征映射到实际值的字典。应使用 TapasTokenizer 创建。
  • logits（形状为 (batch_size, sequence_length) 的 torch.Tensor）— 包含 token 级别 logits 的张量。
  • logits_agg（形状为 (batch_size, num_aggregation_labels) 的 torch.Tensor，可选）— 包含聚合 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 的 logits 转换为实际的预测答案坐标以及可选的聚合索引。

该函数所基于的原始实现可在此处找到。

save_vocabulary

< >

( save_directory: strfilename_prefix: str | None = None )

TapasModel

class transformers.TapasModel

< >

( config: TapasConfigadd_pooling_layer = True )

参数

  • config (TapasConfig) — 模型的配置类，包含模型的所有参数。使用配置文件进行初始化时，不会加载与模型关联的权重，仅加载配置。请查看 from_pretrained() 方法以加载模型权重。
  • add_pooling_layer (bool，可选，默认为 True) — 是否添加池化层

未添加任何特定头部的裸 Tapas 模型，直接输出原始隐藏状态。

该模型继承自 PreTrainedModel。请查阅父类文档，了解该库为所有模型实现的通用方法（例如下载或保存、调整输入嵌入大小、剪枝头等）。

该模型也是 PyTorch torch.nn.Module 的子类。 请将其作为常规的 PyTorch Module 使用，有关通用用法和行为的所有事项，请参阅 PyTorch 文档。

forward

< >

( input_ids: typing.Optional[torch.LongTensor] = Noneattention_mask: typing.Optional[torch.Tensor] = Nonetoken_type_ids: typing.Optional[torch.LongTensor] = Noneposition_ids: typing.Optional[torch.LongTensor] = Noneinputs_embeds: typing.Optional[torch.Tensor] = Noneencoder_hidden_states: typing.Optional[torch.Tensor] = Noneencoder_attention_mask: typing.Optional[torch.Tensor] = Noneoutput_attentions: bool | None = Noneoutput_hidden_states: bool | None = Nonereturn_dict: bool | None = None**kwargs ) → BaseModelOutputWithPooling or tuple(torch.Tensor)

参数

  • input_ids (torch.LongTensor 形状为 (batch_size, sequence_length), ，可选) — 输入序列中各 token 在词汇表中的索引。默认情况下，填充（padding）将被忽略。

    可以使用 AutoTokenizer 获取索引。有关详细信息，请参阅 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。

    什么是输入 ID？

  • attention_mask (torch.Tensor 形状为 (batch_size, sequence_length), ，可选) — 用于避免对填充 token 索引执行注意力机制的掩码。掩码值取自 [0, 1]:
    • 1 表示未被屏蔽的 token，
    • 对于被掩码的 token，值为 0。

    什么是注意力掩码？

  • token_type_ids (torch.LongTensor 形状为 (batch_size, sequence_length, 7), 可选) — 编码表格结构的 Token 索引。可以使用 AutoTokenizer. 获取。有关更多信息，请参阅此 类。

    什么是 token type ID？

  • position_ids (torch.LongTensor 形状为 (batch_size, sequence_length), ，可选) — 输入序列中每个 token 在位置嵌入中的位置索引。如果 reset_position_index_per_cell 的 TapasConfig 设置为 True, ，则使用相对位置嵌入。取值范围为 [0, config.max_position_embeddings - 1].

    什么是位置 ID？

  • inputs_embeds（形状为 (batch_size, sequence_length, hidden_size) 的 torch.Tensor，可选） — 可选地，您可以选择直接传入嵌入表示，而不是传入 input_ids。如果您希望对 input_ids 索引如何转换为相应向量拥有比模型内部嵌入查找矩阵更多的控制权，这将非常有用。
  • encoder_hidden_states (torch.Tensor，形状为 (batch_size, sequence_length, hidden_size)，可选) — 编码器最后一层输出的隐藏状态序列。如果模型被配置为解码器，则用于交叉注意力。
  • encoder_attention_mask (torch.Tensor 形状为 (batch_size, sequence_length), 可选) — 用于避免对编码器输入中的填充 token 索引执行注意力机制的掩码。如果模型被配置为解码器，此掩码将用于交叉注意力。掩码值取自 [0, 1]:
    • 1 表示未被屏蔽的 token，
    • 对于被掩码的 token，值为 0。
  • output_attentions (bool, 可选) — 是否返回所有注意力层的注意力张量。有关详细信息，请参阅返回张量中的 attentions。
  • output_hidden_states (bool，可选) — 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回张量中的 hidden_states。
  • return_dict (bool, 可选) — 是否返回 ModelOutput 而不是普通元组。

返回值

BaseModelOutputWithPooling 或 tuple(torch.Tensor)

一个 BaseModelOutputWithPooling 或 torch.Tensor 元组（如果传入了 return_dict=False 或 config.return_dict=False），其包含的元素取决于配置（TapasConfig）和输入。

TapasModel 的 forward 方法重写了 __call__ 特殊方法。

尽管前向传播的实现需要在此函数中定义，但之后应调用 Module 实例，而不是直接调用此函数，因为前者会负责执行预处理和后处理步骤，而后者则会静默地忽略这些步骤。

  • last_hidden_state（形状为 (batch_size, sequence_length, hidden_size) 的 torch.Tensor）— 模型最后一层输出的隐藏状态序列。

  • pooler_output (torch.Tensor，形状为 (batch_size, hidden_size)) — 序列中第一个 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 之后的权重，用于在自注意力头中计算加权平均值。

示例：

>>> 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

class transformers.TapasForMaskedLM

< >

( config: TapasConfig )

参数

  • config (TapasConfig) — 模型的配置类，包含模型的所有参数。使用配置文件进行初始化时，不会加载与模型关联的权重，仅加载配置。请查看 from_pretrained() 方法以加载模型权重。

顶部带有 language modeling 头的 Tapas 模型。”

该模型继承自 PreTrainedModel。请查阅父类文档，了解该库为所有模型实现的通用方法（例如下载或保存、调整输入嵌入大小、剪枝头等）。

该模型也是 PyTorch torch.nn.Module 的子类。 请将其作为常规的 PyTorch Module 使用，有关通用用法和行为的所有事项，请参阅 PyTorch 文档。

forward

< >

( input_ids: typing.Optional[torch.LongTensor] = Noneattention_mask: typing.Optional[torch.Tensor] = Nonetoken_type_ids: typing.Optional[torch.LongTensor] = Noneposition_ids: typing.Optional[torch.LongTensor] = Noneinputs_embeds: typing.Optional[torch.Tensor] = Noneencoder_hidden_states: typing.Optional[torch.Tensor] = Noneencoder_attention_mask: typing.Optional[torch.Tensor] = Nonelabels: typing.Optional[torch.LongTensor] = Noneoutput_attentions: bool | None = Noneoutput_hidden_states: bool | None = Nonereturn_dict: bool | None = None**kwargs ) → MaskedLMOutput or tuple(torch.Tensor)

参数

  • input_ids (torch.LongTensor 形状为 (batch_size, sequence_length), ，可选) — 输入序列中各 token 在词汇表中的索引。默认情况下，填充（padding）将被忽略。

    可以使用 AutoTokenizer 获取索引。有关详细信息，请参阅 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。

    什么是输入 ID？

  • attention_mask (torch.Tensor 形状为 (batch_size, sequence_length), ，可选) — 用于避免对填充 token 索引执行注意力机制的掩码。掩码值取自 [0, 1]:
    • 1 表示未被屏蔽的 token，
    • 对于被掩码的 token，值为 0。

    什么是注意力掩码？

  • token_type_ids (torch.LongTensor 形状为 (batch_size, sequence_length, 7), 可选) — 编码表格结构的 Token 索引。可以使用 AutoTokenizer. 获取。有关更多信息，请参阅此 类。

    什么是 token type ID？

  • position_ids (torch.LongTensor 形状为 (batch_size, sequence_length), ，可选) — 输入序列中每个 token 在位置嵌入中的位置索引。如果 reset_position_index_per_cell 的 TapasConfig 设置为 True, ，则使用相对位置嵌入。取值范围为 [0, config.max_position_embeddings - 1].

    什么是位置 ID？

  • inputs_embeds（形状为 (batch_size, sequence_length, hidden_size) 的 torch.Tensor，可选） — 可选地，您可以选择直接传入嵌入表示，而不是传入 input_ids。如果您希望对 input_ids 索引如何转换为相应向量拥有比模型内部嵌入查找矩阵更多的控制权，这将非常有用。
  • encoder_hidden_states (torch.Tensor，形状为 (batch_size, sequence_length, hidden_size)，可选) — 编码器最后一层输出的隐藏状态序列。如果模型被配置为解码器，则用于交叉注意力。
  • encoder_attention_mask (torch.Tensor 形状为 (batch_size, sequence_length), 可选) — 用于避免对编码器输入中的填充 token 索引执行注意力机制的掩码。如果模型被配置为解码器，此掩码将用于交叉注意力。掩码值取自 [0, 1]:
    • 1 表示未被屏蔽的 token，
    • 对于被掩码的 token，值为 0。
  • labels (torch.LongTensor，形状为 (batch_size, sequence_length)，可选) — 用于计算掩码语言建模损失的标签。索引应在 [-100, 0, ..., config.vocab_size] 范围内（参见 input_ids 的文档字符串）。索引设置为 -100 的 token 将被忽略（即被掩码），损失仅针对标签在 [0, ..., config.vocab_size] 范围内的 token 进行计算。
  • output_attentions (bool, 可选) — 是否返回所有注意力层的注意力张量。有关详细信息，请参阅返回张量中的 attentions。
  • output_hidden_states (bool，可选) — 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回张量中的 hidden_states。
  • return_dict (bool, 可选) — 是否返回 ModelOutput 而不是普通元组。

返回值

MaskedLMOutput 或 tuple(torch.Tensor)

一个 MaskedLMOutput 或 torch.Tensor 元组（如果传入了 return_dict=False 或 config.return_dict=False），其包含的元素取决于配置（TapasConfig）和输入。

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 之后的权重，用于在自注意力头中计算加权平均值。

示例：

>>> 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

class transformers.TapasForSequenceClassification

< >

( config: TapasConfig )

参数

  • config (TapasConfig) — 模型的配置类，包含模型的所有参数。使用配置文件进行初始化时，不会加载与模型关联的权重，仅加载配置。请查看 from_pretrained() 方法以加载模型权重。

在 Tapas 模型顶部添加一个序列分类头（即在池化输出之上添加一个线性层），例如用于表格蕴含任务，如 TabFact（Chen et al., 2020）。

该模型继承自 PreTrainedModel。请查阅父类文档，了解该库为所有模型实现的通用方法（例如下载或保存、调整输入嵌入大小、剪枝头等）。

该模型也是 PyTorch torch.nn.Module 的子类。 请将其作为常规的 PyTorch Module 使用，有关通用用法和行为的所有事项，请参阅 PyTorch 文档。

forward

< >

( input_ids: typing.Optional[torch.LongTensor] = Noneattention_mask: typing.Optional[torch.Tensor] = Nonetoken_type_ids: typing.Optional[torch.LongTensor] = Noneposition_ids: typing.Optional[torch.LongTensor] = Noneinputs_embeds: typing.Optional[torch.Tensor] = Nonelabels: typing.Optional[torch.LongTensor] = Noneoutput_attentions: bool | None = Noneoutput_hidden_states: bool | None = Nonereturn_dict: bool | None = None**kwargs ) → SequenceClassifierOutput or tuple(torch.Tensor)

参数

  • input_ids (torch.LongTensor 形状为 (batch_size, sequence_length), ，可选) — 输入序列中各 token 在词汇表中的索引。默认情况下，填充（padding）将被忽略。

    可以使用 AutoTokenizer 获取索引。有关详细信息，请参阅 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。

    什么是输入 ID？

  • attention_mask (torch.Tensor 形状为 (batch_size, sequence_length), ，可选) — 用于避免对填充 token 索引执行注意力机制的掩码。掩码值取自 [0, 1]:
    • 1 表示未被屏蔽的 token，
    • 对于被掩码的 token，值为 0。

    什么是注意力掩码？

  • token_type_ids (torch.LongTensor 形状为 (batch_size, sequence_length, 7), 可选) — 编码表格结构的 Token 索引。可以使用 AutoTokenizer. 获取。有关更多信息，请参阅此 类。

    什么是 token type ID？

  • position_ids (torch.LongTensor 形状为 (batch_size, sequence_length), ，可选) — 输入序列中每个 token 在位置嵌入中的位置索引。如果 reset_position_index_per_cell 的 TapasConfig 设置为 True, ，则使用相对位置嵌入。取值范围为 [0, config.max_position_embeddings - 1].

    什么是位置 ID？

  • inputs_embeds（形状为 (batch_size, sequence_length, hidden_size) 的 torch.Tensor，可选） — 可选地，您可以选择直接传入嵌入表示，而不是传入 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 而不是普通元组。

返回值

SequenceClassifierOutput 或 tuple(torch.Tensor)

一个 SequenceClassifierOutput 或 torch.Tensor 元组（如果传入了 return_dict=False 或 config.return_dict=False），其包含的元素取决于配置（TapasConfig）和输入。

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 之后的权重，用于在自注意力头中计算加权平均值。

示例：

>>> 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

class transformers.TapasForQuestionAnswering

< >

( config: TapasConfig )

参数

  • config (TapasConfig) — 模型的配置类，包含模型的所有参数。使用配置文件进行初始化时，不会加载与模型关联的权重，仅加载配置。请查看 from_pretrained() 方法以加载模型权重。

Tapas 模型，顶部带有单元格选择头以及可选的聚合头，用于表格上的问答任务（在隐藏状态输出之上添加线性层以计算 logits 和可选的 logits_aggregation），例如用于 SQA、WTQ 或 WikiSQL 监督任务。

该模型继承自 PreTrainedModel。请查阅父类文档，了解该库为所有模型实现的通用方法（例如下载或保存、调整输入嵌入大小、剪枝头等）。

该模型也是 PyTorch torch.nn.Module 的子类。 请将其作为常规的 PyTorch Module 使用，有关通用用法和行为的所有事项，请参阅 PyTorch 文档。

forward

< >

( input_ids: typing.Optional[torch.LongTensor] = Noneattention_mask: typing.Optional[torch.Tensor] = Nonetoken_type_ids: typing.Optional[torch.LongTensor] = Noneposition_ids: typing.Optional[torch.LongTensor] = Noneinputs_embeds: typing.Optional[torch.Tensor] = Nonetable_mask: typing.Optional[torch.LongTensor] = Nonelabels: typing.Optional[torch.LongTensor] = Noneaggregation_labels: typing.Optional[torch.LongTensor] = Nonefloat_answer: typing.Optional[torch.Tensor] = Nonenumeric_values: typing.Optional[torch.Tensor] = Nonenumeric_values_scale: typing.Optional[torch.Tensor] = Noneoutput_attentions: bool | None = Noneoutput_hidden_states: bool | None = Nonereturn_dict: bool | None = None**kwargs ) → TableQuestionAnsweringOutput or tuple(torch.Tensor)

参数

  • input_ids (torch.LongTensor 形状为 (batch_size, sequence_length), ，可选) — 输入序列中各 token 在词汇表中的索引。默认情况下，填充（padding）将被忽略。

    可以使用 AutoTokenizer 获取索引。有关详细信息，请参阅 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。

    什么是输入 ID？

  • attention_mask (torch.Tensor 形状为 (batch_size, sequence_length), ，可选) — 用于避免对填充 token 索引执行注意力机制的掩码。掩码值取自 [0, 1]:
    • 1 表示未被屏蔽的 token，
    • 对于被掩码的 token，值为 0。

    什么是注意力掩码？

  • token_type_ids (torch.LongTensor 形状为 (batch_size, sequence_length, 7), 可选) — 编码表格结构的 Token 索引。可以使用 AutoTokenizer. 获取。有关更多信息，请参阅此 类。

    什么是 token type ID？

  • position_ids (torch.LongTensor 形状为 (batch_size, sequence_length), ，可选) — 输入序列中每个 token 在位置嵌入中的位置索引。如果 reset_position_index_per_cell 的 TapasConfig 设置为 True, ，则使用相对位置嵌入。取值范围为 [0, config.max_position_embeddings - 1].

    什么是位置 ID？

  • inputs_embeds（形状为 (batch_size, sequence_length, hidden_size) 的 torch.Tensor，可选） — 可选地，您可以选择直接传入嵌入表示，而不是传入 input_ids。如果您希望对 input_ids 索引如何转换为相应向量拥有比模型内部嵌入查找矩阵更多的控制权，这将非常有用。
  • table_mask（形状为 (batch_size, seq_length) 的 torch.LongTensor，可选） — 表格的掩码。指示哪些 token 属于表格（1）。问题 token、表头和填充均为 0。
  • labels (torch.LongTensor 形状为 (batch_size, seq_length), ，可选) — 用于计算分层单元格选择损失的每个 token 的标签。这编码了答案在表格中出现的位置。可以使用 AutoTokenizer.
    • 1 表示该 token 属于答案的一部分，
    • 对于不属于答案的 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 获取。仅在聚合的弱监督（WTQ）情况下需要，用于计算回归损失。
  • numeric_values_scale（形状为 (batch_size, seq_length) 的 torch.Tensor，可选） — 每个 token 的数值值的缩放比例。可通过 AutoTokenizer 获取。仅在聚合的弱监督（WTQ）情况下需要，用于计算回归损失。
  • output_attentions (bool, 可选) — 是否返回所有注意力层的注意力张量。有关详细信息，请参阅返回张量中的 attentions。
  • output_hidden_states (bool，可选) — 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回张量中的 hidden_states。
  • return_dict (bool, 可选) — 是否返回 ModelOutput 而不是普通元组。

返回值

TableQuestionAnsweringOutput 或 tuple(torch.Tensor)

一个 TableQuestionAnsweringOutput 或 torch.Tensor 元组（如果传入了 return_dict=False 或 config.return_dict=False），其包含的元素取决于配置（TapasConfig）和输入。

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 之后的权重，用于在自注意力头中计算加权平均值。

示例：

>>> 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
Update on GitHub

←语音编码器-解码器模型 TIPSv2→