Hugging Face 的 LOGO

Transformers 文档

Switch Transformers

Hugging Face's logo
加入 Hugging Face 社区

并获得增强的文档体验

开始使用

该模型于 2021-01-11 发布，并于 2022-11-15 添加到 Hugging Face Transformers。

PyTorch

Switch Transformers

Switch Transformers 是一个稀疏 T5 模型，其中 MLP 层被替换为专家混合（MoE）。路由机制将每个 token 与一个专家关联起来，而每个专家是一个密集 MLP。稀疏性使得模型能够更好地扩展，而路由机制允许模型即时选择相关权重，从而增加模型容量。

您可以在 Switch Transformer 集合下找到所有原始 Switch Transformers 检查点。

此模型由 ybelkada 和 ArthurZ 贡献。

点击右侧边栏的 Switch Transformers 模型，可查看更多关于如何将 Switch Transformers 应用于不同自然语言任务的示例。

下面的示例演示了如何使用 Pipeline、AutoModel 以及从命令行预测掩码 token。

流水线
自动模型
Transformers CLI
import torch
from transformers import pipeline

pipeline = pipeline(
    task="text2text-generation", 
    model="google/switch-base-8",
    dtype=torch.float16,
    device=0
)
print(pipeline("The capital of France is <extra_id_0>."))

量化通过以较低精度表示权重来减少大型模型的内存负担。有关更多可用量化后端，请参阅量化概述。

下面的示例使用 bitsandbytes 将权重量化为 8 位。

# pip install bitsandbytes
import torch
from transformers import AutoModelForSeq2SeqLM, AutoTokenizer, BitsAndBytesConfig

tokenizer = AutoTokenizer.from_pretrained("google/switch-base-8")
quantization_config = BitsAndBytesConfig(load_in_8bit=True)
model = AutoModelForSeq2SeqLM.from_pretrained("google/switch-base-8", device_map="auto", quantization_config=quantization_config)

input_text = "The capital of France is <extra_id_0>."
input_ids = tokenizer(input_text, return_tensors="pt").input_ids.to(0)

outputs = model.generate(input_ids)
print(tokenizer.decode(outputs[0]))

SwitchTransformersConfig

class transformers.SwitchTransformersConfig

< >

( vocab_size = 32128 d_model = 768 d_kv = 64 d_ff = 2048 expert_capacity = 64 num_layers = 12 num_sparse_encoder_layers = 3 num_decoder_layers = 12 num_sparse_decoder_layers = 3 num_heads = 12 num_experts = 8 router_bias = False router_jitter_noise = 0.01 router_dtype = 'float32' router_ignore_padding_tokens = False relative_attention_num_buckets = 32 relative_attention_max_distance = 128 dropout_rate = 0.1 layer_norm_epsilon = 1e-06 router_z_loss_coef = 0.001 router_aux_loss_coef = 0.001 initializer_factor = 1.0 dense_act_fn = 'relu' is_encoder_decoder = True add_router_probs = False use_cache = True pad_token_id = 0 eos_token_id = 1 bos_token_id = None tie_word_embeddings = True is_decoder = False add_cross_attention = False **kwargs )

