Transformers 4.37 中文文档（十九）（8）-阿里云开发者社区

Transformers 4.37 中文文档（十九）（7）https://developer.aliyun.com/article/1564928

ZeRO-3 和 Infinity 细微差别

ZeRO-3 与 ZeRO-2 非常不同，因为它具有参数分片功能。

ZeRO-Infinity 进一步扩展了 ZeRO-3，以支持 NVMe 内存和多项其他速度和可伸缩性改进。

尽管我们已经尽力使事情能够正常工作，而无需对您的模型进行任何特殊更改，但在某些情况下，您可能会发现需要以下信息。

构建大型模型

DeepSpeed/ZeRO-3 可以处理具有数万亿参数的模型，这些参数可能无法适应现有的 RAM。在这种情况下，但也如果您希望初始化速度更快，请使用*deepspeed.zero.Init()*上下文管理器（也是函数装饰器）初始化模型，如下所示：

from transformers import T5ForConditionalGeneration, T5Config
import deepspeed
with deepspeed.zero.Init():
    config = T5Config.from_pretrained("t5-small")
    model = T5ForConditionalGeneration(config)

正如您所看到的，这为您提供了一个随机初始化的模型。

如果要使用预训练模型，只要is_deepspeed_zero3_enabled()返回True，model_class.from_pretrained将激活此功能，当前情况下，这是由 TrainingArguments 对象设置的，如果传递的 DeepSpeed 配置文件包含 ZeRO-3 配置部分。因此，您必须在调用from_pretrained之前创建 TrainingArguments 对象之前。以下是可能的顺序示例：

from transformers import AutoModel, Trainer, TrainingArguments
training_args = TrainingArguments(..., deepspeed=ds_config)
model = AutoModel.from_pretrained("t5-small")
trainer = Trainer(model=model, args=training_args, ...)

如果您正在使用官方示例脚本，并且您的命令行参数包括--deepspeed ds_config.json并启用了 ZeRO-3 配置，则一切都已经为您完成，因为示例脚本是这样编写的。

注意：如果模型的 fp16 权重无法适应单个 GPU 的内存，则必须使用此功能。

有关此方法和其他相关功能的详细信息，请参阅构建大型模型。

此外，当加载 fp16 预训练模型时，您将希望告诉from_pretrained使用torch_dtype=torch.float16。有关详细信息，请参见 from_pretrained-torch-dtype。

收集参数

在多个 GPU 上的 ZeRO-3 中，除了当前执行层的参数外，没有单个 GPU 拥有所有参数。因此，如果您需要一次访问所有层的所有参数，有一种特定的方法可以做到。您很可能不需要它，但如果需要，请参阅收集参数。

然而，我们在几个地方内部使用它，一个例子是在from_pretrained中加载预训练模型权重时。我们一次加载一层，然后立即将其分区到所有参与的 GPU 上，因为对于非常大的模型，将其加载到一个 GPU 上然后分散到多个 GPU 上是不可能的，由于内存限制。

此外，在 ZeRO-3 下，如果您编写自己的代码并遇到看起来像模型参数权重的问题：

tensor([1.0], device="cuda:0", dtype=torch.float16, requires_grad=True)

强调tensor([1.])，或者如果出现错误，指出参数大小为1，而不是某个更大的多维形状，这意味着参数被分区，您看到的是 ZeRO-3 占位符。

ZeRO 推理

ZeRO 推理使用与 ZeRO-3 训练相同的配置。您只需要不需要优化器和调度程序部分。实际上，如果要与训练共享相同的配置文件，可以将这些部分保留在配置文件中。它们将被忽略。

否则，您只需要传递通常的 TrainingArguments 参数。例如：

deepspeed --num_gpus=2 your_program.py <normal cl args> --do_eval --deepspeed ds_config.json

唯一重要的是您需要使用 ZeRO-3 配置，因为 ZeRO-2 对推理没有任何好处，因为只有 ZeRO-3 执行参数分片，而 ZeRO-1 执行梯度和优化器状态的分片。

以下是在使用所有可用 GPU 部署 DeepSpeed 时运行run_translation.py的示例：

