Transformers 4.37 中文文档（九十四）（3）

Transformers 4.37 中文文档（九十四）（2）https://developer.aliyun.com/article/1564065

用法：推断

Pytorch 隐藏 Pytorch 内容

这里我们解释了如何使用 TapasForQuestionAnswering 或 TFTapasForQuestionAnswering 进行推断（即对新数据进行预测）。对于推断，只需向模型提供input_ids，attention_mask和token_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
• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14
• 15
• 16
• 17
• 18
• 19
• 20
• 21
• 22
• 23
• 24
• 25
• 26
• 27
• 28
• 29
• 30
• 31
• 32
• 33
• 34
• 35
• 36
• 37
• 38
• 39
• 40
• 41
• 42
• 43
• 44
• 45
• 46
• 47
• 48
• 49
• 50

TensorFlow 隐藏 TensorFlow 内容

在这里，我们解释了如何使用 TFTapasForQuestionAnswering 进行推断（即在新数据上进行预测）。对于推断，只需要向模型提供input_ids、attention_mask和token_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
• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14
• 15
• 16
• 17
• 18
• 19
• 20
• 21
• 22
• 23
• 24
• 25
• 26
• 27
• 28
• 29
• 30
• 31
• 32
• 33
• 34
• 35
• 36
• 37
• 38
• 39
• 40
• 41
• 42
• 43
• 44
• 45
• 46
• 47
• 48
• 49
• 50

在对话式设置中，每个表格-问题对必须顺序提供给模型，以便前一个表格-问题对的prev_labels标记类型可以被前一个表格-问题对的预测labels覆盖。再次，更多信息可以在此笔记本（适用于 PyTorch）和此笔记本（适用于 TensorFlow）中找到。

资源

• 文本分类任务指南
  
• 掩码语言建模任务指南
  

TAPAS 特定输出

class transformers.models.tapas.modeling_tapas.TableQuestionAnsweringOutput

<来源>

( loss: Optional = None logits: FloatTensor = None logits_aggregation: FloatTensor = None hidden_states: Optional = None attentions: Optional = None )
• 1

参数

• loss（形状为(1,)的torch.FloatTensor，可选，当提供labels（可能还有answer、aggregation_labels、numeric_values和numeric_values_scale）时返回） — 作为分层单元选择对数似然损失和（可选）半监督回归损失以及（可选）聚合的监督损失的总损失。
  
• logits（形状为(batch_size, sequence_length)的torch.FloatTensor） — 每个标记的单元选择头的预测分数。
  
• logits_aggregation（torch.FloatTensor，可选，形状为(batch_size, num_aggregation_labels)） — 每个聚合运算符的聚合头的预测分数。
  
• hidden_states（tuple(torch.FloatTensor)，可选，当传递output_hidden_states=True或当config.output_hidden_states=True时返回） — 形状为(batch_size, sequence_length, hidden_size)的torch.FloatTensor元组（一个用于嵌入的输出 + 一个用于每层的输出）。模型在每一层的输出的隐藏状态加上初始嵌入输出。
  
• attentions（tuple(torch.FloatTensor)，可选，当传递output_attentions=True或当config.output_attentions=True时返回） — 形状为(batch_size, num_heads, sequence_length, sequence_length)的torch.FloatTensor元组（每层一个）。在注意力 softmax 之后的注意力权重，用于计算自注意力头中的加权平均值。
  

TapasForQuestionAnswering 的输出类型。

TapasConfig

class 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 )
• 1

参数

• vocab_size（int，可选，默认为 30522） — TAPAS 模型的词汇表大小。定义了在调用 TapasModel 时可以表示的不同标记的数量。
  
• hidden_size (int, optional, 默认为 768) — 编码器层和池化器层的维度。
  
• num_hidden_layers (int, optional, 默认为 12) — Transformer 编码器中的隐藏层数量。
  
• num_attention_heads (int, optional, 默认为 12) — Transformer 编码器中每个注意力层的注意力头数。
  
• intermediate_size (int, optional, 默认为 3072) — Transformer 编码器中“中间”（通常称为前馈）层的维度。
  
