Transformers文档

tapas

Hugging Face's logo
加入Hugging Face社区

并获取增强文档体验

开始使用

TAPAS

概览

TAPAS模型由Jonathan Herzig、Paweł Krzysztof Nowak、Thomas Müller、Francesco Piccinno和Julian Martin Eisenschlos在《TAPAS:弱监督表格解析通过预训练》中提出,见https://www.aclweb.org/anthology/2020.acl-main.398。这是一个基于BERT的模型,专门设计(和预训练)用于回答关于表格数据的问题。与BERT相比,TAPAS使用相对位置嵌入,有7种标记类型,用于编码表格结构。TAPAS在大数据集上进行了预训练,该数据集包含来自英语维基百科的数百万个表格和相应的文本,训练目标是掩码语言建模(MLM)。

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

  • SQA(微软的顺序问答)
  • WTQ(斯坦福大学的Wiki表格问答)
  • WikiSQL(由Salesforce提供)。

它在SQA和WTQ上都实现了最先进的性能,在WikiSQL上也具有与SOTA相当的性能,但架构更为简单。

论文的摘要如下:

在表格上回答自然语言问题通常被视为一个语义解析任务。为了减少获取完整逻辑形式的成本,一种流行的方法专注于由指称而非逻辑形式组成的弱监督。然而,从弱监督中训练语义解析器具有困难,而且生成的逻辑形式仅作为检索指称之前的一个中间步骤。在本文中,我们提出了TAPAS,一种无需生成逻辑形式的表格问答方法。TAPAS从弱监督中学习,通过选择表格单元格并可选地应用相应的聚合运算符来预测指称。TAPAS扩展了BERT的架构以对表格进行编码作为输入,从来自维基百科的文本片段和表格的有效联合预训练中初始化,并从头到尾进行训练。我们实验了三个不同的语义解析数据集,发现TAPAS在SQA上的准确率从55.1提高到了67.2,在WIKISQL和WIKITQ上与最先进的方法相当,但模型架构更为简单。此外,我们发现从WIKISQL迁移到WIKITQ的迁移学习效果显著,准确率达到了48.7,领先于最先进的方法4.2个百分点。

此外,作者还进一步微调了TAPAS以识别<强>表格蕴涵,通过创建数百万个自动生成的训练示例数据集,这些示例在微调之前的中间步骤中学习。TAPAS的作者将这种进一步预训练称为中间预训练(因为TAPAS首先在MLM上预训练,然后在另一个数据集上预训练)。他们发现中间预训练进一步提高了SQA的性能,实现了新的最先进成果,在获得了访问量大的数据集TabFact(一个包含16k维基百科表格的大型数据集,用于表格蕴涵,是一个二分类任务)上也达到了最先进水平。更多细节请参考他们的后续论文:Julian Martin Eisenschlos,Syrine Krichene和Thomas Müller发表的Understanding tables with intermediate pre-training

drawing TAPAS架构。来自原始博客文章

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

使用技巧

  • TAPAS 是一个默认使用相对位置嵌入的模型(在每个表格单元上重新启动位置嵌入)。请注意,这是在原始 TAPAS 论文发表后添加的功能。根据作者的说法,这通常会导致性能略有提升,并允许你编码更长的序列而不会耗尽嵌入。这反映在 reset_position_index_per_cell 参数中,该参数在 TapasConfig 中设置为 True。在 hub 上可用的所有模型默认都使用相对位置嵌入。你还可以通过在调用 from_pretrained() 方法时传递额外参数 revision="no_reset" 使用带有绝对位置嵌入的模型。请注意,通常建议将输入在右边填充而非左边。
  • TAPAS 基于伯特,例如 TAPAS-base 对应于 BERT-base 架构。当然,TAPAS-large 将带来最佳性能(论文中报告的结果来自 TAPAS-large)。不同尺寸模型的性能在 原始 GitHub 存储库 中显示。
  • Tapas 在 SQA 上进行了微调,可以回答有关表格的对话设置中的问题。这意味着你可以提出与先前问题相关的问题,例如“他是多大年纪?”请注意,在对话设置中,TAPAS 的前向传递略有不同:在这种情况下,你必须逐个将每个表-问题对输入到模型中,以便将 prev_labels 标记类型 ID 覆写为前一个问题的模型预测的 labels。关于更多信息,请参考“使用”部分。
  • Tapas 与伯特类似,因此依赖于掩码语言建模(MLM)目标。因此,它在预测掩码标记和总体 NLU 方面上很有效,但不适用于文本生成。具有因果语言建模(CLM)目标的训练模型在此方面表现更好。请注意,Tapas 可以作为编码器在 EncoderDecoderModel 框架中用于,并结合自动回归文本解码器,如 GPT-2。

使用:微调

以下是关于如何在您的数据集上微调TapasForQuestionAnswering的详细说明。

步骤1:选择以下3种使用TAPAS的方式之一,或者进行实验

基本上,存在3种微调TapasForQuestionAnswering的不同方法,这对应于Tapas上微调的不同数据集

  1. SQA:如果您对在一个对话设置中提出与表格相关的后续问题感兴趣。例如,如果首先问“第一个演员的名字是什么?”然后您可以提出一个后续问题,例如“他多大了?”。在这里,问题不涉及任何聚合(所有问题都是单元格选择问题)。
  2. WTQ:如果您对在对话设置中提问不感兴趣,而是只想提出有关表格的问题,这些问题可能涉及聚合,例如计算行数、单元格值的总和或平均值。例如,您可以问“C罗在其职业生涯中总共进了多少球?”。这种情况也称为弱监督,因为模型本身必须根据仅有的答案学习适当的聚合操作符(SUM/COUNT/AVERAGE/NONE)。
  3. WikiSQL监督:这个数据集基于WikiSQL,模型在训练期间被赋予了地面真理聚合操作符。这也称为强监督。在这里,学习适当的聚合操作符要容易得多。

总结

任务 示例数据集 描述
对话 SQA 对话,只有单元格选择问题
聚合的弱监督 WTQ 问题可能涉及聚合,模型必须根据仅有的答案作为监督学习这一点
聚合的强监督 WikiSQL监督 问题可能涉及聚合,模型必须根据黄金聚合操作符学习这一点
Pytorch
隐藏Pytorch内容

如下所示,可以通过使用从hub预先训练的基础模型和随机初始化的分类头来初始化模型。

>>> from transformers import TapasConfig, TapasForQuestionAnswering

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

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

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

当然,您不一定必须遵循TAPAS微调的这三种方法之一。您也可以在初始化TapasConfig时定义任何想要的超参数,然后创建一个基于该配置的TapasForQuestionAnswering。例如,如果您有一个同时包含对话问题和可能涉及聚合的问题的数据集,则可以这样做。以下是一个示例

>>> from transformers import TapasConfig, TapasForQuestionAnswering

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

如下所示,可以通过使用从hub预先训练的基础模型和随机初始化的分类头来初始化模型。请确保已安装tensorflow_probability依赖关系

>>> from transformers import TapasConfig, TFTapasForQuestionAnswering

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

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

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

当然,您不一定必须遵循TAPAS微调的这三种方法之一。您也可以在初始化TapasConfig时定义任何想要的超参数,然后创建一个基于该配置的TFTapasForQuestionAnswering。例如,如果您有一个同时包含对话问题和可能涉及聚合的问题的数据集,则可以这样做。以下是一个示例

>>> from transformers import TapasConfig, TFTapasForQuestionAnswering

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

您还可以从已经微调好的检查点开始。需要注意的是,WTQ上预先微调好的检查点有一些由于L2损失而较为脆弱的问题。有关更多信息,请参见此处

有关HuggingFace的hub上可用的所有预训练和微调好的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_text填充answer_coordinatesfloat_answer字段),这意味着WTQ和WikiSQL的结果实际上可以更好地改进。

步骤3:使用TapasTokenizer将您的数据转换为张量

Pytorch
隐藏Pytorch内容

第三,鉴于您已将数据准备好为这种TSV/CSV格式(以及相应的包含表格数据的CSV文件),您可以使用TapasTokenizer将表格-问题对转换为input_idsattention_masktoken_type_ids等。同样,根据您上述选择的三个案例之一,TapasForQuestionAnswering需要不同的输入来进行微调

任务 所需输入
对话 input_idsattention_masktoken_type_idslabels
聚合的弱监督 input_idsattention_masktoken_type_idslabelsnumeric_valuesnumeric_values_scalefloat_answer
聚合的强监督 input_idsattention_masktoken_type_idslabelsaggregation_labels

TapasTokenizer根据TSV文件的answer_coordinatesanswer_text列创建labelsnumeric_valuesnumeric_values_scale。此处的float_answeraggregation_labels已经在第2步的TSV文件中。以下是一个例子

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

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

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

请注意,TapasTokenizer期望表格数据为纯文本。您可以使用.astype(str)对DataFrame执行操作,将其转换为纯文本数据。当然,这里仅展示了如何编码单个训练示例。建议创建数据加载器迭代批处理。

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

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


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

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

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


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

第三,鉴于您已经使用TSV/CSV格式(以及包含表格数据的相应CSV文件)准备好您的数据,您可以使用TapasTokenizer将表格-问题对转换为input_idsattention_masktoken_type_ids等。再次强调,根据您在上面选择的三种情况之一,TFTapasForQuestionAnswering需要不同的输入来进行微调。

任务 所需输入
对话 input_idsattention_masktoken_type_idslabels
聚合的弱监督 input_idsattention_masktoken_type_idslabelsnumeric_valuesnumeric_values_scalefloat_answer
聚合的强监督 input_idsattention_masktoken_type_idslabelsaggregation_labels

