Transformers 4.37 中文文档（三十四）（1）-阿里云开发者社区

原文：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 "") — 未知标记。词汇表中不存在的标记无法转换为 ID，而是设置为此标记。
sep_token (str, optional, defaults to "[SEP]") — 分隔符标记，在从多个序列构建序列时使用，例如用于序列分类的两个序列或用于问答的文本和问题。它也用作使用特殊标记构建的序列的最后一个标记。
pad_token (str, optional, defaults to "") — 用于填充的标记，例如在批处理不同长度的序列时使用。
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，可选，默认为""）— 未知标记。词汇表中不存在的标记无法转换为 ID，而是设置为此标记。
sep_token（str，可选，默认为"[SEP]"）— 分隔符标记，在从多个序列构建序列时使用，例如用于序列分类的两个序列或用于问题回答的文本和问题。它还用作使用特殊标记构建的序列的最后一个标记。
pad_token（str，可选，默认为""）— 用于填充的标记，例如在批处理不同长度的序列时。
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__特殊方法。

单标签分类示例：

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

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

Transformers 4.37 中文文档（三十四）（1）

FNet

概述

使用提示

资源

FNetConfig

`class transformers.FNetConfig`

FNetTokenizer

`class transformers.FNetTokenizer`

`build_inputs_with_special_tokens`

`get_special_tokens_mask`

`create_token_type_ids_from_sequences`

`save_vocabulary`

FNetTokenizerFast

`class transformers.FNetTokenizerFast`

`build_inputs_with_special_tokens`

`create_token_type_ids_from_sequences`

FNetModel

`class transformers.FNetModel`

`forward`

FNetForPreTraining

`class transformers.FNetForPreTraining`

FNetForMaskedLM

`class transformers.FNetForMaskedLM`

`forward`

FNetForNextSentencePrediction

`class transformers.FNetForNextSentencePrediction`

`forward`

FNetForSequenceClassification

`class transformers.FNetForSequenceClassification`

`forward`

热门文章

最新文章

相关课程

相关电子书

热门

活动广场

任务中心

开发者评测

高校计划

乘风者计划

训练营

阿里云MVP

话题

直播

下载

镜像站

技术资料

插件

Transformers 4.37 中文文档（三十四）（1）

FNet

概述

使用提示

资源

FNetConfig

class transformers.FNetConfig

FNetTokenizer

class transformers.FNetTokenizer

build_inputs_with_special_tokens

get_special_tokens_mask

create_token_type_ids_from_sequences

save_vocabulary

FNetTokenizerFast

class transformers.FNetTokenizerFast

build_inputs_with_special_tokens

create_token_type_ids_from_sequences

FNetModel

class transformers.FNetModel

forward

FNetForPreTraining

class transformers.FNetForPreTraining

FNetForMaskedLM

class transformers.FNetForMaskedLM

forward

FNetForNextSentencePrediction

class transformers.FNetForNextSentencePrediction

forward

FNetForSequenceClassification

class transformers.FNetForSequenceClassification

forward

热门文章

最新文章

相关课程

相关电子书

`class transformers.FNetConfig`

`class transformers.FNetTokenizer`

`build_inputs_with_special_tokens`

`get_special_tokens_mask`

`create_token_type_ids_from_sequences`

`save_vocabulary`

`class transformers.FNetTokenizerFast`

`build_inputs_with_special_tokens`

`create_token_type_ids_from_sequences`

`class transformers.FNetModel`

`forward`

`class transformers.FNetForPreTraining`

`class transformers.FNetForMaskedLM`

`forward`

`class transformers.FNetForNextSentencePrediction`

`forward`

`class transformers.FNetForSequenceClassification`

`forward`