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

原文：huggingface.co/docs/transformers

MegatronGPT2

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

概述

MegatronGPT2 模型是由 Mohammad Shoeybi、Mostofa Patwary、Raul Puri、Patrick LeGresley、Jared Casper 和 Bryan Catanzaro 在使用模型并行训练多十亿参数语言模型的 Megatron-LM中提出的。

论文摘要如下：

最近在语言建模方面的工作表明，训练大型 Transformer  模型可以推动自然语言处理应用的最新技术。然而，非常大的模型可能由于内存限制而难以训练。在这项工作中，我们提出了训练非常大的  Transformer 模型的技术，并实现了一种简单高效的层内模型并行方法，使得可以训练具有数十亿参数的 Transformer  模型。我们的方法不需要新的编译器或库更改，与管道模型并行性正交且互补，并且可以通过在原生 PyTorch  中插入几个通信操作来完全实现。我们通过使用 512 个 GPU 收敛基于 Transformer 的模型，达到了 83 亿参数。与维持 39  TeraFLOPs 的强单 GPU 基线相比，我们在整个应用程序中保持了 15.1 PetaFLOPs，其扩展效率为 76%，这是峰值  FLOPs 的 30%。为了证明大型语言模型可以进一步推动最新技术（SOTA），我们训练了一个 83 亿参数的 Transformer  语言模型，类似于 GPT-2，以及一个 39 亿参数的类似 BERT 的模型。我们展示了在 BERT  类似模型中对层归一化的放置要特别注意，这对于随着模型规模增长而实现性能提升至关重要。使用 GPT-2 模型，我们在  WikiText103（10.8，与 15.8 的 SOTA 困惑度相比）和 LAMBADA（66.5%，与 63.2%的 SOTA  准确率相比）数据集上取得了 SOTA 结果。我们的 BERT 模型在 RACE 数据集上取得了 SOTA 结果（90.9%，与 89.4%的  SOTA 准确率相比）。

这个模型是由jdemouth贡献的。原始代码可以在这里找到。该存储库包含了 Megatron 语言模型的多 GPU 和多节点实现。特别是，它包含了使用“张量并行”和“管道并行”技术的混合模型并行方法。

使用提示

我们提供了预训练的GPT2-345M检查点，用于评估或微调下游任务。

要访问这些检查点，首先注册并设置 NVIDIA GPU 云（NGC）注册表 CLI。有关下载模型的更多文档，请参阅NGC 文档。

或者，您可以直接下载检查点：

wget --content-disposition https://api.ngc.nvidia.com/v2/models/nvidia/megatron_lm_345m/versions/v0.0/zip -O
megatron_gpt2_345m_v0_0.zip

一旦您从 NVIDIA GPU 云（NGC）获得了检查点，您需要将其转换为 Hugging Face Transformers GPT2 实现可以轻松加载的格式。

以下命令允许您进行转换。我们假设文件夹models/megatron_gpt2包含megatron_gpt2_345m_v0_0.zip，并且该命令是从该文件夹运行的：

python3 $PATH_TO_TRANSFORMERS/models/megatron_gpt2/convert_megatron_gpt2_checkpoint.py megatron_gpt2_345m_v0_0.zip

MegatronGPT2 架构与 OpenAI GPT-2 相同。有关配置类和其参数的信息，请参考 GPT-2 文档。

Mistral

原始文本：huggingface.co/docs/transformers/v4.37.2/en/model_doc/mistral

概述

Mistral-7B-v0.1 是 Mistral AI 的第一个大型语言模型（LLM）。

模型详情

Mistral-7B-v0.1 是基于解码器的 LM，具有以下架构选择：

• 滑动窗口注意力- 训练时使用 8k 上下文长度和固定缓存大小，理论上的注意力跨度为 128K 个标记
  
• GQA（Grouped Query Attention）- 允许更快的推理和更小的缓存大小。
  
• 字节回退 BPE 分词器- 确保字符永远不会映射到词汇表之外的标记。
  

我们还提供了一个经过指导微调的模型：Mistral-7B-Instruct-v0.1，可用于基于聊天的推理。

有关更多详细信息，请阅读我们的发布博客文章