TapasTokenizer根据TSV文件的answer_coordinatesanswer_text列创建labelsnumeric_valuesnumeric_values_scale。此处的float_answeraggregation_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="tf",
... )
>>> inputs
{'input_ids': tensor([[ ... ]]), 'attention_mask': tensor([[...]]), 'token_type_ids': tensor([[[...]]]),
'numeric_values': tensor([[ ... ]]), 'numeric_values_scale: tensor([[ ... ]]), labels: tensor([[ ... ]])}

请注意,TapasTokenizer期望表格数据为纯文本。您可以使用.astype(str)对DataFrame执行操作,将其转换为纯文本数据。当然,这里仅展示了如何编码单个训练示例。建议创建数据加载器迭代批处理。

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

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


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

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

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


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

请注意,在这里,我们独立对每个表格-问题对进行编码。只要您的数据集不是**对话性的**,这才可以接受。如果您的数据集涉及对话性问题(例如SQA),在编码之前,您应该按照其position索引顺序将每个表格的queriesanswer_coordinatesanswer_text分组在一起,并以批处理方式对每个表格及其问题进行编码。这将确保prev_labels标记类型(参见TapasTokenizer文档)设置正确。有关更多信息,请参阅此notebook。有关使用TensorFlow模型的更多信息,请参阅此notebook

**第四步:训练(微调)模型

Pytorch
隐藏Pytorch内容

您可以使用以下方法微调TapasForQuestionAnswering(以下为聚合情况下的弱监督示例)

>>> from transformers import TapasConfig, TapasForQuestionAnswering, AdamW

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

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

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

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

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

您可以使用以下方法微调TFTapasForQuestionAnswering(以下为聚合情况下的弱监督示例)

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

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

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

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

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

用法:推理

Pytorch
隐藏Pytorch内容

在这里,我们解释如何使用TapasForQuestionAnsweringTFTapasForQuestionAnswering进行推理(即在新的数据上做出预测)。对于推理,只需向模型提供以下内容:input_idsattention_masktoken_type_ids(您可以使用TapasTokenizer获取),即可获得logits。然后,您可以使用强大的~models.tapas.tokenization_tapas.convert_logits_to_predictions方法将这些转换为预测坐标和可选的聚合索引。

请注意,根据设置是否对话性,推理方法可能有所不同。在非对话设置中,可以在批处理中的所有表格-问题对上并行进行推理。以下是一个示例

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

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

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

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

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

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

在这里,我们解释如何使用TFTapasForQuestionAnswering进行推理(即在新的数据上做出预测)。对于推理,只需向模型提供以下内容:input_idsattention_masktoken_type_ids(您可以使用TapasTokenizer获取),即可获得logits。然后,您可以使用强大的~models.tapas.tokenization_tapas.convert_logits_to_predictions方法将这些转换为预测坐标和可选的聚合索引。

请注意,根据设置是否对话性,推理方法可能有所不同。在非对话设置中,可以在批处理中的所有表格-问题对上并行进行推理。以下是一个示例

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

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

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

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

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

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

在会话设置的情况下,必须按顺序将每个表格-问题对提供给模型,这样之前的 tokenize 标记类型就可以被前一个表格-问题对的预测 labels 覆盖。有关更多信息,请参阅下面的笔记本(PyTorch版):这个笔记本 和 TensorFlow 版本的笔记本:这个笔记本

资源

TAPAS 特定输出

transformers.models.tapas.modeling_tapas.TableQuestionAnsweringOutput

< >

( loss: 可选 = None logits: FloatTensor = None logits_aggregation: FloatTensor = None hidden_states: 可选 = None attentions: 可选 = None )

参数

  • loss (torch.FloatTensor of shape (1,), 可选,在提供 labels(以及可能的 answeraggregation_labelsnumeric_valuesnumeric_values_scale)时返回) — 总损失为分层单元选择对数似然损失的和(可选)半监督回归损失(可选)和(可选)聚集监督损失。
  • logits (torch.FloatTensor of shape (batch_size, sequence_length)) — 单元选择头部的预测分数,针对每个标记。
  • logits_aggregation (torch.FloatTensor, 可选, 形状为 (batch_size, num_aggregation_labels)) — 对于每个聚合操作,聚合头的预测得分。
  • hidden_states (tuple(torch.FloatTensor), 可选, 当传递output_hidden_states=True 或配置中config.output_hidden_states=True 时返回) — 包含所有层输出的torch.FloatTensor 的元组(一个用于嵌入输出 + 一个用于每一层的输出),形状为 (batch_size, sequence_length, hidden_size)。模型在每个层的隐藏状态以及初始嵌入输出的隐藏状态。
  • attentions (tuple(torch.FloatTensor), 可选, 当传递 output_attentions=True 或配置中 config.output_attentions=True 时返回) — 包含每个层注意力的 torch.FloatTensor 的元组,形状为 (batch_size, num_heads, sequence_length, sequence_length)。用于在自注意力头中进行加权平均的注意力 softmax 后的注意力权重。

TapasForQuestionAnswering 的输出类型。

TapasConfig

transformers.TapasConfig

< >

( vocab_size = 30522 hidden_size = 768 num_hidden_layers = 12 num_attention_heads = 12 intermediate_size = 3072 hidden_act = 'gelu' hidden_dropout_prob = 0.1 attention_probs_dropout_prob = 0.1 max_position_embeddings = 1024 type_vocab_sizes = [3, 256, 256, 2, 256, 256, 10] initializer_range = 0.02 layer_norm_eps = 1e-12 pad_token_id = 0 positive_label_weight = 10.0 num_aggregation_labels = 0 aggregation_loss_weight = 1.0 use_answer_as_supervision = None answer_loss_importance = 1.0 use_normalized_answer_loss = False huber_loss_delta = None temperature = 1.0 aggregation_temperature = 1.0 use_gumbel_for_cells = False use_gumbel_for_aggregation = False average_approximation_function = 'ratio' cell_selection_preference = None answer_loss_cutoff = None max_num_rows = 64 max_num_columns = 32 average_logits_per_cell = False select_one_column = True allow_empty_column_selection = False init_cell_selection_weights_to_zero = False reset_position_index_per_cell = True disable_per_token_loss = False aggregation_labels = None no_aggregation_label_index = None **kwargs )

参数

  • vocab_size (int, 可选, 默认为 30522) — TAPAS 模型的词汇量。定义了在调用 TapasModelinputs_ids 可以表示的不同标记的数量。
  • hidden_size (int, 可选, 默认为 768) — 编码器层和池化层的维度。
  • num_hidden_layers (int, 可选, 默认为12) — Transformer编码器中的隐藏层数量。
  • num_attention_heads (int, 可选, 默认为12) — Transformer编码器中每个注意层中的注意力头数量。
  • intermediate_size (int, 可选, 默认为3072) — Transformer编码器中“中间层”(常称为前馈层)的维度。
  • hidden_act (strCallable, 可选, 默认为 "gelu") — 编码器和池化器中的非线性激活函数(函数或字符串)。如果是字符串,支持 "gelu""relu""swish""gelu_new"
  • hidden_dropout_prob (float, 可选, 默认值为0.1) — 在嵌入层、编码器池化层的所有全连接层中的dropout概率。
  • attention_probs_dropout_prob (float, 可选, 默认值为0.1) — 注意力概率的dropout比例。
  • max_position_embeddings (int, 可选, 默认值为1024) — 模型可能使用的最大序列长度。通常设置为较大的值以防万一(例如,512、1024或2048)。
  • type_vocab_sizesList[int]可选,默认为[3, 256, 256, 2, 256, 256, 10]) — 调用 TapasModel 时传入的 token_type_ids 的词汇量大小。
  • initializer_rangefloat可选,默认为0.02) — 所有权重矩阵初始化时使用的截断正态分布初值的标准差。
  • layer_norm_epsfloat可选,默认为1e-12) — 层归一化层使用的epsilon值。
  • positive_label_weightfloat可选,默认为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布尔型可选,默认值为 False) — 是否通过预测值和期望值中的最大值规范化答案损失。
  • huber_loss_delta浮点型可选) — 用于计算回归损失的 Delta 参数。
  • temperature浮点型可选,默认值为 1.0) — 用于控制(或改变)细胞对数概率偏斜的值。
  • aggregation_temperature浮点型可选,默认值为 1.0) — 放大集合对数,以控制概率偏斜。
  • 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_preferencefloat可选)— 在模糊情况下的单元格选择优先级。仅适用于聚合(WTQ,WikiSQL)的弱监督情况。如果聚合概率的总质量(排除“NONE”运算符)高于此超参数,则对示例进行聚合预测。
  • answer_loss_cutofffloat可选)— 忽略答案损失大于截止值的示例。
  • max_num_rowsint可选,默认为64)— 最大行数。
  • max_num_columnsint可选,默认为 32)—— 最大列数。
  • average_logits_per_cellbool可选,默认为 False)—— 是否对每个单元的平均 logarithm 进行取平均值。
  • select_one_columnbool可选,默认为 True)—— 是否限制模型只从单个列选择单元格。
  • allow_empty_column_selectionbool可选,默认为 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, 可选) — 如果已定义汇总标签,并且其中一个标签代表“不汇总”,则应将其设置为索引。例如,WTQ 模型的“NONE”汇总标签设置为索引 0,因此对于这些模型应将值设置为 0。

这是存储TapasModel配置的配置类。它用于根据指定的参数实例化 TAPAS 模型,并定义模型架构。使用默认值实例化配置将产生类似于 TAPAS google/tapas-base-finetuned-sqa 架构的配置。

配置对象继承自 PreTrainedConfig 并且可以用来控制模型输出。请阅读PretrainedConfig文档以了解更多信息。

