Accelerate documentation

DeepSpeed

You are viewing main version, which requires installation from source. If you'd like regular pip install, checkout the latest stable version (v1.15.0).
Hugging Face's logo
Join the Hugging Face community

and get access to the augmented documentation experience

to get started

DeepSpeed

DeepSpeed implementa todo lo descrito en el artículo de ZeRO. Algunas de las optimizaciones más destacadas son:

  1. Particionamiento del estado del optimizador (ZeRO stage 1)
  2. Partición de gradientes (ZeRO etapa 2)
  3. Particionamiento de parámetros (ZeRO stage 3)
  4. Gestión personalizada del entrenamiento con precisión mixta
  5. Una variedad de optimizadores rápidos basados en extensiones de CUDA
  6. ZeRO-Offload a CPU y disco/NVMe
  7. Particionamiento jerárquico de los parámetros del modelo (ZeRO++)

ZeRO-Offload tiene su propio artículo dedicado: ZeRO-Offload: Democratizing Billion-Scale Model Training. Y el soporte para NVMe se describe en el artículo ZeRO-Infinity: Breaking the GPU Memory Wall for Extreme Scale Deep Learning.

DeepSpeed ZeRO-2 se utiliza principalmente solo para entrenamiento, ya que sus características no son útiles para la inferencia.

DeepSpeed ZeRO-3 también se puede usar para inferencia, ya que permite cargar modelos enormes en varias GPU, algo que no sería posible en una sola GPU.

Accelerate integra DeepSpeed mediante 2 opciones:

  1. Integración de las funciones de DeepSpeed mediante la especificación de un deepspeed config file en accelerate config. Solo debe proporcionar su archivo de configuración personalizado o usar nuestra plantilla. La mayor parte de este documento se centra en esta función. Esto admite todas las funciones principales de DeepSpeed y ofrece al usuario mucha flexibilidad. Es posible que el usuario tenga que cambiar algunas líneas de código dependiendo de la configuración.
  2. Integración a través de deepspeed_plugin. Esto admite un subconjunto de las funciones de DeepSpeed y utiliza opciones predeterminadas para el resto de las configuraciones. El usuario no necesita cambiar ningún código y es adecuado para quienes están de acuerdo con la mayoría de los ajustes predeterminados de DeepSpeed.

¿Qué está integrado?

Entrenamiento:

  1. Accelerate integra todas las funciones de DeepSpeed ZeRO. Esto incluye todas las etapas de ZeRO 1, 2 y 3, así como ZeRO-Offload, ZeRO-Infinity (que puede descargar a disco/NVMe) y ZeRO++. A continuación se muestra una breve descripción de la Paralelización de Datos usando ZeRO - Zero Redundancy Optimizer, junto con un diagrama de esta publicación de blog ZeRO Data Parallelism

(Fuente: enlace)

a. Etapa 1: Fragmenta los estados del optimizador entre los trabajadores/GPUs de paralelismo de datos

b. Etapa 2: Fragmenta los estados del optimizador y los gradientes entre los trabajadores/GPUs paralelos de datos

c. Etapa 3: Fragmenta los estados del optimizador + gradientes + parámetros del modelo entre los trabajadores/GPUs de paralelismo de datos

d. Optimizer Offload: Descarga los gradientes + estados del optimizador a CPU/Disco, construyendo sobre la base de ZERO Stage 2

e. Param Offload: Descarga los parámetros del modelo a CPU/disco, construyendo sobre la base de ZERO Stage 3

f. Particionamiento jerárquico: Permite un entrenamiento eficiente en varios nodos mediante entrenamiento paralelo de datos entre nodos y particionamiento ZeRO-3 dentro de un nodo, construido sobre ZeRO Stage 3.

Note: With respect to Disk Offload, the disk should be an NVME for decent speed but it technically works on any Disk

Inferencia:

  1. DeepSpeed ZeRO Inference admite la etapa 3 de ZeRO con ZeRO-Infinity. Utiliza el mismo protocolo ZeRO que el entrenamiento, pero no emplea un optimizador ni un programador de tasa de aprendizaje, y solo la etapa 3 es relevante. Para más detalles, consulte: ZeRO Inference.