许可证

Mistral-7B-v0.1和Mistral-7B-Instruct-v0.1均采用 Apache 2.0 许可证。

使用提示

Mistral-7B-v0.1和Mistral-7B-Instruct-v0.1可以在Huggingface Hub上找到

这些准备好使用的检查点可以通过 HuggingFace Hub 下载并使用：

>>> from transformers import AutoModelForCausalLM, AutoTokenizer
>>> device = "cuda" # the device to load the model onto
>>> model = AutoModelForCausalLM.from_pretrained("mistralai/Mistral-7B-v0.1")
>>> tokenizer = AutoTokenizer.from_pretrained("mistralai/Mistral-7B-v0.1")
>>> prompt = "My favourite condiment is"
>>> model_inputs = tokenizer([prompt], return_tensors="pt").to(device)
>>> model.to(device)
>>> generated_ids = model.generate(**model_inputs, max_new_tokens=100, do_sample=True)
>>> tokenizer.batch_decode(generated_ids)[0]
"The expected output"

Mistral-7B-v0.1和Mistral-7B-Instruct-v0.1的原始权重可以从以下网址下载：

要在 HuggingFace 中使用这些原始检查点，您可以使用convert_mistral_weights_to_hf.py脚本将它们转换为 HuggingFace 格式：

python src/transformers/models/mistral/convert_mistral_weights_to_hf.py \
    --input_dir /path/to/downloaded/mistral/weights --model_size 7B --output_dir /output/path

然后，您可以从output/path加载转换后的模型：

from transformers import MistralForCausalLM, LlamaTokenizer
tokenizer = LlamaTokenizer.from_pretrained("/output/path")
model = MistralForCausalLM.from_pretrained("/output/path")

结合 Mistral 和 Flash Attention 2

首先，请确保安装最新版本的 Flash Attention 2 以包含滑动窗口注意力功能。

pip install -U flash-attn --no-build-isolation

还要确保您拥有与 Flash-Attention 2 兼容的硬件。在flash-attn存储库的官方文档中了解更多信息。还要确保以半精度（例如torch.float16）加载您的模型。

要加载和运行使用 Flash Attention 2 的模型，请参考下面的代码片段：

>>> import torch
>>> from transformers import AutoModelForCausalLM, AutoTokenizer
>>> device = "cuda" # the device to load the model onto
>>> model = AutoModelForCausalLM.from_pretrained("mistralai/Mistral-7B-v0.1", torch_dtype=torch.float16, attn_implementation="flash_attention_2")
>>> tokenizer = AutoTokenizer.from_pretrained("mistralai/Mistral-7B-v0.1")
>>> prompt = "My favourite condiment is"
>>> model_inputs = tokenizer([prompt], return_tensors="pt").to(device)
>>> model.to(device)
>>> generated_ids = model.generate(**model_inputs, max_new_tokens=100, do_sample=True)
>>> tokenizer.batch_decode(generated_ids)[0]
"The expected output"

预期的加速

下面是一个预期的加速图，比较了在 transformers 中使用mistralai/Mistral-7B-v0.1检查点和模型的 Flash Attention 2 版本之间的纯推理时间。

滑动窗口注意力

当前实现支持滑动窗口注意力机制和内存高效的缓存管理。要启用滑动窗口注意力，请确保具有与滑动窗口注意力兼容的flash-attn版本（>=2.3.0）。

Flash Attention-2 模型还使用了更高效的内存缓存切片机制-根据 Mistral 模型的官方实现建议，使用滚动缓存机制，我们保持缓存大小固定（self.config.sliding_window），仅支持padding_side="left"的批量生成，并使用当前标记的绝对位置来计算位置嵌入。

Mistral 团队

Albert Jiang，Alexandre Sablayrolles，Arthur Mensch，Chris  Bamford，Devendra Singh Chaplot，Diego de las Casas，Florian  Bressand，Gianna Lengyel，Guillaume Lample，Lélio Renard Lavaud，Lucile  Saulnier，Marie-Anne Lachaux，Pierre Stock，Teven Le Scao，Thibaut  Lavril，Thomas Wang，Timothée Lacroix，William El Sayed。

