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

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

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，可选，默认为""） - 未知标记。词汇表中没有的标记无法转换为 ID，而是设置为此标记。
bos_token（str，可选，默认为""） - 在预训练期间使用的序列开始标记。可以用作序列分类器标记。
在使用特殊标记构建序列时，这不是用于序列开始的标记。使用的标记是cls_token。
~~sep_token（str，可选，默认为"~~"） - 分隔符标记，在从多个序列构建序列时使用，例如用于序列分类的两个序列或用于文本和问题的问题回答。它也用作使用特殊标记构建的序列的最后一个标记。
pad_token（str，可选，默认为""） - 用于填充的标记，例如在批处理不同长度的序列时使用。

构建一个 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 序列具有以下格式：

单个序列： X
序列对： A B

`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?"

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

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

FNetForMultipleChoice

`class transformers.FNetForMultipleChoice`

`forward`

FNetForTokenClassification

`class transformers.FNetForTokenClassification`

`forward`

FNetForQuestionAnswering

`class transformers.FNetForQuestionAnswering`

`forward`

FSMT

概述

实现说明

FSMTConfig

`class transformers.FSMTConfig`

FSMTTokenizer

`class transformers.FSMTTokenizer`

`build_inputs_with_special_tokens`

`get_special_tokens_mask`

`create_token_type_ids_from_sequences`

`save_vocabulary`

FSMTModel

`class transformers.FSMTModel`

`前向`

FSMTForConditionalGeneration

`class transformers.FSMTForConditionalGeneration`

`forward`

热门文章

最新文章

相关课程

相关电子书

热门

活动广场

任务中心

开发者评测

高校计划

乘风者计划

训练营

阿里云MVP

话题

直播

下载

镜像站

技术资料

插件

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

FNetForMultipleChoice

class transformers.FNetForMultipleChoice

forward

FNetForTokenClassification

class transformers.FNetForTokenClassification

forward

FNetForQuestionAnswering

class transformers.FNetForQuestionAnswering

forward

FSMT

概述

实现说明

FSMTConfig

class transformers.FSMTConfig

FSMTTokenizer

class transformers.FSMTTokenizer

build_inputs_with_special_tokens

get_special_tokens_mask

create_token_type_ids_from_sequences

save_vocabulary

FSMTModel

class transformers.FSMTModel

前向

FSMTForConditionalGeneration

class transformers.FSMTForConditionalGeneration

forward

热门文章

最新文章

相关课程

相关电子书

`class transformers.FNetForMultipleChoice`

`forward`

`class transformers.FNetForTokenClassification`

`forward`

`class transformers.FNetForQuestionAnswering`

`forward`

`class transformers.FSMTConfig`

`class transformers.FSMTTokenizer`

`build_inputs_with_special_tokens`

`get_special_tokens_mask`

`create_token_type_ids_from_sequences`

`save_vocabulary`

`class transformers.FSMTModel`

`前向`

`class transformers.FSMTForConditionalGeneration`

`forward`