¿Cómo funciona?

Prerrequisitos: Instale la versión >=0.6.5 de DeepSpeed. Consulte los detalles de la instalación de DeepSpeed para obtener más información.

Primero veremos la integración fácil de usar mediante accelerate config. A continuación, la integración más flexible y con más funciones mediante el deepspeed config file.

Plugin de DeepSpeed de Accelerate

En su(s) máquina(s), simplemente ejecute:

accelerate config

y responder a las preguntas que se formulen. Te preguntará si deseas usar un archivo de configuración para DeepSpeed, a lo que debes responder que no. A continuación, responde a las siguientes preguntas para generar una configuración básica de DeepSpeed. Esto generará un archivo de configuración que se usará automáticamente para establecer correctamente las opciones predeterminadas al realizar

accelerate launch my_script.py --args_to_my_script

Por ejemplo, así es como ejecutarías el ejemplo de NLP examples/nlp_example.py (desde la raíz del repositorio) con DeepSpeed Plugin:

Ejemplo del plugin de DeepSpeed para ZeRO Stage-2

compute_environment: LOCAL_MACHINE
deepspeed_config:
 gradient_accumulation_steps: 1
 gradient_clipping: 1.0
 offload_optimizer_device: none
 offload_param_device: none
 zero3_init_flag: true
 zero_stage: 2
distributed_type: DEEPSPEED
fsdp_config: {}
machine_rank: 0
main_process_ip: null
main_process_port: null
main_training_function: main
mixed_precision: fp16
num_machines: 1
num_processes: 2
use_cpu: false
accelerate launch examples/nlp_example.py --mixed_precision fp16

Ejemplo del plugin de DeepSpeed para ZeRO Stage-3 con CPU Offload

compute_environment: LOCAL_MACHINE
deepspeed_config:
  gradient_accumulation_steps: 1
  gradient_clipping: 1.0
  offload_optimizer_device: cpu
  offload_param_device: cpu
  zero3_init_flag: true
  zero3_save_16bit_model: true
  zero_stage: 3
distributed_type: DEEPSPEED
fsdp_config: {}
machine_rank: 0
main_process_ip: null
main_process_port: null
main_training_function: main
mixed_precision: fp16
num_machines: 1
num_processes: 2
use_cpu: false
accelerate launch examples/nlp_example.py --mixed_precision fp16

Actualmente, Accelerate admite la siguiente configuración a través de la CLI:

`zero_stage`: [0] Disabled, [1] optimizer state partitioning, [2] optimizer+gradient state partitioning and [3] optimizer+gradient+parameter partitioning
`gradient_accumulation_steps`: Number of training steps to accumulate gradients before averaging and applying them.
`gradient_clipping`: Enable gradient clipping with value.
`offload_optimizer_device`: [none] Disable optimizer offloading, [cpu] offload optimizer to CPU, [nvme] offload optimizer to NVMe SSD. Only applicable with ZeRO >= Stage-2.
`offload_optimizer_nvme_path`: Decides Nvme Path to offload optimizer states. If unspecified, will default to 'none'.
`offload_param_device`: [none] Disable parameter offloading, [cpu] offload parameters to CPU, [nvme] offload parameters to NVMe SSD. Only applicable with ZeRO Stage-3.
`offload_param_nvme_path`: Decides Nvme Path to offload parameters. If unspecified, will default to 'none'.
`zero3_init_flag`: Decides whether to enable `deepspeed.zero.Init` for constructing massive models. Only applicable with ZeRO Stage-3.
`zero3_save_16bit_model`: Decides whether to save 16-bit model weights when using ZeRO Stage-3.
`mixed_precision`: `no` for FP32 training, `fp16` for FP16 mixed-precision training and `bf16` for BF16 mixed-precision training.
`deepspeed_moe_layer_cls_names`: Comma-separated list of transformer Mixture-of-Experts (MoE) layer class names (case-sensitive) to wrap ,e.g, `MixtralSparseMoeBlock`, `Qwen2MoeSparseMoeBlock`, `JetMoEAttention,JetMoEBlock` ...
`deepspeed_hostfile`: DeepSpeed hostfile for configuring multi-node compute resources.
`deepspeed_exclusion_filter`: DeepSpeed exclusion filter string when using mutli-node setup.
`deepspeed_inclusion_filter`: DeepSpeed inclusion filter string when using mutli-node setup.
`deepspeed_multinode_launcher`: DeepSpeed multi-node launcher to use, e.g. `pdsh`, `standard`, `openmpi`, `mvapich`, `mpich`, `slurm`, `nossh` (requires DeepSpeed >= 0.14.5). If unspecified, will default to `pdsh`.
`deepspeed_config_file`: path to the DeepSpeed config file in `json` format. See the next section for more details on this.

