Transformers 4.37 中文文档（二十五）

2024-06-26 15:40:01 浏览数 (1)

原文：huggingface.co/docs/transformers

Blenderbot Small

原始文本：huggingface.co/docs/transformers/v4.37.2/en/model_doc/blenderbot-small

请注意，BlenderbotSmallModel 和 BlenderbotSmallForConditionalGeneration 仅与检查点facebook/blenderbot-90M结合使用。较大的 Blenderbot 检查点应该与 BlenderbotModel 和 BlenderbotForConditionalGeneration 一起使用

概述

Blender 聊天机器人模型是由 Stephen Roller，Emily Dinan，Naman Goyal，Da Ju，Mary Williamson，Yinhan Liu，Jing Xu，Myle Ott，Kurt Shuster，Eric M. Smith，Y-Lan Boureau，Jason Weston 于 2020 年 4 月 30 日提出的构建开放域聊天机器人的配方。

该论文的摘要如下：

构建开放域聊天机器人是机器学习研究的一个具有挑战性的领域。先前的工作表明，通过增加神经模型的参数数量和它们所训练的数据的规模可以获得改进的结果，我们表明其他因素对于高性能聊天机器人也很重要。良好的对话需要许多技能，一个专业的对话者以无缝的方式融合在一起：提供引人入胜的话题并倾听他们的伙伴，适当展示知识、同理心和个性，同时保持一致的人设。我们表明，大规模模型可以在给定适当的训练数据和生成策略的情况下学习这些技能。我们构建了这些配方的变体，包括 90M、2.7B 和 9.4B 参数模型，并公开提供我们的模型和代码。人类评估表明，我们的最佳模型在多轮对话中的吸引力和人性度量方面优于现有方法。然后，我们通过分析我们模型的失败案例来讨论这项工作的局限性。

此模型由patrickvonplaten贡献。作者的代码可以在这里找到。

使用提示

Blenderbot Small 是一个具有绝对位置嵌入的模型，因此通常建议在右侧而不是左侧填充输入。

资源

  • 因果语言建模任务指南
  • 翻译任务指南
  • 摘要任务指南

BlenderbotSmallConfig

class transformers.BlenderbotSmallConfig

<来源>

代码语言：javascript复制
( vocab_size = 50265 max_position_embeddings = 512 encoder_layers = 8 encoder_ffn_dim = 2048 encoder_attention_heads = 16 decoder_layers = 8 decoder_ffn_dim = 2048 decoder_attention_heads = 16 encoder_layerdrop = 0.0 decoder_layerdrop = 0.0 use_cache = True is_encoder_decoder = True activation_function = 'gelu' d_model = 512 dropout = 0.1 attention_dropout = 0.0 activation_dropout = 0.0 init_std = 0.02 decoder_start_token_id = 1 scale_embedding = False pad_token_id = 0 bos_token_id = 1 eos_token_id = 2 forced_eos_token_id = 2 **kwargs )

参数

  • vocab_size（int，可选，默认为 50265）— BlenderbotSmall 模型的词汇大小。定义了在调用 BlenderbotSmallModel 或 TFBlenderbotSmallModel 时可以表示的不同标记数量。
  • d_model（int，可选，默认为 512）— 层和池化层的维度。
  • encoder_layers（int，可选，默认为 8）— 编码器层数。
  • decoder_layers（int，可选，默认为 8）— 解码器层数。
  • encoder_attention_heads（int，可选，默认为 16）— Transformer 编码器中每个注意力层的注意力头数。
  • decoder_attention_heads (int, optional, defaults to 16) — Transformer 解码器中每个注意力层的注意力头数。
  • decoder_ffn_dim (int, optional, defaults to 2048) — 解码器中“中间”（通常称为前馈）层的维度。
  • encoder_ffn_dim (int, optional, defaults to 2048) — 解码器中“中间”（通常称为前馈）层的维度。
  • activation_function (str or function, optional, defaults to "gelu") — 编码器和池化器中的非线性激活函数（函数或字符串）。如果是字符串，支持"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 512) — 此模型可能使用的最大序列长度。通常将其设置为较大的值以防万一（例如，512 或 1024 或 2048）。
  • init_std (float, optional, defaults to 0.02) — 用于初始化所有权重矩阵的截断正态初始化器的标准差。
  • encoder_layerdrop (float, optional, defaults to 0.0) — 编码器的 LayerDrop 概率。有关更多详细信息，请参阅 LayerDrop paper)。
  • decoder_layerdrop (float, optional, defaults to 0.0) — 解码器的 LayerDrop 概率。有关更多详细信息，请参阅 LayerDrop paper)。
  • scale_embedding (bool, optional, defaults to False) — 通过除以 sqrt(d_model)来缩放嵌入。
  • use_cache (bool, optional, defaults to True) — 模型是否应返回最后的键/值注意力（并非所有模型都使用）
  • forced_eos_token_id (int, optional, defaults to 2) — 当达到max_length时，强制作为最后生成的标记的标记 ID。通常设置为eos_token_id。

这是用于存储 BlenderbotSmallModel 配置的配置类。根据指定的参数实例化一个 BlenderbotSmall 模型，定义模型架构。使用默认值实例化配置将产生类似于 BlenderbotSmall facebook/blenderbot_small-90M架构的配置。

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

示例：

代码语言：javascript复制
>>> from transformers import BlenderbotSmallConfig, BlenderbotSmallModel

>>> # Initializing a BlenderbotSmall facebook/blenderbot_small-90M style configuration
>>> configuration = BlenderbotSmallConfig()

>>> # Initializing a model (with random weights) from the facebook/blenderbot_small-90M style configuration
>>> model = BlenderbotSmallModel(configuration)

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

BlenderbotSmallTokenizer

class transformers.BlenderbotSmallTokenizer

< source >

代码语言：javascript复制
( vocab_file merges_file bos_token = '__start__' eos_token = '__end__' unk_token = '__unk__' pad_token = '__null__' **kwargs )

参数

  • vocab_file (str) — 包含词汇表的文件。
  • merges_file (str) — 合并文件的路径。
  • bos_token (str, optional, defaults to "__start__") — 句子开头标记。
  • eos_token (str, optional, defaults to "__end__") — 句子结束标记。
  • unk_token (str, optional, defaults to "__unk__") — 未知标记。词汇表中不存在的标记无法转换为 ID，而是设置为此标记。
  • pad_token (str, 可选, 默认为"__null__") — 用于填充的标记，例如在批处理不同长度的序列时使用。
  • kwargs (可选) — 传递给 PreTrainedTokenizer 的额外关键字参数

基于 BPE（字节对编码）构建 Blenderbot-90M 分词器

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

build_inputs_with_special_tokens

< source >

代码语言：javascript复制
( token_ids_0: List token_ids_1: Optional = None ) → export const metadata = 'undefined';List[int]

参数

  • token_ids_0 (List[int]) — 第一个标记化序列。
  • token_ids_1 (List[int], 可选) — 第二个标记化序列。

返回

List[int]

带有特殊标记的模型输入。

通过连接和添加特殊标记，为序列分类任务构建模型输入序列或序列对。

此实现不添加特殊标记，应该在子类中重写此方法。

get_special_tokens_mask

< source >

代码语言：javascript复制
( token_ids_0: List token_ids_1: Optional = None already_has_special_tokens: bool = False ) → export const metadata = 'undefined';A list of integers in the range [0, 1]

参数

  • token_ids_0 (List[int]) — 第一个序列的 ID 列表。
  • token_ids_1 (List[int], 可选) — 第二个序列的 ID 列表。
  • already_has_special_tokens (bool, 可选, 默认为False) — 标记列表是否已经格式化为模型的特殊标记。

返回

一个整数列表，范围为[0, 1]

特殊标记为 1，序列标记为 0。

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

create_token_type_ids_from_sequences

< source >

代码语言：javascript复制
( token_ids_0: List token_ids_1: Optional = None ) → export const metadata = 'undefined';List[int]

参数

  • token_ids_0 (List[int]) — 第一个标记化序列。
  • token_ids_1 (List[int], 可选) — 第二个标记化序列。

返回

List[int]

标记类型 ID。

创建与传递的序列对应的标记类型 ID。什么是标记类型 ID？

如果模型有特殊的构建方式，应该在子类中重写。

save_vocabulary

< source >

代码语言：javascript复制
( save_directory: str filename_prefix: Optional = None )

BlenderbotSmallTokenizerFast

class transformers.BlenderbotSmallTokenizerFast

< source >

代码语言：javascript复制
( vocab_file = None merges_file = None unk_token = '<|endoftext|>' bos_token = '<|endoftext|>' eos_token = '<|endoftext|>' add_prefix_space = False trim_offsets = True **kwargs )

参数

  • vocab_file (str) — 词汇文件的路径。

构建一个“快速”BlenderbotSmall 分词器（由 HuggingFace 的tokenizers库支持）。

create_token_type_ids_from_sequences

< source >

代码语言：javascript复制
( 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]

零的列表。

从传递的两个序列创建一个用于序列对分类任务的掩码。BlenderbotSmall 不使用标记类型 ID，因此返回一个零的列表。

PytorchHide Pytorch 内容

BlenderbotSmallModel

class transformers.BlenderbotSmallModel

< source >

代码语言：javascript复制
( config: BlenderbotSmallConfig )

参数

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

裸的 BlenderbotSmall 模型输出原始隐藏状态，没有特定的头部。该模型继承自 PreTrainedModel。查看超类文档以了解库为所有模型实现的通用方法（如下载或保存、调整输入嵌入、修剪头部等）。

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

forward

< source >