• hidden_act (str 或 Callable, optional, 默认为"gelu") — 编码器和池化器中的非线性激活函数（函数或字符串）。如果是字符串，支持"gelu"、"relu"、"swish"和"gelu_new"。
  
• hidden_dropout_prob (float, optional, 默认为 0.1) — 嵌入层、编码器和池化器中所有全连接层的 dropout 概率。
  
• attention_probs_dropout_prob (float, optional, 默认为 0.1) — 注意力概率的 dropout 比率。
  
• max_position_embeddings (int, optional, 默认为 1024) — 该模型可能使用的最大序列长度。通常将其设置为较大的值以防万一（例如 512、1024 或 2048）。
  
• type_vocab_sizes (List[int], optional, 默认为[3, 256, 256, 2, 256, 256, 10]) — 在调用 TapasModel 时传递的token_type_ids的词汇大小。
  
• initializer_range (float, optional, 默认为 0.02) — 用于初始化所有权重矩阵的 truncated_normal_initializer 的标准差。
  
• layer_norm_eps (float, optional, 默认为 1e-12) — 层归一化层使用的 epsilon。
  
• positive_label_weight (float, optional, 默认为 10.0) — 正标签的权重。
  
• num_aggregation_labels (int, optional, 默认为 0) — 要预测的聚合运算符数量。
  
• aggregation_loss_weight (float, optional, 默认为 1.0) — 聚合损失的重要性权重。
  
• use_answer_as_supervision (bool, optional) — 是否将答案作为聚合示例的唯一监督。
  
• answer_loss_importance (float, optional, 默认为 1.0) — 回归损失的重要性权重。
  
• use_normalized_answer_loss (bool, optional, 默认为False) — 是否通过预测值和期望值的最大值对答案损失进行归一化。
  
• huber_loss_delta (float, optional) — 用于计算回归损失的 Delta 参数。
  
• temperature (float, optional, 默认为 1.0) — 用于控制（或改变）单元格 logits 概率的偏斜度的值。
  
• aggregation_temperature (float, optional, 默认为 1.0) — 缩放聚合 logits 以控制概率的偏斜度。
  
• use_gumbel_for_cells (bool, optional, 默认为False) — 是否对单元格选择应用 Gumbel-Softmax。
  
• use_gumbel_for_aggregation (bool, optional, 默认为False) — 是否对聚合选择应用 Gumbel-Softmax。
  
• average_approximation_function (string, optional, 默认为"ratio") — 计算弱监督情况下单元格期望平均值的方法。可以选择"ratio"、"first_order"或"second_order"之一。
  
• cell_selection_preference (float, optional) — 在模糊情况下对单元格选择的偏好。仅适用于聚合的弱监督情况（WTQ、WikiSQL）。如果聚合概率的总质量（不包括“NONE”运算符）高于此超参数，则对示例进行聚合预测。
  
• answer_loss_cutoff (float, optional) — 忽略答案损失大于截断值的示例。
  
• max_num_rows (int, optional, 默认为 64) — 最大行数。
  
• max_num_columns (int, optional, 默认为 32) — 最大列数。
  
• average_logits_per_cell (bool, optional, defaults to False) — 是否对每个单元格的 logits 进行平均。
  
• select_one_column (bool, optional, defaults to True) — 是否限制模型只选择来自单个列的单元格。
  
• allow_empty_column_selection (bool, optional, defaults to False) — 是否允许不选择任何列。
  
• init_cell_selection_weights_to_zero (bool, optional, defaults to False) — 是否将单元格选择权重初始化为 0，以便初始概率为 50%。
  
• reset_position_index_per_cell (bool, optional, defaults to True) — 是否在每个单元格重新开始位置索引（即使用相对位置嵌入）。
  
• disable_per_token_loss (bool, optional, defaults to False) — 是否禁用对单元格的任何（强或弱）监督。
  
• aggregation_labels (Dict[int, label], optional) — 用于聚合结果的聚合标签。例如，WTQ 模型具有以下聚合标签：{0: "NONE", 1: "SUM", 2: "AVERAGE", 3: "COUNT"}
  