Para poder ajustar más opciones, necesitará usar un archivo de configuración de DeepSpeed.

Archivo de configuración de DeepSpeed

En su(s) máquina(s), simplemente ejecute:

accelerate config

y responder a las preguntas que se formulen. Te preguntará si deseas usar un archivo de configuración de deepspeed, a lo que debes responder que sí y proporcionar la ruta al archivo de configuración de deepspeed. Esto generará un archivo de configuración que se usará automáticamente para establecer correctamente las opciones predeterminadas al realizar

accelerate launch my_script.py --args_to_my_script

Por ejemplo, así es como se ejecutaría el ejemplo de NLP examples/by_feature/deepspeed_with_config_support.py (desde la raíz del repositorio) con un archivo de configuración de DeepSpeed:

Ejemplo de archivo de configuración de DeepSpeed para ZeRO Stage-2

compute_environment: LOCAL_MACHINE
deepspeed_config:
 deepspeed_config_file: /home/ubuntu/accelerate/examples/deepspeed_config_templates/zero_stage2_config.json
 zero3_init_flag: true
distributed_type: DEEPSPEED
fsdp_config: {}
machine_rank: 0
main_process_ip: null
main_process_port: null
main_training_function: main
mixed_precision: fp16
num_machines: 1
num_processes: 2
use_cpu: false

con el contenido de zero_stage2_config.json siendo:

{
    "fp16": {
        "enabled": true,
        "loss_scale": 0,
        "loss_scale_window": 1000,
        "initial_scale_power": 16,
        "hysteresis": 2,
        "min_loss_scale": 1
    },
    "optimizer": {
        "type": "AdamW",
        "params": {
            "lr": "auto",
            "weight_decay": "auto",
            "torch_adam": true,
            "adam_w_mode": true
        }
    },
    "scheduler": {
        "type": "WarmupDecayLR",
        "params": {
            "warmup_min_lr": "auto",
            "warmup_max_lr": "auto",
            "warmup_num_steps": "auto",
            "total_num_steps": "auto"
        }
    },
    "zero_optimization": {
        "stage": 2,
        "allgather_partitions": true,
        "allgather_bucket_size": 2e8,
        "overlap_comm": true,
        "reduce_scatter": true,
        "reduce_bucket_size": "auto",
        "contiguous_gradients": true
    },
    "gradient_accumulation_steps": 1,
    "gradient_clipping": "auto",
    "steps_per_print": 2000,
    "train_batch_size": "auto",
    "train_micro_batch_size_per_gpu": "auto",
    "wall_clock_breakdown": false
}
accelerate launch examples/by_feature/deepspeed_with_config_support.py \
--config_name "gpt2-large" \
--tokenizer_name "gpt2-large" \
--dataset_name "wikitext" \
--dataset_config_name "wikitext-2-raw-v1" \
--block_size 128 \
--output_dir "./clm/clm_deepspeed_stage2_accelerate" \
--learning_rate 5e-4 \
--per_device_train_batch_size 24 \
--per_device_eval_batch_size 24 \
--num_train_epochs 3 \
--with_tracking \
--report_to "wandb"\

Ejemplo de archivo de configuración de DeepSpeed para ZeRO Stage-3 con offload a CPU