BERT 之外的超参数来自原始实现中的 run_task_main.pyhparam_utils.py。原始实现可在https://github.com/google-research/tapas/tree/master找到。

示例

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

< >

( 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 max_row_id: int = 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: Optional = None **kwargs )

参数

  • vocab_file (str) — 包含词汇的文件。
  • do_lower_case (bool, 可选, 默认为 True) — 是否在分词时将输入转换为小写。
  • do_basic_tokenize (bool, 可选, 默认为 True) — 是否在WordPiece之前执行基本分词。
  • never_split (集合, 可选) — 在分词过程中永远不会被分割的标记集合。仅在 do_basic_tokenize=True 时有效。
  • unk_token (str, 可选, 默认为 "[UNK]") — 未知标记。不在词汇表中的标记不能转换成ID,而是设置为此标记。
  • sep_token (str, 可选, 默认为 "[SEP]") — 分隔标记,用于将多个序列(例如,用于序列分类的两个序列或用于问答的文本和问题)构建成一个序列。它也用作由特殊标记构建的序列的最后一个标记。
  • pad_token (str, 可选, 默认为 "[PAD]") — 填充标记,例如在填充不同长度的序列时使用。
  • cls_token (str, 可选, 默认为"[CLS]") — 在进行序列分类(对整个序列进行分类而不是按词分类)时使用的分类器标记。在与特殊标记构建时,它是序列的第一个标记。
  • mask_token (str, 可选, 默认为"[MASK]") — 用于掩码值的标记。这是在用掩码语言模型训练此模型时使用的标记。这是模型将尝试预测的标记。
  • empty_token (str, 可选, 默认为"[EMPTY]") — 用于表格中空单元格值的标记。空单元格值包括 "", “n/a”, “nan” 和 ”?“。
  • tokenize_chinese_chars (bool, 可选, 默认为 True) — 是否进行中文字符分词。对于日语,可能需要将该选项禁用(参见此 问题)。
  • 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, 可选) — 每个问题的最小长度,以标记为单位(否则将跳过)。
  • max_question_length (int, 可选) — 每个问题的最大长度,以标记为单位(否则将跳过)。

构建一个TAPAS分词器。基于WordPiece。将表格和一个或多个相关句子平坦化,供TAPAS模型使用。