• no_aggregation_label_index (int, optional) — 如果定义了聚合标签，并且其中一个标签表示“无聚合”，则应将其设置为其索引。例如，WTQ 模型在索引 0 处具有“NONE”聚合标签，因此对于这些模型，应将该值设置为 0。
  

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

配置对象继承自PreTrainedConfig，可用于控制模型输出。阅读 PretrainedConfig 中的文档以获取更多信息。

除 BERT 外的超参数取自原始实现的 run_task_main.py 和 hparam_utils.py。原始实现可在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
• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8

TapasTokenizer

class transformers.TapasTokenizer

< source >

( 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 )
• 1

参数

• vocab_file (str) — 包含词汇表的文件。
  
• do_lower_case (bool, optional, defaults to True) — 在标记化时是否将输入转换为小写。
  
• do_basic_tokenize (bool, optional, defaults to True) — 在 WordPiece 之前是否进行基本标记化。
  
• never_split (Iterable, optional) — 在标记化期间永远不会分割的标记集合。仅在do_basic_tokenize=True时才有效。
  
• unk_token (str, optional, defaults to "[UNK]") — 未知标记。词汇表中不存在的标记无法转换为 ID，而是设置为此标记。
  
• sep_token (str, optional, defaults to "[SEP]") — 分隔符标记，在构建来自多个序列的序列时使用，例如，用于序列分类的两个序列或用于问题回答的文本和问题。它还用作使用特殊标记构建的序列的最后一个标记。
  
• pad_token (str, optional, defaults to "[PAD]") — 用于填充的标记，例如在批处理不同长度的序列时使用。
  
• cls_token (str, optional, defaults to "[CLS]") — 分类器标记，在进行序列分类（对整个序列进行分类而不是每个标记的分类）时使用。它是使用特殊标记构建的序列的第一个标记。
  
• mask_token (str, optional, 默认为 "[MASK]") — 用于屏蔽值的标记。在使用掩码语言建模训练此模型时使用的标记。这是模型将尝试预测的标记。
  
• empty_token (str, optional, 默认为 "[EMPTY]") — 用于表格中空单元格值的标记。空单元格值包括"“、“n/a”、“nan"和”?”。
  
• tokenize_chinese_chars (bool, optional, 默认为 True) — 是否对中文字符进行标记。这对于日语可能应该被停用（参见此问题）。
  
• strip_accents (bool, optional) — 是否去除所有重音符号。如果未指定此选项，则将由lowercase的值确定（与原始 BERT 相同）。
  
• cell_trim_length (int, optional, 默认为 -1) — 如果 > 0：修剪单元格，使长度 <= 此值。还会禁用进一步的单元格修剪，因此应该与truncation设置为True一起使用。
  
• max_column_id (int, optional) — 要提取的最大列 id。
  
• max_row_id (int, optional) — 要提取的最大行 id。
  
• strip_column_names (bool, optional, 默认为 False) — 是否添加空字符串而不是列名。
  
• update_answer_coordinates (bool, optional, 默认为 False) — 是否重新计算答案文本的答案坐标。
  
• min_question_length (int, optional) — 每个问题的最小长度，以标记为单位（否则将被跳过）。
  
• max_question_length (int, optional) — 每个问题的最大长度，以标记为单位（否则将被跳过）。
  

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

这个分词器继承自  PreTrainedTokenizer，其中包含大部分主要方法。用户应该参考这个超类以获取有关这些方法的更多信息。TapasTokenizer  创建了几个标记类型 id 来编码表格结构。更准确地说，它按照以下顺序添加了 7 个标记类型 id：segment_ids、column_ids、row_ids、prev_labels、column_ranks、inv_column_ranks和numeric_relations：

• segment_ids: 指示一个标记属于问题（0）还是表格（1）。对于特殊标记和填充，值为 0。
  
• column_ids: 指示一个标记属于表格的哪一列（从 1 开始）。对于所有问题标记、特殊标记和填充，值为 0。
  