compute_environment: LOCAL_MACHINE
deepspeed_config:
 deepspeed_config_file: /home/ubuntu/accelerate/examples/deepspeed_config_templates/zero_stage3_offload_config.json
 zero3_init_flag: true
distributed_type: DEEPSPEED
fsdp_config: {}
machine_rank: 0
main_process_ip: null
main_process_port: null
main_training_function: main
mixed_precision: fp16
num_machines: 1
num_processes: 2
use_cpu: false

con el contenido de zero_stage3_offload_config.json siendo:

{
    "fp16": {
        "enabled": true,
        "loss_scale": 0,
        "loss_scale_window": 1000,
        "initial_scale_power": 16,
        "hysteresis": 2,
        "min_loss_scale": 1
    },
    "optimizer": {
        "type": "AdamW",
        "params": {
            "lr": "auto",
            "weight_decay": "auto"
        }
    },
    "scheduler": {
        "type": "WarmupDecayLR",
        "params": {
            "warmup_min_lr": "auto",
            "warmup_max_lr": "auto",
            "warmup_num_steps": "auto",
            "total_num_steps": "auto"
        }
    },
    "zero_optimization": {
        "stage": 3,
        "offload_optimizer": {
            "device": "cpu",
            "pin_memory": true
        },
        "offload_param": {
            "device": "cpu",
            "pin_memory": true
        },
        "overlap_comm": true,
        "contiguous_gradients": true,
        "reduce_bucket_size": "auto",
        "stage3_prefetch_bucket_size": "auto",
        "stage3_param_persistence_threshold": "auto",
        "sub_group_size": 1e9,
        "stage3_max_live_parameters": 1e9,
        "stage3_max_reuse_distance": 1e9,
        "stage3_gather_16bit_weights_on_model_save": "auto"
    },
    "gradient_accumulation_steps": 1,
    "gradient_clipping": "auto",
    "steps_per_print": 2000,
    "train_batch_size": "auto",
    "train_micro_batch_size_per_gpu": "auto",
    "wall_clock_breakdown": false
}
accelerate launch examples/by_feature/deepspeed_with_config_support.py \
--config_name "gpt2-large" \
--tokenizer_name "gpt2-large" \
--dataset_name "wikitext" \
--dataset_config_name "wikitext-2-raw-v1" \
--block_size 128 \
--output_dir "./clm/clm_deepspeed_stage3_offload_accelerate" \
--learning_rate 5e-4 \
--per_device_train_batch_size 32 \
--per_device_eval_batch_size 32 \
--num_train_epochs 3 \
--with_tracking \
--report_to "wandb"\

Ejemplo de configuración de ZeRO++ Puedes usar las funciones de ZeRO++ mediante los parámetros de configuración adecuados. Ten en cuenta que ZeRO++ es una extensión de ZeRO Stage 3. A continuación se muestra cómo se puede modificar el archivo de configuración, según el tutorial de ZeRO++ de DeepSpeed:

{
    "zero_optimization": {
        "stage": 3,
        "reduce_bucket_size": "auto",

        "zero_quantized_weights": true,
        "zero_hpz_partition_size": 8,
        "zero_quantized_gradients": true,

        "contiguous_gradients": true,
        "overlap_comm": true
    }
}

Para la partición jerárquica, el tamaño de partición zero_hpz_partition_size debería establecerse idealmente en el número de GPUs por nodo. (Por ejemplo, el archivo de configuración anterior asume 8 GPUs por nodo)