deepspeed examples/pytorch/translation/run_translation.py \
--deepspeed tests/deepspeed/ds_config_zero3.json \
--model_name_or_path t5-small --output_dir output_dir \
--do_eval --max_eval_samples 50 --warmup_steps 50  \
--max_source_length 128 --val_max_target_length 128 \
--overwrite_output_dir --per_device_eval_batch_size 4 \
--predict_with_generate --dataset_config "ro-en" --fp16 \
--source_lang en --target_lang ro --dataset_name wmt16 \
--source_prefix "translate English to Romanian: "

由于在推理中不需要额外大内存用于优化器状态和梯度，您应该能够在相同的硬件上适应更大的批次和/或序列长度。

此外，DeepSpeed 目前正在开发一个名为 Deepspeed-Inference 的相关产品，它与 ZeRO 技术没有关系，而是使用张量并行性来扩展无法适应单个 GPU 的模型。这是一个正在进行的工作，一旦该产品完成，我们将提供集成。

内存要求

由于 Deepspeed ZeRO 可以将内存卸载到 CPU（和 NVMe），该框架提供了一些实用程序，允许您根据使用的 GPU 数量告诉需要多少 CPU 和 GPU 内存。

让我们估计在单个 GPU 上对“bigscience/T0_3B”进行微调所需的内存：

$ python -c 'from transformers import AutoModel; \
from deepspeed.runtime.zero.stage3 import estimate_zero3_model_states_mem_needs_all_live; \
model = AutoModel.from_pretrained("bigscience/T0_3B"); \
estimate_zero3_model_states_mem_needs_all_live(model, num_gpus_per_node=1, num_nodes=1)'
[...]
Estimated memory needed for params, optim states and gradients for a:
HW: Setup with 1 node, 1 GPU per node.
SW: Model with 2783M total params, 65M largest layer params.
  per CPU  |  per GPU |   Options
   70.00GB |   0.25GB | offload_param=cpu , offload_optimizer=cpu , zero_init=1
   70.00GB |   0.25GB | offload_param=cpu , offload_optimizer=cpu , zero_init=0
   62.23GB |   5.43GB | offload_param=none, offload_optimizer=cpu , zero_init=1
   62.23GB |   5.43GB | offload_param=none, offload_optimizer=cpu , zero_init=0
    0.37GB |  46.91GB | offload_param=none, offload_optimizer=none, zero_init=1
   15.56GB |  46.91GB | offload_param=none, offload_optimizer=none, zero_init=0

因此，您可以将其放在单个 80GB GPU 上，不使用 CPU 卸载，或者使用一个小型的 8GB GPU，但是需要大约 60GB 的 CPU 内存。请记住，这只是参数、优化器状态和梯度的内存 - 您将需要更多内存用于 cuda 内核、激活和临时存储。

然后就是成本与速度的权衡。购买/租用较小的 GPU（或较少的 GPU，因为您可以使用 Deepspeed ZeRO 来使用多个 GPU）。但这样会更慢，所以即使您不关心某件事情会多快完成，减速也会直接影响使用 GPU 的持续时间，从而增加成本。因此，请进行实验并比较哪种方法最好。

如果您有足够的 GPU 内存，请确保禁用 CPU/NVMe 卸载，因为这将使一切更快。

例如，让我们重复使用 2 个 GPU：

$ python -c 'from transformers import AutoModel; \
from deepspeed.runtime.zero.stage3 import estimate_zero3_model_states_mem_needs_all_live; \
model = AutoModel.from_pretrained("bigscience/T0_3B"); \
estimate_zero3_model_states_mem_needs_all_live(model, num_gpus_per_node=2, num_nodes=1)'
[...]
Estimated memory needed for params, optim states and gradients for a:
HW: Setup with 1 node, 2 GPUs per node.
SW: Model with 2783M total params, 65M largest layer params.
  per CPU  |  per GPU |   Options
   70.00GB |   0.25GB | offload_param=cpu , offload_optimizer=cpu , zero_init=1
   70.00GB |   0.25GB | offload_param=cpu , offload_optimizer=cpu , zero_init=0
   62.23GB |   2.84GB | offload_param=none, offload_optimizer=cpu , zero_init=1
   62.23GB |   2.84GB | offload_param=none, offload_optimizer=cpu , zero_init=0
    0.74GB |  23.58GB | offload_param=none, offload_optimizer=none, zero_init=1
   31.11GB |  23.58GB | offload_param=none, offload_optimizer=none, zero_init=0