MistralConfig

class transformers.MistralConfig

<来源>

( vocab_size = 32000 hidden_size = 4096 intermediate_size = 14336 num_hidden_layers = 32 num_attention_heads = 32 num_key_value_heads = 8 hidden_act = 'silu' max_position_embeddings = 131072 initializer_range = 0.02 rms_norm_eps = 1e-06 use_cache = True pad_token_id = None bos_token_id = 1 eos_token_id = 2 tie_word_embeddings = False rope_theta = 10000.0 sliding_window = 4096 attention_dropout = 0.0 **kwargs )

参数

• vocab_size (int, optional, 默认为 32000) — Mistral 模型的词汇量。定义了在调用 MistralModel 时可以由inputs_ids表示的不同标记数量。
  
• hidden_size (int, optional, 默认为 4096) — 隐藏表示的维度。
  
• intermediate_size (int, optional, 默认为 14336) — MLP 表示的维度。
  
• num_hidden_layers (int, optional, 默认为 32) — Transformer 编码器中的隐藏层数。
  
• num_attention_heads (int, optional, 默认为 32) — Transformer 编码器中每个注意力层的注意力头数。
  
• num_key_value_heads (int, optional, 默认为 8) — 这是应该用于实现分组查询注意力的 key_value 头数。如果num_key_value_heads=num_attention_heads，模型将使用多头注意力（MHA），如果num_key_value_heads=1，模型将使用多查询注意力（MQA），否则使用 GQA。将多头检查点转换为 GQA 检查点时，应通过对该组中所有原始头部进行均值池化来构建每个组键和值头。有关更多详细信息，请查看此论文。如果未指定，将默认为8。
  
• hidden_act (str 或 function, optional, 默认为"silu") — 解码器中的非线性激活函数（函数或字符串）。
  
• max_position_embeddings (int, optional, 默认为4096*32) — 该模型可能被使用的最大序列长度。Mistral 的滑动窗口注意力允许最多 4096*32 个标记的序列。
  
• initializer_range (float, optional, 默认为 0.02) — 用于初始化所有权重矩阵的截断正态初始化器的标准差。
  
• rms_norm_eps (float, optional, 默认为 1e-06) — rms 归一化层使用的 epsilon。
  
• use_cache (bool, optional, 默认为True) — 模型是否应返回最后的键/值注意力（并非所有模型都使用）。仅在config.is_decoder=True时相关。
  
• pad_token_id (int, optional) — 填充标记的 id。
  
• bos_token_id (int, optional, 默认为 1) — “序列开始”标记的 id。
  
• eos_token_id (int, optional, 默认为 2) — “序列结束”标记的 id。
  
• tie_word_embeddings (bool, optional, 默认为False) — 模型的输入和输出词嵌入是否应该被绑定。
  
• rope_theta (float, optional, 默认为 10000.0) — RoPE 嵌入的基本周期。
  
• sliding_window (int, optional, 默认为 4096) — 滑动窗口注意力窗口大小。如果未指定，将默认为4096。
  
• attention_dropout (float, optional, 默认为 0.0) — 注意力概率的 dropout 比率。
  

这是用于存储 MistralModel 配置的配置类。它用于根据指定的参数实例化 Mistral 模型，定义模型架构。使用默认值实例化配置将产生类似于 Mistral-7B-v0.1 或 Mistral-7B-Instruct-v0.1 的配置。

mistralai/Mistral-7B-v0.1 mistralai/Mistral-7B-Instruct-v0.1

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

>>> from transformers import MistralModel, MistralConfig
>>> # Initializing a Mistral 7B style configuration
>>> configuration = MistralConfig()
>>> # Initializing a model from the Mistral 7B style configuration
>>> model = MistralModel(configuration)
>>> # Accessing the model configuration
>>> configuration = model.config

MistralModel

class transformers.MistralModel

<来源>

( config: MistralConfig )

参数

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

裸露的 Mistral 模型输出原始的隐藏状态，没有特定的头部。这个模型继承自 PreTrainedModel。检查超类文档以获取库为其所有模型实现的通用方法（如下载或保存，调整输入嵌入，修剪头等）。

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