Cambios importantes en el código al usar un archivo de configuración de DeepSpeed

  1. Optimizadores y programadores de DeepSpeed. Para obtener más información sobre estos, consulte la documentación de Optimizadores de DeepSpeed y Programadores de DeepSpeed. A continuación, veremos los cambios necesarios en el código al utilizarlos.

    a. DS Optim + DS Scheduler: el caso en el que las claves optimizer y scheduler están presentes en el archivo de configuración de DeepSpeed. En esta situación, se utilizarán esas claves y el usuario debe emplear accelerate.utils.DummyOptim y accelerate.utils.DummyScheduler para reemplazar los optimizadores y programadores de PyTorch/personalizados en su código. A continuación se muestra un fragmento de examples/by_feature/deepspeed_with_config_support.py que ilustra esto:

     # Creates Dummy Optimizer if `optimizer` was specified in the config file else creates Adam Optimizer
     optimizer_cls = (
         torch.optim.AdamW
         if accelerator.state.deepspeed_plugin is None
         or "optimizer" not in accelerator.state.deepspeed_plugin.deepspeed_config
         else DummyOptim
     )
     optimizer = optimizer_cls(optimizer_grouped_parameters, lr=args.learning_rate)
    
     # Creates Dummy Scheduler if `scheduler` was specified in the config file else creates `args.lr_scheduler_type` Scheduler
     if (
         accelerator.state.deepspeed_plugin is None
         or "scheduler" not in accelerator.state.deepspeed_plugin.deepspeed_config
     ):
         lr_scheduler = get_scheduler(
             name=args.lr_scheduler_type,
             optimizer=optimizer,
             num_warmup_steps=args.num_warmup_steps,
             num_training_steps=args.max_train_steps,
         )
     else:
         lr_scheduler = DummyScheduler(
             optimizer, total_num_steps=args.max_train_steps, warmup_num_steps=args.num_warmup_steps
         )

    b. Optimizador personalizado + programador personalizado: el caso en el que las claves optimizer y scheduler están ausentes en el archivo de configuración de DeepSpeed. En esta situación, no se necesitan cambios de código por parte del usuario y este es el caso al usar la integración a través del DeepSpeed Plugin. En el ejemplo anterior podemos ver que el código permanece sin cambios si las claves optimizer y scheduler están ausentes en el archivo de configuración de DeepSpeed.

    c. Optim personalizado + programador de DS: el caso en el que solo está presente la clave scheduler en el archivo de configuración de DeepSpeed. En esta situación, el usuario debe usar accelerate.utils.DummyScheduler para reemplazar el programador de PyTorch/personalizado en su código.

    d. DS Optim + Programador personalizado: el caso en el que solo está presente la clave optimizer en el archivo de configuración de DeepSpeed. Esto provocará un error, ya que solo se puede usar DS Scheduler cuando se usa DS Optim.

  2. Observe los valores auto en los archivos de configuración de DeepSpeed del ejemplo anterior. Estos se manejan automáticamente mediante el método prepare en función del modelo, los dataloaders, el optimizador ficticio y los programadores ficticios proporcionados al método prepare. Solo los campos auto especificados en los ejemplos anteriores son manejados por el método prepare y el resto deben ser especificados explícitamente por el usuario.

Los valores auto se calculan de la siguiente manera:

  • reduce_bucket_size: hidden_size * hidden_size
  • stage3_prefetch_bucket_size: int(0.9 * hidden_size * hidden_size)
  • stage3_param_persistence_threshold: 10 * hidden_size

Para que la función auto funcione con estas 3 entradas de configuración, Accelerate utilizará model.config.hidden_size o max(model.config.hidden_sizes) como hidden_size. Si ninguna de estas está disponible, el lanzamiento fallará y tendrás que establecer estas 3 entradas de configuración manualmente. Recuerda que las 2 primeras entradas de configuración son los búferes de comunicación: cuanto más grandes sean, más eficientes serán las comunicaciones, pero también más memoria de GPU consumirán, por lo que se trata de un compromiso de rendimiento ajustable.

Aspectos a tener en cuenta al usar el archivo de configuración de DeepSpeed

A continuación se muestra un script de ejemplo que utiliza deepspeed_config_file en diferentes escenarios.

Código test.py:

from accelerate import Accelerator
from accelerate.state import AcceleratorState


def main():
    accelerator = Accelerator()
    accelerator.print(f"{AcceleratorState()}")


if __name__ == "__main__":
    main()

Escenario 1: archivo de configuración de accelerate manipulado manualmente que contiene deepspeed_config_file junto con otras entradas.

  1. Contenido de la configuración de accelerate:
