Transformers--4-37-中文文档-十八-

Transformers 4.37 中文文档（十八）

原文：huggingface.co/docs/transformers

FNet

原文链接: huggingface.co/docs/transformers/v4.37.2/en/model_doc/fnet

概述

FNet 模型由 James Lee-Thorp, Joshua Ainslie, Ilya Eckstein, Santiago Ontanon 在 FNet: Mixing Tokens with Fourier Transforms 中提出。该模型用傅立叶变换替换了 BERT 模型中的自注意力层，仅返回变换的实部。该模型比 BERT 模型快得多，因为它具有更少的参数并且更节省内存。该模型在 GLUE 基准测试中达到了约 92-97% 的准确率，并且比 BERT 模型训练速度更快。论文的摘要如下：

我们展示了 Transformer 编码器架构可以通过用简单的线性变换替换自注意力子层来加速，且准确性损失有限。这些线性混合器，以及前馈层中的标准非线性，在几个文本分类任务中证明了在建模语义关系方面的能力。最令人惊讶的是，我们发现将 Transformer 编码器中的自注意力子层替换为标准的、无参数的傅立叶变换，在 GLUE 基准测试中达到了 BERT 对应模型准确率的 92-97%，但在 GPU 上训练速度快 80%，在 TPU 上快 70%，在标准的 512 输入长度下。在更长的输入长度下，我们的 FNet 模型速度显著更快：与 Long Range Arena 基准测试中的“高效”Transformer 相比，FNet 在 GPU 上与最准确的模型匹敌，同时在所有序列长度上超过最快的模型（在 TPU 上相对较短的长度）。最后，FNet 具有轻量级的内存占用，并且在较小的模型尺寸上特别高效；对于固定的速度和准确性预算，小型的 FNet 模型胜过 Transformer 对应模型。

该模型由 gchhablani 贡献。原始代码可以在 这里 找到。

使用提示

该模型在训练时没有使用注意力掩码，因为它基于傅立叶变换。该模型在最大序列长度为 512 的情况下进行训练，其中包括填充标记。因此，强烈建议在微调和推理时使用相同的最大序列长度。

资源

• 文本分类任务指南

• 标记分类任务指南

• 问答任务指南

• 遮蔽语言建模任务指南

• 多选任务指南

FNetConfig

class transformers.FNetConfig

<来源>

( vocab_size = 32000 hidden_size = 768 num_hidden_layers = 12 intermediate_size = 3072 hidden_act = 'gelu_new' hidden_dropout_prob = 0.1 max_position_embeddings = 512 type_vocab_size = 4 initializer_range = 0.02 layer_norm_eps = 1e-12 use_tpu_fourier_optimizations = False tpu_short_seq_length = 512 pad_token_id = 3 bos_token_id = 1 eos_token_id = 2 **kwargs )

参数

• vocab_size (int, optional, defaults to 32000) — FNet 模型的词汇表大小。定义了在调用 FNetModel 或 TFFNetModel 时可以表示的不同标记的数量。

• hidden_size (int, optional, defaults to 768) — 编码器层和池化器层的维度。

• num_hidden_layers (int, optional, defaults to 12) — Transformer 编码器中的隐藏层数量。

• intermediate_size (int, optional, defaults to 3072) — Transformer 编码器中“中间”（即前馈）层的维度。

• hidden_act (str or function, optional, defaults to "gelu_new") — 编码器和池化器中的非线性激活函数（函数或字符串）。如果是字符串，支持 "gelu", "relu", "selu" 和 "gelu_new"。

• hidden_dropout_prob (float, optional, defaults to 0.1) — 嵌入层、编码器和池化器中所有全连接层的丢弃概率。

• max_position_embeddings (int, optional, defaults to 512) — 此模型可能使用的最大序列长度。通常将其设置为较大的值以防万一（例如，512、1024 或 2048）。

• type_vocab_size (int, optional, defaults to 4) — 在调用 FNetModel 或 TFFNetModel 时传递的 token_type_ids 的词汇表大小。

• initializer_range (float, optional, defaults to 0.02) — 用于初始化所有权重矩阵的截断正态初始化器的标准差。

• layer_norm_eps (float, optional, defaults to 1e-12) — 层归一化层使用的 epsilon。

• use_tpu_fourier_optimizations (bool, optional, defaults to False) — 决定是否使用 TPU 优化的 FFT。如果为 True，模型将偏向于轴向 FFT 变换。对于 GPU/CPU 硬件，请设置为 False，在这种情况下将使用 n 维 FFT。

• tpu_short_seq_length (int, optional, defaults to 512) — 在使用 TPU 时模型期望的序列长度。当 use_tpu_fourier_optimizations 设置为 True 且输入序列长度短于或等于 4096 个标记时，将用于初始化 DFT 矩阵。

这是用于存储 FNetModel 配置的配置类。根据指定的参数实例化一个 FNet 模型，定义模型架构。使用默认值实例化配置将产生类似于 FNet google/fnet-base 架构的配置。

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

示例：

>>> from transformers import FNetConfig, FNetModel

>>> # Initializing a FNet fnet-base style configuration
>>> configuration = FNetConfig()

>>> # Initializing a model (with random weights) from the fnet-base style configuration
>>> model = FNetModel(configuration)

>>> # Accessing the model configuration
>>> configuration = model.config

FNetTokenizer

class transformers.FNetTokenizer

<来源>

( vocab_file do_lower_case = False remove_space = True keep_accents = True unk_token = '<unk>' sep_token = '[SEP]' pad_token = '<pad>' cls_token = '[CLS]' mask_token = '[MASK]' sp_model_kwargs: Optional = None **kwargs )

参数

• vocab_file (str) — 包含实例化标记器所需词汇表的 SentencePiece 文件（通常具有 .spm 扩展名）。

• do_lower_case (bool, optional, defaults to False) — 在进行标记化时是否将输入转换为小写。

• remove_space (bool, optional, defaults to True) — 在标记化时是否去除文本中的空格（删除字符串前后的多余空格）。

• keep_accents (bool, optional, defaults to 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, defaults to "[MASK]") — 用于屏蔽值的标记。在使用掩码语言建模训练此模型时使用的标记。这是模型将尝试预测的标记。

• sp_model_kwargs（dict，可选）- 将传递给SentencePieceProcessor.__init__()方法。可以使用SentencePiece 的 Python 包装器，其中包括设置：

  • enable_sampling：启用子词正则化。

  • nbest_size：unigram 的抽样参数。对于 BPE-Dropout 无效。

    • nbest_size = {0,1}：不执行抽样。

    • nbest_size > 1：从 nbest_size 结果中抽样。

    • nbest_size < 0：假设 nbest_size 是无限的，并使用前向过滤和后向抽样算法从所有假设（格）中抽样。

  • alpha：用于 unigram 抽样的平滑参数，以及用于 BPE-dropout 的合并操作的丢弃概率。

• sp_model（SentencePieceProcessor）- 用于每次转换（字符串、标记和 ID）的SentencePiece处理器。

构建一个 FNet 标记器。改编自 AlbertTokenizer。基于SentencePiece。此标记器继承自 PreTrainedTokenizer，其中包含大多数主要方法。用户应参考此超类以获取有关这些方法的更多信息。

build_inputs_with_special_tokens

<来源>

( token_ids_0: List token_ids_1: Optional = None ) → export const metadata = 'undefined';List[int]

参数

• token_ids_0（List[int]）- 将添加特殊标记的 ID 列表。

• token_ids_1（List[int]，可选）- 序列对的第二个 ID 列表（可选）。

返回

List[int]

具有适当特殊标记的输入 ID 列表。

通过连接和添加特殊标记，从序列或序列对构建用于序列分类任务的模型输入。FNet 序列具有以下格式：

• 单个序列：[CLS] X [SEP]

• 序列对：[CLS] A [SEP] B [SEP]

get_special_tokens_mask

<来源>

( token_ids_0: List token_ids_1: Optional = None already_has_special_tokens: bool = False ) → export const metadata = 'undefined';List[int]

参数

• token_ids_0（List[int]）- ID 列表。

• token_ids_1（List[int]，可选）- 序列对的第二个 ID 列表（可选）。

• already_has_special_tokens（bool，可选，默认为False）- 标记列表是否已经格式化为模型的特殊标记。

返回

List[int]

一个整数列表，范围为[0, 1]：1 表示特殊标记，0 表示序列标记。

从没有添加特殊标记的标记列表中检索序列 id。在使用标记器prepare_for_model方法添加特殊标记时调用此方法。

create_token_type_ids_from_sequences

<来源>

( token_ids_0: List token_ids_1: Optional = None ) → export const metadata = 'undefined';List[int]

参数

• token_ids_0（List[int]）- ID 列表。

• token_ids_1（List[int]，可选）- 序列对的第二个 ID 列表（可选）。

返回

List[int]

根据给定序列的标记类型 ID 列表。

从传递的两个序列创建一个掩码，用于在序列对分类任务中使用。一个 FNet 序列

序列对掩码的格式如下：

0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1 1 | first sequence | second sequence |

如果token_ids_1为None，则此方法仅返回掩码的第一部分（0）。

save_vocabulary

<来源>

( save_directory: str filename_prefix: Optional = None )

FNetTokenizerFast

class transformers.FNetTokenizerFast

<来源>

( vocab_file = None tokenizer_file = None do_lower_case = False remove_space = True keep_accents = True unk_token = '<unk>' sep_token = '[SEP]' pad_token = '<pad>' cls_token = '[CLS]' mask_token = '[MASK]' **kwargs )

参数

• vocab_file（str）- 包含实例化标记器所需词汇的SentencePiece文件（通常具有.spm扩展名）。

• do_lower_case（bool，可选，默认为False）— 在标记化时是否将输入转换为小写。

• remove_space（bool，可选，默认为True）— 在标记化时是否去除文本中的空格（删除字符串前后的多余空格）。

• keep_accents（bool，可选，默认为True）— 在标记化时是否保留重音。

• unk_token（str，可选，默认为"<unk>"）— 未知标记。词汇表中不存在的标记无法转换为 ID，而是设置为此标记。

• sep_token（str，可选，默认为"[SEP]"）— 分隔符标记，在从多个序列构建序列时使用，例如用于序列分类的两个序列或用于问题回答的文本和问题。它还用作使用特殊标记构建的序列的最后一个标记。

• pad_token（str，可选，默认为"<pad>"）— 用于填充的标记，例如在批处理不同长度的序列时。

• cls_token（str，可选，默认为"[CLS]"）— 分类器标记，用于进行序列分类（对整个序列进行分类，而不是对每个标记进行分类）。在使用特殊标记构建时，它是序列的第一个标记。

• mask_token（str，可选，默认为"[MASK]"）— 用于屏蔽值的标记。这是在使用掩码语言建模训练此模型时使用的标记。这是模型将尝试预测的标记。

构建一个“快速”FNetTokenizer（由 HuggingFace 的tokenizers库支持）。改编自 AlbertTokenizerFast。基于Unigram。此标记器继承自 PreTrainedTokenizerFast，其中包含大多数主要方法。用户应参考此超类以获取有关这些方法的更多信息

build_inputs_with_special_tokens

<来源>

( token_ids_0: List token_ids_1: Optional = None ) → export const metadata = 'undefined';List[int]

参数

• token_ids_0（List[int]）— 要添加特殊标记的 ID 列表

• token_ids_1（List[int]，可选）— 序列对的可选第二个 ID 列表。

返回

List[int]

具有适当特殊标记的 input IDs 列表。

从序列或序列对构建模型输入，用于序列分类任务，通过连接和添加特殊标记。一个 FNet 序列具有以下格式：

• 单个序列：[CLS] X [SEP]

• 序列对：[CLS] A [SEP] B [SEP]

create_token_type_ids_from_sequences

<来源>

( token_ids_0: List token_ids_1: Optional = None ) → export const metadata = 'undefined';List[int]

参数

• token_ids_0（List[int]）— ID 列表。

• token_ids_1（List[int]，可选）— 序列对的可选第二个 ID 列表。

返回

List[int]

根据给定序列的标记类型 ID 列表。

从传递的两个序列创建一个用于序列对分类任务的掩码。一个 FNet

序列对掩码具有以下格式：

0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1 1
| first sequence    | second sequence |

如果 token_ids_1 为 None，则仅返回掩码的第一部分（0s）。

FNetModel

class transformers.FNetModel

<来源>

( config add_pooling_layer = True )

参数

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

裸 FNet 模型变压器输出原始隐藏状态，没有特定的顶部头。该模型是 PyTorch torch.nn.Module 子类。将其用作常规 PyTorch 模块，并参考 PyTorch 文档以获取有关一般用法和行为的所有相关信息。

该模型可以作为编码器运行，遵循 FNet: Mixing Tokens with Fourier Transforms 中描述的架构，作者为 James Lee-Thorp, Joshua Ainslie, Ilya Eckstein, Santiago Ontanon。

forward

< source >

( input_ids: Optional = None token_type_ids: Optional = None position_ids: Optional = None inputs_embeds: Optional = None output_hidden_states: Optional = None return_dict: Optional = None ) → export const metadata = 'undefined';transformers.modeling_outputs.BaseModelOutput or tuple(torch.FloatTensor)

参数

• input_ids (torch.LongTensor of shape (batch_size, sequence_length)) — 词汇表中输入序列标记的索引。

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

  什么是输入 ID？

• token_type_ids (torch.LongTensor of shape (batch_size, sequence_length), optional) — 段标记索引，指示输入的第一部分和第二部分。索引选择在 [0, 1] 中：

  • 0 对应于 句子 A 标记，

  • 1 对应于 句子 B 标记。

  什么是令牌类型 ID？

• position_ids (torch.LongTensor of shape (batch_size, sequence_length), optional) — 每个输入序列标记在位置嵌入中的位置索引。在范围 [0, config.max_position_embeddings - 1] 中选择。

  什么是位置 ID？

• inputs_embeds (torch.FloatTensor of shape (batch_size, sequence_length, hidden_size), optional) — 可选地，可以直接传递嵌入表示，而不是传递 input_ids。如果您想要更多控制如何将 input_ids 索引转换为相关向量，这将很有用，而不是使用模型的内部嵌入查找矩阵。

• output_hidden_states (bool, optional) — 是否返回所有层的隐藏状态。有关更多详细信息，请查看返回张量下的 hidden_states。

• return_dict (bool, optional) — 是否返回 ModelOutput 而不是普通元组。

返回值

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

一个 transformers.modeling_outputs.BaseModelOutput 或一个 torch.FloatTensor 元组（如果传递了 return_dict=False 或 config.return_dict=False 时）包含不同元素，具体取决于配置（FNetConfig）和输入。

• last_hidden_state (torch.FloatTensor of shape (batch_size, sequence_length, hidden_size)) — 模型最后一层的隐藏状态序列。

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

FNetModel 前向方法，覆盖了__call__特殊方法。

虽然前向传递的配方需要在此函数内定义，但应该在此之后调用Module实例，而不是这个，因为前者负责运行预处理和后处理步骤，而后者则默默地忽略它们。

示例：

>>> from transformers import AutoTokenizer, FNetModel
>>> import torch

>>> tokenizer = AutoTokenizer.from_pretrained("google/fnet-base")
>>> model = FNetModel.from_pretrained("google/fnet-base")

>>> inputs = tokenizer("Hello, my dog is cute", return_tensors="pt")
>>> outputs = model(**inputs)

>>> last_hidden_states = outputs.last_hidden_state

FNetForPreTraining

class transformers.FNetForPreTraining

<来源>

( config )

参数

• config（FNetConfig）— 具有模型所有参数的模型配置类。使用配置文件初始化不会加载与模型相关的权重，只加载配置。查看 from_pretrained()方法以加载模型权重。

FNet 模型在预训练期间在顶部有两个头部：一个掩码语言建模头部和一个下一个句子预测（分类）头部。

这个模型是一个 PyTorch torch.nn.Module子类。将其用作常规的 PyTorch 模块，并参考 PyTorch 文档以获取有关一般用法和行为的所有相关信息。

前进

<来源>

( input_ids: Optional = None token_type_ids: Optional = None position_ids: Optional = None inputs_embeds: Optional = None labels: Optional = None next_sentence_label: Optional = None output_hidden_states: Optional = None return_dict: Optional = None ) → export const metadata = 'undefined';transformers.models.fnet.modeling_fnet.FNetForPreTrainingOutput or tuple(torch.FloatTensor)

参数

• input_ids（形状为(batch_size, sequence_length)的torch.LongTensor）— 词汇表中输入序列标记的索引。

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

  什么是输入 ID？

• token_type_ids（形状为(batch_size, sequence_length)的torch.LongTensor，可选）— 段标记索引，用于指示输入的第一部分和第二部分。索引在[0, 1]中选择：

  • 0 对应于句子 A标记，

  • 1 对应于句子 B标记。

  什么是标记类型 ID？

• position_ids（形状为(batch_size, sequence_length)的torch.LongTensor，可选）— 每个输入序列标记的位置的索引在位置嵌入中。在范围[0, config.max_position_embeddings - 1]中选择。

  什么是位置 ID？

• inputs_embeds（形状为(batch_size, sequence_length, hidden_size)的torch.FloatTensor，可选）— 可选地，您可以直接传递一个嵌入表示，而不是传递input_ids。如果您想要更多控制如何将input_ids索引转换为相关向量，而不是使用模型的内部嵌入查找矩阵，这是有用的。

• output_hidden_states（bool，可选）— 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回张量下的hidden_states。

• return_dict（bool，可选）— 是否返回一个 ModelOutput 而不是一个普通元组。

• 标签（torch.LongTensor，形状为(batch_size, sequence_length)，可选）— 用于计算掩码语言建模损失的标签。索引应在[-100, 0, ..., config.vocab_size]范围内（参见input_ids文档字符串）。索引设置为-100的标记将被忽略（掩码），损失仅计算具有标签在[0, ..., config.vocab_size]范围内的标记。

• next_sentence_label（形状为(batch_size,)的torch.LongTensor，可选）— 用于计算下一个序列预测（分类）损失的标签。输入应为一个序列对（参见input_ids文档字符串）。索引应在[0, 1]范围内：

  • 0 表示序列 B 是序列 A 的延续，

  • 1 表示序列 B 是一个随机序列。

• kwargs（Dict[str, any]，可选，默认为{}）— 用于隐藏已弃用的旧参数。

返回

transformers.models.fnet.modeling_fnet.FNetForPreTrainingOutput或tuple(torch.FloatTensor)

一个transformers.models.fnet.modeling_fnet.FNetForPreTrainingOutput或一个torch.FloatTensor元组（如果传递return_dict=False或当config.return_dict=False时）包含根据配置（FNetConfig）和输入的各种元素。

• loss（可选，当提供labels时返回，形状为(1,)的torch.FloatTensor）— 总损失，作为掩码语言建模损失和下一个序列预测（分类）损失的总和。

• prediction_logits（形状为(batch_size, sequence_length, config.vocab_size)的torch.FloatTensor）— 语言建模头的预测分数（SoftMax 之前每个词汇标记的分数）。

• seq_relationship_logits（形状为(batch_size, 2)的torch.FloatTensor）— 下一个序列预测（分类）头的预测分数（SoftMax 之前的 True/False 延续分数）。

• hidden_states（tuple(torch.FloatTensor)，可选，当传递output_hidden_states=True或config.output_hidden_states=True时返回）— 形状为(batch_size, sequence_length, hidden_size)的torch.FloatTensor元组。模型在每一层输出的隐藏状态加上初始嵌入输出。

FNetForPreTraining 的前向方法，覆盖了__call__特殊方法。

虽然前向传递的步骤需要在此函数内定义，但应该在此之后调用Module实例，而不是在此处调用，因为前者负责运行预处理和后处理步骤，而后者则默默地忽略它们。

示例：

>>> from transformers import AutoTokenizer, FNetForPreTraining
>>> import torch

>>> tokenizer = AutoTokenizer.from_pretrained("google/fnet-base")
>>> model = FNetForPreTraining.from_pretrained("google/fnet-base")
>>> inputs = tokenizer("Hello, my dog is cute", return_tensors="pt")
>>> outputs = model(**inputs)
>>> prediction_logits = outputs.prediction_logits
>>> seq_relationship_logits = outputs.seq_relationship_logits

FNetForMaskedLM

class transformers.FNetForMaskedLM

<来源>

( config )

参数

• config（FNetConfig）— 具有模型所有参数的模型配置类。使用配置文件初始化不会加载与模型相关的权重，只会加载配置。查看 from_pretrained()方法以加载模型权重。

FNet 模型顶部带有语言建模头。此模型是 PyTorch torch.nn.Module子类。将其用作常规 PyTorch 模块，并参考 PyTorch 文档以获取与一般用法和行为相关的所有信息。

forward

< source >

( input_ids: Optional = None token_type_ids: Optional = None position_ids: Optional = None inputs_embeds: Optional = None labels: Optional = None output_hidden_states: Optional = None return_dict: Optional = None ) → export const metadata = 'undefined';transformers.modeling_outputs.MaskedLMOutput or tuple(torch.FloatTensor)

参数

• input_ids (torch.LongTensor of shape (batch_size, sequence_length)) — 词汇表中输入序列标记的索引。

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

  什么是输入 ID？

• token_type_ids (torch.LongTensor of shape (batch_size, sequence_length), optional) — 指示输入的第一部分和第二部分的段标记索引。索引在 [0, 1] 中选择：

  • 0 对应于 句子 A 标记，

  • 1 对应于 句子 B 标记。

  什么是标记类型 ID？

• position_ids (torch.LongTensor of shape (batch_size, sequence_length), optional) — 每个输入序列标记在位置嵌入中的位置索引。在范围 [0, config.max_position_embeddings - 1] 中选择。

  什么是位置 ID？

• inputs_embeds (torch.FloatTensor of shape (batch_size, sequence_length, hidden_size), optional) — 可选地，可以直接传递嵌入表示而不是 input_ids。如果您想要更多控制如何将 input_ids 索引转换为相关向量，这将非常有用，而不是使用模型的内部嵌入查找矩阵。

• output_hidden_states (bool, optional) — 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回张量下的 hidden_states。

• return_dict (bool, optional) — 是否返回 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.MaskedLMOutput 或 tuple(torch.FloatTensor)

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

• loss (torch.FloatTensor of shape (1,), optional, 当提供 labels 时返回) — 掩码语言建模（MLM）损失。

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