此分词器继承自PreTrainedTokenizer,其中包含大多数主要方法。用户应参考这个超类来获取更多关于这些方法的信息。《TapasTokenizer》创建了几个标记类型ID来编码表格结构。更精确地说,它添加了7个标记类型ID,按以下顺序:segment_idscolumn_idsrow_idsprev_labelscolumn_ranksinv_column_ranksnumeric_relations

  • segment_ids:指示一个标记是否属于问题(0)或表格(1)。对于特殊标记和填充为0。
  • column_ids:指示一个标记属于表格的哪一列(从1开始)。对于所有问题标记、特殊标记和填充为0。
  • row_ids:指示一个标记属于表格的哪一行(从1开始)。对于所有问题标记、特殊标记和填充为0。列标题的标记也是0。
  • prev_labels:指示一个标记是否是前一个问题(部分)的答案(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 对表及相关句子进行端到端的标记化:标点分割和词元分解。

__call__

< >

( table: pd.DataFrame queries: 联合 = None answer_coordinates: 联合 = None answer_text: 联合 = None add_special_tokens: 布尔 = True padding: 联合 = False truncation: 联合 = False max_length: 可选 = None pad_to_multiple_of: 可选 = None return_tensors: 联合 = None return_token_type_ids: 可选 = None return_attention_mask: 可选 = None return_overflowing_tokens: 布尔 = False return_special_tokens_mask: 布尔 = False return_offsets_mapping: 布尔 = False return_length: 布尔 = False verbose: 布尔 = True **kwargs )

参数

  • table (pd.DataFrame) — 包含表格数据的表格。注意,所有单元格值都必须是文本。在使用 Pandas dataframe 时,使用 .astype(str) 将其转换为字符串。
  • queries (strList[str]) — 与表格相关的待编码的问题或问题批处理。注意,在批处理中,所有问题都必须与同一张表格相关。
  • answer_coordinates (List[Tuple]List[List[Tuple]], 可选) — 批处理中每个表格-问题对的答案坐标。在仅提供一个表格-问题对的情况下,answer_coordinates 必须是一个包含一个或多个元组的单一列表。每个元组必须是一个 (row_index, column_index) 对。第一行数据(不是列标题行)的索引为 0。第一列的索引为 0。在提供表格-问题对批处理的情况下,answer_coordinates 必须是一个包含元组列表的列表(每个列表对应单个表格-问题对)。
  • answer_text (List[str] or List[List[str]], 可选) — 批量中每个表格-问题对的答案文本。如果只提供了一个表格-问题对,则answer_text必须是一个包含一个或多个字符串的单个列表。每个字符串必须是相应答案坐标的答案文本。如果提供了一组表格-问题对,则answer_coordinates必须是一个字符串列表的列表(每个列表对应单个表格-问题对)。
  • add_special_tokens (bool, 可选,默认为True)— 是否将序列编码为相对于模型的特殊标记。
  • padding (boolstrPaddingStrategy可选,默认为False) — 激活并控制填充。接受以下值:

  • 截断 (bool, strTapasTruncationStrategy, 可选,默认为 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 或词分类很有用。
  • pad_to_multiple_of (int, 可选) — 如果设置,将序列填充到提供值的倍数。这在启用具有计算能力 >= 7.5 的 NVIDIA 硬件上的 Tensor Cores(Volta)特别有用。
  • return_tensors (strTensorType, 可选) — 如果设置,将返回张量而不是 python 整数列表。可接受的值有:

主方法用于对与表格相关的序列进行分词和准备。

convert_logits_to_predictions

< >

( data logits logits_agg = None cell_classification_threshold = 0.5 ) tuple comprising various elements depending on the inputs

参数

  • data (dict) — 将特征映射到实际值。应使用 TapasTokenizer 创建。
  • logits (torch.Tensortf.Tensor 形状 (batch_size, sequence_length)) — 包含 token 级别 logits 的 Tensor。
  • logits_agg (torch.Tensortf.Tensor 形状为 (batch_size, num_aggregation_labels),可选) — 包含聚合logits的Tensor。
  • cell_classification_threshold (float,可选,默认为0.5) — 用于单元格选择的阈值。所有概率大于此阈值的表格单元格将被选中。

返回值

包含多种元素的元组,具体取决于输入内容

  • predicted_answer_coordinates (List[List[[tuple]] 的长度为 batch_size):预测的答案坐标,表示为列表的列表的元组。列表中的每个元素包含批处理中单个示例的预测答案坐标,为数组的列表。每个元组表示一个单元格,即(行索引,列索引)。
  • predicted_aggregation_indices (List[int] 的长度为 batch_size,可选,当提供 logits_aggregation 时返回):聚合头的预测聚合操作索引。

TapasForQuestionAnswering 的logits转换为实际预测答案坐标和可选的聚合索标准。

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

save_vocabulary

< >

( save_directory: str filename_prefix: Optional = None )

Pytorch
隐藏Pytorch内容

TapasModel

transformers.TapasModel

< >

( config add_pooling_layer = True )

参数

  • config (TapasConfig) — 包含模型所有参数的模型配置类。使用配置文件初始化时不加载模型相关的权重,只有配置。检查 from_pretrained() 方法来加载模型权重。

一个裸 Tapas 模型变压器,输出原始隐藏状态,没有顶部具体头部的。此模型继承自 PreTrainedModel。有关库为所有模型实现的后备方法(如下载或保存、调整输入嵌入、剪枝头部等)的文档,请检查超类文档。

此模型也是 PyTorch torch.nn.Module 的子类。将其用作常规 PyTorch 模块,并参考 PyTorch 文档了解所有与一般使用和行为相关的事项。

BertModel 相比,此类仅进行了微小改动,考虑了额外的标记类型ID。

该模型可以作为编码器(只有自注意力)以及解码器进行操作,在这种情况下,在自注意力层之间添加了一个交叉注意力层,该方法遵循 Ashish Vaswani、Noam Shazeer、Niki Parmar、Jakob Uszkoreit、Llion Jones、Aidan N. Gomez、Lukasz Kaiser 和 Illia Polosukhin 在 Attention is all you need 中的体系结构描述。

forward

< >

( input_ids: 可选 = None attention_mask: 可选 = None token_type_ids: 可选 = None position_ids: 可选 = None head_mask: 可选 = None inputs_embeds: 可选 = None encoder_hidden_states: 可选 = None encoder_attention_mask: 可选 = None output_attentions: 可选 = None output_hidden_states: 可选 = None return_dict: 可选 = None ) transformers.modeling_outputs.BaseModelOutputWithPoolingtuple(torch.FloatTensor)

参数

  • input_ids (torch.LongTensor 形状 (batch_size, sequence_length)) — 词汇表中的输入序列标记的索引。索引可以通过 AutoTokenizer 获取。有关详情,请参阅 PreTrainedTokenizer.encode()PreTrainedTokenizer.call()

  • attention_mask (torch.FloatTensor of shape (batch_size, sequence_length), 可选) — 避免在填充标记索引上执行注意力的掩码。掩码值在 [0, 1] 之间选择:

    • 1 代表未掩码的标记;
    • 0 代表掩码的标记。

    什么是注意力掩码?

  • token_type_ids (torch.LongTensor of shape (batch_size, sequence_length, 7), 可选) — 编码表格结构的标记索引。可以使用 AutoTokenizer 获取索引。更多信息请参阅该类。

    什么是标记类型ID?

  • position_ids (torch.LongTensor of shape (batch_size, sequence_length), 可选) — 每个输入序列标记在位置嵌入中的位置索引。如果 TapasConfigreset_position_index_per_cell 设置为 True,将使用相对位置嵌入。选择范围在 [0, config.max_position_embeddings - 1] 内。

    什么是位置ID?

  • head_mask(《torch.FloatTensor》形状为(num_heads,)(num_layers, num_heads)可选)— 用于取消自我注意模块选中头的屏蔽。屏蔽值选择在[0, 1]:- 1 表示头没有被屏蔽,- 0 表示头已经被屏蔽
  • inputs_embeds(《torch.FloatTensor》形状为(batch_size, sequence_length, hidden_size)可选)— 可选地,不通过传递input_ids,您可以选择直接传递嵌入表示。如果您想要对将输入Id索引转换为相关向量的方式有更多控制,这很有用,而不是模型内部的嵌入查找矩阵。
  • output_attentions(《bool》类型,可选)— 是否返回所有注意力层的注意力张量。有关返回张量中“attentions”的更多详情,请参阅。
  • output_hidden_states (bool, 可选) — 决定是否返回所有层的隐藏状态。更多细节请参阅返回张量下的 hidden_states
  • return_dict (bool, 可选) — 决定是否返回 ModelOutput 对象而不是普通的元组。

返回值

transformers.modeling_outputs.BaseModelOutputWithPoolingtuple(torch.FloatTensor)

A transformers.modeling_outputs.BaseModelOutputWithPooling 或一个包含 torch.FloatTensor 的元组(如果传递了 return_dict=False 或当 config.return_dict=False 时),它包含根据配置(TapasConfig)和输入的各种元素。

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

  • pooler_output (torch.FloatTensor 形状为 (batch_size, hidden_size)) — 经过用于辅助预训练任务层进一步处理后,序列中第一个令牌(分类令牌)的最后一层隐藏状态。例如,对于 BERT 系列模型,这返回分类令牌经过线性层和 tanh 激活函数处理后的输出。线性层的权重在预训练期间从下一个句子预测(分类)目标中训练。

  • hidden_states (tuple(torch.FloatTensor), 可选,在传递 output_hidden_states=True 时返回,或当 config.output_hidden_states=True 时返回) — 一个为嵌入层的输出(如果模型有嵌入层,+ 一个为每层的输出)的 torch.FloatTensor 的元组,形状为 (batch_size, sequence_length, hidden_size)

    在每个层的输出处以及可选的初始嵌入输出处的模型隐藏状态。

  • attentions (tuple(torch.FloatTensor), 可选,在传递 output_attentions=True 时返回,或当 config.output_attentions=True 时返回) — 一个 torch.FloatTensor 的元组(每个层一个),形状为 (batch_size, num_heads, sequence_length, sequence_length)

    注意力软化的权重之后,用于在自注意力头中进行加权的平均值。

TapasModel 的前进方法重写了 __call__ 特别方法。

尽管需要在函数内定义前向传递的配方,但是应该调用 Module 实例,而不是这个,因为前者负责运行预和后处理步骤,而后者会默默地忽略这些步骤。

示例

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

参数

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

在顶部有一个 语言建模 首部的 Tapas 模型。此模型继承自 PreTrainedModel。请查看超类文档,了解库为所有模型实现的一般方法(如下载或保存,调整输入嵌入的大小,剪枝头部等)。

此模型也是 PyTorch torch.nn.Module 的子类。将其用作常规 PyTorch 模块,并参考 PyTorch 文档了解所有与一般使用和行为相关的事项。

forward

< >

( input_ids: Optional = None attention_mask: Optional = None token_type_ids: Optional = None position_ids: Optional = None head_mask: Optional = None inputs_embeds: Optional = None encoder_hidden_states: Optional = None encoder_attention_mask: Optional = None labels: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None **kwargs ) transformers.modeling_outputs.MaskedLMOutput or tuple(torch.FloatTensor)

参数

  • input_ids (torch.LongTensor 形状为 (batch_size, sequence_length)) —— 在词汇表中的输入序列标记索引。索引可以通过使用 AutoTokenizer 获取。有关详细信息,请参阅 PreTrainedTokenizer.encode()PreTrainedTokenizer.call()

    什么是输入 ID?

  • attention_mask (torch.FloatTensor 形状为 (batch_size, sequence_length),可选) —— 用于防止在填充标记索引上执行注意力的掩码。掩码值为 [0, 1]:

    • 1 对于 未掩码 的标记,
    • 0 对于 已掩码 的标记。

    什么是注意力掩码?

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

    什么是标记类型 ID?

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

    什么是位置ID?

  • head_mask (torch.FloatTensor of shape (num_heads,) or (num_layers, num_heads), 可选) — 用于取消选中自注意力模块选中头部的掩码。掩码值选择范围为[0, 1]:- 1表示头部没有被掩码,- 0表示头部被掩码。
  • inputs_embeds (torch.FloatTensor of shape (batch_size, sequence_length, hidden_size), 可选) — 可选地,而不是传递input_ids,您可以选择直接传递嵌入式表示。这在您想要比模型的内部嵌入查找矩阵有更多控制权,如何将input_ids索引转换为相关向量时很有用。
  • output_attentions (bool, 可选) —— 是否返回所有注意力层的注意力张量。有关返回张量下的 attentions 的详细信息,请参阅。
  • output_hidden_states (bool, 可选) —— 是否返回所有层的隐藏状态。有关返回张量下的 hidden_states 的详细信息,请参阅。
  • return_dict (bool, 可选) —— 是否返回对象 ModelOutput 而非普通元组。
  • labels (torch.LongTensor of shape (batch_size, sequence_length), optional) — 计算遮蔽语言建模损失时的标签。索引应在 [-100, 0, ..., config.vocab_size] 范围内(参见 input_ids 的文档字符串)索引设置为 -100 的标记被忽略(遮蔽),仅对标签在 [0, ..., config.vocab_size] 范围内的标记计算损失

返回值

transformers.modeling_outputs.MaskedLMOutputtuple(torch.FloatTensor)

A transformers.modeling_outputs.MaskedLMOutput 或一个由 torch.FloatTensor 组成的元组(如果传递了 return_dict=False 或当 config.return_dict=False)根据配置(TapasConfig)和输入包含各种元素。

  • loss (torch.FloatTensor of shape (1,), optional, returned when labels is provided) — 遮蔽语言建模(MLM)损失。

  • logits (torch.FloatTensor of shape (batch_size, sequence_length, config.vocab_size)) — 语言建模头部的预测分数(在 SoftMax 之前的每个词汇表标记的分数)。

  • hidden_states (tuple(torch.FloatTensor), 可选,在传递 output_hidden_states=True 时返回,或当 config.output_hidden_states=True 时返回) — 一个为嵌入层的输出(如果模型有嵌入层,+ 一个为每层的输出)的 torch.FloatTensor 的元组,形状为 (batch_size, sequence_length, hidden_size)

    在每个层的输出处以及可选的初始嵌入输出处的模型隐藏状态。

  • attentions (tuple(torch.FloatTensor), 可选,在传递 output_attentions=True 时返回,或当 config.output_attentions=True 时返回) — 一个 torch.FloatTensor 的元组(每个层一个),形状为 (batch_size, num_heads, sequence_length, sequence_length)

    注意力软化的权重之后,用于在自注意力头中进行加权的平均值。

TapasForMaskedLM 的前进方法,重写了 __call__ 特殊方法。

尽管需要在函数内定义前向传递的配方,但是应该调用 Module 实例,而不是这个,因为前者负责运行预和后处理步骤,而后者会默默地忽略这些步骤。

示例

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

参数

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

Tapas 模型在顶部有一个序列分类头(池化输出的线性层),例如 TabFact (Chen et al., 2020) 等表格蕴含任务。

此模型继承自 PreTrainedModel。请查阅超类文档了解库为所有模型实现的基本方法(例如下载或保存、调整输入嵌入式、剪枝头部等)。

此模型也是 PyTorch torch.nn.Module 的子类。将其用作常规 PyTorch 模块,并参考 PyTorch 文档了解所有与一般使用和行为相关的事项。

forward

< >

( input_ids: 可选 = None attention_mask: 可选 = None token_type_ids: 可选 = None position_ids: 可选 = None head_mask: 可选 = None inputs_embeds: 可选 = None labels: 可选 = None output_attentions: 可选 = None output_hidden_states: 可选 = None return_dict: 可选 = None ) transformers.modeling_outputs.SequenceClassifierOutputtuple(torch.FloatTensor)

参数

  • input_ids (torch.LongTensor of shape (batch_size, sequence_length)) — 输入序列令牌在词汇表中的索引。可以使用 AutoTokenizer 获取索引。有关详细信息,请参阅 PreTrainedTokenizer.encode()PreTrainedTokenizer.call()

    什么是输入ID?

  • attention_mask (torch.FloatTensor of shape (batch_size, sequence_length), 可选) — 当避开对填充token索引执行注意力操作时使用的掩码。掩码值选择为[0, 1]

    • 1 表示未掩码的tokens,
    • 0 表示掩码的tokens。

    什么是注意力掩码?

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

    什么是token类型ID?

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

    什么是位置ID?

  • head_mask (torch.FloatTensor of shape (num_heads,) or (num_layers, num_heads), optional) — 用于取消自注意力模块中选定的head。掩码值在[0, 1]之间选择:- 1表示头未被掩码,- 0表示头被掩码。
  • inputs_embeds (torch.FloatTensor of shape (batch_size, sequence_length, hidden_size), optional) — 可以选择直接传递嵌入式表示,而不是传递input_ids。这适用于您想更多地控制如何将input_ids索引转换为相关向量,而不是模型内部的嵌入查找矩阵。
  • output_attentions (bool, optional) — 是否返回所有注意力层的注意力张量。有关返回张量中的attentions的更多信息,请参阅。
  • output_hidden_states (bool, 可选) — 是否返回所有层的隐藏状态。请参阅返回的张量下的 hidden_states 获取更多详细信息。
  • return_dict (bool, 可选) — 是否返回 ModelOutput 而不是一个普通的元组。
  • labels (torch.LongTensor 形状为 (batch_size,), 可选) — 用于计算序列分类/回归损失的标签。索引应在 [0, ..., config.num_labels - 1] 范围内。如果 config.num_labels == 1,则计算回归损失(均方损失),如果 config.num_labels > 1,则计算分类损失(交叉熵)。注意:在原始实现中被称为“classification_class_index”。

返回值

transformers.modeling_outputs.SequenceClassifierOutputtuple(torch.FloatTensor)

A transformers.modeling_outputs.SequenceClassifierOutput 或一个包含 torch.FloatTensor 的元组(如果 return_dict=False 被传递或当 config.return_dict=False 时),其包含各种元素,具体取决于配置 (TapasConfig) 和输入。

  • loss (torch.FloatTensor 形状为 (1,), 可选,当提供 labels 时返回) — 分类(或如果 config.num_labels==1,则回归)损失。

  • logits (torch.FloatTensor 形状为 (batch_size, config.num_labels)) — 分类(如果 config.num_labels==1,则回归)得分(在 SoftMax 之前)。

  • hidden_states (tuple(torch.FloatTensor), 可选,在传递 output_hidden_states=True 时返回,或当 config.output_hidden_states=True 时返回) — 一个为嵌入层的输出(如果模型有嵌入层,+ 一个为每层的输出)的 torch.FloatTensor 的元组,形状为 (batch_size, sequence_length, hidden_size)

    在每个层的输出处以及可选的初始嵌入输出处的模型隐藏状态。

  • attentions (tuple(torch.FloatTensor), 可选,在传递 output_attentions=True 时返回,或当 config.output_attentions=True 时返回) — 一个 torch.FloatTensor 的元组(每个层一个),形状为 (batch_size, num_heads, sequence_length, sequence_length)

    注意力软化的权重之后,用于在自注意力头中进行加权的平均值。

TapasForSequenceClassification 前向方法,覆盖了 __call__ 特殊方法。

尽管需要在函数内定义前向传递的配方,但是应该调用 Module 实例,而不是这个,因为前者负责运行预和后处理步骤,而后者会默默地忽略这些步骤。

示例

>>> 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() 方法以加载模型权重。

在表格问答任务(如SQA、WTQ或WikiSQL监督任务)上具有单元选择头和可选聚合头的Tapas模型,在隐藏态输出上使用线性层计算logits和可选的logits_aggregation

此模型继承自 PreTrainedModel。请查阅超类文档了解库为所有模型实现的基本方法(例如下载或保存、调整输入嵌入式、剪枝头部等)。

此模型也是 PyTorch torch.nn.Module 的子类。将其用作常规 PyTorch 模块,并参考 PyTorch 文档了解所有与一般使用和行为相关的事项。

forward

< >

( input_ids: Optional = None attention_mask: Optional = None token_type_ids: Optional = None position_ids: Optional = None head_mask: Optional = None inputs_embeds: Optional = None table_mask: Optional = None labels: Optional = None aggregation_labels: Optional = None float_answer: Optional = None numeric_values: Optional = None numeric_values_scale: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None ) transformers.models.tapas.modeling_tapas.TableQuestionAnsweringOutputtuple(torch.FloatTensor)

参数

  • input_ids (torch.LongTensor,形状为(batch_size, sequence_length)) — 输入序列令牌在词汇表中的索引。索引可以通过使用 AutoTokenizer 来获得。有关详细信息,请参阅 PreTrainedTokenizer.encode()PreTrainedTokenizer.call()

    什么是输入ID?

  • attention_mask (torch.FloatTensor,形状为 (batch_size, sequence_length)可选) — 用于避免在填充标记索引上执行关注的掩码。掩码值选择在 [0, 1]:《p>

    • 1 表示未掩码的标记,
    • 0 表示掩码的标记。

    什么是关注掩码?

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

    什么是标记类型ID?

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

    什么是位置ID?

  • head_mask (torch.FloatTensor 形状为 (num_heads,)(num_layers, num_heads)可选) — 用于取消激活自注意模块所选头部的掩码。掩码值选择在 [0, 1] 之间:- 1 表示头部 未掩码,- 0 表示头部 掩码
  • inputs_embeds (torch.FloatTensor 形状为 (batch_size, sequence_length, hidden_size)可选) — 可选地,您可以选择直接传递嵌入表示,而不是传递 input_ids。这在您希望对将 input_ids 索引转换为相关向量具有更多控制权时很有用,而不是模型内部嵌入查找矩阵。
  • output_attentions (bool, 可选) — 是否返回所有注意力层中的注意力张量。请参阅返回的张量下的 attentions 获取更多细节。
  • output_hidden_states (bool, 可选) — 是否返回所有层的隐藏状态。请参阅返回的张量下的 hidden_states 获取更多细节。
  • return_dict (bool, 可选) — 是否返回一个 ModelOutput 而不是一个普通的元组。
  • table_mask (shape为(batch_size, seq_length)torch.LongTensor可选) — 表的掩码。指示哪些标记属于表(1)。问题标记、表头和填充为0。
  • labels (shape为(batch_size, seq_length)torch.LongTensor可选) — 计算层次单元选择损失的token标签。此标签编码表中出现答案的位置。可以使用AutoTokenizer获取。
    • 1 表示答案的tokentken是答案的一部分
    • 0 表示token是非答案的一部分
  • aggregation_labels (shape为(batch_size, )torch.LongTensor可选) — 为每个批次中的每个示例计算聚合损失的聚合函数索引。索引应在[0, ..., config.num_aggregation_labels - 1]之间。只有在聚合强监督的情况下(WikiSQL监督)才需要。
  • float_answer (torch.FloatTensor of shape (batch_size, ), optional) — 批次中每个样本的浮点答案。对于选择单元的问题,设置为您 float(‘nan’)。仅在弱监督(WTQ)的情况下需要,用于计算聚合掩码和回归损失。
  • numeric_values (torch.FloatTensor of shape (batch_size, seq_length), optional) — 每个标记的数值,对于非数值标记为 NaN。可以使用 AutoTokenizer 获取。仅在弱监督聚合(WTQ)的情况下需要,用于计算回归损失。
  • numeric_values_scale (torch.FloatTensor of shape (batch_size, seq_length), optional) — 每个标记的数值的缩放系数。可以使用 AutoTokenizer 获取。仅在弱监督聚合(WTQ)的情况下需要,用于计算回归损失。

返回值

transformers.models.tapas.modeling_tapas.TableQuestionAnsweringOutputtuple(torch.FloatTensor)

这是一个transformers.models.tapas.modeling_tapas.TableQuestionAnsweringOutput 或是一个包含各种元素的 torch.FloatTensor 的元组(如果传递了 return_dict=False 或当 config.return_dict=False)的结构,这些元素取决于配置(TapasConfig)和输入。

  • losstorch.FloatTensor,形状为 (1,)可选,当提供 labels(以及可能的 answeraggregation_labelsnumeric_valuesnumeric_values_scale)时返回)—— 总损失是层状单元格选择对数似然损失之和,以及可选的半监督回归损失和可选的聚合监督损失。
  • logitstorch.FloatTensor,形状为 (batch_size, sequence_length))—— 单元格选择头的预测分数,对每个标记来说。
  • logits_aggregationtorch.FloatTensor可选,形状为 (batch_size, num_aggregation_labels))—— 聚合头对每个聚合操作器的预测分数。
  • hidden_statestuple(torch.FloatTensor)可选,当传递 output_hidden_states=True 或当 config.output_hidden_states=True 时返回)—— 包含每个层的 torch.FloatTensor 的元组(一个用于嵌入输出 + 一系列层的输出),形状为 (batch_size, sequence_length, hidden_size)。每个层输出的模型隐藏状态加上初始嵌入输出。
  • attentionstuple(torch.FloatTensor)可选,当传递 output_attentions=True 或当 config.output_attentions=True 时返回)—— 每个层的 torch.FloatTensor 的元组(形状为 (batch_size, num_heads, sequence_length, sequence_length))。注意力 softmax 之后的注意力权重,用于计算自注意力头中的加权平均。

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