参数

  • vocab_size (int, optional, defaults to 32128) — SwitchTransformers 模型的词汇表大小。定义调用 SwitchTransformersModel 时传入的 inputs_ids 可以表示的不同 token 的数量。
  • d_model (int, optional, defaults to 768) — 编码器层和池化层的尺寸。
  • d_kv (int, optional, defaults to 64) — 每个注意力头的键、查询、值投影的尺寸。d_kv 必须等于 d_model // num_heads。
  • d_ff (int, optional, defaults to 2048) — 每个 SwitchTransformersBlock 中间前馈层的尺寸。
  • expert_capacity (int, optional, defaults to 64) — 每个专家可以存储的 token 数量。如果设置为 1，模型将表现得像一个常规的 Transformer。
  • num_layers (int, optional, defaults to 12) — Transformer 编码器层中的密集隐藏层数量。
  • num_sparse_encoder_layers (int, optional, defaults to 3) — Transformer 编码器层中的稀疏（MoE）密集隐藏层数量。
  • num_decoder_layers (int, optional, defaults to 12) — Transformer 解码器中的隐藏层数量。如果未设置，则使用与 num_layers 相同的值。
  • num_sparse_decoder_layers (int, optional, defaults to 3) — Transformer 解码器层中的稀疏（MoE）密集隐藏层数量。
  • num_heads (int, optional, defaults to 12) — Transformer 编码器中每个注意力层的注意力头数量。
  • num_experts (int, optional, defaults to 8) — 每个 SwitchTransformer 层使用的专家数量。
  • router_bias (bool, optional, defaults to False) — 是否为路由器添加偏置。
  • router_jitter_noise (float, optional, defaults to 0.01) — 添加到路由器的噪声量。
  • router_dtype (str, optional, default to "float32") — 路由器使用的 dtype。根据 论文 中的选择性精度讨论，建议将 dtype 保留为 "float32"。
  • router_ignore_padding_tokens (bool, optional, defaults to False) — 是否在路由时忽略填充 token。
  • relative_attention_num_buckets (int, optional, defaults to 32) — 为每个注意力层使用的 bucket 数量。
  • relative_attention_max_distance (int, optional, defaults to 128) — bucket 分离的长序列的最大距离。
  • dropout_rate (float, optional, defaults to 0.1) — 所有 dropout 层的比率。
  • layer_norm_eps (float, optional, defaults to 1e-6) — 层归一化层使用的 epsilon。
  • router_z_loss_coef (float, optional, defaults to 0.001) — 总损失的 z 损失因子。
  • router_aux_loss_coef (float, optional, defaults to 0.001) — 总损失的 aux 损失因子。
  • initializer_factor (float, optional, defaults to 1.0) — 初始化所有权重矩阵的因子（应保留为 1，在初始化测试中内部使用）。
  • dense_act_fn (string, optional, defaults to "relu") — 要使用的前馈层类型。应为 "relu" 或 "gated-gelu" 之一。SwitchTransformersv1.1 使用 "gated-gelu" 前馈投影。原始 SwitchTransformers 使用 "relu"。
  • add_router_probs (bool, optional, defaults to False) — 是否输出路由器概率以计算路由器辅助损失。
  • use_cache (bool, optional, defaults to True) — 模型是否应返回最后的键/值注意力（并非所有模型都使用）。

这是用于存储 SwitchTransformersModel 配置的配置类。它用于根据指定的参数实例化一个 SwitchTransformers 模型，定义了模型的架构。使用默认值实例化配置将产生一个与 SwitchTransformers google/switch-base-8 架构相似的配置。

配置对象继承自 PreTrainedConfig，可用于控制模型输出。有关更多信息，请阅读 PreTrainedConfig 的文档。

SwitchTransformersTop1Router

class transformers.SwitchTransformersTop1Router

< >

( config: SwitchTransformersConfig )

使用 token 选择 top-1 专家分配的路由器。