因此，您可能需要 2 个 32GB 或更高内存的 GPU，而不需要将内存卸载到 CPU。

有关完整信息，请参阅memory estimators。

提交问题

以下是如何提交问题，以便我们可以快速找到问题的根源并帮助您解除工作阻塞。

在您的报告中，请始终包括：

在报告中提供完整的 Deepspeed 配置文件
如果您使用的是 Trainer 的命令行参数，或者如果您自己编写了 Trainer 设置，则使用 TrainingArguments 参数。请不要转储 TrainingArguments，因为它有数十个与问题无关的条目。
输出：

python -c 'import torch; print(f"torch: {torch.__version__}")'
python -c 'import transformers; print(f"transformers: {transformers.__version__}")'
python -c 'import deepspeed; print(f"deepspeed: {deepspeed.__version__}")'

如果可能的话，请包含一个链接到一个 Google Colab 笔记本，我们可以用它来重现问题。您可以使用这个notebook作为起点。
除非不可能，请始终使用我们可以使用的标准数据集，而不是自定义数据集。
如果可能，请尝试使用现有的examples之一来重现问题。

需要考虑的事项：

Deepspeed 通常不是问题的原因。
一些提交的问题被证明与 Deepspeed 无关。也就是说，一旦从设置中移除了 Deepspeed，问题仍然存在。
因此，如果不是绝对明显是 Deepspeed 相关的问题，例如您可以看到有异常并且可以看到涉及 Deepspeed 模块，首先在没有 Deepspeed 的设置中重新测试您的设置。只有在问题仍然存在时才提到 Deepspeed 并提供所有必要的细节。
如果您明确知道问题出在 DeepSpeed 核心而不是集成部分，请直接向Deepspeed 提交问题。如果您不确定，请不要担心，任何一个问题跟踪器都可以，我们会在您发布后找出问题，并在需要时将您重定向到另一个问题跟踪器。

故障排除

深度速度进程在启动时被终止，没有回溯

如果deepspeed进程在启动时被终止，没有回溯，通常意味着程序尝试分配比您的系统具有的 CPU 内存更多的内存，或者您的进程被允许分配的内存，而操作系统内核终止了该进程。这是因为您的配置文件很可能已经配置了offload_optimizer或offload_param或两者都配置为转移到cpu。如果您有 NVMe，尝试将其转移到 NVMe，如果您正在运行 ZeRO-3。这是如何估算特定模型所需内存量的方法。

训练和/或评估/预测损失为 NaN

当一个以 bf16 混合精度模式预训练的模型尝试在 fp16 下使用时，通常会发生这种情况（无论是否使用混合精度）。大多数在 TPU 上训练的模型，通常是由 Google 发布的模型都属于这一类（例如，几乎所有基于 t5 的模型）。在这种情况下，解决方案是要么使用 fp32，要么使用 bf16，如果您的硬件支持的话（TPU、Ampere GPU 或更新）。

另一个问题可能与使用 fp16 有关。当您配置此部分时：

{
    "fp16": {
        "enabled": "auto",
        "loss_scale": 0,
        "loss_scale_window": 1000,
        "initial_scale_power": 16,
        "hysteresis": 2,
        "min_loss_scale": 1
    }
}

并且您在日志中看到 Deepspeed 报告OVERFLOW!如下：