• hidden_states (tuple(torch.FloatTensor), optional, 当传递 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元组（每层一个）。

  在自注意力头中用于计算加权平均值的注意力权重。

FNetForMaskedLM 的前向方法，覆盖了__call__特殊方法。

虽然前向传递的方法需要在此函数内定义，但应该在此之后调用Module实例，而不是在此处调用，因为前者负责运行预处理和后处理步骤，而后者会默默地忽略它们。

示例：

>>> from transformers import AutoTokenizer, FNetForMaskedLM
>>> import torch

>>> tokenizer = AutoTokenizer.from_pretrained("google/fnet-base")
>>> model = FNetForMaskedLM.from_pretrained("google/fnet-base")

>>> inputs = tokenizer("The capital of France is [MASK].", return_tensors="pt")

>>> with torch.no_grad():
...     logits = model(**inputs).logits

>>> # retrieve index of [MASK]
>>> mask_token_index = (inputs.input_ids == tokenizer.mask_token_id)[0].nonzero(as_tuple=True)[0]

>>> predicted_token_id = logits[0, mask_token_index].argmax(axis=-1)

>>> labels = tokenizer("The capital of France is Paris.", return_tensors="pt")["input_ids"]
>>> # mask labels of non-[MASK] tokens
>>> labels = torch.where(inputs.input_ids == tokenizer.mask_token_id, labels, -100)

>>> outputs = model(**inputs, labels=labels)

FNetForNextSentencePrediction

class transformers.FNetForNextSentencePrediction

< source >

( config )

参数

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

带有下一个句子预测（分类）头部的 FNet 模型。此模型是 PyTorch torch.nn.Module子类。将其用作常规 PyTorch 模块，并参考 PyTorch 文档以获取与一般用法和行为相关的所有事项。

forward

< source >

( input_ids: Optional = None token_type_ids: Optional = None position_ids: Optional = None inputs_embeds: Optional = None labels: Optional = None output_hidden_states: Optional = None return_dict: Optional = None **kwargs ) → export const metadata = 'undefined';transformers.modeling_outputs.NextSentencePredictorOutput or tuple(torch.FloatTensor)

参数

• input_ids (torch.LongTensor of shape (batch_size, sequence_length)) — 输入序列标记在词汇表中的索引。

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

  什么是输入 ID？

• token_type_ids (torch.LongTensor of shape (batch_size, sequence_length), 可选) — 段标记索引，用于指示输入的第一部分和第二部分。索引选择在 [0, 1]：

  • 0 对应于 句子 A 标记，

  • 1 对应于 句子 B 标记。

  什么是标记类型 ID？

• position_ids (torch.LongTensor of shape (batch_size, sequence_length), 可选) — 每个输入序列标记在位置嵌入中的位置索引。选择范围为[0, config.max_position_embeddings - 1]。

  什么是位置 ID？

• inputs_embeds (torch.FloatTensor of shape (batch_size, sequence_length, hidden_size), 可选) — 可选地，可以直接传递嵌入表示而不是传递input_ids。如果您想要更多控制如何将input_ids索引转换为相关向量，这很有用，而不是使用模型的内部嵌入查找矩阵。

• output_hidden_states (bool, 可选) — 是否返回所有层的隐藏状态。有关更多详细信息，请查看返回张量下的hidden_states。

• return_dict (bool, 可选) — 是否返回一个 ModelOutput 而不是一个普通元组。

• labels (torch.LongTensor of shape (batch_size,), optional) — 用于计算下一个序列预测（分类）损失的标签。输入应该是一个序列对（参见input_ids文档字符串）。索引应该在[0, 1]范围内：

  • 0 表示序列 B 是序列 A 的延续，

  • 1 表示序列 B 是一个随机序列。

返回

transformers.modeling_outputs.NextSentencePredictorOutput 或torch.FloatTensor元组

一个 transformers.modeling_outputs.NextSentencePredictorOutput 或一个torch.FloatTensor元组（如果传递return_dict=False或config.return_dict=False时）包含根据配置（FNetConfig）和输入的各种元素。

• loss (torch.FloatTensor of shape (1,), optional, 当提供next_sentence_label时返回) — 下一个序列预测（分类）损失。

• logits (torch.FloatTensor of shape (batch_size, 2)) — 下一个序列预测（分类）头的预测分数（在 SoftMax 之前的 True/False 继续分数）。

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

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

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

  在注意力 softmax 之后的注意力权重，用于计算自注意力头中的加权平均值。

FNetForNextSentencePrediction 的前向方法，覆盖了__call__特殊方法。

虽然前向传递的步骤需要在此函数内定义，但应该在此之后调用Module实例，而不是这个，因为前者会负责运行前后处理步骤，而后者会默默地忽略它们。

示例：

>>> from transformers import AutoTokenizer, FNetForNextSentencePrediction
>>> import torch

>>> tokenizer = AutoTokenizer.from_pretrained("google/fnet-base")
>>> model = FNetForNextSentencePrediction.from_pretrained("google/fnet-base")
>>> prompt = "In Italy, pizza served in formal settings, such as at a restaurant, is presented unsliced."
>>> next_sentence = "The sky is blue due to the shorter wavelength of blue light."
>>> encoding = tokenizer(prompt, next_sentence, return_tensors="pt")
>>> outputs = model(**encoding, labels=torch.LongTensor([1]))
>>> logits = outputs.logits
>>> assert logits[0, 0] < logits[0, 1]  # next sentence was random

FNetForSequenceClassification

class transformers.FNetForSequenceClassification

<来源>

( config )

参数

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

FNet 模型变压器，顶部带有一个序列分类/回归头（在池化输出之上的线性层），例如用于 GLUE 任务。

这个模型是 PyTorch torch.nn.Module 的子类。将其用作常规的 PyTorch 模块，并参考 PyTorch 文档以获取与一般用法和行为相关的所有事项。

forward

<来源>

( input_ids: Optional = None token_type_ids: Optional = None position_ids: Optional = None inputs_embeds: Optional = None labels: Optional = None output_hidden_states: Optional = None return_dict: Optional = None ) → export const metadata = 'undefined';transformers.modeling_outputs.SequenceClassifierOutput or tuple(torch.FloatTensor)

参数

• input_ids (torch.LongTensor of shape (batch_size, sequence_length)) — 词汇表中输入序列标记的索引。

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

  什么是输入 ID？

• token_type_ids (torch.LongTensor，形状为(batch_size, sequence_length)，可选) — 段标记索引，用于指示输入的第一部分和第二部分。索引在[0, 1]中选择：

  • 0 对应于句子 A标记。

  • 1 对应于句子 B标记。

  什么是标记类型 ID？

• position_ids (torch.LongTensor，形状为(batch_size, sequence_length)，可选) — 每个输入序列标记在位置嵌入中的位置索引。在范围[0, config.max_position_embeddings - 1]中选择。

  什么是位置 ID？

• inputs_embeds (torch.FloatTensor，形状为(batch_size, sequence_length, hidden_size)，可选) — 可选地，您可以直接传递嵌入表示而不是传递input_ids。如果您想要更多控制如何将input_ids索引转换为相关向量，这是有用的，而不是使用模型的内部嵌入查找矩阵。

• output_hidden_states (bool, optional) — 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回张量中的hidden_states。

• return_dict (bool，可选) — 是否返回 ModelOutput 而不是普通元组。

• labels (torch.LongTensor，形状为(batch_size,)，可选) — 用于计算序列分类/回归损失的标签。索引应在[0, ..., config.num_labels - 1]中。如果config.num_labels == 1，则计算回归损失（均方损失），如果config.num_labels > 1，则计算分类损失（交叉熵）。

返回

transformers.modeling_outputs.SequenceClassifierOutput 或torch.FloatTensor元组

一个 transformers.modeling_outputs.SequenceClassifierOutput 或torch.FloatTensor元组（如果传递return_dict=False或config.return_dict=False）包含根据配置（FNetConfig）和输入的各种元素。

• 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时返回） — 形状为(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 之后的注意力权重，用于计算自注意力头中的加权平均值。

FNetForSequenceClassification 的前向方法，覆盖了__call__特殊方法。

虽然前向传递的配方需要在此函数内定义，但应该在此之后调用Module实例，而不是这个，因为前者负责运行预处理和后处理步骤，而后者则默默地忽略它们。

单标签分类示例：

>>> import torch
>>> from transformers import AutoTokenizer, FNetForSequenceClassification

>>> tokenizer = AutoTokenizer.from_pretrained("google/fnet-base")
>>> model = FNetForSequenceClassification.from_pretrained("google/fnet-base")

>>> inputs = tokenizer("Hello, my dog is cute", return_tensors="pt")

>>> with torch.no_grad():
...     logits = model(**inputs).logits

>>> predicted_class_id = logits.argmax().item()

>>> # To train a model on `num_labels` classes, you can pass `num_labels=num_labels` to `.from_pretrained(...)`
>>> num_labels = len(model.config.id2label)
>>> model = FNetForSequenceClassification.from_pretrained("google/fnet-base", num_labels=num_labels)

>>> labels = torch.tensor([1])
>>> loss = model(**inputs, labels=labels).loss

多标签分类示例：

>>> import torch
>>> from transformers import AutoTokenizer, FNetForSequenceClassification

>>> tokenizer = AutoTokenizer.from_pretrained("google/fnet-base")
>>> model = FNetForSequenceClassification.from_pretrained("google/fnet-base", problem_type="multi_label_classification")

>>> inputs = tokenizer("Hello, my dog is cute", return_tensors="pt")

>>> with torch.no_grad():
...     logits = model(**inputs).logits

>>> predicted_class_ids = torch.arange(0, logits.shape[-1])[torch.sigmoid(logits).squeeze(dim=0) > 0.5]

>>> # To train a model on `num_labels` classes, you can pass `num_labels=num_labels` to `.from_pretrained(...)`
>>> num_labels = len(model.config.id2label)
>>> model = FNetForSequenceClassification.from_pretrained(
...     "google/fnet-base", num_labels=num_labels, problem_type="multi_label_classification"
... )

>>> labels = torch.sum(
...     torch.nn.functional.one_hot(predicted_class_ids[None, :].clone(), num_classes=num_labels), dim=1
... ).to(torch.float)
>>> loss = model(**inputs, labels=labels).loss

FNetForMultipleChoice

class transformers.FNetForMultipleChoice

<来源>

( config )

参数

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

在顶部具有多项选择分类头部的 FNet 模型（在池化输出的顶部有一个线性层和一个 softmax），例如用于 RocStories/SWAG 任务。

此模型是 PyTorch torch.nn.Module子类。将其用作常规 PyTorch 模块，并参考 PyTorch 文档以获取有关一般用法和行为的所有相关信息。

forward

<来源>

( input_ids: Optional = None token_type_ids: Optional = None position_ids: Optional = None inputs_embeds: Optional = None labels: Optional = None output_hidden_states: Optional = None return_dict: Optional = None ) → export const metadata = 'undefined';transformers.modeling_outputs.MultipleChoiceModelOutput or tuple(torch.FloatTensor)

参数

• input_ids (torch.LongTensor，形状为(batch_size, num_choices, sequence_length)) — 词汇表中输入序列标记的索引。

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

  输入 ID 是什么？

• token_type_ids (torch.LongTensor，形状为(batch_size, num_choices, sequence_length)，可选) — 段标记索引，指示输入的第一部分和第二部分。索引在[0, 1]中选择：

  • 0 对应于句子 A的标记，

  • 1 对应于句子 B的标记。

  令牌类型 ID 是什么？

• position_ids (torch.LongTensor，形状为(batch_size, num_choices, sequence_length)，可选) — 每个输入序列标记在位置嵌入中的位置索引。在范围[0, config.max_position_embeddings - 1]中选择。

  位置 ID 是什么？

• inputs_embeds (torch.FloatTensor，形状为(batch_size, num_choices, sequence_length, hidden_size)，可选) — 可选地，您可以选择直接传递嵌入表示，而不是传递input_ids。如果您想要更多控制如何将input_ids索引转换为相关向量，这将很有用，而不是使用模型的内部嵌入查找矩阵。

• output_hidden_states (bool, 可选) — 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回张量下的hidden_states。

• return_dict (bool, 可选) — 是否返回一个 ModelOutput 而不是一个普通元组。

• labels (torch.LongTensor，形状为(batch_size,)，可选) — 用于计算多项选择分类损失的标签。索引应在[0, ..., num_choices-1]范围内，其中num_choices是输入张量第二维的大小。 (参见上面的input_ids)

返回

transformers.modeling_outputs.MultipleChoiceModelOutput 或torch.FloatTensor元组

一个 transformers.modeling_outputs.MultipleChoiceModelOutput 或一个torch.FloatTensor元组（如果传递return_dict=False或当config.return_dict=False时）包含各种元素，取决于配置（FNetConfig）和输入。

• loss (torch.FloatTensor，形状为(1,)，可选*，当提供labels时返回) — 分类损失。

• logits (torch.FloatTensor，形状为(batch_size, num_choices)) — num_choices是输入张量的第二维。(参见上面的input_ids)。

  分类得分（SoftMax 之前）。

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

FNetForMultipleChoice 的前向方法，覆盖了__call__特殊方法。

虽然前向传递的方法需要在这个函数内定义，但应该在此之后调用Module实例，而不是在此处调用，因为前者会负责运行前后处理步骤，而后者会默默地忽略它们。

示例：

>>> from transformers import AutoTokenizer, FNetForMultipleChoice
>>> import torch

>>> tokenizer = AutoTokenizer.from_pretrained("google/fnet-base")
>>> model = FNetForMultipleChoice.from_pretrained("google/fnet-base")

>>> prompt = "In Italy, pizza served in formal settings, such as at a restaurant, is presented unsliced."
>>> choice0 = "It is eaten with a fork and a knife."
>>> choice1 = "It is eaten while held in the hand."
>>> labels = torch.tensor(0).unsqueeze(0)  # choice0 is correct (according to Wikipedia ;)), batch size 1

>>> encoding = tokenizer([prompt, prompt], [choice0, choice1], return_tensors="pt", padding=True)
>>> outputs = model(**{k: v.unsqueeze(0) for k, v in encoding.items()}, labels=labels)  # batch size is 1

>>> # the linear classifier still needs to be trained
>>> loss = outputs.loss
>>> logits = outputs.logits

FNetForTokenClassification

class transformers.FNetForTokenClassification

<来源>

( config )

参数

• config（FNetConfig） — 具有模型所有参数的模型配置类。使用配置文件初始化不会加载与模型相关的权重，只会加载配置。查看 from_pretrained()方法以加载模型权重。

FNet 模型在顶部带有一个标记分类头（隐藏状态输出的线性层），例如用于命名实体识别（NER）任务。

这个模型是 PyTorch torch.nn.Module子类。将其用作常规的 PyTorch 模块，并参考 PyTorch 文档以获取有关一般用法和行为的所有信息。

forward

<来源>

( input_ids: Optional = None token_type_ids: Optional = None position_ids: Optional = None inputs_embeds: Optional = None labels: Optional = None output_hidden_states: Optional = None return_dict: Optional = None ) → export const metadata = 'undefined';transformers.modeling_outputs.TokenClassifierOutput or tuple(torch.FloatTensor)

参数

• input_ids (torch.LongTensor，形状为(batch_size, sequence_length)) — 词汇表中输入序列标记的索引。

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

  什么是输入 ID？

• token_type_ids（形状为(batch_size, sequence_length)的torch.LongTensor，可选）- 段标记索引，指示输入的第一部分和第二部分。索引在[0, 1]中选择：

  • 0 对应于句子 A的标记，

  • 1 对应于句子 B的标记。

  什么是标记类型 ID？

• position_ids（形状为(batch_size, sequence_length)的torch.LongTensor，可选）- 每个输入序列标记在位置嵌入中的位置索引。在范围[0, config.max_position_embeddings - 1]中选择。

  什么是位置 ID？

• inputs_embeds（torch.FloatTensor，形状为(batch_size, sequence_length, hidden_size)，可选）- 可选地，您可以选择直接传递嵌入表示，而不是传递input_ids。如果您想要更多控制权，以便将input_ids索引转换为相关向量，而不是模型的内部嵌入查找矩阵。

• output_hidden_states（bool，可选）- 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回张量下的hidden_states。

• return_dict（bool，可选）- 是否返回 ModelOutput 而不是普通元组。

• labels（形状为(batch_size, sequence_length)的torch.LongTensor，可选）- 用于计算标记分类损失的标签。索引应在[0, ..., config.num_labels - 1]中。

返回

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

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

• loss（形状为(1,)的torch.FloatTensor，可选，当提供labels时返回）- 分类损失。

• logits（形状为(batch_size, sequence_length, config.num_labels)的torch.FloatTensor）- 分类分数（SoftMax 之前）。

• 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元组（每层一个）。

  在自注意力头中用于计算加权平均值的注意力权重。

FNetForTokenClassification 的前向方法，覆盖了__call__特殊方法。

虽然前向传递的步骤需要在此函数内定义，但应该在此之后调用Module实例，而不是在此处调用，因为前者负责运行预处理和后处理步骤，而后者会默默地忽略它们。

示例：

>>> from transformers import AutoTokenizer, FNetForTokenClassification
>>> import torch

>>> tokenizer = AutoTokenizer.from_pretrained("google/fnet-base")
>>> model = FNetForTokenClassification.from_pretrained("google/fnet-base")

>>> inputs = tokenizer(
...     "HuggingFace is a company based in Paris and New York", add_special_tokens=False, return_tensors="pt"
... )

>>> with torch.no_grad():
...     logits = model(**inputs).logits

>>> predicted_token_class_ids = logits.argmax(-1)

>>> # Note that tokens are classified rather then input words which means that
>>> # there might be more predicted token classes than words.
>>> # Multiple token classes might account for the same word
>>> predicted_tokens_classes = [model.config.id2label[t.item()] for t in predicted_token_class_ids[0]]

>>> labels = predicted_token_class_ids
>>> loss = model(**inputs, labels=labels).loss

FNetForQuestionAnswering

class transformers.FNetForQuestionAnswering

<来源>

( config )

参数

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

FNet 模型，顶部带有一个用于提取式问答任务（如 SQuAD）的跨度分类头（在隐藏状态输出顶部的线性层，用于计算span start logits和span end logits）。

此模型是 PyTorch torch.nn.Module子类。将其用作常规 PyTorch 模块，并参考 PyTorch 文档以获取有关一般用法和行为的所有相关信息。

forward

<来源>

( input_ids: Optional = None token_type_ids: Optional = None position_ids: Optional = None inputs_embeds: Optional = None start_positions: Optional = None end_positions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None ) → export const metadata = 'undefined';transformers.modeling_outputs.QuestionAnsweringModelOutput or tuple(torch.FloatTensor)

参数

• input_ids（形状为(batch_size, sequence_length)的torch.LongTensor）— 词汇表中输入序列令牌的索引。

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

  什么是输入 ID？

• token_type_ids（形状为(batch_size, sequence_length)的torch.LongTensor，可选）— 段令牌索引，指示输入的第一部分和第二部分。索引在[0, 1]中选择：

  • 0 对应于句子 A令牌，

  • 1 对应于句子 B令牌。

  什么是令牌类型 ID？

• position_ids（形状为(batch_size, sequence_length)的torch.LongTensor，可选）— 每个输入序列令牌在位置嵌入中的位置索引。在范围[0, config.max_position_embeddings - 1]中选择。

  什么是位置 ID？

• inputs_embeds（形状为(batch_size, sequence_length, hidden_size)的torch.FloatTensor，可选）— 可选地，您可以选择直接传递嵌入表示而不是传递input_ids。如果您想要更多控制如何将input_ids索引转换为关联向量，而不是使用模型的内部嵌入查找矩阵，则这很有用。

• output_hidden_states（bool，可选）— 是否返回所有层的隐藏状态。有关更多详细信息，请查看返回张量下的hidden_states。

• return_dict（bool，可选）— 是否返回 ModelOutput 而不是普通元组。

• start_positions（形状为(batch_size,)的torch.LongTensor，可选）— 用于计算令牌分类损失的标记跨度开始位置（索引）的标签。位置被夹紧到序列的长度（sequence_length）。超出序列范围的位置不会计入损失计算。

• end_positions（形状为(batch_size,)的torch.LongTensor，可选）— 用于计算令牌分类损失的标记跨度结束位置（索引）的标签。位置被夹紧到序列的长度（sequence_length）。超出序列范围的位置不会计入损失计算。

返回

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

一个 transformers.modeling_outputs.QuestionAnsweringModelOutput 或一个 torch.FloatTensor 元组（如果传入 return_dict=False 或当 config.return_dict=False 时）包括各种元素，取决于配置（FNetConfig）和输入。

• loss (torch.FloatTensor，形状为 (1,)，可选，当提供 labels 时返回) — 总跨度提取损失是开始和结束位置的交叉熵之和。

• start_logits (torch.FloatTensor，形状为 (batch_size, sequence_length)) — 跨度开始得分（SoftMax 之前）。

• end_logits (torch.FloatTensor，形状为 (batch_size, sequence_length)) — 跨度结束得分（SoftMax 之前）。

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

FNetForQuestionAnswering 的前向方法，覆盖了 __call__ 特殊方法。

虽然前向传递的步骤需要在这个函数内定义，但应该在此之后调用 Module 实例，而不是这个，因为前者负责运行预处理和后处理步骤，而后者会默默地忽略它们。

示例：

>>> from transformers import AutoTokenizer, FNetForQuestionAnswering
>>> import torch

>>> tokenizer = AutoTokenizer.from_pretrained("google/fnet-base")
>>> model = FNetForQuestionAnswering.from_pretrained("google/fnet-base")

>>> question, text = "Who was Jim Henson?", "Jim Henson was a nice puppet"

>>> inputs = tokenizer(question, text, return_tensors="pt")
>>> with torch.no_grad():
...     outputs = model(**inputs)

>>> answer_start_index = outputs.start_logits.argmax()
>>> answer_end_index = outputs.end_logits.argmax()

>>> predict_answer_tokens = inputs.input_ids[0, answer_start_index : answer_end_index + 1]

>>> # target is "nice puppet"
>>> target_start_index = torch.tensor([14])
>>> target_end_index = torch.tensor([15])

>>> outputs = model(**inputs, start_positions=target_start_index, end_positions=target_end_index)
>>> loss = outputs.loss

FSMT

原文链接：huggingface.co/docs/transformers/v4.37.2/en/model_doc/fsmt

概述

FSMT（FairSeq MachineTranslation）模型由 Nathan Ng、Kyra Yee、Alexei Baevski、Myle Ott、Michael Auli、Sergey Edunov 在Facebook FAIR 的 WMT19 新闻翻译任务提交中介绍。

该论文的摘要如下：

本文描述了 Facebook FAIR 在 WMT19 共享新闻翻译任务中的提交。我们参与了两种语言对和四种语言方向，英语<->德语和英语<->俄语。继续我们去年的提交，我们的基线系统是使用 Fairseq 序列建模工具训练的大型基于 BPE 的变压器模型，依赖于采样的回译。今年我们尝试了不同的双语数据过滤方案，以及添加过滤后的回译数据。我们还对领域特定数据进行集成和微调，然后使用嘈杂通道模型重新排序解码。我们的提交在人类评估活动的所有四个方向中排名第一。在 En->De 方向上，我们的系统明显优于其他系统以及人类翻译。这个系统比我们的 WMT’18 提交提高了 4.5 个 BLEU 分数。

这个模型是由stas贡献的。原始代码可以在这里找到。

实现说明

• FSMT 使用未合并为一个的源和目标词汇对。它也不共享嵌入标记。其分词器非常类似于 XLMTokenizer，主要模型源自 BartModel。

FSMTConfig

class transformers.FSMTConfig

< source >

( langs = ['en', 'de'] src_vocab_size = 42024 tgt_vocab_size = 42024 activation_function = 'relu' d_model = 1024 max_length = 200 max_position_embeddings = 1024 encoder_ffn_dim = 4096 encoder_layers = 12 encoder_attention_heads = 16 encoder_layerdrop = 0.0 decoder_ffn_dim = 4096 decoder_layers = 12 decoder_attention_heads = 16 decoder_layerdrop = 0.0 attention_dropout = 0.0 dropout = 0.1 activation_dropout = 0.0 init_std = 0.02 decoder_start_token_id = 2 is_encoder_decoder = True scale_embedding = True tie_word_embeddings = False num_beams = 5 length_penalty = 1.0 early_stopping = False use_cache = True pad_token_id = 1 bos_token_id = 0 eos_token_id = 2 forced_eos_token_id = 2 **common_kwargs )

参数

• langs (List[str]) — 包含源语言和目标语言的列表（例如，[‘en’, ‘ru’]）。

• src_vocab_size (int) — 编码器的词汇表大小。定义了可以由传递给编码器前向方法的inputs_ids表示的不同标记的数量。

• tgt_vocab_size (int) — 解码器的词汇表大小。定义了可以由传递给解码器前向方法的inputs_ids表示的不同标记的数量。

• d_model (int, optional, defaults to 1024) — 层和池化器层的维度。

• encoder_layers (int, optional, defaults to 12) — 编码器层数。

• decoder_layers (int, optional, defaults to 12) — 解码器层数。

• encoder_attention_heads (int, optional, defaults to 16) — 变压器编码器中每个注意力层的注意力头数。

• decoder_attention_heads (int, optional, defaults to 16) — 变压器解码器中每个注意力层的注意力头数。

• decoder_ffn_dim (int, optional, defaults to 4096) — 解码器中“中间”（通常称为前馈）层的维度。

• encoder_ffn_dim (int, optional, defaults to 4096) — 解码器中“中间”（通常称为前馈）层的维度。

• activation_function (str or Callable, optional, defaults to "relu") — 编码器和池化器中的非线性激活函数（函数或字符串）。如果是字符串，支持"gelu"、"relu"、"silu"和"gelu_new"。

• dropout (float, optional, defaults to 0.1) — 嵌入、编码器和池化器中所有完全连接层的丢失概率。

• attention_dropout (float, optional, defaults to 0.0) — 注意力概率的丢失比率。

• activation_dropout (float, optional, defaults to 0.0) — 完全连接层内激活的丢失比率。

• max_position_embeddings (int, optional, defaults to 1024) — 此模型可能使用的最大序列长度。通常将其设置为较大的值以防万一（例如 512、1024 或 2048）。

• init_std (float, optional, defaults to 0.02) — 用于初始化所有权重矩阵的截断正态初始化器的标准差。

• scale_embedding (bool, optional, defaults to True) — 通过除以 sqrt(d_model)来缩放嵌入。

• bos_token_id (int, optional, defaults to 0) — 流的开始标记 id。

• pad_token_id (int, optional, defaults to 1) — 填充标记 id。

• eos_token_id (int, optional, defaults to 2) — 流的结束标记 id。

• decoder_start_token_id (int, optional) — 此模型从eos_token_id开始解码。

• encoder_layerdrop (float, optional, defaults to 0.0) — 谷歌“layerdrop arxiv”，因为无法用一行解释。

• decoder_layerdrop (float, optional, defaults to 0.0) — 谷歌“layerdrop arxiv”，因为无法用一行解释。

• is_encoder_decoder (bool, optional, defaults to True) — 是否这是一个编码器/解码器模型。

• tie_word_embeddings (bool, optional, defaults to False) — 是否绑定输入和输出嵌入。

• num_beams (int, optional, defaults to 5) — 在模型的generate方法中默认使用的 beam 搜索的数量。1 表示没有 beam 搜索。

• length_penalty (float, optional, defaults to 1) — 用于基于 beam 的生成的长度的指数惩罚。它作为序列长度的指数应用，进而用于将序列的分数除以。由于分数是序列的对数似然（即负数），length_penalty > 0.0 促进更长的序列，而 length_penalty < 0.0 鼓励更短的序列。

• early_stopping (bool, optional, defaults to False) — 默认情况下在模型的generate方法中使用的标志。是否在每个批次至少完成num_beams个句子时停止 beam search 或不停止。

• use_cache (bool, optional, defaults to True) — 模型是否应返回最后的键/值注意力（并非所有模型都使用）。

• forced_eos_token_id (int, optional, defaults to 2) — 当达到max_length时强制作为最后生成的标记的标记 id。通常设置为eos_token_id。

这是一个配置类，用于存储 FSMTModel 的配置。根据指定的参数实例化一个 FSMT 模型，定义模型架构。使用默认值实例化配置将产生类似于 FSMT facebook/wmt19-en-ru架构的配置。

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

示例：

>>> from transformers import FSMTConfig, FSMTModel

>>> # Initializing a FSMT facebook/wmt19-en-ru style configuration
>>> config = FSMTConfig()

>>> # Initializing a model (with random weights) from the configuration
>>> model = FSMTModel(config)

>>> # Accessing the model configuration
>>> configuration = model.config

FSMTTokenizer

class transformers.FSMTTokenizer

< source >

( langs = None src_vocab_file = None tgt_vocab_file = None merges_file = None do_lower_case = False unk_token = '<unk>' bos_token = '<s>' sep_token = '</s>' pad_token = '<pad>' **kwargs )

参数

• langs (List[str], optional) — 要从中翻译的两种语言的列表，例如["en", "ru"]。

• src_vocab_file (str, optional) — 包含源语言词汇的文件。

• tgt_vocab_file (st, optional) — 包含目标语言词汇的文件。

• merges_file (str, optional) — 包含合并的文件。

• do_lower_case (bool, optional, defaults to False) — 在标记化时是否将输入转换为小写。

• unk_token（str，可选，默认为"<unk>"） - 未知标记。词汇表中没有的标记无法转换为 ID，而是设置为此标记。

• bos_token（str，可选，默认为"<s>"） - 在预训练期间使用的序列开始标记。可以用作序列分类器标记。

  在使用特殊标记构建序列时，这不是用于序列开始的标记。使用的标记是cls_token。

• sep_token（str，可选，默认为"</s>"） - 分隔符标记，在从多个序列构建序列时使用，例如用于序列分类的两个序列或用于文本和问题的问题回答。它也用作使用特殊标记构建的序列的最后一个标记。

• pad_token（str，可选，默认为"<pad>"） - 用于填充的标记，例如在批处理不同长度的序列时使用。

构建一个 FAIRSEQ Transformer 分词器。基于字节对编码。分词过程如下：

• 摩西预处理和标记化。

• 规范化所有输入文本。

• 参数special_tokens和函数set_special_tokens可以用于向词汇表添加额外的符号（如"classify"）。

• 参数langs定义了一对语言。

这个分词器继承自 PreTrainedTokenizer，其中包含大部分主要方法。用户应参考这个超类以获取有关这些方法的更多信息。

build_inputs_with_special_tokens

<来源>

( token_ids_0: List token_ids_1: Optional = None ) → export const metadata = 'undefined';List[int]

参数

• token_ids_0（List[int]） - 将添加特殊标记的 ID 列表。

• token_ids_1（List[int]，可选） - 序列对的可选第二个 ID 列表。

返回

List[int]

具有适当特殊标记的输入 ID 列表。

通过连接和添加特殊标记，从序列或序列对构建用于序列分类任务的模型输入。FAIRSEQ Transformer 序列具有以下格式：

• 单个序列：<s> X </s>

• 序列对：<s> A </s> B </s>

get_special_tokens_mask

<来源>

( token_ids_0: List token_ids_1: Optional = None already_has_special_tokens: bool = False ) → export const metadata = 'undefined';List[int]

参数

• token_ids_0（List[int]） - ID 列表。

• token_ids_1（List[int]，可选） - 序列对的可选第二个 ID 列表。

• already_has_special_tokens（bool，可选，默认为False） - 标记列表是否已经使用模型的特殊标记格式化。

返回

List[int]

一个整数列表，范围为[0, 1]：1 表示特殊标记，0 表示序列标记。

从没有添加特殊标记的标记列表中检索序列 ID。当使用分词器的prepare_for_model方法添加特殊标记时，将调用此方法。

create_token_type_ids_from_sequences

<来源>

( token_ids_0: List token_ids_1: Optional = None ) → export const metadata = 'undefined';List[int]

参数

• token_ids_0（List[int]） - ID 列表。

• token_ids_1（List[int]，可选） - 序列对的可选第二个 ID 列表。

返回

List[int]

根据给定序列的标记类型 ID 列表。

从传递的两个序列创建一个用于序列对分类任务的掩码。一个 FAIRSEQ

Transformer 序列对掩码具有以下格式：

0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1 1
| first sequence    | second sequence |

如果token_ids_1为None，则此方法仅返回掩码的第一部分（0）。

从传递的两个序列创建一个用于序列对分类任务的掩码。一个 FAIRSEQ_TRANSFORMER 序列对掩码具有以下格式：

save_vocabulary

<来源>

( save_directory: str filename_prefix: Optional = None )

FSMTModel

class transformers.FSMTModel

<来源>

( config: FSMTConfig )

参数

• config（FSMTConfig）- 具有模型所有参数的模型配置类。使用配置文件初始化不会加载与模型关联的权重，只加载配置。查看 from_pretrained()方法以加载模型权重。

裸的 FSMT 模型输出原始隐藏状态，没有特定的头部在顶部。

此模型继承自 PreTrainedModel。检查超类文档，了解库为其所有模型实现的通用方法（如下载或保存、调整输入嵌入、修剪头等）。

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

前向

<来源>

( input_ids: LongTensor attention_mask: Optional = None decoder_input_ids: Optional = None decoder_attention_mask: Optional = None head_mask: Optional = None decoder_head_mask: Optional = None cross_attn_head_mask: Optional = None encoder_outputs: Optional = None past_key_values: Optional = None use_cache: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None inputs_embeds: Optional = None decoder_inputs_embeds: Optional = None return_dict: Optional = None ) → export const metadata = 'undefined';transformers.modeling_outputs.Seq2SeqModelOutput or tuple(torch.FloatTensor)

参数

• input_ids（形状为(batch_size, sequence_length)的torch.LongTensor）- 词汇表中输入序列标记的索引。

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

  什么是输入标识？

• attention_mask（形状为(batch_size, sequence_length)的torch.Tensor，可选）- 避免在填充标记索引上执行注意力的掩码。选择的掩码值在[0, 1]中：

  • 对于未屏蔽的标记，

  • 0 表示标记为屏蔽。

  什么是注意力掩码？

• decoder_input_ids（形状为(batch_size, target_sequence_length)的torch.LongTensor，可选）- 词汇表中解码器输入序列标记的索引。

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

  什么是 decoder input IDs?

  FSMT 使用eos_token_id作为decoder_input_ids生成的起始标记。如果使用past_key_values，则可选择仅输入最后的decoder_input_ids（请参阅past_key_values）。

• decoder_attention_mask（形状为(batch_size, target_sequence_length)的torch.BoolTensor，可选）- 默认行为：生成一个张量，忽略decoder_input_ids中的填充标记。因果屏蔽也将默认使用。

• head_mask（形状为(encoder_layers, encoder_attention_heads)的torch.Tensor，可选）- 在编码器中使选定的注意力模块的头部无效的掩码。选择的掩码值在[0, 1]中：

  • 1 表示头部未被屏蔽,

  • 0 表示头部被屏蔽。

• decoder_head_mask（形状为(decoder_layers, decoder_attention_heads)的torch.Tensor，可选）- 在解码器中使选定的注意力模块的头部无效的掩码。选择的掩码值在[0, 1]中：

  • 1 表示头部未被屏蔽,

  • 0 表示头部被屏蔽。

• cross_attn_head_mask（形状为(decoder_layers, decoder_attention_heads)的torch.Tensor，可选）— 用于在解码器中使交叉注意力模块中选择的头部失效的掩码。掩码值选在[0, 1]中：

  • 1 表示头部未被masked，

  • 0 表示头部被masked。

• encoder_outputs（Tuple(torch.FloatTensor)，可选）— 元组包括（last_hidden_state，可选：hidden_states，可选：attentions）last_hidden_state的形状为(batch_size, sequence_length, hidden_size)，是编码器最后一层的隐藏状态序列。用于解码器的交叉注意力。

• past_key_values（长度为config.n_layers的Tuple(torch.FloatTensor)，每个元组有 4 个形状为(batch_size, num_heads, sequence_length - 1, embed_size_per_head)的张量）— 包含注意力块的预计算键和值隐藏状态。可用于加速解码。如果使用past_key_values，用户可以选择仅输入最后的decoder_input_ids（那些没有将它们的过去键值状态提供给此模型的）的形状为(batch_size, 1)，而不是形状为(batch_size, sequence_length)的所有decoder_input_ids。

• inputs_embeds（形状为(batch_size, sequence_length, hidden_size)的torch.FloatTensor，可选）— 可选地，可以直接传递嵌入表示，而不是传递input_ids。如果要更好地控制如何将input_ids索引转换为相关向量，而不是使用模型的内部嵌入查找矩阵，则这很有用。

• decoder_inputs_embeds（形状为(batch_size, target_sequence_length, hidden_size)的torch.FloatTensor，可选）— 可选地，可以直接传递嵌入表示，而不是传递decoder_input_ids。如果使用past_key_values，可以选择仅输入最后的decoder_inputs_embeds（参见past_key_values）。如果要更好地控制如何将decoder_input_ids索引转换为相关向量，而不是使用模型的内部嵌入查找矩阵，则这很有用。

  如果decoder_input_ids和decoder_inputs_embeds都未设置，则decoder_inputs_embeds取inputs_embeds的值。

• use_cache（bool，可选，默认为True）— 如果设置为True，则返回past_key_values键值状态，可用于加速解码（参见past_key_values）。

• output_attentions（bool，可选）— 是否返回所有注意力层的注意力张量。有关更多详细信息，请参阅返回张量下的attentions。

• output_hidden_states（bool，可选）— 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回张量下的hidden_states。

• return_dict（bool，可选）— 是否返回 ModelOutput 而不是普通元组。

返回

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

一个 transformers.modeling_outputs.Seq2SeqModelOutput 或一个torch.FloatTensor元组（如果传递了return_dict=False或config.return_dict=False时）包含各种元素，具体取决于配置（FSMTConfig）和输入。

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

  如果使用past_key_values，则输出形状为(batch_size, 1, hidden_size)的序列的最后一个隐藏状态。

• past_key_values (tuple(tuple(torch.FloatTensor)), 可选的, 当传递use_cache=True或config.use_cache=True时返回) — 长度为config.n_layers的tuple(torch.FloatTensor)元组，每个元组有 2 个形状为(batch_size, num_heads, sequence_length, embed_size_per_head)的张量和 2 个额外的形状为(batch_size, num_heads, encoder_sequence_length, embed_size_per_head)的张量。

  包含预先计算的隐藏状态（自注意力块和交叉注意力块中的键和值），可用于加速顺序解码（参见past_key_values输入）。

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

  解码器在每一层输出的隐藏状态以及可选的初始嵌入输出。

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

  解码器的注意力权重，在注意力 softmax 之后，用于计算自注意力头中的加权平均值。

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

  解码器的交叉注意力层的注意力权重，在注意力 softmax 之后，用于计算交叉注意力头中的加权平均值。

• encoder_last_hidden_state (形状为(batch_size, sequence_length, hidden_size)的torch.FloatTensor`，可选的) — 模型编码器最后一层的隐藏状态序列。

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

  编码器在每一层输出的隐藏状态以及可选的初始嵌入输出。

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

  编码器的注意力权重，在注意力 softmax 之后，用于计算自注意力头中的加权平均值。

FSMTModel 的前向方法，覆盖了__call__特殊方法。

虽然前向传递的步骤需要在这个函数内定义，但应该在此之后调用Module实例，而不是在此处调用，因为前者会处理运行前后处理步骤，而后者会默默地忽略它们。

示例：

>>> from transformers import AutoTokenizer, FSMTModel
>>> import torch

>>> tokenizer = AutoTokenizer.from_pretrained("facebook/wmt19-ru-en")
>>> model = FSMTModel.from_pretrained("facebook/wmt19-ru-en")

>>> inputs = tokenizer("Hello, my dog is cute", return_tensors="pt")
>>> outputs = model(**inputs)

>>> last_hidden_states = outputs.last_hidden_state

FSMTForConditionalGeneration

class transformers.FSMTForConditionalGeneration

<来源>

( config: FSMTConfig )

参数

• config（FSMTConfig）- 具有模型所有参数的模型配置类。使用配置文件初始化不会加载与模型关联的权重，只加载配置。查看 from_pretrained()方法以加载模型权重。

带有语言建模头的 FSMT 模型。可用于摘要。

此模型继承自 PreTrainedModel。查看超类文档，了解库为其所有模型实现的通用方法（例如下载或保存、调整输入嵌入、修剪头等）。

此模型还是 PyTorch torch.nn.Module子类。将其用作常规 PyTorch 模块，并参考 PyTorch 文档以获取有关一般用法和行为的所有相关信息。

forward

<来源>

( input_ids: LongTensor attention_mask: Optional = None decoder_input_ids: Optional = None decoder_attention_mask: Optional = None head_mask: Optional = None decoder_head_mask: Optional = None cross_attn_head_mask: Optional = None encoder_outputs: Optional = None past_key_values: Optional = None inputs_embeds: Optional = None decoder_inputs_embeds: Optional = None labels: Optional = None use_cache: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None ) → export const metadata = 'undefined';transformers.modeling_outputs.Seq2SeqLMOutput or tuple(torch.FloatTensor)

参数

• input_ids（形状为(batch_size, sequence_length)的torch.LongTensor）- 词汇表中输入序列标记的索引。

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

  什么是输入 ID？

• attention_mask（形状为(batch_size, sequence_length)的torch.Tensor，可选）- 用于避免在填充标记索引上执行注意力。选择的掩码值在[0, 1]中：

  • 1 表示未被掩盖的标记，

  • 0 表示被掩盖的标记。

  什么是注意力掩码？

• decoder_input_ids（形状为(batch_size, target_sequence_length)的torch.LongTensor，可选）- 词汇表中解码器输入序列标记的索引。

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

  什么是解码器输入 ID？

  FSMT 使用eos_token_id作为decoder_input_ids生成的起始标记。如果使用past_key_values，则只需选择最后的decoder_input_ids输入（请参阅past_key_values）。

• decoder_attention_mask（形状为(batch_size, target_sequence_length)的torch.BoolTensor，可选）- 默认行为：生成一个张量，忽略decoder_input_ids中的填充标记。因果掩码也将默认使用。

• head_mask（形状为(encoder_layers, encoder_attention_heads)的torch.Tensor，可选）- 用于在编码器中使注意力模块的选定头部失效的掩码。选择的掩码值在[0, 1]中：

  • 1 表示头部未被掩盖，

  • 0 表示头部被掩盖。

• decoder_head_mask（形状为(decoder_layers, decoder_attention_heads)的torch.Tensor，可选）- 用于在解码器中使注意力模块的选定头部失效的掩码。选择的掩码值在[0, 1]中：

  • 1 表示头部未被掩盖，

  • 0 表示头部被掩盖。

• cross_attn_head_mask（形状为(decoder_layers, decoder_attention_heads)的torch.Tensor，可选）- 用于在解码器中使交叉注意力模块的选定头部失效的掩码。选择的掩码值在[0, 1]中：

  • 1 表示头部未被掩盖，

  • 0 表示头部被掩盖。

• encoder_outputs（Tuple(torch.FloatTensor)，可选）- 元组包括（last_hidden_state，可选：hidden_states，可选：attentions）last_hidden_state的形状为(batch_size, sequence_length, hidden_size)，是编码器最后一层输出的隐藏状态序列。用于解码器的交叉注意力。

• past_key_values（长度为config.n_layers的Tuple(torch.FloatTensor)，每个元组包含形状为(batch_size, num_heads, sequence_length - 1, embed_size_per_head)的 4 个张量）- 包含注意力块的预计算键和值隐藏状态。可用于加速解码。如果使用past_key_values，用户可以选择仅输入最后的decoder_input_ids（这些没有将其过去的键值状态提供给此模型的）的形状为(batch_size, 1)的张量，而不是所有形状为(batch_size, sequence_length)的decoder_input_ids。

• inputs_embeds（形状为(batch_size, sequence_length, hidden_size)的torch.FloatTensor，可选）- 可选地，您可以选择直接传递嵌入表示，而不是传递input_ids。如果您想要更多控制如何将input_ids索引转换为相关向量，而不是使用模型的内部嵌入查找矩阵，这将非常有用。

• decoder_inputs_embeds（形状为(batch_size, target_sequence_length, hidden_size)的torch.FloatTensor，可选）- 可选地，您可以选择直接传递嵌入表示，而不是传递decoder_input_ids。如果使用past_key_values，则可以选择仅输入最后的decoder_inputs_embeds（请参阅past_key_values）。如果您想要更多控制如何将decoder_input_ids索引转换为相关向量，而不是使用模型的内部嵌入查找矩阵，这将非常有用。

  如果decoder_input_ids和decoder_inputs_embeds都未设置，则decoder_inputs_embeds取inputs_embeds的值。

• use_cache（bool，可选，默认为True）- 如果设置为True，则返回past_key_values键值状态，并可用于加速解码（请参阅past_key_values）。

• output_attentions（bool，可选）- 是否返回所有注意力层的注意力张量。有关更多详细信息，请参阅返回张量下的attentions。

• output_hidden_states（bool，可选）- 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回张量下的hidden_states。

• return_dict（bool，可选）- 是否返回一个 ModelOutput 而不是一个普通元组。

• labels（形状为(batch_size, sequence_length)的torch.LongTensor，可选）- 用于计算掩码语言建模损失的标签。索引应该在[0, ..., config.vocab_size]或-100（请参阅input_ids文档字符串）。将索引设置为-100的标记将被忽略（掩码），仅对具有[0, ..., config.vocab_size]标签的标记计算损失。

返回

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

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

• loss（形状为(1,)的torch.FloatTensor，可选，当提供labels时返回）- 语言建模损失。

• logits（形状为(batch_size, sequence_length, config.vocab_size)的torch.FloatTensor）- 语言建模头的预测分数（SoftMax 之前每个词汇标记的分数）。

• past_key_values（tuple(tuple(torch.FloatTensor))，可选，当传递use_cache=True或config.use_cache=True时返回） — 长度为config.n_layers的tuple(torch.FloatTensor)元组，每个元组有 2 个形状为(batch_size, num_heads, sequence_length, embed_size_per_head)的张量和 2 个额外的形状为(batch_size, num_heads, encoder_sequence_length, embed_size_per_head)的张量。

  包含预先计算的隐藏状态（自注意力块和交叉注意力块中的键和值），可用于加速顺序解码（参见past_key_values输入）。

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

  解码器在每个层的输出的隐藏状态加上初始嵌入输出。

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

  解码器的注意力权重，在注意力 softmax 之后，用于计算自注意力头中的加权平均值。

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

  解码器的交叉注意力层的注意力权重，在注意力 softmax 之后，用于计算交叉注意力头中的加权平均值。

• encoder_last_hidden_state（形状为(batch_size, sequence_length, hidden_size)的torch.FloatTensor，可选） — 模型编码器最后一层的隐藏状态序列。

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

  编码器在每个层的输出的隐藏状态加上初始嵌入输出。

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

  编码器的注意力权重，在注意力 softmax 之后，用于计算自注意力头中的加权平均值。

FSMTForConditionalGeneration 的前向方法，覆盖了__call__特殊方法。

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

翻译示例：

>>> from transformers import AutoTokenizer, FSMTForConditionalGeneration

>>> mname = "facebook/wmt19-ru-en"
>>> model = FSMTForConditionalGeneration.from_pretrained(mname)
>>> tokenizer = AutoTokenizer.from_pretrained(mname)

>>> src_text = "Машинное обучение - это здорово, не так ли?"
>>> input_ids = tokenizer(src_text, return_tensors="pt").input_ids
>>> outputs = model.generate(input_ids, num_beams=5, num_return_sequences=3)
>>> tokenizer.decode(outputs[0], skip_special_tokens=True)
"Machine learning is great, isn't it?"

Funnel Transformer

原文链接：huggingface.co/docs/transformers/v4.37.2/en/model_doc/funnel

概述

Funnel Transformer 模型是在论文Funnel-Transformer: Filtering out Sequential Redundancy for Efficient Language Processing中提出的。它是一个双向变压器模型，类似于 BERT，但在每个层块之后进行池化操作，有点像传统卷积神经网络（CNN）在计算机视觉中的操作。

该论文的摘要如下：

随着语言预训练的成功，开发更高效且具有良好可扩展性的架构以更低成本利用丰富的未标记数据变得非常可取。为了提高效率，我们研究了在维护完整长度的令牌级表示中常被忽视的冗余，特别是对于只需要序列的单向量表示的任务。基于这种直觉，我们提出了漏斗变压器（Funnel-Transformer），逐渐压缩隐藏状态序列至更短的序列，从而降低计算成本。更重要的是，通过将长度减少所节省的 FLOPs 重新投资于构建更深或更宽的模型，我们进一步提高了模型容量。此外，为了执行常见预训练目标所需的令牌级预测，Funnel-Transformer 能够通过解码器从减少的隐藏序列中恢复每个令牌的深度表示。经验上，使用可比较或更少的 FLOPs，Funnel-Transformer 在各种序列级预测任务上优于标准变压器，包括文本分类、语言理解和阅读理解。

该模型由sgugger贡献。原始代码可以在这里找到。

使用提示

• 由于 Funnel Transformer 使用了池化，隐藏状态的序列长度在每个层块之后发生变化。这样，它们的长度被除以 2，加快了下一个隐藏状态的计算。因此，基础模型最终的序列长度是原始长度的四分之一。该模型可以直接用于只需要句子摘要的任务（如序列分类或多项选择）。对于其他任务，使用完整模型；这个完整模型具有一个解码器，将最终的隐藏状态上采样到与输入相同的序列长度。

• 对于分类等任务，这不是问题，但对于像掩码语言建模或令牌分类这样的任务，我们需要一个与原始输入具有相同序列长度的隐藏状态。在这些情况下，最终的隐藏状态被上采样到输入序列长度，并经过两个额外的层。这就是为什么每个检查点有两个版本的原因。带有“-base”后缀的版本仅包含三个块，而没有该后缀的版本包含三个块和上采样头以及其额外的层。

• Funnel Transformer 的检查点都有完整版本和基础版本。第一个应该用于 FunnelModel、FunnelForPreTraining、FunnelForMaskedLM、FunnelForTokenClassification 和 FunnelForQuestionAnswering。第二个应该用于 FunnelBaseModel、FunnelForSequenceClassification 和 FunnelForMultipleChoice。

资源

• 文本分类任务指南

• 令牌分类任务指南

• 问答任务指南

• 掩码语言建模任务指南

• 多选任务指南

FunnelConfig

class transformers.FunnelConfig

<来源>

( vocab_size = 30522 block_sizes = [4, 4, 4] block_repeats = None num_decoder_layers = 2 d_model = 768 n_head = 12 d_head = 64 d_inner = 3072 hidden_act = 'gelu_new' hidden_dropout = 0.1 attention_dropout = 0.1 activation_dropout = 0.0 initializer_range = 0.1 initializer_std = None layer_norm_eps = 1e-09 pooling_type = 'mean' attention_type = 'relative_shift' separate_cls = True truncate_seq = True pool_q_only = True **kwargs )

参数

• vocab_size (int, optional, defaults to 30522) — Funnel transformer 的词汇大小。定义了在调用 FunnelModel 或 TFFunnelModel 时可以表示的不同令牌数量。

• block_sizes (List[int], optional, defaults to [4, 4, 4]) — 模型中使用的块的大小。

• block_repeats (List[int], optional) — 如果传递，每个块的每一层将重复指定次数。

• num_decoder_layers (int, optional, defaults to 2) — 解码器中的层数（当不使用基础模型时）。

• d_model (int, optional, defaults to 768) — 模型隐藏状态的维度。

• n_head (int, optional, defaults to 12) — Transformer 编码器中每个注意力层的注意力头数。

• d_head (int, optional, defaults to 64) — 模型头部的维度。

• d_inner (int, optional, defaults to 3072) — 前馈块中的内部维度。

• hidden_act (str or callable, optional, defaults to "gelu_new") — 编码器和池化器中的非线性激活函数（函数或字符串）。如果是字符串，支持"gelu"、"relu"、"silu"和"gelu_new"。

• hidden_dropout (float, optional, defaults to 0.1) — 嵌入、编码器和池化器中所有全连接层的 dropout 概率。

• attention_dropout (float, optional, defaults to 0.1) — 注意力概率的 dropout 概率。

• activation_dropout (float, optional, defaults to 0.0) — 在前馈块的两层之间使用的 dropout 概率。

• initializer_range (float, optional, defaults to 0.1) — 初始化所有注意力层中的权重矩阵的均匀初始化器的上界。

• initializer_std (float, optional) — 用于初始化嵌入矩阵和线性层权重的正态初始化器的标准差。对于嵌入矩阵，默认为 1，对于线性层，默认为 Xavier 初始化给定的值。

• layer_norm_eps (float, optional, defaults to 1e-09) — 层归一化层使用的 epsilon。

• pooling_type (str, optional, defaults to "mean") — 可能的值为"mean"或"max"。在每个块的开头执行池化的方式。

• attention_type (str, optional, defaults to "relative_shift") — 可能的值为"relative_shift"或"factorized"。前者在 CPU/GPU 上更快，而后者在 TPU 上更快。

• separate_cls (bool, optional, defaults to True) — 是否在应用池化时分离 cls 标记。

• truncate_seq (bool, optional, defaults to True) — 当使用separate_cls时，是否截断最后一个标记以避免获得不是 2 的倍数的序列长度。

• pool_q_only (bool, optional, defaults to True) — 是否仅将池化应用于查询或用于查询、键和值的注意力层。

这是用于存储 FunnelModel 或 TFBertModel 配置的配置类。根据指定的参数实例化 Funnel Transformer 模型，定义模型架构。使用默认值实例化配置将产生类似于 Funnel Transformer funnel-transformer/small架构的配置。

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

FunnelTokenizer

class transformers.FunnelTokenizer

<来源>

( 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>' bos_token = '<s>' eos_token = '</s>' tokenize_chinese_chars = True strip_accents = None **kwargs )

参数

• 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, defaults to "<mask>") — 用于屏蔽值的标记。在使用掩码语言建模训练此模型时使用的标记。这是模型将尝试预测的标记。

• bos_token (str, optional, defaults to "<s>") — 句子开头的标记。

• eos_token (str, optional, defaults to "</s>") — 句子结尾的标记。

• tokenize_chinese_chars (bool, optional, defaults to True) — 是否对中文字符进行标记化。

  这可能需要在日语中停用（请参阅此问题）。

• strip_accents (bool, 可选) — 是否去除所有重音符号。如果未指定此选项，则将由 lowercase 的值决定（与原始 BERT 相同）。

构建一个漏斗 Transformer 分词器。基于 WordPiece。

此分词器继承自 PreTrainedTokenizer，其中包含大多数主要方法。用户应参考此超类以获取有关这些方法的更多信息。

build_inputs_with_special_tokens

<来源>

( token_ids_0: List token_ids_1: Optional = None ) → export const metadata = 'undefined';List[int]

参数

• token_ids_0 (List[int]) — 将添加特殊标记的 ID 列表。

• token_ids_1 (List[int], 可选) — 序列对的可选第二个 ID 列表。

返回

List[int]

具有适当特殊标记的 input IDs 列表。

通过连接和添加特殊标记，从序列或序列对构建用于序列分类任务的模型输入。一个 BERT 序列的格式如下：

• 单个序列：[CLS] X [SEP]

• 序列对：[CLS] A [SEP] B [SEP]

get_special_tokens_mask

<来源>

( token_ids_0: List token_ids_1: Optional = None already_has_special_tokens: bool = False ) → export const metadata = 'undefined';List[int]

参数

• token_ids_0 (List[int]) — ID 列表。

• token_ids_1 (List[int], 可选) — 序列对的可选第二个 ID 列表。

• already_has_special_tokens (bool, 可选, 默认为 False) — 标记列表是否已经格式化为模型的特殊标记。

返回

List[int]

一个整数列表，范围为[0, 1]：特殊标记为 1，序列标记为 0。

从没有添加特殊标记的标记列表中检索序列 ID。当使用分词器的 prepare_for_model 方法添加特殊标记时，将调用此方法。

create_token_type_ids_from_sequences

<来源>

( token_ids_0: List token_ids_1: Optional = None ) → export const metadata = 'undefined';List[int]

参数

• token_ids_0 (List[int]) — ID 列表。

• token_ids_1 (List[int], 可选) — 序列对的可选第二个 ID 列表。

返回

List[int]

根据给定序列的 token type IDs 列表。

从传递的两个序列创建一个用于序列对分类任务的掩码。一个漏斗

Transformer 序列对掩码的格式如下：

2 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1 1
| first sequence    | second sequence |

如果 token_ids_1 为 None，则此方法仅返回掩码的第一部分（0s）。

save_vocabulary

<来源>

( save_directory: str filename_prefix: Optional = None )

FunnelTokenizerFast

class transformers.FunnelTokenizerFast

<来源>

( vocab_file = None tokenizer_file = None do_lower_case = True unk_token = '<unk>' sep_token = '<sep>' pad_token = '<pad>' cls_token = '<cls>' mask_token = '<mask>' bos_token = '<s>' eos_token = '</s>' clean_text = True tokenize_chinese_chars = True strip_accents = None wordpieces_prefix = '##' **kwargs )

参数

• vocab_file (str) — 包含词汇表的文件。

• do_lower_case (bool, 可选, 默认为 True) — 在分词化时是否将输入转换为小写。

• unk_token (str, 可选, 默认为 "<unk>") — 未知标记。词汇表中不存在的标记无法转换为 ID，而是设置为此标记。

• sep_token (str, 可选, 默认为 "<sep>") — 分隔符标记，在构建来自多个序列的序列时使用，例如用于序列分类的两个序列或用于文本和问题的问题回答。它还用作使用特殊标记构建的序列的最后一个标记。

• pad_token (str, 可选, 默认为 "<pad>") — 用于填充的标记，例如在批处理不同长度的序列时使用。

• cls_token（str，可选，默认为"<cls>"）- 在进行序列分类（对整个序列而不是每个标记进行分类）时使用的分类器标记。当使用特殊标记构建序列时，它是序列的第一个标记。

• mask_token（str，可选，默认为"<mask>"）- 用于屏蔽值的标记。这是在使用掩码语言建模训练此模型时使用的标记。这是模型将尝试预测的标记。

• clean_text（bool，可选，默认为True）- 是否在分词之前清理文本，通过删除所有控制字符并用经典字符替换所有空格。

• tokenize_chinese_chars（bool，可选，默认为True）- 是否对中文字符进行分词。这对于日语可能需要停用（参见此问题）。

• bos_token（str，可选，默认为"<s>"）- 句子开头标记。

• eos_token（str，可选，默认为"</s>"）- 句子结束标记。

• strip_accents（bool，可选）- 是否去除所有重音符号。如果未指定此选项，则将由lowercase的值确定（与原始 BERT 中的情况相同）。

• wordpieces_prefix（str，可选，默认为"##"）- 子词的前缀。

构建一个“快速”Funnel Transformer 分词器（由 HuggingFace 的tokenizers库支持）。基于 WordPiece。

这个分词器继承自 PreTrainedTokenizerFast，其中包含大部分主要方法。用户应参考这个超类以获取有关这些方法的更多信息。

build_inputs_with_special_tokens

<来源>

( token_ids_0 token_ids_1 = None ) → export const metadata = 'undefined';List[int]

参数

• token_ids_0（List[int]）- 将添加特殊标记的 ID 列表。

• token_ids_1（List[int]，可选）- 序列对的可选第二个 ID 列表。

返回

List[int]

具有适当特殊标记的输入 ID 列表。

通过连接和添加特殊标记，从序列或序列对构建用于序列分类任务的模型输入。Funnel 序列的格式如下：

• 单个序列：[CLS] X [SEP]

• 序列对：[CLS] A [SEP] B [SEP]

create_token_type_ids_from_sequences

<来源>

( token_ids_0: List token_ids_1: Optional = None ) → export const metadata = 'undefined';List[int]

参数

• token_ids_0（List[int]）- ID 列表。

• token_ids_1（List[int]，可选）- 序列对的可选第二个 ID 列表。

返回

List[int]

根据给定序列的标记类型 ID 列表。

从传递的两个序列创建一个用于序列对分类任务的掩码。一个 Funnel

Transformer 序列对掩码的格式如下：

2 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1 1
| first sequence    | second sequence |

如果token_ids_1为None，则此方法仅返回掩码的第一部分（0）。

Funnel 特定输出

class transformers.models.funnel.modeling_funnel.FunnelForPreTrainingOutput

<来源>

( loss: Optional = None logits: FloatTensor = None hidden_states: Optional = None attentions: Optional = None )

参数

• loss（可选，在提供labels时返回，形状为(1,)的torch.FloatTensor）- ELECTRA 风格目标的总损失。

• logits（形状为(batch_size, sequence_length)的torch.FloatTensor）- 头部的预测分数（SoftMax 之前每个标记的分数）。

• hidden_states (tuple(torch.FloatTensor), optional, 当传递output_hidden_states=True或config.output_hidden_states=True时返回) — 形状为(batch_size, sequence_length, hidden_size)的torch.FloatTensor元组（一个用于嵌入的输出 + 一个用于每个层的输出）。

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

• attentions (tuple(torch.FloatTensor), optional, 当传递output_attentions=True或config.output_attentions=True时返回) — 形状为(batch_size, num_heads, sequence_length, sequence_length)的torch.FloatTensor元组。

  自注意力头中用于计算加权平均值的注意力 softmax 后的注意力权重。

FunnelForPreTraining 的输出类型。

class transformers.models.funnel.modeling_tf_funnel.TFFunnelForPreTrainingOutput

<来源>

( logits: tf.Tensor = None hidden_states: Tuple[tf.Tensor] | None = None attentions: Tuple[tf.Tensor] | None = None )

参数

• logits (tf.Tensor，形状为(batch_size, sequence_length)) — 头部的预测分数（SoftMax 之前每个标记的分数）。

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

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

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

  自注意力头中用于计算加权平均值的注意力 softmax 后的注意力权重。

FunnelForPreTraining 的输出类型。

Pytorch 隐藏内容

FunnelBaseModel

class transformers.FunnelBaseModel

<来源>

( config: FunnelConfig )

参数

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

基本的 Funnel Transformer 模型，输出原始隐藏状态，没有上采样头（也称为解码器）或任何特定任务头在顶部。

Funnel Transformer 模型由 Zihang Dai、Guokun Lai、Yiming Yang、Quoc V. Le 在Funnel-Transformer: Filtering out Sequential Redundancy for Efficient Language Processing中提出。

此模型继承自 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 output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None ) → export const metadata = 'undefined';transformers.modeling_outputs.BaseModelOutput or tuple(torch.FloatTensor)

参数

• input_ids（形状为(batch_size, sequence_length)的torch.LongTensor）- 词汇表中输入序列标记的索引。

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

  什么是输入 ID？

• attention_mask（形状为(batch_size, sequence_length)的torch.FloatTensor，可选）- 避免在填充标记索引上执行注意力的掩码。掩码值在[0, 1]中选择：

  • 1 表示未被掩盖的标记，

  • 0 表示被掩盖的标记。

  什么是注意力掩码？

• token_type_ids（形状为(batch_size, sequence_length)的torch.LongTensor，可选）- 段标记索引，指示输入的第一部分和第二部分。索引在[0, 1]中选择：

  • 0 对应于句子 A的标记，

  • 1 对应于句子 B的标记。

  什么是标记类型 ID？

• inputs_embeds（形状为(batch_size, sequence_length, hidden_size)的torch.FloatTensor，可选）- 可选地，您可以选择直接传递嵌入表示，而不是传递input_ids。如果您想要更多控制如何将input_ids索引转换为关联向量，而不是使用模型的内部嵌入查找矩阵，这将非常有用。

• output_attentions（bool，可选）- 是否返回所有注意力层的注意力张量。有关更多详细信息，请参阅返回张量中的attentions。

• output_hidden_states（bool，可选）- 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回张量中的hidden_states。

• return_dict（bool，可选）- 是否返回 ModelOutput 而不是普通元组。

返回

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

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

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

• 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 之后的注意力权重。

FunnelBaseModel 的前向方法，覆盖了__call__特殊方法。

尽管前向传递的步骤需要在此函数内定义，但应该在此之后调用Module实例，而不是在此处调用，因为前者会处理运行前后处理步骤，而后者会默默地忽略它们。

示例：

>>> from transformers import AutoTokenizer, FunnelBaseModel
>>> import torch

>>> tokenizer = AutoTokenizer.from_pretrained("funnel-transformer/small-base")
>>> model = FunnelBaseModel.from_pretrained("funnel-transformer/small-base")

>>> inputs = tokenizer("Hello, my dog is cute", return_tensors="pt")
>>> outputs = model(**inputs)

>>> last_hidden_states = outputs.last_hidden_state

FunnelModel

class transformers.FunnelModel

<来源>

( config: FunnelConfig )

参数

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

裸的 Funnel Transformer 模型，输出原始隐藏状态，没有特定的顶部头。

Funnel Transformer 模型是由 Zihang Dai，Guokun Lai，Yiming Yang，Quoc V. Le 在Funnel-Transformer: Filtering out Sequential Redundancy for Efficient Language Processing中提出的。

此模型继承自 PreTrainedModel。检查超类文档以获取库为所有模型实现的通用方法（例如下载或保存、调整输入嵌入、修剪头等）。

此模型还是 PyTorch torch.nn.Module子类。将其用作常规 PyTorch 模块，并参考 PyTorch 文档以获取与一般用法和行为相关的所有事项。

forward

<来源>

( input_ids: Optional = None attention_mask: Optional = None token_type_ids: Optional = None inputs_embeds: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None ) → export const metadata = 'undefined';transformers.modeling_outputs.BaseModelOutput or tuple(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), optional) — 避免在填充标记索引上执行注意力的掩码。选择的掩码值在[0, 1]中：

  • 1 表示未屏蔽的标记，

  • 0 表示屏蔽的标记。

  什么是注意力蒙版？

• token_type_ids (torch.LongTensor of shape (batch_size, sequence_length), optional) — 段标记索引，指示输入的第一部分和第二部分。索引在[0, 1]中选择：

  • 0 对应于句子 A标记，

  • 1 对应于句子 B标记。

  什么是标记类型 ID？

• 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, optional) — 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回的张量中的hidden_states。

• return_dict（bool，可选）- 是否返回 ModelOutput 而不是普通元组。

返回

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

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

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

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

FunnelModel 的前向方法，覆盖了 __call__ 特殊方法。

虽然前向传递的方法需要在此函数内定义，但应该在此之后调用 Module 实例，而不是这个，因为前者会负责运行预处理和后处理步骤，而后者会默默地忽略它们。

示例：

>>> from transformers import AutoTokenizer, FunnelModel
>>> import torch

>>> tokenizer = AutoTokenizer.from_pretrained("funnel-transformer/small")
>>> model = FunnelModel.from_pretrained("funnel-transformer/small")

>>> inputs = tokenizer("Hello, my dog is cute", return_tensors="pt")
>>> outputs = model(**inputs)

>>> last_hidden_states = outputs.last_hidden_state

FunnelModelForPreTraining

class transformers.FunnelForPreTraining

<来源>

( config: FunnelConfig )

forward

<来源>

( input_ids: Optional = None attention_mask: Optional = None token_type_ids: Optional = None inputs_embeds: Optional = None labels: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None ) → export const metadata = 'undefined';transformers.models.funnel.modeling_funnel.FunnelForPreTrainingOutput or tuple(torch.FloatTensor)

参数

• input_ids（形状为 (batch_size, sequence_length) 的 torch.LongTensor）- 词汇表中输入序列标记的索引。

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

  输入 ID 是什么？

• attention_mask（形状为 (batch_size, sequence_length) 的 torch.FloatTensor，可选）- 避免在填充标记索引上执行注意力的蒙版。蒙版值在 [0, 1] 中选择：

  • 1 用于未被 masked 的标记，

  • 0 用于被 masked 的标记。

  注意力蒙版是什么？

• token_type_ids（形状为 (batch_size, sequence_length) 的 torch.LongTensor，可选）- 段标记索引，指示输入的第一部分和第二部分。索引在 [0, 1] 中选择：

  • 0 对应于 句子 A 标记，

  • 1 对应于 句子 B 标记。

  令牌类型 ID 是什么？

• inputs_embeds（形状为(batch_size, sequence_length, hidden_size)的torch.FloatTensor，可选）— 可选地，您可以选择直接传递嵌入表示，而不是传递input_ids。如果您想要更多控制权，以便将input_ids索引转换为相关向量，而不是模型的内部嵌入查找矩阵，则这很有用。

• output_attentions（bool，可选）— 是否返回所有注意力层的注意力张量。有关更多详细信息，请参见返回张量下的attentions。

• output_hidden_states（bool，可选）— 是否返回所有层的隐藏状态。有关更多详细信息，请参见返回张量下的hidden_states。

• return_dict（bool，可选）— 是否返回 ModelOutput 而不是普通元组。

• labels（形状为(batch_size, sequence_length)的torch.LongTensor，可选）— 用于计算 ELECTRA 风格损失的标签。输入应为一系列标记（参见input_ids文档字符串）。索引应在[0, 1]之间：

  • 0 表示标记是原始标记，

  • 1 表示标记已被替换。

返回

transformers.models.funnel.modeling_funnel.FunnelForPreTrainingOutput 或tuple(torch.FloatTensor)

transformers.models.funnel.modeling_funnel.FunnelForPreTrainingOutput 或一个torch.FloatTensor元组（如果传递return_dict=False或config.return_dict=False时）包括根据配置（FunnelConfig）和输入的不同元素。

• loss（可选，当提供labels时返回，形状为(1,)的torch.FloatTensor）— ELECTRA 风格目标的总损失。

• logits（形状为(batch_size, sequence_length)的torch.FloatTensor）— 头部的预测分数（SoftMax 之前每个标记的分数）。

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

FunnelForPreTraining 的前向方法，覆盖了__call__特殊方法。

虽然前向传递的步骤需要在此函数内定义，但应该在此之后调用Module实例，而不是在此处调用，因为前者负责运行预处理和后处理步骤，而后者会默默地忽略它们。

示例：

>>> from transformers import AutoTokenizer, FunnelForPreTraining
>>> import torch

>>> tokenizer = AutoTokenizer.from_pretrained("funnel-transformer/small")
>>> model = FunnelForPreTraining.from_pretrained("funnel-transformer/small")

>>> inputs = tokenizer("Hello, my dog is cute", return_tensors="pt")
>>> logits = model(**inputs).logits

FunnelForMaskedLM

class transformers.FunnelForMaskedLM

<来源>

( config: FunnelConfig )

参数

• config（FunnelConfig）— 具有模型所有参数的模型配置类。使用配置文件初始化不会加载与模型关联的权重，只加载配置。查看 from_pretrained()方法以加载模型权重。

在顶部带有 语言建模 头的 Funnel Transformer 模型。

Funnel Transformer 模型是由 Zihang Dai、Guokun Lai、Yiming Yang、Quoc V. Le 在 Funnel-Transformer: Filtering out Sequential Redundancy for Efficient Language Processing 中提出的。

此模型继承自 PreTrainedModel。检查超类文档以获取库为所有模型实现的通用方法（例如下载或保存、调整输入嵌入、修剪头等）。

此模型也是 PyTorch torch.nn.Module 的子类。将其用作常规 PyTorch 模块，并参考 PyTorch 文档以获取有关一般用法和行为的所有相关信息。

forward

<来源>

( input_ids: Optional = None attention_mask: Optional = None token_type_ids: Optional = None inputs_embeds: Optional = None labels: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None ) → export const metadata = 'undefined';transformers.modeling_outputs.MaskedLMOutput or tuple(torch.FloatTensor)

参数

• input_ids（形状为(batch_size, sequence_length)的torch.LongTensor）— 词汇表中输入序列标记的索引。

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

  什么是输入 ID？

• attention_mask（形状为(batch_size, sequence_length)的torch.FloatTensor，可选）— 避免在填充标记索引上执行注意力的掩码。选择的掩码值在[0, 1]中：

  • 对于未屏蔽的标记，

  • 0 对于被屏蔽的标记。

  什么是注意力掩码？

• token_type_ids（形状为(batch_size, sequence_length)的torch.LongTensor，可选）— 段标记索引，指示输入的第一部分和第二部分。索引在[0, 1]中选择：

  • 0 对应于 句子 A 标记，

  • 1 对应于 句子 B 标记。

  什么是标记类型 ID？

• inputs_embeds（形状为(batch_size, sequence_length, hidden_size)的torch.FloatTensor，可选）— 可选地，您可以选择直接传递嵌入表示，而不是传递input_ids。如果您想要更多控制如何将input_ids索引转换为关联向量，这将非常有用，而不是使用模型的内部嵌入查找矩阵。

• output_attentions（bool，可选）— 是否返回所有注意力层的注意力张量。有关更多详细信息，请参阅返回张量下的attentions。

• output_hidden_states（bool，可选）— 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回张量下的hidden_states。

• return_dict（bool，可选）— 是否返回 ModelOutput 而不是普通元组。

• labels（形状为(batch_size, sequence_length)的torch.LongTensor，可选）— 用于计算被屏蔽语言建模损失的标签。索引应在[-100, 0, ..., config.vocab_size]中（参见input_ids文档字符串）。索引设置为-100的标记将被忽略（被屏蔽），损失仅计算具有标签在[0, ..., config.vocab_size]中的标记。

返回

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

一个 transformers.modeling_outputs.MaskedLMOutput 或一个torch.FloatTensor元组（如果传递return_dict=False或config.return_dict=False）包含根据配置（FunnelConfig）和输入的各种元素。

• 损失 (torch.FloatTensor，形状为(1,)，可选，当提供labels时返回) — 掩码语言建模（MLM）损失。

• logits (torch.FloatTensor，形状为(batch_size, sequence_length, config.vocab_size)) — 语言建模头的预测分数（SoftMax 之前每个词汇标记的分数）。

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

FunnelForMaskedLM 的前向方法，覆盖了__call__特殊方法。

虽然前向传递的方法需要在此函数内定义，但应该在此之后调用Module实例，而不是这个，因为前者会负责运行预处理和后处理步骤，而后者会默默地忽略它们。

示例：

>>> from transformers import AutoTokenizer, FunnelForMaskedLM
>>> import torch

>>> tokenizer = AutoTokenizer.from_pretrained("funnel-transformer/small")
>>> model = FunnelForMaskedLM.from_pretrained("funnel-transformer/small")

>>> inputs = tokenizer("The capital of France is <mask>.", return_tensors="pt")

>>> with torch.no_grad():
...     logits = model(**inputs).logits

>>> # retrieve index of <mask>
>>> mask_token_index = (inputs.input_ids == tokenizer.mask_token_id)[0].nonzero(as_tuple=True)[0]

>>> predicted_token_id = logits[0, mask_token_index].argmax(axis=-1)

>>> labels = tokenizer("The capital of France is Paris.", return_tensors="pt")["input_ids"]
>>> # mask labels of non-<mask> tokens
>>> labels = torch.where(inputs.input_ids == tokenizer.mask_token_id, labels, -100)

>>> outputs = model(**inputs, labels=labels)

FunnelForSequenceClassification

class transformers.FunnelForSequenceClassification

< source >

( config: FunnelConfig )

参数

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

Funnel Transformer 模型，顶部带有一个序列分类/回归头（在最后隐藏状态的第一个时间步之上有两个线性层），例如用于 GLUE 任务。

Funnel Transformer 模型由 Zihang Dai、Guokun Lai、Yiming Yang、Quoc V. Le 在 Funnel-Transformer: Filtering out Sequential Redundancy for Efficient Language Processing 中提出。

该模型继承自 PreTrainedModel。查看超类文档以了解库为所有模型实现的通用方法（如下载或保存、调整输入嵌入、修剪头等）。

该模型也是一个 PyTorch torch.nn.Module 子类。将其用作常规 PyTorch 模块，并参考 PyTorch 文档以获取有关一般用法和行为的所有信息。

forward

< source >

( input_ids: Optional = None attention_mask: Optional = None token_type_ids: Optional = None inputs_embeds: Optional = None labels: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None ) → export const metadata = 'undefined';transformers.modeling_outputs.SequenceClassifierOutput or tuple(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), optional) — 用于避免在填充标记索引上执行注意力的掩码。掩码值在[0, 1]中选择：

  • 1 用于未被掩码的标记，

  • 0 用于被掩码的标记。

  什么是注意力掩码？

• token_type_ids (torch.LongTensor of shape (batch_size, sequence_length), optional) — 段标记索引，用于指示输入的第一部分和第二部分。索引在[0, 1]中选择：

  • 0 对应于句子 A的标记，

  • 1 对应于句子 B的标记。

  什么是标记类型 ID？

• 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, optional) — 是否返回所有层的隐藏状态。有关更多详细信息，请参见返回张量下的hidden_states。

• return_dict (bool, optional) — 是否返回 ModelOutput 而不是普通元组。

• labels (torch.LongTensor of shape (batch_size,), optional) — 用于计算序列分类/回归损失的标签。索引应在[0, ..., config.num_labels - 1]中。如果config.num_labels == 1，则计算回归损失（均方损失），如果config.num_labels > 1，则计算分类损失（交叉熵）。

返回

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

一个 transformers.modeling_outputs.SequenceClassifierOutput 或一个torch.FloatTensor元组（如果传递return_dict=False或config.return_dict=False）包含各种元素，具体取决于配置（FunnelConfig）和输入。

• loss (torch.FloatTensor of shape (1,), optional, 当提供labels时返回) — 分类（如果 config.num_labels==1 则为回归）损失。

• logits (torch.FloatTensor of shape (batch_size, config.num_labels)) — 分类（如果 config.num_labels==1 则为回归）分数（SoftMax 之前）。

• hidden_states (tuple(torch.FloatTensor), optional, 当传递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 之后的注意力权重，用于计算自注意力头中的加权平均值。

FunnelForSequenceClassification 的前向方法，覆盖了__call__特殊方法。

虽然前向传递的步骤需要在此函数内定义，但应该在此之后调用Module实例，而不是在此处调用，因为前者负责运行前后处理步骤，而后者会默默地忽略它们。

单标签分类示例：

>>> import torch
>>> from transformers import AutoTokenizer, FunnelForSequenceClassification

>>> tokenizer = AutoTokenizer.from_pretrained("funnel-transformer/small-base")
>>> model = FunnelForSequenceClassification.from_pretrained("funnel-transformer/small-base")

>>> inputs = tokenizer("Hello, my dog is cute", return_tensors="pt")

>>> with torch.no_grad():
...     logits = model(**inputs).logits

>>> predicted_class_id = logits.argmax().item()

>>> # To train a model on `num_labels` classes, you can pass `num_labels=num_labels` to `.from_pretrained(...)`
>>> num_labels = len(model.config.id2label)
>>> model = FunnelForSequenceClassification.from_pretrained("funnel-transformer/small-base", num_labels=num_labels)

>>> labels = torch.tensor([1])
>>> loss = model(**inputs, labels=labels).loss

多标签分类示例：

>>> import torch
>>> from transformers import AutoTokenizer, FunnelForSequenceClassification

>>> tokenizer = AutoTokenizer.from_pretrained("funnel-transformer/small-base")
>>> model = FunnelForSequenceClassification.from_pretrained("funnel-transformer/small-base", problem_type="multi_label_classification")

>>> inputs = tokenizer("Hello, my dog is cute", return_tensors="pt")

>>> with torch.no_grad():
...     logits = model(**inputs).logits

>>> predicted_class_ids = torch.arange(0, logits.shape[-1])[torch.sigmoid(logits).squeeze(dim=0) > 0.5]

>>> # To train a model on `num_labels` classes, you can pass `num_labels=num_labels` to `.from_pretrained(...)`
>>> num_labels = len(model.config.id2label)
>>> model = FunnelForSequenceClassification.from_pretrained(
...     "funnel-transformer/small-base", num_labels=num_labels, problem_type="multi_label_classification"
... )

>>> labels = torch.sum(
...     torch.nn.functional.one_hot(predicted_class_ids[None, :].clone(), num_classes=num_labels), dim=1
... ).to(torch.float)
>>> loss = model(**inputs, labels=labels).loss

FunnelForMultipleChoice

class transformers.FunnelForMultipleChoice

来源

( config: FunnelConfig )

参数

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

Funnel Transformer 模型，顶部带有多选分类头（在最后隐藏状态的第一个时间步之上有两个线性层，以及一个 softmax），例如用于 RocStories/SWAG 任务。

Funnel Transformer 模型由 Zihang Dai、Guokun Lai、Yiming Yang、Quoc V. Le 在Funnel-Transformer: Filtering out Sequential Redundancy for Efficient Language Processing中提出。

此模型继承自 PreTrainedModel。查看超类文档以获取库为所有模型实现的通用方法（例如下载或保存、调整输入嵌入、修剪头等）。

此模型还是 PyTorch torch.nn.Module子类。将其用作常规 PyTorch 模块，并参考 PyTorch 文档以获取与一般用法和行为相关的所有事项。

forward

来源

( input_ids: Optional = None attention_mask: Optional = None token_type_ids: Optional = None inputs_embeds: Optional = None labels: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None ) → export const metadata = 'undefined';transformers.modeling_outputs.MultipleChoiceModelOutput or tuple(torch.FloatTensor)

参数

• input_ids（形状为(batch_size, num_choices, sequence_length)的torch.LongTensor）— 词汇表中输入序列标记的索引。

  可以使用 AutoTokenizer 获取索引。查看 PreTrainedTokenizer.encode()和 PreTrainedTokenizer.call()获取详细信息。

  什么是输入 ID？

• attention_mask（形状为(batch_size, num_choices, sequence_length)的torch.FloatTensor，可选）— 避免在填充标记索引上执行注意力的掩码。掩码值在[0, 1]中选择：

  • 对于“未屏蔽”的标记为 1，

  • 对于“屏蔽”的标记为 0。

  什么是注意力掩码？

• token_type_ids（形状为(batch_size, num_choices, sequence_length)的torch.LongTensor，可选）— 分段标记索引，指示输入的第一部分和第二部分。索引在[0, 1]中选择：

  • 0 对应于句子 A标记，

  • 1 对应于句子 B标记。

  什么是标记类型 ID？

• inputs_embeds（形状为(batch_size, num_choices, sequence_length, hidden_size)的torch.FloatTensor，可选）- 可选地，您可以选择直接传递嵌入表示，而不是传递input_ids。如果您想要更多控制权来将input_ids索引转换为相关向量，而不是使用模型的内部嵌入查找矩阵，这将非常有用。

• output_attentions（可选，bool）- 是否返回所有注意力层的注意力张量。有关更多详细信息，请参见返回张量下的attentions。

• output_hidden_states（可选，bool）- 是否返回所有层的隐藏状态。有关更多详细信息，请参见返回张量下的hidden_states。

• return_dict（可选，bool）- 是否返回 ModelOutput 而不是普通元组。

• labels（形状为(batch_size,)的torch.LongTensor，可选）- 用于计算多项选择分类损失的标签。索引应在[0, ..., num_choices-1]范围内，其中num_choices是输入张量的第二维度的大小。（参见上面的input_ids）

返回

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

一个 transformers.modeling_outputs.MultipleChoiceModelOutput 或一个torch.FloatTensor元组（如果传递return_dict=False或当config.return_dict=False时）包含各种元素，具体取决于配置（FunnelConfig）和输入。

• loss（形状为(1,)的torch.FloatTensor，可选，当提供labels时返回）- 分类损失。

• logits（形状为(batch_size, num_choices)的torch.FloatTensor）- num_choices是输入张量的第二维度。（参见上面的input_ids）。

  SoftMax 之前的分类分数。

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

FunnelForMultipleChoice 的前向方法，覆盖__call__特殊方法。

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

示例：

>>> from transformers import AutoTokenizer, FunnelForMultipleChoice
>>> import torch

>>> tokenizer = AutoTokenizer.from_pretrained("funnel-transformer/small-base")
>>> model = FunnelForMultipleChoice.from_pretrained("funnel-transformer/small-base")

>>> prompt = "In Italy, pizza served in formal settings, such as at a restaurant, is presented unsliced."
>>> choice0 = "It is eaten with a fork and a knife."
>>> choice1 = "It is eaten while held in the hand."
>>> labels = torch.tensor(0).unsqueeze(0)  # choice0 is correct (according to Wikipedia ;)), batch size 1

>>> encoding = tokenizer([prompt, prompt], [choice0, choice1], return_tensors="pt", padding=True)
>>> outputs = model(**{k: v.unsqueeze(0) for k, v in encoding.items()}, labels=labels)  # batch size is 1

>>> # the linear classifier still needs to be trained
>>> loss = outputs.loss
>>> logits = outputs.logits

FunnelForTokenClassification

transformers.FunnelForTokenClassification类

<来源>

( config: FunnelConfig )

参数

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

在顶部带有令牌分类头的 Funnel Transformer 模型（在隐藏状态输出的顶部有一个线性层），例如用于命名实体识别（NER）任务。

Funnel Transformer 模型由戴子航、赖国坤、杨一鸣、雷鸥等人在漏斗变压器：过滤顺序冗余以实现高效语言处理中提出。

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

该模型还是 PyTorch torch.nn.Module子类。将其用作常规 PyTorch 模块，并参考 PyTorch 文档以获取有关一般用法和行为的所有相关信息。

forward

<来源>

( input_ids: Optional = None attention_mask: Optional = None token_type_ids: Optional = None inputs_embeds: Optional = None labels: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None ) → export const metadata = 'undefined';transformers.modeling_outputs.TokenClassifierOutput or tuple(torch.FloatTensor)

参数

• input_ids（形状为(batch_size, sequence_length)的torch.LongTensor）— 词汇中输入序列令牌的索引。

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

  输入 ID 是什么？

• attention_mask（形状为(batch_size, sequence_length)的torch.FloatTensor，可选）— 用于避免在填充令牌索引上执行注意力的掩码。选择的掩码值为[0, 1]：

  • 1 表示未被掩盖的令牌，

  • 0 表示被掩盖的令牌。

  注意掩码是什么？

• token_type_ids（形状为(batch_size, sequence_length)的torch.LongTensor，可选）— 段令牌索引，指示输入的第一部分和第二部分。索引在[0, 1]中选择：

  • 0 对应于句子 A的令牌，

  • 1 对应于句子 B的令牌。

  令牌类型 ID 是什么？

• inputs_embeds（形状为(batch_size, sequence_length, hidden_size)的torch.FloatTensor，可选）— 可选地，您可以选择直接传递嵌入表示而不是传递input_ids。如果您想要更多控制如何将input_ids索引转换为关联向量，而不是使用模型的内部嵌入查找矩阵，则这很有用。

• output_attentions（bool，可选）— 是否返回所有注意力层的注意力张量。有关更多详细信息，请参阅返回张量下的attentions。

• output_hidden_states（bool，可选）— 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回张量下的hidden_states。

• return_dict（bool，可选）— 是否返回 ModelOutput 而不是普通元组。

• labels（形状为(batch_size, sequence_length)的torch.LongTensor，可选）— 用于计算令牌分类损失的标签。索引应在[0, ..., config.num_labels - 1]范围内。

返回

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

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

• loss (torch.FloatTensor of shape (1,), optional, returned when labels is provided) — 分类损失。

• logits (torch.FloatTensor of shape (batch_size, sequence_length, config.num_labels)) — 分类分数（SoftMax 之前）。

• hidden_states (tuple(torch.FloatTensor), optional, 当传递 output_hidden_states=True 或 config.output_hidden_states=True 时返回) — 形状为 (batch_size, sequence_length, hidden_size) 的 torch.FloatTensor 元组。

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

• attentions (tuple(torch.FloatTensor), optional, 当传递 output_attentions=True 或 config.output_attentions=True 时返回) — 形状为 (batch_size, num_heads, sequence_length, sequence_length) 的 torch.FloatTensor 元组。

  在注意力 softmax 之后的注意力权重，用于计算自注意力头中的加权平均值。

FunnelForTokenClassification 的前向方法覆盖了 __call__ 特殊方法。

虽然前向传递的步骤需要在此函数内定义，但应该在此之后调用 Module 实例，而不是在此处调用，因为前者会负责运行预处理和后处理步骤，而后者会默默地忽略它们。

示例：

>>> from transformers import AutoTokenizer, FunnelForTokenClassification
>>> import torch

>>> tokenizer = AutoTokenizer.from_pretrained("funnel-transformer/small")
>>> model = FunnelForTokenClassification.from_pretrained("funnel-transformer/small")

>>> inputs = tokenizer(
...     "HuggingFace is a company based in Paris and New York", add_special_tokens=False, return_tensors="pt"
... )

>>> with torch.no_grad():
...     logits = model(**inputs).logits

>>> predicted_token_class_ids = logits.argmax(-1)

>>> # Note that tokens are classified rather then input words which means that
>>> # there might be more predicted token classes than words.
>>> # Multiple token classes might account for the same word
>>> predicted_tokens_classes = [model.config.id2label[t.item()] for t in predicted_token_class_ids[0]]

>>> labels = predicted_token_class_ids
>>> loss = model(**inputs, labels=labels).loss

FunnelForQuestionAnswering

class transformers.FunnelForQuestionAnswering

< source >

( config: FunnelConfig )

参数

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

在顶部带有跨度分类头的 Funnel Transformer 模型，用于提取式问答任务，如 SQuAD（在隐藏状态输出的顶部有一个线性层，用于计算 span start logits 和 span end logits）。

Funnel Transformer 模型是由 Zihang Dai、Guokun Lai、Yiming Yang、Quoc V. Le 在 Funnel-Transformer: Filtering out Sequential Redundancy for Efficient Language Processing 中提出的。

此模型继承自 PreTrainedModel。查看超类文档以获取库为所有模型实现的通用方法（如下载或保存、调整输入嵌入、修剪头等）。

此模型也是 PyTorch torch.nn.Module 的子类。将其用作常规 PyTorch 模块，并参考 PyTorch 文档以获取有关一般用法和行为的所有相关信息。

forward

< source >

( input_ids: Optional = None attention_mask: Optional = None token_type_ids: Optional = None inputs_embeds: Optional = None start_positions: Optional = None end_positions: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None ) → export const metadata = 'undefined';transformers.modeling_outputs.QuestionAnsweringModelOutput or tuple(torch.FloatTensor)

参数

• input_ids（形状为(batch_size, sequence_length)的torch.LongTensor）— 词汇表中输入序列标记的索引。

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

  什么是输入 ID？

• attention_mask（形状为(batch_size, sequence_length)的torch.FloatTensor，可选）— 用于避免在填充标记索引上执行注意力的蒙版。蒙版值在[0, 1]中选择：

  • 1 对于那些未被掩盖的标记，

  • 0 对于那些被掩盖的标记。

  什么是注意力蒙版？

• token_type_ids（形状为(batch_size, sequence_length)的torch.LongTensor，可选）— 段标记索引，指示输入的第一部分和第二部分。索引在[0, 1]中选择：

  • 0 对应于一个 句子 A 的标记，

  • 1 对应于一个 句子 B 的标记。

  什么是标记类型 ID？

• inputs_embeds（形状为(batch_size, sequence_length, hidden_size)的torch.FloatTensor，可选）— 可选地，您可以选择直接传递嵌入表示，而不是传递input_ids。如果您想要更多控制如何将input_ids索引转换为相关向量，而不是模型的内部嵌入查找矩阵，则这是有用的。

• output_attentions（bool，可选）— 是否返回所有注意力层的注意力张量。有关更多详细信息，请参见返回张量下的attentions。

• output_hidden_states（bool，可选）— 是否返回所有层的隐藏状态。有关更多详细信息，请参见返回张量下的hidden_states。

• return_dict（bool，可选）— 是否返回一个 ModelOutput 而不是一个普通元组。

• start_positions（形状为(batch_size,)的torch.LongTensor，可选）— 用于计算标记分类损失的标记范围开始位置的位置（索引）的标签。位置被夹紧到序列的长度（sequence_length）。超出序列范围的位置不会被考虑在内以计算损失。

• end_positions（形状为(batch_size,)的torch.LongTensor，可选）— 用于计算标记范围结束位置的位置（索引）的标签，以计算标记分类损失。位置被夹紧到序列的长度（sequence_length）。超出序列范围的位置不会被考虑在内以计算损失。

返回值

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

一个 transformers.modeling_outputs.QuestionAnsweringModelOutput 或一个torch.FloatTensor元组（如果传递了return_dict=False或当config.return_dict=False时）包含根据配置（FunnelConfig）和输入的各种元素。

• loss（形状为(1,)的torch.FloatTensor，可选，当提供labels时返回）— 总跨度提取损失是开始和结束位置的交叉熵之和。

• start_logits（形状为(batch_size, sequence_length)的torch.FloatTensor）— 跨度开始分数（SoftMax 之前）。

• end_logits（形状为(batch_size, sequence_length)的torch.FloatTensor）— 跨度结束分数（SoftMax 之前）。

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

FunnelForQuestionAnswering 的前向方法，覆盖了__call__特殊方法。

虽然前向传递的方法需要在此函数内定义，但应该在此之后调用Module实例，而不是调用此函数，因为前者会处理运行前后处理步骤，而后者会默默地忽略它们。

示例：

>>> from transformers import AutoTokenizer, FunnelForQuestionAnswering
>>> import torch

>>> tokenizer = AutoTokenizer.from_pretrained("funnel-transformer/small")
>>> model = FunnelForQuestionAnswering.from_pretrained("funnel-transformer/small")

>>> question, text = "Who was Jim Henson?", "Jim Henson was a nice puppet"

>>> inputs = tokenizer(question, text, return_tensors="pt")
>>> with torch.no_grad():
...     outputs = model(**inputs)

>>> answer_start_index = outputs.start_logits.argmax()
>>> answer_end_index = outputs.end_logits.argmax()

>>> predict_answer_tokens = inputs.input_ids[0, answer_start_index : answer_end_index + 1]

>>> # target is "nice puppet"
>>> target_start_index = torch.tensor([14])
>>> target_end_index = torch.tensor([15])

>>> outputs = model(**inputs, start_positions=target_start_index, end_positions=target_end_index)
>>> loss = outputs.loss

TensorFlow 隐藏 TensorFlow 内容

TFFunnelBaseModel

class transformers.TFFunnelBaseModel

<来源>

( config: FunnelConfig *inputs **kwargs )

参数

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

基础 Funnel Transformer 模型，输出原始隐藏状态，没有上采样头（也称为解码器）或任何特定任务头。

Funnel Transformer 模型是由 Zihang Dai, Guokun Lai, Yiming Yang, Quoc V. Le 在Funnel-Transformer: Filtering out Sequential Redundancy for Efficient Language Processing中提出的。

此模型继承自 TFPreTrainedModel。查看超类文档以了解库为所有模型实现的通用方法（如下载或保存、调整输入嵌入、修剪头等）。

此模型也是tf.keras.Model的子类。将其用作常规的 TF 2.0 Keras 模型，并参考 TF 2.0 文档以获取有关一般用法和行为的所有相关信息。

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

• 将所有输入作为关键字参数（类似于 PyTorch 模型），或

• 将所有输入作为列表、元组或字典的第一个位置参数。

支持第二种格式的原因是，Keras 方法在将输入传递给模型和层时更喜欢这种格式。由于这种支持，当使用model.fit()等方法时，应该“只需传递”输入和标签，model.fit()支持的任何格式都可以正常工作！但是，如果要在 Keras 方法之外使用第二种格式，例如在使用 KerasFunctionalAPI 创建自己的层或模型时，有三种可能性可用于收集第一个位置参数中的所有输入张量：

• 只有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 函数一样传递输入！

call

<来源>

( input_ids: TFModelInputType | None = None attention_mask: np.ndarray | tf.Tensor | None = None token_type_ids: 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 training: bool = False ) → export const metadata = 'undefined';transformers.modeling_tf_outputs.TFBaseModelOutput or tuple(tf.Tensor)

参数

• input_ids（形状为(batch_size, sequence_length)的Numpy数组或tf.Tensor）— 词汇表中输入序列标记的索引。

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

  什么是输入 ID？

• attention_mask（形状为(batch_size, sequence_length)的Numpy数组或tf.Tensor，可选）— 用于避免在填充标记索引上执行注意力的掩码。掩码值在[0, 1]中选择：

  • 1 对应于未被“masked”掉的标记，

  • 对于被masked掉的标记。

  什么是注意力掩码？

• token_type_ids（形状为(batch_size, sequence_length)的Numpy数组或tf.Tensor，可选）— 段标记索引，指示输入的第一部分和第二部分。索引在[0, 1]中选择：

  • 0 对应于 句子 A 标记，

  • 1 对应于 句子 B 标记。

  什么是标记类型 ID？

• inputs_embeds（形状为(batch_size, sequence_length, hidden_size)的tf.Tensor，可选）— 可选地，您可以选择直接传递嵌入表示，而不是传递input_ids。如果您想要更多控制如何将input_ids索引转换为相关向量，而不是模型内部的嵌入查找矩阵，则这很有用。

• output_attentions（bool，可选）— 是否返回所有注意力层的注意力张量。有关更多详细信息，请参阅返回张量下的attentions。此参数仅可在急切模式下使用，在图模式下将使用配置中的值。

• output_hidden_states（bool，可选）— 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回张量下的hidden_states。此参数仅可在急切模式下使用，在图模式下将使用配置中的值。

• return_dict（bool，可选）— 是否返回 ModelOutput 而不是普通元组。此参数可在急切模式下使用，在图模式下该值将始终设置为 True。

• training（bool，可选，默认为False）— 是否在训练模式下使用模型（一些模块如 dropout 模块在训练和评估之间有不同的行为）。

返回

transformers.modeling_tf_outputs.TFBaseModelOutput 或tuple(tf.Tensor)

transformers.modeling_tf_outputs.TFBaseModelOutput 或一个tf.Tensor元组（如果传递了return_dict=False或config.return_dict=False时）包含根据配置（FunnelConfig）和输入的各种元素。

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

• hidden_states (tuple(tf.FloatTensor), 可选的，当传递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元组（每个层一个）。

  注意力权重在注意力 softmax 之后，用于计算自注意力头中的加权平均值。

TFFunnelBaseModel 的前向方法，覆盖了__call__特殊方法。

虽然前向传递的步骤需要在此函数内定义，但应该在此之后调用Module实例，而不是这个，因为前者会处理运行前后处理步骤，而后者会默默地忽略它们。

示例：

>>> from transformers import AutoTokenizer, TFFunnelBaseModel
>>> import tensorflow as tf

>>> tokenizer = AutoTokenizer.from_pretrained("funnel-transformer/small-base")
>>> model = TFFunnelBaseModel.from_pretrained("funnel-transformer/small-base")

>>> inputs = tokenizer("Hello, my dog is cute", return_tensors="tf")
>>> outputs = model(inputs)

>>> last_hidden_states = outputs.last_hidden_state

TFFunnelModel

class transformers.TFFunnelModel

<来源>

( config: FunnelConfig *inputs **kwargs )

参数

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

裸的 Funnel Transformer 模型，输出原始隐藏状态，没有特定的头部。

Funnel Transformer 模型是由 Zihang Dai、Guokun Lai、Yiming Yang、Quoc V. Le 在Funnel-Transformer: Filtering out Sequential Redundancy for Efficient Language Processing中提出的。

此模型继承自 TFPreTrainedModel。查看超类文档以了解库为所有模型实现的通用方法（如下载或保存、调整输入嵌入、修剪头等）。

此模型也是tf.keras.Model的子类。将其用作常规的 TF 2.0 Keras 模型，并参考 TF 2.0 文档以获取有关一般用法和行为的所有信息。

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

• 将所有输入作为关键字参数（类似于 PyTorch 模型），或者

• 将所有输入作为列表、元组或字典的第一个位置参数。

支持第二种格式的原因是 Keras 方法在将输入传递给模型和层时更喜欢这种格式。由于这种支持，当使用model.fit()等方法时，应该“只需传递”您的输入和标签，model.fit()支持的任何格式都可以！但是，如果您想在 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 函数一样传递输入！

call

<来源>

( input_ids: TFModelInputType | None = None attention_mask: np.ndarray | tf.Tensor | None = None token_type_ids: 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 training: bool = False ) → export const metadata = 'undefined';transformers.modeling_tf_outputs.TFBaseModelOutput or tuple(tf.Tensor)

参数

• input_ids（形状为(batch_size, sequence_length)的Numpy 数组或tf.Tensor）— 词汇表中输入序列标记的索引。

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

  什么是输入 ID？

• attention_mask（Numpy 数组或形状为(batch_size, sequence_length)的tf.Tensor，可选）— 避免在填充标记索引上执行注意力的掩码。选择的掩码值在[0, 1]中：

  • 1 表示未被屏蔽的标记，

  • 0 表示被屏蔽的标记。

  什么是注意力掩码？

• token_type_ids（形状为(batch_size, sequence_length)的Numpy 数组或tf.Tensor，可选）— 段标记索引，指示输入的第一部分和第二部分。索引在[0, 1]中选择：

  • 0 对应于句子 A标记，

  • 1 对应于句子 B标记。

  什么是标记类型 ID？

• inputs_embeds（形状为(batch_size, sequence_length, hidden_size)的tf.Tensor，可选）— 可选地，您可以直接传递嵌入表示，而不是传递input_ids。如果您想要更多控制如何将input_ids索引转换为相关向量，这将非常有用，而不是使用模型的内部嵌入查找矩阵。

• output_attentions（bool，可选）— 是否返回所有注意力层的注意力张量。有关更多详细信息，请参见返回张量下的attentions。此参数仅在急切模式下使用，在图模式中将使用配置中的值。

• output_hidden_states（bool，可选）— 是否返回所有层的隐藏状态。有关更多详细信息，请参见返回张量下的hidden_states。此参数仅在急切模式下使用，在图模式中将使用配置中的值。

• return_dict（bool，可选）— 是否返回 ModelOutput 而不是普通元组。此参数可在急切模式下使用，在图模式中该值将始终设置为 True。

• training（bool，可选，默认为False）— 是否在训练模式下使用模型（一些模块如 dropout 模块在训练和评估之间有不同的行为）。

返回

transformers.modeling_tf_outputs.TFBaseModelOutput 或 tuple(tf.Tensor)

一个 transformers.modeling_tf_outputs.TFBaseModelOutput 或一个tf.Tensor元组（如果传递了return_dict=False或config.return_dict=False时）包含根据配置(FunnelConfig)和输入的不同元素。

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

• hidden_states（tuple(tf.FloatTensor)，可选，当传递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元组（每层一个）。

  在注意力 softmax 之后的注意力权重，用于计算自注意力头中的加权平均值。

TFFunnelModel 的前向方法，覆盖了__call__特殊方法。

尽管前向传递的配方需要在此函数中定义，但应该在此之后调用Module实例，而不是在此之后调用，因为前者负责运行预处理和后处理步骤，而后者则默默地忽略它们。

示例：

>>> from transformers import AutoTokenizer, TFFunnelModel
>>> import tensorflow as tf

>>> tokenizer = AutoTokenizer.from_pretrained("funnel-transformer/small")
>>> model = TFFunnelModel.from_pretrained("funnel-transformer/small")

>>> inputs = tokenizer("Hello, my dog is cute", return_tensors="tf")
>>> outputs = model(inputs)

>>> last_hidden_states = outputs.last_hidden_state

TFFunnelModelForPreTraining

class transformers.TFFunnelForPreTraining

<来源>

( config: FunnelConfig **kwargs )

参数

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

在顶部带有二元分类头的漏斗模型，用于在预训练期间识别生成的标记。

漏斗变压器模型是由 Zihang Dai、Guokun Lai、Yiming Yang、Quoc V. Le 在漏斗变压器：过滤顺序冗余以实现高效语言处理中提出的。

此模型继承自 TFPreTrainedModel。查看超类文档，了解库为其所有模型实现的通用方法（例如下载或保存、调整输入嵌入、修剪头等）。

此模型还是tf.keras.Model的子类。将其用作常规的 TF 2.0 Keras 模型，并参考 TF 2.0 文档，了解与一般用法和行为相关的所有事项。

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

• 将所有输入作为关键字参数（类似于 PyTorch 模型），或者

• 将所有输入作为列表、元组或字典放在第一个位置参数中。

支持第二种格式的原因是 Keras 方法在将输入传递给模型和层时更喜欢这种格式。由于有此支持，当使用model.fit()等方法时，应该可以“正常工作” - 只需以model.fit()支持的任何格式传递输入和标签！但是，如果您想在 Keras 方法之外使用第二种格式，例如在使用 KerasFunctionalAPI 创建自己的层或模型时，有三种可能性可用于收集第一个位置参数中的所有输入张量：

• 仅使用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 函数一样传递输入！

call

< source >

( input_ids: TFModelInputType | None = None attention_mask: np.ndarray | tf.Tensor | None = None token_type_ids: 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 training: bool = False **kwargs ) → export const metadata = 'undefined';transformers.models.funnel.modeling_tf_funnel.TFFunnelForPreTrainingOutput or tuple(tf.Tensor)

参数

• input_ids (Numpy array or tf.Tensor of shape (batch_size, sequence_length)) — 词汇表中输入序列标记的索引。

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

  什么是输入 ID？

• attention_mask (Numpy array or tf.Tensor of shape (batch_size, sequence_length), optional) — 避免在填充标记索引上执行注意力的掩码。掩码值选择在 [0, 1] 之间：

  • 对于未被掩盖的标记，返回 1，

  • 对于被掩盖的标记，返回 0。

  什么是注意力掩码？

• token_type_ids (Numpy array or tf.Tensor of shape (batch_size, sequence_length), optional) — 段标记索引，指示输入的第一部分和第二部分。索引选择在 [0, 1] 之间：

  • 0 对应于 句子 A 标记，

  • 1 对应于 句子 B 标记。

  什么是标记类型 ID？

• inputs_embeds (tf.Tensor of shape (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 而不是普通元组。此参数可在急切模式下使用，在图模式下该值将始终设置为 True。

• training (bool, optional, defaults to False) — 是否在训练模式下使用模型（一些模块如 dropout 模块在训练和评估之间有不同的行为）。

返回

transformers.models.funnel.modeling_tf_funnel.TFFunnelForPreTrainingOutput 或 tuple(tf.Tensor)

一个 transformers.models.funnel.modeling_tf_funnel.TFFunnelForPreTrainingOutput 或一个 tf.Tensor 元组（如果传递了 return_dict=False 或当 config.return_dict=False 时）包含根据配置（FunnelConfig）和输入的不同元素。

• logits (tf.Tensor of shape (batch_size, sequence_length)) — 头部的预测分数（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元组（每层一个）。

  在注意力 softmax 之后的注意力权重，用于计算自注意力头中的加权平均值。

TFFunnelForPreTraining 的前向方法，覆盖了__call__特殊方法。

尽管前向传递的步骤需要在此函数内定义，但应该在此之后调用Module实例，而不是在此之后调用，因为前者会处理运行前后处理步骤，而后者会默默地忽略它们。

示例：

>>> from transformers import AutoTokenizer, TFFunnelForPreTraining
>>> import torch

>>> tokenizer = AutoTokenizer.from_pretrained("funnel-transformer/small")
>>> model = TFFunnelForPreTraining.from_pretrained("funnel-transformer/small")

>>> inputs = tokenizer("Hello, my dog is cute", return_tensors="tf")
>>> logits = model(inputs).logits

TFFunnelForMaskedLM

class transformers.TFFunnelForMaskedLM

<来源>

( config: FunnelConfig *inputs **kwargs )

参数

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

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

Funnel Transformer 模型由 Zihang Dai，Guokun Lai，Yiming Yang，Quoc V. Le 在Funnel-Transformer: Filtering out Sequential Redundancy for Efficient Language Processing中提出。

这个模型继承自 TFPreTrainedModel。查看超类文档以了解库实现的通用方法（如下载或保存，调整输入嵌入大小，修剪头等）。

这个模型也是一个tf.keras.Model子类。将其用作常规的 TF 2.0 Keras 模型，并参考 TF 2.0 文档以获取有关一般用法和行为的所有相关信息。

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

• 将所有输入作为关键字参数（类似于 PyTorch 模型），或者

• 将所有输入作为列表、元组或字典的第一个位置参数。

支持第二种格式的原因是，Keras 方法在将输入传递给模型和层时更喜欢这种格式。由于这种支持，当使用model.fit()等方法时，应该可以“正常工作” - 只需以model.fit()支持的任何格式传递输入和标签即可！然而，如果您想在 Keras 方法之外使用第二种格式，比如在使用 KerasFunctionalAPI 创建自己的层或模型时，有三种可能性可以用来收集所有输入张量在第一个位置参数中：

• 一个只有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 函数一样传递输入！

call

<来源>

( input_ids: TFModelInputType | None = None attention_mask: np.ndarray | tf.Tensor | None = None token_type_ids: 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: bool = False ) → export const metadata = 'undefined';transformers.modeling_tf_outputs.TFMaskedLMOutput or tuple(tf.Tensor)

参数

• input_ids（形状为(batch_size, sequence_length)的Numpy数组或tf.Tensor）— 输入序列标记在词汇表中的索引。

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

  什么是输入 ID？

• attention_mask（形状为(batch_size, sequence_length)的Numpy数组或tf.Tensor，可选）— 用于避免在填充标记索引上执行注意力的掩码。掩码值选在[0, 1]之间：

  • 1 对应于未被masked的标记，

  • 对于被masked的标记，索引为 0。

  什么是注意力掩码？

• token_type_ids（形状为(batch_size, sequence_length)的Numpy数组或tf.Tensor，可选）— 段标记索引，指示输入的第一部分和第二部分。索引在[0, 1]中选择：

  • 0 对应于句子 A标记，

  • 1 对应于句子 B标记。

  什么是标记类型 ID？

• inputs_embeds（形状为(batch_size, sequence_length, hidden_size)的tf.Tensor，可选）— 可选地，您可以选择直接传递嵌入表示而不是传递input_ids。如果您想要更多控制如何将input_ids索引转换为相关向量，而不是使用模型的内部嵌入查找矩阵，这将非常有用。

• output_attentions（bool，可选）— 是否返回所有注意力层的注意力张量。有关更多详细信息，请参阅返回张量中的attentions。此参数仅在急切模式下使用，在图模式下将使用配置中的值。

• output_hidden_states（bool，可选）— 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回张量中的hidden_states。此参数仅在急切模式下使用，在图模式下将使用配置中的值。

• return_dict（bool，可选）— 是否返回 ModelOutput 而不是普通元组。此参数可以在急切模式下使用，在图模式下该值将始终设置为 True。

• training（bool，可选，默认为False）— 是否在训练模式下使用模型（一些模块如 dropout 模块在训练和评估之间有不同的行为）。

• labels（形状为(batch_size, sequence_length)的tf.Tensor，可选）— 用于计算掩码语言建模损失的标签。索引应在[-100, 0, ..., config.vocab_size]中（请参阅input_ids文档字符串）。索引设置为-100的标记将被忽略（被masked），损失仅计算具有标签在[0, ..., config.vocab_size]中的标记。

返回

transformers.modeling_tf_outputs.TFMaskedLMOutput 或tuple(tf.Tensor)

一个 transformers.modeling_tf_outputs.TFMaskedLMOutput 或一个tf.Tensor元组（如果传递了return_dict=False或config.return_dict=False时）包含根据配置（FunnelConfig）和输入的各种元素。

• loss（形状为(n,)的tf.Tensor，可选，其中 n 是非屏蔽标签的数量，在提供labels时返回）—掩蔽语言建模（MLM）损失。

• logits（形状为(batch_size, sequence_length, config.vocab_size)的tf.Tensor）—语言建模头的预测分数（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元组（每层一个）。

  在自注意力头中用于计算加权平均值的注意力 softmax 之后的注意力权重。

TFFunnelForMaskedLM 的前向方法，覆盖了__call__特殊方法。

虽然前向传递的步骤需要在此函数内定义，但应该在此之后调用Module实例，而不是在此处调用，因为前者负责运行预处理和后处理步骤，而后者会默默地忽略它们。

示例：

>>> from transformers import AutoTokenizer, TFFunnelForMaskedLM
>>> import tensorflow as tf

>>> tokenizer = AutoTokenizer.from_pretrained("funnel-transformer/small")
>>> model = TFFunnelForMaskedLM.from_pretrained("funnel-transformer/small")

>>> inputs = tokenizer("The capital of France is [MASK].", return_tensors="tf")
>>> logits = model(**inputs).logits

>>> # retrieve index of [MASK]
>>> mask_token_index = tf.where((inputs.input_ids == tokenizer.mask_token_id)[0])
>>> selected_logits = tf.gather_nd(logits[0], indices=mask_token_index)

>>> predicted_token_id = tf.math.argmax(selected_logits, axis=-1)

>>> labels = tokenizer("The capital of France is Paris.", return_tensors="tf")["input_ids"]
>>> # mask labels of non-[MASK] tokens
>>> labels = tf.where(inputs.input_ids == tokenizer.mask_token_id, labels, -100)

>>> outputs = model(**inputs, labels=labels)

TFFunnelForSequenceClassification

class transformers.TFFunnelForSequenceClassification

< source >

( config: FunnelConfig *inputs **kwargs )

参数

• config（XxxConfig）—模型配置类，具有模型的所有参数。使用配置文件初始化不会加载与模型关联的权重，只加载配置。查看 from_pretrained()方法以加载模型权重。

Funnel 模型变压器顶部带有序列分类/回归头（池化输出顶部的线性层），例如用于 GLUE 任务。

Funnel Transformer 模型是由 Zihang Dai，Guokun Lai，Yiming Yang，Quoc V. Le 在Funnel-Transformer: Filtering out Sequential Redundancy for Efficient Language Processing中提出的。

该模型继承自 TFPreTrainedModel。查看超类文档以了解库为所有模型实现的通用方法（如下载或保存，调整输入嵌入，修剪头等）。

该模型也是tf.keras.Model的子类。将其用作常规的 TF 2.0 Keras 模型，并参考 TF 2.0 文档以获取与一般用法和行为相关的所有信息。

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

• 将所有输入作为关键字参数（如 PyTorch 模型），或者

• 将所有输入作为列表、元组或字典的第一个位置参数。

支持第二种格式的原因是，Keras 方法在将输入传递给模型和层时更喜欢这种格式。由于有了这种支持，当使用model.fit()等方法时，您应该可以“轻松使用” - 只需以model.fit()支持的任何格式传递输入和标签！但是，如果您想在 Keras 方法之外使用第二种格式，例如在使用 KerasFunctional 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 函数一样传递输入！

call

<来源>

( input_ids: TFModelInputType | None = None attention_mask: np.ndarray | tf.Tensor | None = None token_type_ids: 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: bool = False ) → export const metadata = 'undefined';transformers.modeling_tf_outputs.TFSequenceClassifierOutput or tuple(tf.Tensor)

参数

• input_ids（形状为(batch_size, sequence_length)的Numpy 数组或tf.Tensor）- 词汇表中输入序列标记的索引。

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

  什么是输入 ID？

• attention_mask（形状为(batch_size, sequence_length)的Numpy 数组或tf.Tensor，可选）- 用于避免在填充标记索引上执行注意力的掩码。选择的掩码值在[0, 1]中：

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

  • 0 表示被掩码的标记。

  什么是注意力掩码？

• token_type_ids（形状为(batch_size, sequence_length)的Numpy 数组或tf.Tensor，可选）- 段标记索引，指示输入的第一部分和第二部分。索引在[0, 1]中选择：

  • 0 对应于句子 A标记，

  • 1 对应于句子 B标记。

  什么是标记类型 ID？

• inputs_embeds（形状为(batch_size, sequence_length, hidden_size)的tf.Tensor，可选）- 可选地，您可以选择直接传递嵌入表示，而不是传递input_ids。如果您希望更多地控制如何将input_ids索引转换为相关向量，而不是使用模型的内部嵌入查找矩阵，则这很有用。

• output_attentions（bool，可选）- 是否返回所有注意力层的注意力张量。有关更多详细信息，请参见返回张量下的attentions。此参数仅在急切模式下使用，在图模式下将使用配置中的值。

• output_hidden_states（bool，可选）- 是否返回所有层的隐藏状态。有关更多详细信息，请参见返回张量下的hidden_states。此参数仅在急切模式下使用，在图模式下将使用配置中的值。

• return_dict（bool，可选）- 是否返回 ModelOutput 而不是普通元组。此参数可在急切模式下使用，在图模式下该值将始终设置为 True。

• training (bool, optional, 默认为False) — 是否在训练模式下使用模型（一些模块如 dropout 模块在训练和评估之间有不同的行为）。

• labels (tf.Tensor of shape (batch_size,), optional) — 用于计算序列分类/回归损失的标签。索引应在[0, ..., config.num_labels - 1]范围内。如果config.num_labels == 1，则计算回归损失（均方损失），如果config.num_labels > 1，则计算分类损失（交叉熵）。

返回值

transformers.modeling_tf_outputs.TFSequenceClassifierOutput 或tuple(tf.Tensor)

一个 transformers.modeling_tf_outputs.TFSequenceClassifierOutput 或一个tf.Tensor元组（如果传递了return_dict=False或config.return_dict=False时）包含根据配置（FunnelConfig）和输入的各种元素。

• loss (tf.Tensor of shape (batch_size, ), optional, 当提供labels时返回) — 分类（如果 config.num_labels==1 则为回归）损失。

• logits (tf.Tensor of shape (batch_size, config.num_labels)) — 分类（如果 config.num_labels==1 则为回归）得分（SoftMax 之前）。

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

  模型在每一层输出的隐藏状态加上初始嵌入输出。

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

  注意力 softmax 后的注意力权重，用于计算自注意力头中的加权平均值。

TFFunnelForSequenceClassification 的前向方法，覆盖了__call__特殊方法。

虽然前向传递的步骤需要在此函数内定义，但应该在此之后调用Module实例，而不是在此之后调用，因为前者会负责运行前处理和后处理步骤，而后者会默默地忽略它们。

示例:

>>> from transformers import AutoTokenizer, TFFunnelForSequenceClassification
>>> import tensorflow as tf

>>> tokenizer = AutoTokenizer.from_pretrained("funnel-transformer/small-base")
>>> model = TFFunnelForSequenceClassification.from_pretrained("funnel-transformer/small-base")

>>> inputs = tokenizer("Hello, my dog is cute", return_tensors="tf")

>>> logits = model(**inputs).logits

>>> predicted_class_id = int(tf.math.argmax(logits, axis=-1)[0])

>>> # To train a model on `num_labels` classes, you can pass `num_labels=num_labels` to `.from_pretrained(...)`
>>> num_labels = len(model.config.id2label)
>>> model = TFFunnelForSequenceClassification.from_pretrained("funnel-transformer/small-base", num_labels=num_labels)

>>> labels = tf.constant(1)
>>> loss = model(**inputs, labels=labels).loss

TFFunnelForMultipleChoice

class transformers.TFFunnelForMultipleChoice

< source >

( config: FunnelConfig *inputs **kwargs )

参数

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

在顶部具有多选分类头的 Funnel 模型（在池化输出的顶部有一个线性层和一个 softmax），例如用于 RocStories/SWAG 任务。

Funnel Transformer 模型是由 Zihang Dai, Guokun Lai, Yiming Yang, Quoc V. Le 在 Funnel-Transformer: Filtering out Sequential Redundancy for Efficient Language Processing 中提出的。

该模型继承自 TFPreTrainedModel。查看超类文档以了解库为所有模型实现的通用方法（如下载或保存、调整输入嵌入、修剪头等）。

此模型也是tf.keras.Model子类。将其用作常规 TF 2.0 Keras 模型，并参考 TF 2.0 文档以获取与一般用法和行为相关的所有内容。

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

• 将所有输入作为关键字参数（类似于 PyTorch 模型），或

• 将所有输入作为列表、元组或字典放在第一个位置参数中。

支持第二种格式的原因是，当将输入传递给模型和层时，Keras 方法更喜欢这种格式。由于有了这种支持，当使用model.fit()等方法时，应该可以“正常工作” - 只需以model.fit()支持的任何格式传递输入和标签即可！但是，如果您想在 Keras 方法之外使用第二种格式，例如在使用 KerasFunctional 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 函数一样传递输入！

call

<来源>

( input_ids: TFModelInputType | None = None attention_mask: np.ndarray | tf.Tensor | None = None token_type_ids: 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: bool = False ) → export const metadata = 'undefined';transformers.modeling_tf_outputs.TFMultipleChoiceModelOutput or tuple(tf.Tensor)

参数

• input_ids（形状为(batch_size, num_choices, sequence_length)的Numpy数组或tf.Tensor） - 词汇表中输入序列令牌的索引。

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

  什么是输入 ID？

• attention_mask（形状为(batch_size, num_choices, sequence_length)的Numpy数组或tf.Tensor，可选） - 用于避免在填充令牌索引上执行注意力的掩码。选择的掩码值在[0, 1]中：

  • 1 表示“未掩码”令牌，

  • 0 表示“掩码”令牌。

  什么是注意力掩码？

• token_type_ids（形状为(batch_size, num_choices, sequence_length)的Numpy数组或tf.Tensor，可选） - 段令牌索引，指示输入的第一部分和第二部分。选择的索引在[0, 1]中：

  • 0 对应于“句子 A”令牌，

  • 1 对应于“句子 B”令牌。

  什么是令牌类型 ID？

• inputs_embeds（形状为(batch_size, num_choices, sequence_length, hidden_size)的tf.Tensor，可选） - 可选地，您可以选择直接传递嵌入表示，而不是传递input_ids。如果您想要更多控制权，以便将input_ids索引转换为相关向量，而不是模型的内部嵌入查找矩阵，则这很有用。

• output_attentions（bool，可选） - 是否返回所有注意力层的注意力张量。有关更多详细信息，请参见返回张量下的attentions。此参数仅在急切模式下可用，在图模式下将使用配置中的值。

• output_hidden_states (bool, 可选) — 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回张量中的 hidden_states。此参数仅在急切模式下可用，在图模式下将使用配置中的值。

• return_dict (bool, 可选) — 是否返回 ModelOutput 而不是普通元组。此参数可在急切模式下使用，在图模式下该值将始终设置为 True。

• training (bool, 可选, 默认为 False) — 是否在训练模式下使用模型（一些模块如 dropout 模块在训练和评估之间有不同的行为）。

• labels (tf.Tensor 的形状为 (batch_size,), 可选) — 用于计算多项选择分类损失的标签。索引应在 [0, ..., num_choices] 范围内，其中 num_choices 是输入张量第二维的大小。 (参见上面的 input_ids)

返回

transformers.modeling_tf_outputs.TFMultipleChoiceModelOutput 或 tuple(tf.Tensor)

transformers.modeling_tf_outputs.TFMultipleChoiceModelOutput 或 tf.Tensor 元组（如果传递 return_dict=False 或 config.return_dict=False 时）包含根据配置（FunnelConfig）和输入的不同元素。

• 损失 (tf.Tensor 的形状为 (batch_size, ), 可选, 当提供 labels 时返回) — 分类损失。

• logits (tf.Tensor 的形状为 (batch_size, num_choices)) — num_choices 是输入张量的第二维。 (参见上面的 input_ids)。

  分类分数（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 元组（每层一个）。

  注意力 softmax 后的注意力权重，用于计算自注意力头中的加权平均值。

TFFunnelForMultipleChoice 前向方法，覆盖 __call__ 特殊方法。

虽然前向传递的步骤需要在此函数内定义，但应该在此之后调用 Module 实例而不是这个，因为前者负责运行预处理和后处理步骤，而后者会默默地忽略它们。

示例:

>>> from transformers import AutoTokenizer, TFFunnelForMultipleChoice
>>> import tensorflow as tf

>>> tokenizer = AutoTokenizer.from_pretrained("funnel-transformer/small-base")
>>> model = TFFunnelForMultipleChoice.from_pretrained("funnel-transformer/small-base")

>>> prompt = "In Italy, pizza served in formal settings, such as at a restaurant, is presented unsliced."
>>> choice0 = "It is eaten with a fork and a knife."
>>> choice1 = "It is eaten while held in the hand."

>>> encoding = tokenizer([prompt, prompt], [choice0, choice1], return_tensors="tf", padding=True)
>>> inputs = {k: tf.expand_dims(v, 0) for k, v in encoding.items()}
>>> outputs = model(inputs)  # batch size is 1

>>> # the linear classifier still needs to be trained
>>> logits = outputs.logits

TFFunnelForTokenClassification

class transformers.TFFunnelForTokenClassification

< source >

( config: FunnelConfig *inputs **kwargs )

参数

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

在顶部具有一个标记分类头的漏斗模型（隐藏状态输出的线性层），例如用于命名实体识别（NER）任务。

Funnel Transformer 模型是由 Zihang Dai、Guokun Lai、Yiming Yang、Quoc V. Le 在Funnel-Transformer: Filtering out Sequential Redundancy for Efficient Language Processing中提出的。

此模型继承自 TFPreTrainedModel。查看超类文档以了解库实现的通用方法（例如下载或保存、调整输入嵌入、修剪头等）。

此模型还是tf.keras.Model子类。将其用作常规的 TF 2.0 Keras 模型，并参考 TF 2.0 文档以获取与一般用法和行为相关的所有内容。

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

• 将所有输入作为关键字参数（类似于 PyTorch 模型），或

• 将所有输入作为列表、元组或字典的第一个位置参数。

支持第二种格式的原因是 Keras 方法在将输入传递给模型和层时更喜欢这种格式。由于有了这种支持，当使用model.fit()等方法时，应该可以“正常工作” - 只需以model.fit()支持的任何格式传递输入和标签即可！但是，如果您想在 Keras 方法之外使用第二种格式，例如在使用 KerasFunctionalAPI 创建自己的层或模型时，有三种可能性可用于收集所有输入张量在第一个位置参数中：

• 一个仅包含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 函数一样传递输入！

call

<来源>

( input_ids: TFModelInputType | None = None attention_mask: np.ndarray | tf.Tensor | None = None token_type_ids: 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: bool = False ) → export const metadata = 'undefined';transformers.modeling_tf_outputs.TFTokenClassifierOutput or tuple(tf.Tensor)

参数

• input_ids（形状为(batch_size, sequence_length)的Numpy数组或tf.Tensor）- 词汇表中输入序列标记的索引。

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

  什么是输入 ID？

• attention_mask（形状为(batch_size, sequence_length)的Numpy数组或tf.Tensor，可选）- 避免在填充标记索引上执行注意力的掩码。掩码值在[0, 1]中选择：

  • 1 用于未屏蔽的标记，

  • 0 用于已屏蔽的标记。

  什么是注意力掩码？

• token_type_ids（形状为(batch_size, sequence_length)的Numpy数组或tf.Tensor，可选）- 段标记索引，指示输入的第一部分和第二部分。索引在[0, 1]中选择：

  • 0 对应于句子 A标记，

  • 1 对应于句子 B标记。

  什么是标记类型 ID？

• inputs_embeds (tf.Tensor of shape (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 而不是普通元组。此参数可以在急切模式下使用，在图模式下该值将始终设置为 True。

• training (bool, optional, 默认为 False) — 是否在训练模式下使用模型（一些模块如 dropout 模块在训练和评估之间有不同的行为）。

• labels (tf.Tensor of shape (batch_size, sequence_length), optional) — 用于计算标记分类损失的标签。索引应在 [0, ..., config.num_labels - 1] 中。

返回

transformers.modeling_tf_outputs.TFTokenClassifierOutput 或 tf.Tensor 元组

transformers.modeling_tf_outputs.TFTokenClassifierOutput 或 tf.Tensor 元组（如果传递 return_dict=False 或 config.return_dict=False，则包含根据配置（FunnelConfig）和输入的各种元素。

• loss (tf.Tensor of shape (n,), optional, 当提供 labels 时返回，其中 n 是未屏蔽标签的数量) — 分类损失。

• logits (tf.Tensor of shape (batch_size, sequence_length, config.num_labels)) — 分类分数（SoftMax 之前）。

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

  每个层输出的模型隐藏状态加上初始嵌入输出。

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

  注意力 softmax 后的注意力权重，用于计算自注意力头中的加权平均值。

TFFunnelForTokenClassification 前向方法，覆盖了 __call__ 特殊方法。

虽然前向传递的步骤需要在此函数内定义，但应该在此之后调用 Module 实例，而不是在此处调用，因为前者会负责运行预处理和后处理步骤，而后者会默默地忽略它们。

示例：

>>> from transformers import AutoTokenizer, TFFunnelForTokenClassification
>>> import tensorflow as tf

>>> tokenizer = AutoTokenizer.from_pretrained("funnel-transformer/small")
>>> model = TFFunnelForTokenClassification.from_pretrained("funnel-transformer/small")

>>> inputs = tokenizer(
...     "HuggingFace is a company based in Paris and New York", add_special_tokens=False, return_tensors="tf"
... )

>>> logits = model(**inputs).logits
>>> predicted_token_class_ids = tf.math.argmax(logits, axis=-1)

>>> # Note that tokens are classified rather then input words which means that
>>> # there might be more predicted token classes than words.
>>> # Multiple token classes might account for the same word
>>> predicted_tokens_classes = [model.config.id2label[t] for t in predicted_token_class_ids[0].numpy().tolist()]

>>> labels = predicted_token_class_ids
>>> loss = tf.math.reduce_mean(model(**inputs, labels=labels).loss)

TFFunnelForQuestionAnswering

class transformers.TFFunnelForQuestionAnswering

< source >

( config: FunnelConfig *inputs **kwargs )

参数

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

漏斗模型，顶部带有用于提取问答任务（如 SQuAD）的跨度分类头（在隐藏状态输出的顶部进行线性层计算span start logits和span end logits）。

漏斗变换器模型是由 Zihang Dai、Guokun Lai、Yiming Yang、Quoc V. Le 在漏斗变换器：过滤顺序冗余以实现高效语言处理中提出的。

此模型继承自 TFPreTrainedModel。检查超类文档以了解库为其所有模型实现的通用方法（如下载或保存、调整输入嵌入、修剪头等）。

此模型还是一个tf.keras.Model子类。将其用作常规的 TF 2.0 Keras 模型，并参考 TF 2.0 文档以获取与一般用法和行为相关的所有信息。

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

• 将所有输入作为关键字参数（类似于 PyTorch 模型），或

• 将所有输入作为列表、元组或字典放在第一个位置参数中。

支持第二种格式的原因是，当将输入传递给模型和层时，Keras 方法更喜欢这种格式。由于有了这种支持，当使用诸如model.fit()之类的方法时，对您来说应该“只需工作” - 只需以model.fit()支持的任何格式传递您的输入和标签！但是，如果您想在 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 函数一样传递输入！

call

<来源>

( input_ids: TFModelInputType | None = None attention_mask: np.ndarray | tf.Tensor | None = None token_type_ids: 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 start_positions: np.ndarray | tf.Tensor | None = None end_positions: np.ndarray | tf.Tensor | None = None training: bool = False ) → export const metadata = 'undefined';transformers.modeling_tf_outputs.TFQuestionAnsweringModelOutput or tuple(tf.Tensor)

参数

• input_ids（形状为(batch_size, sequence_length)的Numpy数组或tf.Tensor）- 词汇表中输入序列标记的索引。

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

  输入 ID 是什么？

• attention_mask（形状为(batch_size, sequence_length)的Numpy数组或tf.Tensor，可选）- 用于避免在填充令牌索引上执行注意力的掩码。选择的掩码值在[0, 1]中：

  • 对于未被masked的标记为 1，

  • 对于被masked的标记为 0。

  注意力掩码是什么？

• token_type_ids (Numpy 数组 或形状为 (batch_size, sequence_length) 的 tf.Tensor，可选) — 段标记索引，指示输入的第一部分和第二部分。索引在 [0, 1] 中选择：

  • 0 对应于 句子 A 的标记，

  • 1 对应于 句子 B 的标记。

  什么是 token type IDs？

• inputs_embeds (tf.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 (bool，可选，默认为 False) — 是否在训练模式下使用模型（一些模块如 dropout 模块在训练和评估之间有不同的行为）。

• start_positions (tf.Tensor，形状为 (batch_size,)，可选) — 用于计算标记跨度开始位置（索引）的标签。位置被夹紧到序列的长度（sequence_length）。序列外的位置不会被考虑在内计算损失。

• end_positions (tf.Tensor，形状为 (batch_size,)，可选) — 用于计算标记跨度结束位置（索引）的标签。位置被夹紧到序列的长度（sequence_length）。序列外的位置不会被考虑在内计算损失。

返回

transformers.modeling_tf_outputs.TFQuestionAnsweringModelOutput 或 tuple(tf.Tensor)

一个 transformers.modeling_tf_outputs.TFQuestionAnsweringModelOutput 或一个 tf.Tensor 元组（如果传递 return_dict=False 或 config.return_dict=False）包含各种元素，具体取决于配置（FunnelConfig）和输入。

• loss (tf.Tensor，形状为 (batch_size,)，可选，当提供 start_positions 和 end_positions 时返回) — 总跨度提取损失是开始和结束位置的交叉熵之和。

• start_logits (tf.Tensor，形状为 (batch_size, sequence_length)) — 跨度开始得分（SoftMax 之前）。

• end_logits (tf.Tensor，形状为 (batch_size, sequence_length)) — 跨度结束得分（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元组（每层一个）。

  注意权重在注意力 softmax 之后，用于计算自注意力头中的加权平均值。

TFFunnelForQuestionAnswering 前向方法，覆盖了__call__特殊方法。

虽然前向传递的步骤需要在这个函数内定义，但应该在之后调用Module实例，而不是这个函数，因为前者会处理运行前后的处理步骤，而后者会默默地忽略它们。

示例：

>>> from transformers import AutoTokenizer, TFFunnelForQuestionAnswering
>>> import tensorflow as tf

>>> tokenizer = AutoTokenizer.from_pretrained("funnel-transformer/small")
>>> model = TFFunnelForQuestionAnswering.from_pretrained("funnel-transformer/small")

>>> question, text = "Who was Jim Henson?", "Jim Henson was a nice puppet"

>>> inputs = tokenizer(question, text, return_tensors="tf")
>>> outputs = model(**inputs)

>>> answer_start_index = int(tf.math.argmax(outputs.start_logits, axis=-1)[0])
>>> answer_end_index = int(tf.math.argmax(outputs.end_logits, axis=-1)[0])

>>> predict_answer_tokens = inputs.input_ids[0, answer_start_index : answer_end_index + 1]

>>> # target is "nice puppet"
>>> target_start_index = tf.constant([14])
>>> target_end_index = tf.constant([15])

>>> outputs = model(**inputs, start_positions=target_start_index, end_positions=target_end_index)
>>> loss = tf.math.reduce_mean(outputs.loss)

Fuyu

原始文本：huggingface.co/docs/transformers/v4.37.2/en/model_doc/fuyu

概述

Fuyu 模型由ADEPT创建，作者是 Rohan Bavishi、Erich Elsen、Curtis Hawthorne、Maxwell Nye、Augustus Odena、Arushi Somani、Sağnak Taşırlar。

作者介绍了 Fuyu-8B，这是一个仅解码器的基于经典 transformers 架构的多模态模型，具有查询和键规范化。线性编码器被添加以从图像输入创建多模态嵌入。

通过将图像标记视为文本标记，并使用特殊的图像换行符，模型知道图像行何时结束。移除了图像位置嵌入。这避免了为各种图像分辨率进行不同训练阶段的需要。Fuyu-8B 具有 80 亿个参数，并在 CC-BY-NC 许可下发布，以其处理文本和图像的能力、令人印象深刻的 16K 上下文大小和整体性能而闻名。

Fuyu模型是使用bfloat16训练的，但原始推理使用float16。上传到 hub 的检查点使用torch_dtype = 'float16'，AutoModel API 将使用它将检查点从torch.float32转换为torch.float16。

在线权重的dtype大多数情况下并不重要，除非在使用torch_dtype="auto"初始化模型时使用model = AutoModelForCausalLM.from_pretrained("path", torch_dtype = "auto")。原因是模型将首先被下载（使用在线检查点的dtype），然后将被转换为torch的默认dtype（变为torch.float32）。用户应该指定他们想要的torch_dtype，如果他们不这样做，它将是torch.float32。

不建议在float16中微调模型，因为已知会产生nan，因此应该在bfloat16中微调模型。

提示：

• 要转换模型，您需要使用git clone https://github.com/persimmon-ai-labs/adept-inference克隆原始存储库，然后获取检查点：

git clone https://github.com/persimmon-ai-labs/adept-inference
wget path/to/fuyu-8b-model-weights.tar
tar -xvf fuyu-8b-model-weights.tar
python src/transformers/models/fuyu/convert_fuyu_weights_to_hf.py  --input_dir /path/to/downloaded/fuyu/weights/ --output_dir /output/path \
    --pt_model_path /path/to/fuyu_8b_release/iter_0001251/mp_rank_00/model_optim_rng.pt
    --ada_lib_path /path/to/adept-inference

对于聊天模型：

wget https://axtkn4xl5cip.objectstorage.us-phoenix-1.oci.customer-oci.com/n/axtkn4xl5cip/b/adept-public-data/o/8b_chat_model_release.tar
tar -xvf 8b_base_model_release.tar

然后，模型可以通过以下方式加载：

from transformers import FuyuConfig, FuyuForCausalLM
model_config = FuyuConfig()
model = FuyuForCausalLM(model_config).from_pretrained('/output/path')

需要通过特定的处理器传递输入以获得正确的格式。处理器需要一个图像处理器和一个分词器。因此，输入可以通过以下方式加载：

from PIL import Image
from transformers import AutoTokenizer
from transformers.models.fuyu.processing_fuyu import FuyuProcessor
from transformers.models.fuyu.image_processing_fuyu import FuyuImageProcessor

tokenizer = AutoTokenizer.from_pretrained('adept-hf-collab/fuyu-8b')
image_processor = FuyuImageProcessor()

processor = FuyuProcessor(image_processor=image_processor, tokenizer=tokenizer)
text_prompt = "Generate a coco-style caption.\\n"

bus_image_url = "https://huggingface.co/datasets/hf-internal-testing/fixtures-captioning/resolve/main/bus.png"
bus_image_pil = Image.open(io.BytesIO(requests.get(bus_image_url).content))
inputs_to_model = processor(text=text_prompt, images=image_pil)

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

• Fuyu 使用基于sentencepiece的分词器，采用Unigram模型。它支持字节回退，仅在快速分词器的tokenizers==0.14.0中可用。LlamaTokenizer被用作它是句子片段的标准包装器。

• 作者建议为图像字幕使用以下提示：f"生成一个 coco 风格的字幕。\\n"

FuyuConfig

class transformers.FuyuConfig

<来源>

( vocab_size = 262144 hidden_size = 4096 intermediate_size = 16384 num_hidden_layers = 36 num_attention_heads = 64 hidden_act = 'relu2' max_position_embeddings = 16384 image_size = 300 patch_size = 30 num_channels = 3 initializer_range = 0.02 layer_norm_eps = 1e-05 use_cache = True tie_word_embeddings = False rope_theta = 25000.0 rope_scaling = None qk_layernorm = True hidden_dropout = 0.0 attention_dropout = 0.0 partial_rotary_factor = 0.5 pad_token_id = None bos_token_id = 1 eos_token_id = 2 text_config = None **kwargs )

参数

• vocab_size (int, optional, 默认为 262144) — Fuyu 模型的词汇表大小。定义了在调用 FuyuForCausalLM 时可以由inputs_ids表示的不同标记数量。

• hidden_size (int, optional, 默认为 4096) — 隐藏表示的维度。

• intermediate_size (int, optional, 默认为 16384) — MLP 表示的维度。

• num_hidden_layers (int, optional, 默认为 36) — Transformer 编码器中的隐藏层数量。

• num_attention_heads (int, optional, 默认为 64) — Transformer 编码器中每个注意力层的注意力头数量。

• hidden_act (str或function, optional, 默认为"relu2") — 解码器中的非线性激活函数（函数或字符串）。

• max_position_embeddings（int，可选，默认为 16384）-此模型可能使用的最大序列长度。

• image_size（int，可选，默认为 300）-输入图像大小。

• patch_size（int，可选，默认为 30）-输入视觉变换器编码块大小。

• num_channels（int，可选，默认为 3）-输入图像通道数。

• initializer_range（float，可选，默认为 0.02）-用于初始化所有权重矩阵的截断正态初始化器的标准差。

• layer_norm_eps（float，可选，默认为 1e-05）-rms 归一化层使用的 epsilon。

• use_cache（bool，可选，默认为True）-模型是否应返回最后的键/值注意力（不是所有模型都使用）。仅在config.is_decoder=True时相关。是否绑定权重嵌入

• tie_word_embeddings（bool，可选，默认为False）-是否绑定输入和输出嵌入。

• rope_theta（float，可选，默认为 25000.0）-RoPE 嵌入的基本周期。

• rope_scaling（Dict，可选）-包含 RoPE 嵌入的缩放配置的字典。当前支持两种缩放策略：线性和动态。它们的缩放因子必须是大于 1 的浮点数。预期格式为{"type"：策略名称，"factor"：缩放因子}。使用此标志时，不要将max_position_embeddings更新为预期的新最大值。有关这些缩放策略行为的更多信息，请参见以下线程：www.reddit.com/r/LocalFuyu/comments/14mrgpr/dynamically_scaled_rope_further_increases/。这是一个实验性功能，可能在将来的版本中会有破坏性的 API 更改。

• qk_layernorm（bool，可选，默认为True）-在投影隐藏状态后是否规范查询和键

• hidden_dropout（float，可选，默认为 0.0）-在将 MLP 应用于隐藏状态后的丢失比率。

• attention_dropout（float，可选，默认为 0.0）-计算注意力分数后的丢失比率。

• partial_rotary_factor（float，可选，默认为 0.5）-查询和键的百分比，将具有旋转嵌入。

• pad_token_id（int，可选）- 填充 标记的 ID。

• bos_token_id（int，可选，默认为 1）- 序列开始 标记的 ID。

• eos_token_id（Union[int，List[int]]，可选，默认为 2）- 序列结束 标记的 ID。可选择使用列表设置多个序列结束 标记。

• text_config（dict，可选）-用于初始化language```pyAut.

This is the configuration class to store the configuration of a FuyuForCausalLM. It is used to instantiate an Fuyu model according to the specified arguments, defining the model architecture. Instantiating a configuration with the defaults will yield a similar configuration to that of the adept/fuyu-8b.

Configuration objects inherit from PretrainedConfig and can be used to control the model outputs. Read the documentation from PretrainedConfig for more information.

从转换器导入 FuyuConfig

初始化 Fuyu fuyu-7b 风格配置

配置= FuyuConfig（）

```py

## FuyuForCausalLM

 ### `class transformers.FuyuForCausalLM`

[< source >](https://github.com/huggingface/transformers/blob/v4.37.2/src/transformers/models/fuyu/modeling_fuyu.py#L143)

```

（配置：FuyuConfig）

```py

Parameters

*   `config` (FuyuConfig) — Model configuration class with all the parameters of the model. Initializing with a config file does not load the weights associated with the model, only the configuration. Check out the from_pretrained() method to load the model weights.

Fuyu Model with a language modeling head on top for causal language model conditioned on image patches and text. This model inherits from PreTrainedModel. Check the superclass documentation for the generic methods the library implements for all its model (such as downloading or saving, resizing the input embeddings, pruning heads etc.)

This model is also a PyTorch [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) subclass. Use it as a regular PyTorch Module and refer to the PyTorch documentation for all matter related to general usage and behavior.

 #### `forward`

[< source >](https://github.com/huggingface/transformers/blob/v4.37.2/src/transformers/models/fuyu/modeling_fuyu.py#L210)

```

（input_ids：LongTensor = None image_patches：Tensor = None image_patches_indices：Tensor = None attention_mask：Optional = None position_ids：Optional = None past_key_values：Optional = None inputs_embeds：Optional = None use_cache：Optional = None labels：Optional = None output_attentions：Optional = None output_hidden_states：Optional = None return_dict：Optional = None）→导出常量元数据='未定义';transformers.modeling_outputs.CausalLMOutputWithPast 或元组（torch.FloatTensor）

```py

Parameters

*   `input_ids` (`torch.LongTensor` of shape `(batch_size, sequence_length)`) — Indices of input sequence tokens in the vocabulary. Padding will be ignored by default should you provide it.

    Indices can be obtained using AutoTokenizer. See PreTrainedTokenizer.encode() and PreTrainedTokenizer.`call`() for details.

    What are input IDs? 
*   `attention_mask` (`torch.Tensor` of shape `(batch_size, sequence_length)`, *optional*) — Mask to avoid performing attention on padding token indices. Mask values selected in `[0, 1]`:

    *   1 for tokens that are `not masked`,
    *   0 for tokens that are `masked`.

    What are attention masks?

    Indices can be obtained using AutoTokenizer. See PreTrainedTokenizer.encode() and PreTrainedTokenizer.`call`() for details.

    If `past_key_values` is used, optionally only the last `decoder_input_ids` have to be input (see `past_key_values`).

    If you want to change padding behavior, you should read `modeling_opt._prepare_decoder_attention_mask` and modify to your needs. See diagram 1 in [the paper](https://arxiv.org/abs/1910.13461) for more information on the default strategy.

    *   1 indicates the head is `not masked`,
    *   0 indicates the head is `masked`. 
*   `image_patches` (`torch.FloatTensor` of shape `(batch_size, num_total_patches, patch_size_ x patch_size x num_channels)`, *optional*) — Image patches to be used as continuous embeddings. The patches are flattened and then projected to the hidden size of the model.
*   `image_patches_indices` (`torch.LongTensor` of shape `(batch_size, num_total_patches + number_of_newline_tokens + number_of_text_tokens, patch_size_ x patch_size x num_channels )`, *optional*) — Indices indicating at which position the image_patches have to be inserted in input_embeds.
*   `position_ids` (`torch.LongTensor` of shape `(batch_size, sequence_length)`, *optional*) — Indices of positions of each input sequence tokens in the position embeddings. Selected in the range `[0, config.n_positions - 1]`.

    What are position IDs? 
*   `past_key_values` (`tuple(tuple(torch.FloatTensor))`, *optional*, returned when `use_cache=True` is passed or when `config.use_cache=True`) — Tuple of `tuple(torch.FloatTensor)` of length `config.n_layers`, with each tuple having 2 tensors of shape `(batch_size, num_heads, sequence_length, embed_size_per_head)`) and 2 additional tensors of shape `(batch_size, num_heads, encoder_sequence_length, embed_size_per_head)`.

    Contains pre-computed hidden-states (key and values in the self-attention blocks and in the cross-attention blocks) that can be used (see `past_key_values` input) to speed up sequential decoding.

    If `past_key_values` are used, the user can optionally input only the last `decoder_input_ids` (those that don’t have their past key value states given to this model) of shape `(batch_size, 1)` instead of all `decoder_input_ids` of shape `(batch_size, sequence_length)`. 
*   `inputs_embeds` (`torch.FloatTensor` of shape `(batch_size, sequence_length, hidden_size)`, *optional*) — Optionally, instead of passing `input_ids` you can choose to directly pass an embedded representation. This is useful if you want more control over how to convert `input_ids` indices into associated vectors than the model’s internal embedding lookup matrix.
*   `use_cache` (`bool`, *optional*) — If set to `True`, `past_key_values` key value states are returned and can be used to speed up decoding (see `past_key_values`).
*   `output_attentions` (`bool`, *optional*) — Whether or not to return the attentions tensors of all attention layers. See `attentions` under returned tensors for more detail.
*   `output_hidden_states` (`bool`, *optional*) — Whether or not to return the hidden states of all layers. See `hidden_states` under returned tensors for more detail.
*   `return_dict` (`bool`, *optional*) — Whether or not to return a ModelOutput instead of a plain tuple.
*   `labels` (`torch.LongTensor` of shape `(batch_size, sequence_length)`, *optional*) — Labels for computing the masked language modeling loss. Indices should either be in `[0, ..., config.vocab_size]` or -100 (see `input_ids` docstring). Tokens with indices set to `-100` are ignored (masked), the loss is only computed for the tokens with labels in `[0, ..., config.vocab_size]`.

Returns

transformers.modeling_outputs.CausalLMOutputWithPast or `tuple(torch.FloatTensor)`

A transformers.modeling_outputs.CausalLMOutputWithPast or a tuple of `torch.FloatTensor` (if `return_dict=False` is passed or when `config.return_dict=False`) comprising various elements depending on the configuration (FuyuConfig) and inputs.

*   `loss` (`torch.FloatTensor` of shape `(1,)`, *optional*, returned when `labels` is provided) — Language modeling loss (for next-token prediction).

*   `logits` (`torch.FloatTensor` of shape `(batch_size, sequence_length, config.vocab_size)`) — Prediction scores of the language modeling head (scores for each vocabulary token before SoftMax).

*   `past_key_values` (`tuple(tuple(torch.FloatTensor))`, *optional*, returned when `use_cache=True` is passed or when `config.use_cache=True`) — Tuple of `tuple(torch.FloatTensor)` of length `config.n_layers`, with each tuple having 2 tensors of shape `(batch_size, num_heads, sequence_length, embed_size_per_head)`)

    Contains pre-computed hidden-states (key and values in the self-attention blocks) that can be used (see `past_key_values` input) to speed up sequential decoding.

*   `hidden_states` (`tuple(torch.FloatTensor)`, *optional*, returned when `output_hidden_states=True` is passed or when `config.output_hidden_states=True`) — Tuple of `torch.FloatTensor` (one for the output of the embeddings, if the model has an embedding layer, + one for the output of each layer) of shape `(batch_size, sequence_length, hidden_size)`.

    Hidden-states of the model at the output of each layer plus the optional initial embedding outputs.

*   `attentions` (`tuple(torch.FloatTensor)`, *optional*, returned when `output_attentions=True` is passed or when `config.output_attentions=True`) — Tuple of `torch.FloatTensor` (one for each layer) of shape `(batch_size, num_heads, sequence_length, sequence_length)`.

    Attentions weights after the attention softmax, used to compute the weighted average in the self-attention heads.

The FuyuForCausalLM forward method, overrides the `__call__` special method.

Although the recipe for forward pass needs to be defined within this function, one should call the `Module` instance afterwards instead of this since the former takes care of running the pre and post processing steps while the latter silently ignores them.

Examples:

```

从转换器导入 FuyuProcessor，FuyuForCausalLM

从 PIL 导入图像

导入请求

处理器= FuyuProcessor.from_pretrained（“adept/fuyu-8b”）

模型= FuyuForCausalLM.from_pretrained（“adept/fuyu-8b”）

网址=“http://images.cocodataset.org/val2017/000000039769.jpg”

图像 = Image.open(requests.get(url, stream=True).raw)

提示=“生成一个 coco 风格的标题。\n”

输入=处理器（文本= text_prompt，图像=图像，return_tensors=“pt”）

输出=模型（**输入）

>>> generated_ids = model.generate(**model_inputs, max_new_tokens=7)

>>> generation_text = processor.batch_decode(generated_ids, skip_special_tokens=True)

>>> print(generation_text)

“停在路边的公共汽车。”

```py

## FuyuImageProcessor

 ### `class transformers.FuyuImageProcessor`

[< source >](https://github.com/huggingface/transformers/blob/v4.37.2/src/transformers/models/fuyu/image_processing_fuyu.py#L180)

```

（do_resize: bool=True size: Optional=None resample: Resampling=<Resampling.BILINEAR: 2> do_pad: bool=True padding_value: float=1.0 padding_mode: str='constant' do_normalize: bool=True image_mean: Union=0.5 image_std: Union=0.5 do_rescale: bool=True rescale_factor: float=0.00392156862745098 patch_size: Optional=None **kwargs）

```py

Parameters

*   `do_resize` (`bool`, *optional*, defaults to `True`) — Whether to resize the image to `size`.
*   `size` (`Dict[str, int]`, *optional*, defaults to `{"height" -- 1080, "width": 1920}`): Dictionary in the format `{"height": int, "width": int}` specifying the size of the output image.
*   `resample` (`PILImageResampling`, *optional*, defaults to `Resampling.BILINEAR`) — `PILImageResampling` filter to use when resizing the image e.g. `PILImageResampling.BILINEAR`.
*   `do_pad` (`bool`, *optional*, defaults to `True`) — Whether to pad the image to `size`.
*   `padding_value` (`float`, *optional*, defaults to 1.0) — The value to pad the image with.
*   `padding_mode` (`str`, *optional*, defaults to `"constant"`) — The padding mode to use when padding the image.
*   `do_normalize` (`bool`, *optional*, defaults to `True`) — Whether to normalize the image.
*   `image_mean` (`float`, *optional*, defaults to 0.5) — The mean to use when normalizing the image.
*   `image_std` (`float`, *optional*, defaults to 0.5) — The standard deviation to use when normalizing the image.
*   `do_rescale` (`bool`, *optional*, defaults to `True`) — Whether to rescale the image.
*   `rescale_factor` (`float`, *optional*, defaults to `1 / 255`) — The factor to use when rescaling the image.
*   `patch_size` (`Dict[str, int]`, *optional*, defaults to `{"height" -- 30, "width": 30}`): Dictionary in the format `{"height": int, "width": int}` specifying the size of the patches.

This class should handle the image processing part before the main FuyuForCausalLM. In particular, it should handle:

*   Processing Images: Taking a batch of images as input. If the images are variable-sized, it resizes them based on the desired patch dimensions. The image output is always img_h, img_w of (1080, 1920)

    Then, it patches up these images using the patchify_image function.

*   Creating Image Input IDs: For each patch, a placeholder ID is given to identify where these patches belong in a token sequence. For variable-sized images, each line of patches is terminated with a newline ID.

*   Image Patch Indices: For each image patch, the code maintains an index where these patches should be inserted in a token stream.

 #### `__call__`

[< source >](https://github.com/huggingface/transformers/blob/v4.37.2/src/transformers/image_processing_utils.py#L550)

```

（images **kwargs）

```py

Preprocess an image or a batch of images.

## FuyuProcessor

 ### `class transformers.FuyuProcessor`

[< source >](https://github.com/huggingface/transformers/blob/v4.37.2/src/transformers/models/fuyu/processing_fuyu.py#L309)

```

（图像处理器 标记器）

```py

Parameters

*   `image_processor` (FuyuImageProcessor) — The image processor is a required input.
*   `tokenizer` (LlamaTokenizerFast) — The tokenizer is a required input.

Constructs a Fuyu processor which wraps a Fuyu image processor and a Llama tokenizer into a single processor.

FuyuProcessor offers all the functionalities of FuyuImageProcessor and LlamaTokenizerFast. See the **call**() and `decode()` for more information.

 #### `__call__`

[< source >](https://github.com/huggingface/transformers/blob/v4.37.2/src/transformers/models/fuyu/processing_fuyu.py#L451)

```

（text=None images=None add_special_tokens: bool=True return_attention_mask: bool=True padding: Union=False truncation: Union=None max_length: Optional=None stride: int=0 pad_to_multiple_of: Optional=None return_overflowing_tokens: bool=False return_special_tokens_mask: bool=False return_offsets_mapping: bool=False return_token_type_ids: bool=False return_length: bool=False verbose: bool=True return_tensors: Union=None **kwargs）→ export const metadata = 'undefined';FuyuBatchEncoding

```

参数

+   `text`（`str`，`List[str]`）— 要编码的序列或序列批次。每个序列可以是字符串或字符串列表（预标记化字符串）。如果将序列提供为字符串列表（预标记化），则必须设置`is_split_into_words=True`（以消除与序列批次的歧义）。

+   `images`（`PIL.Image.Image`，`List[PIL.Image.Image]`）— 要准备的图像或图像批次。每个图像可以是 PIL 图像、NumPy 数组或 PyTorch 张量。对于 NumPy 数组/PyTorch 张量，每个图像的形状应为（C，H，W），其中 C 是通道数，H 和 W 是图像的高度和宽度。

返回

`FuyuBatchEncoding`

一个具有以下字段的`FuyuBatchEncoding`：

+   `input_ids` — 要提供给模型的标记 id 张量。当`text`不是`None`时返回。

+   `image_patches` — 图像补丁张量列表。当`images`不是`None`时返回。

+   `image_patches_indices` — 指示模型应插入补丁嵌入的索引张量。

+   `attention_mask` — 指定模型在`return_attention_mask=True`时应关注哪些标记的索引列表。

准备模型一个或多个序列和图像的主要方法。如果`text`不是`None`，此方法将`text`和`kwargs`参数转发给 LlamaTokenizerFast 的**call**()以对文本进行编码。要准备图像，如果`images`不是`None`，此方法将`images`和`kwargs`参数转发给 FuyuImageProcessor 的**call**()。有关更多信息，请参考上述两种方法的文档。


# OpenAI GPT

> 原始文本：[`huggingface.co/docs/transformers/v4.37.2/en/model_doc/openai-gpt`](https://huggingface.co/docs/transformers/v4.37.2/en/model_doc/openai-gpt)

![模型](https://huggingface.co/models?filter=openai-gpt) ![空间](https://huggingface.co/spaces/docs-demos/openai-gpt)

## 概述

OpenAI GPT 模型是由 Alec Radford、Karthik Narasimhan、Tim Salimans 和 Ilya Sutskever 在[通过生成预训练改进语言理解](https://s3-us-west-2.amazonaws.com/openai-assets/research-covers/language-unsupervised/language_understanding_paper.pdf)中提出的。它是一个使用语言建模在大型语料库上进行预训练的因果（单向）变压器，具有长距离依赖性，多伦多图书语料库。

论文摘要如下：

*自然语言理解包括各种不同的任务，如文本蕴涵、问题回答、语义相似性评估和文档分类。尽管大量未标记的文本语料库丰富，但用于学习这些特定任务的标记数据稀缺，这使得经过区分训练的模型难以表现出色。我们证明，通过在多样化的未标记文本语料库上对语言模型进行生成预训练，然后在每个特定任务上进行区分微调，可以实现这些任务的大幅提升。与以往方法相反，我们在微调过程中利用任务感知的输入转换，实现有效的迁移，同时对模型架构进行最小的更改。我们在自然语言理解的广泛基准上展示了我们方法的有效性。我们的通用任务不可知模型在 9 个研究的 12 个任务中优于使用专门为每个任务精心设计的架构的经过区分训练的模型，显著改进了技术水平。*

[使用 Transformer 写作](https://transformer.huggingface.co/doc/gpt)是由 Hugging Face 创建和托管的网络应用程序，展示了几种模型的生成能力。GPT 是其中之一。

此模型由[thomwolf](https://huggingface.co/thomwolf)贡献。原始代码可以在[此处](https://github.com/openai/finetune-transformer-lm)找到。

## 使用提示

+   GPT 是一个具有绝对位置嵌入的模型，因此通常建议在右侧而不是左侧填充输入。

+   GPT 是通过因果语言建模（CLM）目标进行训练的，因此在预测序列中的下一个标记时非常强大。利用这一特性使 GPT-2 能够生成句法连贯的文本，可以在*run_generation.py*示例脚本中观察到。

注意：

如果您想复制*OpenAI GPT*论文的原始标记化过程，您需要安装`ftfy`和`SpaCy`：

```py
pip install spacy ftfy==4.4.3
python -m spacy download en
```

如果您没有安装`ftfy`和`SpaCy`，OpenAIGPTTokenizer 将默认使用 BERT 的`BasicTokenizer`进行标记化，然后是字节对编码（对于大多数用途来说应该没问题，不用担心）。

## 资源

官方 Hugging Face 和社区（由🌎表示）资源列表，可帮助您开始使用 OpenAI GPT。如果您有兴趣提交资源以包含在此处，请随时打开 Pull Request，我们将进行审查！资源应该理想地展示一些新东西，而不是重复现有资源。

文本分类

+   一篇关于[使用 SetFit 在文本分类中胜过 OpenAI GPT-3 的博客文章](https://www.philschmid.de/getting-started-setfit)。

+   另请参阅：文本分类任务指南

文本生成

+   关于如何[使用 Hugging Face 对非英语 GPT-2 模型进行微调](https://www.philschmid.de/fine-tune-a-non-english-gpt-2-model-with-huggingface)的博客。

+   一篇关于如何使用 GPT-2 进行文本生成的博客：[使用不同解码方法进行语言生成与 Transformers](https://huggingface.co/blog/how-to-generate)。

+   一篇关于从头开始训练 [CodeParrot 🦜 的博客](https://huggingface.co/blog/codeparrot)，一个大型的 GPT-2 模型。

+   一篇关于如何使用 GPT-2 进行 [更快的文本生成与 TensorFlow 和 XLA](https://huggingface.co/blog/tf-xla-generate) 的博客。

+   一篇关于如何使用 GPT-2 模型 [训练语言模型与 Megatron-LM](https://huggingface.co/blog/megatron-training) 的博客。

+   一篇关于如何 [微调 GPT2 以生成您最喜爱艺术家风格的歌词](https://colab.research.google.com/github/AlekseyKorshuk/huggingartists/blob/master/huggingartists-demo.ipynb) 的笔记本。🌎

+   一篇关于如何 [微调 GPT2 以生成您最喜爱 Twitter 用户风格的推文](https://colab.research.google.com/github/borisdayma/huggingtweets/blob/master/huggingtweets-demo.ipynb) 的笔记本。🌎

+   🤗 Hugging Face 课程的 [因果语言建模](https://huggingface.co/course/en/chapter7/6?fw=pt#training-a-causal-language-model-from-scratch) 章节。

+   OpenAIGPTLMHeadModel 在这个 [因果语言建模示例脚本](https://github.com/huggingface/transformers/tree/main/examples/pytorch/language-modeling#gpt-2gpt-and-causal-language-modeling)、[文本生成示例脚本](https://github.com/huggingface/transformers/blob/main/examples/pytorch/text-generation/run_generation.py) 和 [笔记本](https://colab.research.google.com/github/huggingface/notebooks/blob/main/examples/language_modeling.ipynb) 中得到支持。

+   TFOpenAIGPTLMHeadModel 在这个 [因果语言建模示例脚本](https://github.com/huggingface/transformers/tree/main/examples/tensorflow/language-modeling#run_clmpy) 和 [笔记本](https://colab.research.google.com/github/huggingface/notebooks/blob/main/examples/language_modeling-tf.ipynb) 中得到支持。

+   另请参阅：因果语言建模任务指南

标记分类

+   有关 [字节对编码标记化](https://huggingface.co/course/en/chapter6/5) 的课程材料。

## OpenAIGPTConfig

### `class transformers.OpenAIGPTConfig`

[< source >](https://github.com/huggingface/transformers/blob/v4.37.2/src/transformers/models/openai/configuration_openai.py#L27)

```py
( vocab_size = 40478 n_positions = 512 n_embd = 768 n_layer = 12 n_head = 12 afn = 'gelu' resid_pdrop = 0.1 embd_pdrop = 0.1 attn_pdrop = 0.1 layer_norm_epsilon = 1e-05 initializer_range = 0.02 summary_type = 'cls_index' summary_use_proj = True summary_activation = None summary_proj_to_labels = True summary_first_dropout = 0.1 **kwargs )
```

参数

+   `vocab_size` (`int`, *可选*, 默认为 40478) — GPT-2 模型的词汇大小。定义了在调用 OpenAIGPTModel 或 TFOpenAIGPTModel 时可以表示的不同标记数量。

+   `n_positions` (`int`, *可选*, 默认为 512) — 此模型可能会使用的最大序列长度。通常设置为较大的值以防万一（例如，512、1024 或 2048）。

+   `n_embd` (`int`, *可选*, 默认为 768) — 嵌入和隐藏状态的维度。

+   `n_layer` (`int`, *可选*, 默认为 12) — Transformer 编码器中的隐藏层数。

+   `n_head` (`int`, *可选*, 默认为 12) — Transformer 编码器中每个注意力层的注意力头数。

+   `afn` (`str` 或 `Callable`, *可选*, 默认为 `"gelu"`) — 编码器和池化器中的非线性激活函数（函数或字符串）。如果是字符串，支持 `"gelu"`, `"relu"`, `"silu"` 和 `"gelu_new"`。

+   `resid_pdrop` (`float`, *可选*, 默认为 0.1) — 嵌入、编码器和池化器中所有全连接层的丢弃概率。

+   `embd_pdrop` (`int`, *可选*, 默认为 0.1) — 嵌入的丢弃比率。

+   `attn_pdrop` (`float`, *可选*, 默认为 0.1) — 注意力的丢弃比率。

+   `layer_norm_epsilon` (`float`, *可选*, 默认为 1e-05) — 在层归一化层中使用的 epsilon

+   `initializer_range` (`float`, *可选*, 默认为 0.02) — 用于初始化所有权重矩阵的截断正态初始化器的标准差。

+   `summary_type` (`str`, *可选*, 默认为 `"cls_index"`) — 在进行序列摘要时使用的参数，在模型 OpenAIGPTDoubleHeadsModel 和 OpenAIGPTDoubleHeadsModel 中使用。

    必须是以下选项之一：

    +   `"last"`: 获取最后一个标记的隐藏状态（类似于 XLNet）。

    +   `"first"`: 获取第一个标记的隐藏状态（类似于 BERT）。

    +   `"mean"`: 获取所有标记的隐藏状态的平均值。

    +   `"cls_index"`: 提供一个分类标记位置的张量（类似于 GPT/GPT-2）。

    +   `"attn"`: 目前未实现，使用多头注意力。

+   `summary_use_proj` (`bool`, *可选*, 默认为 `True`) — 在进行序列摘要时使用的参数，在模型 OpenAIGPTDoubleHeadsModel 和 OpenAIGPTDoubleHeadsModel 中使用。

    是否在向量提取后添加投影。

+   `summary_activation` (`str`, *可选*) — 在进行序列摘要时使用的参数，在模型 OpenAIGPTDoubleHeadsModel 和 OpenAIGPTDoubleHeadsModel 中使用。

    将 `"tanh"` 传递给输出以获得双曲正切激活，其他任何值都将导致无激活。

+   `summary_proj_to_labels` (`bool`, *可选*, 默认为 `True`) — 在进行序列摘要时使用的参数，在模型 OpenAIGPTDoubleHeadsModel 和 OpenAIGPTDoubleHeadsModel 中使用。

    投影输出应具有 `config.num_labels` 或 `config.hidden_size` 类。

+   `summary_first_dropout` (`float`, *可选*, 默认为 0.1) — 在进行序列摘要时使用的参数，在模型 OpenAIGPTDoubleHeadsModel 和 OpenAIGPTDoubleHeadsModel 中使用。

    在投影和激活之后使用的辍学比例。

这是用于存储 OpenAIGPTModel 或 TFOpenAIGPTModel 配置的配置类。它用于根据指定的参数实例化一个 GPT 模型，定义模型架构。使用默认值实例化配置将产生类似于 OpenAI 的 GPT [openai-gpt](https://huggingface.co/openai-gpt)架构的配置。

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

示例：

```py
>>> from transformers import OpenAIGPTConfig, OpenAIGPTModel

>>> # Initializing a GPT configuration
>>> configuration = OpenAIGPTConfig()

>>> # Initializing a model (with random weights) from the configuration
>>> model = OpenAIGPTModel(configuration)

>>> # Accessing the model configuration
>>> configuration = model.config
```

## OpenAIGPTTokenizer

### `class transformers.OpenAIGPTTokenizer`

[< source >](https://github.com/huggingface/transformers/blob/v4.37.2/src/transformers/models/openai/tokenization_openai.py#L245)

```py
( vocab_file merges_file unk_token = '<unk>' **kwargs )
```

参数

+   `vocab_file` (`str`) — 词汇文件的路径。

+   `merges_file` (`str`) — 合并文件的路径。

+   `unk_token`（`str`，*可选*，默认为`"<unk>"`）- 未知标记。词汇表中不存在的标记无法转换为 ID，而是设置为此标记。

构建一个 GPT 分词器。基于字节对编码，具有以下特点：

+   将所有输入转换为小写，

+   如果安装了`SpaCy`分词器和`ftfy`，则使用它们进行 BPE 标记化，否则回退到 BERT 的`BasicTokenizer`。

此分词器继承自 PreTrainedTokenizer，其中包含大多数主要方法。用户应参考此超类以获取有关这些方法的更多信息。

#### `save_vocabulary`

[<来源>](https://github.com/huggingface/transformers/blob/v4.37.2/src/transformers/models/openai/tokenization_openai.py#L378)

```py
( save_directory: str filename_prefix: Optional = None )
```

## OpenAIGPTTokenizerFast

### `class transformers.OpenAIGPTTokenizerFast`

[<来源>](https://github.com/huggingface/transformers/blob/v4.37.2/src/transformers/models/openai/tokenization_openai_fast.py#L40)

```py
( vocab_file = None merges_file = None tokenizer_file = None unk_token = '<unk>' **kwargs )
```

参数

+   `vocab_file`（`str`）- 词汇表文件的路径。

+   `merges_file`（`str`）- 合并文件的路径。

+   `unk_token`（`str`，*可选*，默认为`"<unk>"`）- 未知标记。词汇表中不存在的标记无法转换为 ID，而是设置为此标记。

构建一个“快速”GPT 分词器（由 HuggingFace 的*tokenizers*库支持）。基于字节对编码，具有以下特点：

+   将所有输入转换为小写

+   使用 BERT 的 BasicTokenizer 进行 BPE 标记化

此分词器继承自 PreTrainedTokenizerFast，其中包含大多数主要方法。用户应参考此超类以获取有关这些方法的更多信息。

## OpenAI 特定输出

### `class transformers.models.openai.modeling_openai.OpenAIGPTDoubleHeadsModelOutput`

[<来源>](https://github.com/huggingface/transformers/blob/v4.37.2/src/transformers/models/openai/modeling_openai.py#L297)

```py
( loss: Optional = None mc_loss: Optional = None logits: FloatTensor = None mc_logits: FloatTensor = None hidden_states: Optional = None attentions: Optional = None )
```

参数

+   `loss`（形状为`(1,)`的`torch.FloatTensor`，*可选*，在提供`labels`时返回）- 语言建模损失。

+   `mc_loss`（形状为`(1,)`的`torch.FloatTensor`，*可选*，在提供`mc_labels`时返回）- 多项选择分类损失。

+   `logits`（形状为`(batch_size, num_choices, sequence_length, config.vocab_size)`的`torch.FloatTensor`）- 语言建模头的预测分数（SoftMax 之前每个词汇标记的分数）。

+   `mc_logits`（形状为`(batch_size, num_choices)`的`torch.FloatTensor`）- 多项选择分类头的预测分数（SoftMax 之前每个选择的分数）。

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

用于预测两个句子是否连续的模型输出的基类。

### `class transformers.models.openai.modeling_tf_openai.TFOpenAIGPTDoubleHeadsModelOutput`

[<来源>](https://github.com/huggingface/transformers/blob/v4.37.2/src/transformers/models/openai/modeling_tf_openai.py#L413)

```py
( logits: tf.Tensor = None mc_logits: tf.Tensor = None hidden_states: Tuple[tf.Tensor] | None = None attentions: Tuple[tf.Tensor] | None = None )
```

参数

+   `logits`（形状为`(batch_size, num_choices, sequence_length, config.vocab_size)`的`tf.Tensor`）- 语言建模头的预测分数（SoftMax 之前每个词汇标记的分数）。

+   `mc_logits` (`tf.Tensor`，形状为 `(batch_size, num_choices)`) — 多项选择分类头的预测分数（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` 元组（每层一个）。

    注意力权重在注意力 softmax 之后，用于计算自注意力头中的加权平均值。

模型输出的基类，用于预测两个句子是否连续。

PytorchHide Pytorch 内容

## OpenAIGPTModel

### `class transformers.OpenAIGPTModel`

[<来源>](https://github.com/huggingface/transformers/blob/v4.37.2/src/transformers/models/openai/modeling_openai.py#L398)

```py
( config )
```

参数

+   `config` (OpenAIGPTConfig) — 包含模型所有参数的模型配置类。使用配置文件初始化不会加载与模型相关的权重，只加载配置。查看 from_pretrained() 方法以加载模型权重。

裸的 OpenAI GPT 变压器模型输出原始隐藏状态，没有特定的头部。

此模型继承自 PreTrainedModel。查看超类文档以了解库为所有模型实现的通用方法（如下载或保存、调整输入嵌入、修剪头等）。

此模型也是 PyTorch [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) 的子类。将其用作常规的 PyTorch 模块，并参考 PyTorch 文档以了解一般用法和行为相关的所有事项。

#### `forward`

[<来源>](https://github.com/huggingface/transformers/blob/v4.37.2/src/transformers/models/openai/modeling_openai.py#L428)

```py
( 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 output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None ) → export const metadata = 'undefined';transformers.modeling_outputs.BaseModelOutput 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]` 中选择：

    +   对于未被 `masked` 的标记为 1，

    +   对于被 `masked` 的标记为 0。

    什么是注意力掩码？

+   `token_type_ids` (`torch.LongTensor`，形状为 `(batch_size, sequence_length)`，*可选*) — 指示输入的第一部分和第二部分的段标记索引。索引在 `[0, 1]` 中选择：

    +   0 对应于一个 *句子 A* 标记，

    +   1 对应于一个 *句子 B* 标记。

    什么是标记类型 ID？

+   `position_ids` (`torch.LongTensor`，形状为 `(batch_size, sequence_length)`，*可选*) — 每个输入序列标记在位置嵌入中的位置索引。选择范围为 `[0, config.max_position_embeddings - 1]`。

    什么是位置 ID？

+   `head_mask` (`torch.FloatTensor`，形状为`(num_heads,)`或`(num_layers, num_heads)`，*可选*) — 用于使自注意力模块中的选定头部失效的掩码。掩码值选定在`[0, 1]`之间：

    +   1 表示头部未被`masked`，

    +   0 表示头部被`masked`。

+   `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 而不是普通元组。

返回

transformers.modeling_outputs.BaseModelOutput 或`tuple(torch.FloatTensor)`

transformers.modeling_outputs.BaseModelOutput 或一个`torch.FloatTensor`元组（如果传递`return_dict=False`或当`config.return_dict=False`时）包含各种元素，取决于配置(OpenAIGPTConfig)和输入。

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

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

OpenAIGPTModel 的前向方法，覆盖了`__call__`特殊方法。

虽然前向传递的步骤需要在此函数内定义，但应该在此之后调用`Module`实例，而不是在此处调用，因为前者负责运行预处理和后处理步骤，而后者会默默地忽略它们。

示例：

```py
>>> from transformers import AutoTokenizer, OpenAIGPTModel
>>> import torch

>>> tokenizer = AutoTokenizer.from_pretrained("openai-gpt")
>>> model = OpenAIGPTModel.from_pretrained("openai-gpt")

>>> inputs = tokenizer("Hello, my dog is cute", return_tensors="pt")
>>> outputs = model(**inputs)

>>> last_hidden_states = outputs.last_hidden_state
```

## OpenAIGPTLMHeadModel

### `class transformers.OpenAIGPTLMHeadModel`

[<来源>](https://github.com/huggingface/transformers/blob/v4.37.2/src/transformers/models/openai/modeling_openai.py#L526)

```py
( config )
```

参数

+   `config` (OpenAIGPTConfig) — 模型的所有参数的模型配置类。使用配置文件初始化不会加载与模型相关的权重，只会加载配置。查看 from_pretrained()方法以加载模型权重。

OpenAI GPT 模型变压器，顶部带有语言建模头（线性层，其权重与输入嵌入绑定）。

此模型继承自 PreTrainedModel。检查超类文档以获取库实现的所有模型的通用方法（例如下载或保存、调整输入嵌入、修剪头等）。

此模型还是 PyTorch [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module)子类。将其用作常规 PyTorch 模块，并参考 PyTorch 文档以获取有关一般用法和行为的所有相关信息。

#### `forward`

[<来源>](https://github.com/huggingface/transformers/blob/v4.37.2/src/transformers/models/openai/modeling_openai.py#L550)

```py
( 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 labels: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None ) → export const metadata = 'undefined';transformers.modeling_outputs.CausalLMOutput 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 表示未被`masked`的令牌，

    +   0 表示被`masked`的令牌。

    什么是注意力掩码？

+   `token_type_ids` (`torch.LongTensor`，形状为`(batch_size, sequence_length)`，*可选*) — 段令牌索引，指示输入的第一部分和第二部分。索引在`[0, 1]`中选择：

    +   0 对应于*句子 A*令牌，

    +   1 对应于*句子 B*令牌。

    什么是令牌类型 ID？

+   `position_ids` (`torch.LongTensor`，形状为`(batch_size, sequence_length)`，*可选*) — 每个输入序列令牌在位置嵌入中的位置索引。选择范围为`[0, config.max_position_embeddings - 1]`。

    什么是位置 ID？

+   `head_mask` (`torch.FloatTensor`，形状为`(num_heads,)`或`(num_layers, num_heads)`，*可选*) — 用于使自注意力模块中选择的头部失效的掩码。掩码值在`[0, 1]`中选择：

    +   1 表示头部未被`masked`，

    +   0 表示头部被`masked`。

+   `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 而不是一个普通的元组。

+   `labels` (`torch.LongTensor`，形状为`(batch_size, sequence_length)`，*可选*) — 用于语言建模的标签。请注意，模型内部的标签**已经被移位**，即您可以设置`labels = input_ids`。索引在`[-100, 0, ..., config.vocab_size]`中选择。所有设置为`-100`的标签都被忽略（掩码），损失仅计算在`[0, ..., config.vocab_size]`中的标签。

返回

transformers.modeling_outputs.CausalLMOutput 或`tuple(torch.FloatTensor)`

一个 transformers.modeling_outputs.CausalLMOutput 或一个`torch.FloatTensor`元组（如果传递`return_dict=False`或`config.return_dict=False`）包含根据配置（OpenAIGPTConfig）和输入的各种元素。

+   `loss`（形状为`(1,)`的`torch.FloatTensor`，*可选*，当提供`labels`时返回）— 语言建模损失（用于下一个标记预测）。

+   `logits`（形状为`(batch_size, sequence_length, config.vocab_size)`的`torch.FloatTensor`）— 语言建模头的预测分数（SoftMax 之前每个词汇标记的分数）。

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

OpenAIGPTLMHeadModel 的前向方法，覆盖了`__call__`特殊方法。

虽然前向传递的步骤需要在此函数内定义，但应该在此之后调用`Module`实例，而不是在此处调用，因为前者负责运行预处理和后处理步骤，而后者则默默地忽略它们。

示例：

```py
>>> import torch
>>> from transformers import AutoTokenizer, OpenAIGPTLMHeadModel

>>> tokenizer = AutoTokenizer.from_pretrained("openai-gpt")
>>> model = OpenAIGPTLMHeadModel.from_pretrained("openai-gpt")

>>> inputs = tokenizer("Hello, my dog is cute", return_tensors="pt")
>>> outputs = model(**inputs, labels=inputs["input_ids"])
>>> loss = outputs.loss
>>> logits = outputs.logits
```

## OpenAIGPTDoubleHeadsModel

### `class transformers.OpenAIGPTDoubleHeadsModel`

[<来源>](https://github.com/huggingface/transformers/blob/v4.37.2/src/transformers/models/openai/modeling_openai.py#L615)

```py
( config )
```

参数

+   `config`（OpenAIGPTConfig）— 具有模型所有参数的模型配置类。使用配置文件初始化不会加载与模型相关的权重，只加载配置。查看 from_pretrained()方法以加载模型权重。

OpenAI GPT 模型变压器，顶部带有语言建模和多选分类头，例如用于 RocStories/SWAG 任务。这两个头是两个线性层。语言建模头的权重与输入嵌入绑定，分类头以指定的分类标记索引的输入作为输入序列的输入）。

这个模型继承自 PreTrainedModel。检查超类文档以获取库为所有模型实现的通用方法（如下载或保存、调整输入嵌入、修剪头等）。

这个模型也是一个 PyTorch [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module)子类。将其用作常规的 PyTorch 模块，并参考 PyTorch 文档以获取与一般用法和行为相关的所有内容。

#### `forward`

[<来源>](https://github.com/huggingface/transformers/blob/v4.37.2/src/transformers/models/openai/modeling_openai.py#L644)

```py
( 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 mc_token_ids: Optional = None labels: Optional = None mc_labels: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None ) → export const metadata = 'undefined';transformers.models.openai.modeling_openai.OpenAIGPTDoubleHeadsModelOutput or tuple(torch.FloatTensor)
```

参数

+   `input_ids`（形状为`(batch_size, sequence_length)`的`torch.LongTensor`）— 词汇表中输入序列标记的索引。

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

    什么是输入 ID？

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

    +   1 表示未被掩盖的标记，

    +   0 表示被掩盖的标记。

    什么是注意力掩码？

+   `token_type_ids` (`torch.LongTensor` of shape `(batch_size, sequence_length)`, *optional*) — 指示输入的第一部分和第二部分的段标记索引。索引选择在`[0, 1]`中：

    +   0 对应于*句子 A*标记，

    +   1 对应于*句子 B*标记。

    什么是标记类型 ID？

+   `position_ids` (`torch.LongTensor` of shape `(batch_size, sequence_length)`, *optional*) — 每个输入序列标记在位置嵌入中的位置索引。选择范围为`[0, config.max_position_embeddings - 1]`。

    什么是位置 ID？

+   `head_mask` (`torch.FloatTensor` of shape `(num_heads,)` or `(num_layers, num_heads)`, *optional*) — 用于使自注意力模块的选定头部无效的掩码。掩码值选择在`[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`, *optional*) — 是否返回所有层的隐藏状态。有关更多详细信息，请参见返回张量下的`hidden_states`。

+   `return_dict` (`bool`, *optional*) — 是否返回 ModelOutput 而不是普通元组。

+   `mc_token_ids` (`torch.LongTensor` of shape `(batch_size, num_choices)`, *optional*, 默认为输入的最后一个标记的索引) — 每个输入序列中分类标记的索引。选择范围为`[0, input_ids.size(-1) - 1]`。

+   `labels` (`torch.LongTensor` of shape `(batch_size, sequence_length)`, *optional*) — 用于语言建模的标签。请注意，模型内部的标签**已经移位**，即您可以设置`labels = input_ids`。索引选择在`[-1, 0, ..., config.vocab_size]`中。所有设置为`-100`的标签都被忽略（掩盖），损失仅计算在`[0, ..., config.vocab_size]`中的标签。

+   `mc_labels` (`torch.LongTensor` of shape `(batch_size)`, *optional*) — 用于计算多项选择分类损失的标签。索引应在`[0, ..., num_choices]`中，其中*num_choices*是输入张量第二维的大小。（参见上面的*input_ids*）

返回

transformers.models.openai.modeling_openai.OpenAIGPTDoubleHeadsModelOutput 或 `tuple(torch.FloatTensor)`

一个 transformers.models.openai.modeling_openai.OpenAIGPTDoubleHeadsModelOutput 或一个`torch.FloatTensor`元组（如果传递了`return_dict=False`或`config.return_dict=False`时）包含根据配置（OpenAIGPTConfig）和输入不同元素。

+   `loss`（`torch.FloatTensor`，形状为`(1,)`，*可选*，在提供`labels`时返回）— 语言建模损失。

+   `mc_loss`（`torch.FloatTensor`，形状为`(1,)`，*可选*，在提供`mc_labels`时返回）— 多项选择分类损失。

+   `logits`（`torch.FloatTensor`，形状为`(batch_size, num_choices, sequence_length, config.vocab_size)`）— 语言建模头的预测分数（SoftMax 之前每个词汇标记的分数）。

+   `mc_logits`（`torch.FloatTensor`，形状为`(batch_size, num_choices)`）— 多项选择分类头的预测分数（SoftMax 之前每个选择的分数）。

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

OpenAIGPTDoubleHeadsModel 的前向方法，覆盖了`__call__`特殊方法。

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

示例：

```py
>>> from transformers import AutoTokenizer, OpenAIGPTDoubleHeadsModel
>>> import torch

>>> tokenizer = AutoTokenizer.from_pretrained("openai-gpt")
>>> model = OpenAIGPTDoubleHeadsModel.from_pretrained("openai-gpt")
>>> tokenizer.add_special_tokens(
...     {"cls_token": "[CLS]"}
... )  # Add a [CLS] to the vocabulary (we should train it also!)
>>> model.resize_token_embeddings(len(tokenizer))

>>> choices = ["Hello, my dog is cute [CLS]", "Hello, my cat is cute [CLS]"]
>>> input_ids = torch.tensor([tokenizer.encode(s) for s in choices]).unsqueeze(0)  # Batch size 1, 2 choices
>>> mc_token_ids = torch.tensor([input_ids.size(-1) - 1, input_ids.size(-1) - 1]).unsqueeze(0)  # Batch size 1

>>> outputs = model(input_ids, mc_token_ids=mc_token_ids)
>>> lm_logits = outputs.logits
>>> mc_logits = outputs.mc_logits
```

## OpenAIGPTForSequenceClassification

### `class transformers.OpenAIGPTForSequenceClassification`

[<来源>](https://github.com/huggingface/transformers/blob/v4.37.2/src/transformers/models/openai/modeling_openai.py#L740)

```py
( config )
```

参数

+   `config`（OpenAIGPTConfig）— 具有模型所有参数的模型配置类。使用配置文件初始化不会加载与模型相关的权重，只加载配置。查看 from_pretrained()方法以加载模型权重。

原始的 OpenAI GPT 模型变压器，顶部带有序列分类头（线性层）。OpenAIGPTForSequenceClassification 使用最后一个标记进行分类，就像其他因果模型（例如 GPT-2）一样。由于它在最后一个标记上进行分类，因此需要知道最后一个标记的位置。如果在配置中定义了`pad_token_id`，则找到每行中不是填充标记的最后一个标记。如果未定义`pad_token_id`，则简单地取批次中每行的最后一个值。由于在传递`inputs_embeds`而不是`input_ids`时无法猜测填充标记，因此它执行相同操作（取批次中每行的最后一个值）。

此模型继承自 PreTrainedModel。检查超类文档，了解库为其所有模型实现的通用方法（例如下载或保存、调整输入嵌入、修剪头等）。

此模型还是 PyTorch [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module)子类。将其用作常规 PyTorch 模块，并参考 PyTorch 文档以获取与一般用法和行为相关的所有事项。

#### `forward`

[<来源>](https://github.com/huggingface/transformers/blob/v4.37.2/src/transformers/models/openai/modeling_openai.py#L762)

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

参数

+   `input_ids`（形状为`(batch_size, sequence_length)`的`torch.LongTensor`） — 词汇表中输入序列标记的索引。

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

    什么是输入 ID？

+   `attention_mask`（形状为`(batch_size, sequence_length)`的`torch.FloatTensor`，*可选*） — 用于避免在填充标记索引上执行注意力的掩码。掩码值在`[0, 1]`中选择：

    +   1 表示“未被掩盖”的标记，

    +   0 表示“被掩盖”的标记。

    什么是注意力掩码？

+   `token_type_ids`（形状为`(batch_size, sequence_length)`的`torch.LongTensor`，*可选*） — 段标记索引，用于指示输入的第一部分和第二部分。索引在`[0, 1]`中选择：

    +   0 对应于*句子 A*标记。

    +   1 对应于*句子 B*标记。

    什么是标记类型 ID？

+   `position_ids`（形状为`(batch_size, sequence_length)`的`torch.LongTensor`，*可选*） — 每个输入序列标记在位置嵌入中的位置索引。在范围`[0, config.max_position_embeddings - 1]`中选择。

    什么是位置 ID？

+   `head_mask`（形状为`(num_heads,)`或`(num_layers, num_heads)`的`torch.FloatTensor`，*可选*） — 用于使自注意力模块中选择的头部失效的掩码。掩码值在`[0, 1]`中选择：

    +   1 表示头部“未被掩盖”，

    +   0 表示头部“被掩盖”。

+   `inputs_embeds`（形状为`(batch_size, sequence_length, hidden_size)`的`torch.FloatTensor`，*可选*） — 可选地，您可以选择直接传递嵌入表示，而不是传递`input_ids`。如果您想要更多控制权来将`input_ids`索引转换为相关向量，这将非常有用，而不是使用模型的内部嵌入查找矩阵。

+   `output_attentions`（`bool`，*可选*） — 是否返回所有注意力层的注意力张量。有关更多详细信息，请参阅返回张量中的`attentions`。

+   `output_hidden_states`（`bool`，*可选*） — 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回张量中的`hidden_states`。

+   `return_dict`（`bool`，*可选*） — 是否返回 ModelOutput 而不是普通元组。

+   `labels`（形状为`(batch_size,)`的`torch.LongTensor`，*可选*） — 用于计算序列分类/回归损失的标签。索引应在`[0, ..., config.num_labels - 1]`中。如果`config.num_labels == 1`，则计算回归损失（均方损失），如果`config.num_labels > 1`，则计算分类损失（交叉熵）。

返回

transformers.modeling_outputs.SequenceClassifierOutput 或`tuple(torch.FloatTensor)`

一个 transformers.modeling_outputs.SequenceClassifierOutput 或一个`torch.FloatTensor`元组（如果传递`return_dict=False`或`config.return_dict=False`时）包含各种元素，取决于配置(OpenAIGPTConfig)和输入。

+   `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`时返回) — 形状为`(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 后的注意力权重，用于计算自注意力头中的加权平均值。

OpenAIGPTForSequenceClassification 的前向方法，覆盖了`__call__`特殊方法。

虽然前向传递的步骤需要在此函数内定义，但应该在此之后调用`Module`实例，而不是在此处调用，因为前者会负责运行预处理和后处理步骤，而后者会默默地忽略它们。

单标签分类示例：

```py
>>> import torch
>>> from transformers import AutoTokenizer, OpenAIGPTForSequenceClassification

>>> tokenizer = AutoTokenizer.from_pretrained("openai-gpt")
>>> model = OpenAIGPTForSequenceClassification.from_pretrained("openai-gpt")

>>> inputs = tokenizer("Hello, my dog is cute", return_tensors="pt")

>>> with torch.no_grad():
...     logits = model(**inputs).logits

>>> predicted_class_id = logits.argmax().item()

>>> # To train a model on `num_labels` classes, you can pass `num_labels=num_labels` to `.from_pretrained(...)`
>>> num_labels = len(model.config.id2label)
>>> model = OpenAIGPTForSequenceClassification.from_pretrained("openai-gpt", num_labels=num_labels)

>>> labels = torch.tensor([1])
>>> loss = model(**inputs, labels=labels).loss
```

多标签分类示例：

```py
>>> import torch
>>> from transformers import AutoTokenizer, OpenAIGPTForSequenceClassification

>>> tokenizer = AutoTokenizer.from_pretrained("openai-gpt")
>>> model = OpenAIGPTForSequenceClassification.from_pretrained("openai-gpt", problem_type="multi_label_classification")

>>> inputs = tokenizer("Hello, my dog is cute", return_tensors="pt")

>>> with torch.no_grad():
...     logits = model(**inputs).logits

>>> predicted_class_ids = torch.arange(0, logits.shape[-1])[torch.sigmoid(logits).squeeze(dim=0) > 0.5]

>>> # To train a model on `num_labels` classes, you can pass `num_labels=num_labels` to `.from_pretrained(...)`
>>> num_labels = len(model.config.id2label)
>>> model = OpenAIGPTForSequenceClassification.from_pretrained(
...     "openai-gpt", num_labels=num_labels, problem_type="multi_label_classification"
... )

>>> labels = torch.sum(
...     torch.nn.functional.one_hot(predicted_class_ids[None, :].clone(), num_classes=num_labels), dim=1
... ).to(torch.float)
>>> loss = model(**inputs, labels=labels).loss
```

TensorFlow 隐藏 TensorFlow 内容

## TFOpenAIGPTModel

### `class transformers.TFOpenAIGPTModel`

[<来源>](https://github.com/huggingface/transformers/blob/v4.37.2/src/transformers/models/openai/modeling_tf_openai.py#L540)

```py
( config *inputs **kwargs )
```

参数

+   `config` (OpenAIGPTConfig) — 模型的所有参数的模型配置类。使用配置文件初始化不会加载与模型相关的权重，只会加载配置。查看 from_pretrained()方法来加载模型权重。

裸的 OpenAI GPT 变换器模型输出原始隐藏状态，没有特定的顶部头。

此模型继承自 TFPreTrainedModel。查看超类文档以了解库为所有模型实现的通用方法（如下载或保存、调整输入嵌入、修剪头等）。

此模型也是[tf.keras.Model](https://www.tensorflow.org/api_docs/python/tf/keras/Model)的子类。将其用作常规的 TF 2.0 Keras 模型，并参考 TF 2.0 文档以获取有关一般用法和行为的所有相关信息。

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

+   将所有输入作为关键字参数（类似于 PyTorch 模型），或

+   将所有输入作为列表、元组或字典放在第一个位置参数中。

第二种格式得到支持的原因是，当将输入传递给模型和层时，Keras 方法更喜欢这种格式。由于这种支持，在使用诸如`model.fit()`之类的方法时，应该对您“只需工作” - 只需以`model.fit()`支持的任何格式传递您的输入和标签！但是，如果您想在 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})`

请注意，当使用[子类化](https://keras.io/guides/making_new_layers_and_models_via_subclassing/)创建模型和层时，您无需担心任何这些，因为您可以像将输入传递给任何其他 Python 函数一样传递输入！

#### `call`

[<来源>](https://github.com/huggingface/transformers/blob/v4.37.2/src/transformers/models/openai/modeling_tf_openai.py#L549)

```py
( 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 training: Optional[bool] = False ) → export const metadata = 'undefined';transformers.modeling_tf_outputs.TFBaseModelOutput or tuple(tf.Tensor)
```

参数

+   `input_ids`（形状为`(batch_size, sequence_length)`的`Numpy array`或`tf.Tensor`） - 词汇表中输入序列令牌的索引。

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

    什么是输入 ID？

+   `attention_mask`（形状为`(batch_size, sequence_length)`的`tf.Tensor`或`Numpy array`，*可选*） - 用于避免在填充令牌索引上执行注意力的掩码。掩码值在`[0, 1]`中选择：

    +   1 表示未被`masked`的令牌，

    +   0 表示被`masked`的令牌。

    什么是注意力掩码？

+   `token_type_ids`（形状为`(batch_size, sequence_length)`的`tf.Tensor`或`Numpy array`，*可选*） - 段标记索引，指示输入的第一部分和第二部分。索引在`[0, 1]`中选择：

    +   0 对应于*句子 A*令牌，

    +   1 对应于*句子 B*令牌。

    什么是令牌类型 ID？

+   `position_ids`（形状为`(batch_size, sequence_length)`的`tf.Tensor`或`Numpy array`，*可选*） - 每个输入序列令牌在位置嵌入中的位置索引。在范围`[0, config.max_position_embeddings - 1]`中选择。

    什么是位置 ID？

+   `head_mask`（形状为`(num_heads,)`或`(num_layers, num_heads)`的`tf.Tensor`或`Numpy array`，*可选*） - 用于使自注意力模块的选定头部无效的掩码。掩码值在`[0, 1]`中选择：

    +   1 表示头部未被`masked`，

    +   0 表示头部是`masked`。

+   `inputs_embeds`（形状为`(batch_size, sequence_length, hidden_size)`的`tf.Tensor`或`Numpy array`，*可选*） - 可选地，您可以选择直接传递嵌入表示，而不是传递`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 模块在训练和评估之间有不同的行为）。

返回

transformers.modeling_tf_outputs.TFBaseModelOutput 或 `tuple(tf.Tensor)`

一个 transformers.modeling_tf_outputs.TFBaseModelOutput 或一个 `tf.Tensor` 元组（如果传入 `return_dict=False` 或当 `config.return_dict=False` 时）包含根据配置（OpenAIGPTConfig）和输入的各种元素。

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

+   `hidden_states` (`tuple(tf.FloatTensor)`，*可选*，当传入 `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` 元组。

    注意力权重在注意力 softmax 之后，用于计算自注意力头中的加权平均值。

TFOpenAIGPTModel 的前向方法，覆盖了 `__call__` 特殊方法。

虽然前向传递的步骤需要在此函数内定义，但应该在此之后调用 `Module` 实例，而不是这个，因为前者负责运行预处理和后处理步骤，而后者会默默地忽略它们。

示例：

```py
>>> from transformers import AutoTokenizer, TFOpenAIGPTModel
>>> import tensorflow as tf

>>> tokenizer = AutoTokenizer.from_pretrained("openai-gpt")
>>> model = TFOpenAIGPTModel.from_pretrained("openai-gpt")

>>> inputs = tokenizer("Hello, my dog is cute", return_tensors="tf")
>>> outputs = model(inputs)

>>> last_hidden_states = outputs.last_hidden_state
```

## TFOpenAIGPTLMHeadModel

`transformers.TFOpenAIGPTLMHeadModel` 类

[< source >](https://github.com/huggingface/transformers/blob/v4.37.2/src/transformers/models/openai/modeling_tf_openai.py#L592)

```py
( config *inputs **kwargs )
```

参数

+   `config` (OpenAIGPTConfig) — 具有模型所有参数的模型配置类。使用配置文件初始化不会加载与模型相关的权重，只加载配置。查看 from_pretrained() 方法以加载模型权重。

带有语言建模头的 OpenAI GPT 模型变换器（线性层，其权重与输入嵌入相关联）。

此模型继承自 TFPreTrainedModel。查看超类文档以了解库为所有模型实现的通用方法（如下载或保存、调整输入嵌入、修剪头等）。

此模型也是一个[tf.keras.Model](https://www.tensorflow.org/api_docs/python/tf/keras/Model)子类。将其用作常规的 TF 2.0 Keras 模型，并参考 TF 2.0 文档以获取与一般用法和行为相关的所有事项。

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

+   将所有输入作为关键字参数（类似于 PyTorch 模型），或

+   将所有输入作为列表、元组或字典放在第一个位置参数中。

支持第二种格式的原因是 Keras 方法在将输入传递给模型和层时更喜欢这种格式。由于这种支持，当使用`model.fit()`等方法时，应该可以“正常工作” - 只需以`model.fit()`支持的任何格式传递输入和标签即可！但是，如果您想在 Keras 方法之外使用第二种格式，例如在使用 Keras `Functional` API 创建自己的层或模型时，有三种可能性可以用来收集第一个位置参数中的所有输入 Tensor：

+   仅具有`input_ids`的单个 Tensor，没有其他内容：`model(input_ids)`

+   一个具有不同长度的列表，其中包含一个或多个按照文档字符串中给定的顺序的输入 Tensor：`model([input_ids, attention_mask])`或`model([input_ids, attention_mask, token_type_ids])`

+   一个字典，其中包含一个或多个与文档字符串中给定的输入名称相关联的输入 Tensor：`model({"input_ids": input_ids, "token_type_ids": token_type_ids})`

请注意，当使用[子类化](https://keras.io/guides/making_new_layers_and_models_via_subclassing/)创建模型和层时，您无需担心任何这些，因为您可以像对待任何其他 Python 函数一样传递输入！

#### `call`

[<来源>](https://github.com/huggingface/transformers/blob/v4.37.2/src/transformers/models/openai/modeling_tf_openai.py#L612)

```py
( 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 ) → export const metadata = 'undefined';transformers.modeling_tf_outputs.TFCausalLMOutput or tuple(tf.Tensor)
```

参数

+   `input_ids`（形状为`(batch_size, sequence_length)`的`Numpy`数组或`tf.Tensor`）- 词汇表中输入序列标记的索引。

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

    什么是输入 ID？

+   `attention_mask`（形状为`(batch_size, sequence_length)`的`tf.Tensor`或`Numpy`数组，*可选*）- 避免在填充标记索引上执行注意力的掩码。选择的掩码值在`[0, 1]`中：

    +   1 表示`not masked`的标记，

    +   0 表示`masked`的标记。

    什么是注意力掩码？

+   `token_type_ids`（形状为`(batch_size, sequence_length)`的`tf.Tensor`或`Numpy`数组，*可选*）- 指示输入的第一部分和第二部分的段标记索引。索引在`[0, 1]`中选择：

    +   0 对应于*句子 A*的标记，

    +   1 对应于*句子 B*的标记。

    什么是标记类型 ID？

+   `position_ids`（`tf.Tensor`或形状为`(batch_size, sequence_length)`的`Numpy`数组，*可选*）- 每个输入序列标记在位置嵌入中的位置的索引。在范围`[0, config.max_position_embeddings - 1]`中选择。

    什么是位置 ID？

+   `head_mask`（形状为`(num_heads,)`或`(num_layers, num_heads)`的`tf.Tensor`或`Numpy`数组，*可选*）- 用于使自注意力模块的选定头部无效的掩码。选择的掩码值在`[0, 1]`中：

    +   1 表示头部是`not masked`，

    +   0 表示头部是`masked`。

+   `inputs_embeds`（形状为`(batch_size, sequence_length, hidden_size)`的`tf.Tensor`或`Numpy array`，*可选*）— 可选地，可以直接传递嵌入表示，而不是传递`input_ids`。如果您想要更多控制如何将`input_ids`索引转换为关联向量，而不是模型的内部嵌入查找矩阵，则这很有用。

+   `output_attentions`（`bool`，*可选*）— 是否返回所有注意力层的注意力张量。有关更多详细信息，请参阅返回张量下的`attentions`。此参数仅在急切模式下使用，在图模式下将使用配置中的值。

+   `output_hidden_states`（`bool`，*可选*）— 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回张量下的`hidden_states`。此参数仅在急切模式下使用，在图模式下将使用配置中的值。

+   `return_dict`（`bool`，*可选*）— 是否返回 ModelOutput 而不是普通元组。此参数可在急切模式下使用，在图模式下该值将始终设置为 True。

+   `training`（`bool`，*可选*，默认为`False`）— 是否在训练模式中使用模型（一些模块如 dropout 模块在训练和评估之间有不同的行为）。

+   `labels`（形状为`(batch_size, sequence_length)`的`tf.Tensor`，*可选*）— 用于计算交叉熵分类损失的标签。索引应在`[0, ..., config.vocab_size - 1]`范围内。

返回

transformers.modeling_tf_outputs.TFCausalLMOutput 或`tuple(tf.Tensor)`

一个 transformers.modeling_tf_outputs.TFCausalLMOutput 或一个`tf.Tensor`元组（如果传递`return_dict=False`或`config.return_dict=False`，则根据配置（OpenAIGPTConfig）和输入包含各种元素。

+   `loss`（形状为`(n,)`的`tf.Tensor`，*可选*，当提供`labels`时返回，其中 n 是未屏蔽标签的数量）— 语言建模损失（用于下一个标记预测）。

+   `logits`（形状为`(batch_size, sequence_length, config.vocab_size)`的`tf.Tensor`）— 语言建模头的预测分数（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`元组（每个层一个）。

    注意力 softmax 后的注意力权重，用于计算自注意力头中的加权平均值。

TFOpenAIGPTLMHeadModel 的前向方法，覆盖了`__call__`特殊方法。

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

示例：

```py
>>> from transformers import AutoTokenizer, TFOpenAIGPTLMHeadModel
>>> import tensorflow as tf

>>> tokenizer = AutoTokenizer.from_pretrained("openai-gpt")
>>> model = TFOpenAIGPTLMHeadModel.from_pretrained("openai-gpt")

>>> inputs = tokenizer("Hello, my dog is cute", return_tensors="tf")
>>> outputs = model(inputs)
>>> logits = outputs.logits
```

## TFOpenAIGPTDoubleHeadsModel

### `class transformers.TFOpenAIGPTDoubleHeadsModel`

[< source >](https://github.com/huggingface/transformers/blob/v4.37.2/src/transformers/models/openai/modeling_tf_openai.py#L685)

```py
( config *inputs **kwargs )
```

参数

+   `config`（OpenAIGPTConfig）— 具有模型所有参数的模型配置类。使用配置文件初始化不会加载与模型关联的权重，只加载配置。查看 from_pretrained()方法以加载模型权重。

OpenAI GPT 模型变压器，具有语言建模和顶部的多选分类头，例如用于 RocStories/SWAG 任务。这两个头是两个线性层。语言建模头的权重与输入嵌入绑定，分类头以输入序列中指定分类标记索引的输入为输入）。

此模型继承自 TFPreTrainedModel。查看超类文档以获取库为所有模型实现的通用方法（如下载或保存、调整输入嵌入、修剪头等）。

这个模型也是一个[tf.keras.Model](https://www.tensorflow.org/api_docs/python/tf/keras/Model)的子类。将其用作常规的 TF 2.0 Keras 模型，并参考 TF 2.0 文档以获取与一般用法和行为相关的所有内容。

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

+   将所有输入作为关键字参数（类似于 PyTorch 模型），或

+   将所有输入作为列表、元组或字典放在第一个位置参数中。

支持第二种格式的原因是，当将输入传递给模型和层时，Keras 方法更喜欢这种格式。由于这种支持，当使用`model.fit()`等方法时，应该“只需工作” - 只需以`model.fit()`支持的任何格式传递您的输入和标签！但是，如果您想在 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})`

请注意，当使用[子类化](https://keras.io/guides/making_new_layers_and_models_via_subclassing/)创建模型和层时，您无需担心这些问题，因为您可以像将输入传递给任何其他 Python 函数一样传递输入！

#### `call`

[<来源>](https://github.com/huggingface/transformers/blob/v4.37.2/src/transformers/models/openai/modeling_tf_openai.py#L703)

```py
( 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 mc_token_ids: np.ndarray | tf.Tensor | None = None output_attentions: Optional[bool] = None output_hidden_states: Optional[bool] = None return_dict: Optional[bool] = None training: Optional[bool] = False ) → export const metadata = 'undefined';transformers.models.openai.modeling_tf_openai.TFOpenAIGPTDoubleHeadsModelOutput or tuple(tf.Tensor)
```

参数

+   `input_ids`（形状为`(batch_size, sequence_length)`的`Numpy array`或`tf.Tensor`）— 词汇表中输入序列标记的索引。

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

    什么是输入 ID？

+   `attention_mask`（`tf.Tensor`或形状为`(batch_size, sequence_length)`的`Numpy array`，*可选*）— 用于避免在填充标记索引上执行注意力的掩码。选择在`[0, 1]`中的掩码值：

    +   1 表示未被`masked`的标记，

    +   0 表示被`masked`的标记。

    什么是注意力掩码？

+   `token_type_ids` (`tf.Tensor`或`Numpy array`，形状为`(batch_size, sequence_length)`，*optional*) — 段标记索引，指示输入的第一部分和第二部分。索引在`[0, 1]`中选择：

    +   0 对应于 *sentence A* 标记，

    +   1 对应于 *sentence B* 标记。

    什么是 token type IDs？

+   `position_ids` (`tf.Tensor`或`Numpy array`，形状为`(batch_size, sequence_length)`，*optional*) — 每个输入序列标记在位置嵌入中的位置索引。在范围`[0, config.max_position_embeddings - 1]`中选择。

    什么是 position IDs？

+   `head_mask` (`tf.Tensor`或`Numpy array`，形状为`(num_heads,)`或`(num_layers, num_heads)`，*optional*) — 用于使自注意力模块的选定头部无效的掩码。选择的掩码值在`[0, 1]`中：

    +   1 表示头部未被`masked`，

    +   0 表示头部被`masked`。

+   `inputs_embeds` (`tf.Tensor`或`Numpy array`，形状为`(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 而不是普通元组。此参数可在急切模式下使用，在图模式下该值将始终设置为 True。

+   `training` (`bool`, *optional*, defaults to `False`) — 是否在训练模式下使用模型（一些模块如 dropout 模块在训练和评估之间有不同的行为）。

+   `mc_token_ids` (`tf.Tensor`或`Numpy array`，形状为`(batch_size, num_choices)`，*optional*，默认为输入序列的最后一个标记的索引) — 每个输入序列中分类标记的索引。在范围`[0, input_ids.size(-1) - 1]`中选择。

返回

transformers.models.openai.modeling_tf_openai.TFOpenAIGPTDoubleHeadsModelOutput 或 `tuple(tf.Tensor)`

一个 transformers.models.openai.modeling_tf_openai.TFOpenAIGPTDoubleHeadsModelOutput 或一个`tf.Tensor`元组（如果传递`return_dict=False`或当`config.return_dict=False`时）包含根据配置（OpenAIGPTConfig）和输入的不同元素。

+   `logits` (`tf.Tensor`，形状为`(batch_size, num_choices, sequence_length, config.vocab_size)`) — 语言建模头的预测分数（SoftMax 之前每个词汇标记的分数）。

+   `mc_logits` (`tf.Tensor`，形状为`(batch_size, num_choices)`) — 多项选择分类头的预测分数（SoftMax 之前每个选择的分数）。

+   `hidden_states` (`tuple(tf.Tensor)`, *optional*, 当传递`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`元组（每层一个）。

    在注意力 softmax 之后的注意力权重，用于计算自注意力头中的加权平均值。

TFOpenAIGPTDoubleHeadsModel 的前向方法，覆盖`__call__`特殊方法。

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

示例：

```py
>>> import tensorflow as tf
>>> from transformers import AutoTokenizer, TFOpenAIGPTDoubleHeadsModel

>>> tokenizer = AutoTokenizer.from_pretrained("openai-gpt")
>>> model = TFOpenAIGPTDoubleHeadsModel.from_pretrained("openai-gpt")

>>> # Add a [CLS] to the vocabulary (we should train it also!)
>>> tokenizer.add_special_tokens({"cls_token": "[CLS]"})
>>> model.resize_token_embeddings(len(tokenizer))  # Update the model embeddings with the new vocabulary size
>>> print(tokenizer.cls_token_id, len(tokenizer))  # The newly token the last token of the vocabulary

>>> choices = ["Hello, my dog is cute [CLS]", "Hello, my cat is cute [CLS]"]
>>> encoding = tokenizer(choices, return_tensors="tf")
>>> inputs = {k: tf.expand_dims(v, 0) for k, v in encoding.items()}
>>> inputs["mc_token_ids"] = tf.constant(
...     [inputs["input_ids"].shape[-1] - 1, inputs["input_ids"].shape[-1] - 1]
... )[
...     None, :
... ]  # Batch size 1
>>> outputs = model(inputs)
>>> lm_prediction_scores, mc_prediction_scores = outputs[:2]
```

## TFOpenAIGPTForSequenceClassification

### `class transformers.TFOpenAIGPTForSequenceClassification`

[< source >](https://github.com/huggingface/transformers/blob/v4.37.2/src/transformers/models/openai/modeling_tf_openai.py#L817)

```py
( config *inputs **kwargs )
```

参数

+   `config`（OpenAIGPTConfig）- 包含模型所有参数的模型配置类。使用配置文件初始化不会加载与模型关联的权重，只会加载配置。查看 from_pretrained()方法以加载模型权重。

在顶部带有序列分类头的 OpenAI GPT 模型变压器（线性层）。

TFOpenAIGPTForSequenceClassification 使用最后一个令牌来进行分类，就像其他因果模型（例如 GPT-2）一样。

由于它对最后一个令牌进行分类，因此需要知道最后一个令牌的位置。如果在配置中定义了`pad_token_id`，则它会找到每行中不是填充令牌的最后一个令牌。如果没有定义`pad_token_id`，则它会简单地取每行批次中的最后一个值。由于在传递`inputs_embeds`而不是`input_ids`时无法猜测填充令牌，因此它会执行相同的操作（取每行批次中的最后一个值）。

这个模型继承自 TFPreTrainedModel。查看超类文档，了解库为所有模型实现的通用方法（如下载或保存、调整输入嵌入、修剪头等）。

这个模型也是一个[tf.keras.Model](https://www.tensorflow.org/api_docs/python/tf/keras/Model)子类。将其用作常规的 TF 2.0 Keras 模型，并参考 TF 2.0 文档以获取与一般用法和行为相关的所有信息。

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

+   将所有输入作为关键字参数（类似于 PyTorch 模型），或

+   将所有输入作为列表、元组或字典放在第一个位置参数中。

支持第二种格式的原因是，当将输入传递给模型和层时，Keras 方法更喜欢这种格式。由于这种支持，当使用`model.fit()`等方法时，您应该可以“只需传递”您的输入和标签，以任何`model.fit()`支持的格式！但是，如果您想在 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})`

请注意，当使用 [子类化](https://keras.io/guides/making_new_layers_and_models_via_subclassing/) 创建模型和层时，您无需担心这些内容，因为您可以像对待其他 Python 函数一样传递输入！

#### `call`

[<来源>](https://github.com/huggingface/transformers/blob/v4.37.2/src/transformers/models/openai/modeling_tf_openai.py#L845)

```py
( 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 ) → export const metadata = 'undefined';transformers.modeling_tf_outputs.TFSequenceClassifierOutput or tuple(tf.Tensor)
```

参数

+   `input_ids` (`Numpy array` 或 `tf.Tensor`，形状为 `(batch_size, sequence_length)`) — 词汇表中输入序列标记的索引。

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

    什么是输入 ID？

+   `attention_mask` (`tf.Tensor` 或 `Numpy array`，形状为 `(batch_size, sequence_length)`，*可选*) — 用于避免在填充标记索引上执行注意力的掩码。掩码值选定在 `[0, 1]`：

    +   1 表示未被 `masked` 的标记，

    +   0 表示被 `masked` 的标记。

    什么是注意力掩码？

+   `token_type_ids` (`tf.Tensor` 或 `Numpy array`，形状为 `(batch_size, sequence_length)`，*可选*) — 段标记索引，指示输入的第一部分和第二部分。索引选定在 `[0, 1]`：

    +   0 对应于 *句子 A* 标记，

    +   1 对应于 *句子 B* 标记。

    什么是标记类型 ID？

+   `position_ids` (`tf.Tensor` 或 `Numpy array`，形状为 `(batch_size, sequence_length)`，*可选*) — 每个输入序列标记在位置嵌入中的位置索引。选定范围为 `[0, config.max_position_embeddings - 1]`。

    什么是位置 ID？

+   `head_mask` (`tf.Tensor` 或 `Numpy array`，形状为 `(num_heads,)` 或 `(num_layers, num_heads)`，*可选*) — 用于使自注意力模块中的选定头部失效的掩码。掩码值选定在 `[0, 1]`：

    +   1 表示头部未被 `masked`，

    +   0 表示头部被 `masked`。

+   `inputs_embeds` (`tf.Tensor` 或 `Numpy array`，形状为 `(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` (`bool`，*可选*，默认为 `False`) — 是否在训练模式下使用模型（一些模块，如 dropout 模块，在训练和评估之间有不同的行为）。

+   `labels` (`tf.Tensor`，形状为`(batch_size, sequence_length)`，*可选*) — 用于计算交叉熵分类损失的标签。索引应在`[0, ..., config.vocab_size - 1]`范围内。

返回

`transformers.modeling_tf_outputs.TFSequenceClassifierOutput` 或 `tuple(tf.Tensor)`

一个 transformers.modeling_tf_outputs.TFSequenceClassifierOutput 或一个`tf.Tensor`元组（如果传递`return_dict=False`或`config.return_dict=False`时）包含根据配置（OpenAIGPTConfig）和输入而异的各种元素。

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

+   `logits` (`tf.Tensor`，形状为`(batch_size, config.num_labels)`) — 分类（如果`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`元组（每个层一个）。

    在注意力 softmax 之后的注意力权重，用于计算自注意力头中的加权平均值。

TFOpenAIGPTForSequenceClassification 的前向方法，覆盖了`__call__`特殊方法。

虽然前向传递的方法需要在此函数内定义，但应该在此之后调用`Module`实例，而不是这个，因为前者会处理运行前后处理步骤，而后者会默默地忽略它们。

示例：

```py
>>> from transformers import AutoTokenizer, TFOpenAIGPTForSequenceClassification
>>> import tensorflow as tf

>>> tokenizer = AutoTokenizer.from_pretrained("openai-gpt")
>>> model = TFOpenAIGPTForSequenceClassification.from_pretrained("openai-gpt")

>>> inputs = tokenizer("Hello, my dog is cute", return_tensors="tf")

>>> logits = model(**inputs).logits

>>> predicted_class_id = int(tf.math.argmax(logits, axis=-1)[0])
```

```py
>>> # To train a model on `num_labels` classes, you can pass `num_labels=num_labels` to `.from_pretrained(...)`
>>> num_labels = len(model.config.id2label)
>>> model = TFOpenAIGPTForSequenceClassification.from_pretrained("openai-gpt", num_labels=num_labels)

>>> labels = tf.constant(1)
>>> loss = model(**inputs, labels=labels).loss
```