• row_ids: 指示一个标记属于表格的哪一行（从 1 开始）。对于所有问题标记、特殊标记和填充，值为 0。列标题的标记也为 0。
  
• prev_labels: 指示一个标记是否是前一个问题的答案的一部分（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 在表格和相关句子上运行端到端的分词：标点符号拆分和 wordpiece。

__call__

<来源>

( table: pd.DataFrame queries: Union = None answer_coordinates: Union = None answer_text: Union = None add_special_tokens: bool = True padding: Union = False truncation: Union = False max_length: Optional = None pad_to_multiple_of: Optional = None return_tensors: Union = None return_token_type_ids: Optional = None return_attention_mask: Optional = None return_overflowing_tokens: bool = False return_special_tokens_mask: bool = False return_offsets_mapping: bool = False return_length: bool = False verbose: bool = True **kwargs )
• 1

参数

• table (pd.DataFrame) — 包含表格数据的表格。请注意，所有单元格的值必须是文本。在 Pandas 数据帧上使用*.astype(str)*将其转换为字符串。
  
• queries (str 或 List[str]) — 与要编码的表格相关的问题或问题批次。请注意，在批处理的情况下，所有问题必须引用相同的表格。
  
• answer_coordinates (List[Tuple] 或 List[List[Tuple]], 可选)  — 批次中每个表格-问题对的答案坐标。如果只提供单个表格-问题对，则 answer_coordinates  必须是一个包含一个或多个元组的列表。每个元组必须是（行索引，列索引）对。第一行数据行（而不是列标题行）的索引为 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'：截断到指定长度的最大长度，或者如果未提供该参数，则截断到模型的最大可接受输入长度。这将逐行截断，从表中删除行。
  
• False 或 'do_not_truncate'（默认）：不截断（即，可以输出批次，其序列长度大于模型最大可接受的输入大小）。
  

• max_length (int, 可选) — 控制截断/填充参数使用的最大长度。
  如果未设置或设置为None，则如果截断/填充参数需要最大长度，则将使用预定义的模型最大长度。如果模型没有特定的最大输入长度（如 XLNet），则将禁用截断/填充到最大长度。
  
• is_split_into_words (bool, 可选, 默认为False) — 输入是否已经预分词（例如，已分割为单词）。如果设置为True，分词器会假定输入已经分割为单词（例如，通过在空格上分割），然后对其进行分词。这对于 NER 或标记分类很有用。
  
• pad_to_multiple_of (int, 可选) — 如果设置，将填充序列到提供的值的倍数。这对于启用具有计算能力>= 7.5（Volta）的 NVIDIA 硬件上的 Tensor Cores 特别有用。
  
• return_tensors (str 或 TensorType, 可选) — 如果设置，将返回张量而不是 Python 整数列表。可接受的值为：

• 'tf': 返回 TensorFlow tf.constant 对象。
  
• 'pt': 返回 PyTorch torch.Tensor 对象。
  
• 'np': 返回 Numpy np.ndarray 对象。
  

用于对一个或多个与表格相关的序列进行标记化和准备模型的主要方法。

convert_logits_to_predictions

< source >

( data logits logits_agg = None cell_classification_threshold = 0.5 ) → export const metadata = 'undefined';tuple comprising various elements depending on the inputs
• 1

参数

• data (dict) — 将特征映射到实际值的字典。应使用 TapasTokenizer 创建。
  
• logits (torch.Tensor 或 tf.Tensor，形状为 (batch_size, sequence_length)) — 包含标记级别上的 logits 的张量。
  
• logits_agg (torch.Tensor 或 tf.Tensor，形状为 (batch_size, num_aggregation_labels)，可选) — 包含聚合 logits 的张量。
  
• 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

< source >

( save_directory: str filename_prefix: Optional = None )
• 1

PytorchHide Pytorch content

TapasModel

class transformers.TapasModel

< source >

( config add_pooling_layer = True )
• 1

参数

• 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描述的架构。

forward

< source >