0%|                                                                                                                             | 0/189 [00:00<?, ?it/s]
 [deepscale] OVERFLOW! Rank 0 Skipping step. Attempted loss scale: 262144, reducing to 262144
  1%|▌                                                                                                                    | 1/189 [00:00<01:26,  2.17it/s]
 [deepscale] OVERFLOW! Rank 0 Skipping step. Attempted loss scale: 262144, reducing to 131072.0
  1%|█▏
 [...]
 [deepscale] OVERFLOW! Rank 0 Skipping step. Attempted loss scale: 1, reducing to 1
 14%|████████████████▌                                                                                                   | 27/189 [00:14<01:13,  2.21it/s]
 [deepscale] OVERFLOW! Rank 0 Skipping step. Attempted loss scale: 1, reducing to 1
 15%|█████████████████▏                                                                                                  | 28/189 [00:14<01:13,  2.18it/s]
 [deepscale] OVERFLOW! Rank 0 Skipping step. Attempted loss scale: 1, reducing to 1
 15%|█████████████████▊                                                                                                  | 29/189 [00:15<01:13,  2.18it/s]
 [deepscale] OVERFLOW! Rank 0 Skipping step. Attempted loss scale: 1, reducing to 1
[...]

这意味着 Deepspeed 损失缩放器无法找到一个缩放系数来克服损失溢出。

（此处的日志已经过处理，以便更易阅读。）

在这种情况下，通常需要提高initial_scale_power的值。将其设置为"initial_scale_power": 32通常会解决问题。

注

虽然 DeepSpeed 有一个可通过 pip 安装的 PyPI 软件包，但强烈建议从源安装，以最好地匹配您的硬件，并且如果您需要启用某些功能，比如 1 比特 Adam，在 pypi 分发中是不可用的。
您不必使用 Trainer 来使用🤗 Transformers 的 DeepSpeed - 您可以使用任何模型与您自己的训练器，并且您将根据DeepSpeed 集成说明来调整后者。

非 Trainer Deepspeed 集成

HfDeepSpeedConfig 用于将 Deepspeed 集成到🤗 Transformers 核心功能中，当未使用 Trainer 时。它唯一要做的就是处理 Deepspeed ZeRO-3 参数收集，并在from_pretrained调用期间自动将模型分割到多个 GPU 上。其他所有事情都需要您自己来做。

使用 Trainer 时，一切都会自动处理。

当不使用 Trainer 时，为了有效部署 DeepSpeed ZeRO-3，您必须在实例化模型之前实例化 HfDeepSpeedConfig 对象，并保持该对象处于活动状态。

如果您正在使用 Deepspeed ZeRO-1 或 ZeRO-2，则根本不需要使用HfDeepSpeedConfig。

例如，对于预训练模型：

from transformers.integrations import HfDeepSpeedConfig
from transformers import AutoModel
import deepspeed
ds_config = {...}  # deepspeed config object or path to the file
# must run before instantiating the model to detect zero 3
dschf = HfDeepSpeedConfig(ds_config)  # keep this object alive
model = AutoModel.from_pretrained("gpt2")
engine = deepspeed.initialize(model=model, config_params=ds_config, ...)

或对于非预训练模型：

from transformers.integrations import HfDeepSpeedConfig
from transformers import AutoModel, AutoConfig
import deepspeed
ds_config = {...}  # deepspeed config object or path to the file
# must run before instantiating the model to detect zero 3
dschf = HfDeepSpeedConfig(ds_config)  # keep this object alive
config = AutoConfig.from_pretrained("gpt2")
model = AutoModel.from_config(config)
engine = deepspeed.initialize(model=model, config_params=ds_config, ...)

请注意，如果您没有使用 Trainer 集成，您将完全独立。基本上遵循Deepspeed网站上的文档。此外，您必须明确配置配置文件 - 不能使用"auto"值，而必须使用实际值。

HfDeepSpeedConfig

`class transformers.integrations.HfDeepSpeedConfig`

<来源>

( config_file_or_dict )

参数

config_file_or_dict（Union[str, Dict]）— DeepSpeed 配置文件或字典的路径。

此对象包含一个 DeepSpeed 配置字典，可以快速查询诸如零阶段之类的内容。

此对象的weakref存储在模块的全局变量中，以便能够从 Trainer 对象不可用的区域访问配置（例如from_pretrained和_get_resized_embeddings）。因此，在程序仍在运行时，这个对象保持活动是很重要的。