command_file: null
commands: null
compute_environment: LOCAL_MACHINE
deepspeed_config:
  gradient_accumulation_steps: 1
  gradient_clipping: 1.0
  offload_optimizer_device: 'cpu'
  offload_param_device: 'cpu'
  zero3_init_flag: true
  zero3_save_16bit_model: true
  zero_stage: 3
  deepspeed_config_file: 'ds_config.json'
distributed_type: DEEPSPEED
downcast_bf16: 'no'
dynamo_backend: 'NO'
fsdp_config: {}
gpu_ids: null
machine_rank: 0
main_process_ip: null
main_process_port: null
main_training_function: main
megatron_lm_config: {}
num_machines: 1
num_processes: 2
rdzv_backend: static
same_network: true
tpu_name: null
tpu_zone: null
use_cpu: false
  1. ds_config.json:
{
    "bf16": {
        "enabled": true
    },
    "zero_optimization": {
        "stage": 3,
        "stage3_gather_16bit_weights_on_model_save": false,
        "offload_optimizer": {
            "device": "none"
        },
        "offload_param": {
            "device": "none"
        }
    },
    "gradient_clipping": 1.0,
    "train_batch_size": "auto",
    "train_micro_batch_size_per_gpu": "auto",
    "gradient_accumulation_steps": 10,
    "steps_per_print": 2000000
}
  1. Salida de accelerate launch test.py:
ValueError: When using `deepspeed_config_file`, the following accelerate config variables will be ignored:
['gradient_accumulation_steps', 'gradient_clipping', 'zero_stage', 'offload_optimizer_device', 'offload_param_device',
'zero3_save_16bit_model', 'mixed_precision'].
Please specify them appropriately in the DeepSpeed config file.
If you are using an accelerate config file, remove other config variables mentioned in the above specified list.
The easiest method is to create a new config following the questionnaire via `accelerate config`.
It will only ask for the necessary config variables when using `deepspeed_config_file`.

Escenario 2: use la solución del error para crear una nueva configuración de accelerate y compruebe que ya no se lanza ningún error de ambigüedad.

  1. Ejecuta accelerate config:
$ accelerate config
-------------------------------------------------------------------------------------------------------------------------------
In which compute environment are you running?
This machine
-------------------------------------------------------------------------------------------------------------------------------
Which type of machine are you using?
multi-GPU
How many different machines will you use (use more than 1 for multi-node training)? [1]:
Do you wish to optimize your script with torch dynamo?[yes/NO]:
Do you want to use DeepSpeed? [yes/NO]: yes
Do you want to specify a json file to a DeepSpeed config? [yes/NO]: yes
Please enter the path to the json DeepSpeed config file: ds_config.json
Do you want to enable `deepspeed.zero.Init` when using ZeRO Stage-3 for constructing massive models? [yes/NO]: yes
How many GPU(s) should be used for distributed training? [1]:4
accelerate configuration saved at ds_config_sample.yaml
  1. Contenido de la configuración de accelerate:
compute_environment: LOCAL_MACHINE
deepspeed_config:
  deepspeed_config_file: ds_config.json
  zero3_init_flag: true
distributed_type: DEEPSPEED
downcast_bf16: 'no'
dynamo_backend: 'NO'
fsdp_config: {}
machine_rank: 0
main_training_function: main
megatron_lm_config: {}
num_machines: 1
num_processes: 4
rdzv_backend: static
same_network: true
use_cpu: false
  1. Salida de accelerate launch test.py:
Distributed environment: DEEPSPEED  Backend: nccl
Num processes: 4
Process index: 0
Local process index: 0
Device: cuda:0
Mixed precision type: bf16
ds_config: {'bf16': {'enabled': True}, 'zero_optimization': {'stage': 3, 'stage3_gather_16bit_weights_on_model_save': False, 'offload_optimizer': {'device': 'none'}, 'offload_param': {'device': 'none'}}, 'gradient_clipping': 1.0, 'train_batch_size': 'auto', 'train_micro_batch_size_per_gpu': 'auto', 'gradient_accumulation_steps': 10, 'steps_per_print': inf, 'fp16': {'enabled': False}}