( 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 output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None ) → export const metadata = 'undefined';transformers.modeling_outputs.BaseModelOutputWithPooling or tuple(torch.FloatTensor)
• 1

参数

• input_ids (torch.LongTensor，形状为(batch_size, sequence_length)) — 词汇表中输入序列标记的索引。可以使用 AutoTokenizer 获取索引。有关详细信息，请参见 PreTrainedTokenizer.encode()和 PreTrainedTokenizer.call()。
  什么是输入 ID？
  
• attention_mask (torch.FloatTensor，形状为(batch_size, sequence_length)，optional) — 用于避免在填充标记索引上执行注意力的掩码。掩码值选在[0, 1]范围内：

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

• 什么是注意力掩码？
  
• token_type_ids (torch.LongTensor，形状为(batch_size, sequence_length, 7)，optional) — 编码表格结构的标记索引。可以使用 AutoTokenizer 获取索引。有关更多信息，请参见此类。
  什么是标记类型 ID？
  
• position_ids (torch.LongTensor，形状为(batch_size, sequence_length)，optional) — 每个输入序列标记在位置嵌入中的位置索引。如果 TapasConfig 的reset_position_index_per_cell设置为True，则将使用相对位置嵌入。选在范围[0, config.max_position_embeddings - 1]内。
  什么是位置 ID？
  
• head_mask (torch.FloatTensor，形状为(num_heads,)或(num_layers, num_heads)，optional) — 用于使自注意力模块中选择的头部失效的掩码。掩码值选在[0, 1]范围内：- 1 表示头部未被掩码，- 0 表示头部被掩码。
  
• inputs_embeds (torch.FloatTensor，形状为(batch_size, sequence_length, hidden_size)，optional) — 可选地，您可以选择直接传递嵌入表示而不是传递input_ids。如果您想要更多控制如何将input_ids索引转换为相关向量，这将非常有用，而不是使用模型的内部嵌入查找矩阵。
  
• output_attentions (bool, optional) — 是否返回所有注意力层的注意力张量。有关更多详细信息，请参见返回张量下的attentions。
  
• output_hidden_states (bool, optional) — 是否返回所有层的隐藏状态。有关更多详细信息，请参见返回张量下的hidden_states。
  
• return_dict (bool, optional) — 是否返回一个 ModelOutput 而不是一个普通元组。
  

返回

transformers.modeling_outputs.BaseModelOutputWithPooling 或tuple(torch.FloatTensor)

一个 transformers.modeling_outputs.BaseModelOutputWithPooling 或一个torch.FloatTensor元组（如果传递return_dict=False或当config.return_dict=False时）包含根据配置（TapasConfig）和输入的不同元素。

• last_hidden_state (torch.FloatTensor of shape (batch_size, sequence_length, hidden_size)) — 模型最后一层的隐藏状态序列。
  
• pooler_output (torch.FloatTensor of shape (batch_size, hidden_size)) — 经过用于辅助预训练任务的层进一步处理后的序列的第一个标记（分类标记）的最后一层隐藏状态。例如，对于 BERT 系列模型，这将返回经过线性层和 tanh 激活函数处理后的分类标记。线性层的权重是在预训练期间从下一个句子预测（分类）目标中训练的。
  
• hidden_states (tuple(torch.FloatTensor), 可选的, 当传递output_hidden_states=True或当config.output_hidden_states=True时返回) — 形状为(batch_size, sequence_length, hidden_size)的torch.FloatTensor元组（如果模型有嵌入层，则为嵌入输出的一个+每层输出的一个）。
  模型在每一层的输出的隐藏状态以及可选的初始嵌入输出。
  
• attentions (tuple(torch.FloatTensor), 可选的, 当传递output_attentions=True或当config.output_attentions=True时返回) — 形状为(batch_size, num_heads, sequence_length, sequence_length)的torch.FloatTensor元组（每层一个）。
  注意力权重在注意力 softmax 之后，用于计算自注意力头中的加权平均值。
  

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
• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14
• 15
• 16
• 17
• 18

Transformers 4.37 中文文档（九十四）（4）