Trainer 使用HfTrainerDeepSpeedConfig子类。该子类具有将配置与 TrainingArguments 的值同步的逻辑，通过替换特殊占位符值："auto"。如果没有这种特殊逻辑，DeepSpeed 配置将不会以任何方式修改。

自定义 DeepSpeed ZeRO 推理

以下是一个示例，演示如何在无法将模型放入单个 GPU 的情况下进行 DeepSpeed ZeRO 推理，而不使用 Trainer。解决方案包括使用额外的 GPU 和/或将 GPU 内存转移到 CPU 内存。

这里需要理解的重要细微差别是，ZeRO 的设计方式使您可以并行处理不同 GPU 上的不同输入。

示例有大量注释并且是自我记录的。

确保：

如果您有足够的 GPU 内存，请禁用 CPU 卸载（因为它会减慢速度）
如果您拥有 Ampere 或更新的 GPU，请启用 bf16 以加快速度。如果您没有该硬件，可以启用 fp16，只要不使用在 bf16 混合精度（例如大多数 t5 模型）中预训练的模型。这些通常在 fp16 中溢出，您将看到垃圾输出。

#!/usr/bin/env python
# This script demonstrates how to use Deepspeed ZeRO in an inference mode when one can't fit a model
# into a single GPU
#
# 1\. Use 1 GPU with CPU offload
# 2\. Or use multiple GPUs instead
#
# First you need to install deepspeed: pip install deepspeed
#
# Here we use a 3B "bigscience/T0_3B" model which needs about 15GB GPU RAM - so 1 largish or 2
# small GPUs can handle it. or 1 small GPU and a lot of CPU memory.
#
# To use a larger model like "bigscience/T0" which needs about 50GB, unless you have an 80GB GPU -
# you will need 2-4 gpus. And then you can adapt the script to handle more gpus if you want to
# process multiple inputs at once.
#
# The provided deepspeed config also activates CPU memory offloading, so chances are that if you
# have a lot of available CPU memory and you don't mind a slowdown you should be able to load a
# model that doesn't normally fit into a single GPU. If you have enough GPU memory the program will
# run faster if you don't want offload to CPU - so disable that section then.
#
# To deploy on 1 gpu:
#
# deepspeed --num_gpus 1 t0.py
# or:
# python -m torch.distributed.run --nproc_per_node=1 t0.py
#
# To deploy on 2 gpus:
#
# deepspeed --num_gpus 2 t0.py
# or:
# python -m torch.distributed.run --nproc_per_node=2 t0.py
from transformers import AutoTokenizer, AutoConfig, AutoModelForSeq2SeqLM
from transformers.integrations import HfDeepSpeedConfig
import deepspeed
import os
import torch
os.environ["TOKENIZERS_PARALLELISM"] = "false"  # To avoid warnings about parallelism in tokenizers
# distributed setup
local_rank = int(os.getenv("LOCAL_RANK", "0"))
world_size = int(os.getenv("WORLD_SIZE", "1"))
torch.cuda.set_device(local_rank)
deepspeed.init_distributed()
model_name = "bigscience/T0_3B"
config = AutoConfig.from_pretrained(model_name)
model_hidden_size = config.d_model
# batch size has to be divisible by world_size, but can be bigger than world_size
train_batch_size = 1 * world_size
# ds_config notes
#
# - enable bf16 if you use Ampere or higher GPU - this will run in mixed precision and will be
# faster.
#
# - for older GPUs you can enable fp16, but it'll only work for non-bf16 pretrained models - e.g.
# all official t5 models are bf16-pretrained
#
# - set offload_param.device to "none" or completely remove the `offload_param` section if you don't
# - want CPU offload
#
# - if using `offload_param` you can manually finetune stage3_param_persistence_threshold to control
# - which params should remain on gpus - the larger the value the smaller the offload size
#
# For indepth info on Deepspeed config see
# https://huggingface.co/docs/transformers/main/main_classes/deepspeed
# keeping the same format as json for consistency, except it uses lower case for true/false
# fmt: off
ds_config = {
    "fp16": {
        "enabled": False
    },
    "bf16": {
        "enabled": False
    },
    "zero_optimization": {
        "stage": 3,
        "offload_param": {
            "device": "cpu",
            "pin_memory": True
        },
        "overlap_comm": True,
        "contiguous_gradients": True,
        "reduce_bucket_size": model_hidden_size * model_hidden_size,
        "stage3_prefetch_bucket_size": 0.9 * model_hidden_size * model_hidden_size,
        "stage3_param_persistence_threshold": 10 * model_hidden_size
    },
    "steps_per_print": 2000,
    "train_batch_size": train_batch_size,
    "train_micro_batch_size_per_gpu": 1,
    "wall_clock_breakdown": False
}
# fmt: on
# next line instructs transformers to partition the model directly over multiple gpus using
# deepspeed.zero.Init when model's `from_pretrained` method is called.
#
# **it has to be run before loading the model AutoModelForSeq2SeqLM.from_pretrained(model_name)**
#
# otherwise the model will first be loaded normally and only partitioned at forward time which is
# less efficient and when there is little CPU RAM may fail
dschf = HfDeepSpeedConfig(ds_config)  # keep this object alive
# now a model can be loaded.
model = AutoModelForSeq2SeqLM.from_pretrained(model_name)
# initialise Deepspeed ZeRO and store only the engine object
ds_engine = deepspeed.initialize(model=model, config_params=ds_config)[0]
ds_engine.module.eval()  # inference
# Deepspeed ZeRO can process unrelated inputs on each GPU. So for 2 gpus you process 2 inputs at once.
# If you use more GPUs adjust for more.
# And of course if you have just one input to process you then need to pass the same string to both gpus
# If you use only one GPU, then you will have only rank 0.
rank = torch.distributed.get_rank()
if rank == 0:
    text_in = "Is this review positive or negative? Review: this is the best cast iron skillet you will ever buy"