由config.num_hidden_layers层组成的 Transformer 解码器。每一层都是一个MistralDecoderLayer。

forward

<来源>

( input_ids: LongTensor = None attention_mask: Optional = None position_ids: Optional = None past_key_values: Optional = None inputs_embeds: Optional = None use_cache: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None )

参数

• 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，
  
• 对于被屏蔽的标记为 0。
  

• 注意力掩码是什么？
  可以使用 AutoTokenizer 获取索引。有关详细信息，请参阅 PreTrainedTokenizer.encode()和 PreTrainedTokenizer.call()。
  如果使用past_key_values，则可选择仅输入最后的decoder_input_ids（请参阅past_key_values）。
  如果要更改填充行为，应阅读modeling_opt._prepare_decoder_attention_mask并根据需要进行修改。有关默认策略的更多信息，请参阅论文中的图表 1。
  

• 1 表示头部未被屏蔽，
  
• 0 表示头部被屏蔽。
  

• position_ids（形状为(batch_size, sequence_length)的torch.LongTensor，可选）- 每个输入序列标记在位置嵌入中的位置索引。选择范围为[0, config.n_positions - 1]。
  位置 ID 是什么？
  
• past_key_values（Cache或tuple(tuple(torch.FloatTensor))，可选）- 预先计算的隐藏状态（自注意力块和交叉注意力块中的键和值），可用于加速顺序解码。这通常包括模型在先前解码阶段返回的past_key_values，当use_cache=True或config.use_cache=True时。允许两种格式：

• 一个 Cache 实例；
  
• 长度为config.n_layers的元组的元组（每个元组有 2 个形状为(batch_size, num_heads, sequence_length, embed_size_per_head)的张量）。这也被称为传统的缓存格式。
  

• 模型将输出与输入相同的缓存格式。如果没有传递past_key_values，则将返回传统的缓存格式。
  如果使用了past_key_values，用户可以选择仅输入最后的input_ids（即那些没有将它们的过去键值状态提供给此模型的）的形状为(batch_size, 1)的张量，而不是形状为(batch_size, sequence_length)的所有input_ids。
  
• inputs_embeds（形状为(batch_size, sequence_length, hidden_size)的torch.FloatTensor，可选）- 可选地，您可以选择直接传递嵌入表示，而不是传递input_ids。如果您想要更多控制如何将input_ids索引转换为相关向量，这将非常有用，而不是使用模型的内部嵌入查找矩阵。
  
• use_cache（bool，可选）- 如果设置为True，将返回past_key_values键值状态，并可用于加速解码（参见past_key_values）。
  
• output_attentions（bool，可选）- 是否返回所有注意力层的注意力张量。有关更多详细信息，请参阅返回张量下的attentions。
  
• output_hidden_states（bool，可选）- 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回张量下的hidden_states。
  
• return_dict（bool，可选）- 是否返回一个 ModelOutput 而不是一个普通的元组。
  

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

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

MistralForCausalLM

class transformers.MistralForCausalLM

<来源>

( config )

forward

<来源>