尽管需要在函数内定义前向传递的配方,但是应该调用 Module 实例,而不是这个,因为前者负责运行预和后处理步骤,而后者会默默地忽略这些步骤。

示例

>>> 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
TensorFlow
隐藏TensorFlow内容

TFTapasModel

class transformers.TFTapasModel

< >

( config:TapasConfig *inputs **kwargs )

参数

  • config (TapasConfig) — 包含模型所有参数的模型配置类。使用配置文件初始化不会加载模型的权重,仅加载配置。查看from_pretrained()方法来加载模型权重。

一个裸Tapas模型变换器,输出原始隐藏状态,不带有任何特定头。

该模型继承了TFPreTrainedModel。有关库为所有模型实现的一般方法(例如下载或保存,调整输入嵌入大小,剪枝头等)的文档,请检查其超类文档。

该模型也是keras.Model的子类。将其用作常规TF 2.0 Keras模型,并参考TF 2.0文档以获取与通用使用和行为相关的所有内容。

transformers中的TensorFlow模型和层接受两种输入格式

  • 所有输入均作为关键字参数(类似于PyTorch模型),或
  • 所有输入作为第一个位置参数中的列表、元组或字典。

支持第二种格式的理由是Keras方法在传递输入到模型和层时首选此格式。由于这种支持,当使用model.fit()等方法时,应该“一切正常”——只需按照model.fit()支持的方式进行输入和标签传递即可!但是,如果您想在fit()predict()等Keras方法之外使用第二种格式,例如在创建自己的层或使用Keras Functional API创建自己的模型时,您可以使用以下三种方法来获取第一个位置参数中的所有输入张量

  • 仅包含input_ids的单个张量:model(input_ids)
  • 长度不一的列表,其中包含一个或多个按文档字符串中给出的顺序排列的输入张量:model([input_ids, attention_mask])model([input_ids, attention_mask, token_type_ids])
  • 与文档字符串中给出的输入名称关联的一个或多个输入张量的字典:model({"input_ids": input_ids, "token_type_ids": token_type_ids})