elif rank == 1:
    text_in = "Is this review positive or negative? Review: this is the worst restaurant ever"
tokenizer = AutoTokenizer.from_pretrained(model_name)
inputs = tokenizer.encode(text_in, return_tensors="pt").to(device=local_rank)
with torch.no_grad():
    outputs = ds_engine.module.generate(inputs, synced_gpus=True)
text_out = tokenizer.decode(outputs[0], skip_special_tokens=True)
print(f"rank{rank}:\n   in={text_in}\n  out={text_out}")

让我们将其保存为t0.py并运行：

$ deepspeed --num_gpus 2 t0.py
rank0:
   in=Is this review positive or negative? Review: this is the best cast iron skillet you will ever buy
  out=Positive
rank1:
   in=Is this review positive or negative? Review: this is the worst restaurant ever
  out=negative

这是一个非常基本的示例，您将希望根据自己的需求进行调整。

生成细微差别

使用多个 GPU 与 ZeRO Stage-3 一起使用时，必须通过调用generate(..., synced_gpus=True)来同步 GPU。如果不这样做，如果一个 GPU 在其他 GPU 之前完成生成，整个系统将挂起，因为其他 GPU 将无法接收停止生成的 GPU 的权重片段。

从transformers>=4.28开始，如果未明确指定synced_gpus，则在检测到这些条件时，它将自动设置为True。但是，如果需要，仍然可以覆盖synced_gpus的值。

测试 Deepspeed 集成

如果您提交涉及 DeepSpeed 集成的 PR，请注意我们的 CircleCI PR CI 设置没有 GPU，因此我们只在另一个 CI 每晚运行需要 GPU 的测试。因此，如果您在 PR 中收到绿色 CI 报告，这并不意味着 DeepSpeed 测试通过。

要运行 DeepSpeed 测试，请至少运行：

RUN_SLOW=1 pytest tests/deepspeed/test_deepspeed.py

如果更改了建模或 pytorch 示例代码中的任何内容，则还要运行模型动物园测试。以下将运行所有 DeepSpeed 测试：

RUN_SLOW=1 pytest tests/deepspeed

主 DeepSpeed 资源

论文：

最后，请记住，HuggingFace Trainer 只集成了 DeepSpeed，因此如果您在使用 DeepSpeed 方面遇到任何问题或疑问，请在 DeepSpeed GitHub 上提交问题。

Transformers 4.37 中文文档（十九）（8）