此路由器使用与 Switch Transformer (https://huggingface.co/papers/2101.03961) 和 V-MoE (https://huggingface.co/papers/2106.05974) 相同的机制：token 选择它们的 top 专家。项目按 router_probs 排序，然后路由到它们的专家选择，直到达到专家的 expert_capacity。不能保证每个 token 都会被专家处理，也不能保证每个专家至少接收到一个 token。

forward

< >

( hidden_states: Tensor ) → router_probabilities (torch.Tensor)

参数

  • hidden_states (torch.Tensor) — 从中计算路由器概率的 (batch_size, sequence_length, hidden_dim)。

返回

router_probabilities (torch.Tensor)

形状为 (batch_size, sequence_length, num_experts) 的张量，表示每个 token 和专家的概率。用于将 token 路由到专家。router_logits (torch.Tensor)：形状为 (batch_size, sequence_length, num_experts) 的 logits 张量，表示原始路由器 logits。这稍后将用于计算路由器的 z-loss。

从输入的 hidden states 计算路由器概率。

SwitchTransformersSparseMLP

class transformers.SwitchTransformersSparseMLP

< >

( config: SwitchTransformersConfig )

forward

< >

( hidden_states: Tensor )

SwitchTransformersModel

class transformers.SwitchTransformersModel

< >

( config: SwitchTransformersConfig )

参数

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

最基础的 Switch Transformers 模型，输出原始 hidden-states，不带任何特定的顶部头。

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

此模型也是一个 PyTorch torch.nn.Module 子类。像普通的 PyTorch Module 一样使用它，并参考 PyTorch 文档了解一般用法和行为的所有相关信息。

forward

< >

( input_ids: torch.LongTensor | None = None attention_mask: torch.FloatTensor | None = None decoder_input_ids: torch.LongTensor | None = None decoder_attention_mask: torch.BoolTensor | None = None encoder_outputs: tuple[tuple[torch.FloatTensor]] | None = None past_key_values: transformers.cache_utils.Cache | None = None inputs_embeds: torch.Tensor | None = None decoder_inputs_embeds: torch.Tensor | None = None cache_position: torch.LongTensor | None = None **kwargs: typing_extensions.Unpack[transformers.utils.generic.TransformersKwargs] ) → transformers.modeling_outputs.Seq2SeqMoEModelOutput or tuple(torch.FloatTensor)

参数

  • input_ids (torch.LongTensor of shape (batch_size, sequence_length), optional) — 词汇表中输入序列 token 的索引。默认情况下会忽略填充。

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

    输入 ID 是什么？

  • attention_mask (torch.FloatTensor of shape (batch_size, sequence_length), optional) — 用于避免对填充 token 索引执行注意力的掩码。选择值在 [0, 1] 中：

    • 1 表示未掩码的 token，
    • 0 表示已掩码的 token。

    注意掩码是什么？

  • decoder_input_ids (torch.LongTensor of shape (batch_size, target_sequence_length), optional) — 解码器输入序列 token 在词汇表中的索引。

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

    解码器输入 ID 是什么？

  • decoder_attention_mask (torch.BoolTensor of shape (batch_size, target_sequence_length), optional) — 用于避免对某些 token 索引执行注意力的掩码。默认情况下，将使用因果掩码，以确保模型只能查看过去的输入以预测未来。
  • encoder_outputs (tuple, optional) — 元组包含 (last_hidden_state, optional: hidden_states, optional: attentions) 形状为 (batch_size, sequence_length, hidden_size) 的 last_hidden_state，optional）是编码器最后一层的输出 hidden-states 序列。用于解码器的交叉注意力。
  • past_key_values (~cache_utils.Cache, optional) — 预先计算的 hidden-states（自注意力块和交叉注意力块中的键和值），可用于加速顺序解码。这通常包括模型在解码的先前阶段返回的 past_key_values，当 use_cache=True 或 config.use_cache=True 时。

    只有 Cache 实例允许作为输入，请参阅我们的 kv 缓存指南。如果未传递 past_key_values，默认将初始化 DynamicCache。

    模型将输出与输入相同的缓存格式。

    如果使用 past_key_values，则用户需要仅输入未处理的 input_ids（其 past key value 状态未传递给此模型的那些），其形状为 (batch_size, unprocessed_length)，而不是所有 input_ids，其形状为 (batch_size, sequence_length)。

  • inputs_embeds (torch.Tensor, 形状为 (batch_size, sequence_length, hidden_size), 可选) — 可选地，您可以选择直接传入嵌入表示，而不是传入 input_ids。如果您希望对如何将 input_ids 索引转换为关联向量的控制程度超过模型内部的嵌入查找矩阵，这将非常有用。
  • decoder_inputs_embeds (torch.Tensor, 形状为 (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 的值。

  • cache_position (torch.LongTensor, 形状为 (sequence_length), 可选) — 指示输入序列 token 在序列中的位置的索引。与 position_ids 不同，此张量不受填充影响。它用于在正确的位置更新缓存并推断完整序列长度。

返回

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

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

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

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

  • past_key_values (EncoderDecoderCache, optional, 当传入 use_cache=True 或当 config.use_cache=True 时返回) — 这是一个 EncoderDecoderCache 实例。有关更多详细信息，请参阅我们的 kv 缓存指南。

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

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

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

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

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

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

    解码器的路由器 logits，用于计算混合专家模型的辅助损失。

  • cross_attentions (tuple(torch.FloatTensor), optional, returned when output_attentions=True is passed or when config.output_attentions=True) — Tuple of torch.FloatTensor (one for each layer) of shape (batch_size, num_heads, sequence_length, sequence_length).

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

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

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

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

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

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

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

    编码器的路由器 logits，用于计算稀疏模块的辅助损失和 z_loss。

transformers.SwitchTransformersModel 的 forward 方法，覆盖了 __call__ 特殊方法。

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

SwitchTransformersForConditionalGeneration

class transformers.SwitchTransformersForConditionalGeneration

< >

( config: SwitchTransformersConfig )

参数

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

在顶部带有 language modeling 头部的 SWITCH_TRANSFORMERS 模型。

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

此模型也是一个 PyTorch torch.nn.Module 子类。像普通的 PyTorch Module 一样使用它，并参考 PyTorch 文档了解一般用法和行为的所有相关信息。

forward

< >

( input_ids: torch.LongTensor | None = None attention_mask: torch.FloatTensor | None = None decoder_input_ids: torch.LongTensor | None = None decoder_attention_mask: torch.BoolTensor | None = None encoder_outputs: tuple[tuple[torch.Tensor]] | None = None past_key_values: transformers.cache_utils.Cache | None = None inputs_embeds: torch.FloatTensor | None = None decoder_inputs_embeds: torch.FloatTensor | None = None labels: torch.LongTensor | None = None output_router_logits: bool | None = False cache_position: torch.LongTensor | None = None **kwargs: typing_extensions.Unpack[transformers.utils.generic.TransformersKwargs] ) → transformers.modeling_outputs.Seq2SeqMoEOutput 或 tuple(torch.FloatTensor)

参数

  • input_ids (torch.LongTensor, 形状为 (batch_size, sequence_length), 可选) — 词汇表中输入序列 token 的索引。默认情况下会忽略填充。

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

    什么是输入 ID？

  • attention_mask (torch.FloatTensor, 形状为 (batch_size, sequence_length), 可选) — 用于避免对填充 token 索引执行 attention 的掩码。掩码值选择在 [0, 1] 中：

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

    什么是 attention 掩码？

  • decoder_input_ids (torch.LongTensor, 形状为 (batch_size, target_sequence_length), 可选) — 词汇表中解码器输入序列 token 的索引。

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

    什么是解码器输入 ID？

  • decoder_attention_mask (torch.BoolTensor, 形状为 (batch_size, target_sequence_length), 可选) — 用于避免对某些 token 索引执行 attention 的掩码。默认情况下，将使用因果掩码，以确保模型只能查看之前的输入来预测未来。
  • encoder_outputs (tuple, 可选) — 元组包含（last_hidden_state, 可选: hidden_states, 可选: attentions）last_hidden_state，形状为 (batch_size, sequence_length, hidden_size), 可选）是编码器最后一层的输出隐藏状态序列。在解码器的交叉 attention 中使用。
  • past_key_values (~cache_utils.Cache, 可选) — 预先计算的隐藏状态（自 attention 块和交叉 attention 块中的 key 和 value），可用于加速顺序解码。这通常包括当 use_cache=True 或 config.use_cache=True 时，模型在先前解码阶段返回的 past_key_values。

    只有 Cache 实例被允许作为输入，请参阅我们的 kv cache 指南。如果未传入 past_key_values，默认将初始化 DynamicCache。

    模型将输出与输入相同的缓存格式。

    如果使用了 past_key_values，用户需要只传入未处理的 input_ids（即其 past key value 状态未传递给此模型的那些），形状为 (batch_size, unprocessed_length)，而不是所有 input_ids，其形状为 (batch_size, sequence_length)。

  • inputs_embeds (torch.Tensor, 形状为 (batch_size, sequence_length, hidden_size), 可选) — 可选地，您可以选择直接传入嵌入表示，而不是传入 input_ids。如果您希望对如何将 input_ids 索引转换为关联向量的控制程度超过模型内部的嵌入查找矩阵，这将非常有用。
  • decoder_inputs_embeds (torch.Tensor, 形状为 (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 的值。

  • labels (torch.LongTensor, 形状为 (batch_size, sequence_length), 可选) — 用于计算掩码语言模型损失的标签。索引应在 [0, ..., config.vocab_size] 或 -100 范围内（参见 input_ids 文档字符串）。索引设置为 -100 的 token 将被忽略（掩码），损失仅为标签在 [0, ..., config.vocab_size] 范围内的 token 计算。
  • output_router_logits (bool, 可选, 默认为 False) — 是否返回所有路由器的 logits。它们对于计算路由器损失很有用，在推理期间不应返回。
  • cache_position (torch.LongTensor, 形状为 (sequence_length), 可选) — 指示输入序列 token 在序列中的位置的索引。与 position_ids 不同，此张量不受填充影响。它用于在正确的位置更新缓存并推断完整序列长度。

返回

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

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

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

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

  • past_key_values (EncoderDecoderCache, optional, 当传入 use_cache=True 或当 config.use_cache=True 时返回) — 这是一个 EncoderDecoderCache 实例。有关更多详细信息，请参阅我们的 kv 缓存指南。

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

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

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

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

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

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

    解码器的路由器 logits，用于计算混合专家模型的辅助损失。

  • cross_attentions (tuple(torch.FloatTensor), optional, returned when output_attentions=True is passed or when config.output_attentions=True) — Tuple of torch.FloatTensor (one for each layer) of shape (batch_size, num_heads, sequence_length, sequence_length).

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

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

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

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

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

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

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

    编码器的路由器 logits，用于计算混合专家模型的辅助损失和 z_loss。

transformers.SwitchTransformersForConditionalGeneration 的 forward 方法，覆盖了 __call__ 特殊方法。

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

SwitchTransformersEncoderModel

class transformers.SwitchTransformersEncoderModel

< >

( config: SwitchTransformersConfig )

forward

< >

( input_ids: torch.LongTensor | None = None attention_mask: torch.FloatTensor | None = None inputs_embeds: torch.FloatTensor | None = None use_cache: bool | None = None **kwargs: typing_extensions.Unpack[transformers.utils.generic.TransformersKwargs] ) → transformers.modeling_outputs.MoEModelOutput 或 tuple(torch.FloatTensor)

参数

  • input_ids (torch.LongTensor, 形状为 (batch_size, sequence_length), 可选) — 词汇表中输入序列 token 的索引。默认情况下会忽略填充。

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

    什么是输入 ID？

  • attention_mask (torch.FloatTensor of shape (batch_size, sequence_length), optional) — Mask to avoid performing attention on padding token indices. Mask values selected in [0, 1]:

    • 1 for tokens that are not masked,
    • 0 for tokens that are masked.

    What are attention masks?

  • inputs_embeds (torch.FloatTensor of shape (batch_size, sequence_length, hidden_size), optional) — Optionally, instead of passing input_ids you can choose to directly pass an embedded representation. This is useful if you want more control over how to convert input_ids indices into associated vectors than the model’s internal embedding lookup matrix.
  • use_cache (bool, optional) — If set to True, past_key_values key value states are returned and can be used to speed up decoding (see past_key_values).

返回

transformers.modeling_outputs.MoEModelOutput or tuple(torch.FloatTensor)

A transformers.modeling_outputs.MoEModelOutput or a tuple of torch.FloatTensor (if return_dict=False is passed or when config.return_dict=False) comprising various elements depending on the configuration (None) and inputs.

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

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

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

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

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

  • router_probs (tuple(torch.FloatTensor), optional, returned when output_router_probs=True and config.add_router_probs=True is passed or when config.output_router_probs=True) — Tuple of torch.FloatTensor (one for each layer) of shape (batch_size, sequence_length, num_experts).

    Raw router probabilities that are computed by MoE routers, these terms are used to compute the auxiliary loss and the z_loss for Mixture of Experts models.

The SwitchTransformersEncoderModel forward method, overrides the __call__ special method.

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

在 GitHub 上更新

←Starcoder2 T5→
© . This site is unofficial and not affiliated with Hugging Face, Inc.