Escenario 3: Establecer los argumentos del comando accelerate launch relacionados con DeepSpeed como "auto" en el archivo de configuración de DeepSpeed y verificar que todo funcione como se espera.

  1. Nuevo ds_config.json con "auto" para los argumentos de la línea de comandos de accelerate launch de DeepSpeed:
{
    "bf16": {
        "enabled": "auto"
    },
    "zero_optimization": {
        "stage": "auto",
        "stage3_gather_16bit_weights_on_model_save": "auto",
        "offload_optimizer": {
            "device": "auto"
        },
        "offload_param": {
            "device": "auto"
        }
    },
    "gradient_clipping": "auto",
    "train_batch_size": "auto",
    "train_micro_batch_size_per_gpu": "auto",
    "gradient_accumulation_steps": "auto",
    "steps_per_print": 2000000
}
  1. Salida de accelerate launch --mixed_precision="fp16" --zero_stage=3 --gradient_accumulation_steps=5 --gradient_clipping=1.0 --offload_param_device="cpu" --offload_optimizer_device="nvme" --zero3_save_16bit_model="true" test.py:
Distributed environment: DEEPSPEED  Backend: nccl
Num processes: 4
Process index: 0
Local process index: 0
Device: cuda:0
Mixed precision type: fp16
ds_config: {'bf16': {'enabled': False}, 'zero_optimization': {'stage': 3, 'stage3_gather_16bit_weights_on_model_save': True, 'offload_optimizer': {'device': 'nvme'}, 'offload_param': {'device': 'cpu'}}, 'gradient_clipping': 1.0, 'train_batch_size': 'auto', 'train_micro_batch_size_per_gpu': 'auto', 'gradient_accumulation_steps': 5, 'steps_per_print': inf, 'fp16': {'enabled': True, 'auto_cast': True}}

Nota:

  1. Los valores "auto" restantes se gestionan en la llamada a accelerator.prepare(), tal como se explica en el punto 2 de Important code changes when using DeepSpeed Config File.
  2. Solo cuando gradient_accumulation_steps es auto, se utilizará el valor pasado al crear el objeto Accelerator mediante Accelerator(gradient_accumulation_steps=k). Al usar DeepSpeed Plugin, se utilizará el valor de este y sobrescribirá el valor pasado al crear el objeto Accelerator.