( input_ids: LongTensor = None attention_mask: Optional = None position_ids: 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.CausalLMOutputWithPast 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，
  
• 对于被屏蔽的标记，为 0。
  

• 注意力掩码是什么？
  可以使用 AutoTokenizer 获取索引。有关详细信息，请参阅 PreTrainedTokenizer.encode()和 PreTrainedTokenizer.call()。
  如果使用了past_key_values，可以选择仅输入最后的decoder_input_ids（参见past_key_values）。
  如果您想要更改填充行为，您应该阅读modeling_opt._prepare_decoder_attention_mask并根据您的需求进行修改。有关默认策略的更多信息，请参见论文中的图表 1。
  

• 1 表示头部是not masked，
  
• 0 表示头部是masked。
  

• position_ids（形状为(batch_size, sequence_length)的torch.LongTensor，可选）— 每个输入序列标记在位置嵌入中的位置索引。在范围[0, config.n_positions - 1]中选择。
  什么是位置 ID？
  
• past_key_values（Cache或tuple(tuple(torch.FloatTensor))，可选）— 预先计算的隐藏状态（自注意力块和交叉注意力块中的键和值），可用于加速顺序解码。这通常包括模型在先前解码阶段返回的past_key_values，当use_cache=True或config.use_cache=True时。允许两种格式：

• 一个 Cache 实例；
  
• 长度为config.n_layers的tuple(torch.FloatTensor)的元组，每个元组有 2 个形状为(batch_size, num_heads, sequence_length, embed_size_per_head)的张量。这也被称为传统缓存格式。
  

• 模型将输出与输入相同的缓存格式。如果没有传递past_key_values，则将返回传统的缓存格式。
  如果使用past_key_values，用户可以选择仅输入形状为(batch_size, 1)的最后一个input_ids（那些没有将其过去的键值状态提供给此模型的输入）而不是形状为(batch_size, sequence_length)的所有input_ids。
  
• inputs_embeds（形状为(batch_size, sequence_length, hidden_size)的torch.FloatTensor，可选）— 可选地，您可以选择直接传递嵌入表示而不是传递input_ids。如果您希望更多地控制如何将input_ids索引转换为相关向量，而不是模型的内部嵌入查找矩阵，则这很有用。
  
• use_cache（bool，可选）— 如果设置为True，将返回past_key_values键值状态，并可用于加速解码（参见past_key_values）。
  
• output_attentions（bool，可选）— 是否返回所有注意力层的注意力张量。有关更多详细信息，请参见返回张量下的attentions。
  
• output_hidden_states（bool，可选）— 是否返回所有层的隐藏状态。有关更多详细信息，请参见返回张量下的hidden_states。
  
• return_dict（bool，可选）— 是否返回 ModelOutput 而不是普通元组。
  参数 — 标签（形状为(batch_size, sequence_length)的torch.LongTensor，可选）：用于计算掩码语言建模损失的标签。索引应该在[0, ..., config.vocab_size]或-100（参见input_ids文档字符串）。将索引设置为-100的标记将被忽略（掩码），损失仅计算具有标签在[0, ..., config.vocab_size]中的标记。
  

返回

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

一个 transformers.modeling_outputs.CausalLMOutputWithPast 或一个torch.FloatTensor的元组（如果传递了return_dict=False或config.return_dict=False，或者取决于配置（MistralConfig）和输入）。

• loss（形状为(1,)的torch.FloatTensor，可选，当提供labels时返回）— 语言建模损失（用于下一个标记预测）。
  
• logits (torch.FloatTensor，形状为(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(torch.FloatTensor)元组，每个元组有两个形状为(batch_size, num_heads, sequence_length, embed_size_per_head)的张量。
  包含预先计算的隐藏状态（自注意力块中的键和值），可用于加速顺序解码（查看past_key_values输入）。
  
• hidden_states (tuple(torch.FloatTensor), optional, 当传递output_hidden_states=True或config.output_hidden_states=True时返回) — 形状为(batch_size, sequence_length, hidden_size)的torch.FloatTensor元组。
  模型在每一层的输出的隐藏状态以及可选的初始嵌入输出。
  
• attentions (tuple(torch.FloatTensor), optional, 当传递output_attentions=True或config.output_attentions=True时返回) — 形状为(batch_size, num_heads, sequence_length, sequence_length)的torch.FloatTensor元组（每层一个）。
  自注意力头中的注意力权重经过注意力 softmax 后，用于计算自注意力头中的加权平均值。
  

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

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

示例：

>>> from transformers import AutoTokenizer, MistralForCausalLM
>>> model = MistralForCausalLM.from_pretrained("mistralai/Mistral-7B-v0.1")
>>> tokenizer = AutoTokenizer.from_pretrained("mistralai/Mistral-7B-v0.1")
>>> prompt = "Hey, are you conscious? Can you talk to me?"
>>> inputs = tokenizer(prompt, return_tensors="pt")
>>> # Generate
>>> generate_ids = model.generate(inputs.input_ids, max_length=30)
>>> tokenizer.batch_decode(generate_ids, skip_special_tokens=True, clean_up_tokenization_spaces=False)[0]
"Hey, are you conscious? Can you talk to me?\nI'm not conscious, but I can talk to you."

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