代码语言：javascript复制
( input_ids: Optional = None 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: Union = None past_key_values: Optional = None inputs_embeds: Optional = None decoder_inputs_embeds: 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.Seq2SeqModelOutput or tuple(torch.FloatTensor)

参数

  • input_ids (torch.LongTensor，形状为 (batch_size, sequence_length)) — 词汇表中输入序列标记的索引。默认情况下将忽略填充。 索引可以使用 AutoTokenizer 获得。查看 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call() 以获取详细信息。 什么是输入 ID？
  • attention_mask (torch.Tensor，形状为 (batch_size, sequence_length)，可选) — 用于避免在填充标记索引上执行注意力的掩码。掩码值选定在 [0, 1]：
    • 1 表示标记未被遮蔽，
    • 0 表示标记被遮蔽。

    什么是注意力掩码？

  • decoder_input_ids (torch.LongTensor，形状为 (batch_size, target_sequence_length)，可选) — 词汇表中解码器输入序列标记的索引。 索引可以使用 AutoTokenizer 获得。查看 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call() 以获取详细信息。 什么是解码器输入 ID？ BlenderbotSmall 使用 bos_token_id 作为 decoder_input_ids 生成的起始标记。如果使用了 past_key_values，则只需输入最后的 decoder_input_ids（参见 past_key_values）。
  • decoder_attention_mask (torch.LongTensor，形状为 (batch_size, target_sequence_length)，可选) — 默认行为：生成一个张量，忽略 decoder_input_ids 中的填充标记。因果掩码也将默认使用。
  • head_mask (torch.Tensor，形状为 (encoder_layers, encoder_attention_heads)，可选) — 用于在编码器中使选定的注意力模块头部失效的掩码。掩码值选定在 [0, 1]：
    • 1 表示头部未被遮蔽，
    • 0 表示头部被遮蔽。
  • decoder_head_mask (torch.Tensor，形状为 (decoder_layers, decoder_attention_heads)，可选) — 用于在解码器中使选定的注意力模块头部失效的掩码。掩码值选定在 [0, 1]：
    • 1 表示头部未被遮蔽，
    • 0 表示头部被遮蔽。
  • cross_attn_head_mask (torch.Tensor，形状为 (decoder_layers, decoder_attention_heads)，可选) — 用于在解码器中的交叉注意力模块中使选定头部失效的掩码。掩码值选定在 [0, 1]：
    • 1 表示头部未被遮蔽，
    • 0 表示头部被遮蔽。
  • encoder_outputs (tuple(tuple(torch.FloatTensor))，可选) — 元组包括 (last_hidden_state，可选：hidden_states，可选：attentions) last_hidden_state 的形状为 (batch_size, sequence_length, 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 输入）。 如果使用了 past_key_values，用户可以选择仅输入最后的 decoder_input_ids（那些没有将其过去的键值状态提供给此模型的）的形状为 (batch_size, 1) 的张量，而不是形状为 (batch_size, sequence_length) 的所有 decoder_input_ids。
  • inputs_embeds (torch.FloatTensor，形状为 (batch_size, sequence_length, hidden_size)，可选) — 可选地，您可以选择直接传递嵌入表示，而不是传递 input_ids。如果您想要更多控制如何将 input_ids 索引转换为相关向量，而不是使用模型的内部嵌入查找矩阵，这将非常有用。
  • decoder_inputs_embeds (torch.FloatTensor，形状为 (batch_size, target_sequence_length, hidden_size)，可选) — 可选地，您可以选择直接传递嵌入表示，而不是传递 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，则返回 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 时）包含根据配置（BlenderbotSmallConfig）和输入的不同元素。

  • last_hidden_state (torch.FloatTensor，形状为(batch_size, sequence_length, hidden_size)) — 模型解码器最后一层的隐藏状态序列。 如果使用past_key_values，则只输出形状为(batch_size, 1, hidden_size)的序列的最后隐藏状态。
  • past_key_values (tuple(tuple(torch.FloatTensor)), optional, 当传递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), optional, 当传递output_hidden_states=True或config.output_hidden_states=True时返回) — 形状为(batch_size, sequence_length, hidden_size)的torch.FloatTensor元组（用于嵌入层的输出和每层输出的一个）。 解码器每层输出的隐藏状态以及可选的初始嵌入输出。
  • decoder_attentions (tuple(torch.FloatTensor), optional, 当传递output_attentions=True或config.output_attentions=True时返回) — 形状为(batch_size, num_heads, sequence_length, sequence_length)的torch.FloatTensor元组（每层一个）。 解码器的注意力权重，在注意力 softmax 之后，用于计算自注意力头中的加权平均值。
  • cross_attentions (tuple(torch.FloatTensor), optional, 当传递output_attentions=True或config.output_attentions=True时返回) — 形状为(batch_size, num_heads, sequence_length, sequence_length)的torch.FloatTensor元组（每层一个）。 解码器的交叉注意力层的注意力权重，在注意力 softmax 之后，用于计算交叉注意力头中的加权平均值。
  • encoder_last_hidden_state (torch.FloatTensor，形状为(batch_size, sequence_length, hidden_size)，optional) — 模型编码器最后一层的隐藏状态序列。
  • encoder_hidden_states (tuple(torch.FloatTensor), optional, 当传递output_hidden_states=True或config.output_hidden_states=True时返回) — 形状为(batch_size, sequence_length, hidden_size)的torch.FloatTensor元组（用于嵌入层的输出和每层输出的一个）。 编码器每层输出的隐藏状态以及可选的初始嵌入输出。
  • encoder_attentions (tuple(torch.FloatTensor), optional, 当传递output_attentions=True或config.output_attentions=True时返回) — 形状为(batch_size, num_heads, sequence_length, sequence_length)的torch.FloatTensor元组（每层一个）。 编码器的注意力权重，在注意力 softmax 之后，用于计算自注意力头中的加权平均值。

BlenderbotSmallModel 的前向方法重写了__call__特殊方法。

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

示例：

代码语言：javascript复制
>>> from transformers import AutoTokenizer, BlenderbotSmallModel

>>> model = BlenderbotSmallModel.from_pretrained("facebook/blenderbot_small-90M")
>>> tokenizer = AutoTokenizer.from_pretrained("facebook/blenderbot_small-90M")

>>> inputs = tokenizer("Studies have been shown that owning a dog is good for you", return_tensors="pt")
>>> decoder_inputs = tokenizer("Studies show that", return_tensors="pt")  # Batch size 1
>>> outputs = model(input_ids=inputs.input_ids, decoder_input_ids=decoder_inputs.input_ids)

>>> last_hidden_states = outputs.last_hidden_state
>>> list(last_hidden_states.shape)
[1, 3, 512]

BlenderbotSmallForConditionalGeneration

class transformers.BlenderbotSmallForConditionalGeneration

<来源>

代码语言：javascript复制
( config: BlenderbotSmallConfig )

参数

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

BlenderbotSmall 模型带有一个语言建模头。可用于摘要。此模型继承自 PreTrainedModel。检查超类文档以获取库为其所有模型实现的通用方法（例如下载或保存、调整输入嵌入、修剪头等）。

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

forward

< source >

代码语言：javascript复制
( input_ids: Optional = None 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: Union = 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 (torch.LongTensor of shape (batch_size, sequence_length)) — 输入序列标记在词汇表中的索引。默认情况下，如果提供填充，则将忽略填充。 可以使用 AutoTokenizer 获取索引。有关详细信息，请参阅 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。 什么是输入 ID？
  • attention_mask (torch.Tensor of shape (batch_size, sequence_length), optional) — 用于避免在填充标记索引上执行注意力的掩码。掩码值选定在 [0, 1]：
    • 1 表示标记是 未被掩码，
    • 0 表示标记是 被掩码。

    什么是注意力掩码？

  • decoder_input_ids (torch.LongTensor of shape (batch_size, target_sequence_length), optional) — 解码器输入序列标记在词汇表中的索引。 可以使用 AutoTokenizer 获取索引。有关详细信息，请参阅 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。 什么是解码器输入 ID？ BlenderbotSmall 使用 bos_token_id 作为 decoder_input_ids 生成的起始标记。如果使用了 past_key_values，则只需选择最后的 decoder_input_ids 输入（参见 past_key_values）。
  • decoder_attention_mask (torch.LongTensor of shape (batch_size, target_sequence_length), optional) — 默认行为：生成一个张量，忽略 decoder_input_ids 中的填充标记。默认情况下也将使用因果掩码。
  • head_mask (torch.Tensor of shape (encoder_layers, encoder_attention_heads), optional) — 用于在编码器中使注意力模块中的选定头部失效的掩码。掩码值选定在 [0, 1]：
    • 1 表示头部是 未被掩码，
    • 0 表示头部是 被掩码。
  • decoder_head_mask (torch.Tensor of shape (decoder_layers, decoder_attention_heads), optional) — 用于在解码器中使注意力模块中的选定头部失效的掩码。掩码值选定在 [0, 1]：
    • 1 表示头部是 未被掩码，
    • 0 表示头部是 被掩码。
  • cross_attn_head_mask (torch.Tensor 的形状为 (decoder_layers, decoder_attention_heads)，optional) — 用于将解码器中交叉注意力模块的选定头部置零的掩码。掩码值选定在 [0, 1] 中：
    • 1 表示头部是 not masked,
    • 0 表示头部是 masked。
  • encoder_outputs (tuple(tuple(torch.FloatTensor), optional) — 元组包含 (last_hidden_state, optional: hidden_states, optional: attentions) last_hidden_state 的形状为 (batch_size, sequence_length, hidden_size)，optional) 是编码器最后一层的隐藏状态序列。用于解码器的交叉注意力。
  • past_key_values (tuple(tuple(torch.FloatTensor)), optional, 当传递 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 输入）。 如果使用了 past_key_values，用户可以选择仅输入最后的 decoder_input_ids（那些没有将其过去的键值状态提供给此模型的）的形状为 (batch_size, 1)，而不是所有形状为 (batch_size, sequence_length) 的 decoder_input_ids。
  • inputs_embeds (torch.FloatTensor 的形状为 (batch_size, sequence_length, hidden_size)，optional) — 可选地，可以直接传递嵌入表示，而不是传递 input_ids。如果要更好地控制如何将 input_ids 索引转换为相关向量，这将非常有用，而不是使用模型的内部嵌入查找矩阵。
  • decoder_inputs_embeds (torch.FloatTensor 的形状为 (batch_size, target_sequence_length, hidden_size)，optional) — 可选地，可以直接传递嵌入表示，而不是传递 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, optional) — 如果设置为 True，则返回 past_key_values 键值状态，并可用于加速解码（参见 past_key_values）。
  • output_attentions (bool, optional) — 是否返回所有注意力层的注意力张量。有关更多详细信息，请参阅返回张量下的 attentions。
  • output_hidden_states (bool, optional) — 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回张量下的 hidden_states。
  • return_dict (bool, optional) — 是否返回 ModelOutput 而不是普通元组。
  • labels (torch.LongTensor 的形状为 (batch_size, sequence_length)，optional) — 用于计算掩码语言建模损失的标签。索引应该在 [0, ..., config.vocab_size] 或 -100（参见 input_ids 文档字符串）。索引设置为 -100 的标记将被忽略（masked），损失仅计算具有标签在 [0, ..., config.vocab_size] 中的标记。

返回

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

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

  • loss (torch.FloatTensor of shape (1,), optional, 当提供labels时返回) — 语言建模损失。
  • logits (torch.FloatTensor of shape (batch_size, sequence_length, config.vocab_size)) — 语言建模头的预测分数（SoftMax 之前每个词汇标记的分数）。
  • past_key_values (tuple(tuple(torch.FloatTensor)), optional, 当传递use_cache=True或config.use_cache=True时返回) — 长度为config.n_layers的tuple(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), optional, 当传递output_hidden_states=True或config.output_hidden_states=True时返回) — 形状为(batch_size, sequence_length, hidden_size)的torch.FloatTensor元组。 解码器每一层的输出的隐藏状态加上初始嵌入输出。
  • decoder_attentions (tuple(torch.FloatTensor), optional, 当传递output_attentions=True或config.output_attentions=True时返回) — 形状为(batch_size, num_heads, sequence_length, sequence_length)的torch.FloatTensor元组。 解码器的注意力权重，在注意力 softmax 之后，用于计算自注意力头中的加权平均值。
  • cross_attentions (tuple(torch.FloatTensor), optional, 当传递output_attentions=True或config.output_attentions=True时返回) — 形状为(batch_size, num_heads, sequence_length, sequence_length)的torch.FloatTensor元组。 解码器的交叉注意力层的注意力权重，在注意力 softmax 之后，用于计算交叉注意力头中的加权平均值。
  • encoder_last_hidden_state (torch.FloatTensor of shape (batch_size, sequence_length, hidden_size), optional) — 模型编码器最后一层的隐藏状态序列。
  • encoder_hidden_states (tuple(torch.FloatTensor), optional, 当传递output_hidden_states=True或config.output_hidden_states=True时返回) — 形状为(batch_size, sequence_length, hidden_size)的torch.FloatTensor元组。 编码器每一层的输出的隐藏状态加上初始嵌入输出。
  • encoder_attentions (tuple(torch.FloatTensor), optional, 当传递output_attentions=True或config.output_attentions=True时返回) — 形状为(batch_size, num_heads, sequence_length, sequence_length)的torch.FloatTensor元组。 编码器的注意力权重，在注意力 softmax 之后，用于计算自注意力头中的加权平均值。

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

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

对话示例：

代码语言：javascript复制
>>> from transformers import AutoTokenizer, BlenderbotSmallForConditionalGeneration

>>> mname = "facebook/blenderbot_small-90M"
>>> model = BlenderbotSmallForConditionalGeneration.from_pretrained(mname)
>>> tokenizer = AutoTokenizer.from_pretrained(mname)
>>> UTTERANCE = "My friends are cool but they eat too many carbs."
>>> print("Human: ", UTTERANCE)
Human:  My friends are cool but they eat too many carbs.

>>> inputs = tokenizer([UTTERANCE], return_tensors="pt")
>>> reply_ids = model.generate(**inputs)
>>> print("Bot: ", tokenizer.batch_decode(reply_ids, skip_special_tokens=True)[0])
Bot:  what kind of carbs do they eat? i don't know much about carbs.

>>> REPLY = "I'm not sure"
>>> print("Human: ", REPLY)
Human: I'm not sure

>>> NEXT_UTTERANCE = (
...     "My friends are cool but they eat too many carbs.__end__ __start__what kind of carbs do they eat? "
...     "i don't know much about carbs__end__ "
...     "__start__ I'm not sure."
... )
>>> inputs = tokenizer([NEXT_UTTERANCE], return_tensors="pt")
>>> next_reply_ids = model.generate(**inputs)
>>> print("Bot: ", tokenizer.batch_decode(next_reply_ids, skip_special_tokens=True)[0])
Bot:  they eat a lot of carbs. carbs are high in fat, protein, and fats.

BlenderbotSmallForCausalLM

class transformers.BlenderbotSmallForCausalLM

<来源>

代码语言：javascript复制
( config )
forward

<来源>

代码语言：javascript复制
( input_ids: LongTensor = None attention_mask: Optional = None encoder_hidden_states: Optional = None encoder_attention_mask: Optional = None head_mask: Optional = None cross_attn_head_mask: Optional = None past_key_values: Optional = None 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.CausalLMOutputWithCrossAttentions 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.Tensor，可选）— 用于避免对填充标记索引执行注意力。掩码值选定在[0, 1]之间：
    • 1 表示未被 masked的标记，
    • 0 表示被 masked的标记。

    什么是注意力掩码？

  • encoder_hidden_states（形状为(batch_size, sequence_length, hidden_size)的torch.FloatTensor，可选）— 编码器最后一层的隐藏状态序列。如果模型配置为解码器，则在交叉注意力中使用。
  • encoder_attention_mask（形状为(batch_size, sequence_length)的torch.FloatTensor，可选）— 用于避免对编码器输入的填充标记索引执行注意力。如果模型配置为解码器，则在交叉注意力中使用此掩码。掩码值选定在[0, 1]之间：
  • head_mask（形状为(decoder_layers, decoder_attention_heads)的torch.Tensor，可选）— 用于使注意力模块中选定头部失效的掩码。掩码值选定在[0, 1]之间：
    • 1 表示头部未被 masked，
    • 0 表示头部被 masked。
  • cross_attn_head_mask（形状为(decoder_layers, decoder_attention_heads)的torch.Tensor，可选）— 用于使交叉注意力模块中选定头部失效的掩码。掩码值选定在[0, 1]之间：
    • 1 表示头部未被 masked，
    • 0 表示头部被masked。
  • 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输入）。 如果使用past_key_values，用户可以选择性地仅输入最后一个形状为(batch_size, 1)的decoder_input_ids（那些没有将它们的过去键值状态提供给此模型的输入），而不是形状为(batch_size, sequence_length)的所有decoder_input_ids。
  • labels（形状为(batch_size, sequence_length)的torch.LongTensor，可选） — 用于计算掩码语言建模损失的标签。索引应该在[0, ..., config.vocab_size]范围内，或者为-100（参见input_ids文档字符串）。将索引设置为-100的标记将被忽略（屏蔽），损失仅计算具有[0, ..., config.vocab_size]标签的标记。
  • use_cache（bool，可选） — 如果设置为True，则返回past_key_values键值状态，并可用于加速解码（参见past_key_values）。
    • 对于未屏蔽的标记，
    • 对于被屏蔽的标记为 0。
  • output_attentions（bool，可选） — 是否返回所有注意力层的注意力张量。有关更多详细信息，请参见返回张量下的attentions。
  • output_hidden_states（bool，可选） — 是否返回所有层的隐藏状态。有关更多详细信息，请参见返回张量下的hidden_states。
  • return_dict（bool，可选） — 是否返回 ModelOutput 而不是普通元组。

返回

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

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

  • 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 之后的注意力权重。
  • cross_attentions（tuple(torch.FloatTensor)，可选，当传递output_attentions=True或config.output_attentions=True时返回） — 形状为(batch_size, num_heads, sequence_length, sequence_length)的torch.FloatTensor元组（每层一个）。 交叉注意力 softmax 之后的交叉注意力权重，用于计算交叉注意力头中的加权平均值。
  • past_key_values（tuple(tuple(torch.FloatTensor))，可选，当传递use_cache=True或config.use_cache=True时返回） — 长度为config.n_layers的torch.FloatTensor元组的元组，每个元组包含自注意力和交叉注意力层的缓存键、值状态，如果模型用于编码器-解码器设置，则相关。仅在config.is_decoder = True时相关。 包含预先计算的隐藏状态（注意力块中的键和值），可用于加速顺序解码。

示例：

代码语言：javascript复制
>>> from transformers import AutoTokenizer, BlenderbotSmallForCausalLM

>>> tokenizer = AutoTokenizer.from_pretrained("facebook/blenderbot_small-90M")
>>> model = BlenderbotSmallForCausalLM.from_pretrained("facebook/blenderbot_small-90M", add_cross_attention=False)
>>> assert model.config.is_decoder, f"{model.__class__} has to be configured as a decoder."
>>> inputs = tokenizer("Hello, my dog is cute", return_tensors="pt")
>>> outputs = model(**inputs)

>>> logits = outputs.logits
>>> expected_shape = [1, inputs.input_ids.shape[-1], model.config.vocab_size]
>>> list(logits.shape) == expected_shape
True

TensorFlow 隐藏 TensorFlow 内容

TFBlenderbotSmallModel

class transformers.TFBlenderbotSmallModel

<来源>

代码语言：javascript复制
( config: BlenderbotSmallConfig *inputs **kwargs )

参数

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

裸的 BLENDERBOT_SMALL 模型输出原始的隐藏状态，没有特定的头部。此模型继承自 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

<来源>

代码语言：javascript复制
( input_ids: tf.Tensor | None = None attention_mask: tf.Tensor | None = None decoder_input_ids: tf.Tensor | None = None decoder_attention_mask: tf.Tensor | None = None decoder_position_ids: tf.Tensor | None = None head_mask: tf.Tensor | None = None decoder_head_mask: tf.Tensor | None = None cross_attn_head_mask: tf.Tensor | None = None encoder_outputs: Optional[Union[Tuple, TFBaseModelOutput]] = None past_key_values: List[tf.Tensor] | None = None inputs_embeds: tf.Tensor | None = None decoder_inputs_embeds: tf.Tensor | None = None use_cache: Optional[bool] = None output_attentions: Optional[bool] = None output_hidden_states: Optional[bool] = None return_dict: Optional[bool] = None training: Optional[bool] = False **kwargs ) → export const metadata = 'undefined';transformers.modeling_tf_outputs.TFSeq2SeqModelOutput or tuple(tf.Tensor)

参数

  • input_ids（形状为(batch_size, sequence_length)的tf.Tensor） — 词汇表中输入序列标记的索引。 可以使用 AutoTokenizer 获取索引。有关详细信息，请参阅 PreTrainedTokenizer.encode()和 PreTrainedTokenizer.call()。 什么是输入 ID？
  • attention_mask（形状为(batch_size, sequence_length)的tf.Tensor，可选） — 避免在填充标记索引上执行注意力的掩码。选择在[0, 1]中的掩码值：
    • 对于未被屏蔽的标记为 1，
    • 对于被屏蔽的标记为 0。

    什么是注意力掩码？

  • decoder_input_ids (tf.Tensor of shape (batch_size, target_sequence_length), optional) — 词汇表中解码器输入序列标记的索引。 可以使用 AutoTokenizer 获取索引。有关详细信息，请参阅 PreTrainedTokenizer.encode()和 PreTrainedTokenizer.call()。 什么是解码器输入 ID？ BlenderbotSmall 使用bos_token_id作为decoder_input_ids生成的起始标记。如果使用past_key_values，则只需输入最后的decoder_input_ids（参见past_key_values）。
  • decoder_attention_mask (tf.Tensor of shape (batch_size, target_sequence_length), optional) — 将默认生成并忽略填充标记。不建议为大多数用例设置此参数。
  • decoder_position_ids (tf.Tensor of shape (batch_size, sequence_length), optional) — 每个解码器输入序列标记在位置嵌入中的位置索引。在范围[0, config.max_position_embeddings - 1]中选择。
  • head_mask (tf.Tensor of shape (encoder_layers, encoder_attention_heads), optional) — 编码器中注意力模块中选择性头部的掩码。掩码值在[0, 1]范围内选择：
    • 1 表示头部未被掩码，
    • 0 表示头部被掩码。
  • decoder_head_mask (tf.Tensor of shape (decoder_layers, decoder_attention_heads), optional) — 解码器中注意力模块中选择性头部的掩码。掩码值在[0, 1]范围内选择：
    • 1 表示头部未被掩码，
    • 0 表示头部被掩码。
  • cross_attn_head_mask (tf.Tensor of shape (decoder_layers, decoder_attention_heads), optional) — 交叉注意力模块中选择性头部的掩码。掩码值在[0, 1]范围内选择：
    • 1 表示头部未被掩码，
    • 0 表示头部被掩码。
  • encoder_outputs (tf.FloatTensor, optional) — 编码器最后一层的隐藏状态输出。在解码器的交叉注意力中使用。形状为(batch_size, sequence_length, hidden_size)的序列
  • past_key_values (Tuple[Tuple[tf.Tensor]] of length config.n_layers) — 包含预先计算的注意力块的键和值隐藏状态。可用于加速解码。如果使用past_key_values，用户可以选择仅输入最后的decoder_input_ids（即不将其过去的键值状态提供给此模型）的形状为(batch_size, 1)，而不是形状为(batch_size, sequence_length)的所有decoder_input_ids。
  • use_cache (bool, optional, 默认为True) — 如果设置为True，则返回past_key_values键值状态，可用于加速解码（参见past_key_values）。在训练期间设置为False，在生成期间设置为True。
  • output_attentions (bool, optional) — 是否返回所有注意力层的注意力张量。有关更多详细信息，请参阅返回张量中的attentions。此参数仅在急切模式下可用，在图模式中将使用配置中的值。
  • output_hidden_states (bool, optional) — 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回张量中的hidden_states。此参数仅在急切模式下可用，在图模式中将使用配置中的值。
  • return_dict (bool, optional) — 是否返回 ModelOutput 而不是普通元组。此参数可在急切模式下使用，在图模式中该值将始终设置为 True。
  • training (bool, 可选, 默认为 False) — 是否在训练模式下使用模型（一些模块如 dropout 模块在训练和评估之间有不同的行为）。

返回

transformers.modeling_tf_outputs.TFSeq2SeqModelOutput 或tf.Tensor元组。

transformers.modeling_tf_outputs.TFSeq2SeqModelOutput 或一个tf.Tensor元组（如果传递return_dict=False或config.return_dict=False）包含根据配置（BlenderbotSmallConfig）和输入的各种元素。

  • last_hidden_state (tf.Tensor，形状为(batch_size, sequence_length, hidden_size)) — 模型解码器最后一层的隐藏状态序列。 如果使用past_key_values，则只输出形状为(batch_size, 1, hidden_size)的序列的最后隐藏状态。
  • past_key_values (List[tf.Tensor], 可选, 当传递use_cache=True或config.use_cache=True时返回) — 长度为config.n_layers的tf.Tensor列表，每个张量的形状为(2, batch_size, num_heads, sequence_length, embed_size_per_head)。 包含解码器的预计算隐藏状态（注意力块中的键和值），可用于加速顺序解码（参见past_key_values输入）。
  • decoder_hidden_states (tuple(tf.Tensor), 可选, 当传递output_hidden_states=True或config.output_hidden_states=True时返回) — 形状为(batch_size, sequence_length, hidden_size)的tf.Tensor元组（一个用于嵌入的输出 一个用于每层的输出）。 解码器每层输出的隐藏状态加上初始嵌入输出。
  • decoder_attentions (tuple(tf.Tensor), 可选, 当传递output_attentions=True或config.output_attentions=True时返回) — 形状为(batch_size, num_heads, sequence_length, sequence_length)的tf.Tensor元组（每层一个）。 解码器的注意力权重，在注意力 softmax 之后，用于计算自注意力头中的加权平均值。
  • cross_attentions (tuple(tf.Tensor), 可选, 当传递output_attentions=True或config.output_attentions=True时返回) — 形状为(batch_size, num_heads, sequence_length, sequence_length)的tf.Tensor元组（每层一个）。 解码器的交叉注意力层的注意力权重，在注意力 softmax 之后，用于计算交叉注意力头中的加权平均值。
  • encoder_last_hidden_state (tf.Tensor，形状为(batch_size, sequence_length, hidden_size)，可选) — 模型编码器最后一层的隐藏状态序列。
  • encoder_hidden_states (tuple(tf.Tensor), 可选, 当传递output_hidden_states=True或config.output_hidden_states=True时返回) — 形状为(batch_size, sequence_length, hidden_size)的tf.Tensor元组（一个用于嵌入的输出 一个用于每层的输出）。 编码器每层输出的隐藏状态加上初始嵌入输出。
  • encoder_attentions (tuple(tf.Tensor), 可选, 当传递output_attentions=True或config.output_attentions=True时返回) — 形状为(batch_size, num_heads, sequence_length, sequence_length)的tf.Tensor元组（每层一个）。 编码器的注意力权重，在注意力 softmax 之后，用于计算自注意力头中的加权平均值。

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

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

示例：

代码语言：javascript复制
>>> from transformers import AutoTokenizer, TFBlenderbotSmallModel
>>> import tensorflow as tf

>>> tokenizer = AutoTokenizer.from_pretrained("facebook/blenderbot_small-90M")
>>> model = TFBlenderbotSmallModel.from_pretrained("facebook/blenderbot_small-90M")

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

>>> last_hidden_states = outputs.last_hidden_state

TFBlenderbotSmallForConditionalGeneration

class transformers.TFBlenderbotSmallForConditionalGeneration

<来源>

代码语言：javascript复制
( config *inputs **kwargs )

参数

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

BLENDERBOT_SMALL 模型带有语言建模头。可用于摘要。此模型继承自 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

<来源>

代码语言：javascript复制
( input_ids: tf.Tensor | None = None attention_mask: tf.Tensor | None = None decoder_input_ids: tf.Tensor | None = None decoder_attention_mask: tf.Tensor | None = None decoder_position_ids: tf.Tensor | None = None head_mask: tf.Tensor | None = None decoder_head_mask: tf.Tensor | None = None cross_attn_head_mask: tf.Tensor | None = None encoder_outputs: Optional[TFBaseModelOutput] = None past_key_values: List[tf.Tensor] | None = None inputs_embeds: tf.Tensor | None = None decoder_inputs_embeds: tf.Tensor | None = None use_cache: Optional[bool] = None output_attentions: Optional[bool] = None output_hidden_states: Optional[bool] = None return_dict: Optional[bool] = None labels: tf.Tensor | None = None training: Optional[bool] = False ) → export const metadata = 'undefined';transformers.modeling_tf_outputs.TFSeq2SeqLMOutput or tuple(tf.Tensor)

参数

  • input_ids（形状为({0})的tf.Tensor）—词汇表中输入序列标记的索引。 可以使用 AutoTokenizer 获取索引。有关详细信息，请参阅 PreTrainedTokenizer.encode()和 PreTrainedTokenizer.call()。 什么是输入 ID？
  • attention_mask（形状为({0})的tf.Tensor，可选）— 避免在填充标记索引上执行注意力的遮罩。选择在[0, 1]中的遮罩值：
    • 1 表示未被遮罩的标记，
    • 0 表示被遮罩的标记。

    什么是注意力遮罩？

  • decoder_input_ids（形状为(batch_size, target_sequence_length)的tf.Tensor，可选）— 解码器输入序列标记在词汇表中的索引。 可以使用 AutoTokenizer 获取索引。有关详细信息，请参阅 PreTrainedTokenizer.encode()和 PreTrainedTokenizer.call()。 什么是解码器输入 ID？ BlenderbotSmall 使用bos_token_id作为decoder_input_ids生成的起始标记。如果使用past_key_values，可以选择仅输入最后的decoder_input_ids（参见past_key_values）。
  • decoder_attention_mask（形状为(batch_size, target_sequence_length)的tf.Tensor，可选）— 将默认生成并忽略填充标记。不建议为大多数用例设置此项。
  • decoder_position_ids（形状为(batch_size, sequence_length)的tf.Tensor，可选）— 每个解码器输入序列标记在位置嵌入中的位置索引。选择在范围[0, config.max_position_embeddings - 1]中。
  • head_mask（形状为(encoder_layers, encoder_attention_heads)的tf.Tensor，可选）— 用于使编码器中注意力模块的选定头部失效的遮罩。选择在[0, 1]中的遮罩值：
    • 1 表示头部未被遮罩，
    • 0 表示头部被遮罩。
  • decoder_head_mask（形状为(decoder_layers, decoder_attention_heads)的tf.Tensor，可选）— 用于使解码器中注意力模块的选定头部失效的遮罩。选择在[0, 1]中的遮罩值：
    • 1 表示头部未被遮罩，
    • 0 表示头部被遮罩。
  • cross_attn_head_mask（形状为(decoder_layers, decoder_attention_heads)的tf.Tensor，可选）— 用于使交叉注意力模块的选定头部失效的遮罩。选择在[0, 1]中的遮罩值：
    • 1 表示头部未被遮罩，
    • 0 表示头部被遮罩。
  • encoder_outputs（tf.FloatTensor，可选）— 编码器最后一层的隐藏状态输出。在解码器的交叉注意力中使用。形状为(batch_size, sequence_length, hidden_size)是一个序列
  • past_key_values（长度为config.n_layers的Tuple[Tuple[tf.Tensor]]）— 包含注意力块的预计算键和值隐藏状态。可用于加速解码。如果使用past_key_values，用户可以选择仅输入最后的decoder_input_ids（那些没有将它们的过去键值状态提供给此模型的）形状为(batch_size, 1)而不是形状为(batch_size, sequence_length)的所有decoder_input_ids。
  • use_cache（bool，可选，默认为True）— 如果设置为True，将返回past_key_values键值状态，并可用于加速解码（参见past_key_values）。在训练期间设置为False，在生成期间设置为True。
  • 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]范围内，或者为-100（参见input_ids文档字符串）。索引设置为-100的标记将被忽略（掩码），损失仅计算具有标签在[0, ..., config.vocab_size]范围内的标记。

返回

transformers.modeling_tf_outputs.TFSeq2SeqLMOutput 或者tuple(tf.Tensor)

一个 transformers.modeling_tf_outputs.TFSeq2SeqLMOutput 或者一个tf.Tensor元组（如果传递了return_dict=False或者当config.return_dict=False时）包括不同的元素，取决于配置（BlenderbotSmallConfig）和输入。

  • loss（形状为(n,)的tf.Tensor，可选，当提供labels时返回，其中 n 是非掩码标签的数量） — 语言建模损失。
  • logits（形状为(batch_size, sequence_length, config.vocab_size)的tf.Tensor） — 语言建模头的预测分数（SoftMax 之前每个词汇标记的分数）。
  • past_key_values（List[tf.Tensor]，可选，当传递use_cache=True或者当config.use_cache=True时返回） — 长度为config.n_layers的tf.Tensor列表，每个张量的形状为(2, batch_size, num_heads, sequence_length, embed_size_per_head)。 包含解码器的预计算隐藏状态（注意力块中的键和值），可用于加速顺序解码。
  • decoder_hidden_states（tuple(tf.Tensor)，可选，当传递output_hidden_states=True或者当config.output_hidden_states=True时返回） — 形状为(batch_size, sequence_length, hidden_size)的tf.Tensor元组（一个用于嵌入的输出 一个用于每层的输出）。 每层解码器的隐藏状态以及初始嵌入输出。
  • decoder_attentions（tuple(tf.Tensor)，可选，当传递output_attentions=True或者当config.output_attentions=True时返回） — 形状为(batch_size, num_heads, sequence_length, sequence_length)的tf.Tensor元组（每层一个）。 解码器的注意力权重，在注意力 softmax 之后，用于计算自注意力头中的加权平均值。
  • cross_attentions（tuple(tf.Tensor)，可选，当传递output_attentions=True或者当config.output_attentions=True时返回） — 形状为(batch_size, num_heads, sequence_length, sequence_length)的tf.Tensor元组（每层一个）。 解码器交叉注意力层的注意力权重，在注意力 softmax 之后，用于计算交叉注意力头中的加权平均值。
  • encoder_last_hidden_state（形状为(batch_size, sequence_length, hidden_size)的tf.Tensor，可选） — 模型编码器最后一层的隐藏状态序列。
  • encoder_hidden_states（tuple(tf.Tensor)，可选，当传递output_hidden_states=True或者当config.output_hidden_states=True时返回） — 形状为(batch_size, sequence_length, hidden_size)的tf.Tensor元组（一个用于嵌入的输出 一个用于每层的输出）。 编码器每一层输出的隐藏状态加上初始嵌入输出。
  • encoder_attentions (tuple(tf.Tensor), 可选, 当传递output_attentions=True或config.output_attentions=True时返回) — 形状为(batch_size, num_heads, sequence_length, sequence_length)的tf.Tensor元组（每层一个）。 编码器的注意力权重，在注意力 softmax 之后使用，用于计算自注意力头中的加权平均值。

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

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

对话示例::

代码语言：javascript复制
>>> from transformers import AutoTokenizer, TFBlenderbotSmallForConditionalGeneration

>>> mname = "facebook/blenderbot_small-90M"
>>> model = BlenderbotSmallForConditionalGeneration.from_pretrained(mname)
>>> tokenizer = AutoTokenizer.from_pretrained(mname)

>>> UTTERANCE = "My friends are cool but they eat too many carbs."
>>> print("Human: ", UTTERANCE)
>>> inputs = tokenizer([UTTERANCE], return_tensors="tf")

>>> reply_ids = model.generate(**inputs)
>>> print("Bot: ", tokenizer.batch_decode(reply_ids, skip_special_tokens=True)[0])
what kind of carbs do they eat? i don't know much about carbs.

>>> REPLY = "I'm not sure"
>>> print("Human: ", REPLY)
>>> NEXT_UTTERANCE = (
...     "My friends are cool but they eat too many carbs.</s> "
...     "<s>what kind of carbs do they eat? i don't know much about carbs.</s> "
...     "<s>I'm not sure."
... )

>>> inputs = tokenizer([NEXT_UTTERANCE], return_tensors="tf")
>>> inputs.pop("token_type_ids")
>>> next_reply_ids = model.generate(**inputs)
>>> print("Bot: ", tokenizer.batch_decode(next_reply_ids, skip_special_tokens=True)[0])

JAXHide JAX 内容

FlaxBlenderbotSmallModel

class transformers.FlaxBlenderbotSmallModel

<来源>

代码语言：javascript复制
( config: BlenderbotSmallConfig input_shape: Tuple = (1, 1) seed: int = 0 dtype: dtype = <class 'jax.numpy.float32'> _do_init: bool = True **kwargs )

参数

  • config（BlenderbotSmallConfig）— 具有模型所有参数的模型配置类。使用配置文件初始化不会加载与模型关联的权重，只会加载配置。查看 from_pretrained()方法以加载模型权重。
  • dtype（jax.numpy.dtype，可选，默认为jax.numpy.float32）— 计算的数据类型。可以是jax.numpy.float32、jax.numpy.float16（在 GPU 上）和jax.numpy.bfloat16（在 TPU 上）之一。 这可以用于在 GPU 或 TPU 上启用混合精度训练或半精度推断。如果指定了dtype，则所有计算将使用给定的dtype执行。 请注意，这仅指定计算的数据类型，不影响模型参数的数据类型。 如果您希望更改模型参数的数据类型，请参阅 to_fp16()和 to_bf16()。

裸的 BlenderbotSmall Model 变压器输出原始隐藏状态，没有特定的头部。此模型继承自 FlaxPreTrainedModel。查看超类文档以了解库为所有模型实现的通用方法（如下载或保存、调整输入嵌入、修剪头等）。

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

最后，此模型支持内在的 JAX 功能，例如：

  • 即时（JIT）编译
  • 自动微分
  • 矢量化
  • 并行化
__call__

<来源>

代码语言：javascript复制
( input_ids: Array attention_mask: Optional = None decoder_input_ids: Optional = None decoder_attention_mask: Optional = None position_ids: Optional = None decoder_position_ids: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None train: bool = False params: dict = None dropout_rng: PRNGKey = None ) → export const metadata = 'undefined';transformers.modeling_flax_outputs.FlaxSeq2SeqModelOutput or tuple(torch.FloatTensor)

返回

transformers.modeling_flax_outputs.FlaxSeq2SeqModelOutput 或tuple(torch.FloatTensor)

一个 transformers.modeling_flax_outputs.FlaxSeq2SeqModelOutput 或一个torch.FloatTensor元组（如果传递了return_dict=False或当config.return_dict=False时），包括根据配置（BlenderbotSmallConfig）和输入而异的各种元素。

  • last_hidden_state (jnp.ndarray，形状为(batch_size, sequence_length, hidden_size)) — 模型解码器最后一层的隐藏状态序列。 如果使用past_key_values，则只输出形状为(batch_size, 1, hidden_size)的序列的最后一个隐藏状态。
  • past_key_values (tuple(tuple(jnp.ndarray))，可选，当传递use_cache=True或当config.use_cache=True时返回） — 长度为config.n_layers的tuple(jnp.ndarray)元组，每个元组有 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(jnp.ndarray)，可选，当传递output_hidden_states=True或当config.output_hidden_states=True时返回） — 形状为(batch_size, sequence_length, hidden_size)的jnp.ndarray元组。 解码器在每一层输出的隐藏状态加上初始嵌入输出。
  • decoder_attentions (tuple(jnp.ndarray)，可选，当传递output_attentions=True或当config.output_attentions=True时返回） — 形状为(batch_size, num_heads, sequence_length, sequence_length)的jnp.ndarray元组。 解码器的注意力权重，在注意力 softmax 之后，用于计算自注意力头中的加权平均值。
  • cross_attentions (tuple(jnp.ndarray)，可选，当传递output_attentions=True或当config.output_attentions=True时返回） — 形状为(batch_size, num_heads, sequence_length, sequence_length)的jnp.ndarray元组。 解码器的交叉注意力层的注意力权重，在注意力 softmax 之后，用于计算交叉注意力头中的加权平均值。
  • encoder_last_hidden_state (jnp.ndarray，形状为(batch_size, sequence_length, hidden_size)，可选) — 模型编码器最后一层的隐藏状态序列。
  • encoder_hidden_states (tuple(jnp.ndarray)，可选，当传递output_hidden_states=True或当config.output_hidden_states=True时返回） — 形状为(batch_size, sequence_length, hidden_size)的jnp.ndarray元组。 编码器在每一层输出的隐藏状态加上初始嵌入输出。
  • encoder_attentions (tuple(jnp.ndarray)，可选，当传递output_attentions=True或当config.output_attentions=True时返回） — 形状为(batch_size, num_heads, sequence_length, sequence_length)的jnp.ndarray元组。 编码器的注意力权重，在注意力 softmax 之后，用于计算自注意力头中的加权平均值。

示例：

代码语言：javascript复制
>>> from transformers import AutoTokenizer, FlaxBlenderbotSmallModel

>>> tokenizer = AutoTokenizer.from_pretrained("facebook/blenderbot_small-90M")
>>> model = FlaxBlenderbotSmallModel.from_pretrained("facebook/blenderbot_small-90M")

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

>>> last_hidden_states = outputs.last_hidden_state
encode

<来源>

代码语言：javascript复制
( input_ids: Array attention_mask: Optional = None position_ids: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None train: bool = False params: dict = None dropout_rng: PRNGKey = None ) → export const metadata = 'undefined';transformers.modeling_flax_outputs.FlaxBaseModelOutput or tuple(torch.FloatTensor)

参数

  • input_ids (jnp.ndarray，形状为(batch_size, sequence_length)) — 词汇表中输入序列标记的索引。默认情况下将忽略填充。 可以使用 AutoTokenizer 获取索引。有关详细信息，请参阅 PreTrainedTokenizer.encode()和 PreTrainedTokenizer.call()。 输入 ID 是什么？
  • attention_mask（形状为(batch_size, sequence_length)的jnp.ndarray，可选）- 避免在填充标记索引上执行注意力的掩码。选择的掩码值在[0, 1]中：
    • 对于未被掩码的标记为 1，
    • 对于被掩码的标记为 0。

    什么是注意力掩码？

  • position_ids（形状为(batch_size, sequence_length)的numpy.ndarray，可选）- 每个输入序列标记在位置嵌入中的位置索引。选择范围为[0, config.max_position_embeddings - 1]。
  • output_attentions（bool，可选）- 是否返回所有注意力层的注意力张量。有关更多详细信息，请参阅返回张量下的attentions。
  • output_hidden_states（bool，可选）- 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回张量下的hidden_states。
  • return_dict（bool，可选）- 是否返回 ModelOutput 而不是普通元组。

返回

transformers.modeling_flax_outputs.FlaxBaseModelOutput 或tuple(torch.FloatTensor)

一个 transformers.modeling_flax_outputs.FlaxBaseModelOutput 或一个torch.FloatTensor元组（如果传递了return_dict=False或config.return_dict=False时）包括根据配置（<class 'transformers.models.blenderbot_small.configuration_blenderbot_small.BlenderbotSmallConfig'>）和输入的不同元素。

  • last_hidden_state（形状为(batch_size, sequence_length, hidden_size)的jnp.ndarray）- 模型最后一层的隐藏状态序列。
  • hidden_states（tuple(jnp.ndarray)，可选，当传递output_hidden_states=True或config.output_hidden_states=True时返回）- 形状为(batch_size, sequence_length, hidden_size)的jnp.ndarray元组（一个用于嵌入的输出 一个用于每一层的输出）。 模型在每一层输出的隐藏状态加上初始嵌入输出。
  • attentions（tuple(jnp.ndarray)，可选，当传递output_attentions=True或config.output_attentions=True时返回）- 形状为(batch_size, num_heads, sequence_length, sequence_length)的jnp.ndarray元组（每层一个）。 在自注意力头中用于计算加权平均值的注意力 softmax 之后的注意力权重。

示例：

代码语言：javascript复制
>>> from transformers import AutoTokenizer, FlaxBlenderbotSmallForConditionalGeneration

>>> model = FlaxBlenderbotSmallForConditionalGeneration.from_pretrained("facebook/blenderbot_small-90M")
>>> tokenizer = AutoTokenizer.from_pretrained("facebook/blenderbot_small-90M")

>>> text = "My friends are cool but they eat too many carbs."
>>> inputs = tokenizer(text, max_length=1024, return_tensors="np")
>>> encoder_outputs = model.encode(**inputs)
decode

<来源>

代码语言：javascript复制
( decoder_input_ids encoder_outputs encoder_attention_mask: Optional = None decoder_attention_mask: Optional = None decoder_position_ids: Optional = None past_key_values: dict = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None train: bool = False params: dict = None dropout_rng: PRNGKey = None ) → export const metadata = 'undefined';transformers.modeling_flax_outputs.FlaxBaseModelOutputWithPastAndCrossAttentions or tuple(torch.FloatTensor)

参数

  • decoder_input_ids（形状为(batch_size, target_sequence_length)的jnp.ndarray）- 译码器输入序列标记在词汇表中的索引。 可以使用 AutoTokenizer 获取索引。有关详细信息，请参阅 PreTrainedTokenizer.encode()和 PreTrainedTokenizer.call()。 什么是解码器输入 ID？ 对于翻译和摘要训练，应提供decoder_input_ids。如果没有提供decoder_input_ids，模型将通过将input_ids向右移动来创建此张量，以用于去噪预训练。
  • encoder_outputs (tuple(tuple(jnp.ndarray)) — 元组由(last_hidden_state, optional: hidden_states, optional: attentions)组成，last_hidden_state的形状为(batch_size, sequence_length, hidden_size)，optional)是编码器最后一层的隐藏状态序列。用于解码器的交叉注意力。
  • encoder_attention_mask (jnp.ndarray of shape (batch_size, sequence_length), optional) — 避免在填充标记索引上执行注意力的掩码。掩码值选择在[0, 1]中：
    • 1 表示未被掩码的标记，
    • 0 表示被掩码的标记。

    什么是注意力掩码？

  • decoder_attention_mask (jnp.ndarray of shape (batch_size, target_sequence_length), optional) — 默认行为：生成一个张量，忽略decoder_input_ids中的填充标记。因果掩码也将默认使用。 如果要更改填充行为，应根据需要进行修改。有关默认策略的更多信息，请参见论文中的图表 1。
  • decoder_position_ids (numpy.ndarray of shape (batch_size, sequence_length), optional) — 每个解码器输入序列标记在位置嵌入中的位置索引。在范围[0, config.max_position_embeddings - 1]中选择。
  • past_key_values (Dict[str, np.ndarray], optional, 由init_cache返回或者传递先前的past_key_values时返回) — 预先计算的隐藏状态字典（注意力块中的键和值），可用于快速自回归解码。预先计算的键和值隐藏状态的形状为*[batch_size, max_length]*。
  • output_attentions (bool, optional) — 是否返回所有注意力层的注意力张量。有关更多详细信息，请参见返回张量下的attentions。
  • output_hidden_states (bool, optional) — 是否返回所有层的隐藏状态。有关更多详细信息，请参见返回张量下的hidden_states。
  • return_dict (bool, optional) — 是否返回 ModelOutput 而不是普通元组。

返回

transformers.modeling_flax_outputs.FlaxBaseModelOutputWithPastAndCrossAttentions 或者tuple(torch.FloatTensor)

一个 transformers.modeling_flax_outputs.FlaxBaseModelOutputWithPastAndCrossAttentions 或者一个torch.FloatTensor元组（如果传递了return_dict=False或者config.return_dict=False）包含各种元素，取决于配置（<class 'transformers.models.blenderbot_small.configuration_blenderbot_small.BlenderbotSmallConfig'>）和输入。

  • last_hidden_state (jnp.ndarray of shape (batch_size, sequence_length, hidden_size)) — 模型最后一层的隐藏状态序列。 如果仅使用past_key_values，则输出序列的最后一个隐藏状态的形状为(batch_size, 1, hidden_size)。
  • past_key_values (tuple(tuple(jnp.ndarray)), optional, 当传递use_cache=True或者config.use_cache=True时返回) — 长度为config.n_layers的tuple(jnp.ndarray)元组，每个元组有 2 个形状为(batch_size, num_heads, sequence_length, embed_size_per_head)的张量，如果config.is_encoder_decoder=True还有 2 个额外的形状为(batch_size, num_heads, encoder_sequence_length, embed_size_per_head)的张量。 包含预先计算的隐藏状态（自注意力块中的键和值，以及在交叉注意力块中可选地使用config.is_encoder_decoder=True）可用于加速顺序解码（请参见past_key_values输入）。
  • hidden_states (tuple(jnp.ndarray), 可选, 当传递output_hidden_states=True或config.output_hidden_states=True时返回) — 形状为(batch_size, sequence_length, hidden_size)的jnp.ndarray元组（一个用于嵌入的输出，一个用于每个层的输出）。 模型在每一层输出的隐藏状态加上初始嵌入输出。
  • attentions (tuple(jnp.ndarray), 可选, 当传递output_attentions=True或config.output_attentions=True时返回) — 形状为(batch_size, num_heads, sequence_length, sequence_length)的jnp.ndarray元组（每层一个）。 在自注意力头中用于计算加权平均值的注意力 softmax 后的注意力权重。
  • cross_attentions (tuple(jnp.ndarray), 可选, 当传递output_attentions=True和config.add_cross_attention=True或config.output_attentions=True时返回) — 形状为(batch_size, num_heads, sequence_length, sequence_length)的jnp.ndarray元组（每层一个）。 解码器的交叉注意力层的注意力权重，在注意力 softmax 后使用，用于计算交叉注意力头中的加权平均值。

示例：

代码语言：javascript复制
>>> import jax.numpy as jnp
>>> from transformers import AutoTokenizer, FlaxBlenderbotSmallForConditionalGeneration

>>> model = FlaxBlenderbotSmallForConditionalGeneration.from_pretrained("facebook/blenderbot_small-90M")
>>> tokenizer = AutoTokenizer.from_pretrained("facebook/blenderbot_small-90M")

>>> text = "My friends are cool but they eat too many carbs."
>>> inputs = tokenizer(text, max_length=1024, return_tensors="np")
>>> encoder_outputs = model.encode(**inputs)

>>> decoder_start_token_id = model.config.decoder_start_token_id
>>> decoder_input_ids = jnp.ones((inputs.input_ids.shape[0], 1), dtype="i4") * decoder_start_token_id

>>> outputs = model.decode(decoder_input_ids, encoder_outputs)
>>> last_decoder_hidden_states = outputs.last_hidden_state

FlaxBlenderbotForConditionalGeneration

class transformers.FlaxBlenderbotSmallForConditionalGeneration

<来源>

代码语言：javascript复制
( config: BlenderbotSmallConfig input_shape: Tuple = (1, 1) seed: int = 0 dtype: dtype = <class 'jax.numpy.float32'> _do_init: bool = True **kwargs )

参数

  • config (BlenderbotSmallConfig) — 具有模型所有参数的模型配置类。使用配置文件初始化不会加载与模型关联的权重，只加载配置。查看 from_pretrained()方法以加载模型权重。
  • dtype (jax.numpy.dtype, 可选, 默认为jax.numpy.float32) — 计算的数据类型。可以是jax.numpy.float32、jax.numpy.float16（在 GPU 上）和jax.numpy.bfloat16（在 TPU 上）之一。 这可以用于在 GPU 或 TPU 上启用混合精度训练或半精度推断。如果指定了，所有计算将使用给定的dtype执行。 请注意，这仅指定计算的 dtype，不影响模型参数的 dtype。 如果要更改模型参数的 dtype，请参阅 to_fp16()和 to_bf16()。

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

此模型也是 Flax 亚麻flax.nn.Module子类。将其用作常规 Flax 模块，并参考 Flax 文档以获取与一般用法和行为相关的所有内容。

最后，此模型支持 JAX 的固有特性，例如：

  • 即时（JIT）编译
  • 自动微分
  • 矢量化
  • 并行化
__call__

<来源>

代码语言：javascript复制
( input_ids: Array attention_mask: Optional = None decoder_input_ids: Optional = None decoder_attention_mask: Optional = None position_ids: Optional = None decoder_position_ids: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None train: bool = False params: dict = None dropout_rng: PRNGKey = None ) → export const metadata = 'undefined';transformers.modeling_flax_outputs.FlaxSeq2SeqLMOutput or tuple(torch.FloatTensor)

参数

  • input_ids (jnp.ndarray of shape (batch_size, sequence_length)) — 词汇表中输入序列标记的索引。默认情况下，如果提供了填充，则将被忽略。 可以使用 AutoTokenizer 获取索引。有关详细信息，请参阅 PreTrainedTokenizer.encode()和 PreTrainedTokenizer.call()。 什么是输入 ID？
  • attention_mask (jnp.ndarray of shape (batch_size, sequence_length), optional) — 避免在填充标记索引上执行注意力的掩码。掩码值选择在[0, 1]之间：
    • 对于not masked的标记为 1，
    • 对于masked的标记为 0。

    什么是注意力掩码？

  • decoder_input_ids (jnp.ndarray of shape (batch_size, target_sequence_length), optional) — 词汇表中解码器输入序列标记的索引。 可以使用 AutoTokenizer 获取索引。有关详细信息，请参阅 PreTrainedTokenizer.encode()和 PreTrainedTokenizer.call()。 什么是解码器输入 ID？ 对于翻译和摘要训练，应提供decoder_input_ids。如果未提供decoder_input_ids，模型将通过将input_ids向右移动来创建此张量，以进行去噪预训练，遵循论文。
  • decoder_attention_mask (jnp.ndarray of shape (batch_size, target_sequence_length), optional) — 默认行为：生成一个忽略decoder_input_ids中填充标记的张量。默认情况下还将使用因果掩码。 如果要更改填充行为，应根据需要进行修改。有关默认策略的更多信息，请参阅论文中的图表 1。
  • position_ids (numpy.ndarray of shape (batch_size, sequence_length), optional) — 每个输入序列标记在位置嵌入中的位置索引。选择范围为[0, config.max_position_embeddings - 1]。
  • decoder_position_ids (numpy.ndarray of shape (batch_size, sequence_length), optional) — 每个解码器输入序列标记在位置嵌入中的位置索引。选择范围为[0, config.max_position_embeddings - 1]。
  • output_attentions (bool, optional) — 是否返回所有注意力层的注意力张量。有关更多详细信息，请参阅返回张量中的attentions。
  • output_hidden_states (bool, optional) — 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回张量中的hidden_states。
  • return_dict (bool, optional) — 是否返回 ModelOutput 而不是普通元组。

返回

transformers.modeling_flax_outputs.FlaxSeq2SeqLMOutput 或 tuple(torch.FloatTensor)

一个 transformers.modeling_flax_outputs.FlaxSeq2SeqLMOutput 或一个torch.FloatTensor元组（如果传递了return_dict=False或config.return_dict=False时）包括根据配置（BlenderbotSmallConfig）和输入的各种元素。

  • logits（形状为(batch_size, sequence_length, config.vocab_size)的jnp.ndarray）— 语言建模头的预测分数（SoftMax 之前每个词汇标记的分数）。
  • past_key_values（tuple(tuple(jnp.ndarray))，可选，当传递use_cache=True或config.use_cache=True时返回）— 长度为config.n_layers的tuple(jnp.ndarray)元组，每个元组有 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(jnp.ndarray)，可选，当传递output_hidden_states=True或config.output_hidden_states=True时返回）— 形状为(batch_size, sequence_length, hidden_size)的jnp.ndarray元组（一个用于嵌入的输出 一个用于每一层的输出）。 解码器每一层的隐藏状态加上初始嵌入输出。
  • decoder_attentions（tuple(jnp.ndarray)，可选，当传递output_attentions=True或config.output_attentions=True时返回）— 形状为(batch_size, num_heads, sequence_length, sequence_length)的jnp.ndarray元组（每层一个）。 解码器的注意力权重，在注意力 softmax 之后，用于计算自注意力头中的加权平均值。
  • cross_attentions（tuple(jnp.ndarray)，可选，当传递output_attentions=True或config.output_attentions=True时返回）— 形状为(batch_size, num_heads, sequence_length, sequence_length)的jnp.ndarray元组（每层一个）。 解码器的交叉注意力层的注意力权重，在注意力 softmax 之后，用于计算交叉注意力头中的加权平均值。
  • encoder_last_hidden_state（形状为(batch_size, sequence_length, hidden_size)的jnp.ndarray，可选）— 模型编码器最后一层的隐藏状态序列。
  • encoder_hidden_states（tuple(jnp.ndarray)，可选，当传递output_hidden_states=True或config.output_hidden_states=True时返回）— 形状为(batch_size, sequence_length, hidden_size)的jnp.ndarray元组（一个用于嵌入的输出 一个用于每一层的输出）。 编码器每一层的隐藏状态加上初始嵌入输出。
  • encoder_attentions（tuple(jnp.ndarray)，可选，当传递output_attentions=True或config.output_attentions=True时返回）— 形状为(batch_size, num_heads, sequence_length, sequence_length)的jnp.ndarray元组（每层一个）。 编码器的注意力权重，在注意力 softmax 之后，用于计算自注意力头中的加权平均值。

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

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

摘要示例：

代码语言：javascript复制
>>> from transformers import AutoTokenizer, FlaxBlenderbotSmallForConditionalGeneration

>>> model = FlaxBlenderbotSmallForConditionalGeneration.from_pretrained("facebook/blenderbot_small-90M")
>>> tokenizer = AutoTokenizer.from_pretrained("facebook/blenderbot_small-90M")

>>> ARTICLE_TO_SUMMARIZE = "My friends are cool but they eat too many carbs."
>>> inputs = tokenizer([ARTICLE_TO_SUMMARIZE], max_length=1024, return_tensors="np")

>>> # Generate Summary
>>> summary_ids = model.generate(inputs["input_ids"]).sequences
>>> print(tokenizer.batch_decode(summary_ids, skip_special_tokens=True, clean_up_tokenization_spaces=False))

填充掩码示例：

代码语言：javascript复制
>>> from transformers import AutoTokenizer, FlaxBlenderbotSmallForConditionalGeneration

>>> tokenizer = AutoTokenizer.from_pretrained("facebook/blenderbot_small-90M")
>>> TXT = "My friends are <mask> but they eat too many carbs."

>>> model = FlaxBlenderbotSmallForConditionalGeneration.from_pretrained("facebook/blenderbot_small-90M")
>>> input_ids = tokenizer([TXT], return_tensors="np")["input_ids"]
>>> logits = model(input_ids).logits

>>> masked_index = (input_ids[0] == tokenizer.mask_token_id).nonzero().item()
>>> probs = jax.nn.softmax(logits[0, masked_index], axis=0)
>>> values, predictions = jax.lax.top_k(probs)

>>> tokenizer.decode(predictions).split()
encode

< source >

代码语言：javascript复制
( input_ids: Array attention_mask: Optional = None position_ids: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None train: bool = False params: dict = None dropout_rng: PRNGKey = None ) → export const metadata = 'undefined';transformers.modeling_flax_outputs.FlaxBaseModelOutput or tuple(torch.FloatTensor)

参数

  • input_ids (jnp.ndarray of shape (batch_size, sequence_length)) — 词汇表中输入序列标记的索引。默认情况下将忽略填充。 可以使用 AutoTokenizer 获取索引。有关详细信息，请参阅 PreTrainedTokenizer.encode()和 PreTrainedTokenizer.call()。 什么是输入 ID？
  • attention_mask (jnp.ndarray of shape (batch_size, sequence_length), optional) — 避免在填充标记索引上执行注意力的掩码。掩码值选择在[0, 1]中：
    • 对于未被掩码的标记为 1，
    • 对于被掩码的标记为 0。

    什么是注意力掩码？

  • position_ids (numpy.ndarray of shape (batch_size, sequence_length), optional) — 每个输入序列标记在位置嵌入中的位置索引。在范围[0, config.max_position_embeddings - 1]中选择。
  • output_attentions (bool, optional) — 是否返回所有注意力层的注意力张量。有关更多详细信息，请参阅返回的张量中的attentions。
  • output_hidden_states (bool, optional) — 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回的张量中的hidden_states。
  • return_dict (bool, optional) — 是否返回 ModelOutput 而不是普通元组。

返回

transformers.modeling_flax_outputs.FlaxBaseModelOutput 或 tuple(torch.FloatTensor)

一个 transformers.modeling_flax_outputs.FlaxBaseModelOutput 或一个torch.FloatTensor元组（如果传递return_dict=False或config.return_dict=False）包含根据配置（<class 'transformers.models.blenderbot_small.configuration_blenderbot_small.BlenderbotSmallConfig'>）和输入的不同元素。

  • last_hidden_state (jnp.ndarray of shape (batch_size, sequence_length, hidden_size)) — 模型最后一层输出的隐藏状态序列。
  • hidden_states (tuple(jnp.ndarray), optional, 当传递output_hidden_states=True或config.output_hidden_states=True时返回) — jnp.ndarray的元组（一个用于嵌入的输出 一个用于每一层的输出），形状为(batch_size, sequence_length, hidden_size)。 每层模型的隐藏状态加上初始嵌入输出。
  • attentions (tuple(jnp.ndarray), optional, 当传递output_attentions=True或config.output_attentions=True时返回) — jnp.ndarray的元组（每层一个），形状为(batch_size, num_heads, sequence_length, sequence_length)。 在注意力 softmax 之后的注意力权重，用于计算自注意力头中的加权平均值。

示例：

代码语言：javascript复制
>>> from transformers import AutoTokenizer, FlaxBlenderbotSmallForConditionalGeneration

>>> model = FlaxBlenderbotSmallForConditionalGeneration.from_pretrained("facebook/blenderbot_small-90M")
>>> tokenizer = AutoTokenizer.from_pretrained("facebook/blenderbot_small-90M")

>>> text = "My friends are cool but they eat too many carbs."
>>> inputs = tokenizer(text, max_length=1024, return_tensors="np")
>>> encoder_outputs = model.encode(**inputs)
decode

< source >

代码语言：javascript复制
( decoder_input_ids encoder_outputs encoder_attention_mask: Optional = None decoder_attention_mask: Optional = None decoder_position_ids: Optional = None past_key_values: dict = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None deterministic: bool = True params: dict = None dropout_rng: PRNGKey = None ) → export const metadata = 'undefined';transformers.modeling_flax_outputs.FlaxCausalLMOutputWithCrossAttentions or tuple(torch.FloatTensor)

参数

  • decoder_input_ids (jnp.ndarray of shape (batch_size, target_sequence_length)) — 词汇表中解码器输入序列标记的索引。 可以使用 AutoTokenizer 获取索引。有关详细信息，请参阅 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。 什么是解码器输入 ID？ 对于翻译和摘要训练，应提供decoder_input_ids。如果未提供decoder_input_ids，模型将通过将input_ids向右移动来创建此张量，以便进行去噪预训练，遵循论文。
  • encoder_outputs (tuple(tuple(jnp.ndarray)) — 元组包括 (last_hidden_state, optional: hidden_states, optional: attentions) last_hidden_state 的形状为 (batch_size, sequence_length, hidden_size)，optional) 是编码器最后一层输出的隐藏状态序列。用于解码器的交叉注意力。
  • encoder_attention_mask (jnp.ndarray of shape (batch_size, sequence_length), optional) — 用于避免在填充标记索引上执行注意力的掩码。掩码值选择在 [0, 1] 之间：
    • 对于未被masked的标记为 1，
    • 对于被masked的标记为 0。

    什么是注意力掩码？

  • decoder_attention_mask (jnp.ndarray of shape (batch_size, target_sequence_length), optional) — 默认行为：生成一个张量，忽略decoder_input_ids中的填充标记。因果掩码也将默认使用。 如果要更改填充行为，应根据需要进行修改。有关默认策略的更多信息，请参阅 论文 中的图表 1。
  • decoder_position_ids (numpy.ndarray of shape (batch_size, sequence_length), optional) — 每个解码器输入序列标记在位置嵌入中的位置索引。在范围 [0, config.max_position_embeddings - 1] 中选择。
  • past_key_values (Dict[str, np.ndarray], optional, 由 init_cache 返回或传递先前的 past_key_values 时返回) — 预先计算的隐藏状态字典（注意力块中的键和值），可用于快速自回归解码。预先计算的键和值隐藏状态的形状为 [batch_size, max_length]。
  • output_attentions (bool, optional) — 是否返回所有注意力层的注意力张量。有关更多详细信息，请参阅返回的张量下的 attentions。
  • output_hidden_states (bool, optional) — 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回的张量下的 hidden_states。
  • return_dict (bool, optional) — 是否返回 ModelOutput 而不是普通元组。

返回

transformers.modeling_flax_outputs.FlaxCausalLMOutputWithCrossAttentions 或 tuple(torch.FloatTensor)

一个 transformers.modeling_flax_outputs.FlaxCausalLMOutputWithCrossAttentions 或一个 torch.FloatTensor 元组（如果传递了 return_dict=False 或当 config.return_dict=False 时）包含各种元素，具体取决于配置（<class 'transformers.models.blenderbot_small.configuration_blenderbot_small.BlenderbotSmallConfig'>）和输入。

  • logits (jnp.ndarray of shape (batch_size, sequence_length, config.vocab_size)) — 语言建模头的预测分数（SoftMax 之前每个词汇标记的分数）。
  • hidden_states（tuple(jnp.ndarray)，可选，当传递output_hidden_states=True或当config.output_hidden_states=True时返回） - 形状为(batch_size, sequence_length, hidden_size)的jnp.ndarray元组（一个用于嵌入输出，一个用于每一层的输出）。 模型在每一层输出的隐藏状态以及初始嵌入输出。
  • attentions（tuple(jnp.ndarray)，可选，当传递output_attentions=True或当config.output_attentions=True时返回） - 形状为(batch_size, num_heads, sequence_length, sequence_length)的jnp.ndarray元组（每层一个）。 注意力权重在注意力 softmax 之后，用于计算自注意力头中的加权平均值。
  • cross_attentions（tuple(jnp.ndarray)，可选，当传递output_attentions=True或当config.output_attentions=True时返回） - 形状为(batch_size, num_heads, sequence_length, sequence_length)的jnp.ndarray元组（每层一个）。 交叉注意力权重在注意力 softmax 之后，用于计算交叉注意力头中的加权平均值。
  • past_key_values（tuple(tuple(jnp.ndarray))，可选，当传递use_cache=True或当config.use_cache=True时返回） - 长度为config.n_layers的jnp.ndarray元组，每个元组包含自注意力和交叉注意力层的缓存键、值状态，如果模型用于编码器-解码器设置，则相关。仅在config.is_decoder = True时相关。 包含预先计算的隐藏状态（注意力块中的键和值），可用于加速顺序解码。

示例：

代码语言：javascript复制
>>> import jax.numpy as jnp
>>> from transformers import AutoTokenizer, FlaxBlenderbotSmallForConditionalGeneration

>>> model = FlaxBlenderbotSmallForConditionalGeneration.from_pretrained("facebook/blenderbot_small-90M")
>>> tokenizer = AutoTokenizer.from_pretrained("facebook/blenderbot_small-90M")

>>> text = "My friends are cool but they eat too many carbs."
>>> inputs = tokenizer(text, max_length=1024, return_tensors="np")
>>> encoder_outputs = model.encode(**inputs)

>>> decoder_start_token_id = model.config.decoder_start_token_id
>>> decoder_input_ids = jnp.ones((inputs.input_ids.shape[0], 1), dtype="i4") * decoder_start_token_id

>>> outputs = model.decode(decoder_input_ids, encoder_outputs)
>>> logits = outputs.logits

BLOOM

原文: huggingface.co/docs/transformers/v4.37.2/en/model_doc/bloom

概览

BLOOM 模型是通过 BigScience Workshop 提出的，通过其各种版本。BigScience 受到其他开放科学倡议的启发，研究人员共同投入时间和资源，以共同实现更高的影响力。BLOOM 的架构与 GPT3 基本相似（用于下一个令牌预测的自回归模型），但已在 46 种不同语言和 13 种编程语言上进行了训练。在相同数据集上训练了几个较小版本的模型。BLOOM 提供以下版本:

  • bloom-560m
  • bloom-1b1
  • bloom-1b7
  • bloom-3b
  • bloom-7b1
  • bloom (176B 参数)

资源

官方 Hugging Face 和社区资源（由

模型 配置 索引 hidden size

0 人点赞