请注意,当通过子类化创建模型和层时,您无需担心这些问题,因为您可以像传递给任何其他Python函数一样传递输入!

调用

参数

  • input_ids (np.ndarray, tf.Tensor, List[tf.Tensor] `Dict[str, tf.Tensor]Dict[str, np.ndarray] 以及每个示例都必须具有形状 (批量大小, 序列长度)) —词汇表中输入序列标记的索引。

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

    什么是输入 ID?

  • attention_mask (np.ndarraytf.Tensor 形状为 (批量大小, 序列长度)可选) — 用于防止在填充标记索引上执行注意力的掩码。掩码值选择在 [0, 1] 范围内:

    • 1 表示 未掩码 的标记,
    • 0 表示 掩码 的标记。

    什么是注意力掩码?

  • token_type_ids (np.ndarraytf.Tensor 形状为 (批量大小, 序列长度, 7)可选) — 编码表格结构的标记索引。可以使用 AutoTokenizer 获取索引。更多信息请参阅此类。

    什么是标记类型 ID?

  • position_ids (np.ndarraytf.Tensor 形状为 (batch_size, sequence_length)可选) — 每个输入序列标记在位置嵌入中的索引。如果 TapasConfigreset_position_index_per_cell 设置为 True,将使用相对位置嵌入。选择范围在 [0, config.max_position_embeddings - 1] 之间。
  • head_mask (np.ndarraytf.Tensor 形状为 (num_heads,)(num_layers, num_heads)可选) — 用于使自注意力模块中选定的头无效化的掩码。掩码值在 [0, 1] 范围内:
    • 1 表示头未掩码,
    • 0 表示头已掩码。
  • inputs_embeds (np.ndarraytf.Tensor 形状为 (batch_size, sequence_length, hidden_size)可选) — 也可选择直接传递嵌入表示,而不是传递 input_ids。这在您想要比模型的内部嵌入查找矩阵有更多控制权以将 input_ids 索引转换为相关向量时很有用。
  • output_attentions (bool, 可选) — 是否返回所有注意力层的注意力张量。详见返回张量下的attentions以获取更多详细信息。此参数只能在急切模式下使用,在图模式下将使用配置中的值。
  • output_hidden_states (bool, 可选) — 是否返回所有层的隐藏状态。详见返回张量下的hidden_states以获取更多详细信息。此参数只能在急切模式下使用,在图模式下将使用配置中的值。
  • return_dict (bool, 可选) — 是否返回模型输出对象,而不是平凡的元组。此参数可以在急切模式下使用,在图模式下该值始终设置为True。
  • 训练 (bool, 可选,默认为 `False`) — 是否在训练模式下使用模型(某些模块如dropout模块在训练和评估之间有不同的行为)。

返回值

transformers.modeling_tf_outputs.TFBaseModelOutputWithPoolingtuple(tf.Tensor)

一个 transformers.modeling_tf_outputs.TFBaseModelOutputWithPooling 或一个 tf.Tensor 的元组(如果传递了 return_dict=False 或者当 config.return_dict=False),根据配置(TapasConfig)和输入包含各种元素。

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

  • pooler_output (tf.Tensor 形状为 (batch_size, hidden_size)) — 序列中第一个标记(分类标记)的最后一层隐藏状态,经过线性层和 Tanh 激活函数进一步处理。预训练期间 Linear 层的权重来自下一个句子预测(分类)目标。

    这个输出通常 不是 输入语义内容的好总结,你通常需要平均或池化整个输入序列的隐藏状态序列。

  • hidden_states (tuple(tf.Tensor),可选,当传递 output_hidden_states=True 或当 config.output_hidden_states=True 时返回) — 一个形状为 (batch_size, sequence_length, hidden_size)tf.Tensor 的元组(一个用于嵌入输出的输出,一个用于每一层的输出)。

    模型的每层输出以及初始嵌入输出的隐藏状态。

  • attentions (tuple(tf.Tensor),可选,当传递 output_attentions=True 或当 config.output_attentions=True 时返回) — 一个形状为 (batch_size, num_heads, sequence_length, sequence_length)tf.Tensor 的元组(每层一个)。

    注意力软化的权重之后,用于在自注意力头中进行加权的平均值。

TFTapasModel 前向方法,重写了 `__call__` 特殊方法。

尽管需要在函数内定义前向传递的配方,但是应该调用 Module 实例,而不是这个,因为前者负责运行预和后处理步骤,而后者会默默地忽略这些步骤。

示例

>>> 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="tf")
>>> outputs = model(**inputs)

>>> last_hidden_states = outputs.last_hidden_state

TFTapasForMaskedLM

transformers.TFTapasForMaskedLM

< >

( config:TapasConfig *inputs **kwargs )

参数

  • config (TapasConfig) — 模型配置类,包含所有模型参数。用配置文件初始化不会加载模型相关的权重,只加载配置。请查阅 from_pretrained() 方法以加载模型权重。

带有顶部 语言建模 头的 Tapas 模型。

该模型继承了TFPreTrainedModel。有关库为所有模型实现的一般方法(例如下载或保存,调整输入嵌入大小,剪枝头等)的文档,请检查其超类文档。

该模型也是keras.Model的子类。将其用作常规TF 2.0 Keras模型,并参考TF 2.0文档以获取与通用使用和行为相关的所有内容。

transformers中的TensorFlow模型和层接受两种输入格式

  • 所有输入均作为关键字参数(类似于PyTorch模型),或
  • 所有输入作为第一个位置参数中的列表、元组或字典。

支持第二种格式的理由是Keras方法在传递输入到模型和层时首选此格式。由于这种支持,当使用model.fit()等方法时,应该“一切正常”——只需按照model.fit()支持的方式进行输入和标签传递即可!但是,如果您想在fit()predict()等Keras方法之外使用第二种格式,例如在创建自己的层或使用Keras Functional API创建自己的模型时,您可以使用以下三种方法来获取第一个位置参数中的所有输入张量

  • 仅包含input_ids的单个张量:model(input_ids)
  • 长度不一的列表,其中包含一个或多个按文档字符串中给出的顺序排列的输入张量:model([input_ids, attention_mask])model([input_ids, attention_mask, token_type_ids])
  • 与文档字符串中给出的输入名称关联的一个或多个输入张量的字典:model({"input_ids": input_ids, "token_type_ids": token_type_ids})

请注意,当通过子类化创建模型和层时,您无需担心这些问题,因为您可以像传递给任何其他Python函数一样传递输入!

调用

< >

( input_ids: TFModelInputType | None = None attention_mask: np.ndarray | tf.Tensor | None = None token_type_ids: np.ndarray | tf.Tensor | None = None position_ids: np.ndarray | tf.Tensor | None = None head_mask: np.ndarray | tf.Tensor | None = None inputs_embeds: np.ndarray | tf.Tensor | None = None output_attentions: Optional[bool] = None output_hidden_states: Optional[bool] = None return_dict: Optional[bool] = None labels: np.ndarray | tf.Tensor | None = None training: Optional[bool] = False ) transformers.modeling_tf_outputs.TFMaskedLMOutput or tuple(tf.Tensor)

参数

  • input_ids (np.ndarray, tf.Tensor, List[tf.Tensor] `Dict[str, tf.Tensor] or Dict[str, np.ndarray] and each example must have the shape (batch_size, sequence_length)) — 输入序列token在词表中的索引。

    索引可以通过使用 AutoTokenizer 获得详细信息。请参阅 PreTrainedTokenizer.call()PreTrainedTokenizer.encode()

    输入ID是什么?

  • attention_mask (np.ndarraytf.Tensor 形状为 (batch_size, sequence_length)可选) - 避免在填充 token 索引上执行 attention 的掩码。掩码值选择在 [0, 1]

    • 1 表示 未掩码 的 token,
    • 0 表示 已掩码 的 token。

    什么是 attention_mask?

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

    什么是 token_type_ids?

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

    什么是 position_ids?

  • head_mask (np.ndarraytf.Tensor shape(num_heads,)(num_layers, num_heads)可选)— 使自注意力模块中选定的头无效的掩码。在[0, 1]范围内选择掩码值:
    • 1表示头未掩码,
  • 0表示头已掩码。
  • inputs_embeds (np.ndarraytf.Tensor shape(batch_size, sequence_length, hidden_size)可选)— 可以选择直接传递嵌入表示而不是输入ID,而不是传递输入ID。如果您想要比模型内部嵌入查找矩阵更多控制如何将input_ids索引转换为相关向量,这很有用。
  • output_attentions (bool可选)— 是否返回所有注意力层的注意力张量。有关更多详细信息,请参阅返回张量中的attentions。此参数仅在紧急模式下使用,在图形模式下,将使用配置中的值。
  • output_hidden_states (bool, 可选) — 是否返回所有层的隐藏状态。有关更多详细信息,请参阅返回张量下的 hidden_states。此参数只能在急切模式下使用,在图模式下将使用配置中的值。
  • return_dict (bool, 可选) — 是否返回 ModelOutput 而不是纯元组。此参数可以在急切模式下使用,在图模式下此值始终设置为 True。
  • training (bool, 可选, 默认为 `False`) — 是否在训练模式下使用模型(某些模块,如dropout模块,在训练和评估模式间有不同的行为)。
  • labels (tf.Tensornp.ndarray 的形状为 (batch_size, sequence_length)可选) — 用于计算掩码语言模型损失的标签。索引应在 [-100, 0, ..., config.vocab_size] 范围内(见 input_ids 文档字符串)索引设置为 -100 的标记将被忽略(掩码),损失仅计算具有标签在 [0, ..., config.vocab_size] 范围内的标记
  • 返回值

    transformers.modeling_tf_outputs.TFMaskedLMOutputtuple(tf.Tensor)

    transformers.modeling_tf_outputs.TFMaskedLMOutputtf.Tensor 的元组(如果传递了 return_dict=Falseconfig.return_dict=False 时),根据配置(TapasConfig)和输入包含各种元素。

    • loss(《tf.Tensor 形状为 (n,)可选,其中 n 是非掩码标签的数量,在提供 labels 时返回)— 埋言语言模型(MLM)损失。

    • logitstf.Tensor 形状为 (batch_size, sequence_length, config.vocab_size))— 语言模型头部预测分数(SoftMax 之前每个词汇表的分数)。

    • hidden_states (tuple(tf.Tensor),可选,当传递 output_hidden_states=True 或当 config.output_hidden_states=True 时返回) — 一个形状为 (batch_size, sequence_length, hidden_size)tf.Tensor 的元组(一个用于嵌入输出的输出,一个用于每一层的输出)。

      模型的每层输出以及初始嵌入输出的隐藏状态。

    • attentions (tuple(tf.Tensor),可选,当传递 output_attentions=True 或当 config.output_attentions=True 时返回) — 一个形状为 (batch_size, num_heads, sequence_length, sequence_length)tf.Tensor 的元组(每层一个)。

      注意力软化的权重之后,用于在自注意力头中进行加权的平均值。

    TFTapasForMaskedLM 前向方法,重写了 __call__ 特殊方法。

    尽管需要在函数内定义前向传递的配方,但是应该调用 Module 实例,而不是这个,因为前者负责运行预和后处理步骤,而后者会默默地忽略这些步骤。

    示例

    >>> 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="tf"
    ... )
    >>> labels = tokenizer(
    ...     table=table, queries="How many movies has George Clooney played in?", return_tensors="tf"
    ... )["input_ids"]
    
    >>> outputs = model(**inputs, labels=labels)
    >>> logits = outputs.logits

    TFTapasForSequenceClassification

    class transformers.TFTapasForSequenceClassification

    < >

    ( config:TapasConfig *inputs **kwargs )

    参数

    • config(《TapasConfig》)—— 具有模型所有参数的模型配置类。使用配置文件初始化不会加载模型相关的权重,只加载配置。请查看 TapasConfig,使用 from_pretrained()方法加载模型权重。

    Tapas 模型在顶部有一个序列分类头(池化输出的线性层),例如 TabFact (Chen et al., 2020) 等表格蕴含任务。

    该模型继承了TFPreTrainedModel。有关库为所有模型实现的一般方法(例如下载或保存,调整输入嵌入大小,剪枝头等)的文档,请检查其超类文档。

    该模型也是keras.Model的子类。将其用作常规TF 2.0 Keras模型,并参考TF 2.0文档以获取与通用使用和行为相关的所有内容。

    transformers中的TensorFlow模型和层接受两种输入格式

    • 所有输入均作为关键字参数(类似于PyTorch模型),或
    • 所有输入作为第一个位置参数中的列表、元组或字典。

    支持第二种格式的理由是Keras方法在传递输入到模型和层时首选此格式。由于这种支持,当使用model.fit()等方法时,应该“一切正常”——只需按照model.fit()支持的方式进行输入和标签传递即可!但是,如果您想在fit()predict()等Keras方法之外使用第二种格式,例如在创建自己的层或使用Keras Functional API创建自己的模型时,您可以使用以下三种方法来获取第一个位置参数中的所有输入张量

    • 仅包含input_ids的单个张量:model(input_ids)
    • 长度不一的列表,其中包含一个或多个按文档字符串中给出的顺序排列的输入张量:model([input_ids, attention_mask])model([input_ids, attention_mask, token_type_ids])
    • 与文档字符串中给出的输入名称关联的一个或多个输入张量的字典:model({"input_ids": input_ids, "token_type_ids": token_type_ids})

    请注意,当通过子类化创建模型和层时,您无需担心这些问题,因为您可以像传递给任何其他Python函数一样传递输入!

    调用

    < >

    ( input_ids: TFModelInputType | None = None attention_mask: np.ndarray | tf.Tensor | None = None token_type_ids: np.ndarray | tf.Tensor | None = None position_ids: np.ndarray | tf.Tensor | None = None head_mask: np.ndarray | tf.Tensor | None = None inputs_embeds: np.ndarray | tf.Tensor | None = None output_attentions: 可选[bool] = None output_hidden_states: 可选[bool] = None return_dict: 可选[bool] = None labels: np.ndarray | tf.Tensor | None = None training: 可选[bool] = False ) transformers.modeling_tf_outputs.TFSequenceClassifierOutputtuple(tf.Tensor)

    参数

    • input_ids (np.ndarray, tf.Tensor, List[tf.Tensor] `Dict[str, tf.Tensor] or Dict[str, np.ndarray] and each example must have the shape (batch_size, num_choices, sequence_length)) — 输入序列词的词汇索引。

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

      什么是输入 ID?

    • attention_mask (np.ndarraytf.Tensor 形状为 (batch_size, num_choices, sequence_length)可选) — 避免在填充词索引上执行注意力的掩码。掩码值在 [0, 1] 之间选择:

      • 1 代表 未掩码 的标记,
      • 0 代表 掩码 的标记。

      什么是注意掩码?

    • token_type_ids (np.ndarraytf.Tensor 形状为 (batch_size, num_choices, sequence_length, 7)可选) — 编码表格结构的标记索引。可以使用 AutoTokenizer 获取索引。参阅此类获取更多信息。

      什么是标记类型 ID?

    • position_ids (np.ndarraytf.Tensor 形状为 (batch_size, num_choices, sequence_length)可选) — 每个输入序列标记在位置嵌入中的索引。如果 TapasConfigreset_position_index_per_cell 设置为 True,则使用相对位置嵌入。选择范围 [0, config.max_position_embeddings - 1]

      什么是位置 ID?

    • head_mask (np.ndarraytf.Tensor 形状为 (num_heads,)(num_layers, num_heads)可选) — 用于取消自我注意模块中选定的头的掩码。掩码值在 [0, 1]

      • 1 表示头未被 掩码
      • 0 表示头被 掩码
    • inputs_embeds (np.ndarraytf.Tensor 形状为 (batch_size, num_choices, sequence_length, hidden_size)可选) — 可选,您可以选择直接传递嵌入表示而不是 input_ids。当您想比模型内部嵌入查找矩阵有更多控制权将 input_ids 索引转换为关联向量时,这很有用。
    • output_attentions (bool可选) — 是否返回所有注意层张量的注意力。更多详情请见返回的自张量下的 attentions。此参数仅在动态模式中可用,在图模式中,将使用配置中的值。
    • output_hidden_states (bool, 可选) —— 是否返回所有层的隐藏状态。有关更多详细信息,请参阅返回张量下的 hidden_states。此参数只能在eager模式中使用,在图模式中,将使用配置中的值。
    • return_dict (bool, 可选) —— 是否返回一个 ModelOutput 而不是普通的元组。此参数可以在eager模式中使用,在图模式中,该值始终被设置为True。
    • training (bool, 可选,默认为 `False`) —— 是否使用训练模式的模型(某些模块,如dropout模块,在训练和评估之间有不同的行为)。
    • labels (torch.LongTensor 的形状为(batch_size,)可选) — 用于计算序列分类/回归损失的标签。索引应位于 [0, ..., config.num_labels - 1]。如果 config.num_labels == 1,则计算回归损失(均方损失),如果 config.num_labels > 1,则计算分类损失(交叉熵)。注意:这是原始实现中的“classification_class_index”。

    返回值

    transformers.modeling_tf_outputs.TFSequenceClassifierOutputtuple(tf.Tensor)

    一个 transformers.modeling_tf_outputs.TFSequenceClassifierOutput 或一个 tf.Tensor 的元组(如果传递了 return_dict=Falseconfig.return_dict=False),它包含根据配置(TapasConfig)和输入的不同元素。

    • loss (当提供 labels 时返回,形状为 (batch_size, )tf.Tensor,可选) — 分类(或如果 config.num_labels==1 则为回归)损失。

    • logits (形状为 (batch_size, config.num_labels)tf.Tensor) — 分类(如果 config.num_labels==1 则为回归)分数(在 SoftMax 之前)。

    • hidden_states (tuple(tf.Tensor),可选,当传递 output_hidden_states=True 或当 config.output_hidden_states=True 时返回) — 一个形状为 (batch_size, sequence_length, hidden_size)tf.Tensor 的元组(一个用于嵌入输出的输出,一个用于每一层的输出)。

      模型的每层输出以及初始嵌入输出的隐藏状态。

    • attentions (tuple(tf.Tensor),可选,当传递 output_attentions=True 或当 config.output_attentions=True 时返回) — 一个形状为 (batch_size, num_heads, sequence_length, sequence_length)tf.Tensor 的元组(每层一个)。

      注意力软化的权重之后,用于在自注意力头中进行加权的平均值。

    TFTapasForSequenceClassification 前向方法,覆盖了 __call__ 特殊方法。

    尽管需要在函数内定义前向传递的配方,但是应该调用 Module 实例,而不是这个,因为前者负责运行预和后处理步骤,而后者会默默地忽略这些步骤。

    示例

    >>> from transformers import AutoTokenizer, TapasForSequenceClassification
    >>> import tensorflow as tf
    >>> 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="tf")
    >>> labels = tf.convert_to_tensor([1, 0])  # 1 means entailed, 0 means refuted
    
    >>> outputs = model(**inputs, labels=labels)
    >>> loss = outputs.loss
    >>> logits = outputs.logits

    TFTapasForQuestionAnswering

    class transformers.TFTapasForQuestionAnswering

    < >

    ( config:TapasConfig *inputs **kwargs )

    参数

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

    在表格问答任务(如SQA、WTQ或WikiSQL监督任务)上具有单元选择头和可选聚合头的Tapas模型,在隐藏态输出上使用线性层计算logits和可选的logits_aggregation

    该模型继承了TFPreTrainedModel。有关库为所有模型实现的一般方法(例如下载或保存,调整输入嵌入大小,剪枝头等)的文档,请检查其超类文档。

    该模型也是keras.Model的子类。将其用作常规TF 2.0 Keras模型,并参考TF 2.0文档以获取与通用使用和行为相关的所有内容。

    transformers中的TensorFlow模型和层接受两种输入格式

    • 所有输入均作为关键字参数(类似于PyTorch模型),或
    • 所有输入作为第一个位置参数中的列表、元组或字典。

    支持第二种格式的理由是Keras方法在传递输入到模型和层时首选此格式。由于这种支持,当使用model.fit()等方法时,应该“一切正常”——只需按照model.fit()支持的方式进行输入和标签传递即可!但是,如果您想在fit()predict()等Keras方法之外使用第二种格式,例如在创建自己的层或使用Keras Functional API创建自己的模型时,您可以使用以下三种方法来获取第一个位置参数中的所有输入张量

    • 仅包含input_ids的单个张量:model(input_ids)
    • 长度不一的列表,其中包含一个或多个按文档字符串中给出的顺序排列的输入张量:model([input_ids, attention_mask])model([input_ids, attention_mask, token_type_ids])
    • 与文档字符串中给出的输入名称关联的一个或多个输入张量的字典:model({"input_ids": input_ids, "token_type_ids": token_type_ids})

    请注意,当通过子类化创建模型和层时,您无需担心这些问题,因为您可以像传递给任何其他Python函数一样传递输入!

    调用

    < >

    ( input_ids: TFModelInputType | None = None attention_mask: np.ndarray | tf.Tensor | None = None token_type_ids: np.ndarray | tf.Tensor | None = None position_ids: np.ndarray | tf.Tensor | None = None head_mask: np.ndarray | tf.Tensor | None = None inputs_embeds: np.ndarray | tf.Tensor | None = None table_mask: np.ndarray | tf.Tensor | None = None aggregation_labels: np.ndarray | tf.Tensor | None = None float_answer: np.ndarray | tf.Tensor | None = None numeric_values: np.ndarray | tf.Tensor | None = None numeric_values_scale: np.ndarray | tf.Tensor | None = None output_attentions: Optional[bool] = None output_hidden_states: Optional[bool] = None return_dict: Optional[bool] = None labels: np.ndarray | tf.Tensor | None = None training: Optional[bool] = False ) transformers.models.tapas.modeling_tf_tapas.TFTableQuestionAnsweringOutput or tuple(tf.Tensor)

    参数

    • input_ids (np.ndarray, tf.Tensor, List[tf.Tensor] `Dict[str, tf.Tensor] or Dict[str, np.ndarray] and each example must have the shape (batch_size, sequence_length)) — 输入序列标记在词汇表中的索引。

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

      什么是输入 ID?

    • attention_mask (np.ndarraytf.Tensor 形状为 (batch_size, sequence_length), 可选) — 用于避免在填充标记索引上执行注意力的掩码。掩码值选择为 [0, 1]:

      • 1 用于 非掩码 标记,
      • 0 用于 掩码 标记。

      什么是注意力掩码?

    • token_type_ids (np.ndarraytf.Tensor 形状为 (batch_size, sequence_length, 7), 可选) — 加密表格结构的标记索引。可以使用 AutoTokenizer 获取索引。有关更多详细信息,请参阅此类。

      什么是标记类型 ID?

    • position_ids (np.ndarraytf.Tensor 形状 (batch_size, sequence_length),可选) — 每个输入序列标记在位置嵌入中的位置标识符。如果 TapasConfig 中的 reset_position_index_per_cell 设置为 True,将使用相对位置嵌入。选择范围 [0, config.max_position_embeddings - 1]

      什么是位置ID?

    • head_mask (np.ndarraytf.Tensor 形状 (num_heads,)(num_layers, num_heads),可选) — 使自注意力模块中的选定头为零的掩码。掩码值选择范围为 [0, 1]

      • 1 表示头部未被掩码
      • 0 表示头部已被掩码
    • inputs_embeds (np.ndarraytf.Tensor 形状 (batch_size, sequence_length, hidden_size),可选) — 可选地,您可以直接传递嵌入表示,而不是传递 input_ids。如果您想比模型内部嵌入查找矩阵有更多控制权,将 input_ids 索引转换为相关向量,则此方法很有用。
    • output_attentions (bool, 可选) — 是否返回所有注意力层的注意力张量。详细信息请见返回张量下的 attentions。此参数只能在即时模式中使用,在图模式中将使用配置中的值。
    • output_hidden_states (bool, 可选) — 是否返回所有层的隐藏状态。详细信息请见返回张量下的 hidden_states。此参数只能在即时模式中使用,在图模式中将使用配置中的值。
    • return_dict (bool, 可选) — 是否返回一个 ModelOutput 而不是普通的元组。此参数可以在即时模式中使用,在图模式中该值总是设置为 True。
    • training(《布尔值`, 可选(optional), 默认值`False`) — 是否在使用训练模式下的模型(某些模块,如dropout模块,在不同的训练和评估模式间有不同的行为)。
    • table_mask(《tf.Tensor》维度为(batch_size, seq_length), 可选) — 表的掩码。指示哪些标记属于表(1)。问题标记、表头和填充为0。
    • labels(《tf.Tensor》维度为(batch_size, seq_length), 可选) — 每个token的标签用于计算层次单元格选择损失。这编码了在表中出现答案的位置。可以使用AutoTokenizer获取。

      • 1 对于是 答案的一部分的token
      • 0 对于不是 答案的一部分的token
    • aggregation_labels (tf.Tensor 形状为 (batch_size, )可选)— 为每个批次的示例计算聚合损失时的聚合函数索引。索引应在 [0, ..., config.num_aggregation_labels - 1] 之间。在聚合强监督(WikiSQL监督)的情况下才需要。
    • float_answer (tf.Tensor 形状为 (batch_size, )可选)— 每个批次的示例的浮点数答案。对于单元格选择问题,设置为 float(‘nan’)。在弱监督(WTQ)情况下才需要以计算聚合掩码和回归损失。
    • numeric_values (tf.Tensor 形状为 (batch_size, seq_length)可选)— 每个标记的数值,对于非数值标记,使用 NaN。可以使用 AutoTokenizer 获取。在弱监督(WTQ)情况下才需要以计算回归损失。
    • numeric_values_scale (tf.Tensor of shape (batch_size, seq_length), optional) — 每个标记的数值缩放。可以使用 AutoTokenizer 获取。仅在弱监督聚合(WTQ)的情况下计算回归损失时需要。

    返回值

    transformers.models.tapas.modeling_tf_tapas.TFTableQuestionAnsweringOutputtuple(tf.Tensor)

    A transformers.models.tapas.modeling_tf_tapas.TFTableQuestionAnsweringOutput 或一个 tf.Tensor 的元组(如果传递了 return_dict=False 或当 config.return_dict=False),包含不同配置(TapasConfig)和输入的各种元素。

    • loss (tf.Tensor of shape (1,), optional, returned when labels (and possibly answer, aggregation_labels, numeric_values and numeric_values_scale are provided)) — 总损失,是层次节点选择对数似然损失之和(可选)半监督回归损失以及(可选)聚合的监督损失。
    • logits (tf.Tensor of shape (batch_size, sequence_length)) — 细胞选择的预测分数,针对每个标记。
    • logits_aggregation (tf.Tensor, optional, of shape (batch_size, num_aggregation_labels)) — 聚合操作的预测分数,针对每个聚合操作符。
    • hidden_states (tuple(tf.Tensor), optional, returned when output_hidden_states=True is passed or when config.output_hidden_states=True) — 当传递 output_hidden_states=True 或当 config.output_hidden_states=True 时返回的 tf.Tensor 的元组(一个用于嵌入输出,一个用于每层的输出)的形状为 (batch_size, sequence_length, hidden_size)。在每层输出的隐藏状态加上初始嵌入输出。
    • attentions (tuple(tf.Tensor), optional, returned when output_attentions=True is passed or when config.output_attentions=True) — 当传递 output_attentions=True 或当 config.output_attentions=True 时返回的 tf.Tensor 的元组(一个用于每个层)的形状为 (batch_size, num_heads, sequence_length, sequence_length)。注意力权重在注意力softmax后使用,用于计算自注意力头中的加权平均。

    TFTapasForQuestionAnswering 前向方法,覆盖了 __call__ 特殊方法。

    尽管需要在函数内定义前向传递的配方,但是应该调用 Module 实例,而不是这个,因为前者负责运行预和后处理步骤,而后者会默默地忽略这些步骤。

    示例

    >>> 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="tf")
    >>> outputs = model(**inputs)
    
    >>> logits = outputs.logits
    >>> logits_aggregation = outputs.logits_aggregation
    < > 在GitHub上更新