Guardar y cargar

  1. El guardado y la carga de modelos no cambian para ZeRO Stage-1 y Stage-2.

  2. En ZeRO Stage-3, state_dict contiene solo los marcadores de posición, ya que los pesos del modelo se particionan entre varias GPU. ZeRO Stage-3 tiene 2 opciones:

    a. Guardar los pesos completos del modelo de 16 bits para cargarlos directamente más adelante usando model.load_state_dict(torch.load(pytorch_model.bin)). Para ello, establezca zero_optimization.stage3_gather_16bit_weights_on_model_save en True en el archivo de configuración de DeepSpeed o establezca zero3_save_16bit_model en True en el plugin de DeepSpeed. Tenga en cuenta que esta opción requiere la consolidación de los pesos en una sola GPU, por lo que puede ser lenta y consumir mucha memoria; úsela solo cuando sea necesario. A continuación se muestra un fragmento de examples/by_feature/deepspeed_with_config_support.py que ilustra esto:

    unwrapped_model = accelerator.unwrap_model(model)
    
    # New Code #
    # Saves the whole/unpartitioned fp16 model when in ZeRO Stage-3 to the output directory if
    # `stage3_gather_16bit_weights_on_model_save` is True in DeepSpeed Config file or
    # `zero3_save_16bit_model` is True in DeepSpeed Plugin.
    # For Zero Stages 1 and 2, models are saved as usual in the output directory.
    # The model name saved is `pytorch_model.bin`
    unwrapped_model.save_pretrained(
        args.output_dir,
        is_main_process=accelerator.is_main_process,
        save_function=accelerator.save,
        state_dict=accelerator.get_state_dict(model),
    )

    b. Para obtener pesos de 32 bits, primero guarde el modelo usando model.save_checkpoint(). A continuación se muestra el fragmento de examples/by_feature/deepspeed_with_config_support.py que muestra esto:

    success = model.save_checkpoint(PATH, ckpt_id, checkpoint_state_dict)
    status_msg = f"checkpointing: PATH={PATH}, ckpt_id={ckpt_id}"
    if success:
        logging.info(f"Success {status_msg}")
    else:
        logging.warning(f"Failure {status_msg}")

    Esto creará particiones del modelo y del optimizador ZeRO junto con el script zero_to_fp32.py en el directorio de checkpoint. Puede usar este script para realizar una consolidación fuera de línea. No requiere archivos de configuración ni GPUs. A continuación se muestra un ejemplo de su uso:

    $ cd /path/to/checkpoint_dir
    $ ./zero_to_fp32.py . pytorch_model.bin
    Processing zero checkpoint at global_step1
    Detected checkpoint of type zero stage 3, world_size: 2
    Saving fp32 state dict to pytorch_model.bin (total_numel=60506624)

    Para obtener un modelo de 32 bits para guardarlo o realizar inferencias, puedes ejecutar lo siguiente:

    from deepspeed.utils.zero_to_fp32 import load_state_dict_from_zero_checkpoint
    
    unwrapped_model = accelerator.unwrap_model(model)
    fp32_model = load_state_dict_from_zero_checkpoint(unwrapped_model, checkpoint_dir)

    Si solo te interesa el state_dict, puedes hacer lo siguiente:

    from deepspeed.utils.zero_to_fp32 import get_fp32_state_dict_from_zero_checkpoint
    
    state_dict = get_fp32_state_dict_from_zero_checkpoint(checkpoint_dir)

    Tenga en cuenta que todas estas funciones requieren ~2x de memoria (RAM general) del tamaño del punto de control final.

ZeRO Inference

DeepSpeed ZeRO Inference admite la etapa 3 de ZeRO con ZeRO-Infinity. Utiliza el mismo protocolo ZeRO que el entrenamiento, pero no emplea un optimizador ni un programador de tasa de aprendizaje, y solo la etapa 3 es relevante. Con la integración de accelerate, solo necesitas preparar el modelo y el dataloader como se muestra a continuación:

model, eval_dataloader = accelerator.prepare(model, eval_dataloader)

Algunas advertencias a tener en cuenta

  1. La integración actual no admite el paralelismo de pipeline de DeepSpeed.
  2. La integración actual no admite mpu, lo que limita el paralelismo de tensores que se admite en Megatron-LM.
  3. La integración actual no admite varios modelos.

Multi-nodo DeepSpeed

DeepSpeed admite la inferencia y el entrenamiento multinodo a través de una variedad de lanzadores diferentes. Puede especificar un lanzador diferente configurando deepspeed_multinode_launcher en la CLI o en el archivo de configuración de DeepSpeed.

Actualmente, accelerate admite pasar la configuración para los siguientes lanzadores multinodo de DeepSpeed: pdsh (predeterminado), standard, openmpi, mvapich, mpich, slurm, nossh (requiere DeepSpeed >= 0.14.5).

Lea la documentación de DeepSpeed para obtener más información sobre los distintos lanzadores. De forma predeterminada, DeepSpeed intentará usar SSH sin contraseña desde el nodo principal hacia los demás nodos para ejecutar el comando del lanzador. En esta configuración, el comando accelerate launch solo necesita ejecutarse en el nodo principal. Si utiliza el lanzador nossh, deberá ejecutar el comando accelerate launch en cada nodo usando una configuración copiada.

Recursos de DeepSpeed

La documentación sobre los aspectos internos relacionados con DeepSpeed se puede encontrar aquí.

Artículos:

Por último, recuerda que Accelerate solo integra DeepSpeed, por lo que si tienes algún problema o pregunta sobre el uso de DeepSpeed, abre un issue en DeepSpeed GitHub.

Para quienes estén interesados en las similitudes y diferencias entre FSDP y DeepSpeed, ¡consulten la guía de conceptos aquí!

Update on GitHub